public void TestMethod_BasicSendReceive()
{
string testName = "BasicSendReceive";
const int nMsgs = 200;
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("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();
}
static void Main(string[] args)
{
string brokerUrl = "amqp://localhost:5672";
string address = "my_queue";
Address brokerAddr = new Address(brokerUrl);
Connection connection = new Connection(brokerAddr);
Session session = new Session(connection);
SenderLink sender = new SenderLink(session, "sender", address);
ReceiverLink receiver = new ReceiverLink(session, "receiver", address);
Message helloOut = new Message("Hello World!");
sender.Send(helloOut);
Message helloIn = receiver.Receive();
receiver.Accept(helloIn);
Console.WriteLine(helloIn.Body.ToString());
receiver.Close();
sender.Close();
session.Close();
connection.Close();
}
public void PerfAtLeastOnceSend()
{
string testName = "PerfAtLeastOnceSend";
Connection connection = new Connection(address);
Session session = new Session(connection);
this.sender = new SenderLink(session, "sender-" + testName, "q1");
this.onOutcome = OnSendComplete;
this.done = new ManualResetEvent(false);
this.totalCount = 1000000;
this.completedCount = 0;
this.initialCount = 300;
this.batchCount = 100;
Trace.TraceLevel = TraceLevel.Information;
var watch = new System.Diagnostics.Stopwatch();
watch.Start();
this.SendMessages(initialCount);
this.done.WaitOne();
watch.Stop();
Trace.WriteLine(TraceLevel.Information, "total: {0}, time: {1}ms", this.totalCount, watch.ElapsedMilliseconds);
connection.Close();
}
/// <summary>
/// Disposes whatever resources that must be disposed
/// </summary>
public void Dispose()
{
if (amqpReceiver != null)
{
amqpReceiver.Close();
}
amqpSession.Close();
amqpConnection.Close();
}
//
// 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;
}
//
// Sample invocation: Interop.Drain.exe --broker localhost:5672 --timeout 30 --address my-queue
//
static int Main(string[] args)
{
const int ERROR_SUCCESS = 0;
const int ERROR_NO_MESSAGE = 1;
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);
ReceiverLink receiver = new ReceiverLink(session, "receiver-drain", options.Address);
int timeout = int.MaxValue;
if (!options.Forever)
timeout = 1000 * options.Timeout;
Message message = new Message();
int nReceived = 0;
receiver.SetCredit(options.InitialCredit);
while ((message = receiver.Receive(timeout)) != null)
{
nReceived++;
if (!options.Quiet)
{
Console.WriteLine("Message(Properties={0}, ApplicationProperties={1}, Body={2}",
message.Properties, message.ApplicationProperties, message.Body);
}
receiver.Accept(message);
if (options.Count > 0 && nReceived == options.Count)
{
break;
}
}
if (message == null)
{
exitCode = ERROR_NO_MESSAGE;
}
receiver.Close();
session.Close();
connection.Close();
}
catch (Exception e)
{
Console.WriteLine("Exception {0}.", e);
if (null != connection)
connection.Close();
exitCode = ERROR_OTHER;
}
return exitCode;
}
static string[] GetPartitions()
{
Trace.WriteLine(TraceLevel.Information, "Retrieving partitions...");
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);
// create a pair of links for request/response
Trace.WriteLine(TraceLevel.Information, "Creating a request and a response link...");
string clientNode = "client-temp-node";
SenderLink sender = new SenderLink(session, "mgmt-sender", "$management");
ReceiverLink receiver = new ReceiverLink(
session,
"mgmt-receiver",
new Attach()
{
Source = new Source() { Address = "$management" },
Target = new Target() { Address = clientNode }
},
null);
Message request = new Message();
request.Properties = new Properties() { MessageId = "request1", ReplyTo = clientNode };
request.ApplicationProperties = new ApplicationProperties();
request.ApplicationProperties["operation"] = "READ";
request.ApplicationProperties["name"] = entity;
request.ApplicationProperties["type"] = "com.microsoft:eventhub";
sender.Send(request, null, null);
Message response = receiver.Receive();
if (response == null)
{
throw new Exception("No response was received.");
}
receiver.Accept(response);
receiver.Close();
sender.Close();
connection.Close();
Trace.WriteLine(TraceLevel.Information, "Partition info {0}", response.Body.ToString());
string[] partitions = (string[])((Map)response.Body)["partition_ids"];
Trace.WriteLine(TraceLevel.Information, "Partitions {0}", string.Join(",", partitions));
Trace.WriteLine(TraceLevel.Information, "");
return partitions;
}
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();
}
}
void ReceiveMessages(int count, string sessionId)
{
Trace.WriteLine(TraceLevel.Information, "Establishing a connection...");
Connection connection = new Connection(this.GetAddress());
Trace.WriteLine(TraceLevel.Information, "Creating a session...");
Session session = new Session(connection);
Trace.WriteLine(TraceLevel.Information, "Accepting a message session '{0}'...", sessionId ?? "<any>");
Map filters = new Map();
filters.Add(new Symbol("com.microsoft:session-filter"), sessionId);
ReceiverLink receiver = new ReceiverLink(
session,
"sessionful-receiver-link",
new Source() { Address = this.Entity, FilterSet = filters },
null);
for (int i = 0; i < count; i++)
{
Message message = receiver.Receive(30000);
if (message == null)
{
break;
}
if (i == 0)
{
Trace.WriteLine(TraceLevel.Information, "Received message from session '{0}'", message.Properties.GroupId);
}
receiver.Accept(message);
}
Trace.WriteLine(TraceLevel.Information, "Finished receiving. Shutting down...");
Trace.WriteLine(TraceLevel.Information, "");
receiver.Close();
session.Close();
connection.Close();
}
static void RunMessageClient(string address)
{
const int nMsgs = 10;
Connection connection = new Connection(new Address(address));
Session session = new Session(connection);
SenderLink sender = new SenderLink(session, "message-client", "message_processor");
for (int i = 0; i < nMsgs; ++i)
{
Message message = new Message("hello");
message.Properties = new Properties() { MessageId = "msg" + i };
message.ApplicationProperties = new ApplicationProperties();
message.ApplicationProperties["sn"] = i;
sender.Send(message);
Console.WriteLine("Sent message {0} body {1}", message.Properties, message.Body);
}
sender.Close();
session.Close();
connection.Close();
}
static void Main(string[] args)
{
//Create host and register message processor
var uri = new Uri(Address);
var host = new ContainerHost(new List<Uri>() { uri }, null, uri.UserInfo);
host.RegisterMessageProcessor(MsgProcName, new MessageProcessor());
host.Open();
//Create client
var connection = new Connection(new Address(Address));
var session = new Session(connection);
var sender = new SenderLink(session, "message-client", MsgProcName);
//Send message with an object of custom type as the body
var person = new Person() { EyeColor = "brown", Height = 175, Weight = 75 };
sender.Send(new Message(person));
sender.Close();
session.Close();
connection.Close();
host.Close();
}
public void ContainerHostMessageProcessorTest()
{
string name = MethodInfo.GetCurrentMethod().Name;
var processor = new TestMessageProcessor();
this.host.RegisterMessageProcessor(name, processor);
int count = 500;
var connection = new Connection(Address);
var session = new Session(connection);
var sender = new SenderLink(session, "send-link", name);
for (int i = 0; i < count; i++)
{
var message = new Message("msg" + i);
message.Properties = new Properties() { GroupId = name };
sender.Send(message, SendTimeout);
}
sender.Close();
session.Close();
connection.Close();
Assert.AreEqual(count, processor.Messages.Count);
for (int i = 0; i < count; i++)
{
var message = processor.Messages[i];
Assert.AreEqual("msg" + i, message.GetBody<string>());
}
}
public void TestMethod_ConnectionFrameSize()
{
string testName = "ConnectionFrameSize";
const int nMsgs = 200;
int frameSize = 4 * 1024;
Connection connection = new Connection(testTarget.Address, null, new Open() { ContainerId = "c1", MaxFrameSize = (uint)frameSize }, null);
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(new string('A', frameSize + (i - nMsgs / 2)));
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();
string value = (string)message.Body;
Trace.WriteLine(TraceLevel.Verbose, "receive: {0}x{1}", value[0], value.Length);
receiver.Accept(message);
}
sender.Close();
receiver.Close();
session.Close();
connection.Close();
}
public void TestMethod_LinkReopen()
{
string testName = "LinkReopen";
Connection connection = new Connection(testTarget.Address);
Session session = new Session(connection);
SenderLink sender = new SenderLink(session, "sender", testTarget.Path);
sender.Send(new Message("test") { Properties = new Properties() { MessageId = testName } });
sender.Close();
sender = new SenderLink(session, "sender", testTarget.Path);
sender.Send(new Message("test2") { Properties = new Properties() { MessageId = testName } });
sender.Close();
ReceiverLink receiver = new ReceiverLink(session, "receiver", testTarget.Path);
for (int i = 1; i <= 2; i++)
{
var m = receiver.Receive();
Assert.IsTrue(m != null, "Didn't receive message " + i);
receiver.Accept(m);
}
session.Close(0);
connection.Close();
Assert.IsTrue(connection.Error == null, "connection has error!");
}
public void TestMethod_LinkCreateClose()
{
Connection connection = new Connection(testTarget.Address);
Session session = new Session(connection);
SenderLink sender = new SenderLink(session, "sender", testTarget.Path);
ReceiverLink receiver = new ReceiverLink(session, "receiver", testTarget.Path);
sender.Close(0);
receiver.Close(0);
session.Close(0);
connection.Close();
Assert.IsTrue(connection.Error == null, "connection has error!");
}
public void TestMethod_SessionCreateClose()
{
Connection connection = new Connection(testTarget.Address);
Session session = new Session(connection);
session.Close(0);
connection.Close();
Assert.IsTrue(connection.Error == null, "connection has error!");
}
public void TestMethod_SendEmptyMessage()
{
string testName = "SendEmptyMessage";
Connection connection = new Connection(testTarget.Address);
Session session = new Session(connection);
SenderLink sender = new SenderLink(session, "sender-" + testName, testTarget.Path);
bool threwArgEx = false;
try
{
sender.Send(new Message());
}
catch (ArgumentException)
{
threwArgEx = true;
}
finally
{
sender.Close();
session.Close();
connection.Close();
}
Assert.IsTrue(threwArgEx, "Should throw an argument exception when sending an empty message.");
}
public void ContainerHostCloseTest()
{
string name = MethodInfo.GetCurrentMethod().Name;
this.host.RegisterMessageProcessor(name, new TestMessageProcessor());
//Create a client to send data to the host message processor
var closedEvent = new ManualResetEvent(false);
var connection = new Connection(Address);
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
this.host.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
this.host = new ContainerHost(new List<Uri>() { Uri }, null, Uri.UserInfo);
this.host.RegisterMessageProcessor(name, new TestMessageProcessor());
this.host.Open();
connection = new Connection(Address);
session = new Session(connection);
sender = new SenderLink(session, "sender-link", name);
sender.Send(new Message("Hello"), SendTimeout);
connection.Close();
}
public void ContainerHostProcessorOrderTest()
{
string name = MethodInfo.GetCurrentMethod().Name;
this.host.RegisterMessageProcessor(name, new TestMessageProcessor());
this.host.RegisterLinkProcessor(new TestLinkProcessor());
int count = 80;
var connection = new Connection(Address);
var session = new Session(connection);
var sender = new SenderLink(session, "send-link", name);
for (int i = 0; i < count; i++)
{
var message = new Message("msg" + i);
message.Properties = new Properties() { GroupId = name };
sender.Send(message, SendTimeout);
}
sender.Close();
sender = new SenderLink(session, "send-link", TestLinkProcessor.Name);
for (int i = 0; i < count; i++)
{
var message = new Message("msg" + i);
message.Properties = new Properties() { GroupId = name };
sender.Send(message, SendTimeout);
}
sender.Close();
session.Close();
connection.Close();
}
public void ContainerHostSessionFlowControlTest()
{
string name = MethodInfo.GetCurrentMethod().Name;
this.host.RegisterMessageProcessor(name, new TestMessageProcessor(500000, null));
// this test assumes that nMsgs is greater than session's window size
int nMsgs = 10000;
var connection = new Connection(Address);
var session = new Session(connection);
var sender = new SenderLink(session, "send-link", name);
for (int i = 0; i < nMsgs; i++)
{
var message = new Message("msg" + i);
message.Properties = new Properties() { GroupId = name };
sender.Send(message, SendTimeout);
}
sender.Close();
session.Close();
connection.Close();
}
public void TestMethod_SynchronousSend()
{
string testName = "SynchronousSend";
Connection connection = new Connection(testTarget.Address);
Session session = new Session(connection);
SenderLink sender = new SenderLink(session, "sender-" + testName, testTarget.Path);
Message message = new Message("hello");
sender.Send(message, 60000);
ReceiverLink receiver = new ReceiverLink(session, "receiver-" + testName, testTarget.Path);
message = receiver.Receive();
Assert.IsTrue(message != null, "no message was received.");
receiver.Accept(message);
sender.Close();
receiver.Close();
session.Close();
connection.Close();
}
public void TestMethod_LinkCloseWithPendingSend()
{
string testName = "LinkCloseWithPendingSend";
Connection connection = new Connection(testTarget.Address);
Session session = new Session(connection);
SenderLink sender = new SenderLink(session, "sender-" + testName, testTarget.Path);
bool cancelled = false;
Message message = new Message("released");
sender.Send(message, (m, o, s) => cancelled = true, null);
sender.Close(0);
// assume that Close is called before connection/link is open so message is still queued in link
// but this is not very reliable, so just do a best effort check
if (cancelled)
{
Trace.WriteLine(TraceLevel.Verbose, "The send was cancelled as expected");
}
else
{
Trace.WriteLine(TraceLevel.Verbose, "The send was not cancelled as expected. This can happen if close call loses the race");
}
try
{
message = new Message("failed");
sender.Send(message, (m, o, s) => cancelled = true, null);
Assert.IsTrue(false, "Send should fail after link is closed");
}
catch (AmqpException exception)
{
Trace.WriteLine(TraceLevel.Verbose, "Caught exception: ", exception.Error);
}
session.Close();
connection.Close();
}
public void TestMethod_ReceiveWithFilter()
{
string testName = "ReceiveWithFilter";
Connection connection = new Connection(testTarget.Address);
Session session = new Session(connection);
Message message = new Message("I can match a filter");
message.Properties = new Properties() { GroupId = "abcdefg" };
message.ApplicationProperties = new ApplicationProperties();
message.ApplicationProperties["sn"] = 100;
SenderLink sender = new SenderLink(session, "sender-" + testName, testTarget.Path);
sender.Send(message, null, null);
// update the filter descriptor and expression according to the broker
Map filters = new Map();
// JMS selector filter: code = 0x0000468C00000004L, symbol="apache.org:selector-filter:string"
filters.Add(new Symbol("f1"), new DescribedValue(new Symbol("apache.org:selector-filter:string"), "sn = 100"));
ReceiverLink receiver = new ReceiverLink(session, "receiver-" + testName, new Source() { Address = testTarget.Path, FilterSet = filters }, null);
Message message2 = receiver.Receive();
receiver.Accept(message2);
sender.Close();
receiver.Close();
session.Close();
connection.Close();
}
public void TestMethod_MessageId()
{
string testName = "MessageId";
Connection connection = new Connection(testTarget.Address);
Session session = new Session(connection);
object[] idList = new object[] { null, "string-id", 20000UL, Guid.NewGuid(), Encoding.UTF8.GetBytes("binary-id") };
SenderLink sender = new SenderLink(session, "sender-" + testName, testTarget.Path);
for (int i = 0; i < idList.Length; ++i)
{
Message message = new Message() { Properties = new Properties() };
message.Properties.SetMessageId(idList[i]);
message.Properties.SetCorrelationId(idList[(i + 2) % idList.Length]);
sender.Send(message, null, null);
}
ReceiverLink receiver = new ReceiverLink(session, "receiver-" + testName, testTarget.Path);
for (int i = 0; i < idList.Length; ++i)
{
Message message = receiver.Receive();
receiver.Accept(message);
Assert.AreEqual(idList[i], message.Properties.GetMessageId());
Assert.AreEqual(idList[(i + 2) % idList.Length], message.Properties.GetCorrelationId());
}
connection.Close();
// invalid types
Properties prop = new Properties();
try
{
prop.SetMessageId(0);
Assert.IsTrue(false, "not a valid identifier type");
}
catch (AmqpException ae)
{
Assert.AreEqual(ErrorCode.NotAllowed, (string)ae.Error.Condition);
}
try
{
prop.SetCorrelationId(new Symbol("symbol"));
Assert.IsTrue(false, "not a valid identifier type");
}
catch (AmqpException ae)
{
Assert.AreEqual(ErrorCode.NotAllowed, (string)ae.Error.Condition);
}
}
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);
ManualResetEvent gotMessage = new ManualResetEvent(false);
Fx.StartThread(() =>
{
Message message = receiver.Receive();
if (message != null)
{
Trace.WriteLine(TraceLevel.Verbose, "receive: {0}", message.Properties.MessageId);
receiver.Accept(message);
gotMessage.Set();
}
});
SenderLink sender = new SenderLink(session, "sender-" + testName, testTarget.Path);
Message msg = new Message() { Properties = new Properties() { MessageId = "123456" } };
sender.Send(msg, null, null);
Assert.IsTrue(gotMessage.WaitOne(5000), "No message was received");
sender.Close();
receiver.Close();
session.Close();
connection.Close();
}
public void ContainerHostRequestProcessorTest()
{
string name = MethodInfo.GetCurrentMethod().Name;
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, SendTimeout);
}
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 TestMethod_DynamicReceiverLink()
{
string testName = "DynamicReceiverLink";
Connection connection = new Connection(testTarget.Address);
Session session = new Session(connection);
string remoteSource = null;
ManualResetEvent attached = new ManualResetEvent(false);
OnAttached onAttached = (link, attach) => { remoteSource = ((Source)attach.Source).Address; attached.Set(); };
ReceiverLink receiver = new ReceiverLink(session, "receiver-" + testName, new Source() { Dynamic = true }, onAttached);
attached.WaitOne(10000);
Assert.IsTrue(remoteSource != null, "dynamic source not attached");
SenderLink sender = new SenderLink(session, "sender-" + testName, remoteSource);
Message message = new Message("hello");
sender.Send(message, 60000);
message = receiver.Receive();
Assert.IsTrue(message != null, "no message was received.");
receiver.Accept(message);
sender.Close();
receiver.Close();
session.Close();
connection.Close();
}
public void ContainerHostUnknownProcessorTest()
{
string name = MethodInfo.GetCurrentMethod().Name;
this.host.RegisterMessageProcessor("message" + name, new TestMessageProcessor());
this.host.RegisterRequestProcessor("request" + name, new TestRequestProcessor());
var connection = new Connection(Address);
var session = new Session(connection);
var sender = new SenderLink(session, "send-link", name);
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.NotFound, exception.Error.Condition, "Wrong error code");
}
sender.Close();
session.Close();
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) => ((Link)c).Close(0), 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) => ((Link)c).Close(0), 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 void TestMethod_DynamicSenderLink()
{
string testName = "DynamicSenderLink";
Connection connection = new Connection(testTarget.Address);
Session session = new Session(connection);
string targetAddress = null;
OnAttached onAttached = (link, attach) =>
{
targetAddress = ((Target)attach.Target).Address;
};
SenderLink sender = new SenderLink(session, "sender-" + testName, new Target() { Dynamic = true }, onAttached);
Message message = new Message("hello");
sender.Send(message, 60000);
Assert.IsTrue(targetAddress != null, "dynamic target not attached");
ReceiverLink receiver = new ReceiverLink(session, "receiver-" + testName, targetAddress);
message = receiver.Receive();
Assert.IsTrue(message != null, "no message was received.");
receiver.Accept(message);
sender.Close();
receiver.Close();
session.Close();
connection.Close();
}
public void TestMethod_AdvancedLinkFlowControl()
{
string testName = "AdvancedLinkFlowControl";
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.Properties = new Properties() { MessageId = "msg" + i };
sender.Send(message, null, null);
}
ReceiverLink receiver = new ReceiverLink(session, "receiver-" + testName, testTarget.Path);
receiver.SetCredit(2, false);
Message m1 = receiver.Receive();
Message m2 = receiver.Receive();
Assert.AreEqual("msg0", m1.Properties.MessageId);
Assert.AreEqual("msg1", m2.Properties.MessageId);
receiver.Accept(m1);
receiver.Accept(m2);
ReceiverLink receiver2 = new ReceiverLink(session, "receiver2-" + testName, testTarget.Path);
receiver2.SetCredit(2, false);
Message m3 = receiver2.Receive();
Message m4 = receiver2.Receive();
Assert.AreEqual("msg2", m3.Properties.MessageId);
Assert.AreEqual("msg3", m4.Properties.MessageId);
receiver2.Accept(m3);
receiver2.Accept(m4);
receiver.SetCredit(4);
for (int i = 4; i < nMsgs; i++)
{
Message m = receiver.Receive();
Assert.AreEqual("msg" + i, m.Properties.MessageId);
receiver.Accept(m);
}
sender.Close();
receiver.Close();
receiver2.Close();
session.Close();
connection.Close();
}
