private void Listen()
{
// real applicaiton needs to implement error handling and recovery
Connection connection = new Connection(new Address(this.address));
Session session = new Session(connection);
SenderLink sender = new SenderLink(session, "send-link", "data");
ReceiverLink receiver = new ReceiverLink(session, "receive-link", "control");
receiver.Start(100, this.OnMessage);
while (true)
{
this.changed.WaitOne();
Message message = new Message();
message.ApplicationProperties = new Amqp.Framing.ApplicationProperties();
message.ApplicationProperties["temperature"] = this.temperature;
sender.Send(message, null, null);
AmqpTrace.WriteLine(TraceLevel.Information, "sent data to monitor");
}
}
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();
}
void Setup()
{
this.connection = new Connection(new Address(address));
this.session = new Session(connection);
Attach recvAttach = new Attach()
{
Source = new Source()
{
Address = "request_processor"
},
Target = new Target()
{
Address = this.replyTo
}
};
this.receiver = new ReceiverLink(session, "request-client-receiver", recvAttach, null);
this.receiver.Start(300);
this.sender = new SenderLink(session, "request-client-sender", "request_processor");
}
private void Open()
{
_session = new Session(_connection);
_session.Closed += (sender, error) =>
{
var exception = new SessionClosedException(error.Description);
foreach (var observer in _observers)
{
observer.OnError(exception);
}
};
var entity = $"/devices/{Id}/messages/events";
_senderLink = new SenderLink(_session, "sender-link", entity);
entity = $"/devices/{Id}/messages/deviceBound";
var receiver = new ReceiverLink(_session, "receiver-link", entity);
receiver.Start(5, OnMessage);
}
public void ReceiveWithLinkDetachTest()
{
this.testListener.RegisterTarget(TestPoint.Flow, (stream, channel, fields) =>
{
// detach link without error. receivers should return null (eof)
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 = "ReceiveWithLinkDetachTest";
Trace.WriteLine(TraceLevel.Information, "sync test");
{
Connection connection = new Connection(this.address);
Session session = new Session(connection);
ReceiverLink receiver = new ReceiverLink(session, "receiver-" + testName, "any");
DateTime dt = DateTime.UtcNow;
var message = receiver.Receive(30000);
Assert.IsTrue(message == null);
connection.Close();
Assert.IsTrue(DateTime.UtcNow.Subtract(dt).TotalMilliseconds < 10000, "receive should return right away");
}
Trace.WriteLine(TraceLevel.Information, "async test");
Task.Factory.StartNew(async() =>
{
Connection connection = await Connection.Factory.CreateAsync(this.address);
Session session = new Session(connection);
ReceiverLink receiver = new ReceiverLink(session, "receiver-" + testName, "any");
DateTime dt = DateTime.UtcNow;
var message = await receiver.ReceiveAsync(30000);
Assert.IsTrue(message == null);
await connection.CloseAsync();
Assert.IsTrue(DateTime.UtcNow.Subtract(dt).TotalMilliseconds < 10000, "receive should return right away");
}).Unwrap().GetAwaiter().GetResult();
}
private static void WorkerThread()
{
// need to wait for network connection...
NetworkHelpers.IpAddressAvailable.WaitOne();
// ... and valid date time
NetworkHelpers.DateTimeAvailable.WaitOne();
// parse Azure IoT Hub Map settings to AMQP protocol settings
string hostName = iotHubName + ".azure-devices.net";
string userName = device + "@sas." + iotHubName;
string senderAddress = "devices/" + device + "/messages/events";
string receiverAddress = "devices/" + device + "/messages/deviceBound";
Connection connection = new Connection(new Address(hostName, 5671, userName, sasToken));
Session session = new Session(connection);
SenderLink sender = new SenderLink(session, "send-link", senderAddress);
ReceiverLink receiver = new ReceiverLink(session, "receive-link", receiverAddress);
receiver.Start(100, OnMessage);
while (true)
{
// wait for button press
sendMessage.WaitOne();
// compose message
Message message = new Message();
message.ApplicationProperties = new Amqp.Framing.ApplicationProperties();
message.ApplicationProperties["temperature"] = temperature;
// send message with temperature
sender.Send(message, null, null);
}
// the loop won't reach here, just kept here for the ceremony
sender.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(TimeSpan.Zero);
connection.Close();
Assert.IsTrue(connection.Error == null, "connection has error!");
}
public async Task BasicSendReceiveAsync()
{
string testName = "BasicSendReceiveAsync";
int nMsgs = 100;
Connection connection = await Connection.Factory.CreateAsync(this.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, GroupId = testName
};
message.ApplicationProperties = new ApplicationProperties();
message.ApplicationProperties["sn"] = i;
await sender.SendAsync(message);
}
ReceiverLink receiver = new ReceiverLink(session, "receiver-" + testName, testTarget.Path);
for (int i = 0; i < nMsgs; ++i)
{
Message message = await receiver.ReceiveAsync();
Trace.WriteLine(TraceLevel.Information, "receive: {0}", message.ApplicationProperties["sn"]);
receiver.Accept(message);
}
await sender.CloseAsync();
await receiver.CloseAsync();
await session.CloseAsync();
await connection.CloseAsync();
}
static void RunRequestClient(string address)
{
Connection connection = new Connection(new Address(address));
Session session = new Session(connection);
string replyTo = "client-reply-to";
Attach recvAttach = new Attach()
{
Source = new Source()
{
Address = "request_processor"
},
Target = new Target()
{
Address = replyTo
}
};
ReceiverLink receiver = new ReceiverLink(session, "request-client-receiver", recvAttach, null);
SenderLink sender = new SenderLink(session, "request-client-sender", "request_processor");
Message request = new Message("hello");
request.Properties = new Properties()
{
MessageId = "request1", ReplyTo = replyTo
};
sender.Send(request, null, null);
Console.WriteLine("Sent request {0} body {1}", request.Properties, request.Body);
Message response = receiver.Receive();
Console.WriteLine("Received response: {0} body {1}", response.Properties, response.Body);
receiver.Accept(response);
receiver.Close();
sender.Close();
session.Close();
connection.Close();
}
static void Main(string[] args)
{
Trace.TraceLevel = TraceLevel.Frame;
Trace.TraceListener = (f, a) =>
System.Diagnostics.Trace.WriteLine(DateTime.Now.ToString("[hh:ss.fff]") + " " + string.Format(f, a));
// Ignore root certificate store and accept all SSL certificates.
Connection.DisableServerCertValidation = true;
var amqpConnection = new Connection(
new Address("amqps://*****:*****@bus001.servicebus.windows.net"))
{
Closed = (sender, error) => { Console.WriteLine("Connection closed"); },
};
var amqpSession = new Session(amqpConnection)
{
Closed = (sender, error) => { Console.WriteLine("Session closed"); }
};
var amqpReceiver = new ReceiverLink(amqpSession,
string.Format("receive-link/{0}/{1}", TopicName, SubscriptionName), // unique name for all links from this client
string.Format("{0}/subscriptions/{1}", TopicName, SubscriptionName)) // Service Bus topic/subscription name
{
Closed = (receiver, error) => { Console.WriteLine("ReceiverLink closed"); }
};
amqpReceiver.Start(1, (receiver, msg) =>
{
Console.WriteLine("Message received:\n\t" + msg.Properties.ToString() + "\n\t" + msg.ApplicationProperties.ToString());
amqpReceiver.Accept(msg);
});
Console.WriteLine("Press ENTER to quit");
Console.ReadLine();
amqpReceiver.Close();
amqpSession.Close();
amqpConnection.Close();
}
public static void Connect()
{
var factory = new ConnectionFactory();
factory.SASL.Profile = SaslProfile.Anonymous;
// If using a self-signed cert in the server, uncomment this line for testing
factory.SSL.RemoteCertificateValidationCallback = (a, b, c, d) => true;
//factory.SSL.CheckCertificateRevocation = false;
try
{
connection = factory.CreateAsync(new Address(amqpServerAddress)).Result;
session = new Session(connection);
clientAddressName = "client-" + Guid.NewGuid().ToString();
Attach recvAttach = new Attach()
{
Source = new Source()
{
Address = "Server"
},
Target = new Target()
{
Address = clientAddressName
}
};
receiver = new ReceiverLink(session, "Link-STC", recvAttach, null);
receiver.Start(300, OnMessageReceived);
sender = new SenderLink(session, "Link-CTS", clientAddressName);
Windows.WriteMainWindowDescriptiveText("Connected.");
}
catch (Exception ex)
{
Windows.WriteMainWindowDescriptiveText(ex.ToString());
}
}
private static async Task SendMessage()
{
var edxUrl = ConfigurationManager.AppSettings["EdxUrl"];
var readQueue = ConfigurationManager.AppSettings["EdxInboxQueue"];
var connection = new Connection(new Address(edxUrl));
var session = new Session(connection);
var inbox = new ReceiverLink(session, "inbox", readQueue);
// App settings
var timeout = int.Parse(ConfigurationManager.AppSettings["TimeoutMs"]);
try
{
var result = await inbox.ReceiveAsync(TimeSpan.FromMilliseconds(timeout));
ToConsole(result); // Print received message
if (result != null)
{
inbox.Accept(result);
Console.WriteLine("Message accepted");
}
}
catch (Exception ex)
{
Console.WriteLine(ex);
}
finally
{
// Close all connections
await inbox.CloseAsync();
await session.CloseAsync();
await connection.CloseAsync();
}
}
public void SetupConnection()
{
string amqpURL = "multicast://*****:*****@localhost:5672";
Connection connection = new Connection(new Address(amqpURL));
MqSession = new Session(connection);
Source source = CreateBasicSource();
source.Address = "MyTopicAddress";
//source.DistributionMode = new Symbol();
source.ExpiryPolicy = new Symbol("never");
source.Durable = 2;
source.DistributionMode = new Symbol("copy");
ReceiverLink receiver = new ReceiverLink(MqSession, "test-subscription", source, null);
receiver.Start(10, OnMessage);
//var msg = receiver.Receive();
//Console.WriteLine("Received: " + msg.Body);
//MqSession.Close();
}
public async Task <IConsumer> CreateAsync(ConsumerConfiguration configuration, CancellationToken cancellationToken)
{
CheckConfiguration(configuration);
cancellationToken.ThrowIfCancellationRequested();
cancellationToken.Register(() => _tcs.TrySetCanceled());
var source = new Source
{
Address = GetAddress(configuration),
Capabilities = GetCapabilities(configuration),
FilterSet = GetFilterSet(configuration.FilterExpression, configuration.NoLocalFilter),
};
var receiverLink = new ReceiverLink(_session, Guid.NewGuid().ToString(), source, OnAttached);
receiverLink.AddClosedCallback(OnClosed);
await _tcs.Task.ConfigureAwait(false);
receiverLink.Closed -= OnClosed;
return(new Consumer(_loggerFactory, receiverLink, _transactionsManager, configuration));
}
public async Task ReceiveFromNonExistingAsync()
{
string testName = "ReceiveFromNonExistingAsync";
Connection connection = await Connection.Factory.CreateAsync(this.testTarget.Address);
Session session = new Session(connection);
ReceiverLink receiver = new ReceiverLink(session, "$explicit:receiver-" + testName, Guid.NewGuid().ToString());
try
{
await receiver.ReceiveAsync();
Assert.IsTrue(false, "Receive should fail with not-found error");
}
catch (AmqpException exception)
{
Assert.AreEqual((Symbol)ErrorCode.NotFound, exception.Error.Condition);
}
await connection.CloseAsync();
}
public void TestMethod_ReceiveFromNonExistingNode()
{
string testName = "ReceiveFromNonExistingNode";
Connection connection = new Connection(testTarget.Address);
Session session = new Session(connection);
ReceiverLink receiver = new ReceiverLink(session, "$explicit:receiver-" + testName, Guid.NewGuid().ToString());
try
{
receiver.Receive();
Assert.IsTrue(false, "receive does not fail");
}
catch (AmqpException exception)
{
Assert.AreEqual((Symbol)ErrorCode.NotFound, exception.Error.Condition);
}
finally
{
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);
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 override BrokeredMessage Receive()
{
if (this.factory.OpenConnection())
{
if (this.session == null)
{
this.session = new Session(this.factory.Connection);
this.link = new ReceiverLink(this.session, "amqp-receive-link " + this.Path, this.Path);
}
this.link.SetCredit(1, false);
Message message = this.link.Receive();
if (message != null)
{
BrokeredMessage brokeredMessage = new BrokeredMessage(message);
// accept message if receive and delete mode
if (this.receiveMode == ReceiveMode.ReceiveAndDelete)
{
this.link.Accept(message);
}
else
{
// get "lock token" and add message to peeked messages collection
// to enable complete or abandon in the future
brokeredMessage.LockToken = new Guid(message.DeliveryTag);
brokeredMessage.Receiver = this;
this.peekedMessages.Add(brokeredMessage.LockToken, message);
}
return(brokeredMessage);
}
return(null);
}
return(null);
}
protected ChangeReceiverBase(IConfiguration config)
{
_topicPrefix = Settings.AMQP_TOPIC_PREFIX(config);
_isAzure = Settings.USE_AZURE_SERVICE_BUS(config);
var protocol = Settings.AMQP_PROTOCOL(config);
var policyName = Settings.AMQP_POLICY_NAME(config);
var policyKey = Settings.AMQP_POLICY_KEY(config);
var namespaceUrl = Settings.AMQP_NAMESPACE_URL(config);
var connStr = $"{protocol}://{policyName}:{policyKey}@{namespaceUrl}/";
var address = new Address(connStr);
var connection = new Connection(address);
var session = new Session(connection);
var topicAddress = GetTopicAddress();
var receiver = new ReceiverLink(session, GetType().Name, topicAddress);
receiver.Start(100, (rec, msg) =>
{
ProcessMessage(rec, msg);
rec.Accept(msg);
});
}
public Consumer(ILoggerFactory loggerFactory, ReceiverLink receiverLink, TransactionsManager transactionsManager, ConsumerConfiguration configuration)
{
_logger = loggerFactory.CreateLogger <Consumer>();
_receiverLink = receiverLink;
_transactionsManager = transactionsManager;
_configuration = configuration;
var channel = Channel.CreateBounded <Message>(configuration.Credit);
_reader = channel.Reader;
_writer = channel.Writer;
_receiverLink.Start(configuration.Credit, (receiver, m) =>
{
var message = new Message(m);
if (_writer.TryWrite(message))
{
Log.MessageBuffered(_logger, message);
}
else
{
Log.FailedToBufferMessage(_logger, message);
}
});
}
private static async void Consumer()
{
try
{
Connection connection = new Connection(new Address("amqp://*****:*****@localhost:5672"));
Session session = new Session(connection);
//ReceiverLink receiver = new ReceiverLink(session, "receiver-link2", "q1");
ReceiverLink receiver = new ReceiverLink(session, "receiver-link2", "topic://q1");
while (true)
{
Message message = await receiver.ReceiveAsync();
Console.WriteLine(message.Body.ToString());
receiver.Accept(message);
}
}
catch (Exception e)
{
Console.WriteLine(e);
throw;
}
}
private void StartReceiverThread(CancellationToken token)
{
Task.Run(async() =>
{
try
{
var audience = $"{_simulator.DefaultEndPoint}/{_simulator.Topic}";
bool cbs = PutCbsToken(_amqpConnection, _simulator.DefaultEndPoint, GetSASKey(), audience);
var receiveLink = new ReceiverLink(_amqpSession, "receive-link", _simulator.Topic);
await _notificationPublisher.PublishAsync(Targets.WebSocket, Channels.Simulator, InstanceId, $"Started Listener Thread on AMQP Listener {_simulator.DefaultEndPoint} on Port {_simulator.DefaultPort} for topic {_simulator.Topic} ");
_listening = true;
while (_listening)
{
if (cbs)
{
try
{
var received = receiveLink.Receive();
if (received != null)
{
receiveLink.Accept(received);
}
}
catch (TaskCanceledException) { }
catch (AmqpException) { }
}
}
receiveLink.Close();
}
catch (Exception ex)
{
}
}, token);
}
public void TestMethod_ReceiveWithFilter()
{
string testName = "ReceiveWithFilter";
Connection connection = new Connection(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, "q1");
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 = "q1", FilterSet = filters
}, null);
Message message2 = receiver.Receive();
receiver.Accept(message2);
sender.Close();
receiver.Close();
session.Close();
connection.Close();
}
public void ReceiveWithConnectionResetTest()
{
this.testListener.RegisterTarget(TestPoint.Flow, (stream, channel, fields) =>
{
stream.Dispose();
return(TestOutcome.Continue);
});
string testName = "ReceiveWithConnectionResetTest";
Trace.WriteLine(TraceLevel.Information, "sync test");
{
Connection connection = new Connection(this.address);
Session session = new Session(connection);
ReceiverLink receiver = new ReceiverLink(session, "receiver-" + testName, "any");
DateTime start = DateTime.UtcNow;
Message message = receiver.Receive();
Assert.IsTrue(message == null);
Assert.IsTrue(DateTime.UtcNow.Subtract(start).TotalMilliseconds < 5000, "Receive call is not cancelled.");
connection.Close();
Assert.AreEqual(ErrorCode.ConnectionForced, (string)connection.Error.Condition);
}
Trace.WriteLine(TraceLevel.Information, "async test");
Task.Factory.StartNew(async() =>
{
Connection connection = await Connection.Factory.CreateAsync(this.address);
Session session = new Session(connection);
ReceiverLink receiver = new ReceiverLink(session, "receiver-" + testName, "any");
DateTime start = DateTime.UtcNow;
Message message = await receiver.ReceiveAsync();
Assert.IsTrue(message == null);
Assert.IsTrue(DateTime.UtcNow.Subtract(start).TotalMilliseconds < 1000, "Receive call is not cancelled.");
await connection.CloseAsync();
Assert.AreEqual(ErrorCode.ConnectionForced, (string)connection.Error.Condition);
}).Unwrap().GetAwaiter().GetResult();
}
public void ReceiveWithNoCreditTest()
{
this.testListener.RegisterTarget(TestPoint.Attach, (stream, channel, fields) =>
{
bool role = !(bool)fields[2];
TestListener.FRM(stream, 0x12UL, 0, channel, fields[0], fields[1], role, fields[3], fields[4], new Source(), new Target());
TestListener.FRM(stream, 0x14UL, 0, channel, fields[1], 0u, new byte[0], 0u, true, false); // transfer
return(TestOutcome.Stop);
});
string testName = "ReceiveWithNoCreditTest";
Trace.WriteLine(TraceLevel.Information, "sync test");
{
ManualResetEvent closed = new ManualResetEvent(false);
Connection connection = new Connection(this.address);
connection.Closed += (s, a) => closed.Set();
Session session = new Session(connection);
ReceiverLink receiver = new ReceiverLink(session, "receiver-" + testName, "any");
Assert.IsTrue(closed.WaitOne(5000), "Connection not closed");
Assert.AreEqual(ErrorCode.TransferLimitExceeded, (string)connection.Error.Condition);
Assert.IsTrue(receiver.IsClosed);
}
Trace.WriteLine(TraceLevel.Information, "async test");
Task.Factory.StartNew(async() =>
{
ManualResetEvent closed = new ManualResetEvent(false);
Connection connection = await Connection.Factory.CreateAsync(this.address);
connection.Closed += (s, a) => closed.Set();
Session session = new Session(connection);
ReceiverLink receiver = new ReceiverLink(session, "receiver-" + testName, "any");
Assert.IsTrue(closed.WaitOne(5000), "Connection not closed");
Assert.AreEqual(ErrorCode.TransferLimitExceeded, (string)connection.Error.Condition);
Assert.IsTrue(receiver.IsClosed);
}).Unwrap().GetAwaiter().GetResult();
}
public async Task CustomTransportConfiguration()
{
string testName = "CustomTransportConfiguration";
ConnectionFactory factory = new ConnectionFactory();
factory.TCP.NoDelay = true;
factory.TCP.SendBufferSize = 16 * 1024;
factory.TCP.SendTimeout = 30000;
factory.SSL.RemoteCertificateValidationCallback = (a, b, c, d) => true;
factory.AMQP.MaxFrameSize = 64 * 1024;
factory.AMQP.HostName = "contoso.com";
factory.AMQP.ContainerId = "container:" + testName;
Address sslAddress = new Address("amqps://*****:*****@127.0.0.1:5671");
Connection connection = await factory.CreateAsync(sslAddress);
Session session = new Session(connection);
SenderLink sender = new SenderLink(session, "sender-" + testName, testTarget.Path);
Message message = new Message("custom transport config");
message.Properties = new Properties()
{
MessageId = testName
};
await sender.SendAsync(message);
ReceiverLink receiver = new ReceiverLink(session, "receiver-" + testName, testTarget.Path);
Message message2 = await receiver.ReceiveAsync();
Assert.IsTrue(message2 != null, "no message received");
receiver.Accept(message2);
await connection.CloseAsync();
}
public void DuplicateLinkNameDifferentRoleTest()
{
string name = MethodInfo.GetCurrentMethod().Name;
this.host.RegisterLinkProcessor(new TestLinkProcessor());
string linkName = "same-link-for-different-role";
var connection = new Connection(Address);
var session1 = new Session(connection);
var sender = new SenderLink(session1, linkName, name);
sender.Send(new Message("msg1"), SendTimeout);
var session2 = new Session(connection);
var receiver = new ReceiverLink(session2, linkName, name);
receiver.SetCredit(2, false);
var message = receiver.Receive();
Assert.IsTrue(message != null, "No message was received");
receiver.Accept(message);
connection.Close();
}
public void ReceiveCommand()
{
string audience = Fx.Format("{0}/messages/servicebound/feedback", IoThubURI);
Fx.Format("{0}/messages/servicebound/feedback", IoThubURI);
string entity = Fx.Format("/devices/{0}/messages/deviceBound", AzureIoTHub.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);
}
ReceiverLink receiveCommand = new ReceiverLink(_session, "receiveCommands", entity);
int i = 0;
while (i < 50)
{
var received = receiveCommand.Receive();
if (received != null)
{
receiveCommand.Accept(received);
var returnString = Encoding.UTF8.GetString(received.GetBody <byte[]>());
Console.WriteLine(returnString);
// process the Command at Device
// Write your code here
}
i++;
}
receiveCommand.Close();
}
void RunOnce(int id)
{
Connection connection = this.CreateConnection(new Address(this.Args.Address));
connection.Closed += (o, e) => this.SetComplete();
Session session = new Session(connection);
Attach attach = new Attach()
{
Source = new Source()
{
Address = this.Args.Node
},
Target = new Target(),
SndSettleMode = this.Args.SenderMode,
RcvSettleMode = this.Args.ReceiverMode
};
ReceiverLink receiver = new ReceiverLink(session, "perf-test-receiver" + id, attach, null);
receiver.Start(
this.Args.Queue,
(r, m) =>
{
r.Accept(m);
m.Dispose();
this.OnComplete();
});
this.Wait();
receiver.Close();
session.Close();
connection.Close();
}
private void ReceiveFeedback()
{
string audience = Fx.Format("{0}/messages/servicebound/feedback", HOST);
string resourceUri = Fx.Format("{0}/messages/servicebound/feedback", 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 entity = "/messages/servicebound/feedback";
ReceiverLink receiveLink = new ReceiverLink(session, "receive-link", entity);
Message received = receiveLink.Receive();
if (received != null)
{
receiveLink.Accept(received);
System.Diagnostics.Debug.WriteLine(Encoding.UTF8.GetString((byte[])received.Body));
}
receiveLink.Close();
}
}
