/// <summary> /// Constructs an uploader object. /// </summary> /// <param name="eventHubConnectionString">The Azure Stream Analytics connection string.</param> /// <param name="batchConfig">Optional; The batching configuration to used when uploading data.</param> /// <param name="developmentMode">If true, enables additional logging and disables batching.</param> public EventUploaderASA ( string eventHubConnectionString, BatchingConfiguration batchConfig = null, bool developmentMode = false ) : base(batchConfig, developmentMode) { this.connectionString = eventHubConnectionString; var builder = new ServiceBusConnectionStringBuilder(this.connectionString) { TransportType = TransportType.Amqp, }; var eventHubInputName = builder.EntityPath; builder.EntityPath = null; if (this.batchConfig.ReUseTcpConnection) { this.client = EventHubClient.CreateFromConnectionString(builder.ToString(), eventHubInputName); } else { var factory = MessagingFactory.CreateFromConnectionString(builder.ToString()); this.client = factory.CreateEventHubClient(eventHubInputName); } }
static void Main() { //Build the Service Bus connection string (again, not necessary if using config from the config file) var connBuilder = new ServiceBusConnectionStringBuilder(); connBuilder.ManagementPort = HttpPort; connBuilder.RuntimePort = TcpPort; connBuilder.Endpoints.Add(new UriBuilder { Scheme = "sb", Host = ServerFqdn, Path = ServiceNamespace }.Uri); connBuilder.StsEndpoints.Add(new UriBuilder { Scheme = "https", Host = ServerFqdn, Port = HttpPort, Path = ServiceNamespace }.Uri); //Create a NamespaceManager instance (for management operations) and a MessagingFactory instance (for sending and receiving messages) //MessagingFactory messageFactory = MessagingFactory.Create(); var messageFactory = MessagingFactory.CreateFromConnectionString(connBuilder.ToString()); //NamespaceManager namespaceManager = NamespaceManager.Create(); var namespaceManager = NamespaceManager.CreateFromConnectionString(connBuilder.ToString()); //Create a new queue const string queueName = "ServiceBusQueueSample"; if (namespaceManager == null) { Console.WriteLine("\nUnexpected Error: NamespaceManager is NULL"); return; } if (namespaceManager.QueueExists(queueName)) { namespaceManager.DeleteQueue(queueName); } namespaceManager.CreateQueue(queueName); //Create a queue client to send and receive messages to and from the queue var myQueueClient = messageFactory.CreateQueueClient(queueName); //Create a simple brokered message and send it to the queue var sendMessage = new BrokeredMessage("Hello World!"); myQueueClient.Send(sendMessage); Console.WriteLine("Message sent: Body = {0}", sendMessage.GetBody <string>()); //Receive the message from the queue var receivedMessage = myQueueClient.Receive(TimeSpan.FromSeconds(5)); if (receivedMessage != null) { Console.WriteLine("Message received: Body = {0}", receivedMessage.GetBody <string>()); receivedMessage.Complete(); } //Close the connection to the Service Bus messageFactory.Close(); Console.WriteLine("Press Enter to close."); Console.ReadLine(); }
static void Main(string[] args) { _serverFqdn = System.Net.Dns.GetHostEntry(string.Empty).HostName; var connectionStringBuilder = new ServiceBusConnectionStringBuilder { ManagementPort = HttpPort, RuntimePort = TcpPort }; connectionStringBuilder.Endpoints.Add(new UriBuilder() { Scheme = "sb", Host = _serverFqdn, Path = ServiceNamespace }.Uri); connectionStringBuilder.StsEndpoints.Add(new UriBuilder() { Scheme = "https", Host = _serverFqdn, Port = HttpPort, Path = ServiceNamespace }.Uri); var messageFactory = MessagingFactory.CreateFromConnectionString(connectionStringBuilder.ToString()); var namespaceManager = NamespaceManager.CreateFromConnectionString(connectionStringBuilder.ToString()); if (namespaceManager == null) { Console.WriteLine("\nUnexpected Error"); return; } if (!namespaceManager.QueueExists(QueueName)) { Console.WriteLine(@"Error: TALServiceBusQueue Queue des not Exist... Start your Queue first"); return; } QueueClient queueClient = messageFactory.CreateQueueClient(QueueName); while (true) { try { // Receive the message from the queue BrokeredMessage receivedMessage = queueClient.Receive(); if (receivedMessage != null) { Console.WriteLine(@"Message received: {0}", receivedMessage.GetBody<ServiceBusEventMessage>()); receivedMessage.Complete(); } else { Console.WriteLine(@"No new messages in the queue"); Thread.Sleep(1000); } } catch (Exception e) { Console.WriteLine("Unexpected exception {0}", e); throw; } } if (messageFactory != null) { messageFactory.Close(); } // Console.WriteLine("Press ENTER to clean up and exit."); // Console.ReadLine(); }
static void Main() { //Build the Service Bus connection string (again, not necessary if using config from the config file) var connBuilder = new ServiceBusConnectionStringBuilder(); connBuilder.ManagementPort = HttpPort; connBuilder.RuntimePort = TcpPort; connBuilder.Endpoints.Add(new UriBuilder { Scheme = "sb", Host = ServerFqdn, Path = ServiceNamespace }.Uri); connBuilder.StsEndpoints.Add(new UriBuilder { Scheme = "https", Host = ServerFqdn, Port = HttpPort, Path = ServiceNamespace }.Uri); var messageFactory = MessagingFactory.CreateFromConnectionString(connBuilder.ToString()); var namespaceManager = NamespaceManager.CreateFromConnectionString(connBuilder.ToString()); const string topicName = "DemoTopic"; //const string subscriptionName = "status_verifications"; const string subscriptionName = "Subscription1"; //Give the publisher some time to create the topic System.Threading.Thread.Sleep(5000); //Only uncomment to reset the subscription //namespaceManager.DeleteSubscription(topicName, subscriptionName); //Create the subscription (if it doesn't exist) if (!namespaceManager.SubscriptionExists(topicName, subscriptionName)) { //Only subscribe to messages that are Type1 var filter = new SqlFilter("Type = 'Type1'"); namespaceManager.CreateSubscription(topicName, subscriptionName, filter); } // Create the subscription client var subscriptionClient = messageFactory.CreateSubscriptionClient(topicName, subscriptionName, ReceiveMode.PeekLock); Console.WriteLine(subscriptionName); Console.WriteLine("----------------"); while (true) { var message = subscriptionClient.Receive(TimeSpan.FromSeconds(5)); if (message != null) { Console.WriteLine("{0} message received: Id = {1}; delivery count = {2}", subscriptionName, message.MessageId, message.DeliveryCount); message.Abandon(); } System.Threading.Thread.Sleep(10); } }
static void Main(string[] args) { _serverFqdn = System.Net.Dns.GetHostEntry(string.Empty).HostName; var connectionStringBuilder = new ServiceBusConnectionStringBuilder {ManagementPort = HttpPort, RuntimePort = TcpPort}; connectionStringBuilder.Endpoints.Add(new UriBuilder() { Scheme = "sb", Host = _serverFqdn, Path = ServiceNamespace }.Uri); connectionStringBuilder.StsEndpoints.Add(new UriBuilder() { Scheme = "https", Host = _serverFqdn, Port = HttpPort, Path = ServiceNamespace }.Uri); var messageFactory = MessagingFactory.CreateFromConnectionString(connectionStringBuilder.ToString()); var namespaceManager = NamespaceManager.CreateFromConnectionString(connectionStringBuilder.ToString()); if (namespaceManager == null) { Console.WriteLine("\nUnexpected Error"); return; } if (namespaceManager.QueueExists(QueueName)) { namespaceManager.DeleteQueue(QueueName); } namespaceManager.CreateQueue(QueueName); QueueClient queueClient = messageFactory.CreateQueueClient(QueueName); DisplayHeader(); var userInput = string.Empty; while (!ShouldExit(userInput)) { try { userInput = Console.ReadLine(); var numberOfMessages = userInput; var messagesList = GetListOfMessages(numberOfMessages); var startTime = DateTime.Now; SendMessages(messagesList, queueClient); var sendingTime = (DateTime.Now - startTime).TotalSeconds; Console.WriteLine(string.Format("\n{0} Messages Sent.. [Total Time: {1} Secs]", messagesList.Count(), sendingTime)); } catch (Exception e) { Console.WriteLine("Unexpected exception {0}", e.ToString()); throw; } } if (messageFactory != null) { messageFactory.Close(); } }
public void Run(MessageIngestor.SetEventActionEventEmbedded setEventActionEventEmbedded) { try { SetEventActionEventEmbedded = setEventActionEventEmbedded; //Load message ingestor MessageIngestor.Init(SetEventActionEventEmbedded); // Assign the delegate // Load vars var eventHubConnectionString = ConfigurationLibrary.AzureNameSpaceConnectionString(); var eventHubName = ConfigurationLibrary.GroupEventHubsName(); LogEngine.TraceInformation( $"Start GrabCaster DownStream - Point Id {ConfigurationLibrary.PointId()} - Point name {ConfigurationLibrary.PointName()} - Channel Id {ConfigurationLibrary.ChannelId()} - Channel name {ConfigurationLibrary.ChannelName()} "); var builder = new ServiceBusConnectionStringBuilder(eventHubConnectionString) { TransportType = TransportType.Amqp }; //If not exit it create one, drop brachets because Azure rules var eventHubConsumerGroup = string.Concat(ConfigurationLibrary.EngineName(), "_", ConfigurationLibrary.ChannelId().Replace("{", "").Replace("}", "").Replace("-", "")); var nsManager = NamespaceManager.CreateFromConnectionString(builder.ToString()); LogEngine.TraceInformation( $"Start DirectRegisterEventReceiving. - Initializing Group Name {eventHubConsumerGroup}"); // Create Event Hubs var eventHubClient = EventHubClient.CreateFromConnectionString(builder.ToString(), eventHubName); // Create consumer nsManager.CreateConsumerGroupIfNotExists(eventHubName, eventHubConsumerGroup); var namespaceManager = NamespaceManager.CreateFromConnectionString(builder.ToString()); var ehDescription = namespaceManager.GetEventHub(eventHubName); // Use the default consumer group foreach (var partitionId in ehDescription.PartitionIds) { var myNewThread = new Thread(() => ReceiveDirectFromPartition(eventHubClient, partitionId, eventHubConsumerGroup)); myNewThread.Start(); } LogEngine.TraceInformation("After DirectRegisterEventReceiving Downstream running."); } catch (Exception ex) { LogEngine.TraceError( $"Error in {MethodBase.GetCurrentMethod().Name} - Hint: Check if the firewall outbound port 5671 is opened. - Error {ex.Message}"); } }
static void Main(string[] args) { timer.Elapsed += TimerElapsed; //Build the Service Bus connection string (again, not necessary if using config from the config file) var connBuilder = new ServiceBusConnectionStringBuilder(); connBuilder.ManagementPort = HttpPort; connBuilder.RuntimePort = TcpPort; connBuilder.Endpoints.Add(new UriBuilder() { Scheme = "sb", Host = ServerFQDN, Path = ServiceNamespace }.Uri); connBuilder.StsEndpoints.Add(new UriBuilder() { Scheme = "https", Host = ServerFQDN, Port = HttpPort, Path = ServiceNamespace }.Uri); var messageFactory = MessagingFactory.CreateFromConnectionString(connBuilder.ToString()); var namespaceManager = NamespaceManager.CreateFromConnectionString(connBuilder.ToString()); //connBuilder.ToString() const string TopicName = "DemoTopic"; const string SubscriptionName = "Subscription2"; //Create the subscription (if it doesn't exist) if (!namespaceManager.SubscriptionExists(TopicName, SubscriptionName)) { var inventorySubscription = namespaceManager.CreateSubscription(TopicName, SubscriptionName); } // Create the subscription client var agentSubscriptionClient = messageFactory.CreateSubscriptionClient(TopicName, SubscriptionName, ReceiveMode.PeekLock); Console.WriteLine(SubscriptionName); Console.WriteLine("----------------"); while (true) { var message = agentSubscriptionClient.Receive(TimeSpan.FromSeconds(5)); if (message != null) { Console.WriteLine(string.Format("{0} message received: Id = {1}, Body = {2}", SubscriptionName, message.MessageId, message.GetBody <string>())); message.Complete(); numMessages++; //When we receive a message, stop and restart the timer. If the timer ever ticks, then display how many messages were processed timer.Stop(); timer.Start(); } System.Threading.Thread.Sleep(10); } }
static void Main() { //Build the Service Bus connection string (again, not necessary if using config from the config file) var connBuilder = new ServiceBusConnectionStringBuilder(); connBuilder.ManagementPort = HttpPort; connBuilder.RuntimePort = TcpPort; connBuilder.Endpoints.Add(new UriBuilder { Scheme = "sb", Host = ServerFqdn, Path = ServiceNamespace }.Uri); connBuilder.StsEndpoints.Add(new UriBuilder { Scheme = "https", Host = ServerFqdn, Port = HttpPort, Path = ServiceNamespace }.Uri); var messageFactory = MessagingFactory.CreateFromConnectionString(connBuilder.ToString()); var namespaceManager = NamespaceManager.CreateFromConnectionString(connBuilder.ToString()); const string topicName = "DemoTopic"; const string subscriptionName = "Subscription2"; //Give the publisher some time to create the topic System.Threading.Thread.Sleep(5000); //Create the subscription (if it doesn't exist) if (!namespaceManager.SubscriptionExists(topicName, subscriptionName)) { //Do not filter messages at all, so it will be subscribed to ALL messages, regardless of type namespaceManager.CreateSubscription(topicName, subscriptionName); } // Create the subscription client var subscriptionClient = messageFactory.CreateSubscriptionClient(topicName, subscriptionName, ReceiveMode.PeekLock); Console.WriteLine(subscriptionName); Console.WriteLine("----------------"); while (true) { var message = subscriptionClient.Receive(TimeSpan.FromSeconds(5)); if (message != null) { Console.WriteLine("{0} message received: Id = {1}, Body = {2}, Type = {3}", subscriptionName, message.MessageId, message.GetBody <string>(), message.Properties["Type"]); message.Complete(); } System.Threading.Thread.Sleep(10); } }
/// <summary> /// Builds the MessagingFactory and NamespaceManager for the ServiceBus /// which are used for managing the service bus itself and creating senders and receivers /// </summary> /// <param name="serviceNamespace"></param> /// <param name="serverFullyQualifiedDomainName"></param> /// <param name="httpPort"></param> /// <param name="tcpPort"></param> public async Task <bool> Connect(string serviceNamespace, string serverFullyQualifiedDomainName, int httpPort, int tcpPort) { Trace($"Namespace: {serviceNamespace}, FQDN: {serverFullyQualifiedDomainName}, httpPort: {httpPort}, tcpPort: {tcpPort}"); if (MessagingFactory != null && NamespaceManager != null) { return(true); //only one connection. could use a disconnect method } ServiceBusConnectionStringBuilder builder = new ServiceBusConnectionStringBuilder(); builder.ManagementPort = httpPort; builder.RuntimePort = tcpPort; builder.Endpoints.Add(new UriBuilder() { Scheme = "sb", Host = serverFullyQualifiedDomainName, Path = serviceNamespace }.Uri); builder.StsEndpoints.Add(new UriBuilder() { Scheme = "https", Host = serverFullyQualifiedDomainName, Port = httpPort, Path = serviceNamespace }.Uri); var serverAddress = builder.ToString(); return(await Connect(serverAddress)); }
public void ConnectionStringBuilderShouldTrimTrailingSemicolon() { var csBuilder = new ServiceBusConnectionStringBuilder { Endpoint = " amqps://contoso.servicebus.windows.net", SasKeyName = " keyname " }; Assert.Equal("Endpoint=amqps://contoso.servicebus.windows.net;SharedAccessKeyName=keyname", csBuilder.ToString()); csBuilder.SasKeyName = ""; Assert.Equal("Endpoint=amqps://contoso.servicebus.windows.net", csBuilder.ToString()); csBuilder.EntityPath = "myQ"; Assert.Equal("Endpoint=amqps://contoso.servicebus.windows.net;EntityPath=myQ", csBuilder.ToString()); csBuilder.EntityPath = ""; csBuilder.TransportType = TransportType.AmqpWebSockets; Assert.Equal("Endpoint=amqps://contoso.servicebus.windows.net;TransportType=AmqpWebSockets", csBuilder.ToString()); csBuilder.OperationTimeout = TimeSpan.FromSeconds(42); Assert.Equal("Endpoint=amqps://contoso.servicebus.windows.net;TransportType=AmqpWebSockets;OperationTimeout=00:00:42", csBuilder.ToString()); csBuilder.ConnectionIdleTimeout = TimeSpan.FromSeconds(42); Assert.Equal("Endpoint=amqps://contoso.servicebus.windows.net;TransportType=AmqpWebSockets;OperationTimeout=00:00:42;ConnectionIdleTimeout=00:00:42", csBuilder.ToString()); }
static string GetEventHubConnectionString() { var connectionString = ConfigurationManager.AppSettings["Microsoft.ServiceBus.ConnectionString"]; if (string.IsNullOrEmpty(connectionString)) { Console.ForegroundColor = ConsoleColor.Red; Console.WriteLine("Did not find Service Bus connections string in appsettings (app.config)"); Console.ResetColor(); return(string.Empty); } try { var builder = new ServiceBusConnectionStringBuilder(connectionString); builder.TransportType = TransportType.Amqp; return(builder.ToString()); } catch (Exception exception) { Console.ForegroundColor = ConsoleColor.Red; Console.WriteLine(exception.Message); Console.ResetColor(); } return(string.Empty); }
static void Main(string[] args) { Console.WriteLine("Receive messages. Ctrl-C to exit.\n"); var builder = new ServiceBusConnectionStringBuilder(connectionString) { TransportType = TransportType.Amqp, }; eventHubClient = EventHubClient.CreateFromConnectionString(builder.ToString(), iotHubD2cEndpoint); var d2cPartitions = eventHubClient.GetRuntimeInformation().PartitionIds; CancellationTokenSource cts = new CancellationTokenSource(); System.Console.CancelKeyPress += (s, e) => { e.Cancel = true; cts.Cancel(); Console.WriteLine("Exiting..."); }; var tasks = new List <Task>(); foreach (string partition in d2cPartitions) { tasks.Add(ReceiveMessagesFromDeviceAsync(partition, cts.Token)); } Task.WaitAll(tasks.ToArray()); }
EventProcessorHost IEventHubProvider.GetEventProcessorHost(string eventHubName, string consumerGroup) { ReceiverCreds creds; if (this._receiverCreds.TryGetValue(eventHubName, out creds)) { // Common case. Create a new EventProcessorHost instance to listen. string eventProcessorHostName = Guid.NewGuid().ToString(); if (consumerGroup == null) { consumerGroup = EventHubConsumerGroup.DefaultGroupName; } var storageConnectionString = creds.StorageConnectionString; if (storageConnectionString == null) { storageConnectionString = _defaultStorageString; } // If the connection string provides a hub name, that takes precedence. // Note that connection strings *can't* specify a consumerGroup, so must always be passed in. string actualPath = eventHubName; ServiceBusConnectionStringBuilder sb = new ServiceBusConnectionStringBuilder(creds.EventHubConnectionString); if (sb.EntityPath != null) { actualPath = sb.EntityPath; sb.EntityPath = null; // need to remove to use with EventProcessorHost } var @namespace = GetServiceBusNamespace(sb); var blobPrefix = GetBlobPrefix(actualPath, @namespace); // Use blob prefix support available in EPH starting in 2.2.6 EventProcessorHost host = new EventProcessorHost( hostName: eventProcessorHostName, eventHubPath: actualPath, consumerGroupName: consumerGroup, eventHubConnectionString: sb.ToString(), storageConnectionString: storageConnectionString, leaseContainerName: LeaseContainerName, leaseBlobPrefix: blobPrefix); if (_partitionOptions != null) { host.PartitionManagerOptions = _partitionOptions; } return(host); } else { // Rare case: a power-user caller specifically provided an event processor host to use. EventProcessorHost host; if (_explicitlyProvidedHosts.TryGetValue(eventHubName, out host)) { return(host); } } throw new InvalidOperationException("No event hub receiver named " + eventHubName); }
static void Main(string[] args) { string connectionString = CloudConfigurationManager.GetSetting("Microsoft.ServiceBus.ConnectionString"); string eventHubName = CloudConfigurationManager.GetSetting("EventHubName"); if (string.IsNullOrEmpty(connectionString) || string.IsNullOrEmpty(eventHubName)) { Trace.WriteLine("One or more parameters missing in appsettings (app.config)"); return; } // Change Culture settings to en-US to ensure formmatting of CSV data is correct System.Globalization.CultureInfo.DefaultThreadCurrentCulture = new System.Globalization.CultureInfo("en-US"); ServiceBusConnectionStringBuilder builder = new ServiceBusConnectionStringBuilder(connectionString); builder.TransportType = TransportType.Amqp; var namespaceManager = NamespaceManager.CreateFromConnectionString(builder.ToString()); int numPartitions = 16; EventHubManager.CreateEventHubIfNotExists(eventHubName, numPartitions, namespaceManager); var driver = new StockMarketDriver(eventHubName, numPartitions); var token = tokenSource.Token; Task.Factory.StartNew(() => driver.Run(token)); Task.Factory.StartNew(() => driver.WaitForEnter(tokenSource)); driver.runCompleteEvent.WaitOne(); }
public AzureSBQSender(string connectionString, string queueName, int numberOfSenders) { NumberOfSenders = numberOfSenders; var connBuilder = new ServiceBusConnectionStringBuilder(connectionString); var namespaceManager = NamespaceManager.CreateFromConnectionString(connBuilder.ToString()); // Create queue. if (!namespaceManager.QueueExists(queueName)) { namespaceManager.CreateQueue(queueName); } // Create messaging factories, senders and receivers. _messagingFactory = new MessagingFactory[NumberOfSenders]; Sender = new MessageSender[NumberOfSenders]; // Create senders. var factoryIndex = 0; for (var i = 0; i < NumberOfSenders; i++) { _messagingFactory[factoryIndex] = MessagingFactory.CreateFromConnectionString(connBuilder.ToString()); Sender[i] = _messagingFactory[factoryIndex++].CreateMessageSender(queueName); } }
public async Task<string> OpenAsync(CancellationToken cancellationToken) { var builder = new ServiceBusConnectionStringBuilder(_connectionString) { TransportType = TransportType.Amqp }; _messagingFactory = MessagingFactory.CreateFromConnectionString(builder.ToString()); _eventHubClient = _messagingFactory.CreateEventHubClient(_eventHubName); _consumerGroup = !string.IsNullOrEmpty(_consumerGroupName) ? _eventHubClient.GetConsumerGroup(_consumerGroupName) : _eventHubClient.GetDefaultConsumerGroup(); _eventProcessorFactory = new EventProcessorFactory(); _leaseRepository = new ReliableStateLeaseRepository(_reliableStateManager); _checkpointManager = new CheckpointManager(_leaseRepository); var allocatedPartitions = await new EventHubPartitionPartitionAllocationStrategy(_serviceName, _partitionId) .AllocateAsync(_eventHubClient, new FabricClient()); foreach (var partition in allocatedPartitions) { var lease = await _leaseRepository.GetOrCreateAsync(_connectionString, _consumerGroupName, _eventHubName, partition); await _consumerGroup.RegisterProcessorFactoryAsync(lease, _checkpointManager, _eventProcessorFactory); } return string.Concat(_eventHubName, " @ ", _connectionString); }
public static bool CreateEventUpStream() { try { Debug.WriteLine("-------------- Engine LogEventUpStream --------------"); Debug.WriteLine("LogEventUpStream - Get Configuration settings."); //Event Hub Configuration azureNameSpaceConnectionString = ConfigurationBag.Configuration.AzureNameSpaceConnectionString; eventHubName = ConfigurationBag.Configuration.LoggingComponentStorage; Debug.WriteLine($"LogEventUpStream - azureNameSpaceConnectionString={azureNameSpaceConnectionString}"); Debug.WriteLine($"LogEventUpStream - eventHubName={eventHubName}"); // TODO ServiceBusEnvironment.SystemConnectivity.Mode = ConnectivityMode.Https; var builder = new ServiceBusConnectionStringBuilder(azureNameSpaceConnectionString) { TransportType = TransportType .Amqp }; Debug.WriteLine("LogEventUpStream - Create the eventHubClient."); eventHubClient = EventHubClient.CreateFromConnectionString(builder.ToString(), eventHubName); return(true); } catch (Exception ex) { Debug.WriteLine("LogEventUpStream - error->{0}", ex.Message); EventLog.WriteEntry("Framework.Log.EventHubs", ex.Message); return(false); } }
private void CreateConnectionData(IConfigurationProvider configurationProvider) { string serviceBusConnectionString = configurationProvider.GetValue("serviceBusConnectionString"); if (string.IsNullOrWhiteSpace(serviceBusConnectionString)) { throw new ConfigurationErrorsException( "Configuration parameter 'serviceBusConnectionString' must be set to a valid Service Bus connection string"); } string eventHubName = configurationProvider.GetValue("eventHubName"); if (string.IsNullOrWhiteSpace(eventHubName)) { throw new ConfigurationErrorsException("Configuration parameter 'eventHubName' must not be empty"); } this.connectionData = new EventHubConnectionData(); this.connectionData.EventHubName = eventHubName; ServiceBusConnectionStringBuilder connStringBuilder = new ServiceBusConnectionStringBuilder(serviceBusConnectionString); connStringBuilder.TransportType = TransportType.Amqp; this.connectionData.MessagingFactories = new MessagingFactory[ConcurrentConnections]; for (uint i = 0; i < ConcurrentConnections; i++) { this.connectionData.MessagingFactories[i] = MessagingFactory.CreateFromConnectionString(connStringBuilder.ToString()); } }
/// <summary> /// pull connection string for Event Hub from the Settings.xml file in this project /// </summary> /// <returns></returns> private string GetEventHubConnectionString() { ConfigurationSettings settingsFile = ActorService.Context.CodePackageActivationContext.GetConfigurationPackageObject("Config").Settings; ConfigurationSection configSection = settingsFile.Sections["Config"]; var connectionString = configSection.Parameters["EventHub"].Value; if (string.IsNullOrEmpty(connectionString)) { Console.WriteLine("Did not find Service Bus connections string in appsettings (app.config)"); return(string.Empty); } try { var builder = new ServiceBusConnectionStringBuilder(connectionString); builder.TransportType = TransportType.Amqp; return(builder.ToString()); } catch (Exception exception) { Console.ForegroundColor = ConsoleColor.Red; Console.WriteLine(exception.Message); Console.ResetColor(); } return(null); }
public bool CreateEventUpStream() { try { //EH Configuration connectionString = ConfigurationLibrary.AzureNameSpaceConnectionString(); eventHubName = ConfigurationLibrary.GroupEventHubsName(); LogEngine.TraceInformation($"Start GrabCaster UpStream - Point Id {ConfigurationLibrary.PointId()} - Point name {ConfigurationLibrary.PointName()} - Channel Id {ConfigurationLibrary.ChannelId()} - Channel name {ConfigurationLibrary.ChannelName()} "); var builder = new ServiceBusConnectionStringBuilder(connectionString) { TransportType = TransportType.Amqp }; eventHubClient = EventHubClient.CreateFromConnectionString(builder.ToString(), eventHubName); return(true); } catch (Exception) { return(false); } }
public AzureSBQRecevier(string connectionString, string queueName, int numberOfReceivers, int prefetchCount) { NumberOfReceivers = numberOfReceivers; var connBuilder = new ServiceBusConnectionStringBuilder(connectionString); var namespaceManager = NamespaceManager.CreateFromConnectionString(connBuilder.ToString()); // Create queue. if (!namespaceManager.QueueExists(queueName)) { namespaceManager.CreateQueue(queueName); } // Create messaging factories, senders and receivers. _messagingFactory = new MessagingFactory[NumberOfReceivers]; Receiver = new MessageReceiver[NumberOfReceivers]; var factoryIndex = 0; // Create receivers. for (var i = 0; i < NumberOfReceivers; i++) { _messagingFactory[factoryIndex] = MessagingFactory.CreateFromConnectionString(connBuilder.ToString()); Receiver[i] = _messagingFactory[factoryIndex++].CreateMessageReceiver(queueName, ReceiveMode.PeekLock); Receiver[i].PrefetchCount = prefetchCount; } }
static string GetAmqpConnectionString() { ServiceBusConnectionStringBuilder builder = new ServiceBusConnectionStringBuilder(connectionString); builder.TransportType = TransportType.Amqp; return(builder.ToString()); }
public bool CreateOffRampStream() { try { //EH Configuration connectionString = ConfigurationBag.Configuration.AzureNameSpaceConnectionString; eventHubName = ConfigurationBag.Configuration.GroupEventHubsName; LogEngine.WriteLog( ConfigurationBag.EngineName, $"Event Hubs transfort Type: {ConfigurationBag.Configuration.ServiceBusConnectivityMode}", Constant.LogLevelError, Constant.TaskCategoriesError, null, Constant.LogLevelInformation); var builder = new ServiceBusConnectionStringBuilder(connectionString) { TransportType = TransportType.Amqp }; eventHubClient = EventHubClient.CreateFromConnectionString(builder.ToString(), eventHubName); return(true); } catch (Exception) { return(false); } }
public void Execute(SetEventActionTrigger setEventActionTrigger, EventActionContext context) { try { this.Context = context; this.SetEventActionTrigger = setEventActionTrigger; // Create the connection string var builder = new ServiceBusConnectionStringBuilder(this.EventHubsConnectionString) { TransportType = TransportType .Amqp }; // Create the EH Client var eventHubClient = EventHubClient.CreateFromConnectionString(builder.ToString(), this.EventHubsName); // muli partition sample var namespaceManager = NamespaceManager.CreateFromConnectionString(builder.ToString()); var eventHubDescription = namespaceManager.GetEventHub(this.EventHubsName); // Use the default consumer group foreach (var partitionId in eventHubDescription.PartitionIds) { var myNewThread = new Thread(() => this.ReceiveDirectFromPartition(eventHubClient, partitionId)); myNewThread.Start(); } } catch (Exception) { // ignored } }
static void Main(string[] args) { var builder = new ServiceBusConnectionStringBuilder(""); builder.TransportType = TransportType.Amqp; var factory = MessagingFactory.CreateFromConnectionString(builder.ToString()); var client = factory.CreateEventHubClient("iotsample"); Console.WriteLine("Hit enter to send a batch of messages, x to exit"); var x = Console.ReadLine(); while (x != "x") { var random = new Random(); var messages = new List<EventData>(); for (int i = 0; i < 1000; i++) { var message = new { deviceId = random.Next(0, 1) }; var body = JsonConvert.SerializeObject(message); messages.Add(new EventData(Encoding.UTF8.GetBytes(body))); } client.SendBatch(messages); Console.WriteLine("Batch sent, hit enter to send the next batch, x to exit"); x = Console.ReadLine(); } }
static string ReadConnectionString() { string connectionString = ConnectionString; do { if (connectionString == null) { Console.Write("\nEnter Service Bus Connection String or type 'exit': "); connectionString = Console.ReadLine(); if (string.Equals(connectionString, "exit", StringComparison.OrdinalIgnoreCase)) { Environment.Exit(0); } } try { ServiceBusConnectionStringBuilder builder = new ServiceBusConnectionStringBuilder(connectionString); connectionString = builder.ToString(); } catch (Exception ex) { Console.WriteLine("Error: {0}", ex.Message); connectionString = null; } } while (connectionString == null); return(connectionString); }
static void Main(string[] args) { var connBuilder = new ServiceBusConnectionStringBuilder(); connBuilder.ManagementPort = HttpPort; connBuilder.RuntimePort = TcpPort; connBuilder.Endpoints.Add(new Uri("sb://Niranga/ServiceBusDefaultNamespace")); connBuilder.StsEndpoints.Add(new Uri("https://Niranga:9355/ServiceBusDefaultNamespace")); var messagingFactory = MessagingFactory.CreateFromConnectionString(connBuilder.ToString()); var namespaceManager = NamespaceManager.CreateFromConnectionString(connBuilder.ToString()); if (namespaceManager == null) { Console.WriteLine("Error"); return; } string queueName = "ServiceBusQueueSample"; if (namespaceManager.QueueExists(queueName)) { namespaceManager.DeleteQueue(queueName); } namespaceManager.CreateQueue(queueName); var queueClient = messagingFactory.CreateQueueClient(queueName); // Send var brokeredMessage = new BrokeredMessage("Hello"); queueClient.Send(brokeredMessage); // Receive var receiveMessage = queueClient.Receive(TimeSpan.FromSeconds(5)); if (receiveMessage != null) { Console.WriteLine("Received '{0}'", receiveMessage.GetBody<string>()); receiveMessage.Complete(); } if (messagingFactory != null) { messagingFactory.Close(); } }
private static MessageReceiver CreateDeadLetterQueueClient(string connectionString, string topicName, string subscriptionName) { var builder = new ServiceBusConnectionStringBuilder(connectionString); var factory = MessagingFactory.CreateFromConnectionString(builder.ToString()); var deadLetterQueuePath = SubscriptionClient.FormatDeadLetterPath(topicName, subscriptionName); return(factory.CreateMessageReceiver(deadLetterQueuePath)); }
public EventPublisher(string connectionString, string eventHubName, string partitionKey, ILogger logger) { var builder = new ServiceBusConnectionStringBuilder(connectionString) { TransportType = TransportType.Amqp }; _partitionKey = partitionKey; _client = EventHubClient.CreateFromConnectionString(builder.ToString(), eventHubName); _logger = logger; }
public void InitializeEventHub() { var builder = new ServiceBusConnectionStringBuilder(); builder.Endpoints.Add(new Uri("sb://" + this.appConfig.EventHubNamespace + "." + this.appConfig.EventHubFqnAddress)); builder.EntityPath = this.appConfig.EventHubEntityPath; builder.SharedAccessKeyName = this.appConfig.EventHubUsername; builder.SharedAccessKey = this.appConfig.EventHubPassword; builder.TransportType = TransportType.Amqp; Context.Logger.Info("EventHubWriter: ConnectionString = {0} ParitionId = {1}", builder.ToString(), Context.TopologyContext.GetThisTaskIndex()); eventHubClient = EventHubClient.CreateFromConnectionString(builder.ToString()); //TODO: Implement a distribution strategy of partitions in case number of bolt tasks is less than partitions in EventHub eventHubSender = eventHubClient.CreatePartitionedSender(Context.TopologyContext.GetThisTaskIndex().ToString()); }
private QueueClient CreateClient(string entityName) { var connectionStringBuilder = new ServiceBusConnectionStringBuilder(configuration.ConnectionString) { EntityPath = entityName }; return(QueueClient.CreateFromConnectionString(connectionStringBuilder.ToString())); }
internal static string GetEntityConnectionString(string entityName) { // If the entity name is populated in the connection string, it will be overridden. var connectionStringBuilder = new ServiceBusConnectionStringBuilder(NamespaceConnectionString) { EntityPath = entityName }; return(connectionStringBuilder.ToString()); }
public Task OpenEventHubAsync(string eventHubConnectionString, string hubName) { return(Task.Factory.StartNew(async() => { if (string.IsNullOrWhiteSpace(eventHubConnectionString)) { throw new ArgumentException("invalid event hub connection string"); } if (string.IsNullOrWhiteSpace(hubName)) { throw new ArgumentException("invalid hubname"); } this.IsOpen = true; var builder = new ServiceBusConnectionStringBuilder(eventHubConnectionString) { TransportType = TransportType.Amqp }; var s = builder.ToString(); _factory = MessagingFactory.CreateFromConnectionString(builder.ToString()); _client = _factory.CreateEventHubClient(hubName); var runtimeInfo = await _client.GetRuntimeInformationAsync(); _partitions.Clear(); foreach (var p in runtimeInfo.PartitionIds) { var partition = await _client.GetPartitionRuntimeInformationAsync(p); var count = partition.LastEnqueuedSequenceNumber - partition.BeginSequenceNumber; if (count != 0) { count++; } this.MessageCount = count; _partitions.Add(new Partition(p, _messages)); _foundPartitions.OnNext(partition); } _foundPartitions.OnCompleted(); })); }
/// <summary> /// Returns Service Bus connection string to use. /// </summary> public string BuildConnectionString() { if (OperationTimeout != null) { var connectionStringBuilder = new ServiceBusConnectionStringBuilder(ConnectionString); connectionStringBuilder.OperationTimeout = OperationTimeout.Value; return(connectionStringBuilder.ToString()); } return(ConnectionString); }
public EventPublisher(string connectionString, string eventHubName, string partitionKey, ILogger logger) { var builder = new ServiceBusConnectionStringBuilder(connectionString) { TransportType = TransportType.Amqp }; _partitionKey = partitionKey; _client = EventHubClient.CreateFromConnectionString(builder.ToString(), eventHubName); _logger = logger; }
public void SetUp() { var serverFQDN = Environment.MachineName; const int HttpPort = 9355; const int TcpPort = 9354; const string ServiceNamespace = "ServiceBusDefaultNamespace"; var connBuilder = new ServiceBusConnectionStringBuilder { ManagementPort = HttpPort, RuntimePort = TcpPort }; connBuilder.Endpoints.Add(new UriBuilder { Scheme = "sb", Host = serverFQDN, Path = ServiceNamespace }.Uri); connBuilder.StsEndpoints.Add(new UriBuilder { Scheme = "https", Host = serverFQDN, Port = HttpPort, Path = ServiceNamespace }.Uri); _testBus = Bus.CreateBus(cfg => cfg.WithConnectionString(connBuilder.ToString()).WithLogger(new TestLogger())).Result; }
private static string GetServiceBusConnectionString() { string connectionString = ConfigurationManager.AppSettings["Microsoft.ServiceBus.ConnectionString"]; if (string.IsNullOrEmpty(connectionString)) { Console.WriteLine("Did not find Service Bus connections string in appsettings (app.config)"); return string.Empty; } ServiceBusConnectionStringBuilder builder = new ServiceBusConnectionStringBuilder(connectionString); builder.TransportType = TransportType.Amqp; return builder.ToString(); }
/// <summary> /// /// </summary> public void CreateReceiver() { if (!isRunning) { isRunning = true; var connectionString = Constants.GstnServiceBusEventHub; string eventhubPath = Constants.GstnReqEventHub; var nsm = NamespaceManager.CreateFromConnectionString(connectionString); //var description = nsm.CreateEventHubIfNotExists(eventhubPath); var builder = new ServiceBusConnectionStringBuilder(connectionString) { TransportType = TransportType.Amqp }; var factory = MessagingFactory.CreateFromConnectionString(builder.ToString()); var client = factory.CreateEventHubClient(eventhubPath); var group = client.GetDefaultConsumerGroup(); var requestdata = new WEP.GSP.Data.RequestData(); try { var receiverList = new List <EventHubReceiver>(); var availablePartition = requestdata.GetInstancePartitions(System.Environment.MachineName + ConfigurationManager.AppSettings["MachineName"].ToString()); if (availablePartition != null && availablePartition.Any()) { foreach (var partitionno in availablePartition) { receiverList.Add(group.CreateReceiver(partitionno, requestdata.RetrievePartitionOffset(partitionno))); } ; var taskFactory = new TaskFactory(); var task = ( from r in receiverList select taskFactory.StartNew(() => { Task.Delay(TimeSpan.FromSeconds(1)); StartReceiver(Convert.ToInt32(r.PartitionId), r); })).ToList(); Task.WaitAll(task.ToArray()); } isRunning = false; } catch (Exception e) { isRunning = false; Trace.TraceInformation(e.Message); } } System.Threading.Thread.Sleep(60000); CreateReceiver(); }
private string GetServiceBusConnectionString() { string connectionString = ConfigurationManager.AppSettings["Microsoft.ServiceBus.ConnectionString"]; if (string.IsNullOrEmpty(connectionString)) { return(string.Empty); } ServiceBusConnectionStringBuilder builder = new ServiceBusConnectionStringBuilder(connectionString); builder.TransportType = TransportType.Amqp; return(builder.ToString()); }
private string GetServiceBusConnectionString() { string connectionString = ConfigurationManager.AppSettings["Microsoft.ServiceBus.ConnectionString"]; if (string.IsNullOrEmpty(connectionString)) { return string.Empty; } ServiceBusConnectionStringBuilder builder = new ServiceBusConnectionStringBuilder(connectionString); builder.TransportType = TransportType.Amqp; return builder.ToString(); }
private static string GetServiceBusConnectionString(string activityType) { string appSettingsKey = string.Format("ServiceBus{0}", activityType); string connectionString = ConfigurationManager.AppSettings[appSettingsKey]; if (string.IsNullOrEmpty(connectionString)) { Console.WriteLine("Did not find Service Bus connections string in appsettings (app.config)"); return string.Empty; } ServiceBusConnectionStringBuilder builder = new ServiceBusConnectionStringBuilder(connectionString); builder.TransportType = TransportType.Amqp; return builder.ToString(); }
public void Build() { var connectionBuilder = new ServiceBusConnectionStringBuilder(); connectionBuilder.ManagementPort = HttpPort; connectionBuilder.RuntimePort = TcpPort; // Service Bus end-point connectionBuilder.Endpoints.Add(new Uri(ServiceBusEndPont)); // STS End-point connectionBuilder.StsEndpoints.Add(new Uri(SecureTokenServiceEndPoint)); ConnectionString = connectionBuilder.ToString(); }
/// <summary> /// Initializes a new instance of the <see cref="LargePublishPerformance"/> class. /// </summary> public LargePublishPerformance() { var serverFQDN = Environment.MachineName; const int HttpPort = 9355; const int TcpPort = 9354; const string ServiceNamespace = "ServiceBusDefaultNamespace"; // Common.Logging.LogManager.Adapter = new Common.Logging.NLog.NLogLoggerFactoryAdapter(new NameValueCollection { { "configType", "FILE" }, { "configFile", "~/NLog.config" } }); var connBuilder = new ServiceBusConnectionStringBuilder { ManagementPort = HttpPort, RuntimePort = TcpPort }; connBuilder.Endpoints.Add(new UriBuilder { Scheme = "sb", Host = serverFQDN, Path = ServiceNamespace }.Uri); connBuilder.StsEndpoints.Add(new UriBuilder { Scheme = "https", Host = serverFQDN, Port = HttpPort, Path = ServiceNamespace }.Uri); _bus = Bus.CreateBus(cfg => cfg.WithConnectionString(connBuilder.ToString())).Result; }
public void SetUp() { var serverFQDN = Environment.MachineName; const int HttpPort = 9355; const int TcpPort = 9354; const string ServiceNamespace = "ServiceBusDefaultNamespace"; var connBuilder = new ServiceBusConnectionStringBuilder { ManagementPort = HttpPort, RuntimePort = TcpPort }; connBuilder.OperationTimeout = TimeSpan.FromSeconds(10); connBuilder.Endpoints.Add(new UriBuilder { Scheme = "sb", Host = serverFQDN, Path = ServiceNamespace }.Uri); connBuilder.StsEndpoints.Add(new UriBuilder { Scheme = "https", Host = serverFQDN, Port = HttpPort, Path = ServiceNamespace }.Uri); _testBus = Bus.CreateBus(cfg => cfg.WithConnectionString(connBuilder.ToString()).WithLogger(new TestLogger())).Result; // _testBus = Bus.CreateBus(cfg => cfg.WithConnectionString(@"Endpoint=sb://funnelfire-test.servicebus.windows.net/;SharedAccessKeyName=RootManageSharedAccessKey;SharedAccessKey=ENUAYOiS9Lt3tDngyClvjzRyls5UkS8ie7aLAyjBV0s=;OperationTimeout=00:00:10").WithLogger(new TestLogger())).Result; }
public Task OpenEventHubAsync(string eventHubConnectionString, string hubName) { return Task.Factory.StartNew(async () => { if (string.IsNullOrWhiteSpace(eventHubConnectionString)) throw new ArgumentException("invalid event hub connection string"); if (string.IsNullOrWhiteSpace(hubName)) throw new ArgumentException("invalid hubname"); this.IsOpen = true; var builder = new ServiceBusConnectionStringBuilder(eventHubConnectionString) { TransportType = TransportType.Amqp }; var s = builder.ToString(); _factory = MessagingFactory.CreateFromConnectionString(builder.ToString()); _client = _factory.CreateEventHubClient(hubName); var runtimeInfo = await _client.GetRuntimeInformationAsync(); _partitions.Clear(); foreach (var p in runtimeInfo.PartitionIds) { var partition = await _client.GetPartitionRuntimeInformationAsync(p); var count = partition.LastEnqueuedSequenceNumber - partition.BeginSequenceNumber; if (count != 0) count++; this.MessageCount = count; _partitions.Add(new Partition(p, _messages)); _foundPartitions.OnNext(partition); } _foundPartitions.OnCompleted(); }); }
private static string GetAmqpConnectionString(string connectionString) { if (string.IsNullOrEmpty(connectionString)) { throw new ApplicationException(ConnectionStringCannotBeNull); } var builder = new ServiceBusConnectionStringBuilder(connectionString) { TransportType = TransportType.Amqp }; return builder.ToString(); }
public async Task EventHubConnectSend(int sendCount) { var cs = @"Endpoint=sb://yournamespace.servicebus.windows.net/;SharedAccessKeyName=YourPublisher;SharedAccessKey=12EHa5NNllnZBz6gksogvNfhketIokdTdjx4ZrTfu9U="; var builder = new ServiceBusConnectionStringBuilder(cs) { TransportType = TransportType.Amqp }; var client = EventHubClient.CreateFromConnectionString(builder.ToString(), "swiftsoftware-eh"); int sentCount = sendCount; string infoText; for (int i = 0; i < sendCount; i++) { try { if (MessageType.Text == "Sensor") { infoText = "Operating Within Expected Parameters"; } else { infoText = "Temperature Sensor Requires Calibration"; } Random rnd = new Random(); int intTemp = rnd.Next(15, 25); int intHum = rnd.Next(50, 80); var e = new Event { MessageType = MessageType.Text, Temp = intTemp, Humidity = intHum, Location = Location.Text, Room = Room.Text, Info = infoText }; var serializedString = JsonConvert.SerializeObject(e); var data = new EventData(Encoding.UTF8.GetBytes(serializedString)) { PartitionKey = rnd.Next(6).ToString() }; // Set user properties if needed data.Properties.Add("Type", "Telemetry_" + DateTime.Now.ToLongTimeString()); await client.SendAsync(data).ConfigureAwait(false); } catch (Exception exp) { Console.WriteLine("Error on send: " + exp.Message); sentCount--; } await Task.Delay(Convert.ToInt32(DelayTime.Text)); } MessageResult.Text = " " + sentCount.ToString() + " " + MessageType.Text + " Messages were successfully sent to Event Hub"; return; }
/// <summary> /// Creates an EventHubReceiver from the given connection sting and partition key. /// The Reliable Dictionaries are used to create a receiver from wherever the service last left off, /// or from the current date/time if it's the first time the service is coming up. /// </summary> /// <param name="connectionString"></param> /// <param name="servicePartitionKey"></param> /// <param name="epochDictionary"></param> /// <param name="offsetDictionary"></param> /// <returns></returns> private async Task<Tuple<EventHubReceiver, MessagingFactory>> ConnectToIoTHubAsync( string connectionString, long servicePartitionKey, IReliableDictionary<string, long> epochDictionary, IReliableDictionary<string, string> offsetDictionary) { // EventHubs doesn't support NetMessaging, so ensure the transport type is AMQP. ServiceBusConnectionStringBuilder connectionStringBuilder = new ServiceBusConnectionStringBuilder(connectionString); connectionStringBuilder.TransportType = TransportType.Amqp; ServiceEventSource.Current.ServiceMessage( this.Context, "RouterService connecting to IoT Hub at {0}", String.Join(",", connectionStringBuilder.Endpoints.Select(x => x.ToString()))); // A new MessagingFactory is created here so that each partition of this service will have its own MessagingFactory. // This gives each partition its own dedicated TCP connection to IoT Hub. MessagingFactory messagingFactory = MessagingFactory.CreateFromConnectionString(connectionStringBuilder.ToString()); EventHubClient eventHubClient = messagingFactory.CreateEventHubClient("messages/events"); EventHubRuntimeInformation eventHubRuntimeInfo = await eventHubClient.GetRuntimeInformationAsync(); EventHubReceiver eventHubReceiver; // Get an IoT Hub partition ID that corresponds to this partition's low key. // This assumes that this service has a partition count 'n' that is equal to the IoT Hub partition count and a partition range of 0..n-1. // For example, given an IoT Hub with 32 partitions, this service should be created with: // partition count = 32 // partition range = 0..31 string eventHubPartitionId = eventHubRuntimeInfo.PartitionIds[servicePartitionKey]; using (ITransaction tx = this.StateManager.CreateTransaction()) { ConditionalValue<string> offsetResult = await offsetDictionary.TryGetValueAsync(tx, "offset", LockMode.Default); ConditionalValue<long> epochResult = await epochDictionary.TryGetValueAsync(tx, "epoch", LockMode.Update); long newEpoch = epochResult.HasValue ? epochResult.Value + 1 : 0; if (offsetResult.HasValue) { // continue where the service left off before the last failover or restart. ServiceEventSource.Current.ServiceMessage( this.Context, "Creating EventHub listener on partition {0} with offset {1}", eventHubPartitionId, offsetResult.Value); eventHubReceiver = await eventHubClient.GetDefaultConsumerGroup().CreateReceiverAsync(eventHubPartitionId, offsetResult.Value, newEpoch); } else { // first time this service is running so there is no offset value yet. // start with the current time. ServiceEventSource.Current.ServiceMessage( this.Context, "Creating EventHub listener on partition {0} with offset {1}", eventHubPartitionId, DateTime.UtcNow); eventHubReceiver = await eventHubClient.GetDefaultConsumerGroup() .CreateReceiverAsync(eventHubPartitionId, DateTime.UtcNow, newEpoch); } // epoch is recorded each time the service fails over or restarts. await epochDictionary.SetAsync(tx, "epoch", newEpoch); await tx.CommitAsync(); } return new Tuple<EventHubReceiver, MessagingFactory>(eventHubReceiver, messagingFactory); }
static string GetAmqpConnectionString() { ServiceBusConnectionStringBuilder builder = new ServiceBusConnectionStringBuilder(connectionString); builder.TransportType = TransportType.Amqp; return builder.ToString(); }
static void Main(string[] args) { // Get the executing server's FQDN...this will be used for the Host paroperty of the sb endpoint. // I initially neglected to populate this value which resulted in errors resolving the namespace at // runtime when an attempt was made to connect to the sb instance. ServerFQDN = System.Net.Dns.GetHostEntry(string.Empty).HostName; // Build the Service Bus connection string ServiceBusConnectionStringBuilder connBuilder = new ServiceBusConnectionStringBuilder(); connBuilder.ManagementPort = HttpPort; connBuilder.RuntimePort = TcpPort; UriBuilder runtimeAddress = new UriBuilder() { Scheme = "sb", // this scheme is for TCP Host = ServerFQDN, Path = ServiceNamespace }; connBuilder.Endpoints.Add(runtimeAddress.Uri); UriBuilder mgmtAddress = new UriBuilder() { Scheme = "https", Host = ServerFQDN, Port = HttpPort, Path = ServiceNamespace }; connBuilder.StsEndpoints.Add(mgmtAddress.Uri); //TODO: Identify specifics of purpose of // NamespaceManager instance... NamespaceManager namespaceManager = NamespaceManager.CreateFromConnectionString(connBuilder.ToString()); MessagingFactory messageFactory = MessagingFactory.CreateFromConnectionString(connBuilder.ToString()); // Now create queue on the fly if (namespaceManager == null) { Console.WriteLine("\nUnexpected Error: NamespaceManager is NULL"); return; } if (namespaceManager.QueueExists(QueueName)) { namespaceManager.DeleteQueue(QueueName); } namespaceManager.CreateQueue(QueueName); // Create a queue client to send and receive messages to and from the queue QueueClient queueClient = messageFactory.CreateQueueClient(QueueName); // Create a simple brokered message and send it to the queue. BrokeredMessage messageToSend = new BrokeredMessage("Hello World! I used GitHub with this solution!"); queueClient.Send(messageToSend); // Receive the message back from the queue. BrokeredMessage receivedMessage = queueClient.Receive(TimeSpan.FromSeconds(5)); if (receivedMessage != null) { Console.WriteLine(string.Format("Message rceived: Body = {0}", receivedMessage.GetBody<string>())); receivedMessage.Complete(); } // Clean up. if (messageFactory != null) { messageFactory.Close(); } Console.ReadLine(); }
/// <summary> /// Returns Service Bus connection string to use. /// </summary> public string BuildConnectionString() { if (OperationTimeout != null) { var connectionStringBuilder = new ServiceBusConnectionStringBuilder(ConnectionString); connectionStringBuilder.OperationTimeout = OperationTimeout.Value; return connectionStringBuilder.ToString(); } return ConnectionString; }
string GetEventHubConnectionString() { var connectionString = ConfigurationManager.AppSettings["Microsoft.ServiceBus.ConnectionString"]; if (string.IsNullOrEmpty(connectionString)) { Console.WriteLine("Did not find Service Bus connections string in appsettings (app.config)"); return string.Empty; } try { var builder = new ServiceBusConnectionStringBuilder(connectionString); builder.TransportType = Microsoft.ServiceBus.Messaging.TransportType.Amqp; return builder.ToString(); } catch (Exception exception) { Console.ForegroundColor = ConsoleColor.Red; Console.WriteLine(exception.Message); Console.ResetColor(); } return null; }
public void InitializeEventHub() { Context.Logger.Info("Current AppConfig File: " + ConfigurationManager.OpenExeConfiguration(ConfigurationUserLevel.None)); Context.Logger.Info("Current AppSettings: " + String.Join(Environment.NewLine, ConfigurationManager.AppSettings.AllKeys)); this.EventHubNamespace = ConfigurationManager.AppSettings["EventHubNamespace"]; if (String.IsNullOrWhiteSpace(this.EventHubNamespace)) { throw new ArgumentException("A required AppSetting cannot be null or empty", "EventHubNamespace"); } this.EventHubEntityPath = ConfigurationManager.AppSettings["EventHubEntityPath"]; if (String.IsNullOrWhiteSpace(this.EventHubEntityPath)) { throw new ArgumentException("A required AppSetting cannot be null or empty", "EventHubEntityPath"); } this.EventHubSharedAccessKeyName = ConfigurationManager.AppSettings["EventHubSharedAccessKeyName"]; if (String.IsNullOrWhiteSpace(this.EventHubSharedAccessKeyName)) { throw new ArgumentException("A required AppSetting cannot be null or empty", "EventHubSharedAccessKeyName"); } this.EventHubSharedAccessKey = ConfigurationManager.AppSettings["EventHubSharedAccessKey"]; if (String.IsNullOrWhiteSpace(this.EventHubSharedAccessKey)) { throw new ArgumentException("A required AppSetting cannot be null or empty", "EventHubSharedAccessKey"); } this.EventHubPartitions = ConfigurationManager.AppSettings["EventHubPartitions"]; if (String.IsNullOrWhiteSpace(this.EventHubPartitions)) { throw new ArgumentException("A required AppSetting cannot be null or empty", "EventHubPartitions"); } var builder = new ServiceBusConnectionStringBuilder(); builder.Endpoints.Add(new Uri("sb://" + this.EventHubNamespace + "." + EventHubFqnAddress)); builder.EntityPath = this.EventHubEntityPath; builder.SharedAccessKeyName = this.EventHubSharedAccessKeyName; builder.SharedAccessKey = this.EventHubSharedAccessKey; builder.TransportType = TransportType.Amqp; var partitionCount = int.Parse(this.EventHubPartitions); TopologyContext topologyContext = Context.TopologyContext; Context.Logger.Info(this.GetType().Name + " TopologyContext info:"); Context.Logger.Info("TaskId: {0}", topologyContext.GetThisTaskId()); var taskIndex = topologyContext.GetThisTaskIndex(); Context.Logger.Info("TaskIndex: {0}", taskIndex); string componentId = topologyContext.GetThisComponentId(); Context.Logger.Info("ComponentId: {0}", componentId); List<int> componentTasks = topologyContext.GetComponentTasks(componentId); Context.Logger.Info("ComponentTasks: {0}", componentTasks.Count); if (partitionCount != componentTasks.Count) { throw new Exception( String.Format("Component task count does not match partition count. Component: {0}, Tasks: {1}, Partition: {2}", componentId, componentTasks.Count, partitionCount)); } partitionId = taskIndex.ToString(); Context.Logger.Info(this.GetType().Name + " ConnectionString = {0}, ParitionId = {1}", builder.ToString(), partitionId); eventHubClient = EventHubClient.CreateFromConnectionString(builder.ToString()); eventHubSender = eventHubClient.CreatePartitionedSender(partitionId); }
public void InitializeEventHub() { Context.Logger.Info("Initializing EventHubClient and EventHubSender..."); var builder = new ServiceBusConnectionStringBuilder(); builder.Endpoints.Add(new Uri("sb://" + this.appConfig.EventHubNamespace + "." + this.appConfig.EventHubFqnAddress)); builder.EntityPath = this.appConfig.EventHubEntityPath; builder.SharedAccessKeyName = this.appConfig.EventHubSharedAccessKeyName; builder.SharedAccessKey = this.appConfig.EventHubSharedAccessKey; builder.TransportType = TransportType.Amqp; Context.Logger.Info("EventHubWriter: ConnectionString = {0} ParitionId = {1}", builder.ToString(), Context.TopologyContext.GetThisTaskIndex()); eventHubClient = EventHubClient.CreateFromConnectionString(builder.ToString()); //TODO: Implement a distribution strategy of partitions in case number of bolt tasks is less than partitions in EventHub eventHubSender = eventHubClient.CreatePartitionedSender(Context.TopologyContext.GetThisTaskIndex().ToString()); }
public async void DoesntIgnoreDefinedTimeoutWhenReceiving(AzureServiceBusMode mode, int operationTimeoutInSeconds) { var operationTimeout = TimeSpan.FromSeconds(operationTimeoutInSeconds); var connString = StandardAzureServiceBusTransportFactory.ConnectionString; var builder = new ServiceBusConnectionStringBuilder(connString) { OperationTimeout = operationTimeout }; var newConnString = builder.ToString(); var consoleLoggerFactory = new ConsoleLoggerFactory(false); var transport = new AzureServiceBusTransport(newConnString, QueueName, consoleLoggerFactory, new TplAsyncTaskFactory(consoleLoggerFactory), new BusLifetimeEvents()); Using(transport); transport.PurgeInputQueue(); //Create the queue for the receiver since it cannot create it self beacuse of lacking rights on the namespace transport.CreateQueue(QueueName); var senderActivator = new BuiltinHandlerActivator(); var senderBus = Configure.With(senderActivator) .Transport(t => t.UseAzureServiceBus(newConnString, "sender", mode)) .Start(); Using(senderBus); // queue 3 messages await senderBus.Advanced.Routing.Send(QueueName, "message to receiver"); await senderBus.Advanced.Routing.Send(QueueName, "message to receiver2"); await senderBus.Advanced.Routing.Send(QueueName, "message to receiver3"); await Task.Delay(TimeSpan.FromSeconds(2)); // wait a bit to make sure the messages are queued. // receive 1 using (var transactionContext = new DefaultTransactionContext()) { var sw = System.Diagnostics.Stopwatch.StartNew(); var msg = await transport.Receive(transactionContext); sw.Stop(); await transactionContext.Complete(); msg.Should().NotBeNull(); sw.Elapsed.Should().BeLessThan(TimeSpan.FromMilliseconds(1500)); } // receive 2 using (var transactionContext = new DefaultTransactionContext()) { var sw = System.Diagnostics.Stopwatch.StartNew(); var msg = await transport.Receive(transactionContext); sw.Stop(); await transactionContext.Complete(); msg.Should().NotBeNull(); sw.Elapsed.Should().BeLessThan(TimeSpan.FromMilliseconds(1500)); } // receive 3 using (var transactionContext = new DefaultTransactionContext()) { var sw = System.Diagnostics.Stopwatch.StartNew(); var msg = await transport.Receive(transactionContext); sw.Stop(); await transactionContext.Complete(); msg.Should().NotBeNull(); sw.Elapsed.Should().BeLessThan(TimeSpan.FromMilliseconds(1500)); } // receive 4 - NOTHING using (var transactionContext = new DefaultTransactionContext()) { var sw = System.Diagnostics.Stopwatch.StartNew(); var msg = await transport.Receive(transactionContext); sw.Stop(); await transactionContext.Complete(); msg.Should().BeNull(); sw.Elapsed.Should().BeCloseTo(operationTimeout, 2000); } // put 1 more message await senderBus.Advanced.Routing.Send(QueueName, "message to receiver5"); await Task.Delay(TimeSpan.FromSeconds(2)); // wait a bit to make sure the messages are queued. // receive 5 using (var transactionContext = new DefaultTransactionContext()) { var sw = System.Diagnostics.Stopwatch.StartNew(); var msg = await transport.Receive(transactionContext); sw.Stop(); await transactionContext.Complete(); msg.Should().NotBeNull(); sw.Elapsed.Should().BeLessThan(TimeSpan.FromMilliseconds(1500)); } // receive 6 - NOTHING using (var transactionContext = new DefaultTransactionContext()) { var sw = System.Diagnostics.Stopwatch.StartNew(); var msg = await transport.Receive(transactionContext); sw.Stop(); await transactionContext.Complete(); msg.Should().BeNull(); sw.Elapsed.Should().BeCloseTo(operationTimeout, 2000); } }
private async Task StartInternalAsync(OnlineTrainerSettingsInternal settings, OnlineTrainerState state = null, byte[] model = null) { this.LastStartDateTimeUtc = DateTime.UtcNow; this.perfCounters = new PerformanceCounters(settings.Metadata.ApplicationID); // setup trainer this.trainer = new Learner(settings, this.DelayedExampleCallback, this.perfCounters); if (settings.ForceFreshStart || model != null) this.trainer.FreshStart(state, model); else await this.trainer.FindAndResumeFromState(); // setup factory this.trainProcessorFactory = new TrainEventProcessorFactory(settings, this.trainer, this.perfCounters); // setup host var serviceBusConnectionStringBuilder = new ServiceBusConnectionStringBuilder(settings.JoinedEventHubConnectionString); var joinedEventhubName = serviceBusConnectionStringBuilder.EntityPath; serviceBusConnectionStringBuilder.EntityPath = string.Empty; this.eventProcessorHost = new EventProcessorHost(settings.Metadata.ApplicationID, joinedEventhubName, EventHubConsumerGroup.DefaultGroupName, serviceBusConnectionStringBuilder.ToString(), settings.StorageConnectionString); await this.eventProcessorHost.RegisterEventProcessorFactoryAsync( this.trainProcessorFactory, new EventProcessorOptions { InitialOffsetProvider = this.InitialOffsetProvider }); // don't perform too often this.perfUpdater = new SafeTimer( TimeSpan.FromMilliseconds(500), this.UpdatePerformanceCounters); this.telemetry.TrackTrace( "OnlineTrainer started", SeverityLevel.Information, new Dictionary<string, string> { { "CheckpointPolicy", settings.CheckpointPolicy.ToString() }, { "VowpalWabbit", settings.Metadata.TrainArguments }, { "ExampleTracing", settings.EnableExampleTracing.ToString() } }); }