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();
}
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 void SendWithInvalidRemoteChannelTest()
{
this.testListener.RegisterTarget(TestPoint.Transfer, (stream, channel, fields) =>
{
// send an end with invalid channel
TestListener.FRM(stream, 0x17UL, 0, 33);
return(TestOutcome.Stop);
});
string testName = "SendWithProtocolErrorTest";
Trace.WriteLine(TraceLevel.Information, "sync test");
{
Connection connection = new Connection(this.address);
Session session = new Session(connection);
SenderLink sender = new SenderLink(session, "sender-" + testName, "any");
try
{
sender.Send(new Message("test")
{
Properties = new Properties()
{
MessageId = testName
}
});
Assert.IsTrue(false, "Send should throw exception");
}
catch (AmqpException exception)
{
Assert.AreEqual(ErrorCode.NotFound, (string)exception.Error.Condition);
}
connection.Close();
Assert.AreEqual(ErrorCode.NotFound, (string)connection.Error.Condition);
}
Trace.WriteLine(TraceLevel.Information, "async test");
Task.Factory.StartNew(async() =>
{
Connection connection = await Connection.Factory.CreateAsync(this.address);
Session session = new Session(connection);
SenderLink sender = new SenderLink(session, "sender-" + testName, "any");
try
{
await sender.SendAsync(new Message("test")
{
Properties = new Properties()
{
MessageId = testName
}
});
Assert.IsTrue(false, "Send should throw exception");
}
catch (AmqpException exception)
{
Assert.AreEqual(ErrorCode.NotFound, (string)exception.Error.Condition);
}
await connection.CloseAsync();
Assert.AreEqual(ErrorCode.NotFound, (string)connection.Error.Condition);
}).Unwrap().GetAwaiter().GetResult();
}
static void Main(string[] args)
{
Console.WriteLine("Producer Started");
try
{
Address address = new Address("amqp://*****:*****@localhost:5672");
Connection connection = new Connection(new Address("amqp://*****:*****@localhost:5672"));
Session session = new Session(connection);
//SenderLink sender = new SenderLink(session, "sender-link", "q1");
SenderLink sender = new SenderLink(session, "sender-link", "topic://q1");
while (true)
{
Console.WriteLine("write something to send");
string msgstr = Console.ReadLine();
Message message = new Message(msgstr);
sender.SendAsync(message);
}
}
catch (Exception e)
{
Console.WriteLine(e);
throw;
}
Console.ReadLine();
}
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 SendMessage <T>(T body)
{
try
{
var settings = new JsonSerializerSettings();
settings.TypeNameHandling = TypeNameHandling.None;
settings.MetadataPropertyHandling = MetadataPropertyHandling.Ignore;
settings.DateParseHandling = DateParseHandling.None;
Message newMessage = new Message(JsonConvert.SerializeObject(body, settings));
newMessage.Header = new Header();
newMessage.Properties = new Properties();
newMessage.Header.Durable = true;
newMessage.Properties.MessageId = Guid.NewGuid().ToString();
newMessage.Properties.CorrelationId = newMessage.Properties.MessageId;
newMessage.Properties.GroupId = "group1";
if (cntr % 2 == 0)
{
//newMessage.Properties.GroupId = "group1";
}
else
{
//newMessage.Properties.GroupId = "group2";
}
await _producer.SendAsync(newMessage);
cntr = cntr + 1;
}
catch (Exception ex)
{
Console.WriteLine(ex.ToString());
}
}
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 void ConnectionMaxFrameSizeTest()
{
this.testListener.RegisterTarget(TestPoint.Open, (stream, channel, fields) =>
{
TestListener.FRM(stream, 0x10UL, 0, 0, "TestListener", "localhost", 512u);
return(TestOutcome.Stop);
});
this.testListener.RegisterTarget(TestPoint.Begin, (stream, channel, fields) =>
{
TestListener.FRM(stream, 0x11UL, 0, channel, channel, 0u, 100u, 100u, 8u, null, null, null,
new Fields()
{
{ new Symbol("big-string"), new string('a', 1024) }
});
return(TestOutcome.Stop);
});
string testName = "ConnectionMaxFrameSizeTest";
Trace.WriteLine(TraceLevel.Information, "sync test");
{
Open open = new Open()
{
ContainerId = testName, HostName = "localhost", MaxFrameSize = 2048
};
Connection connection = new Connection(this.address, null, open, null);
Session session = new Session(connection);
SenderLink sender = new SenderLink(session, "sender-" + testName, "any");
sender.Send(new Message("test")
{
Properties = new Properties()
{
MessageId = testName
}
});
connection.Close();
Assert.IsTrue(connection.Error == null, "connection has error!" + connection.Error);
}
Trace.WriteLine(TraceLevel.Information, "async test");
Task.Factory.StartNew(async() =>
{
ConnectionFactory factory = new ConnectionFactory();
factory.AMQP.MaxFrameSize = 2048;
Connection connection = await factory.CreateAsync(this.address);
Session session = new Session(connection);
SenderLink sender = new SenderLink(session, "sender-" + testName, "any");
await sender.SendAsync(new Message("test")
{
Properties = new Properties()
{
MessageId = testName
}
});
await connection.CloseAsync();
Assert.IsTrue(connection.Error == null, "connection has error!" + connection.Error);
}).Unwrap().GetAwaiter().GetResult();
}
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();
}
private async Task <IoTHubAmqpDeviceClient> Telemetry(SenderLink sl, Action <Message> handler)
{
var message = NewMessage();
handler(message);
await sl.SendAsync(message);
return(this);
}
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);
}
/// <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();
}
public static void PutCsbToken(Connection connection, ServiceBusConfiguration config, string audience)
{
var tokenProvider = new ManagedIdentityTokenProvider();
var token = tokenProvider.GetTokenAsync($"sb://{config.Host}/");
var session = new Session(connection);
var cbsClientAddress = "cbs-client-reply-to";
var cbsSender = new SenderLink(session, config.Subscription, "$cbs");
var cbsReceiver = new ReceiverLink(session, cbsClientAddress, "$cbs");
// construct the put-token message
var request = new Message(token.TokenValue)
{
Properties = new Properties
{
MessageId = Guid.NewGuid().ToString(),
ReplyTo = cbsClientAddress
},
ApplicationProperties = new ApplicationProperties
{
["operation"] = "put-token",
["type"] = token.TokenType,
["expiration"] = token.ExpiresAtUtc,
["name"] = audience
}
};
cbsSender.SendAsync(request).Wait();
Trace.WriteLine(TraceLevel.Information, " request: {0}", request.Properties);
Trace.WriteLine(TraceLevel.Information, " request: {0}", request.ApplicationProperties);
// receive the response
var response = cbsReceiver.ReceiveAsync().Result;
if (response?.Properties == null || response.ApplicationProperties == null)
{
throw new Exception("invalid response received");
}
// validate message properties and status code.
Trace.WriteLine(TraceLevel.Information, " response: {0}", response.Properties);
Trace.WriteLine(TraceLevel.Information, " response: {0}", response.ApplicationProperties);
int statusCode = (int)response.ApplicationProperties["status-code"];
if (statusCode != (int)HttpStatusCode.Accepted && statusCode != (int)HttpStatusCode.OK)
{
throw new Exception("put-token message was not accepted. Error code: " + statusCode);
}
// the sender/receiver may be kept open for refreshing tokens
cbsSender.Close();
cbsReceiver.Close();
session.Close();
}
public void SendTimeoutTest()
{
this.testListener.RegisterTarget(TestPoint.Transfer, (stream, channel, fields) =>
{
return(TestOutcome.Stop);
});
string testName = "SendTimeoutTest";
TimeSpan timeout = TimeSpan.FromMilliseconds(600);
Trace.WriteLine(TraceLevel.Information, "sync test");
{
Connection connection = new Connection(this.address);
Session session = new Session(connection);
SenderLink sender = new SenderLink(session, "sender-" + testName, "any");
try
{
sender.Send(new Message("test")
{
Properties = new Properties()
{
MessageId = testName
}
}, timeout);
Assert.IsTrue(false, "Send should throw exception");
}
catch (TimeoutException)
{
}
connection.Close();
}
Trace.WriteLine(TraceLevel.Information, "async test");
Task.Factory.StartNew(async() =>
{
Connection connection = await Connection.Factory.CreateAsync(this.address);
Session session = new Session(connection);
SenderLink sender = new SenderLink(session, "sender-" + testName, "any");
try
{
await sender.SendAsync(new Message("test")
{
Properties = new Properties()
{
MessageId = testName
}
}, timeout);
Assert.IsTrue(false, "Send should throw exception");
}
catch (TimeoutException)
{
}
await connection.CloseAsync();
}).Unwrap().GetAwaiter().GetResult();
}
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);
}
public async Task ConcurrentWritersMultipleConnections()
{
// Up to version 2.1.3, multiple writers from a single task could cause
// a deadlock (cf issue https://github.com/Azure/amqpnetlite/issues/287)
// This test checks that it's fixed
const int NbProducerTasks = 4;
var data = Enumerable.Range(0, 100 * 1024).Select(x => (byte)x).ToArray();
// Open 2 connections and sender links to 2 queues
var connection1 = await Connection.Factory.CreateAsync(
testTarget.Address, new Open()
{
ContainerId = "c1", MaxFrameSize = 4096
}, null);
var connection2 = await Connection.Factory.CreateAsync(
testTarget.Address, new Open()
{
ContainerId = "c2", MaxFrameSize = 4096
}, null);
var senderLink1 = new SenderLink(new Session(connection1), "Sender 1", "q1");
var senderLink2 = new SenderLink(new Session(connection2), "Sender 2", "q2");
// Start multiple sender tasks that will use both sender links concurrently
var tasks = Enumerable.Range(0, NbProducerTasks).Select(_ =>
Task.Run(async() =>
{
// Send 10 messages on both queues
for (int i = 0; i < 10; i++)
{
var message = new Message()
{
BodySection = new Data()
{
Binary = data
}
};
await senderLink1.SendAsync(message, TimeSpan.FromSeconds(10));
await senderLink2.SendAsync(message, TimeSpan.FromSeconds(10));
}
}));
var sendersFinished = Task.WhenAll(tasks);
var timeoutTask = Task.Delay(TestTimeout);
Assert.AreEqual(sendersFinished, await Task.WhenAny(sendersFinished, timeoutTask),
"Probable deadlock detected: timeout while waiting for concurrent sender tasks to complete");
await connection1.CloseAsync();
await connection2.CloseAsync();
}
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 SendEmailAsync(string email, EmailMessage emailMessage, string sender = null)
{
try
{
bool hasAttachments = emailMessage.Attachments != null && emailMessage.Attachments.Any();
var message = new Message(emailMessage.Body)
{
Properties = new Properties {
MessageId = Guid.NewGuid().ToString()
},
ApplicationProperties = new ApplicationProperties
{
["email"] = email,
["sender"] = !string.IsNullOrEmpty(sender) && sender.IsValidEmail() ? sender : string.Empty,
["isHtml"] = emailMessage.IsHtml,
["subject"] = emailMessage.Subject,
["hasAttachment"] = hasAttachments
}
};
if (hasAttachments)
{
message.ApplicationProperties["contentType"] = emailMessage.Attachments[0].ContentType;
message.ApplicationProperties["fileName"] = emailMessage.Attachments[0].FileName;
using (var ms = new MemoryStream())
{
emailMessage.Attachments[0].Stream.CopyTo(ms);
message.ApplicationProperties["file"] = ms.ToArray();
}
}
string policyName = WebUtility.UrlEncode(_settings.PolicyName);
string key = WebUtility.UrlEncode(_settings.Key);
string connectionString = $"amqps://{policyName}:{key}@{_settings.NamespaceUrl}/";
var connection = await Connection.Factory.CreateAsync(new Address(connectionString));
var amqpSession = new Session(connection);
SenderLink senderLink = new SenderLink(amqpSession, "sender-link", _settings.QueueName);
await senderLink.SendAsync(message);
amqpSession.Close(0);
connection.Close(0);
}
catch (Exception ex)
{
await _log.WriteErrorAsync("EmailSender", "SendEmailAsync", string.Empty, ex);
}
}
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 static void SendDtoMessage(FiniteDto messageDto)
{
var serialized = JsonDtoSerializer.SerializeDto(messageDto);
var message = new Message(serialized);
try
{
sender.SendAsync(message);
}
catch (Exception ex)
{
Windows.WriteMainWindowDescriptiveText(ex.ToString());
}
}
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 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();
}
