public NmsConnection(IConnectionFactory connectionFactory, Apache.NMS.AcknowledgementMode acknowledgementMode, NmsCredentials credentials)
{
this.connection = (credentials == null)
? connectionFactory.CreateConnection()
: connectionFactory.CreateConnection(credentials.Username, credentials.Password);
this.acknowledgementMode = acknowledgementMode;
this.id = idCounter++;
this.WireUpEvents();
}
public ChannelFactory(RawRabbitConfiguration config, IConnectionFactory connectionFactory)
{
_connectionFactory = connectionFactory;
_accessDictionary = new ConcurrentDictionary<IModel, DateTime>();
_config = config;
_threadChannels = new ThreadLocal<IModel>(true);
try
{
_logger.LogDebug("Connecting to primary host.");
_connection = _connectionFactory.CreateConnection(_config.Hostnames);
_logger.LogInformation("Successfully established connection.");
}
catch (BrokerUnreachableException e)
{
_logger.LogError("Unable to connect to broker", e);
throw e.InnerException;
}
_closeTimer = new System.Threading.Timer(state =>
{
var enumerator = _accessDictionary.GetEnumerator();
while (enumerator.MoveNext())
{
if (DateTime.Now - enumerator.Current.Value > _config.RequestTimeout)
{
DateTime lastUsed;
if (_accessDictionary.TryRemove(enumerator.Current.Key, out lastUsed))
{
_logger.LogInformation($"Channel {enumerator.Current.Key.ChannelNumber} was last used {lastUsed}. Closing...");
enumerator.Current.Key.Close();
}
}
}
}, null, _config.RequestTimeout, _config.RequestTimeout);
}
private void CreateMocks()
{
mockConnectionFactory = (IConnectionFactory) mocks.CreateMock(typeof (IConnectionFactory));
mockConnection = (IConnection) mocks.CreateMock(typeof (IConnection));
mockSession = (ISession) mocks.CreateMock(typeof (ISession));
TIBCO.EMS.Queue queue = new TIBCO.EMS.Queue("test"); //(Queue) mocks.CreateMock(typeof (Queue));
Expect.Call(mockConnectionFactory.CreateConnection()).Return(mockConnection).Repeat.Once();
if (UseTransactedTemplate)
{
Expect.Call(mockConnection.CreateSession(true, Session.SESSION_TRANSACTED)).Return(mockSession).Repeat.
Once();
}
else
{
Expect.Call(mockConnection.CreateSession(false, Session.AUTO_ACKNOWLEDGE)).Return(mockSession).
Repeat.
Once();
}
Expect.Call(mockSession.Transacted).Return(true);
mockDestinationResolver =
(IDestinationResolver) mocks.CreateMock(typeof (IDestinationResolver));
mockDestinationResolver.ResolveDestinationName(mockSession, "testDestination", false);
LastCall.Return(queue).Repeat.Any();
}
public void SetUp()
{
connectionFactory = new ConnectionFactory("tcp://localhost:61616", GetType().Name);
connection = connectionFactory.CreateConnection();
connection.Start();
session = connection.CreateSession();
}
private void CreateMocks()
{
mockConnectionFactory = (IConnectionFactory) mocks.CreateMock(typeof (IConnectionFactory));
mockConnection = (IConnection) mocks.CreateMock(typeof (IConnection));
mockSession = (ISession) mocks.CreateMock(typeof (ISession));
IQueue queue = (IQueue) mocks.CreateMock(typeof (IQueue));
Expect.Call(mockConnectionFactory.CreateConnection()).Return(mockConnection).Repeat.Once();
if (UseTransactedTemplate)
{
Expect.Call(mockConnection.CreateSession(AcknowledgementMode.Transactional)).Return(mockSession).Repeat.
Once();
}
else
{
Expect.Call(mockConnection.CreateSession(AcknowledgementMode.AutoAcknowledge)).Return(mockSession).
Repeat.
Once();
}
Expect.Call(mockSession.Transacted).Return(true);
mockDestinationResolver =
(IDestinationResolver) mocks.CreateMock(typeof (IDestinationResolver));
mockDestinationResolver.ResolveDestinationName(mockSession, "testDestination", false);
LastCall.Return(queue).Repeat.Any();
}
public Queue(MsgDeliveryMode mode = MsgDeliveryMode.NonPersistent)
{
Uri msgQueue = new Uri("activemq:tcp://localhost:61616");
_factory = new ConnectionFactory(msgQueue);
try
{
_connection = _factory.CreateConnection();
}
catch (NMSConnectionException ex)
{
Log.FatalException("Error connecting to MQ server", ex);
throw;
}
// TODO check _connection for null
_connection.RequestTimeout = TimeSpan.FromSeconds(60);
Session = _connection.CreateSession();
// TODO need to find out if queue exists.
// It creates a new queue if it doesn't exist.
_destination = Session.GetDestination("queue://TwitterSearchStream");
_consumer = Session.CreateConsumer(_destination);
_producer = Session.CreateProducer(_destination);
_producer.RequestTimeout = TimeSpan.FromSeconds(60);
_producer.DeliveryMode = mode;
_connection.Start();
_connection.ExceptionListener += _connection_ExceptionListener;
_connection.ConnectionInterruptedListener += _connection_ConnectionInterruptedListener;
}
public MessageTransporter()
{
_connectionFactory = new Apache.NMS.Stomp.ConnectionFactory("tcp://0.0.0.0:61613");
_connection = _connectionFactory.CreateConnection();
_session = _connection.CreateSession();
_destination = SessionUtil.GetDestination(_session, "queue://testingQueue");
_messageProducer = _session.CreateProducer(_destination);
_messageConsumer = _session.CreateConsumer(_destination);
}
protected void TryCreateConnectionFactory(object stateInfo)
{
if (Connection != null) Connection.Dispose();
Connection = null;
if (stateInfo != null)
{
Log.Information("Retrying connection");
var autoEvent = (AutoResetEvent)stateInfo;
autoEvent.Set();
}
var tempHostNames = hostNames;
//hostNames.Shuffle();
foreach (var hostName in tempHostNames)
{
try
{
factory = new ConnectionFactory
{
HostName = hostName,
UserName = userName,
Password = password,
NetworkRecoveryInterval = TimeSpan.FromMilliseconds(timeout),
AutomaticRecoveryEnabled = automaticRecoveryEnabled,
RequestedHeartbeat = (ushort) heartbeat,
RequestedConnectionTimeout = 60000
};
Connection = factory.CreateConnection();
Log.Information(
"Connection heartbeat is configured to {0} seconds, and the connection has returned a value of {1} seconds",
heartbeat, Connection.Heartbeat);
Connection.ConnectionShutdown += connection_ConnectionShutdown;
WaitingToConnect = false;
break;
}
catch (SocketException se)
{
Log.Error(se, "RabbitMq: TryCreateConnectionFactory has an Error creating connection to host {0}",
hostName);
}
catch (BrokerUnreachableException be)
{
Log.Error(be, "RabbitMq: TryCreateConnectionFactory Cannot reach broker for host {0}", hostName);
}
catch (Exception ex)
{
Log.Error(ex, "RabbitMq: TryCreateConnectionFactory has an Error with {0} - {1}", hostName,
ex.Message);
}
finally
{
if (Connection != null) Connection.Close();
}
}
if (Connection == null) StartTryToConnect();
}
private void Connect()
{
factory = XmsUtilities.CreateConnectionFactory(destination);
connection = factory.CreateConnection();
connection.ExceptionListener += OnError;
session = connection.CreateSession(transactional, AcknowledgeMode.AutoAcknowledge);
queue = session.CreateQueue(destination.Queue);
queue.SetIntProperty(XMSC.DELIVERY_MODE, XMSC.DELIVERY_PERSISTENT);
producer = session.CreateProducer(queue);
}
/// <summary>
/// Configurate the Connection
/// </summary>
/// <param name="destination">Destionation</param>
private void Configure(string destination)
{
Destination dest = new Destination(destination);
Uri connectionUri = new Uri(dest.Host);
factory = new Apache.NMS.ActiveMQ.ConnectionFactory(connectionUri);
connection = factory.CreateConnection();
session = connection.CreateSession();
connection.Start();
this.destination = session.GetDestination(dest.Queue);
}
private void Configure(string destination)
{
Destination dest = new Destination(destination);
Uri connectionUri = new Uri(dest.Host);
_factory = new NMSConnectionFactory(connectionUri);
_connection = _factory.CreateConnection();
_session = _connection.CreateSession();
_connection.Start();
_destination = _session.GetDestination(dest.Queue);
}
public Master(IUserService service)
{
DownloadUsers = new DownloadUsers(service);
Factory = new NMSConnectionFactory("tcp://localhost:61616");
Connection = Factory.CreateConnection();
Connection.Start();
Session = Connection.CreateSession(AcknowledgementMode.AutoAcknowledge);
Destination = SessionUtil.GetDestination(Session, "Users");
Receiver = Session.CreateConsumer(Destination);
}
public void SetUp()
{
connectionFactory = new ConnectionFactory(BROKER, CLIENT_ID);
connection = connectionFactory.CreateConnection();
connection.Start();
session = connection.CreateSession();
subscriber = new TopicSubscriber(session, TOPIC_NAME);
subscriber.Start(CONSUMER_ID);
subscriber.OnMessageReceived +=
message => Console.WriteLine("Recieving message=>{0}", message);
}
public SingleNodeBroker(BrokerConfiguration config = null)
{
config = config ?? BrokerConfiguration.Local;
_factory = new ConnectionFactory
{
HostName = config.Hostname,
VirtualHost = config.VirtualHost,
Password = config.Password,
UserName = config.Username
};
_connection = _factory.CreateConnection();
}
public void Setup()
{
_endPoint = new DnsEndPoint("localhost", 27017);
_connection = new MockConnection();
_connectionFactory = Substitute.For<IConnectionFactory>();
_connectionFactory.CreateConnection(null, null)
.ReturnsForAnyArgs(_connection);
_capturedEvents = new EventCapturer();
_serverId = new ServerId(new ClusterId(), _endPoint);
_subject = new ServerMonitor(_serverId, _endPoint, _connectionFactory, Timeout.InfiniteTimeSpan, Timeout.InfiniteTimeSpan, _capturedEvents);
}
public void Connect()
{
log.Debug("New physical producer created. About to connect.");
factory = XmsUtilities.CreateConnectionFactory(address);
connection = factory.CreateConnection();
connection.ExceptionListener += OnError;
session = connection.CreateSession(transactional, AcknowledgeMode.AutoAcknowledge);
queue = session.CreateQueue(address.Queue);
queue.SetIntProperty(XMSC.DELIVERY_MODE, XMSC.DELIVERY_PERSISTENT);
producer = session.CreateProducer(queue);
connected = true;
log.Debug("New physical producer successfully connected.");
}
public void Connect()
{
factory = XmsUtilities.CreateConnectionFactory(address);
connection = factory.CreateConnection();
connection.ExceptionListener += OnError;
session = connection.CreateSession(transactional, AcknowledgeMode.AutoAcknowledge);
queue = session.CreateQueue(address.Queue);
queue.SetIntProperty(XMSC.DELIVERY_MODE,
transactional ? XMSC.DELIVERY_PERSISTENT : XMSC.DELIVERY_NOT_PERSISTENT);
consumer = session.CreateConsumer(queue);
connection.Start();
connected = true;
}
public Stomp(bool durable)
{
_connectionFactory = new ConnectionFactory("tcp://localhost:61613");
_connection = _connectionFactory.CreateConnection();
_connection.ClientId = "13AC0CF8-65FE-4638-8B85-62210DD89BEE";
_connection.Start();
_session = _connection.CreateSession();
var topic = _session.GetQueue("exampleQueue");
_producer = _session.CreateProducer(topic);
_producer.DeliveryMode = durable ? MsgDeliveryMode.Persistent : MsgDeliveryMode.NonPersistent;
_consumer = _session.CreateConsumer(topic);
}
public void Setup()
{
connectionFactory = new ConnectionFactory(BROKER, CLIENT_ID);
connection = connectionFactory.CreateConnection();
connection.Start();
session = connection.CreateSession();
for (int i = 0; i < 100; i++)
{
var receiver = new QueueReceiver(session, QUEUE_NAME);
receiver.OnMessageRecieved += (message => Console.WriteLine(message));
receiver.Start(String.Format("Receiver#{0}", i));
receivers.Add(receiver);
}
}
public ManagedConnection(Uri uri)
{
if (uri == null) throw new ArgumentNullException("uri");
var managedConnectionIdBuilder = new UriBuilder(uri)
{
// Sanitize credentials
UserName = "",
Password = ""
};
_managedConnectionId = managedConnectionIdBuilder.Uri.ToString();
_connectionFactory = new ConnectionFactory {Uri = uri.ToString()};
Log.InfoFormat("Establishing managed connection to {0}...", _managedConnectionId);
_connection = _connectionFactory.CreateConnection();
}
public ChannelFactory(RawRabbitConfiguration config, IConnectionFactory connectionFactory)
{
_connectionFactory = connectionFactory;
_config = config;
_threadChannels = new ThreadLocal<IModel>(true);
try
{
_logger.LogDebug("Connecting to primary host.");
_connection = _connectionFactory.CreateConnection(_config.Hostnames);
_logger.LogInformation("Successfully established connection.");
}
catch (BrokerUnreachableException e)
{
_logger.LogError("Unable to connect to broker", e);
throw e.InnerException;
}
}
public ChannelFactory(IConnectionFactory connectionFactory, RawRabbitConfiguration config, ChannelFactoryConfiguration channelConfig)
{
try
{
_connection = connectionFactory.CreateConnection(config.Hostnames);
}
catch (BrokerUnreachableException e)
{
_logger.LogError("Unable to connect to broker", e);
throw e.InnerException;
}
_connectionFactory = connectionFactory;
_config = config;
_channelConfig = channelConfig;
_requestQueue = new ConcurrentQueue<TaskCompletionSource<IModel>>();
_channels = new LinkedList<IModel>();
Initialize();
}
public void InitForm()
{
try
{
factory = new ConnectionFactory(connectUri);
connection = factory.CreateConnection("sempra.ops.gs.service", "sempra");
connection.ExceptionListener += new ExceptionListener(OnException);
connection.Start();
session = connection.CreateSession();
//destination = SessionUtil.GetDestination(session, "topic://sempra.ops.opsTracking.summary.update" + MAX_INACTIVITY_DURATION);
//This is the process that registers the subscriber on the server
//consumer = session.CreateConsumer(destination);
////////////////////////////////////////
//producer = session.CreateProducer(destination);
//consumer.Listener += new MessageListener(OnMessage);
topicSubscriber = new TopicSubscriber(session, TOPIC_NAME);
topicSubscriber.OnMessageReceived += new MessageListener(OnMessage);
topicSubscriber.Start(CONSUMER_ID);
////////////////////////////////////////
//_connectionFactory = new ConnectionFactory(_connectUri, CLIENT_ID);
//_connection = _connectionFactory.CreateConnection(Properties.Settings.Default.MessageServerUserId, Properties.Settings.Default.MessageServerPassword);
//_connection.ExceptionListener += new ExceptionListener(OnException);
//_connection.Start();
//_session = _connection.CreateSession();
//_session = _connection.CreateSession(AcknowledgementMode.AutoAcknowledge);
//_topicSubscriber = new TopicSubscriber(_session, TOPIC_NAME);
//_topicSubscriber.Start(CONSUMER_ID);
//_topicSubscriber.OnMessageReceived += new MessageListener(OnMessage);
}
catch (Exception error)
{
MessageBox.Show("Error:" + error.Message);
}
}
public void Setup()
{
_clusterId = new ClusterId();
_clusterConnectionMode = ClusterConnectionMode.Standalone;
_connectionPool = Substitute.For<IConnectionPool>();
_connectionPoolFactory = Substitute.For<IConnectionPoolFactory>();
_connectionPoolFactory.CreateConnectionPool(null, null)
.ReturnsForAnyArgs(_connectionPool);
_endPoint = new DnsEndPoint("localhost", 27017);
_heartbeatConnection = new MockConnection();
_heartbeatConnectionFactory = Substitute.For<IConnectionFactory>();
_heartbeatConnectionFactory.CreateConnection(null, null)
.ReturnsForAnyArgs(_heartbeatConnection);
_capturedEvents = new EventCapturer();
_settings = new ServerSettings(heartbeatInterval: Timeout.InfiniteTimeSpan);
_subject = new ClusterableServer(_clusterId, _clusterConnectionMode, _settings, _endPoint, _connectionPoolFactory, _heartbeatConnectionFactory, _capturedEvents);
}
public Search(IEnumerable<string> searchFilter)
{
// TODO app setting
Uri msgQueue = new Uri("activemq:tcp://localhost:61616");
_factory = new ConnectionFactory(msgQueue);
try
{
_connection = _factory.CreateConnection();
}
catch (NMSConnectionException ex)
{
Log.FatalException("Error connecting to MQ server", ex);
throw;
}
// TODO handle -- throws connectionclosedexception
_session = _connection.CreateSession();
// TODO app setting
_destination = _session.GetDestination("queue://TwitterSearchStream");
_producer = _session.CreateProducer(_destination);
_connection.Start();
_producer.DeliveryMode = MsgDeliveryMode.NonPersistent;
_producer.RequestTimeout = TimeSpan.FromSeconds(60);
// TODO app setting -- Put your username/password here
searchStream = new SearchStream(uri, "username", "password");
searchStream.StatusReceived += new EventHandler<StreamEvent>(searchStream_StatusReceived);
var searchTerms = new Dictionary<string, string>();
searchTerms.Add("track", string.Join(",", searchFilter.Select(HttpUtility.UrlEncode)));
searchStream.StartStream(searchTerms);
while (true)
{
Thread.Sleep(1000);
}
}
public void RegisteredErrorHandlerIsInvokedOnException()
{
SimpleMessageConsumer messageConsumer = new SimpleMessageConsumer();
ISession session = A.Fake <ISession>();
A.CallTo((() => session.GetQueue(DESTINATION_NAME))).Returns(QUEUE_DESTINATION);
A.CallTo((() => session.CreateConsumer(QUEUE_DESTINATION, null))).Returns(messageConsumer);
// an exception is thrown, so the rollback logic is being applied here...
A.CallTo((() => session.Transacted)).Returns(false);
IConnection connection = A.Fake <IConnection>();
connection.ExceptionListener += container.OnException;
A.CallTo((() => connection.CreateSession(container.SessionAcknowledgeMode))).Returns(session);
connection.Start();
IConnectionFactory connectionFactory = A.Fake <IConnectionFactory>();
A.CallTo((() => connectionFactory.CreateConnection())).Returns(connection);
IllegalStateException theException = new IllegalStateException(EXCEPTION_MESSAGE);
IErrorHandler errorHandler = A.Fake <IErrorHandler>();
errorHandler.HandleError(theException);
IMessage message = A.Fake <IMessage>();
container.ConnectionFactory = connectionFactory;
container.DestinationName = DESTINATION_NAME;
container.MessageListener = new BadSessionAwareMessageListener(theException);
container.ErrorHandler = errorHandler;
container.AfterPropertiesSet();
// manually trigger an Exception with the above bad MessageListener...
messageConsumer.SendMessage(message);
}
private IAutorecoveringConnection Connect()
{
var endpoints = configuration.Hosts.Select(x =>
{
var endpoint = new AmqpTcpEndpoint(x.Host, x.Port);
if (x.Ssl.Enabled)
{
endpoint.Ssl = x.Ssl;
}
else if (configuration.Ssl.Enabled)
{
endpoint.Ssl = configuration.Ssl;
}
return(endpoint);
}).ToArray();
var connection = connectionFactory.CreateConnection(endpoints) as IAutorecoveringConnection;
if (connection == null)
{
throw new NotSupportedException("Non-recoverable connection is not supported");
}
connection.ConnectionShutdown += OnConnectionShutdown;
connection.ConnectionBlocked += OnConnectionBlocked;
connection.ConnectionUnblocked += OnConnectionUnblocked;
connection.RecoverySucceeded += OnConnectionRecovered;
logger.InfoFormat(
"Connected to broker {broker}, port {port}",
connection.Endpoint.HostName,
connection.Endpoint.Port
);
eventBus.Publish(new ConnectionCreatedEvent(connection.Endpoint));
return(connection);
}
private void Connect()
{
if (connection == null || !connection.IsOpen)
{
lock (syncLock)
{
if (connection == null || !connection.IsOpen)
{
if (connection != null)
{
try
{
// when the broker connection is lost
// and ShutdownReport.Count > 0 RabbitMQ.Client
// throw an exception, but before the IConnection.Abort()
// is invoked
// https://github.com/rabbitmq/rabbitmq-dotnet-client/blob/ea913903602ba03841f2515c23f843304211cd9e/projects/client/RabbitMQ.Client/src/client/impl/Connection.cs#L1070
connection.Dispose();
}
catch
{
if (connection.CloseReason != null)
{
this.logger.InfoWrite("Connection '{0}' has shutdown. Reason: '{1}'",
connection, connection.CloseReason.Cause);
}
else
{
throw;
}
}
}
connection = connectionFactory.CreateConnection();
}
}
}
}
public static void rabbitmq(IConnectionFactory connFactory)
{
Console.WriteLine("Start!");
using (IConnection conn = connFactory.CreateConnection())
{
using (IModel channel = conn.CreateModel())
{
//String queueName = String.Empty;
string queueName = "queue1";
//声明一个队列
channel.QueueDeclare(
queue: queueName, ////消息队列名称
durable: false, //是否缓存
exclusive: false,
autoDelete: false,
arguments: null
);
//告诉Rabbit每次只能向消费者发送一条信息,再消费者未确认之前,不再向他发送信息
channel.BasicQos(0, 1, false);
//创建消费者对象
var consumer = new EventingBasicConsumer(channel);
consumer.Received += (model, ea) =>
{
Thread.Sleep(2000);
byte[] message = ea.Body;//接收的消息
Console.WriteLine("接收到的消息为：" + Encoding.UTF8.GetString(message));
//返回消息确认
channel.BasicAck(ea.DeliveryTag, true);
};
//消费者开启监听
//将autoAck设置false 关闭自动确认
channel.BasicConsume(queue: queueName, autoAck: false, consumer: consumer);
Console.ReadKey();
}
}
}
public static void CreateQueue(this IConnectionFactory connectionFactory, string queue)
{
using (var conn = connectionFactory.CreateConnection())
using (var model = conn.CreateModel())
{
try
{
model.QueueDeclarePassive(queue);
}
catch (Exception e)
{
// Queue does not exist, create it
GetOpenedModelIfClosed(conn, model)
.QueueDeclare(queue, true, false, false, HighAvaiableQueueArguments);
}
finally
{
// Declare with routing bindings
try
{
model.ExchangeDeclarePassive(queue);
model.ExchangeDeclarePassive(DeclareWithRebusDirectExchangeType);
}
catch (Exception e)
{
var newModel = GetOpenedModelIfClosed(conn, model);
newModel.ExchangeDeclare(queue, DirectExchangeType, true);
newModel.ExchangeDeclare(DeclareWithRebusDirectExchangeType, DirectExchangeType, true);
}
finally
{
var newModel = GetOpenedModelIfClosed(conn, model);
newModel.QueueBind(queue, queue, queue, null);
newModel.QueueBind(queue, DeclareWithRebusDirectExchangeType, queue, null);
}
}
}
}
public bool TryConnect()
{
Logger.LogInformation("Tentando conectar ao RabbitMQ");
lock (sync_root)
{
var policy = RetryPolicy.Handle <SocketException>()
.Or <BrokerUnreachableException>()
.WaitAndRetry(RetryCount, retryAttempt => TimeSpan.FromSeconds(Math.Pow(2, retryAttempt)), (ex, time) =>
{
Logger.LogWarning(ex, "Não foi possível conectar ao RabbitMQ após {TimeOut}s ({ExceptionMessage})", $"{time.TotalSeconds:n1}", ex.Message);
}
);
policy.Execute(() =>
{
Connection = ConnectionFactory
.CreateConnection();
});
if (IsConnected)
{
Connection.ConnectionShutdown += OnConnectionShutdown;
Connection.CallbackException += OnCallbackException;
Connection.ConnectionBlocked += OnConnectionBlocked;
Logger.LogInformation("Client RabbitMQ estabeleceu conexão com '{HostName}'", Connection.Endpoint.HostName);
return(true);
}
else
{
Logger.LogCritical("ERRO FATAL: Não foi possível conectar ao RabbitMQ");
return(false);
}
}
}
public bool TryConnect()
{
_logger.LogInformation("O RabbitMQ Client está tentando se conectar");
lock (sync_root)
{
var policy = RetryPolicy.Handle <SocketException>()
.Or <BrokerUnreachableException>()
.WaitAndRetry(_retryCount, retryAttempt => TimeSpan.FromSeconds(Math.Pow(2, retryAttempt)), (ex, time) =>
{
_logger.LogWarning(ex, "O RabbitMQ Client não pôde se conectar após {TimeOut}s ({ExceptionMessage})", $"{time.TotalSeconds:n1}", ex.Message);
}
);
policy.Execute(() =>
{
_connection = _connectionFactory
.CreateConnection();
});
if (IsConnected)
{
_connection.ConnectionShutdown += OnConnectionShutdown;
_connection.CallbackException += OnCallbackException;
_connection.ConnectionBlocked += OnConnectionBlocked;
_logger.LogInformation("O RabbitMQ Client adquiriu uma conexão persistente com '{HostName}' e está inscrito em eventos de falha", _connection.Endpoint.HostName);
return(true);
}
else
{
_logger.LogCritical("FATAL ERROR: RabbitMQ conexões não puderam ser criadas e abertas");
return(false);
}
}
}
public bool TryConnect()
{
//_logger.LogInformation("RabbitMQ Client is trying to connect");
lock (sync_root)
{
var policy = RetryPolicy.Handle <SocketException>()
.Or <BrokerUnreachableException>()
.WaitAndRetry(_retryCount, retryAttempt => TimeSpan.FromSeconds(Math.Pow(2, retryAttempt)), (ex, time) =>
{
//_logger.LogWarning(ex.ToString());
}
);
policy.Execute(() =>
{
_connection = _connectionFactory
.CreateConnection();
});
if (IsConnected)
{
_connection.ConnectionShutdown += OnConnectionShutdown;
_connection.CallbackException += OnCallbackException;
_connection.ConnectionBlocked += OnConnectionBlocked;
//_logger.LogInformation($"RabbitMQ persistent connection acquired a connection {_connection.Endpoint.HostName} and is subscribed to failure events");
return(true);
}
else
{
//_logger.LogCritical("FATAL ERROR: RabbitMQ connections could not be created and opened");
return(false);
}
}
}
public bool TryConnect()
{
_logger.Info("TryConnect", "DefaultRabbitMQPersistentConnection", "RabbitMQ Client is trying to connect");
lock (sync_root)
{
var policy = RetryPolicy.Handle <SocketException>()
.Or <BrokerUnreachableException>()
.WaitAndRetry(_timeSpans, (ex, time) =>
{
_logger.Warn("TryConnect/WaitAndRetry", "DefaultRabbitMQPersistentConnection", ex.ToString());
}
);
policy.Execute(() =>
{
_connection = _connectionFactory
.CreateConnection();
});
if (IsConnected)
{
_connection.ConnectionShutdown += OnConnectionShutdown;
_connection.CallbackException += OnCallbackException;
_connection.ConnectionBlocked += OnConnectionBlocked;
_logger.Info("TryConnect", "DefaultRabbitMQPersistentConnection", $"RabbitMQ persistent connection acquired a connection {_connection.Endpoint.HostName} and is subscribed to failure events");
return(true);
}
else
{
_logger.Fatal("TryConnect", "DefaultRabbitMQPersistentConnection", "FATAL ERROR: RabbitMQ connections could not be created and opened");
return(false);
}
}
}
public bool TryConnect()
{
_logger.LogInformation("RabbitMQ Client tentando conexão...");
lock (sync_root)
{
var policy = RetryPolicy.Handle <SocketException>()
.Or <BrokerUnreachableException>()
.WaitAndRetry(_retryCount, retryAttempt => TimeSpan.FromSeconds(Math.Pow(2, retryAttempt)), (ex, time) =>
{
_logger.LogWarning(ex, "RabbitMQ Client could not connect after {TimeOut}s ({ExceptionMessage})", $"{time.TotalSeconds:n1}", ex.Message);
}
);
policy.Execute(() =>
{
_connection = _connectionFactory
.CreateConnection();
});
if (IsConnected)
{
_connection.ConnectionShutdown += OnConnectionShutdown;
_connection.CallbackException += OnCallbackException;
_connection.ConnectionBlocked += OnConnectionBlocked;
_logger.LogInformation("RabbitMQ Client acquired a persistent connection to '{HostName}' and is subscribed to failure events", _connection.Endpoint.HostName);
return(true);
}
else
{
_logger.LogCritical("FATAL ERROR: RabbitMQ connections could not be created and opened");
return(false);
}
}
}
public bool TryConnect()
{
lock (syncRoot)
{
RetryPolicy policy = Policy
.Handle <SocketException>()
.Or <BrokerUnreachableException>()
.WaitAndRetry(_retryCount, retryAttempt => TimeSpan.FromSeconds(Math.Pow(2, retryAttempt)));
policy.Execute(() =>
{
_connection = _connectionFactory.CreateConnection();
});
if (!IsConnected)
{
return(false);
}
_connection.ConnectionShutdown += (o, e) => { if (!_disposed)
{
TryConnect();
}
};
_connection.CallbackException += (o, e) => { if (!_disposed)
{
TryConnect();
}
};
_connection.ConnectionBlocked += (o, e) => { if (!_disposed)
{
TryConnect();
}
};
return(true);
}
}
private void TryConnect()
{
Task.Factory.StartNew(() =>
{
while (!_cts.IsCancellationRequested)
{
if (!_isConnect)
{
_logger.Info("开始连接指令队列服务器![{0}-{1}]".GetFormat(_name, _uri));
try
{
_factory = new ConnectionFactory(_uri);
_connection = _factory.CreateConnection();
_connection.ConnectionInterruptedListener += () =>
{
_logger.Error("与指令队列服务器断开连接![{0}-{1}]".GetFormat(_name, _uri));
_isConnect = false;
};
_connection.ClientId = _clientId;
_connection.Start();
_session = _connection.CreateSession();
_consumer = _session.CreateDurableConsumer(new ActiveMQTopic(_name), _connection.ClientId, null, false);
_consumer.Listener += OnReceived;
_isConnect = true;
_logger.Info("连接指令队列服务器成功![{0}-{1}]".GetFormat(_name, _uri));
}
catch (Exception ex)
{
_logger.Error("连接指令队列服务器失败![{0}-{1}]".GetFormat(_name, _uri), ex);
_isConnect = false;
}
}
Thread.Sleep(10 * 1000);
}
}, _cts.Token);
}
public void Setup()
{
XMSFactoryFactory xff = XMSFactoryFactory.GetInstance(XMSC.CT_WMQ);
IConnectionFactory cf = xff.CreateConnectionFactory();
cf.SetStringProperty(XMSC.WMQ_HOST_NAME, "10.87.188.156(7111)");
cf.SetIntProperty(XMSC.WMQ_PORT, 7111);
cf.SetStringProperty(XMSC.WMQ_CHANNEL, "QMEIGS1.CRM.SVRCONN");
cf.SetIntProperty(XMSC.WMQ_CONNECTION_MODE, XMSC.WMQ_CM_CLIENT);
cf.SetStringProperty(XMSC.WMQ_QUEUE_MANAGER, "QMEIGS1");
cf.SetIntProperty(XMSC.WMQ_BROKER_VERSION, XMSC.WMQ_BROKER_V1);
IConnection conn = cf.CreateConnection();
Console.WriteLine("connection created");
ISession sess = conn.CreateSession(false, AcknowledgeMode.AutoAcknowledge);
IDestination dest = sess.CreateQueue("DOX.APYMT.ESB.SSK.RPO.02");
IMessageConsumer consumer = sess.CreateConsumer(dest);
MessageListener ml = new MessageListener(OnMessage);
consumer.MessageListener = ml;
conn.Start();
Console.WriteLine("Consumer started");
}
private void jmsInitial()
{
try
{
//Console.WriteLine("url:" + serverinfo.Url + ";" + serverinfo.QueueName);
_factory = new ConnectionFactory(this._serverinfo.Url);
//_factory.UseCompression = true;
_connection = _factory.CreateConnection();
_session = _connection.CreateSession(AcknowledgementMode.DupsOkAcknowledge);
_producer = _session.CreateProducer(
new Apache.NMS.ActiveMQ.Commands.ActiveMQQueue(this._serverinfo.QueueName));
_tagsBuilder = new XtiveTags.Builder();
Thread thread = new Thread(new ThreadStart(checkTags));
thread.IsBackground = true;
thread.Start();
}
catch (Exception msg)
{
//出错信息
log.Error(msg.Message);
}
}
public RabbitMessageBus(IConnectionFactory connectionFactory,
IMessageSerializer messageSerializer,
IMessageHandlerExecutionContext messageHandlerExecutionContext,
string exchangeName,
string exchangeType = ExchangeType.Fanout,
string queueName = null,
bool autoAck = false)
: base(messageSerializer, messageHandlerExecutionContext)
{
// Initializes the local variables
this.connectionFactory = connectionFactory;
this.connection = connectionFactory.CreateConnection();
this.channel = connection.CreateModel();
this.exchangeType = exchangeType;
this.exchangeName = exchangeName;
this.autoAck = autoAck;
// Declares the exchange
this.channel.ExchangeDeclare(this.exchangeName, this.exchangeType);
// Initializes the consumer of the message queue
this.queueName = this.InitializeMessageConsumer(queueName);
}
private void CreateMocks()
{
mockConnectionFactory = A.Fake <IConnectionFactory>();
mockConnection = A.Fake <IConnection>();
mockSession = A.Fake <ISession>();
IQueue queue = A.Fake <IQueue>();
A.CallTo(() => mockConnectionFactory.CreateConnection()).Returns(mockConnection).Once();
if (UseTransactedTemplate)
{
A.CallTo(() => mockConnection.CreateSession(AcknowledgementMode.Transactional)).Returns(mockSession).Once();
}
else
{
A.CallTo(() => mockConnection.CreateSession(AcknowledgementMode.AutoAcknowledge)).Returns(mockSession).Once();
}
A.CallTo(() => mockSession.Transacted).Returns(true);
mockDestinationResolver = A.Fake <IDestinationResolver>();
A.CallTo(() => mockDestinationResolver.ResolveDestinationName(mockSession, "testDestination", false)).Returns(queue);
}
public bool TryConnect()
{
lock (sync_root)
{
connection = connectionFactory.CreateConnection();
if (IsConnected)
{
connection.ConnectionShutdown += OnConnectionShutdown;
connection.ConnectionBlocked += OnConnectionBlocked;
connection.CallbackException += OnCallbackException;
logger.LogInformation("RabbitMQ connect to {HostName}", connection.Endpoint.HostName);
return(true);
}
else
{
logger.LogCritical("RabbitMQ connection can not open");
return(false);
}
}
}
public Task <HealthCheckResult> CheckHealthAsync(HealthCheckContext context, CancellationToken cancellationToken = default)
{
try
{
// If no factory was provided then we're stuck using the passed in connection
// regardless of the state it may be in. We don't have a way to attempt to
// create a new connection :(
if (_connectionFactory == null)
{
return(TestConnection(_rmqConnection));
}
using (var connection = _connectionFactory.CreateConnection())
{
return(TestConnection(connection));
}
}
catch (Exception ex)
{
return(Task.FromResult(
new HealthCheckResult(context.Registration.FailureStatus, exception: ex)));
}
}
public void ListenMasterLocalFilesRequests()
{
_xffReadFactory = XMSFactoryFactory.GetInstance(XMSC.CT_WMQ);
_connectionFactory = _xffReadFactory.CreateConnectionFactory();
_connectionFactory.SetStringProperty(XMSC.WMQ_HOST_NAME, LMApplicationConfigurationdetails.RequestConnection);
_connectionFactory.SetIntProperty(XMSC.WMQ_PORT, LMApplicationConfigurationdetails.RequestPort);
_connectionFactory.SetStringProperty(XMSC.WMQ_CHANNEL, LMApplicationConfigurationdetails.RequestChannel);
_connectionFactory.SetIntProperty(XMSC.WMQ_CONNECTION_MODE, XMSC.WMQ_CM_CLIENT);
_connectionFactory.SetStringProperty(XMSC.WMQ_QUEUE_MANAGER, LMApplicationConfigurationdetails.RequestManger);
_connectionFactory.SetIntProperty(XMSC.WMQ_BROKER_VERSION, XMSC.WMQ_BROKER_V1);
_connectionFactory.SetStringProperty(XMSC.WMQ_PROVIDER_VERSION, MQConfigurationSettings.WMQ_PROVIDER_VERSION);
_mqConnection = _connectionFactory.CreateConnection();
_newSesstion = _mqConnection.CreateSession(false, AcknowledgeMode.AutoAcknowledge);
_mqDestination =
_newSesstion.CreateQueue(string.Format("queue://{0}/{1}",
LMApplicationConfigurationdetails.RequestManger, LMApplicationConfigurationdetails.RequestQueueName));
_mqMessageConsumer = _newSesstion.CreateConsumer(_mqDestination);
MessageListener ml = OnFilesReceived;
_mqMessageConsumer.MessageListener = ml;
_mqConnection.Start();
//Thread.Sleep(int.MaxValue);
}
public bool TryConnect()
{
var policy = Policy.Handle <BrokerUnreachableException>()
.Or <SocketException>()
.WaitAndRetry(3, retryAttempt => TimeSpan.FromSeconds(Math.Pow(2, retryAttempt)), (ex, time) =>
{
_logger.LogError(ex, "Unable to connect RabbitMq");
});
policy.Execute(() =>
{
Connection = _connectionFactory.CreateConnection(ConnectionProviderName);
if (IsConnected)
{
Connection.ConnectionShutdown += OnConnectionShutdown;
Connection.CallbackException += OnCallbackException;
Connection.ConnectionBlocked += OnConnectionBlocked;
_logger.LogWarning($"RabbitMQ persistent connection acquired a connection {Connection.Endpoint.HostName} and is subscribed to failure events");
}
});
return(true);
}
public void TestDestinations(
[Values("queue://ZMQTestQueue", "topic://ZMQTestTopic", "temp-queue://ZMQTempQueue", "temp-topic://ZMQTempTopic")]
string destination,
[Values(typeof(Queue), typeof(Topic), typeof(TemporaryQueue), typeof(TemporaryTopic))]
Type destinationType)
{
IConnectionFactory factory = NMSConnectionFactory.CreateConnectionFactory(new Uri("zmq:tcp://localhost:5556"));
Assert.IsNotNull(factory, "Error creating connection factory.");
using (IConnection connection = factory.CreateConnection())
{
Assert.IsNotNull(connection, "Problem creating connection class. Usually problem with libzmq and clrzmq ");
using (ISession session = connection.CreateSession())
{
Assert.IsNotNull(session, "Error creating session.");
using (IDestination testDestination = session.GetDestination(destination))
{
Assert.IsNotNull(testDestination, "Error creating test destination: {0}", destination);
Assert.IsInstanceOf(destinationType, testDestination, "Wrong destintation type.");
}
}
}
}
public void Setup()
{
XMSFactoryFactory xff = XMSFactoryFactory.GetInstance(XMSC.CT_WMQ);
IConnectionFactory cf = xff.CreateConnectionFactory();
cf.SetStringProperty(XMSC.WMQ_HOST_NAME, "localhost");
cf.SetIntProperty(XMSC.WMQ_PORT, 1414);
cf.SetStringProperty(XMSC.WMQ_CHANNEL, "CLIENT");
cf.SetIntProperty(XMSC.WMQ_CONNECTION_MODE, XMSC.WMQ_CM_CLIENT);
cf.SetStringProperty(XMSC.WMQ_QUEUE_MANAGER, "QM_LOCAL");
cf.SetIntProperty(XMSC.WMQ_BROKER_VERSION, XMSC.WMQ_BROKER_V1);
IConnection conn = cf.CreateConnection();
Console.WriteLine("connection created");
ISession sess = conn.CreateSession(false, AcknowledgeMode.AutoAcknowledge);
IDestination dest = sess.CreateQueue("queue://q");
IMessageConsumer consumer = sess.CreateConsumer(dest);
MessageListener ml = new MessageListener(OnMessage);
consumer.MessageListener = ml;
conn.Start();
Console.WriteLine("Consumer started");
}
void AMQStart()
{
//GlobalAMQSettings global_AMQ_settings = FindObjectOfType<GlobalAMQSettings>();
//string address = global_AMQ_settings.GetComponent<GlobalAMQSettings>().address;
//int port = global_AMQ_settings.GetComponent<GlobalAMQSettings>().port;
try {
factory = new NMSConnectionFactory(URI);
//connection = factory.CreateConnection("admin", "admin");
connection = factory.CreateConnection();
Debug.Log("AMQ connecting to "+URI);
session = connection.CreateSession();
networkOpen = true;
connection.Start();
} catch (System.Exception e) {
Debug.LogWarning("AMQ Start Exception " + e);
}
amqWriterThread = new Thread(new ThreadStart(AMQWriter));
amqWriterThread.Start();
amqReaderThread = new Thread(new ThreadStart(AMQReader));
amqReaderThread.Start();
}
public void Send(string message, string queueName)
{
try
{
var messageBytes = Encoding.UTF8.GetBytes(message);
using (var connection = _connectionFactory.CreateConnection())
using (var channel = connection.CreateModel())
{
channel.QueueDeclare(queue: queueName, exclusive: false);
channel.BasicPublish(exchange: "",
routingKey: queueName,
body: messageBytes);
_logger.LogDebug($"Sent {message} on {queueName}");
}
}
catch (Exception exception)
{
_logger.LogError(exception, "Error in Send");
throw;
}
}
public RabbitMQEventBus(IEventHandlerExecutionContext _eventHandlerExecutionContext,
ILogger <RabbitMQEventBus> _logger,
IConnectionFactory _connectionFactory,
string _exchangeName,
string _exchangeType = ExchangeType.Fanout,
string _queueName = null,
bool _autoAck = false
)
: base(_eventHandlerExecutionContext)
{
connectionFactory = _connectionFactory;
logger = _logger;
connection = connectionFactory.CreateConnection();
channel = connection.CreateModel();
exchangeType = _exchangeType;
exchangeName = _exchangeName;
autoAck = _autoAck;
channel.ExchangeDeclare(exchangeName, exchangeType);
queueName = InitializeEventConsumer(_queueName);
logger.LogInformation($"RabbitMQEventBus 构造函数调用完成* Hash Code:{this.GetHashCode()}.");
}
public void PublishMessage <T>(T message, string queueName) where T : class
{
var connection = _connectionFactory.CreateConnection();
var channel = connection.CreateModel();
channel.QueueDeclare(queue: queueName,
durable: true,
exclusive: false,
autoDelete: false,
arguments: null);
var body = Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(message));
var properties = channel.CreateBasicProperties();
properties.Persistent = true;
channel.BasicPublish(exchange: "",
routingKey: queueName,
basicProperties: properties,
body: body);
}
public static IConnection CreateConnection(
this IConnectionFactory factory,
TimeSpan timeout
)
{
var connection = null as IConnection;
var connectedOrTimedOutEvent = new AutoResetEvent(false);
Task.Delay(timeout)
.ContinueWith(task => connectedOrTimedOutEvent.Set());
Task.Run(() =>
{
connection = factory.CreateConnection();
if (!connection.IsOpen)
{
connection = null;
}
connectedOrTimedOutEvent.Set();
});
connectedOrTimedOutEvent.WaitOne();
return(connection);
}
//交换机模式exchange（交换机）模式(发布订阅模式(fanout不建议使用), 路由模式(direct), 通配符模式(topic))
/// <summary>
/// 交换机exchange发布订阅模式fanout
/// </summary>
/// <param name="connFactory"></param>
public void rabbitmqExchangeFanout(IConnectionFactory connFactory)
{
using (IConnection conn = connFactory.CreateConnection())
{
using (IModel channel = conn.CreateModel())
{
//交换机名称
string exchangeName = "exchange1";
channel.ExchangeDeclare(exchange: exchangeName, type: "fanout");
//channel.ConfirmSelect();
//Console.WriteLine("消息内容：");
String message = this.textBox1.Text;
//消息内容
byte[] body = Encoding.UTF8.GetBytes(message);
//发送消息
channel.BasicPublish(exchange: exchangeName, routingKey: "", basicProperties: null, body: body);
//var isok = channel.WaitForConfirms();
Console.WriteLine("成功发送消息11：" + message + ";33"); // + isok.ToString());
}
}
}
public bool TryConnect(PolicyFactory persisterConnectionPolicyFactory)
{
lock (_lockObject)
{
if (IsConnected)
{
return(true);
}
persisterConnectionPolicyFactory(_logger)
.Execute(() =>
{
_connection = _factory.CreateConnection();
});
if (!IsConnected)
{
return(false);
}
return(true);
}
}
private void ConnectToMessageQueue(Common.Model.RabbitMQ.Root settings)
{
connectionFactory.UserName = settings.Username;
connectionFactory.Password = settings.Password;
var timeout = DateTime.Now.AddSeconds(30);
do
{
try
{
this.connection = connectionFactory.CreateConnection(settings.Hosts.Select(h => h.Address).ToList());
}
catch (BrokerUnreachableException)
{
}
}while (DateTime.Now < timeout && this.connection == null);
if (this.connection == null)
{
throw new TimeoutException("Could not connect to RabbitMQ instance.");
}
}
public Queue()
{
Uri msgQueue = new Uri("activemq:tcp://localhost:61616");
_factory = new ConnectionFactory(msgQueue);
try
{
_connection = _factory.CreateConnection();
}
catch (NMSConnectionException exc)
{
// TODO handle no server found issue
}
// TODO check _connection for null -- probably means server not found
_connection.RequestTimeout = TimeSpan.FromSeconds(60);
_session = _connection.CreateSession();
// TODO need to find out if queue exists.
// It creates a new queue if it doesn't exist.
_destination = _session.GetDestination("queue://TwitterSearchStream");
_consumer = _session.CreateConsumer(_destination);
_connection.Start();
//_consumer.Listener += message =>
// {
// var msg = message as ITextMessage;
// ProcessResults(msg.Text);
// };
_connection.ExceptionListener += _connection_ExceptionListener;
_connection.ConnectionInterruptedListener += _connection_ConnectionInterruptedListener;
//while (true)
//{
// Thread.Sleep(1000);
//}
StartReceive();
}
public void CachedMessageProducerTwoRequests()
{
IConnectionFactory connectionFactory = (IConnectionFactory)mocks.CreateMock(typeof(IConnectionFactory));
IConnection connection = new TestConnection();
Expect.Call(connectionFactory.CreateConnection()).Return(connection).Repeat.Once();
mocks.ReplayAll();
CachingConnectionFactory cachingConnectionFactory = new CachingConnectionFactory();
cachingConnectionFactory.TargetConnectionFactory = connectionFactory;
IConnection con1 = cachingConnectionFactory.CreateConnection();
ISession sessionA = con1.CreateSession(true, SessionMode.SessionTransacted);
Topic dest = new Topic("test.topic");
IMessageProducer producerA = sessionA.CreateProducer(dest);
TestMessageProducer tmpA = GetTestMessageProducer(producerA);
ISession sessionB = con1.CreateSession(true, SessionMode.SessionTransacted);
IMessageProducer producerB = sessionB.CreateProducer(dest);
TestMessageProducer tmpB = GetTestMessageProducer(producerB);
Assert.AreNotSame(tmpA, tmpB);
sessionA.Close();
ISession sessionC = con1.CreateSession(true, SessionMode.SessionTransacted);
IMessageProducer producerC = sessionC.CreateProducer(dest);
TestMessageProducer tmpC = GetTestMessageProducer(producerC);
Assert.AreSame(tmpA, tmpC);
mocks.VerifyAll();
}
protected void TryCreateConnectionFactory(object stateInfo)
{
connection = null;
//Log.Debug("RabbitMq: TryCreateConnectionFactory Creating connection factory on {0} - {1}", hostNames, stateInfo);
if (stateInfo != null)
{
var autoEvent = (AutoResetEvent) stateInfo;
autoEvent.Set();
}
var tempHostNames = hostNames;
//hostNames.Shuffle();
foreach (var hostName in tempHostNames)
{
try
{
factory = new ConnectionFactory { HostName = hostName, UserName = userName, Password = password, NetworkRecoveryInterval = TimeSpan.FromMilliseconds(timeout) };
connection = factory.CreateConnection();
waitingToConnect = false;
break;
}
catch (SocketException se)
{
Log.Error(se, "RabbitMq: TryCreateConnectionFactory has an Error creating connection to host {0}", hostName);
}
catch (BrokerUnreachableException be)
{
Log.Error(be, "RabbitMq: TryCreateConnectionFactory Cannot reach broker for host {0}", hostName);
}
catch (Exception ex)
{
Log.Error(ex, "RabbitMq: TryCreateConnectionFactory has an Error with {0} - {1}", hostName, ex.Message);
}
}
if (connection == null) StartTryToConnect();
}
public void Start()
{
factory = new ConnectionFactory(URI);
if (USERNAME != "")
{
connection = factory.CreateConnection(USERNAME, PASSWORD);
}
else
{
connection = factory.CreateConnection();
}
connection.Start();
session = connection.CreateSession();
}
/// <summary>
/// Private method, that must be run for the client to work.
/// <remarks>See constructor</remarks>
/// </summary>
private void InitializeEndpoint()
{
// prepare endpoint
_connectionFactory = GetConnectionFactory();
_connection = _connectionFactory.CreateConnection();
_model = _connection.CreateModel();
_properties = _model.CreateBasicProperties();
_properties.DeliveryMode = (byte)_config.DeliveryMode; //persistance
}
