private MessagingFactory CreateFactory(IEnumerable <Uri> endpoints, IEnumerable <Uri> stsEndpoints, string operationTimeout, string issuerName, string issuerKey, string sasKeyName, string sasKey, string windowsDomain, string windowsUser, SecureString windowsPassword, string oauthDomain, string oauthUser, SecureString oauthPassword, string transportType)
{
MessagingFactory messagingFactory;
try
{
MessagingFactorySettings messagingFactorySetting = new MessagingFactorySettings();
if (!string.IsNullOrWhiteSpace(transportType))
{
messagingFactorySetting.TransportType = (Microsoft.ServiceBus.Messaging.TransportType)Enum.Parse(typeof(Microsoft.ServiceBus.Messaging.TransportType), transportType);
}
messagingFactorySetting.TokenProvider = KeyValueConfigurationManager.CreateTokenProvider(stsEndpoints, issuerName, issuerKey, sasKeyName, sasKey, windowsDomain, windowsUser, windowsPassword, oauthDomain, oauthUser, oauthPassword);
if (!string.IsNullOrEmpty(operationTimeout))
{
messagingFactorySetting.OperationTimeout = TimeSpan.Parse(operationTimeout, CultureInfo.CurrentCulture);
}
messagingFactory = MessagingFactory.Create(endpoints, messagingFactorySetting);
}
catch (ArgumentException argumentException1)
{
ArgumentException argumentException = argumentException1;
throw new ConfigurationErrorsException(SRClient.AppSettingsCreateFactoryWithInvalidConnectionString(argumentException.Message), argumentException);
}
catch (UriFormatException uriFormatException1)
{
UriFormatException uriFormatException = uriFormatException1;
throw new ConfigurationErrorsException(SRClient.AppSettingsCreateFactoryWithInvalidConnectionString(uriFormatException.Message), uriFormatException);
}
return(messagingFactory);
}
public string Get()
{
try
{
// create a parameter object for the messaging factory that configures
// the MSI token provider for Service Bus and use of the AMQP protocol:
MessagingFactorySettings messagingFactorySettings = new MessagingFactorySettings
{
TokenProvider = TokenProvider.CreateManagedServiceIdentityTokenProvider(ServiceAudience.ServiceBusAudience),
TransportType = TransportType.Amqp
};
// create the messaging factory using the namespace endpoint name supplied by the user
MessagingFactory messagingFactory = MessagingFactory.Create($"sb://gordsbus.servicebus.windows.net/",
messagingFactorySettings);
// create a queue client using the queue name supplied by the user
QueueClient queueClient = messagingFactory.CreateQueueClient("fabrictraffic");
queueClient.Send(new BrokeredMessage(Encoding.UTF8.GetBytes("Api hit")));
queueClient.Close();
messagingFactory.Close();
return("All good");
}
catch (Exception ex)
{
return(ex.ToString());
}
}
protected void btnReceive_Click(object sender, EventArgs e)
{
// create a parameter object for the messaging factory that configures
// the MSI token provider for Service Bus and use of the AMQP protocol:
MessagingFactorySettings messagingFactorySettings = new MessagingFactorySettings
{
TokenProvider = TokenProvider.CreateManagedServiceIdentityTokenProvider(ServiceAudience.ServiceBusAudience),
TransportType = TransportType.Amqp
};
// TODO - Remove after backend is patched with the AuthComponent open fix
// https://github.com/Azure/azure-service-bus/issues/136
messagingFactorySettings.AmqpTransportSettings.EnableLinkRedirect = false;
// create the messaging factory using the namespace endpoint name supplied by the user
MessagingFactory messagingFactory = MessagingFactory.Create($"sb://{txtNamespace.Text}/",
messagingFactorySettings);
// create a queue client using the queue name supplied by the user
QueueClient queueClient = messagingFactory.CreateQueueClient(txtQueueName.Text, ReceiveMode.ReceiveAndDelete);
// request a readily available message (with a very short wait)
BrokeredMessage msg = queueClient.Receive(TimeSpan.FromSeconds(1));
if (msg != null)
{
// if we got a message, show its contents.
txtReceivedData.Text += $"Seq#:{msg.SequenceNumber} data:{Encoding.UTF8.GetString(msg.GetBody<byte[]>())}{Environment.NewLine}";
}
queueClient.Close();
messagingFactory.Close();
}
public async Task Send100SyncMessages_WhenHandlerThrowsException_DeadLetters()
{
#pragma warning disable 4014
Task.Run(async() =>
#pragma warning restore 4014
{
for (int i = 0; i < 100; i++)
{
await this.sender.Send(new Message {
Bar = i
});
}
});
await this.context.Wait(handlerCalls : 50);
this.context.HandlerCalls.Should().BeInvoked(ntimes: 50);
// Wait a bit in order to let the bus deadletter
await Task.Delay(10000);
MessageReceiver deadLetterReceiver = await MessagingFactory.Create()
.CreateMessageReceiverAsync(QueueClient.FormatDeadLetterPath(ReceiverEndpointName), ReceiveMode.ReceiveAndDelete);
IEnumerable <BrokeredMessage> deadLetteredMessages = await deadLetterReceiver.ReceiveBatchAsync(50);
deadLetteredMessages.Should().HaveCount(50)
.And.OnlyContain(b => b.DeliveryCount == 10);
}
public static void RetrieveMessageFromDeadLetterForSubscription()
{
var receiverFactory = MessagingFactory.Create(
"sb://<NS>.servicebus.windows.net/",
new MessagingFactorySettings
{
TokenProvider = TokenProvider.CreateSharedAccessSignatureTokenProvider("RootManageSharedAccessKey", ""),
NetMessagingTransportSettings = { BatchFlushInterval = new TimeSpan(0, 0, 0) }
});
string data = SubscriptionClient.FormatDeadLetterPath("mrkartopic", "mrkarsub1");
var receiver = receiverFactory.CreateMessageReceiver(data);
receiver.OnMessageAsync(
async message =>
{
var body = message.GetBody <Stream>();
lock (Console.Out)
{
Console.WriteLine("Message ID :" + message.MessageId);
}
await message.CompleteAsync();
},
new OnMessageOptions {
AutoComplete = false, MaxConcurrentCalls = 1
});
}
/// <summary>
/// Initializes a new instance of the <see cref="TopicSender"/> class,
/// automatically creating the given topic if it does not exist.
/// </summary>
protected TopicSender(ServiceBusSettings settings, string topic, RetryStrategy retryStrategy)
{
this.settings = settings;
this.topic = topic;
this.tokenProvider = TokenProvider.CreateSharedSecretTokenProvider(settings.TokenIssuer, settings.TokenAccessKey);
this.serviceUri = ServiceBusEnvironment.CreateServiceUri(settings.ServiceUriScheme, settings.ServiceNamespace, settings.ServicePath);
// TODO: This could be injected.
this.retryPolicy = new RetryPolicy <ServiceBusTransientErrorDetectionStrategy>(retryStrategy);
this.retryPolicy.Retrying +=
(s, e) =>
{
var handler = this.Retrying;
if (handler != null)
{
handler(this, EventArgs.Empty);
}
Trace.TraceWarning("An error occurred in attempt number {1} to send a message: {0}", e.LastException.Message, e.CurrentRetryCount);
};
var factory = MessagingFactory.Create(this.serviceUri, this.tokenProvider);
this.topicClient = factory.CreateTopicClient(this.topic);
}
private static void CreateQueueToRead()
{
TokenProvider tokenProvider = _namespaceManager.Settings.TokenProvider;
if (_namespaceManager.QueueExists("categoryqueue"))
{
MessagingFactory factory = MessagingFactory.Create(_namespaceManager.Address, tokenProvider);
QueueClient catsQueueClient = factory.CreateQueueClient("categoryqueue");
Console.WriteLine("Receiving the Messages from the Queue....");
BrokeredMessage message;
int ctr = 1;
while ((message = catsQueueClient.Receive(new TimeSpan(hours: 0, minutes: 1, seconds: 5))) != null)
{
Console.WriteLine($"Message Received, Sequance: {message.SequenceNumber}, MessageID: {message.MessageId},\nCat: {message.Properties[(ctr++).ToString()]}");
message.Complete();
Console.WriteLine("Processing Message (sleeping).....");
Thread.Sleep(1000);
}
factory.Close();
catsQueueClient.Close();
_namespaceManager.DeleteQueue("categoryqueue");
Console.WriteLine("Finished getting all the data from the queue, Press any key to exit");
}
}
static void SendMessage()
{
TokenProvider tokenProvider = _namespaceManager.Settings.TokenProvider;
if (!_namespaceManager.TopicExists("DataCollectionTopic"))
{
_namespaceManager.CreateTopic("DataCollectionTopic");
if (!_namespaceManager.SubscriptionExists("DataCollectionTopic", "Inventory"))
{
_namespaceManager.CreateSubscription("DataCollectionTopic", "Inventory");
}
if (!_namespaceManager.SubscriptionExists("DataCollectionTopic", "Dashboard"))
{
_namespaceManager.CreateSubscription("DataCollectionTopic", "Dashboard");
}
MessagingFactory factory = MessagingFactory.Create(_namespaceManager.Address, tokenProvider);
BrokeredMessage message = new BrokeredMessage();//can pass a user defined class too
message.Label = "SalesReport";
message.Properties["StoreName"] = "Nike";
message.Properties["MachineID"] = "POS1";
BrokeredMessage message1 = new BrokeredMessage();//can pass a user defined class too
message1.Label = "SalesRep";
message1.Properties["StoreName"] = "Addidas";
message1.Properties["MachineID"] = "POS3";
MessageSender sender = factory.CreateMessageSender("DataCollectionTopic");
sender.Send(message);
sender.Send(message1);
Console.WriteLine("Message Sent Succefully");
}
}
public async Task Run(string namespaceAddress, string queueName, string receiveToken)
{
var receiverFactory = MessagingFactory.Create(
namespaceAddress,
new MessagingFactorySettings
{
TransportType = TransportType.Amqp,
TokenProvider = TokenProvider.CreateSharedAccessSignatureTokenProvider(receiveToken)
});
try
{
var receiver = receiverFactory.CreateMessageReceiver(queueName, ReceiveMode.PeekLock);
try
{
var responder = new RequestReplyResponder(
new Uri(namespaceAddress),
receiver,
async m =>
{
Console.WriteLine("Got {0}", m.Label);
switch (m.Label)
{
case "requestA":
return(new BrokeredMessage
{
Label = "responseA"
});
case "requestB":
return(new BrokeredMessage
{
Label = "responseB"
});
default:
await m.DeadLetterAsync("Unknown", "Unknown Message");
return(null);
}
});
var cts = new CancellationTokenSource();
var runTask = responder.Run(cts.Token);
Console.WriteLine("Press ENTER to stop processing requests.");
Console.ReadLine();
cts.Cancel();
await runTask;
}
finally
{
receiver.Close();
}
}
finally
{
receiverFactory.Close();
}
}
static void Main(string[] args)
{
var messageCount = 0;
var sw = new Stopwatch();
Console.WriteLine("How many messages should I put in the queue?");
if (!int.TryParse(Console.ReadLine(), out messageCount))
{
return;
}
var namespaceMngr = NamespaceManager.CreateFromConnectionString(connectionString);
var mfs = new MessagingFactorySettings();
mfs.TokenProvider = namespaceMngr.Settings.TokenProvider;
mfs.NetMessagingTransportSettings.BatchFlushInterval = batchFlushInterval;
var tasks = new Task[messageCount];
sw.Start();
var mf = MessagingFactory.Create(namespaceMngr.Address, mfs);
Parallel.For(0, messageCount, (i) =>
{
var client = mf.CreateQueueClient(queueName);
var message = new BrokeredMessage($"This is the #{i} test message!");
Console.WriteLine(String.Format($"Message id {message.MessageId} sent ({i})."));
tasks[i] = client.SendAsync(message);
});
Task.WhenAll(tasks);
Console.WriteLine($"{messageCount} messages successfully sent in {sw.ElapsedMilliseconds / 1000} seconds!{Environment.NewLine}Press ENTER to exit the program.");
Console.ReadLine();
}
public WindowsServiceBusMessageReceiver(string queueName, string connectionString, int preFetch = 10)
{
_namespaceManager = NamespaceManager.CreateFromConnectionString(connectionString);
_messagingFactory = MessagingFactory.Create(_namespaceManager.Address, _namespaceManager.Settings.TokenProvider);
_client = QueueClient.CreateFromConnectionString(connectionString, queueName);
PrefetchCount = preFetch;
}
public EventHubsDataPusher(DataPusherConfiguration configuration, IDatasourceRecordSerializer recordSerializer)
{
_recordSerializer = recordSerializer;
_processorCount = Environment.ProcessorCount;
_eventHubClients = new List <EventHubClient>(_processorCount);
var factory = MessagingFactory.Create(
"sb://" + configuration.EventHubNamespace + ".servicebus.windows.net/",
new MessagingFactorySettings
{
TokenProvider =
TokenProvider.CreateSharedAccessSignatureTokenProvider(configuration.EventHubSharedAccessKeyName,
configuration.EventHubSharedAccessKey),
TransportType = TransportType.Amqp,
AmqpTransportSettings = new AmqpTransportSettings()
});
for (var i = 0; i < _processorCount; i++)
{
var newConnnection = factory.CreateEventHubClient(configuration.EventHubPath);
_eventHubClients.Add(newConnnection);
}
Log.DebugFormat("Initialized {0} Event Hub clients", _processorCount);
}
public static async Task SendPatchMessageAsync(Models.ContactDetails contactDetails, Guid customerId, string reqUrl)
{
var tokenProvider = TokenProvider.CreateSharedAccessSignatureTokenProvider(KeyName, AccessKey);
var messagingFactory = MessagingFactory.Create(BaseAddress, tokenProvider);
var sender = messagingFactory.CreateMessageSender(QueueName);
var messageModel = new
{
TitleMessage = "Contact Details record modification for {" + customerId + "} at " + DateTime.UtcNow,
CustomerGuid = customerId,
LastModifiedDate = contactDetails.LastModifiedDate,
URL = reqUrl,
IsNewCustomer = false,
TouchpointId = contactDetails.LastModifiedTouchpointId,
FirstName = contactDetails.FirstName,
LastName = contactDetails.LastName,
ChangeEmailAddress = contactDetails.ChangeEmailAddress ?? null,
IsDigitalAccount = contactDetails.IsDigitalAccount ?? null,
NewEmail = contactDetails.NewEmail,
CurrentEmail = contactDetails.CurrentEmail,
contactDetails.IdentityStoreId
};
var msg = new BrokeredMessage(new MemoryStream(Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(messageModel))))
{
ContentType = "application/json",
MessageId = customerId + " " + DateTime.UtcNow
};
//msg.ForcePersistence = true; Required when we save message to cosmos
await sender.SendAsync(msg);
}
/// <summary>
/// Initializes a new instance of the <see cref="SubscriptionReceiver"/> class,
/// automatically creating the topic and subscription if they don't exist.
/// </summary>
public SubscriptionReceiver(MessagingSettings settings, string topic, string subscription)
{
this.settings = settings;
this.subscription = subscription;
this.tokenProvider = TokenProvider.CreateSharedSecretTokenProvider(settings.TokenIssuer, settings.TokenAccessKey);
this.serviceUri = ServiceBusEnvironment.CreateServiceUri(settings.ServiceUriScheme, settings.ServiceNamespace, settings.ServicePath);
var messagingFactory = MessagingFactory.Create(this.serviceUri, tokenProvider);
this.client = messagingFactory.CreateSubscriptionClient(topic, subscription);
var manager = new NamespaceManager(this.serviceUri, this.tokenProvider);
try
{
manager.CreateTopic(
new TopicDescription(topic)
{
RequiresDuplicateDetection = true,
DuplicateDetectionHistoryTimeWindow = TimeSpan.FromMinutes(30)
});
}
catch (MessagingEntityAlreadyExistsException)
{ }
try
{
manager.CreateSubscription(topic, subscription);
}
catch (MessagingEntityAlreadyExistsException)
{ }
}
public override Task ExecuteAsync()
{
TokenProvider credentials = TokenProvider.CreateSharedSecretTokenProvider(IssuerName, IssuerSecret);
MessagingFactory factory = MessagingFactory.Create(ServiceBusEnvironment.CreateServiceUri("sb", ServiceNamespace, string.Empty), credentials);
QueueClient myQueueClient = factory.CreateQueueClient(QueueName);
//Get the message from the queue
BrokeredMessage message;
while ((message = myQueueClient.Receive(new TimeSpan(0, 0, 5))) != null)
{
RemoteExecutionContext ex = message.GetBody <RemoteExecutionContext>();
Entity pushNotification = (Entity)ex.InputParameters["Target"];
//Make sure Recipient is populated
var ownerId = pushNotification.GetAttributeValue <EntityReference>("lat_recipient").Id.ToString();
var subject = pushNotification.GetAttributeValue <string>("lat_message");
SendNotificationAsync(subject, ownerId);
message.Complete();
}
return(Task.FromResult(true));
}
private void btnQueue_Click(object sender, EventArgs e)
{
var serviceNamespace = "msswit2013relay";
var issuerName = "owner";
var issuerSecret = "IqyIwa7gNjBO89HT+3Vd1CcoBbyibvcv6Hd92J+FtPg=";
Uri uri = ServiceBusEnvironment.CreateServiceUri("sb", serviceNamespace, string.Empty);
TokenProvider tokenProvider = TokenProvider.CreateSharedSecretTokenProvider(issuerName, issuerSecret);
MessagingFactory factory = MessagingFactory.Create(uri, tokenProvider);
var msg = new ServiceBusTestMessage
{
Password = tbPass.Text
};
BrokeredMessage sbMessage = new BrokeredMessage(msg);
sbMessage.Label = "test message";
sbMessage.Properties["login"] = tbLogin.Text;
MessageSender messageSender = factory.CreateMessageSender("MyTopic");
messageSender.Send(sbMessage);
}
public static async Task SendPostMessageAsync(Models.Address address, string reqUrl)
{
var tokenProvider = TokenProvider.CreateSharedAccessSignatureTokenProvider(KeyName, AccessKey);
var messagingFactory = MessagingFactory.Create(BaseAddress, tokenProvider);
var sender = messagingFactory.CreateMessageSender(QueueName);
var messageModel = new MessageModel()
{
TitleMessage = "New Address record {" + address.AddressId + "} added for {" + address.CustomerId + "} at " + DateTime.UtcNow,
CustomerGuid = address.CustomerId,
LastModifiedDate = address.LastModifiedDate,
URL = reqUrl + "/" + address.AddressId,
IsNewCustomer = false,
TouchpointId = address.LastModifiedTouchpointId
};
var msg = new BrokeredMessage(new MemoryStream(Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(messageModel))))
{
ContentType = "application/json",
MessageId = address.CustomerId + " " + DateTime.UtcNow
};
//msg.ForcePersistence = true; Required when we save message to cosmos
await sender.SendAsync(msg);
}
public static MessagingFactory CreateSenderMessagingFactory(
NamespaceManager namespaceManager, ServiceBusConnectionStringBuilder sbConnectionStringBuilder, string entityPath, ServiceBusMessageSenderSettings messageSenderSettings)
{
MessagingFactory messagingFactory = MessagingFactory.Create(
namespaceManager.Address.ToString(),
new MessagingFactorySettings
{
TransportType = TransportType.NetMessaging,
TokenProvider = TokenProvider.CreateSharedAccessSignatureTokenProvider(
sbConnectionStringBuilder.SharedAccessKeyName,
sbConnectionStringBuilder.SharedAccessKey,
TokenTimeToLive),
NetMessagingTransportSettings = new NetMessagingTransportSettings()
{
BatchFlushInterval = TimeSpan.FromMilliseconds(messageSenderSettings.BatchFlushIntervalInMilliSecs)
}
});
TraceHelper.Trace(
TraceEventType.Information,
"CreateSenderMessagingFactory",
"Initialized messaging factory with address {0}",
messagingFactory.Address);
return(messagingFactory);
}
void EnsurePartitionTopicSubscription(TokenProvider tokenProvider, Uri messagingServiceUri, int topicNumber)
{
var topicName = string.Format("{0}_{1}", this.TopicPathPrefix, topicNumber + 1);
try
{
if (!this.namespaceManager.TopicExists(topicName))
{
this.namespaceManager.CreateTopic(topicName);
}
this.messagingFactories.Add(MessagingFactory.Create(messagingServiceUri, tokenProvider));
this.topicClients.Add(this.messagingFactories[topicNumber].CreateTopicClient(topicName));
if (!this.namespaceManager.SubscriptionExists(topicName, this.instanceId))
{
this.namespaceManager.CreateSubscription(topicName, this.instanceId);
}
var subscriptionClient = this.messagingFactories[topicNumber].CreateSubscriptionClient(topicName, this.instanceId, ReceiveMode.ReceiveAndDelete);
subscriptionClient.PrefetchCount = 1;
this.subscriptionClients.Add(subscriptionClient);
this.caches.Add(new ServiceBusMessageBusCache(topicNumber, this.cacheTtl));
}
catch (Exception e)
{
Trace.TraceError("Error managing topic '{0}' with {1}", topicName, e.ToString());
throw;
}
}
public static void Initialize()
{
// Using Http to be friendly with outbound firewalls.
ServiceBusEnvironment.SystemConnectivity.Mode =
ConnectivityMode.Http;
// Create the namespace manager which gives you access to
// management operations.
var namespaceManager = CreateNamespaceManager();
//string connString = ConfigurationSettings.AppSettings["Microsoft.ServiceBus.ConnectionString"];
//QueueClient = QueueClient.CreateFromConnectionString(connString, QueueName);
// Create the queue if it does not exist already.
if (!namespaceManager.QueueExists(QueueName))
{
namespaceManager.CreateQueue(QueueName);
}
// Get a client to the queue.
var messagingFactory = MessagingFactory.Create(
namespaceManager.Address,
namespaceManager.Settings.TokenProvider);
QueueClient = messagingFactory.CreateQueueClient(
QueueName);
if (QueueClient != null)
{
RegisterOnMessageHandlerAndReceiveMessages();
}
}
public async Task <ActionResult> Queue()
{
var result = new List <Account>();
try
{
TokenProvider tokenProvider = TokenProvider.CreateSharedAccessSignatureTokenProvider(DashboardConfig.keyName, DashboardConfig.accessKey);
MessagingFactory messagingFactory = MessagingFactory.Create(DashboardConfig.baseAddress, tokenProvider);
var receiver = await messagingFactory.CreateMessageReceiverAsync(DashboardConfig.queueName, ReceiveMode.ReceiveAndDelete);
while (true)
{
var msg = await receiver.ReceiveAsync(TimeSpan.Zero);
if (msg != null)
{
var serializer = new XmlSerializer(typeof(Account));
var objresult = (Account)serializer.Deserialize(new StreamReader(msg.GetBody <Stream>()));
result.Add(objresult);
}
else
{
break;
}
}
}
catch (Exception)
{
}
return(View(result));
}
public bool SendMessage(BrokeredMessage message)
{
int trycount = 0;
bool success = false;
while (trycount++ < 10)
{
try
{
topic.Send(message);
success = true;
break;
}
catch
{
MessagingFactory factory = MessagingFactory.Create(uri, tP);
topic = factory.CreateMessageSender(hubmessagingtopic);
}
}
message.Dispose();
if (success)
{
return(true);
}
else
{
return(false);
}
}
public override bool Send(IMessage msg)
{
try
{
// Create management credentials
TokenProvider credentials = TokenProvider.CreateSharedAccessSignatureTokenProvider("RootManageSharedAccessKey", "0cH6A9wTngFOWGpg3jfI8OYd+4FUGSFJWAsid9EHnKE=");
// Create namespace client
//NamespaceManager namespaceClient = new NamespaceManager(ServiceBusEnvironment.CreateServiceUri("sb", "hl7test", string.Empty), credentials);
//QueueDescription myQueue;
//myQueue = namespaceClient.CreateQueue("NewMessageQueue");
MessagingFactory factory = MessagingFactory.Create(ServiceBusEnvironment.CreateServiceUri("sb", "hl7test", string.Empty), credentials);
QueueClient myQueueClient = factory.CreateQueueClient("NewMessageQueue");
//{NHapi.Model.V251.Message.MDM_T01}
var msgDetail = (msg as NHapi.Model.V251.Message.MDM_T01);
if (msgDetail != null)
{
var name = msgDetail.PID.GetPatientName();
var content =
$"<html><body><p>A new appointment has been scheduled for your patient: {msgDetail.PID.PatientID.IDNumber.Value} <b>{name[0].GivenName} {name[0].FamilyName.Surname}</b><p></body></html>";
myQueueClient.Send(new BrokeredMessage(GenerateStreamFromString(content))
{
CorrelationId = Guid.NewGuid().ToString()
});
}
}
catch (IOException)
{
return(false);
}
return(true);
}
public static void ReceiveQ()
{
Console.WriteLine("In Receive method().");
TokenProvider credentials = TokenProvider.CreateSharedSecretTokenProvider(QReceiver.IssuerName, QReceiver.IssuerKey);
Uri serviceUri = ServiceBusEnvironment.CreateServiceUri("sb", QReceiver.ServiceNamespace, string.Empty);
MessagingFactory factory = null;
factory = MessagingFactory.Create(serviceUri, credentials);
QueueClient sessionQueueClient = factory.CreateQueueClient(QReceiver.QueueName);
//Create sessionQueueClient and subscribe to SessionIDs that have a value of "Mike"
MessageSession sessionReceiver = sessionQueueClient.AcceptMessageSession("92610", TimeSpan.FromSeconds(60));
BrokeredMessage receivedMessage;
while ((receivedMessage = sessionReceiver.Receive(TimeSpan.FromSeconds(60))) != null)
{
Console.WriteLine("Received Messages.");
var data = receivedMessage.GetBody <FireEvent>(new DataContractSerializer(typeof(FireEvent)));
//Console.WriteLine(String.Format("Customer Name: {0}", data.CustomerName));
Console.WriteLine("SessionID: {0}", receivedMessage.SessionId);
//remove message from Topic
receivedMessage.Complete();
}
Console.WriteLine("All received on this session...press enter to exit");
Console.Read();
}
public static async Task SendPatchMessageAsync(Models.Transfer transfer, Guid customerId, string reqUrl)
{
var tokenProvider = TokenProvider.CreateSharedAccessSignatureTokenProvider(KeyName, AccessKey);
var messagingFactory = MessagingFactory.Create(BaseAddress, tokenProvider);
var sender = messagingFactory.CreateMessageSender(QueueName);
var messageModel = new MessageModel
{
TitleMessage = "Transfer record modification for {" + customerId + "} at " + DateTime.UtcNow,
CustomerGuid = customerId,
LastModifiedDate = transfer.LastModifiedDate,
URL = reqUrl,
IsNewCustomer = false,
TouchpointId = transfer.LastModifiedTouchpointId
};
var msg = new BrokeredMessage(new MemoryStream(Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(messageModel))))
{
ContentType = "application/json",
MessageId = customerId + " " + DateTime.UtcNow
};
await CheckAndCreateSubscription(transfer);
await sender.SendAsync(msg);
}
public PublisherService()
{
var messageFactory = MessagingFactory.Create();
var namespaceManager = NamespaceManager.Create();
TopicDescription demoTopic;
////Only uncomment this when testing creating a fresh topic
//if (namespaceManager.TopicExists(TopicName))
//{
// namespaceManager.DeleteTopic(TopicName);
//}
if (!namespaceManager.TopicExists(TopicName))
{
demoTopic = new TopicDescription(TopicName);
//TODO: Add permissions
//const string domainUser = "******";
//AuthorizationRule allowRule = new AllowRule("ServiceBusDefaultNamespace", "role", domainUser,
// new List<AccessRights> { AccessRights.Manage, AccessRights.Send, AccessRights.Listen });
//demoTopic.Authorization.Add(allowRule);
namespaceManager.CreateTopic(demoTopic);
}
else
{
demoTopic = namespaceManager.GetTopic(TopicName);
}
//Create a topic client
_topicClient = messageFactory.CreateTopicClient(demoTopic.Path);
}
public static async Task SendPostMessageAsync(Models.Customer customer, string reqUrl)
{
var tokenProvider = TokenProvider.CreateSharedAccessSignatureTokenProvider(KeyName, AccessKey);
var messagingFactory = MessagingFactory.Create(BaseAddress, tokenProvider);
var sender = messagingFactory.CreateMessageSender(QueueName);
var messageModel = new MessageModel()
{
TitleMessage = "New customer record {" + customer.CustomerId + "} added at " + DateTime.UtcNow,
CustomerGuid = customer.CustomerId,
LastModifiedDate = customer.LastModifiedDate,
URL = reqUrl + "/" + customer.CustomerId,
IsNewCustomer = true,
TouchpointId = customer.LastModifiedTouchpointId
};
var msg = new BrokeredMessage(new MemoryStream(Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(messageModel))))
{
ContentType = "application/json",
MessageId = customer.CustomerId + " " + DateTime.UtcNow
};
await AutoSubscribeCustomer(customer);
await sender.SendAsync(msg);
}
static void ReceiveMessage()
{
TokenProvider tokenProvider = _namespaceManager.Settings.TokenProvider;
if (_namespaceManager.TopicExists("DataCollectionTopic"))
{
MessagingFactory factory = MessagingFactory.Create(_namespaceManager.Address, tokenProvider);
//MessageReceiver receiver = factory.CreateMessageReceiver("DataCollectionTopic/subscriptions/Inventory");
MessageReceiver receiver = factory.CreateMessageReceiver("DataCollectionTopic/subscriptions/Dashboard");
BrokeredMessage receivedMessage = null;
try
{
while ((receivedMessage = receiver.Receive()) != null)
{
ProcessMessage(receivedMessage);
receivedMessage.Complete();
}
factory.Close();
_namespaceManager.DeleteSubscription("DataCollectionTopic", "Inventory");
// _namespaceManager.DeleteTopic("DataCollectionTopic");
}
catch (Exception ex)
{
Console.WriteLine(ex.ToString());
receivedMessage.Abandon();
}
}
}
protected void btnSend_Click(object sender, EventArgs e)
{
// create a parameter object for the messaging factory that configures
// the MSI token provider for Service Bus and use of the AMQP protocol:
MessagingFactorySettings messagingFactorySettings = new MessagingFactorySettings
{
TokenProvider = TokenProvider.CreateManagedServiceIdentityTokenProvider(ServiceAudience.ServiceBusAudience),
TransportType = TransportType.Amqp
};
// TODO - Remove after backend is patched with the AuthComponent open fix
// https://github.com/Azure/azure-service-bus/issues/136
messagingFactorySettings.AmqpTransportSettings.EnableLinkRedirect = false;
// create the messaging factory using the namespace endpoint name supplied by the user
MessagingFactory messagingFactory = MessagingFactory.Create($"sb://{txtNamespace.Text}/",
messagingFactorySettings);
// create a queue client using the queue name supplied by the user
QueueClient queueClient = messagingFactory.CreateQueueClient(txtQueueName.Text);
// send a message using the input text
queueClient.Send(new BrokeredMessage(Encoding.UTF8.GetBytes(txtData.Text)));
queueClient.Close();
messagingFactory.Close();
}
private static void CreateQueueToRead()
{
TokenProvider tokenProvider = _namespaceManager.Settings.TokenProvider;
if (_namespaceManager.QueueExists("categoryqueue"))
{
//Creating the queues with details
//QueueDescription mnQueue = namespaceManagerClient.CreateQueue("categoryqueue");
MessagingFactory factory = MessagingFactory.Create(_namespaceManager.Address, tokenProvider);
//ReceiveAndDelete chances of not clearing the data if it crash before
//PeekLock, it locks the second message in line and only by calling Complete it moves to the next only then it deletes it of this is default mode
QueueClient catsQueueClient = factory.CreateQueueClient("categoryqueue");
Console.WriteLine("Receiving the Messages from the Queue....");
BrokeredMessage message;
int ctr = 1;
while ((message = catsQueueClient.Receive(new TimeSpan(hours: 0, minutes: 1, seconds: 5))) != null)
{
//Console.WriteLine("Message Received, Sequence: {0}, Cat: {1} and MessageID: {2}", message.SequenceNumber, message.Properties[(ctr++).ToString()], message.MessageId);
Console.WriteLine($"Message Received, Sequence: {message.SequenceNumber}, MessageID: {message.MessageId},\nCat: {message.Properties[(ctr++).ToString()]}");
message.Complete();
Console.WriteLine("Processing Message (sleeping).....");
Thread.Sleep(2000);
}
factory.Close();
catsQueueClient.Close();
_namespaceManager.DeleteQueue("categoryqueue");
Console.WriteLine("Finished getting all the data from the queue, Press any key to exit");
}
}