public CFXEnvelope ExecuteRequest(string targetUri, CFXEnvelope request)
{
CFXEnvelope response = null;
Connection reqConn = null;
Session reqSession = null;
ReceiverLink receiver = null;
SenderLink sender = null;
Exception ex = null;
Uri targetAddress = new Uri(targetUri);
try
{
if (string.IsNullOrWhiteSpace(request.RequestID))
{
request.RequestID = "REQUEST-" + Guid.NewGuid().ToString();
}
Message req = AmqpUtilities.MessageFromEnvelope(request, UseCompression.Value);
req.Properties.MessageId = "command-request";
req.Properties.ReplyTo = CFXHandle;
req.ApplicationProperties = new ApplicationProperties();
req.ApplicationProperties["offset"] = 1;
Task.Run(() =>
{
try
{
reqConn = new Connection(new Address(targetAddress.ToString()));
reqSession = new Session(reqConn);
Attach recvAttach = new Attach()
{
Source = new Source()
{
Address = CFXHandle
},
Target = new Target()
{
Address = request.Target
}
};
receiver = new ReceiverLink(reqSession, "request-receiver", recvAttach, null);
receiver.Start(300);
sender = new SenderLink(reqSession, CFXHandle, request.Target);
sender.Send(req);
Message resp = receiver.Receive(RequestTimeout.Value);
if (resp != null)
{
receiver.Accept(resp);
response = AmqpUtilities.EnvelopeFromMessage(resp);
}
else
{
throw new TimeoutException("A response was not received from target CFX endpoint in the alloted time.");
}
}
catch (Exception ex3)
{
AppLog.Error(ex3);
ex = ex3;
}
}).Wait();
}
catch (Exception ex2)
{
AppLog.Error(ex2);
if (ex == null)
{
ex = ex2;
}
}
finally
{
if (receiver != null && !receiver.IsClosed)
{
receiver.Close();
}
if (sender != null && !sender.IsClosed)
{
sender.Close();
}
if (reqSession != null && !reqSession.IsClosed)
{
reqSession.Close();
}
if (reqConn != null && !reqConn.IsClosed)
{
reqConn.Close();
}
}
if (ex != null)
{
throw ex;
}
return(response);
}
public void TransactedPosting()
{
string testName = "TransactedPosting";
int nMsgs = 5;
Connection connection = new Connection(testTarget.Address);
Session session = new Session(connection);
SenderLink sender = new SenderLink(session, "sender-" + testName, testTarget.Path);
// commit
using (var ts = new TransactionScope())
{
for (int i = 0; i < nMsgs; i++)
{
Message message = new Message("test");
message.Properties = new Properties()
{
MessageId = "commit" + i, GroupId = testName
};
sender.Send(message);
}
ts.Complete();
}
// rollback
using (var ts = new TransactionScope())
{
for (int i = nMsgs; i < nMsgs * 2; i++)
{
Message message = new Message("test");
message.Properties = new Properties()
{
MessageId = "rollback" + i, GroupId = testName
};
sender.Send(message);
}
}
// commit
using (var ts = new TransactionScope())
{
for (int i = 0; i < nMsgs; i++)
{
Message message = new Message("test");
message.Properties = new Properties()
{
MessageId = "commit" + i, GroupId = testName
};
sender.Send(message);
}
ts.Complete();
}
ReceiverLink receiver = new ReceiverLink(session, "receiver-" + testName, testTarget.Path);
for (int i = 0; i < nMsgs * 2; i++)
{
Message message = receiver.Receive();
Trace.WriteLine(TraceLevel.Information, "receive: {0}", message.Properties.MessageId);
receiver.Accept(message);
Assert.IsTrue(message.Properties.MessageId.StartsWith("commit"));
}
connection.Close();
}
internal static Task <Outcome> SendAsync(this SenderLink link, global::Amqp.Message message, DeliveryState deliveryState, long timeoutMillis)
{
return(new AmqpSendTask(link, message, deliveryState, timeoutMillis).Task);
}
public void ContainerHostRequestProcessorTest()
{
string name = "ContainerHostRequestProcessorTest";
var processor = new TestRequestProcessor();
this.host.RegisterRequestProcessor(name, processor);
int count = 500;
var connection = new Connection(Address);
var session = new Session(connection);
string replyTo = "client-reply-to";
Attach recvAttach = new Attach()
{
Source = new Source()
{
Address = name
},
Target = new Target()
{
Address = replyTo
}
};
var doneEvent = new ManualResetEvent(false);
List <string> responses = new List <string>();
ReceiverLink receiver = new ReceiverLink(session, "request-client-receiver", recvAttach, null);
receiver.Start(
20,
(link, message) =>
{
responses.Add(message.GetBody <string>());
link.Accept(message);
if (responses.Count == count)
{
doneEvent.Set();
}
});
SenderLink sender = new SenderLink(session, "request-client-sender", name);
for (int i = 0; i < count; i++)
{
Message request = new Message("Hello");
request.Properties = new Properties()
{
MessageId = "request" + i, ReplyTo = replyTo
};
sender.Send(request, null, null);
}
Assert.IsTrue(doneEvent.WaitOne(10000), "Not completed in time");
receiver.Close();
sender.Close();
session.Close();
connection.Close();
Assert.AreEqual(count, processor.TotalCount);
Assert.AreEqual(count, responses.Count);
for (int i = 1; i <= count; i++)
{
Assert.AreEqual("OK" + i, responses[i - 1]);
}
}
public void TransactedRetiring()
{
string testName = "TransactedRetiring";
int nMsgs = 10;
Connection connection = new Connection(testTarget.Address);
Session session = new Session(connection);
SenderLink sender = new SenderLink(session, "sender-" + testName, testTarget.Path);
// send one extra for validation
for (int i = 0; i < nMsgs + 1; i++)
{
Message message = new Message("test");
message.Properties = new Properties()
{
MessageId = "msg" + i, GroupId = testName
};
sender.Send(message);
}
ReceiverLink receiver = new ReceiverLink(session, "receiver-" + testName, testTarget.Path);
Message[] messages = new Message[nMsgs];
for (int i = 0; i < nMsgs; i++)
{
messages[i] = receiver.Receive();
Trace.WriteLine(TraceLevel.Information, "receive: {0}", messages[i].Properties.MessageId);
}
// commit harf
using (var ts = new TransactionScope())
{
for (int i = 0; i < nMsgs / 2; i++)
{
receiver.Accept(messages[i]);
}
ts.Complete();
}
// rollback
using (var ts = new TransactionScope())
{
for (int i = nMsgs / 2; i < nMsgs; i++)
{
receiver.Accept(messages[i]);
}
}
// after rollback, messages should be still acquired
{
Message message = receiver.Receive();
Assert.AreEqual("msg" + nMsgs, message.Properties.MessageId);
receiver.Release(message);
}
// commit
using (var ts = new TransactionScope())
{
for (int i = nMsgs / 2; i < nMsgs; i++)
{
receiver.Accept(messages[i]);
}
ts.Complete();
}
// only the last message is left
{
Message message = receiver.Receive();
Assert.AreEqual("msg" + nMsgs, message.Properties.MessageId);
receiver.Accept(message);
}
// at this point, the queue should have zero messages.
// If there are messages, it is a bug in the broker.
connection.Close();
}
static void Main(string[] args)
{
if (args.Length != 3)
{
Console.Error.WriteLine("Usage: Request <connection-url> <address> <message-body>");
Environment.Exit(1);
}
string connUrl = args[0];
string address = args[1];
string messageBody = args[2];
Connection conn = new Connection(new Address(connUrl));
try
{
Session session = new Session(conn);
Target target = new Target()
{
Address = address,
};
OnAttached onSenderAttached = (link, attach) =>
{
Console.WriteLine("REQUEST: Opened sender for target address '{0}'", address);
};
SenderLink sender = new SenderLink(session, "s1", target, onSenderAttached);
string responseAddress = null;
ManualResetEvent done = new ManualResetEvent(false);
Source source = new Source()
{
Dynamic = true,
};
OnAttached onReceiverAttached = (link, attach) =>
{
Console.WriteLine("REQUEST: Opened dynamic receiver for responses");
responseAddress = ((Source)attach.Source).Address;
done.Set();
};
ReceiverLink receiver = new ReceiverLink(session, "r1", source, onReceiverAttached);
done.WaitOne();
Message request = new Message(messageBody);
request.Properties = new Properties()
{
MessageId = Guid.NewGuid().ToString(),
ReplyTo = responseAddress,
};
sender.Send(request);
Console.WriteLine("REQUEST: Sent request '{0}'", messageBody);
Message response = receiver.Receive();
receiver.Accept(response);
Console.WriteLine("REQUEST: Received response '{0}'", response.Body);
}
finally
{
conn.Close();
}
}
/// <summary>
/// Method for transactional sending of messages
/// </summary>
/// <param name="sender">sender link</param>
/// <param name="options">options</param>
private void TransactionSend(SenderLink sender, SenderOptions options)
{
int nSent = 0;
bool txFlag = true;
Message message;
while (txFlag && options.TxSize > 0)
{
using (var txs = new TransactionScope(TransactionScopeOption.RequiresNew))
{
for (int i = 0; i < options.TxSize; i++)
{
message = CreateMessage(options, nSent);
if ((options.Duration > 0) && (options.DurationMode == "before-send"))
{
Utils.Sleep4Next(this.ts, options.MsgCount, (options.Duration), nSent + 1);
}
sender.Send(message, options.Timeout);
if ((options.Duration > 0) && (options.DurationMode == "after-send-before-tx-action"))
{
Utils.Sleep4Next(this.ts, options.MsgCount, (options.Duration), nSent + 1);
}
Formatter.LogMessage(message, options);
nSent++;
}
if (options.TxAction.ToLower() == "commit")
{
txs.Complete();
}
if ((options.Duration > 0) && (options.DurationMode == "after-send-after-tx-action"))
{
Utils.Sleep4Next(ts, options.MsgCount, (options.Duration), nSent);
}
}
//set up tx_batch_flag
if ((options.MsgCount - nSent) < options.TxSize)
{
txFlag = false;
}
}
//rest of messages
using (var txs = new TransactionScope(TransactionScopeOption.RequiresNew))
{
while (nSent < options.MsgCount)
{
message = CreateMessage(options, nSent);
sender.Send(message, options.Timeout);
Formatter.LogMessage(message, options);
nSent++;
}
if (options.TxLoopendAction.ToLower() == "commit")
{
txs.Complete();
}
}
}
protected async Task OnMessageCallbackAsync(IReceiverLink receiver, Message message)
{
var messageTypeName = message.ApplicationProperties[Constants.MESSAGE_TYPE_KEY] as string;
var properties = new Dictionary <string, object> {
["CorrelationId"] = message.Properties.CorrelationId,
["MessageId"] = message.Properties.MessageId,
["MessageType"] = messageTypeName
};
// if message has correlationId, set it so that handling can be found by initial correlation
if (!string.IsNullOrWhiteSpace(message.Properties.CorrelationId))
{
CorrelationContext.SetCorrelationId(message.Properties.CorrelationId);
}
var timer = new Stopwatch();
timer.Start();
using (Logger.BeginScope(properties)) {
Logger.LogInformation($"Received message {message.Properties.MessageId}");
try {
string body = DomainEventMessage.GetBody(message);
Logger.LogTrace("Received message {MessageId} with body: {MessageBody}", message.Properties.MessageId, body);
Logger.LogDebug($"Event type key: {messageTypeName}");
if (!EventTypeLookup.ContainsKey(messageTypeName))
{
Logger.LogError($"Message {message.Properties.MessageId} rejected because message type was not registered for type {messageTypeName}");
receiver.Reject(message);
return;
}
var dataType = EventTypeLookup[messageTypeName];
Logger.LogDebug($"Event type: {dataType}");
var handlerType = typeof(IDomainEventHandler <>).MakeGenericType(dataType);
Logger.LogDebug($"Event type handler interface: {handlerType}");
var handler = Provider.GetService(handlerType);
if (handler == null)
{
Logger.LogError($"Message {message.Properties.MessageId} rejected because handler was not found for type {messageTypeName}");
receiver.Reject(message);
return;
}
Logger.LogDebug($"Event type handler: {handler.GetType()}");
dynamic domainEvent;
try {
domainEvent = DomainEventMessage.CreateGenericInstance(dataType, message);
Logger.LogDebug($"Successfully deserialized body to {dataType}");
} catch (Exception ex) {
Logger.LogError(ex, ex.Message);
receiver.Reject(message);
return;
}
HandlerResult result;
dynamic dhandler = handler;
try {
result = await dhandler.HandleAsync(domainEvent).ConfigureAwait(false);
} catch (Exception ex) {
Logger.LogError(ex, $"Message {message.Properties.MessageId} caught unhandled exception {ex.Message}");
result = HandlerResult.Failed;
}
timer.Stop();
var duration = timer.ElapsedMilliseconds;
var dp = new Dictionary <string, object> {
["duration"] = duration
};
using (Logger.BeginScope(dp)) {
Logger.LogInformation($"Handler executed for message {message.Properties.MessageId} and returned result of {result}");
switch (result)
{
case HandlerResult.Success:
receiver.Accept(message);
Logger.LogInformation($"Message {message.Properties.MessageId} accepted");
break;
case HandlerResult.Retry:
var deliveryCount = message.Header.DeliveryCount;
var delay = 10 * deliveryCount;
var scheduleTime = DateTime.UtcNow.AddSeconds(delay);
using (var ts = new TransactionScope()) {
var sender = new SenderLink(Link.Session, Settings.AppName + "-retry", Settings.Queue);
// create a new message to be queued with scheduled delivery time
var retry = new Message(body)
{
Header = message.Header,
Footer = message.Footer,
Properties = message.Properties,
ApplicationProperties = message.ApplicationProperties
};
retry.ApplicationProperties[Constants.SCHEDULED_ENQUEUE_TIME_UTC] = scheduleTime;
sender.Send(retry);
receiver.Accept(message);
}
Logger.LogInformation($"Message {message.Properties.MessageId} requeued with delay of {delay} seconds for {scheduleTime}");
break;
case HandlerResult.Failed:
receiver.Reject(message);
break;
case HandlerResult.Release:
receiver.Release(message);
break;
default:
throw new NotImplementedException($"Unknown HandlerResult value of {result}");
}
}
} catch (Exception ex) {
timer.Stop();
var duration = timer.ElapsedMilliseconds;
var dp = new Dictionary <string, object> {
["duration"] = duration
};
using (Logger.BeginScope(dp)) {
Logger.LogError(ex, $"Message {message.Properties.MessageId} rejected because of unhandled exception {ex.Message}");
receiver.Reject(message);
}
}
}
}
async Task PutTokenAsync(Connection connection)
{
var session = new Session(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);
var sasToken = GetSASToken(this.KeyName, this.KeyValue, string.Format("http://{0}/{1}", this.Namespace, this.Entity), TimeSpan.FromMinutes(20));
Trace.WriteLine(TraceLevel.Information, " sas token: {0}", sasToken);
// construct the put-token message
var request = new Message(sasToken);
request.Properties = new Properties();
request.Properties.MessageId = "1";
request.Properties.ReplyTo = cbsClientAddress;
request.ApplicationProperties = new ApplicationProperties();
request.ApplicationProperties["operation"] = "put-token";
request.ApplicationProperties["type"] = "servicebus.windows.net:sastoken";
request.ApplicationProperties["name"] = string.Format("amqp://{0}/{1}", this.Namespace, this.Entity);
await cbsSender.SendAsync(request);
Trace.WriteLine(TraceLevel.Information, " request: {0}", request.Properties);
Trace.WriteLine(TraceLevel.Information, " request: {0}", request.ApplicationProperties);
// receive the response
var response = await cbsReceiver.ReceiveAsync();
if (response == null || 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
await cbsSender.CloseAsync();
await cbsReceiver.CloseAsync();
await session.CloseAsync();
}
public async Task WebSocketSslMutalAuthTest()
{
string testName = "WebSocketSslMutalAuthTest";
string listenAddress = "wss://localhost:18081/" + testName + "/";
Uri uri = new Uri(listenAddress);
X509Certificate2 cert = ContainerHostTests.GetCertificate(StoreLocation.LocalMachine, StoreName.My, "localhost");
string output;
int code = Exec("netsh.exe", string.Format("http show sslcert hostnameport={0}:{1}", uri.Host, uri.Port), out output);
if (code != 0)
{
string args = string.Format("http add sslcert hostnameport={0}:{1} certhash={2} certstorename=MY appid={{{3}}} clientcertnegotiation=enable",
uri.Host, uri.Port, cert.Thumbprint, Guid.NewGuid());
code = Exec("netsh.exe", args, out output);
Assert.AreEqual(0, code, "failed to add ssl cert: " + output);
}
X509Certificate serviceCert = null;
X509Certificate clientCert = null;
ListenerLink listenerLink = null;
var linkProcessor = new TestLinkProcessor();
linkProcessor.SetHandler(a => { listenerLink = a.Link; return(false); });
var host = new ContainerHost(new List <Uri>()
{
uri
}, null, uri.UserInfo);
host.Listeners[0].SASL.EnableExternalMechanism = true;
host.Listeners[0].SSL.ClientCertificateRequired = true;
host.Listeners[0].SSL.CheckCertificateRevocation = true;
host.Listeners[0].SSL.RemoteCertificateValidationCallback = (a, b, c, d) => { clientCert = b; return(true); };
host.RegisterLinkProcessor(linkProcessor);
host.Open();
try
{
ServicePointManager.ServerCertificateValidationCallback = (a, b, c, d) => { serviceCert = b; return(true); };
var wssFactory = new WebSocketTransportFactory();
wssFactory.Options = o =>
{
o.ClientCertificates.Add(ContainerHostTests.GetCertificate(StoreLocation.LocalMachine, StoreName.My, uri.Host));
};
ConnectionFactory connectionFactory = new ConnectionFactory(new TransportProvider[] { wssFactory });
connectionFactory.SASL.Profile = SaslProfile.External;
Connection connection = await connectionFactory.CreateAsync(new Address(listenAddress));
Session session = new Session(connection);
SenderLink sender = new SenderLink(session, "sender-" + testName, "q1");
await sender.SendAsync(new Message("test") { Properties = new Properties()
{
MessageId = testName
} });
await connection.CloseAsync();
Assert.IsTrue(serviceCert != null, "service cert not received");
Assert.IsTrue(clientCert != null, "client cert not received");
Assert.IsTrue(listenerLink != null, "link not attached");
IPrincipal principal = ((ListenerConnection)listenerLink.Session.Connection).Principal;
Assert.IsTrue(principal != null, "connection pricipal is null");
Assert.IsTrue(principal.Identity is X509Identity, "identify should be established by client cert");
}
finally
{
host.Close();
}
}
public TransactionCoordinator(SenderLink senderLink)
{
_senderLink = senderLink;
}
public static void Main(string[] args)
{
Trace.TraceLevel = TraceLevel.Frame;
Trace.TraceListener = (f, a) =>
{
var t = DateTime.Now.ToString("[hh:ss.fff]") + " " + string.Format(f, a);
Console.WriteLine(t);
};
connection = new Connection(amqpAddress, null, new Open()
{
ContainerId = Guid.NewGuid().ToString(),
ChannelMax = 64,
MaxFrameSize = 200,
}, null);
connection.Closed = OnClosed;
session = new Session(connection);
session.Closed = OnClosed;
var linkName = Guid.NewGuid().ToString();
senderLink = new SenderLink(session, linkName, new Attach()
{
Target = new Target()
{
Address = "TestQueue1",
},
//RcvSettleMode = ReceiverSettleMode.Second,
//SndSettleMode = SenderSettleMode.Settled,
}, null);
senderLink.Closed = OnClosed;
for (int i = 0; i < 10; i++)
{
senderLink.Send(CreateMessage(), 5000);
}
senderLink.Close();
linkName = Guid.NewGuid().ToString();
receiverLink = new ReceiverLink(session, linkName, "TestQueue1");
receiverLink.Closed = OnClosed;
receiverLink.SetCredit(1);
var message = receiverLink.Receive(20000);
int receiveCount = 0;
while (message != null)
{
receiveCount++;
//Console.WriteLine(message.Body.GetType());
Console.WriteLine(message.BodySection.GetType());
Console.WriteLine("Receive #{0}. Message = \"{1}\"", receiveCount.ToString(), Encoding.UTF8.GetString(message.GetBody <byte[]>()));
if (receiveCount % 7 == 0)
{
receiverLink.Release(message);
}
else if (receiveCount % 4 == 0)
{
receiverLink.Reject(message);
}
else
{
receiverLink.Accept(message);
}
Thread.Sleep(10000);
message = receiverLink.Receive(20000);
}
receiverLink.Close();
session.Close();
connection.Close();
}
/// <summary>
/// Initialize AMQP connection
/// we are using the connection to send data to Azure Event Hubs
/// Connection information is retreived from the app configuration file
/// </summary>
/// <returns>
/// true when successful
/// false when unsuccessful
/// </returns>
private bool InitAMQPConnection(bool reset)
{
this.IsConnectionReady = false;
if (reset)
{
// If the reset flag is set, we need to kill previous connection
try
{
this.logger.Info("Resetting connection to Azure Event Hub");
this.logger.Info("Closing any existing senderLink, session and connection.");
if (this.sender != null)
{
this.sender.Close();
}
if (this.session != null)
{
this.session.Close();
}
if (this.connection != null)
{
this.connection.Close();
}
}
catch (Exception e)
{
this.logger.Error("Error closing AMQP connection to Azure Event Hub: {0}", e.Message);
}
}
this.logger.Info("Initializing connection to Azure Event Hub");
// Initialize AMQPS connection
try
{
this.connection = new Connection(this.appAMQPAddress);
this.session = new Session(this.connection);
this.sender = new SenderLink(this.session, "send-link", this.appEHTarget);
}
catch (Exception e)
{
this.logger.Error("Error connecting to Azure Event Hub: {0}", e.Message);
if (this.sender != null)
{
this.sender.Close();
}
if (this.session != null)
{
this.session.Close();
}
if (this.connection != null)
{
this.connection.Close();
}
return(false);
}
this.IsConnectionReady = true;
this.logger.Info("Connection to Azure Event Hub initialized.");
return(true);
}
private async void Process()
{
while (!Queue.IsEmpty)
{
LogDebug("Attempting to process queued messages...");
bool success = false;
if (!IsClosed)
{
CFXEnvelope[] messages = Queue.PeekMany(AmqpCFXEndpoint.MaxMessagesPerTransmit.Value);
if (messages != null && messages.Any())
{
try
{
Message msg = AmqpUtilities.MessageFromEnvelopes(messages, AmqpCFXEndpoint.Codec.Value);
SenderLink.Send(msg);
success = true;
}
catch (Exception ex)
{
LogError(ex);
AppLog.Error(ex);
}
if (success)
{
Queue.Dequeue(messages.Length);
}
int remainingCount = Queue.Count;
if (success)
{
LogDebug($"{messages.Length} messages transmitted. {Queue.Count} messages remaining in spool.");
}
else
{
LogDebug($"Messages NOT transmitted. {Queue.Count} messages remaining in spool.");
}
if (remainingCount > 90)
{
LogWarn(string.Format("Warning. Spool has {0} buffered messages.", remainingCount));
}
}
}
else
{
int remainingCount = Queue.Count;
if (remainingCount > 0)
{
LogWarn($"Connection Bad or Error. {Queue.Count} messages remaining in spool.");
}
await Task.Delay(Convert.ToInt32(AmqpCFXEndpoint.ReconnectInterval.Value.TotalMilliseconds));
}
}
lock (this)
{
isProcessing = false;
}
await Task.Yield();
}
//
// Sample invocation: Interop.Spout.exe --broker localhost:5672 --timeout 30 --address my-queue
//
static int Main(string[] args)
{
const int ERROR_SUCCESS = 0;
const int ERROR_OTHER = 2;
int exitCode = ERROR_SUCCESS;
Connection connection = null;
try
{
Options options = new Options(args);
Address address = new Address(options.Url);
connection = new Connection(address);
Session session = new Session(connection);
SenderLink sender = new SenderLink(session, "sender-spout", options.Address);
// TODO: ReplyTo
Stopwatch stopwatch = new Stopwatch();
TimeSpan timespan = new TimeSpan(0, 0, options.Timeout);
stopwatch.Start();
for (int nSent = 0;
(0 == options.Count || nSent < options.Count) &&
(0 == options.Timeout || stopwatch.Elapsed <= timespan);
nSent++)
{
string id = options.Id;
if (id.Equals(""))
{
Guid g = Guid.NewGuid();
id = g.ToString();
}
id += ":" + nSent.ToString();
Message message = new Message(options.Content);
message.Properties = new Properties()
{
MessageId = id
};
sender.Send(message);
if (options.Print)
{
Console.WriteLine("Message(Properties={0}, ApplicationProperties={1}, Body={2}",
message.Properties, message.ApplicationProperties, message.Body);
}
}
sender.Close();
session.Close();
connection.Close();
}
catch (Exception e)
{
Console.WriteLine("Exception {0}.", e);
if (null != connection)
{
connection.Close();
}
exitCode = ERROR_OTHER;
}
return(exitCode);
}
public virtual JObject RequestReply(object message, string subject, string queue, TimeSpan?timeout = null, bool emptyResult = false)
{
JObject res = null;
if (timeout == null)
{
timeout = TimeSpan.FromMilliseconds(3000);
}
var session = new Session(_amqpConnection);
var sender = new SenderLink(session, $"Sender-{Guid.NewGuid().ToString()}", queue);
var replyTo = "";
var receiverAttached = new ManualResetEvent(false);
void OnReceiverAttached(ILink l, Attach a)
{
replyTo = ((Source)a.Source).Address;
receiverAttached.Set();
}
var source = new Source
{
Dynamic = false,
Address = Guid.NewGuid().ToString(),
Capabilities = new Symbol[] { new Symbol("topic") }
};
var receiver = new ReceiverLink(
session, $"Receiver-{Guid.NewGuid().ToString()}", source, OnReceiverAttached);
if (receiverAttached.WaitOne(timeout.Value))
{
var request = new Message(AmqpUtils.SerializeMessage(message))
{
Properties = new Properties
{
Subject = subject,
ReplyTo = replyTo
}
};
sender.Send(request);
sender.Close();
var response = receiver.Receive(timeout.Value);
if (null != response)
{
receiver.Accept(response);
res = AmqpUtils.DeserializeMessage(response.Body);
}
receiver.Close();
session.Close();
if (res != null)
{
return(res);
}
if (emptyResult)
{
return(null);
}
throw new AmqpApiException("AMQP: Receiver timeout receiving response");
}
session.Close();
throw new AmqpApiException("AMQP: Receiver attach timeout");
}
public void Send(Message message)
{
Address address = new Address(opts.Url);
var connection = new Connection(address);
Session session = new Session(connection);
var attach = new Attach()
{
Target = new Target()
{
Address = opts.Queue, Durable = Convert.ToUInt32(opts.Durable)
},
Source = new Source()
};
var sender = new SenderLink(session, "shovel", attach, null);
string rawBody = null;
// Get the body
if (message.Body is string)
{
rawBody = message.Body as string;
}
else if (message.Body is byte[])
{
using (var reader = XmlDictionaryReader.CreateBinaryReader(
new MemoryStream(message.Body as byte[]),
null,
XmlDictionaryReaderQuotas.Max)) {
var doc = new XmlDocument();
doc.Load(reader);
rawBody = doc.InnerText;
}
}
// duplicate message so that original can be ack'd
var m = new Message(rawBody)
{
Header = message.Header,
ApplicationProperties = message.ApplicationProperties,
Properties = message.Properties
};
logger.LogInformation($"publishing message {message.Properties.MessageId} to {opts.Queue} with event type {message.ApplicationProperties[MESSAGE_TYPE_KEY]} with body:\n{rawBody}");
try {
sender.Send(m);
logger.LogInformation($"successfully published message {message.Properties.MessageId}");
} finally {
if (sender.Error != null)
{
logger.LogError($"ERROR: [{sender.Error.Condition}] {sender.Error.Description}");
}
if (!sender.IsClosed)
{
sender.Close(TimeSpan.FromSeconds(5));
}
session.Close();
session.Connection.Close();
}
if (sender.Error != null)
{
throw new AmqpException(sender.Error);
}
}
static void Main(string[] args)
{
// number of queues (subscrubers) to be created
int numQueues = Int32.Parse(args[0]);
// number of broadcast messages to send
int numMessages = Int32.Parse(args[1]);
// number of benchmark subs to identify to sample send/recive speed.
int numBenchmarks = Int32.Parse(args[2]);
// broker URL
String url = (args.Length > 3) ? args[3] : "amqp://localhost:5672";
// topic name
String address = (args.Length > 4) ? args[4] : "orders";
Address peerAddr = new Address(url);
Connection connection = new Connection(peerAddr);
//Connection connection = new Connection(peerAddr, SaslProfile.Anonymous, new Open { ContainerId = null }, null);
Session session = new Session(connection);
ReceiverLink[] receivers = new ReceiverLink[numQueues];
Random random = new Random();
List <int> benchmarkIndicies = new List <int>();
Stopwatch stopwatch = new Stopwatch();
// populate array of random benchmarks, these won't receive broadcast messages
while (benchmarkIndicies.Count < numBenchmarks)
{
int nextRandom = random.Next(0, numQueues - 1);
if (!benchmarkIndicies.Contains(nextRandom))
{
benchmarkIndicies.Add(nextRandom);
}
}
Console.WriteLine("Creating subscribers...");
for (var i = 0; i < numQueues; i++)
{
Console.Write("\rCreating subscriber " + (i + 1) + "/" + numQueues);
if (!benchmarkIndicies.Contains(i))
{
// create general subscribers, listening to broadcast messages and store-specific messages
receivers[i] = new ReceiverLink(session, "sub" + i, CreateSharedDurableSubscriberSource(address, new List <String>()
{
"store=" + i + " OR allstores=true"
}), null);
}
else
{
// create benchmark subscribers, listening for only their store number
receivers[i] = new ReceiverLink(session, "sub" + i, CreateSharedDurableSubscriberSource(address, new List <String>()
{
"store=" + i
}), null);
}
Thread.Sleep(TimeSpan.FromSeconds(.0001));
}
Console.WriteLine("\nDone!");
SenderLink sender = new SenderLink(session, "sender", address);
// send broadcast messages
Console.WriteLine("Sending broadcast messages...");
stopwatch.Start();
for (var i = 0; i < numMessages; i++)
{
Console.Write("\rSending message " + (i + 1) + "/" + numMessages);
Message message = new Message(Guid.NewGuid().ToString());
message.ApplicationProperties = new ApplicationProperties();
message.ApplicationProperties["allstores"] = true;
message.Header = new Header();
message.Header.Durable = true;
try
{
sender.Send(message);
}
catch
{
Console.WriteLine("ERROR sending braodcast message");
}
}
stopwatch.Stop();
Console.WriteLine("\n" + numMessages + " messages broadcasted in " + stopwatch.ElapsedMilliseconds + "ms!");
stopwatch.Reset();
Console.WriteLine("Sending messages to randomly selected benchmark subs...");
// send messages to our random benchmarks, tracking delta between send/receive
benchmarkIndicies.ForEach(i => {
Message benchmarkMessage = new Message("benchmark message " + i);
benchmarkMessage.ApplicationProperties = new ApplicationProperties();
benchmarkMessage.ApplicationProperties["store"] = i;
benchmarkMessage.Header = new Header();
benchmarkMessage.Header.Durable = true;
stopwatch.Start();
sender.Send(benchmarkMessage);
Message receivedMessage = receivers[i].Receive(TimeSpan.FromSeconds(60));
receivers[i].Accept(receivedMessage);
stopwatch.Stop();
Console.WriteLine("Benchmark " + receivers[i].Name + " received: \"" + receivedMessage.Body + "\" in " + stopwatch.ElapsedMilliseconds + "ms!");
stopwatch.Reset();
Thread.Sleep(TimeSpan.FromSeconds(1));
});
Console.WriteLine("Receiving broadcast message from random subs...");
for (var i = 0; i < numMessages; i++)
{
{
int nextRandom = random.Next(0, numQueues - 1);
if (!benchmarkIndicies.Contains(nextRandom))
{
Message receivedMessage = receivers[nextRandom].Receive(TimeSpan.FromSeconds(60));
stopwatch.Start();
receivers[nextRandom].Accept(receivedMessage);
stopwatch.Stop();
Console.WriteLine(receivers[nextRandom].Name + " received broadcast message: \"" + receivedMessage.Body + "\" in " + stopwatch.ElapsedMilliseconds + "ms!");
Thread.Sleep(TimeSpan.FromSeconds(1));
}
}
stopwatch.Reset();
}
}
public static void Main(string[] args)
{
String url = (args.Length > 0) ? args[0] : "amqp://127.0.0.1:5672";
String destination = (args.Length > 1) ? args[1] : "myqueue";
Trace.TraceLevel = TraceLevel.Frame;
Trace.TraceListener = (l, f, a) => Console.WriteLine(
DateTime.Now.ToString("[hh:mm:ss.fff]") + " " + string.Format(f, a));
Address address = new Address(url);
string testName = "TransactedPosting";
int nMsgs = 5;
Connection connection = new Connection(address);
Session session = new Session(connection);
SenderLink sender = new SenderLink(session, "sender-" + testName, destination);
// commit
using (var ts = new TransactionScope())
{
for (int i = 0; i < nMsgs; i++)
{
Message message = new Message("test");
message.Properties = new Properties()
{
MessageId = "commit" + i, GroupId = testName
};
sender.Send(message);
}
ts.Complete();
}
Console.WriteLine("Commit");
// rollback
using (var ts = new TransactionScope())
{
for (int i = nMsgs; i < nMsgs * 2; i++)
{
Message message = new Message("test");
message.Properties = new Properties()
{
MessageId = "rollback" + i, GroupId = testName
};
sender.Send(message); //error connection is closed
}
}
Console.WriteLine("Rollback");
// commit
using (var ts = new TransactionScope())
{
for (int i = 0; i < nMsgs; i++)
{
Message message = new Message("test");
message.Properties = new Properties()
{
MessageId = "commit" + i, GroupId = testName
};
sender.Send(message);
}
ts.Complete();
}
Console.WriteLine("Commit");
//receive
ReceiverLink receiver = new ReceiverLink(session, "receiver-" + testName, destination);
for (int i = 0; i < nMsgs * 2; i++)
{
Message message = receiver.Receive();
Trace.WriteLine(TraceLevel.Information, "receive: {0}", message.Properties.MessageId);
receiver.Accept(message);
}
Console.WriteLine("Received messages");
Message m = receiver.Receive(TimeSpan.FromSeconds(5));
if (m != null)
{
throw new Exception("Broker contains uncommited messages");
}
connection.Close();
}
/// <summary>
/// Performs a direct, point-to-point request/response transaction with another CFX Endpoint.
/// </summary>
/// <param name="targetUri">The network address of the Endpoint to which the request will be sent.
/// May use amqp:// or amqps:// topic (amqps for secure communications).
/// May also include user information (for authentication), as well as a custom TCP port.
/// </param>
/// <param name="request">A CFX envelope containing the request.</param>
/// <returns>A CFX envelope containing the response from the Endpoint.</returns>
public async Task <CFXEnvelope> ExecuteRequestAsync(string targetUri, CFXEnvelope request)
{
CFXEnvelope response = null;
Connection reqConn = null;
Session reqSession = null;
ReceiverLink receiver = null;
SenderLink sender = null;
Exception ex = null;
Uri targetAddress = new Uri(targetUri);
CurrentRequestTargetUri = targetAddress;
try
{
if (string.IsNullOrWhiteSpace(request.RequestID))
{
request.RequestID = "REQUEST-" + Guid.NewGuid().ToString();
}
if (string.IsNullOrWhiteSpace(request.Source))
{
request.Source = CFXHandle;
}
Message req = AmqpUtilities.MessageFromEnvelope(request, UseCompression.Value);
req.Properties.MessageId = "command-request";
req.Properties.ReplyTo = CFXHandle;
req.ApplicationProperties = new ApplicationProperties();
req.ApplicationProperties["offset"] = 1;
await Task.Run(() =>
{
try
{
ConnectionFactory factory = new ConnectionFactory();
if (targetAddress.Scheme.ToLower() == "amqps")
{
factory.SSL.RemoteCertificateValidationCallback = ValidateRequestServerCertificate;
factory.SASL.Profile = SaslProfile.External;
}
if (string.IsNullOrWhiteSpace(targetAddress.UserInfo))
{
factory.SASL.Profile = SaslProfile.Anonymous;
}
reqConn = factory.CreateAsync(new Address(targetAddress.ToString())).Result;
reqSession = new Session(reqConn);
Attach recvAttach = new Attach()
{
Source = new Source()
{
Address = request.Target
},
Target = new Target()
{
Address = CFXHandle
}
};
receiver = new ReceiverLink(reqSession, "request-receiver", recvAttach, null);
receiver.Start(300);
sender = new SenderLink(reqSession, CFXHandle, request.Target);
sender.Send(req);
Message resp = receiver.Receive(RequestTimeout.Value);
if (resp != null)
{
receiver.Accept(resp);
response = AmqpUtilities.EnvelopeFromMessage(resp);
}
else
{
throw new TimeoutException("A response was not received from target CFX endpoint in the alloted time.");
}
}
catch (Exception ex3)
{
AppLog.Error(ex3);
ex = ex3;
}
});
}
catch (Exception ex2)
{
AppLog.Error(ex2);
if (ex == null)
{
ex = ex2;
}
}
finally
{
if (receiver != null && !receiver.IsClosed)
{
await receiver.CloseAsync();
}
if (sender != null && !sender.IsClosed)
{
await sender.CloseAsync();
}
if (reqSession != null && !reqSession.IsClosed)
{
await reqSession.CloseAsync();
}
if (reqConn != null && !reqConn.IsClosed)
{
await reqConn.CloseAsync();
}
}
if (ex != null)
{
if (ex.InnerException != null)
{
throw ex.InnerException;
}
throw ex;
}
return(response);
}
/// <summary>
/// Main method of sender
/// </summary>
/// <param name="args">args from command line</param>
/// <returns>int status exit code</returns>
public void Run(string[] args)
{
SenderOptions options = new SenderOptions();
try
{
this.ParseArguments(args, options);
//init timestamping
this.ptsdata = Utils.TsInit(options.LogStats);
Utils.TsSnapStore(this.ptsdata, 'B', options.LogStats);
this.SetAddress(options.Url);
this.CreateConnection(options);
Utils.TsSnapStore(this.ptsdata, 'C', options.LogStats);
this.CreateSession();
Utils.TsSnapStore(this.ptsdata, 'D', options.LogStats);
SenderLink sender = this.PrepareSender(options);
//enable transactions
bool tx_batch_flag = String.IsNullOrEmpty(options.TxLoopendAction) ? (options.TxSize > 0) : true;
Stopwatch stopwatch = new Stopwatch();
TimeSpan timespan = options.Timeout;
stopwatch.Start();
this.ts = Utils.GetTime();
Utils.TsSnapStore(this.ptsdata, 'E', options.LogStats);
//sending of messages
if (tx_batch_flag)
{
this.TransactionSend(sender, options);
}
else
{
this.Send(sender, options);
}
if (options.LogStats.IndexOf("endpoints") > -1)
{
Dictionary <string, object> stats = GetSenderStats(sender);
Formatter.PrintStatistics(stats);
}
Utils.TsSnapStore(this.ptsdata, 'F', options.LogStats);
//close-sleep
if (options.CloseSleep > 0)
{
System.Threading.Thread.Sleep(options.CloseSleep);
}
///close connection and link
this.CloseLink(sender);
this.CloseConnection();
Utils.TsSnapStore(this.ptsdata, 'G', options.LogStats);
if (this.ptsdata.Count > 0)
{
Console.WriteLine("STATS " + Utils.TsReport(this.ptsdata, options.MsgCount,
options.Content.Length * sizeof(Char), 0));
}
this.exitCode = ReturnCode.ERROR_SUCCESS;
}
catch (ArgumentException ex)
{
this.ArgumentExceptionHandler(ex, options);
}
catch (Exception ex)
{
this.OtherExceptionHandler(ex, options);
}
finally
{
this.CloseConnection();
}
Environment.Exit(this.exitCode);
}
/// <summary>
/// Tests if the specified network address and AMQP target address is capable of receiving messages published from this endpoint.
/// </summary>
/// <param name="networkAddress">The network address of the target channel.</param>
/// <param name="address">The AMQP target address to which messages will be published.</param>
/// <param name="error">In the case of an error, returns information about the nature of the error.</param>
/// <param name="virtualHostName">The name of the virtual host at the destination endpoint. Default is null for default virtual host. For RabbitMQ broker, use format vhost:MYVHOST</param>
/// <param name="certificate">If secure amqps is being used, this property may optionally include the certificate that will be matched
/// against the server's certificate. Leave null if you do not wish to perform certificate matching (secure communications will still be established
/// using the server's certificate (if using amqps).</param>
/// <returns>A boolean value indicated whether or not the channel is valid.</returns>
public bool TestPublishChannel(Uri networkAddress, string address, out Exception error, string virtualHostName = null, X509Certificate certificate = null)
{
error = null;
Connection conn = null;
Session sess = null;
SenderLink link = null;
Exception ex = null;
try
{
Open o = new Open()
{
ContainerId = Guid.NewGuid().ToString(),
HostName = virtualHostName,
MaxFrameSize = (uint)AmqpCFXEndpoint.MaxFrameSize.Value
};
ConnectionFactory fact = new ConnectionFactory();
if (string.IsNullOrWhiteSpace(networkAddress.UserInfo))
{
fact.SASL.Profile = SaslProfile.Anonymous;
}
if (networkAddress.Scheme.ToUpper() == "AMQPS")
{
LastCertificate = certificate;
LastUri = networkAddress;
fact.SSL.RemoteCertificateValidationCallback = ValidateServerCertificate;
}
Task <Connection> tConn = fact.CreateAsync(new Address(networkAddress.ToString()), o);
tConn.Wait(3000);
if (tConn.Status != TaskStatus.RanToCompletion)
{
throw new Exception("Timeout");
}
conn = tConn.Result;
conn.Closed += (IAmqpObject s, Error e) => { if (e != null)
{
ex = new Exception(e.Description);
}
};
sess = new Session(conn);
sess.Closed += (IAmqpObject s, Error e) => { if (e != null)
{
ex = new Exception(e.Description);
}
};
if (ex != null)
{
throw ex;
}
link = new SenderLink(sess, address, address);
link.Closed += (IAmqpObject s, Error e) => { if (e != null)
{
ex = new Exception(e.Description);
}
};
link.Close();
Task.Delay(10).Wait();
if (ex != null)
{
throw ex;
}
}
catch (Exception ex2)
{
error = ex2;
Debug.WriteLine(ex2.Message);
}
finally
{
if (sess != null && !sess.IsClosed)
{
sess.CloseAsync();
}
if (conn != null && !conn.IsClosed)
{
conn.CloseAsync();
}
}
if (error == null)
{
return(true);
}
return(false);
}
public void ContainerHostCloseTest()
{
string name = "ContainerHostCloseTest";
Uri uri = new Uri("amqp://*****:*****@localhost:15673");
ContainerHost h = new ContainerHost(new List <Uri>()
{
uri
}, null, uri.UserInfo);
h.Open();
h.RegisterMessageProcessor(name, new TestMessageProcessor());
//Create a client to send data to the host message processor
var closedEvent = new ManualResetEvent(false);
var connection = new Connection(new Address(uri.AbsoluteUri));
connection.Closed += (AmqpObject obj, Error error) =>
{
closedEvent.Set();
};
var session = new Session(connection);
var sender = new SenderLink(session, "sender-link", name);
//Send one message while the host is open
sender.Send(new Message("Hello"), SendTimeout);
//Close the host. this should close existing connections
h.Close();
Assert.IsTrue(closedEvent.WaitOne(10000), "connection is not closed after host is closed.");
try
{
sender.Send(new Message("test"));
Assert.IsTrue(false, "exception not thrown");
}
catch (AmqpException exception)
{
Assert.IsTrue(exception.Error != null, "Error is null");
Assert.AreEqual((Symbol)ErrorCode.ConnectionForced, exception.Error.Condition, "Wrong error code");
}
connection.Close();
// Reopen the host and send again
// Use a different port as on some system the port is not released immediately
uri = new Uri("amqp://*****:*****@localhost:15674");
h = new ContainerHost(new List <Uri>()
{
uri
}, null, uri.UserInfo);
h.RegisterMessageProcessor(name, new TestMessageProcessor());
h.Open();
connection = new Connection(new Address(uri.AbsoluteUri));
session = new Session(connection);
sender = new SenderLink(session, "sender-link", name);
sender.Send(new Message("Hello"), SendTimeout);
connection.Close();
h.Close();
}
public void SendWithLinkDetachTest()
{
this.testListener.RegisterTarget(TestPoint.Transfer, (stream, channel, fields) =>
{
// detach the link
TestListener.FRM(stream, 0x16UL, 0, channel, fields[0], true);
return(TestOutcome.Stop);
});
this.testListener.RegisterTarget(TestPoint.Detach, (stream, channel, fields) =>
{
return(TestOutcome.Stop);
});
string testName = "SendWithLinkDetachTest";
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.MessageReleased, (string)exception.Error.Condition);
}
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
}
});
Assert.IsTrue(false, "Send should throw exception");
}
catch (AmqpException exception)
{
Assert.AreEqual(ErrorCode.MessageReleased, (string)exception.Error.Condition);
}
await connection.CloseAsync();
}).Unwrap().GetAwaiter().GetResult();
}
public void TransactedRetiringAndPosting()
{
string testName = "TransactedRetiringAndPosting";
int nMsgs = 10;
Connection connection = new Connection(testTarget.Address);
Session session = new Session(connection);
SenderLink sender = new SenderLink(session, "sender-" + testName, testTarget.Path);
for (int i = 0; i < nMsgs; i++)
{
Message message = new Message("test");
message.Properties = new Properties()
{
MessageId = "msg" + i, GroupId = testName
};
sender.Send(message);
}
ReceiverLink receiver = new ReceiverLink(session, "receiver-" + testName, testTarget.Path);
receiver.SetCredit(2, false);
Message message1 = receiver.Receive();
Message message2 = receiver.Receive();
// ack message1 and send a new message in a txn
using (var ts = new TransactionScope())
{
receiver.Accept(message1);
Message message = new Message("test");
message.Properties = new Properties()
{
MessageId = "msg" + nMsgs, GroupId = testName
};
sender.Send(message);
ts.Complete();
}
// ack message2 and send a new message in a txn but abort the txn
using (var ts = new TransactionScope())
{
receiver.Accept(message2);
Message message = new Message("test");
message.Properties = new Properties()
{
MessageId = "msg" + (nMsgs + 1), GroupId = testName
};
sender.Send(message1);
}
receiver.Release(message2);
// receive all messages. should see the effect of the first txn
receiver.SetCredit(nMsgs, false);
for (int i = 1; i <= nMsgs; i++)
{
Message message = receiver.Receive();
Trace.WriteLine(TraceLevel.Information, "receive: {0}", message.Properties.MessageId);
receiver.Accept(message);
Assert.AreEqual("msg" + i, message.Properties.MessageId);
}
connection.Close();
}
void GetSampleAndSendAmqpMessage(SenderLink sender)
{
// Obtain the last sample as gathered by the background thread
// Interlocked.Exchange guarantees that changes are done atomically between main and background thread
var sample = Interlocked.Exchange(ref lastDataSample, null);
// No new sample since we checked last time: don't send anything
if (sample == null)
{
return;
}
Message message = new Message();
message.Properties = new Properties()
{
Subject = AppSubject, // Message type defined in App.config file for sensor
CreationTime = DateTime.UtcNow, // Time of data sampling
};
message.MessageAnnotations = new MessageAnnotations();
// Event Hub partition key: device id - ensures that all messages from this device go to the same partition and thus preserve order/co-location at processing time
message.MessageAnnotations[new Symbol("x-opt-partition-key")] = deviceId;
message.ApplicationProperties = new ApplicationProperties();
message.ApplicationProperties["time"] = message.Properties.CreationTime;
message.ApplicationProperties["from"] = deviceId; // Originating device
message.ApplicationProperties["dspl"] = AppDeviceDisplayName; // Display name for originating device
if (sample != null && sample.Count > 0)
{
#if !SENDAPPPROPERTIES
var outDictionary = new Dictionary <string, object>(sample);
outDictionary["Subject"] = message.Properties.Subject; // Message Type
outDictionary["time"] = message.Properties.CreationTime;
outDictionary["from"] = deviceId; // Originating device
outDictionary["dspl"] = AppDeviceDisplayName; // Display name for originating device
message.Properties.ContentType = "text/json";
message.Body = new Data()
{
Binary = Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(outDictionary))
};
#else
foreach (var sampleProperty in sample)
{
message.ApplicationProperties [sample.Key] = sample.Value;
}
#endif
}
else
{
// No data: send an empty message with message type "weather error" to help diagnose problems "from the cloud"
message.Properties.Subject = "wthrerr";
}
sender.Send(message, SendOutcome, null); // Send to the cloud asynchronously
#if LOG_MESSAGE_RATE
if (g_messageCount >= 500)
{
float secondsElapsed = ((float)stopWatch.ElapsedMilliseconds) / (float)1000.0;
if (secondsElapsed > 0)
{
Console.WriteLine("Message rate: {0} msg/s", g_messageCount / secondsElapsed);
g_messageCount = 0;
stopWatch.Restart();
}
}
#endif
}
public void TestMethod_ModifyMessage()
{
string testName = "ModifyMessage";
const int nMsgs = 20;
Connection connection = new Connection(testTarget.Address);
Session session = new Session(connection);
SenderLink sender = new SenderLink(session, "sender-" + testName, testTarget.Path);
for (int i = 0; i < nMsgs; ++i)
{
Message message = new Message();
message.MessageAnnotations = new MessageAnnotations();
message.MessageAnnotations[(Symbol)"a1"] = 12345L;
message.Properties = new Properties()
{
MessageId = "msg" + i
};
message.ApplicationProperties = new ApplicationProperties();
message.ApplicationProperties["sn"] = i;
sender.Send(message, null, null);
}
ReceiverLink receiver = new ReceiverLink(session, "receiver-" + testName, testTarget.Path);
for (int i = 0; i < nMsgs; ++i)
{
Message message = receiver.Receive();
Trace.WriteLine(TraceLevel.Verbose, "receive: {0}", message.Properties.MessageId);
if (i % 2 == 0)
{
receiver.Accept(message);
}
else
{
receiver.Modify(message, true, false, new Fields()
{
{ (Symbol)"reason", "app offline" }
});
}
}
receiver.Close();
ReceiverLink receiver2 = new ReceiverLink(session, "receiver2-" + testName, testTarget.Path);
for (int i = 0; i < nMsgs / 2; ++i)
{
Message message = receiver2.Receive();
Trace.WriteLine(TraceLevel.Verbose, "receive: {0}", message.Properties.MessageId);
Assert.IsTrue(message.Header != null, "header is null");
Assert.IsTrue(message.Header.DeliveryCount > 0, "delivery-count is 0");
Assert.IsTrue(message.MessageAnnotations != null, "annotation is null");
Assert.IsTrue(message.MessageAnnotations[(Symbol)"a1"].Equals(12345L));
Assert.IsTrue(message.MessageAnnotations[(Symbol)"reason"].Equals("app offline"));
receiver2.Accept(message);
}
receiver2.Close();
sender.Close();
session.Close();
connection.Close();
}
/// <summary>
///
/// </summary>
/// <param name="deviceId"></param>
public void SendEvent(string deviceId)
{
string to = Fx.Format("/devices/{0}/messages/events", deviceId);
string audience = Fx.Format("{0}/devices/{1}", IoThubURI, deviceId);
Fx.Format($"{0}/devices/{1}", IoThubURI, deviceId);
string sasToken = "SharedAccessSignature sr=IoTHubCookBook.azure-devices.net&sig=hU2tQbo1aYnFfGC8ctSfifeIV677KKlWpnCS%2F05SMxY%3D&se=1531101825&skn=iothubowner";
bool cbs = PutCbsToken(_connection, sasToken, audience);
if (cbs)
{
_session = new Session(_connection);
}
SenderLink senderevent = new SenderLink(_session, "senderevent", to);
double avgWindSpeed = 10; // m/s
Random rand = new Random();
int i = 0;
while (i < 10)
{
var currentWindSpeed = avgWindSpeed + rand.NextDouble() * 4 - 2;
var telemetryDataPoint = new
{
deviceId,
windSpeed = currentWindSpeed,
highTemp = rand.Next(45, 95),
lowtemp = rand.Next(-5, 25),
latitude = "17.5122560",
longitude = "70.7760470"
};
var json = JsonConvert.SerializeObject(telemetryDataPoint);
var messageValue = Encoding.UTF8.GetBytes(json);
var telemetryMessage = new Message()
{
BodySection = new Data()
{
Binary = messageValue
}
};
telemetryMessage.Properties = new Properties();
telemetryMessage.Properties.To = to;
telemetryMessage.Properties.MessageId = Guid.NewGuid().ToString();
telemetryMessage.ApplicationProperties = new ApplicationProperties();
senderevent.Send(telemetryMessage);
System.Threading.Thread.Sleep(5000);
i++;
}
senderevent.Close();
}
//
// Sample invocation: Interop.Client amqp://guest:guest@localhost:5672 [loopcount]
//
static int Main(string[] args)
{
String url = "amqp://*****:*****@localhost:5672";
String requestQueueName = "service_queue";
int loopcount = 1;
if (args.Length > 0)
{
url = args[0];
}
if (args.Length > 1)
{
loopcount = Convert.ToInt32(args[1]);
}
Connection.DisableServerCertValidation = true;
// uncomment the following to write frame traces
//Trace.TraceLevel = TraceLevel.Frame;
//Trace.TraceListener = (f, a) => Console.WriteLine(DateTime.Now.ToString("[hh:mm:ss.fff]") + " " + string.Format(f, a));
Connection connection = null;
try
{
Address address = new Address(url);
connection = new Connection(address);
Session session = new Session(connection);
// Sender attaches to fixed request queue name
SenderLink sender = new SenderLink(session, "Interop.Client-sender", requestQueueName);
// Receiver attaches to dynamic address.
// Discover its name when it attaches.
String replyTo = "";
ManualResetEvent receiverAttached = new ManualResetEvent(false);
OnAttached onReceiverAttached = (l, a) =>
{
replyTo = ((Source)a.Source).Address;
receiverAttached.Set();
};
// Create receiver and wait for it to attach.
ReceiverLink receiver = new ReceiverLink(
session, "Interop.Client-receiver", new Source()
{
Dynamic = true
}, onReceiverAttached);
if (receiverAttached.WaitOne(10000))
{
// Receiver is attached.
// Send a series of requests, gather and print responses.
String[] requests = new String[] {
"Twas brillig, and the slithy toves",
"Did gire and gymble in the wabe.",
"All mimsy were the borogoves,",
"And the mome raths outgrabe."
};
for (int j = 0; j < loopcount; j++)
{
Console.WriteLine("Pass {0}", j);
for (int i = 0; i < requests.Length; i++)
{
Message request = new Message(requests[i]);
request.Properties = new Properties()
{
MessageId = "request" + i, ReplyTo = replyTo
};
sender.Send(request);
Message response = receiver.Receive(10000);
if (null != response)
{
receiver.Accept(response);
Console.WriteLine("Processed request: {0} -> {1}",
GetContent(request), GetContent(response));
}
else
{
Console.WriteLine("Receiver timeout receiving response {0}", i);
break;
}
}
}
}
else
{
Console.WriteLine("Receiver attach timeout");
}
receiver.Close();
sender.Close();
session.Close();
connection.Close();
return(0);
}
catch (Exception e)
{
Console.WriteLine("Exception {0}.", e);
if (null != connection)
{
connection.Close();
}
}
return(1);
}
static async Task RunAsync(string address)
{
var serializer = new AmqpSerializer(new PocoContractResolver()
{
PrefixList = new[] { "Serialization.Poco" }
});
try
{
Connection connection = await Connection.Factory.CreateAsync(new Address(address));
Session session = new Session(connection);
SenderLink sender = new SenderLink(session, "sender", "q1");
Shape shape1 = new Circle()
{
Id = Guid.NewGuid(),
Attributes = new Dictionary <string, object>()
{
{ "Time", DateTime.UtcNow },
{ "Source", "amqpnetlite.samples" }
},
Radius = 5.3
};
Console.WriteLine("Sending {0}", shape1);
await sender.SendAsync(new Message()
{
BodySection = new AmqpValue <object>(shape1, serializer)
});
Shape shape2 = new Rectangle()
{
Id = Guid.NewGuid(),
Attributes = new Dictionary <string, object>()
{
{ "Color", new Symbol("blue") },
{ "Line", true }
},
Width = 8,
Height = 10
};
Console.WriteLine("Sending {0}", shape2);
await sender.SendAsync(new Message()
{
BodySection = new AmqpValue <object>(shape2, serializer)
});
await connection.CloseAsync();
}
catch (Exception exception)
{
Console.WriteLine(exception.ToString());
return;
}
try
{
Connection connection = await Connection.Factory.CreateAsync(new Address(address));
Session session = new Session(connection);
ReceiverLink receiver = new ReceiverLink(session, "receiver", "q1");
using (Message message = await receiver.ReceiveAsync())
{
Shape shape = message.GetBody <Shape>(serializer);
Console.WriteLine("Received {0}", shape);
receiver.Accept(message);
}
using (Message message = await receiver.ReceiveAsync())
{
Shape shape = message.GetBody <Shape>(serializer);
Console.WriteLine("Received {0}", shape);
receiver.Accept(message);
}
await connection.CloseAsync();
}
catch (Exception exception)
{
Console.WriteLine(exception.ToString());
}
}
