static async Task Run() { string address = "amqp://*****:*****@localhost:5672"; Connection connection = await Connection.Factory.CreateAsync(new Address(address)); Session session = new Session(connection); SenderLink sender = new SenderLink(session, "test-sender", "q1"); Message message1 = new Message("Hello AMQP!"); await sender.SendAsync(message1); ReceiverLink receiver = new ReceiverLink(session, "test-receiver", "q1"); Message message2 = await receiver.ReceiveAsync(); Console.WriteLine(message2.GetBody <string>()); receiver.Accept(message2); await sender.CloseAsync(); await receiver.CloseAsync(); await session.CloseAsync(); await connection.CloseAsync(); }
static async Task RunSampleAsync() { ConnectionFactory factory = new ConnectionFactory(); factory.SASL.Profile = SaslProfile.External; Trace.WriteLine(TraceLevel.Information, "Establishing a connection..."); Address address = new Address(sbNamespace, 5671, null, null, "/", "amqps"); var connection = await factory.CreateAsync(address); // before any operation can be performed, a token must be put to the $cbs node Trace.WriteLine(TraceLevel.Information, "Putting a token to the $cbs node..."); await PutTokenAsync(connection); Trace.WriteLine(TraceLevel.Information, "Sending a message..."); var session = new Session(connection); var sender = new SenderLink(session, "ServiceBus.Cbs:sender-link", entity); await sender.SendAsync(new Message("test")); await sender.CloseAsync(); Trace.WriteLine(TraceLevel.Information, "Receiving the message back..."); var receiver = new ReceiverLink(session, "ServiceBus.Cbs:receiver-link", entity); var message = await receiver.ReceiveAsync(); receiver.Accept(message); await receiver.CloseAsync(); Trace.WriteLine(TraceLevel.Information, "Closing the connection..."); await session.CloseAsync(); await connection.CloseAsync(); }
public async Task SendAsync <T>(T @event) where T : class { var data = JsonConvert.SerializeObject(@event); var eventType = @event.GetType().FullName; var address = Settings.Address + @event.GetType().Name; var session = CreateSession(); var sender = new SenderLink(session, Settings.AppName, address); var message = new Message(data) { ApplicationProperties = new ApplicationProperties(), Properties = new Properties { MessageId = Guid.NewGuid().ToString(), GroupId = eventType } }; message.ApplicationProperties[MESSAGE_TYPE_KEY] = eventType; try { await sender.SendAsync(message); } finally { await sender.CloseAsync(TimeSpan.Zero); } }
public async Task AddToQueue(IEnumerable <T> data) { await Connect(); var target = new Target { Address = queue.IndexOf("topic", StringComparison.InvariantCultureIgnoreCase) == 0 ? $"topic://{queue}" : $"queue://{queue}" }; SenderLink sender = new SenderLink(session, receiverName, target, null); foreach (var d in data) { var message = new Message(JsonConvert.SerializeObject(d)) { Properties = new Properties { CreationTime = DateTime.UtcNow }, }; await sender.SendAsync(message); } await sender.CloseAsync(); }
public async ValueTask DisposeAsync() { await ActionUtil.ExecuteAll( () => _receiverLink.CloseAsync(), () => _senderLink.CloseAsync(), () => _senderLink.Session.CloseAsync() ).ConfigureAwait(false); }
public async Task ReceiverSenderAsync() { string testName = "ReceiverSenderAsync"; ConnectionFactory connectionFactory = new ConnectionFactory(); // Creating first ReceiverLink Connection firstReceiverConnection = await connectionFactory.CreateAsync(this.testTarget.Address); Session firstReceiverSession = new Session(firstReceiverConnection); ReceiverLink firstReceiverLink = new ReceiverLink(firstReceiverSession, "receiver-link", testName); // Does not work when creating SenderLink after first ReceiverLink var senderConnection = await connectionFactory.CreateAsync(this.testTarget.Address); var senderSession = new Session(senderConnection); var senderLink = new SenderLink(senderSession, "sender-link", testName); // Send and receive message await senderLink.SendAsync(new Message(testName)); Message firstMessageReceived = await firstReceiverLink.ReceiveAsync(TimeSpan.FromMilliseconds(1000)); // Close first reveiver link await firstReceiverLink.CloseAsync(); await firstReceiverSession.CloseAsync(); await firstReceiverConnection.CloseAsync(); // Creating second ReceiverLink Connection secondReceiverConnection = await connectionFactory.CreateAsync(this.testTarget.Address); Session secondReceiverSession = new Session(secondReceiverConnection); ReceiverLink secondReceiverLink = new ReceiverLink(secondReceiverSession, "receiver-link", testName); // Send and receive message await senderLink.SendAsync(new Message(testName)); Message message = await secondReceiverLink.ReceiveAsync(TimeSpan.FromMilliseconds(1000)); Assert.IsTrue(message != null, "No message received"); secondReceiverLink.Accept(message); // Close second reveiver link await secondReceiverLink.CloseAsync(); await secondReceiverSession.CloseAsync(); await secondReceiverConnection.CloseAsync(); // Close sender link await senderLink.CloseAsync(); await senderSession.CloseAsync(); await senderConnection.CloseAsync(); }
public async Task SendAsync(string eventType, string address, string data, string correlationId) { var messageId = Guid.NewGuid().ToString(); using (Logger.BeginScope(new Dictionary <string, object> { ["CorrelationId"] = correlationId, ["MessageId"] = messageId, ["MessageType"] = eventType })) { Logger.LogTrace($"Publishing message {messageId} to {address} with body: {data}"); var session = CreateSession(); var attach = new Attach() { Target = new Target() { Address = address, Durable = Settings.Durable }, Source = new Source() }; var sender = new SenderLink(session, Settings.AppName, attach, null); sender.Closed += OnClosed; var message = new Message(data) { Header = new Header { Durable = (Settings.Durable == 2) }, ApplicationProperties = new ApplicationProperties(), Properties = new Properties { MessageId = messageId, GroupId = eventType, CorrelationId = correlationId } }; message.ApplicationProperties[MESSAGE_TYPE_KEY] = eventType; try { await sender.SendAsync(message); Logger.LogInformation($"Published message {messageId}"); } finally { if (sender.Error != null) { Error = new DomainEventError(); Error.Condition = sender.Error.Condition.ToString(); Error.Description = sender.Error.Description; Closed?.Invoke(this, Error); } if (!sender.IsClosed) { await sender.CloseAsync(TimeSpan.FromSeconds(5)); } await session.CloseAsync(); await session.Connection.CloseAsync(); } } }
public async Task PublishAsync <T>(T model, string topic) { var sender = new SenderLink(Session, $"{GetType().FullName}.sender", topic); var message = GetMessage(model); await sender.SendAsync(message); await sender.CloseAsync(); }
/// <summary> /// renews the cbs token /// </summary> /// <param name="sharedAccessToken">token to renew</param> /// <returns>Task to wait on</returns> private async Task RenewTokenAsync(string sharedAccessToken) { var session = new Session(m_connection); string cbsClientAddress = "cbs-client-reply-to"; var cbsSender = new SenderLink(session, "cbs-sender", "$cbs"); var receiverAttach = new Attach() { Source = new Source() { Address = "$cbs" }, Target = new Target() { Address = cbsClientAddress } }; var cbsReceiver = new ReceiverLink(session, "cbs-receiver", receiverAttach, null); // construct the put-token message var request = new Message(sharedAccessToken); request.Properties = new Properties(); request.Properties.MessageId = "1"; request.Properties.ReplyTo = cbsClientAddress; request.ApplicationProperties = new ApplicationProperties(); request.ApplicationProperties["operation"] = "put-token"; request.ApplicationProperties["type"] = TokenType; request.ApplicationProperties["name"] = TokenScope; await cbsSender.SendAsync(request); // receive the response var response = await cbsReceiver.ReceiveAsync(); if (response == null || response.Properties == null || response.ApplicationProperties == null) { throw new Exception("invalid response received"); } int statusCode = (int)response.ApplicationProperties["status-code"]; await cbsSender.CloseAsync(); await cbsReceiver.CloseAsync(); await session.CloseAsync(); if (statusCode != (int)HttpStatusCode.Accepted && statusCode != (int)HttpStatusCode.OK) { throw new Exception("put-token message was not accepted. Error code: " + statusCode); } // Now create new link await ResetLinkAsync(); }
private static async Task <bool> PutCbsToken(Connection connection, string shareAccessSignature, string audience) { Log.Debug("Sending authentication token"); bool result = true; var session = new Session(connection); const string cbsReplyToAddress = "cbs-reply-to"; var cbsSender = new SenderLink(session, "cbs-sender", "$cbs"); var cbsReceiver = new ReceiverLink(session, cbsReplyToAddress, "$cbs"); // construct the put-token message var request = new Message(shareAccessSignature) { Properties = new Properties { MessageId = Guid.NewGuid().ToString(), ReplyTo = cbsReplyToAddress }, ApplicationProperties = new ApplicationProperties { ["operation"] = "put-token", ["type"] = "azure-devices.net:sastoken", ["name"] = audience } }; await cbsSender.SendAsync(request); // receive the response var response = await cbsReceiver.ReceiveAsync(); if (response?.Properties == null || response.ApplicationProperties == null) { result = false; } else { var statusCode = (int)response.ApplicationProperties["status-code"]; var statusCodeDescription = (string)response.ApplicationProperties["status-description"]; if (statusCode != 202 && statusCode != 200) { result = false; Log.ErrorFormat("Authentication failure {status}", statusCodeDescription); } } // the sender/receiver may be kept open for refreshing tokens await cbsSender.CloseAsync(); await cbsReceiver.CloseAsync(); await session.CloseAsync(); Log.Debug("Authentication complete"); return(result); }
async Task SendReceiveAsync(int count) { // it is also possible to create the Address object form a Uri string as follows, // wss://[sas-policy]:[sas-key]@[ns].servicebus.windows.net/$servicebus/websocket // note that [sas-policy] and [sas-key] should be URL encoded Address wsAddress = new Address(this.Namespace, 443, this.KeyName, this.KeyValue, "/$servicebus/websocket", "wss"); WebSocketTransportFactory wsFactory = new WebSocketTransportFactory("AMQPWSB10"); Trace.WriteLine(TraceLevel.Information, "Establishing a connection..."); ConnectionFactory connectionFactory = new ConnectionFactory(new TransportProvider[] { wsFactory }); Connection connection = await connectionFactory.CreateAsync(wsAddress); Trace.WriteLine(TraceLevel.Information, "Creating a session..."); Session session = new Session(connection); Trace.WriteLine(TraceLevel.Information, "Creating a sender link..."); SenderLink sender = new SenderLink(session, "websocket-sender-link", this.Entity); Trace.WriteLine(TraceLevel.Information, "Sending {0} messages...", count); for (int i = 0; i < count; i++) { Message message = new Message("testing"); message.Properties = new Properties() { MessageId = "websocket-test-" + i }; await sender.SendAsync(message); } Trace.WriteLine(TraceLevel.Information, "Closing sender..."); await sender.CloseAsync(); Trace.WriteLine(TraceLevel.Information, "Receiving messages..."); ReceiverLink receiver = new ReceiverLink(session, "websocket-receiver-link", this.Entity); for (int i = 0; i < count; i++) { Message message = await receiver.ReceiveAsync(30000); if (message == null) { break; } receiver.Accept(message); } Trace.WriteLine(TraceLevel.Information, "Closing receiver..."); await receiver.CloseAsync(); Trace.WriteLine(TraceLevel.Information, "Shutting down..."); await session.CloseAsync(); await connection.CloseAsync(); }
private async Task InnerSendAsync(Message message, EventProperties properties) { using (Logger.BeginScope(new Dictionary <string, object> { ["CorrelationId"] = message.Properties.CorrelationId, ["MessageId"] = message.Properties.MessageId, ["MessageType"] = message.Properties.GroupId })) { Logger.LogTrace($"Publishing message {message.Properties.MessageId} to {properties.Address} with body: {message.Body}"); var disconnectAfter = false; if (conn == null) { Connect(); disconnectAfter = true; } var session = new Session(conn); var attach = new Attach() { Target = new Target() { Address = properties.Address, Durable = Settings.Durable }, Source = new Source() }; var sender = new SenderLink(session, Settings.AppName + Guid.NewGuid().ToString(), attach, null); sender.Closed += OnClosed; try { await sender.SendAsync(message).ConfigureAwait(false); Logger.LogInformation($"Published message {message.Properties.MessageId}"); } finally { if (sender.Error != null) { Error = new DomainEventError(); Error.Condition = sender.Error.Condition.ToString(); Error.Description = sender.Error.Description; Closed?.Invoke(this, Error); } if (disconnectAfter) { if (!sender.IsClosed) { await sender.CloseAsync(TimeSpan.FromSeconds(5)).ConfigureAwait(false); } await session.CloseAsync().ConfigureAwait(false); await session.Connection.CloseAsync().ConfigureAwait(false); } } } }
public async Task SendMessage(string addressName) { string message = $"Hello AMQP! at time {DateTime.Now}"; SenderLink sender = new SenderLink(MqSession, "Client", addressName); Message message1 = new Message(message); await sender.SendAsync(message1); await sender.CloseAsync(); Console.WriteLine("Sent a message: " + message); }
async Task SendReceiveAsync(int count) { Trace.WriteLine(TraceLevel.Information, "Establishing a connection..."); Connection connection = await Connection.Factory.CreateAsync(this.GetAddress()); Trace.WriteLine(TraceLevel.Information, "Creating a session..."); Session session = new Session(connection); Trace.WriteLine(TraceLevel.Information, "Creating a sender link..."); SenderLink sender = new SenderLink(session, "topic-sender-link", this.Entity); Trace.WriteLine(TraceLevel.Information, "Sending {0} messages...", count); for (int i = 0; i < count; i++) { Message message = new Message(); message.Properties = new Properties() { MessageId = "topic-test-" + i }; message.BodySection = new Data() { Binary = Encoding.UTF8.GetBytes("message #" + i) }; await sender.SendAsync(message); } Trace.WriteLine(TraceLevel.Information, "Closing sender..."); await sender.CloseAsync(); Trace.WriteLine(TraceLevel.Information, "Receiving messages from subscription..."); ReceiverLink receiver = new ReceiverLink(session, "receiver-link", this.Entity + "/Subscriptions/sub1"); for (int i = 0; i < count; i++) { Message message = await receiver.ReceiveAsync(30000); if (message == null) { break; } receiver.Accept(message); } Trace.WriteLine(TraceLevel.Information, "Closing receiver..."); await receiver.CloseAsync(); Trace.WriteLine(TraceLevel.Information, "Shutting down..."); await session.CloseAsync(); await connection.CloseAsync(); }
public async Task WebSocketSendReceiveAsync() { if (Environment.GetEnvironmentVariable("CoreBroker") == "1") { // No Websocket listener on .Net Core return; } string testName = "WebSocketSendReceiveAsync"; // assuming it matches the broker's setup and port is not taken Address wsAddress = new Address(address); int nMsgs = 50; ConnectionFactory connectionFactory = new ConnectionFactory( new TransportProvider[] { new WebSocketTransportFactory() }); Connection connection = await connectionFactory.CreateAsync(wsAddress); Session session = new Session(connection); SenderLink sender = new SenderLink(session, "sender-" + testName, "q1"); for (int i = 0; i < nMsgs; ++i) { Message message = new Message(); message.Properties = new Properties() { MessageId = "msg" + i, GroupId = testName }; message.ApplicationProperties = new ApplicationProperties(); message.ApplicationProperties["sn"] = i; await sender.SendAsync(message); } ReceiverLink receiver = new ReceiverLink(session, "receiver-" + testName, "q1"); for (int i = 0; i < nMsgs; ++i) { Message message = await receiver.ReceiveAsync(); Trace.WriteLine(TraceLevel.Information, "receive: {0}", message.ApplicationProperties["sn"]); receiver.Accept(message); } await sender.CloseAsync(); await receiver.CloseAsync(); await session.CloseAsync(); await connection.CloseAsync(); }
static async Task <int> SslConnectionTestAsync() { try{ ConnectionFactory factory = new ConnectionFactory(); String certFile = "C:\\location\\certificate.cer"; factory.SSL.RemoteCertificateValidationCallback = ValidateServerCertificate; factory.SSL.LocalCertificateSelectionCallback = (a, b, c, d, e) => X509Certificate.CreateFromCertFile(certFile); factory.SSL.ClientCertificates.Add(X509Certificate.CreateFromCertFile(certFile)); factory.SASL.Profile = SaslProfile.External; Connection.DisableServerCertValidation = false; Address address = new Address("amqps://*****:*****@host:5671"); Connection connection = await factory.CreateAsync(address); Session session = new Session(connection); SenderLink sender = new SenderLink(session, "sender-link", "amqp"); Message message = null; DateTime d1 = DateTime.Now; Console.WriteLine(d1); Console.WriteLine("Send Start time : {0}!", d1); for (int i = 0; i < 5; i++) { string msg = "num --" + i + "-->this is a testing message for sender, to test sending proformance"; message = new Message(msg); sender.SendAsync(message); Console.WriteLine("Sent messaging {0}!", msg); } DateTime d2 = DateTime.Now; Console.WriteLine("Send End time : {0}!", d2); Console.WriteLine("Press enter key to exit..."); Console.ReadLine(); await sender.CloseAsync(); await session.CloseAsync(); await connection.CloseAsync(); return(0); } catch (Exception e) { Console.WriteLine("Exception {0}.", e); return(1); } }
public async Task StartNewCup(Maker.Interfaces.DTOs.RequestCup requestCup) { Connection connection = await Connection.Factory.CreateAsync(await GetAmqpAddressAsync()); Amqp.Session session = new Amqp.Session(connection); SenderLink sender = new SenderLink(session, "barista-sender", "StartNewCup"); //create message Message message = new Message(JsonConvert.SerializeObject(requestCup)); await sender.SendAsync(message); await sender.CloseAsync(); await connection.CloseAsync(); }
public async Task LargeMessageSendReceiveAsync() { string testName = "LargeMessageSendReceiveAsync"; int nMsgs = 50; Connection connection = await Connection.Factory.CreateAsync( this.testTarget.Address, new Open() { ContainerId = "c1", MaxFrameSize = 4096 }, null); Session session = new Session(connection); SenderLink sender = new SenderLink(session, "sender-" + testName, testTarget.Path); int messageSize = 100 * 1024; for (int i = 0; i < nMsgs; ++i) { Message message = new Message(new string('D', messageSize)); message.Properties = new Properties() { MessageId = "msg" + i, GroupId = testName }; message.ApplicationProperties = new ApplicationProperties(); message.ApplicationProperties["sn"] = i; await sender.SendAsync(message); } ReceiverLink receiver = new ReceiverLink(session, "receiver-" + testName, testTarget.Path); for (int i = 0; i < nMsgs; ++i) { Message message = await receiver.ReceiveAsync(); string value = message.GetBody <string>(); Trace.WriteLine(TraceLevel.Information, "receive: {0} body {1}x{2}", message.ApplicationProperties["sn"], value[0], value.Length); receiver.Accept(message); } await sender.CloseAsync(); await receiver.CloseAsync(); await session.CloseAsync(); await connection.CloseAsync(); }
protected override async Task SendAsync(Message message, EventProperties properties) { var disconnectAfter = false; if (conn == null) { Connect(); disconnectAfter = true; } var session = new Session(conn); var attach = new Attach() { Target = new Target() { Address = properties.Address, Durable = Settings.Durable }, Source = new Source() }; var sender = new SenderLink(session, Settings.AppName + Guid.NewGuid().ToString(), attach, null); sender.Closed += OnClosed; try { await sender.SendAsync(message).ConfigureAwait(false); Logger.LogInformation($"Published message {message.Properties.MessageId}"); } finally { if (sender.Error != null) { Error = new DomainEventError(); Error.Condition = sender.Error.Condition.ToString(); Error.Description = sender.Error.Description; Closed?.Invoke(this, Error); } if (disconnectAfter) { if (!sender.IsClosed) { await sender.CloseAsync(TimeSpan.FromSeconds(5)).ConfigureAwait(false); } await session.CloseAsync().ConfigureAwait(false); await session.Connection.CloseAsync().ConfigureAwait(false); } } }
public async Task CloseAsync() { try { var closeTimeout = session.Connection.Provider.CloseTimeout; await senderLink.CloseAsync(TimeSpan.FromMilliseconds(closeTimeout)).AwaitRunContinuationAsync(); } catch (NMSException) { throw; } catch (Exception ex) { throw ExceptionSupport.Wrap(ex, "Failed to close Link {0}", this.info.Id); } }
public async Task SendMessageToDevice(string messageToDevice) { var sender = new SenderLink(session, "sender-link", "/messages/devicebound"); var message = new Message(System.Text.Encoding.UTF8.GetBytes(messageToDevice)); message.Properties = new Properties(); message.Properties.To = BuzzerDeviceTo; message.Properties.MessageId = Guid.NewGuid().ToString(); message.ApplicationProperties = new ApplicationProperties(); message.ApplicationProperties["iothub-ack"] = "full"; await sender.SendAsync(message); await sender.CloseAsync(); }
public async Task SetBuzzerStateAsync(bool doorState) { var sender = new SenderLink(session, "sender-link", "/messages/devicebound"); var message = new Message(doorState); message.Properties = new Properties(); message.Properties.To = Constants.BuzzerDeviceTo; message.Properties.MessageId = Guid.NewGuid().ToString(); message.ApplicationProperties = new ApplicationProperties(); message.ApplicationProperties ["iothub-ack"] = "full"; await sender.SendAsync(message); await sender.CloseAsync(); }
async static Task <bool> PutCbsToken(Connection connection, string host, string shareAccessSignature, string audience) { bool result = true; Session session = new Session(connection); string cbsReplyToAddress = "cbs-reply-to"; var cbsSender = new SenderLink(session, "cbs-sender", "$cbs"); var cbsReceiver = new ReceiverLink(session, cbsReplyToAddress, "$cbs"); // construct the put-token message var request = new Message(shareAccessSignature); request.Properties = new Properties(); request.Properties.MessageId = Guid.NewGuid().ToString(); request.Properties.ReplyTo = cbsReplyToAddress; request.ApplicationProperties = new ApplicationProperties(); request.ApplicationProperties["operation"] = "put-token"; request.ApplicationProperties["type"] = "azure-devices.net:sastoken"; request.ApplicationProperties["name"] = audience; await cbsSender.SendAsync(request); // receive the response var response = await cbsReceiver.ReceiveAsync(); if (response == null || response.Properties == null || response.ApplicationProperties == null) { result = false; } else { int statusCode = (int)response.ApplicationProperties["status-code"]; string statusCodeDescription = (string)response.ApplicationProperties["status-description"]; if (statusCode != (int)202 && statusCode != (int)200) // !Accepted && !OK { result = false; } } // the sender/receiver may be kept open for refreshing tokens await cbsSender.CloseAsync(); await cbsReceiver.CloseAsync(); await session.CloseAsync(); return(result); }
public async Task CustomMessgeBody() { string testName = "CustomMessgeBody"; Connection connection = await Connection.Factory.CreateAsync(this.testTarget.Address); Session session = new Session(connection); SenderLink sender = new SenderLink(session, "sender-" + testName, testTarget.Path); Student student = new Student("Tom"); student.Age = 16; student.Address = new StreetAddress() { FullAddress = "100 Main St. Small Town" }; student.DateOfBirth = new System.DateTime(1988, 5, 1, 1, 2, 3, 100, System.DateTimeKind.Utc); Message message = new Message(student); message.Properties = new Properties() { MessageId = "student" }; await sender.SendAsync(message); ReceiverLink receiver = new ReceiverLink(session, "receiver-" + testName, testTarget.Path); Message message2 = await receiver.ReceiveAsync(); Trace.WriteLine(TraceLevel.Information, "receive: {0}", message2.Properties); receiver.Accept(message2); await sender.CloseAsync(); await receiver.CloseAsync(); await session.CloseAsync(); await connection.CloseAsync(); Student student2 = message2.GetBody <Student>(); Assert.AreEqual(student.Age, student2.Age - 1); // incremented in OnDeserialized Assert.AreEqual(student.DateOfBirth, student2.DateOfBirth); Assert.AreEqual(student.Address.FullAddress, student2.Address.FullAddress); }
public static async Task <Message> SendControlRequestAsync(this Session session, string controller, Message request) { if (request.Properties == null) { request.Properties = new Properties(); } request.Properties.ReplyTo = "c-client-reply-to"; var cbsSender = new SenderLink(session, "c-sender", controller); var cbsReceiver = new ReceiverLink(session, "c-receiver", new Attach { Source = new Source { Address = controller }, Target = new Target { Address = "c-client-reply-to" } }, null); try { cbsReceiver.SetCredit(200, true); await cbsSender.SendAsync(request); return(await cbsReceiver.ReceiveAsync()); } finally { try { try { await cbsSender.CloseAsync(); } finally { await cbsReceiver.CloseAsync(); } } catch (AmqpException) { // ignore for closeasync } } }
public async Task TestHelloWorld() { Connection.DisableServerCertValidation = true; Trace.TraceLevel = TraceLevel.Frame; Trace.TraceListener = (l, f, a) => _output.WriteLine(DateTime.Now.ToString("[hh:mm:ss.fff]") + " " + string.Format(f, a)); //strange, works using regular activeMQ and the amqp test broker from here: http://azure.github.io/amqpnetlite/articles/hello_amqp.html //but this does not work in ActiveMQ Artemis var address = new Address(_fixture.HostName, _fixture.AmqpPort, _fixture.UserName, _fixture.Password, scheme: "AMQP"); var connection = new Connection(address); var session = new Session(connection); var message = new Message("Hello AMQP"); var target = new Target { Address = "q1", Capabilities = new Symbol[] { new Symbol("queue") } }; var sender = new SenderLink(session, "sender-link", target, null); await sender.SendAsync(message); var source = new Source { Address = "q1", Capabilities = new Symbol[] { new Symbol("queue") } }; var receiver = new ReceiverLink(session, "receiver-link", source, null); message = await receiver.ReceiveAsync(); receiver.Accept(message); await sender.CloseAsync(); await receiver.CloseAsync(); await session.CloseAsync(); await connection.CloseAsync(); }
static private async Task SendEvent() { string entity = Fx.Format("/devices/{0}/messages/events", deviceId); SenderLink senderLink = new SenderLink(session, "sender-link", entity); var messageValue = Encoding.UTF8.GetBytes(payload); Message message = new Message() { BodySection = new Data() { Binary = messageValue } }; await senderLink.SendAsync(message); await senderLink.CloseAsync(); }
public async Task WebSocketSendReceiveAsync() { string testName = "WebSocketSendReceiveAsync"; // assuming it matches the broker's setup and port is not taken Address wsAddress = new Address(address); int nMsgs = 50; Connection connection = await Connection.Factory.CreateAsync(wsAddress); Session session = new Session(connection); SenderLink sender = new SenderLink(session, "sender-" + testName, "q1"); for (int i = 0; i < nMsgs; ++i) { Message message = new Message(); message.Properties = new Properties() { MessageId = "msg" + i, GroupId = testName }; message.ApplicationProperties = new ApplicationProperties(); message.ApplicationProperties["sn"] = i; await sender.SendAsync(message); } ReceiverLink receiver = new ReceiverLink(session, "receiver-" + testName, "q1"); for (int i = 0; i < nMsgs; ++i) { Message message = await receiver.ReceiveAsync(); Trace.WriteLine(TraceLevel.Information, "receive: {0}", message.ApplicationProperties["sn"]); receiver.Accept(message); } await sender.CloseAsync(); await receiver.CloseAsync(); await session.CloseAsync(); await connection.CloseAsync(); }
public async Task ConcurrentLinkCreateClose() { const int NbProducerTasks = 4; var connection = await Connection.Factory.CreateAsync(testTarget.Address); var session = new Session(connection); var tasks = Enumerable.Range(0, NbProducerTasks).Select(n => Task.Run(async() => { for (int i = 0; i < 100; i++) { var senderLink = new SenderLink(session, $"link{n % NbProducerTasks}", $"q{n % 2}"); await senderLink.CloseAsync().ConfigureAwait(false); } })); await Task.WhenAll(tasks); await connection.CloseAsync(); }
public async Task InnerSendAsync(string address, Message message) { using (Logger.BeginScope(new Dictionary <string, object> { ["CorrelationId"] = message.Properties.CorrelationId, ["MessageId"] = message.Properties.MessageId, ["MessageType"] = message.Properties.GroupId })) { Logger.LogTrace($"Publishing message {message.Properties.MessageId} to {address} with body: {message.Body}"); var session = CreateSession(); var attach = new Attach() { Target = new Target() { Address = address, Durable = Settings.Durable }, Source = new Source() }; var sender = new SenderLink(session, Settings.AppName, attach, null); sender.Closed += OnClosed; try { await sender.SendAsync(message); Logger.LogInformation($"Published message {message.Properties.MessageId}"); } finally { if (sender.Error != null) { Error = new DomainEventError(); Error.Condition = sender.Error.Condition.ToString(); Error.Description = sender.Error.Description; Closed?.Invoke(this, Error); } if (!sender.IsClosed) { await sender.CloseAsync(TimeSpan.FromSeconds(5)); } await session.CloseAsync(); await session.Connection.CloseAsync(); } } }