public void ContainerHostDefaultValueTest()
{
string name = "ContainerHostDefaultValueTest";
this.host.RegisterMessageProcessor(name, new TestMessageProcessor());
Open remoteOpen = null;
Begin remoteBegin = null;
Attach remoteAttach = null;
var connection = new Connection(Address, null, new Open()
{
ContainerId = "c"
}, (c, o) => remoteOpen = o);
var session = new Session(connection, new Begin()
{
NextOutgoingId = 3
}, (s, b) => remoteBegin = b);
var sender1 = new SenderLink(session, "send-link1", new Attach()
{
Role = false, Target = new Target()
{
Address = name
}, Source = new Source()
}, (l, a) => remoteAttach = a);
var sender2 = new SenderLink(session, "send-link2", new Attach()
{
Role = false, Target = new Target()
{
Address = name
}, Source = new Source()
}, (l, a) => remoteAttach = a);
sender1.Send(new Message("m1"));
sender2.Send(new Message("m2"));
session.Close();
connection.Close();
Assert.IsTrue(remoteOpen != null, "remote open not received");
Assert.IsTrue(remoteOpen.MaxFrameSize < uint.MaxValue, "max frame size not set");
Assert.IsTrue(remoteOpen.ChannelMax < ushort.MaxValue, "channel max not set");
Assert.IsTrue(remoteBegin != null, "remote begin not received");
Assert.IsTrue(remoteBegin.IncomingWindow < uint.MaxValue, "incoming window not set");
Assert.IsTrue(remoteBegin.HandleMax < uint.MaxValue, "handle max not set");
Assert.IsTrue(remoteAttach != null, "remote attach not received");
}
public async Task LargeMessageOnMessageCallback()
{
string testName = "LargeMessageOnMessageCallback";
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 = 10 * 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;
sender.Send(message, null, null);
}
ReceiverLink receiver = new ReceiverLink(session, "receiver-" + testName, testTarget.Path);
ManualResetEvent done = new ManualResetEvent(false);
int count = 0;
receiver.Start(30, (link, message) =>
{
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);
if (++count == nMsgs)
{
done.Set();
}
});
Assert.IsTrue(done.WaitOne(120000));
connection.Close();
}
public void TestMethod_RequestResponse()
{
string testName = "RequestResponse";
Connection connection = new Connection(testTarget.Address);
Session session = new Session(connection);
// server app: the request handler
ReceiverLink requestLink = new ReceiverLink(session, "srv.requester-" + testName, testTarget.Path);
requestLink.Start(10, (l, m) =>
{
l.Accept(m);
// got a request, send back a reply
SenderLink sender = new SenderLink(session, "srv.replier-" + testName, m.Properties.ReplyTo);
Message reply = new Message("received");
reply.Properties = new Properties()
{
CorrelationId = m.Properties.MessageId
};
sender.Send(reply, (a, b, c, d) => ((Link)a).Close(TimeSpan.Zero), sender);
});
// client: setup a temp queue and waits for responses
OnAttached onAttached = (l, at) =>
{
// client: sends a request to the request queue, specifies the temp queue as the reply queue
SenderLink sender = new SenderLink(session, "cli.requester-" + testName, testTarget.Path);
Message request = new Message("hello");
request.Properties = new Properties()
{
MessageId = "request1", ReplyTo = ((Source)at.Source).Address
};
sender.Send(request, (a, b, c, d) => ((Link)a).Close(TimeSpan.Zero), sender);
};
ReceiverLink responseLink = new ReceiverLink(session, "cli.responder-" + testName, new Source()
{
Dynamic = true
}, onAttached);
Message response = responseLink.Receive();
Assert.IsTrue(response != null, "no response was received");
responseLink.Accept(response);
requestLink.Close();
responseLink.Close();
session.Close();
connection.Close();
}
public virtual void SendMessage(Message message)
{
if (_senderLink == null || _senderLink.IsClosed || _senderLink.Session.IsClosed)
{
if (_senderLink != null)
{
_senderLink.Detach();
_senderLink.Close();
}
_senderLink = new SenderLink(_session, _clientName + "-sender", _queueName);
}
_senderLink.Send(message);
}
public static void Main(string[] args)
{
string address = "amqp://*****:*****@localhost:5672";
Connection connection = new Connection(new Address(address));
Session session = new Session(connection);
SenderLink sender = new SenderLink(session, "test-sender", "q1");
Message message1 = new Message("Hello AMQP!");
sender.Send(message1);
Console.WriteLine("Message sent into queue q1");
}
void SendRequest(SenderLink sender, string replyTo)
{
Message message = new Message();
message.Properties = new Properties()
{
ReplyTo = replyTo
};
message.Properties.SetCorrelationId(Guid.NewGuid());
message.BodySection = new Data()
{
Binary = this.GetBuffer()
};
sender.Send(message, null, null);
}
public static void ExecLedOn(string deviceId, bool onOrOff)
{
Windows.System.Threading.ThreadPool.RunAsync((workitem) => {
Address address;
Connection connection;
Session session;
address = new Address(HOST, PORT, null, null);
connection = new Connection(address);
session = new Session(connection);
string audience = Fx.Format("{0}/messages/devicebound", HOST);
string resourceUri = Fx.Format("{0}/messages/devicebound", HOST);
string sasToken = GetSharedAccessSignature(SHARED_ACCESS_KEY_NAME, SHARED_ACCESS_KEY, resourceUri, new TimeSpan(1, 0, 0));
bool cbs = PutCbsToken(connection, HOST, sasToken, audience);
if (cbs)
{
string to = Fx.Format("/devices/{0}/messages/devicebound", deviceId);
string entity = "/messages/devicebound";
SenderLink senderLink = new SenderLink(session, "sender-link", entity);
var messageValue = Encoding.UTF8.GetBytes("{\"Name\":\"Toggle" + (onOrOff ? "On" : "Off") + "\",\"Parameters\":{}}");
Message message = new Message()
{
BodySection = new Data()
{
Binary = messageValue
}
};
message.Properties = new Properties();
message.Properties.To = to;
message.Properties.MessageId = Guid.NewGuid().ToString();
message.ApplicationProperties = new ApplicationProperties();
message.ApplicationProperties["iothub-ack"] = "full";
senderLink.Send(message);
senderLink.Close();
}
session.Close();
connection.Close();
});
}
public void TestMethod_ProtocolHandler()
{
string testName = "ProtocolHandler";
int nMsgs = 5;
var handler = new TestHandler(e =>
{
if (e.Id == EventId.SocketConnect)
{
((System.Net.Sockets.Socket)e.Context).SendBufferSize = 4096;
}
else if (e.Id == EventId.SslAuthenticate)
{
((System.Net.Security.SslStream)e.Context).AuthenticateAsClient("localhost");
}
});
Address sslAddress = new Address("amqps://*****:*****@localhost:5671");
Connection connection = new Connection(sslAddress, handler);
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("msg" + i);
message.Properties = new Properties()
{
GroupId = "abcdefg"
};
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.ApplicationProperties["sn"]);
receiver.Accept(message);
}
sender.Close();
receiver.Close();
session.Close();
connection.Close();
}
private static void WorkerThread()
{
try
{
// parse Azure IoT Hub Map settings to AMQP protocol settings
string hostName = HubName + ".azure-devices.net";
string userName = DeviceId + "@sas." + HubName;
string senderAddress = "devices/" + DeviceId + "/messages/events";
string receiverAddress = "devices/" + DeviceId + "/messages/deviceBound";
var connection = new Connection(new Address(hostName, 5671, userName, SasToken));
var session = new Session(connection);
var sender = new SenderLink(session, "send-link", senderAddress);
var receiver = new ReceiverLink(session, "receive-link", receiverAddress);
receiver.Start(100, OnMessage);
while (true)
{
// update the location data
Console.WriteLine("Update location data");
UpdateMockDestination();
Console.WriteLine("Create payload");
string messagePayload = $"{{\"Latitude\":{latitude},\"Longitude\":{longitude}}}";
// compose message
Console.WriteLine("Create message");
Message message = new Message(Encoding.UTF8.GetBytes(messagePayload));
message.ApplicationProperties = new Amqp.Framing.ApplicationProperties();
// send message with the new Lat/Lon
Console.WriteLine("Send message");
sender.Send(message, null, null);
// data sent
Console.WriteLine($"*** DATA SENT - Lat - {latitude}, Lon - {longitude} ***");
// wait before sending the next position update
Console.WriteLine("Sleep");
Thread.Sleep(2000);
}
}
catch (Exception ex)
{
Console.WriteLine($"-- D2C Error - {ex.Message} --");
}
}
public void publish(string msg)
{
Address address = new Address("amqp://localhost:5672");
Connection connection = new Connection(address);
Session session = new Session(connection);
Message message = new Message("Hello AMQP!");
SenderLink sender = new SenderLink(session, "sender-link", "q1");
sender.Send(message);
sender.Close();
session.Close();
connection.Close();
}
public void TestMethod_ReceiveWaiter()
{
string testName = "ReceiveWaiter";
Connection connection = new Connection(testTarget.Address);
Session session = new Session(connection);
ReceiverLink receiver = new ReceiverLink(session, "receiver-" + testName, testTarget.Path);
#if NETFX || NETFX_CORE
Task t = Task.Run(() =>
{
Message message = receiver.Receive();
Trace.WriteLine(TraceLevel.Verbose, "receive: {0}", message.Properties.MessageId);
receiver.Accept(message);
});
#else
Thread t = new Thread(() =>
{
Message message = receiver.Receive();
Trace.WriteLine(TraceLevel.Verbose, "receive: {0}", message.Properties.MessageId);
receiver.Accept(message);
});
t.Start();
#endif
SenderLink sender = new SenderLink(session, "sender-" + testName, testTarget.Path);
Message msg = new Message()
{
Properties = new Properties()
{
MessageId = "123456"
}
};
sender.Send(msg, null, null);
#if NETFX || NETFX_CORE
t.Wait(10000);
#else
t.Join(10000);
#endif
sender.Close();
receiver.Close();
session.Close();
connection.Close();
}
private static void WorkerThread()
{
// need to wait for network connection...
NetworkHelpers.IpAddressAvailable.WaitOne();
// ... and valid date time
NetworkHelpers.DateTimeAvailable.WaitOne();
// establish connection
Connection connection = new Connection(new Address(hubNamespace, 5672, keyName, keyValue));
// create session
Session session = new Session(connection);
// create a sender link
SenderLink sender = new SenderLink(session, "sender-nanoframework", entity);
while (true)
{
// wait for button press
sendMessage.WaitOne();
// compose message
// json format like: { temp: 23.67 }
Message message = new Message()
{
BodySection = new Data()
{
Binary = Encoding.UTF8.GetBytes($"{{ temp: {temperature.ToString("D2")} }}")
}
};
message.Properties = new Properties()
{
GroupId = "F769I-DISCO"
};
// send message
sender.Send(message);
}
// the loop won't reach here, just kept here for the ceremony
sender.Close();
session.Close();
connection.Close();
}
public AmqpSendTask(SenderLink link, global::Amqp.Message message, DeliveryState deliveryState, long timeoutMillis)
{
if (timeoutMillis != NmsConnectionInfo.INFINITE)
{
this.timer = new Timer(OnTimer, this, timeoutMillis, -1);
}
try
{
link.Send(message, deliveryState, OnOutcome, this);
}
catch (Exception e)
{
this.timer?.Dispose();
this.SetException(ExceptionSupport.Wrap(e));
}
}
public void produce()
{
Address address = new Address(addr);
Connection connection = new Connection(address);
Session session = new Session(connection);
SenderLink sender = new SenderLink(session, "sender", queue);
OutcomeCallback callback = (l, msg, o, s) => {
Interlocked.Increment(ref messagesSent);
Interlocked.Increment(ref totalSent);
};
// This is just to limit the number of messages per second we are sending
TokenBucketLimiterImpl tokens = new TokenBucketLimiterImpl(messagesPerSecond);
Task.Factory.StartNew(() => {
Console.WriteLine("Sending {0} messages...", numberOfMessages);
for (var i = 0; i < numberOfMessages; i++)
{
tokens.limit();
Message message = new Message("a message!" + i);
message.Header = new Header();
message.Header.Durable = true;
// The callback here is to make the sending to happen as fast as possible
sender.Send(message, callback, null);
}
Console.WriteLine(".... Done sending");
}, TaskCreationOptions.LongRunning);
// Trace.TraceLevel = TraceLevel.Verbose | TraceLevel.Error |
// TraceLevel.Frame | TraceLevel.Information | TraceLevel.Warning;
// Trace.TraceListener = (l, f, o) => Console.WriteLine(DateTime.Now.ToString("[hh:mm:ss.fff]") + " " + string.Format(f, o));
// sender.Close();
// Task.Factory.StartNew(() => {
// while (true) {
// Console.WriteLine("Sent " + Interlocked.Read(ref messagesSent) + " on queue " + queue + " producer " + this.name);
// Thread.Sleep(1000);
// }
// }, TaskCreationOptions.LongRunning);
}
public static void SendMessage()
{
Address address = new Address("");
Connection connection = new Connection(address);
Session session = new Session(connection);
Message message = new Message("Hello AMQP!");
SenderLink sender = new SenderLink(session, "sender-link", "q1");
sender.Send(message);
Console.WriteLine("Sent Hello AMQP!");
sender.Close();
session.Close();
connection.Close();
}
static void Main(string[] args)
{
//Address address = new Address("amqp://*****:*****@localhost:5672");
Address address = new Address("amqp://*****:*****@mr22gx8ufrq6kv.messaging.solace.cloud:20876");
Connection connection = new Connection(address);
Session session = new Session(connection);
Message message = new Message("Hello AMQP!");
SenderLink sender = new SenderLink(session, "sender-link", "TransactionQueue");
sender.Send(message);
Console.WriteLine("Sent Hello AMQP!");
sender.Close();
session.Close();
connection.Close();
}
private async Task <bool> SendMessageAmqp(string message)
{
//TODO: figure out if AMQP.NET lite support async method calls
// construct message
var messageValue = Encoding.UTF8.GetBytes(message);
// here, AMQP supports 3 types of body, here we use Data.
var formattedMessage = new Message {
BodySection = new Data {
Binary = messageValue
}
};
_sender.Send(formattedMessage, null, null); // Send the message
// _connection.Close(); // close connection
return(true);
}
public void Send(OutgoingTransportMessage transportMessage, IEnumerable <string> addresses)
{
var messageBuffer = messageEncoder.Encode(transportMessage.Message);
var message = new Message(messageBuffer);
message.Header = new Header();
message.Header.Durable = true;
message.Properties = new Properties();
message.Properties.CreationTime = DateTime.UtcNow;
message.Properties.MessageId = Guid.NewGuid().ToString();
message.Properties.ReplyTo = "TODO";
message.ApplicationProperties = new ApplicationProperties();
message.ApplicationProperties["LightRail.ContentType"] = messageEncoder.ContentType;
message.ApplicationProperties["LightRail.EnclosedMessageTypes"] = string.Join(",", messageMapper.GetEnclosedMessageTypes(transportMessage.Message.GetType()).Distinct());
foreach (var pair in transportMessage.Headers)
{
message.ApplicationProperties[pair.Key] = pair.Value;
}
var connection = new Connection(amqpAddress);
var session = new Session(connection);
// Azure does not support Amqp transactions "The server was unable to process the request; please retry the operation. If the problem persists, please contact your Service Bus administrator and provide the tracking id..TrackingId:583da4f8d58d4fa59dc9521c6f799cb8_GWIN-AN5B307EEHM,TimeStamp:11.7.2014. 7:44:17"
try
{
foreach (var address in addresses)
{
logger.Info("Sending Message {0} to {1}", message.Properties.MessageId, address);
var senderLink = new SenderLink(session, Guid.NewGuid().ToString(), address);
try
{
senderLink.Send(message);
}
finally
{
senderLink.Close();
}
}
}
finally
{
session.Close();
connection.Close();
}
}
static void SendMessages(string scenario, string node, int count, bool partitionKey)
{
Trace.WriteLine(TraceLevel.Information, "Running scenario '{0}'...", scenario);
Trace.WriteLine(TraceLevel.Information, " node: '{0}', message count: {1}, set partition key: {2}", node, count, partitionKey);
Trace.WriteLine(TraceLevel.Information, "Establishing a connection...");
Address address = new Address(sbNamespace, 5671, keyName, keyValue);
Connection connection = new Connection(address);
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, "sender-" + scenario, node);
Trace.WriteLine(TraceLevel.Information, "Sending {0} messages...", count);
for (int i = 0; i < count; i++)
{
Message message = new Message()
{
BodySection = new Data()
{
Binary = Encoding.UTF8.GetBytes("msg" + i)
}
};
message.Properties = new Properties()
{
GroupId = scenario
};
if (partitionKey)
{
message.MessageAnnotations = new MessageAnnotations();
message.MessageAnnotations[new Symbol("x-opt-partition-key")] = "pk:" + i;
}
sender.Send(message);
}
Trace.WriteLine(TraceLevel.Information, "Finished sending. Shutting down...");
Trace.WriteLine(TraceLevel.Information, "");
sender.Close();
session.Close();
connection.Close();
}
public void TestMethod_SendAck()
{
string testName = "SendAck";
const int nMsgs = 20;
Connection connection = new Connection(address);
Session session = new Session(connection);
SenderLink sender = new SenderLink(session, "sender-" + testName, "q1");
ManualResetEvent done = new ManualResetEvent(false);
OutcomeCallback callback = (m, o, s) =>
{
Trace.WriteLine(TraceLevel.Information, "send complete: sn {0} outcome {1}", m.ApplicationProperties["sn"], o.Descriptor.Name);
if ((int)m.ApplicationProperties["sn"] == (nMsgs - 1))
{
done.Set();
}
};
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;
sender.Send(message, callback, null);
}
done.WaitOne(10000, waitExitContext);
ReceiverLink receiver = new ReceiverLink(session, "receiver-" + testName, "q1");
for (int i = 0; i < nMsgs; ++i)
{
Message message = receiver.Receive();
Trace.WriteLine(TraceLevel.Information, "receive: {0}", message.ApplicationProperties["sn"]);
receiver.Accept(message);
}
sender.Close();
receiver.Close();
session.Close();
connection.Close();
}
public void ContainerHostCustomSaslMechanismTest()
{
string name = "ContainerHostCustomSaslMechanismTest";
this.host.Listeners[0].SASL.EnableMechanism(name, SaslProfile.Anonymous);
this.host.RegisterMessageProcessor(name, new TestMessageProcessor());
var factory = new ConnectionFactory();
factory.SASL.Profile = new CustomSaslProfile(name);
var connection = factory.CreateAsync(new Address(Address.Host, Address.Port, null, null, "/", Address.Scheme)).Result;
var session = new Session(connection);
var sender = new SenderLink(session, name, name);
sender.Send(new Message("msg1"), Timeout);
connection.Close();
}
public void TestMethod_ConnectionWithIPAddress()
{
string testName = "ConnectionWithIPAddress";
const int nMsgs = 20;
// If the test target is 'localhost' then verify that '127.0.0.1' also works.
if (testTarget.Address.Host != "localhost")
{
Trace.WriteLine(TraceLevel.Verbose,
"Test {0} skipped. Test target '{1}' is not 'localhost'.",
testName, testTarget.Address.Host);
return;
}
Address address2 = new Address("127.0.0.1", testTarget.Address.Port,
testTarget.Address.User, testTarget.Address.Password,
testTarget.Address.Path, testTarget.Address.Scheme);
Connection connection = new Connection(address2);
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("msg" + i);
message.Properties = new Properties()
{
GroupId = "abcdefg"
};
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.ApplicationProperties["sn"]);
receiver.Accept(message);
}
sender.Close();
receiver.Close();
session.Close();
connection.Close();
}
public void CloseSessionWithDetachTest()
{
this.testListener.RegisterTarget(TestPoint.End, (stream, channel, fields) =>
{
// send a detach
TestListener.FRM(stream, 0x16UL, 0, channel, 0u, true);
return(TestOutcome.Continue);
});
string testName = "CloseSessionWithDetachTest";
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");
sender.Send(new Message("test")
{
Properties = new Properties()
{
MessageId = testName
}
});
session.Close(0);
connection.Close();
Assert.IsTrue(connection.Error == null, "connection has error!" + connection.Error);
}
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");
await sender.SendAsync(new Message("test")
{
Properties = new Properties()
{
MessageId = testName
}
});
session.Close(0);
await connection.CloseAsync();
Assert.IsTrue(connection.Error == null, "connection has error!" + connection.Error);
}).Unwrap().GetAwaiter().GetResult();
}
private 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 Amqp.Message(shareAccessSignature);
request.Properties = new Amqp.Framing.Properties();
request.Properties.MessageId = Guid.NewGuid().ToString();
request.Properties.ReplyTo = cbsReplyToAddress;
request.ApplicationProperties = new Amqp.Framing.ApplicationProperties();
request.ApplicationProperties["operation"] = "put-token";
request.ApplicationProperties["type"] = "azure-devices.net:sastoken";
request.ApplicationProperties["name"] = audience;
cbsSender.Send(request);
// receive the response
var response = cbsReceiver.Receive();
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 != 202 && statusCode != 200) // !Accepted && !OK
{
result = false;
}
}
// the sender/receiver may be kept open for refreshing tokens
cbsSender.Close();
cbsReceiver.Close();
session.Close();
return(result);
}
/// <summary>
/// Send Claim Based Security (CBS) token
/// </summary>
/// <param name="shareAccessSignature">Shared access signature (token) to send</param>
private bool PutCbsToken(string shareAccessSignature)
{
bool result = true;
Session session = new Session(this.factory.Connection);
string cbsClientAddress = "cbs-receiver/123";
var cbsSender = new SenderLink(session, "cbs-sender", "$cbs");
var cbsReceiver = new ReceiverLink(session, cbsClientAddress, "$cbs");
// construct the put-token message
var request = new Message(shareAccessSignature);
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"] = Fx.Format("amqp://{0}/{1}", this.factory.Address.Host, this.entity);
cbsSender.Send(request);
// receive the response
var response = cbsReceiver.Receive();
if (response == null || response.Properties == null || response.ApplicationProperties == null)
{
result = false;
}
else
{
int statusCode = (int)response.ApplicationProperties["status-code"];
//if (statusCode != (int)HttpStatusCode.Accepted && statusCode != (int)HttpStatusCode.OK)
if (statusCode != (int)202 && statusCode != (int)200)
{
result = false;
}
}
// the sender/receiver may be kept open for refreshing tokens
cbsSender.Close();
cbsReceiver.Close();
session.Close();
return(result);
}
public void TestMethod_ReceiveWaiterZero()
{
string testName = "ReceiveWaiterZero";
Connection connection = new Connection(testTarget.Address);
Session session = new Session(connection);
ReceiverLink receiver = new ReceiverLink(session, "receiver-" + testName, testTarget.Path);
Message msg = receiver.Receive(TimeSpan.Zero);
Assert.IsTrue(msg == null);
SenderLink sender = new SenderLink(session, "sender-" + testName, testTarget.Path);
msg = new Message()
{
Properties = new Properties()
{
MessageId = "123456"
}
};
sender.Send(msg, null, null);
for (int i = 0; i < 1000; i++)
{
msg = receiver.Receive(TimeSpan.Zero);
if (msg != null)
{
receiver.Accept(msg);
break;
}
#if NETFX_CORE
System.Threading.Tasks.Task.Delay(10).Wait();
#else
Thread.Sleep(10);
#endif
}
Assert.IsTrue(msg != null, "Message not received");
sender.Close();
receiver.Close();
session.Close();
connection.Close();
}
static void Main(string[] args)
{
//Trace.TraceLevel = TraceLevel.Frame;
//Trace.TraceListener = (f, a) => Console.WriteLine(DateTime.Now.ToString("[hh:ss.fff]") + " " + string.Format(f, a));
string address = "amqps://localhost:5671";
// start a host with custom SSL and SASL settings
Console.WriteLine("Starting server...");
Uri addressUri = new Uri(address);
ContainerHost host = new ContainerHost(addressUri);
var listener = host.Listeners[0];
listener.SSL.Certificate = GetCertificate("localhost");
listener.SSL.ClientCertificateRequired = true;
listener.SSL.RemoteCertificateValidationCallback = ValidateServerCertificate;
listener.SASL.EnableExternalMechanism = true;
host.Open();
Console.WriteLine("Container host is listening on {0}:{1}", addressUri.Host, addressUri.Port);
string messageProcessor = "message_processor";
host.RegisterMessageProcessor(messageProcessor, new MessageProcessor());
Console.WriteLine("Message processor is registered on {0}", messageProcessor);
Console.WriteLine("Starting client...");
ConnectionFactory factory = new ConnectionFactory();
factory.SSL.ClientCertificates.Add(GetCertificate("localhost"));
factory.SSL.RemoteCertificateValidationCallback = ValidateServerCertificate;
factory.SASL.Profile = SaslProfile.External;
Console.WriteLine("Sending message...");
Connection connection = factory.CreateAsync(new Address(address)).Result;
Session session = new Session(connection);
SenderLink sender = new SenderLink(session, "certificate-example-sender", "message_processor");
sender.Send(new Message("hello world"));
sender.Close();
session.Close();
connection.Close();
Console.WriteLine("client done");
host.Close();
Console.WriteLine("server stopped");
}
/// <summary>
/// Simple example building a message and sending it.
///
/// Note: Uses synchronous methods for handling connections, AMQP Lite recommends using Async methods
/// </summary>
private static void Main()
{
// Set up connection settings
var edxUrl = ConfigurationManager.AppSettings["EdxUrl"];
var edxOutbox = ConfigurationManager.AppSettings["EdxOutboxQueue"];
var connection = new Connection(new Address(edxUrl));
var session = new Session(connection);
var outbox = new SenderLink(session, "outbox", edxOutbox);
// App settings
var timeout = int.Parse(ConfigurationManager.AppSettings["TimeoutMs"]);
// Create message
const string content = "Hello world";
var msgId = Guid.NewGuid();
var msg = FluentMessageBuilder
.CreateMessage("myBusinessType", content)
.WithReceiverAddress("endpoint@SERVICE-MYSERVICE")
.WithBusinessMessageId(msgId)
.WithCorrelationId(Guid.NewGuid())
.WithSenderApplication("MyAppName");
try
{
// Send message
Console.WriteLine($"Sending message {content} to {edxUrl} ...");
outbox.Send(msg, TimeSpan.FromMilliseconds(timeout));
Console.WriteLine("Success!");
}
catch (Exception ex)
{
// Error handling
Console.WriteLine(ex);
}
finally
{
// Close all connections
outbox.Close();
session.Close();
connection.Close();
}
}
public void ContainerHostMultiplexingTest()
{
string name = "ContainerHostMultiplexingTest";
this.host.RegisterMessageProcessor(name, new TestMessageProcessor());
int completed = 0;
ManualResetEvent doneEvent = new ManualResetEvent(false);
var connection = new Connection(Address, null, new Open()
{
ContainerId = name
}, null);
for (int i = 0; i < 10; i++)
{
var session = new Session(connection, new Begin()
{
NextOutgoingId = (uint)i
}, null);
for (int j = 0; j < 20; j++)
{
var link = new SenderLink(session, string.Join("-", name, i, j), name);
for (int k = 0; k < 30; k++)
{
link.Send(
new Message()
{
Properties = new Properties()
{
MessageId = string.Join("-", "msg", i, j, k)
}
},
(m, o, s) => { if (Interlocked.Increment(ref completed) >= 10 * 20 * 30)
{
doneEvent.Set();
}
},
null);
}
}
}
Assert.IsTrue(doneEvent.WaitOne(10000), "send not completed in time");
connection.Close();
}
static public void SendEvent(string eventData)
{
string entity = Fx.Format("/devices/{0}/messages/events", DEVICE_ID);
SenderLink senderLink = new SenderLink(session, "sender-link", entity);
var messageValue = Encoding.UTF8.GetBytes(eventData);
Message message = new Message()
{
BodySection = new Data()
{
Binary = messageValue
}
};
senderLink.Send(message);
senderLink.Close();
}
