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());
            }
        }
        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();
            }

        }
        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);
        }
        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();
        }
예제 #5
0
        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;
        }
예제 #6
0
        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();
            }
        }
예제 #7
0
 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();
 }
예제 #8
0
        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 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();
     
    
 }
예제 #10
0
        /// <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;
        }
예제 #11
0
        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();
        }
예제 #12
0
        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 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();
        }
        public async Task Run(string connectionString)
        {
            var connectionStringBuilder = new ServiceBusConnectionStringBuilder(connectionString);
            var listenAddress = new UriBuilder(connectionStringBuilder.GetAbsoluteRuntimeEndpoints()[0])
            {
                Path = connectionStringBuilder.EntityPath ?? "relay"
            }.ToString();

            TokenProvider tokenProvider = null;
            if (connectionStringBuilder.SharedAccessKeyName != null &&
                connectionStringBuilder.SharedAccessKey != null)
            {
                tokenProvider =
                    TokenProvider.CreateSharedAccessSignatureTokenProvider(connectionStringBuilder.SharedAccessKeyName,
                        connectionStringBuilder.SharedAccessKey);
            }
            else if (connectionStringBuilder.SharedAccessSignature != null)
            {
                tokenProvider =
                    TokenProvider.CreateSharedAccessSignatureTokenProvider(connectionStringBuilder.SharedAccessSignature);
            }
            else if (connectionStringBuilder.SharedSecretIssuerName != null &&
                     connectionStringBuilder.SharedSecretIssuerSecret != null)
            {
                tokenProvider =
                    TokenProvider.CreateSharedSecretTokenProvider(connectionStringBuilder.SharedSecretIssuerName,
                        connectionStringBuilder.SharedSecretIssuerSecret);
            }

            if (tokenProvider != null)
            {
                using (var host = new ServiceHost(this))
                {
                    host.AddServiceEndpoint(
                        GetType(),
                        new NetTcpRelayBinding {IsDynamic = true},
                        listenAddress)
                        .EndpointBehaviors.Add(
                            new TransportClientEndpointBehavior(tokenProvider));

                    host.Open();
                    Console.WriteLine("Service listening at address {0}", listenAddress);
                    Console.WriteLine("Press [Enter] to close the listener and exit.");
                    Console.ReadLine();
                    host.Close();
                }
            }
        }
        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();
            }
        }
        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 Task Run(string connectionString)
        {
            var connectionStringBuilder = new ServiceBusConnectionStringBuilder(connectionString);
            var sendAddress = new UriBuilder(connectionStringBuilder.GetAbsoluteRuntimeEndpoints()[0])
            {
                Path = connectionStringBuilder.EntityPath ?? "relay"
            }.ToString();

            TokenProvider tokenProvider = null;
            if (connectionStringBuilder.SharedAccessKeyName != null &&
                connectionStringBuilder.SharedAccessKey != null)
            {
                tokenProvider = TokenProvider.CreateSharedAccessSignatureTokenProvider(connectionStringBuilder.SharedAccessKeyName, connectionStringBuilder.SharedAccessKey);
            }
            else if (connectionStringBuilder.SharedAccessSignature != null)
            {
                tokenProvider = TokenProvider.CreateSharedAccessSignatureTokenProvider(connectionStringBuilder.SharedAccessSignature);
            }
            else if (connectionStringBuilder.SharedSecretIssuerName != null && 
                      connectionStringBuilder.SharedSecretIssuerSecret != null)
            {
                tokenProvider = TokenProvider.CreateSharedSecretTokenProvider(connectionStringBuilder.SharedSecretIssuerName, connectionStringBuilder.SharedSecretIssuerSecret);
            }

            if (tokenProvider != null)
            {
                var cf = new ChannelFactory<IClient>(
                    new NetTcpRelayBinding {IsDynamic = true},
                    sendAddress);

                cf.Endpoint.EndpointBehaviors.Add(new TransportClientEndpointBehavior(tokenProvider));

                using (var client = cf.CreateChannel())
                {
                    for (int i = 1; i <= 25; i++)
                    {
                        var result = await client.Echo(DateTime.UtcNow.ToString());
                        Console.WriteLine("Round {0}, Echo: {1}", i, result);
                    }
                    client.Close();
                }
            }

            Console.WriteLine("Press [Enter] to exit.");
            Console.ReadLine();
        }
예제 #18
0
        private static async void CreateHashForDevice(string deviceName, string eventHubName, string serviceBus)
        {
            string serviceBusConnectionString = Constants.GetBusConnectionString(serviceBus, "configure", Constants.ConsumerHash);
            var connectionString = new ServiceBusConnectionStringBuilder(serviceBusConnectionString);

            var namespaceManager = NamespaceManager.CreateFromConnectionString(serviceBusConnectionString);
            var ehd = await namespaceManager.GetEventHubAsync(eventHubName);

            // Create a customer SAS rule with Manage permissions
            ehd.UserMetadata = deviceName;
            string ruleName = deviceName;
            string ruleKey = SharedAccessAuthorizationRule.GenerateRandomKey();
            ehd.Authorization.Add(new SharedAccessAuthorizationRule(ruleName, ruleKey, new AccessRights[] { AccessRights.Send }));
            namespaceManager.UpdateEventHubAsync(ehd).Wait();

            Console.ForegroundColor = ConsoleColor.Cyan;
            Console.WriteLine(String.Format("{0} => {1}", deviceName, ruleKey));
        }
예제 #19
0
파일: Form1.cs 프로젝트: Mecabot/IoT
        private void button1_Click(object sender, EventArgs e)
        {

            string EventHubName = eventhubnametext.Text;
            string serviceBusConnectionString = sbconnstringtext.Text;

            ServiceBusConnectionStringBuilder connectionString = new ServiceBusConnectionStringBuilder(serviceBusConnectionString);

            string ServiceBusNamespace = connectionString.Endpoints.First().Host;
            string namespaceKeyName = connectionString.SharedAccessKeyName;
            string namespaceKey = connectionString.SharedAccessKey;
            string baseAddressHttp = "http://" + ServiceBusNamespace + "/";
            string eventHubAddress = baseAddressHttp + EventHubName;

            var sas = CreateSasToken(ServiceBusNamespace, namespaceKeyName, namespaceKey);

            sastokentext.Text = sas.ToString();

        }
예제 #20
0
        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();
                
            });

        }
        public void Run(SetEventOnRampMessageReceived setEventOnRampMessageReceived)
        {
            try
            {
                // Assign the delegate
                SetEventOnRampMessageReceived = setEventOnRampMessageReceived;
                // Load vars
                var eventHubConnectionString = ConfigurationBag.Configuration.AzureNameSpaceConnectionString;
                var 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(eventHubConnectionString)
                {
                    TransportType =
                        TransportType.Amqp
                };

                //If not exit it create one, drop brachets because Azure rules
                var eventHubConsumerGroup =
                    string.Concat(ConfigurationBag.EngineName, "_", ConfigurationBag.Configuration.ChannelId)
                    .Replace("{", "")
                    .Replace("}", "")
                    .Replace("-", "");
                var nsManager = NamespaceManager.CreateFromConnectionString(builder.ToString());
                Debug.WriteLine($"Initializing Group Name {eventHubConsumerGroup}");

                Debug.WriteLine("Start DirectRegisterEventReceiving.");

                // 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();
                }

                Debug.WriteLine(
                    "After DirectRegisterEventReceiving Downstream running.");
            }
            catch (Exception ex)
            {
                LogEngine.WriteLog(
                    ConfigurationBag.EngineName,
                    $"Error in {MethodBase.GetCurrentMethod().Name} - Hint: Check if the firewall outbound port 5671 is opened.",
                    Constant.LogLevelError,
                    Constant.TaskCategoriesEventHubs,
                    ex,
                    Constant.LogLevelError);
            }
        }
예제 #22
0
        public IServiceProvider ConfigureServices(IServiceCollection services)
        {
            RegisterAppInsights(services);

            // Add framework services.
            services.AddMvc(options =>
            {
                options.Filters.Add(typeof(HttpGlobalExceptionFilter));
            }).AddControllersAsServices();  //Injecting Controllers themselves thru DI
                                            //For further info see: http://docs.autofac.org/en/latest/integration/aspnetcore.html#controllers-as-services

            services.AddTransient <IOrderingIntegrationEventService, OrderingIntegrationEventService>();

            services.AddHealthChecks(checks =>
            {
                var minutes = 1;
                if (int.TryParse(Configuration["HealthCheck:Timeout"], out var minutesParsed))
                {
                    minutes = minutesParsed;
                }
                checks.AddSqlCheck("OrderingDb", Configuration["ConnectionString"], TimeSpan.FromMinutes(minutes));
            });

            services.AddEntityFrameworkSqlServer()
            .AddDbContext <OrderingContext>(options =>
            {
                options.UseSqlServer(Configuration["ConnectionString"],
                                     sqlServerOptionsAction: sqlOptions =>
                {
                    sqlOptions.MigrationsAssembly(typeof(Startup).GetTypeInfo().Assembly.GetName().Name);
                    sqlOptions.EnableRetryOnFailure(maxRetryCount: 10, maxRetryDelay: TimeSpan.FromSeconds(30), errorNumbersToAdd: null);
                });
            },
                                            ServiceLifetime.Scoped //Showing explicitly that the DbContext is shared across the HTTP request scope (graph of objects started in the HTTP request)
                                            );

            services.AddDbContext <IntegrationEventLogContext>(options =>
            {
                options.UseSqlServer(Configuration["ConnectionString"],
                                     sqlServerOptionsAction: sqlOptions =>
                {
                    sqlOptions.MigrationsAssembly(typeof(Startup).GetTypeInfo().Assembly.GetName().Name);
                    //Configuring Connection Resiliency: https://docs.microsoft.com/en-us/ef/core/miscellaneous/connection-resiliency
                    sqlOptions.EnableRetryOnFailure(maxRetryCount: 10, maxRetryDelay: TimeSpan.FromSeconds(30), errorNumbersToAdd: null);
                });
            });


            services.Configure <OrderSettings>(Configuration);

            services.AddSwaggerGen(options =>
            {
                options.DescribeAllEnumsAsStrings();
                options.SwaggerDoc("v1", new Swashbuckle.AspNetCore.Swagger.Info
                {
                    Title          = "Ordering HTTP API",
                    Version        = "v1",
                    Description    = "The Ordering Service HTTP API",
                    TermsOfService = "Terms Of Service"
                });

                options.AddSecurityDefinition("oauth2", new OAuth2Scheme
                {
                    Type             = "oauth2",
                    Flow             = "implicit",
                    AuthorizationUrl = $"{Configuration.GetValue<string>("IdentityUrlExternal")}/connect/authorize",
                    TokenUrl         = $"{Configuration.GetValue<string>("IdentityUrlExternal")}/connect/token",
                    Scopes           = new Dictionary <string, string>()
                    {
                        { "orders", "Ordering API" }
                    }
                });

                options.OperationFilter <AuthorizeCheckOperationFilter>();
            });

            services.AddCors(options =>
            {
                options.AddPolicy("CorsPolicy",
                                  builder => builder.AllowAnyOrigin()
                                  .AllowAnyMethod()
                                  .AllowAnyHeader()
                                  .AllowCredentials());
            });

            // Add application services.
            services.AddSingleton <IHttpContextAccessor, HttpContextAccessor>();
            services.AddTransient <IIdentityService, IdentityService>();
            services.AddTransient <Func <DbConnection, IIntegrationEventLogService> >(
                sp => (DbConnection c) => new IntegrationEventLogService(c));

            services.AddTransient <IOrderingIntegrationEventService, OrderingIntegrationEventService>();

            if (Configuration.GetValue <bool>("AzureServiceBusEnabled"))
            {
                services.AddSingleton <IServiceBusPersisterConnection>(sp =>
                {
                    var logger = sp.GetRequiredService <ILogger <DefaultServiceBusPersisterConnection> >();

                    var serviceBusConnectionString = Configuration["EventBusConnection"];
                    var serviceBusConnection       = new ServiceBusConnectionStringBuilder(serviceBusConnectionString);

                    return(new DefaultServiceBusPersisterConnection(serviceBusConnection));
                });
            }
            else
            {
                services.AddSingleton <IRabbitMqPersistentConnection>(sp =>
                {
                    var logger = sp.GetRequiredService <ILogger <DefaultRabbitMqPersistentConnection> >();


                    var factory = new ConnectionFactory()
                    {
                        HostName = Configuration["EventBusConnection"]
                    };

                    if (!string.IsNullOrEmpty(Configuration["EventBusUserName"]))
                    {
                        factory.UserName = Configuration["EventBusUserName"];
                    }

                    if (!string.IsNullOrEmpty(Configuration["EventBusPassword"]))
                    {
                        factory.Password = Configuration["EventBusPassword"];
                    }

                    var retryCount = 5;
                    if (!string.IsNullOrEmpty(Configuration["EventBusRetryCount"]))
                    {
                        retryCount = int.Parse(Configuration["EventBusRetryCount"]);
                    }

                    return(new DefaultRabbitMqPersistentConnection(factory, logger, retryCount));
                });
            }

            RegisterEventBus(services);
            ConfigureAuthService(services);
            services.AddOptions();

            //configure autofac

            var container = new ContainerBuilder();

            container.Populate(services);

            container.RegisterModule(new MediatorModule());
            container.RegisterModule(new ApplicationModule(Configuration["ConnectionString"]));

            return(new AutofacServiceProvider(container.Build()));
        }
예제 #23
0
        void ConnectionStringBuilderShouldDefaultToAmqp()
        {
            var csBuilder = new ServiceBusConnectionStringBuilder("Endpoint=sb://contoso.servicebus.windows.net;SharedAccessKeyName=keyname;SharedAccessKey=key");

            Assert.Equal(TransportType.Amqp, csBuilder.TransportType);
        }
예제 #24
0
 public ServiceBusPersisterConnection(ServiceBusConnectionStringBuilder serviceBusConnectionStringBuilder)
 {
     ServiceBusConnectionStringBuilder = serviceBusConnectionStringBuilder;
     _topicClient = new TopicClient(ServiceBusConnectionStringBuilder, RetryPolicy.Default);
 }
        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() }
                });
        }
예제 #26
0
 /// <summary>
 /// Creates a new AMQP MessageSender.
 /// </summary>
 /// <param name="connectionStringBuilder">The <see cref="ServiceBusConnectionStringBuilder"/> having entity level connection details.</param>
 /// <param name="retryPolicy">The <see cref="RetryPolicy"/> that will be used when communicating with Service Bus. Defaults to <see cref="RetryPolicy.Default"/></param>
 /// <remarks>Creates a new connection to the entity, which is opened during the first operation.</remarks>
 public MessageSender(
     ServiceBusConnectionStringBuilder connectionStringBuilder,
     RetryPolicy retryPolicy = null)
     : this(connectionStringBuilder?.GetNamespaceConnectionString(), connectionStringBuilder?.EntityPath, retryPolicy)
 {
 }
        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);
        }
예제 #28
0
파일: Startup.cs 프로젝트: cristinarp/lab3
        public virtual IServiceProvider ConfigureServices(IServiceCollection services)
        {
            RegisterAppInsights(services);

            services.AddCustomHealthCheck(Configuration);

            services.AddControllers(options =>
            {
                options.Filters.Add(typeof(HttpGlobalExceptionFilter));
            })
            // Added for functional tests
            .AddApplicationPart(typeof(LocationsController).Assembly)
            .AddNewtonsoftJson();

            ConfigureAuthService(services);

            services.Configure <LocationSettings>(Configuration);

            if (Configuration.GetValue <bool>("AzureServiceBusEnabled"))
            {
                services.AddSingleton <IServiceBusPersisterConnection>(sp =>
                {
                    var logger = sp.GetRequiredService <ILogger <DefaultServiceBusPersisterConnection> >();

                    var serviceBusConnectionString = Configuration["EventBusConnection"];
                    var serviceBusConnection       = new ServiceBusConnectionStringBuilder(serviceBusConnectionString);

                    return(new DefaultServiceBusPersisterConnection(serviceBusConnection, logger));
                });
            }
            else
            {
                services.AddSingleton <IRabbitMQPersistentConnection>(sp =>
                {
                    var logger = sp.GetRequiredService <ILogger <DefaultRabbitMQPersistentConnection> >();

                    var factory = new ConnectionFactory()
                    {
                        HostName = Configuration["EventBusConnection"],
                        DispatchConsumersAsync = true
                    };

                    if (!string.IsNullOrEmpty(Configuration["EventBusUserName"]))
                    {
                        factory.UserName = Configuration["EventBusUserName"];
                    }

                    if (!string.IsNullOrEmpty(Configuration["EventBusPassword"]))
                    {
                        factory.Password = Configuration["EventBusPassword"];
                    }

                    var retryCount = 5;
                    if (!string.IsNullOrEmpty(Configuration["EventBusRetryCount"]))
                    {
                        retryCount = int.Parse(Configuration["EventBusRetryCount"]);
                    }

                    return(new DefaultRabbitMQPersistentConnection(factory, logger, retryCount));
                });
            }

            RegisterEventBus(services);

            // Add framework services.
            services.AddSwaggerGen(options =>
            {
                options.DescribeAllEnumsAsStrings();
                options.SwaggerDoc("v1", new OpenApiInfo
                {
                    Title       = "eShopOnContainers - Location HTTP API",
                    Version     = "v1",
                    Description = "The Location Microservice HTTP API. This is a Data-Driven/CRUD microservice sample",
                });

                options.AddSecurityDefinition("oauth2", new OpenApiSecurityScheme
                {
                    Type  = SecuritySchemeType.OAuth2,
                    Flows = new OpenApiOAuthFlows()
                    {
                        Implicit = new OpenApiOAuthFlow()
                        {
                            AuthorizationUrl = new Uri($"{Configuration.GetValue<string>("IdentityUrlExternal")}/connect/authorize"),
                            TokenUrl         = new Uri($"{Configuration.GetValue<string>("IdentityUrlExternal")}/connect/token"),
                            Scopes           = new Dictionary <string, string>()
                            {
                                { "locations", "Locations API" }
                            }
                        }
                    }
                });

                options.OperationFilter <AuthorizeCheckOperationFilter>();
            });

            services.AddCors(options =>
            {
                options.AddPolicy("CorsPolicy",
                                  builder => builder
                                  .SetIsOriginAllowed((host) => true)
                                  .AllowAnyMethod()
                                  .AllowAnyHeader()
                                  .AllowCredentials());
            });

            services.AddSingleton <IHttpContextAccessor, HttpContextAccessor>();
            services.AddTransient <IIdentityService, IdentityService>();
            services.AddTransient <ILocationsService, LocationsService>();
            services.AddTransient <ILocationsRepository, LocationsRepository>();

            //configure autofac
            var container = new ContainerBuilder();

            container.Populate(services);

            return(new AutofacServiceProvider(container.Build()));
        }
예제 #29
0
        public IServiceProvider ConfigureServices(IServiceCollection services)
        {
            // Add framework services.

            RegisterAppInsights(services);

            services.AddHealthChecks(checks =>
            {
                var minutes = 1;
                if (int.TryParse(Configuration["HealthCheck:Timeout"], out var minutesParsed))
                {
                    minutes = minutesParsed;
                }
                checks.AddMySQLCheck("CatalogDb", Configuration["ConnectionString"], TimeSpan.FromMinutes(minutes));

                var accountName = Configuration.GetValue <string>("AzureStorageAccountName");
                var accountKey  = Configuration.GetValue <string>("AzureStorageAccountKey");
                if (!string.IsNullOrEmpty(accountName) && !string.IsNullOrEmpty(accountKey))
                {
                    checks.AddAzureBlobStorageCheck(accountName, accountKey);
                }
            });

            services.AddMvc(options =>
            {
                options.Filters.Add(typeof(HttpGlobalExceptionFilter));
            }).AddControllersAsServices();

            services.AddDbContext <CatalogContext>(options =>
            {
                options.UseMySql(Configuration["ConnectionString"],
                                 mySqlOptionsAction: sqlOptions =>
                {
                    sqlOptions.MigrationsAssembly(typeof(Startup).GetTypeInfo().Assembly.GetName().Name);
                    //Configuring Connection Resiliency: https://docs.microsoft.com/en-us/ef/core/miscellaneous/connection-resiliency
                    sqlOptions.EnableRetryOnFailure(maxRetryCount: 10, maxRetryDelay: TimeSpan.FromSeconds(30), errorNumbersToAdd: null);
                });

                // Changing default behavior when client evaluation occurs to throw.
                // Default in EF Core would be to log a warning when client evaluation is performed.
                options.ConfigureWarnings(warnings => warnings.Throw(RelationalEventId.QueryClientEvaluationWarning));
                //Check Client vs. Server evaluation: https://docs.microsoft.com/en-us/ef/core/querying/client-eval
            });

            services.AddDbContext <IntegrationEventLogContext>(options =>
            {
                options.UseMySql(Configuration["ConnectionString"],
                                 mySqlOptionsAction: sqlOptions =>
                {
                    sqlOptions.MigrationsAssembly(typeof(Startup).GetTypeInfo().Assembly.GetName().Name);
                    //Configuring Connection Resiliency: https://docs.microsoft.com/en-us/ef/core/miscellaneous/connection-resiliency
                    sqlOptions.EnableRetryOnFailure(maxRetryCount: 10, maxRetryDelay: TimeSpan.FromSeconds(30), errorNumbersToAdd: null);
                });
            });

            services.Configure <ServiceCatalogSettings>(Configuration);

            // Add framework services.
            services.AddSwaggerGen(options =>
            {
                options.DescribeAllEnumsAsStrings();
                options.SwaggerDoc("v1", new Swashbuckle.AspNetCore.Swagger.Info
                {
                    Title          = "Book2 - Service Catalog HTTP API",
                    Version        = "v1",
                    Description    = "The Service Catalog Microservice HTTP API. This is a Data-Driven/CRUD microservice",
                    TermsOfService = "Terms Of Service"
                });
            });

            services.AddCors(options =>
            {
                options.AddPolicy("CorsPolicy",
                                  builder => builder.AllowAnyOrigin()
                                  .AllowAnyMethod()
                                  .AllowAnyHeader()
                                  .AllowCredentials());
            });

            services.AddTransient <Func <DbConnection, IIntegrationEventLogService> >(
                sp => (DbConnection c) => new IntegrationEventLogService(c));

            services.AddTransient <ICatalogIntegrationEventService, CatalogIntegrationEventService>();

            if (Configuration.GetValue <bool>("AzureServiceBusEnabled"))
            {
                services.AddSingleton <IServiceBusPersisterConnection>(sp =>
                {
                    var settings = sp.GetRequiredService <IOptions <ServiceCatalogSettings> >().Value;
                    var logger   = sp.GetRequiredService <ILogger <DefaultServiceBusPersisterConnection> >();

                    var serviceBusConnection = new ServiceBusConnectionStringBuilder(settings.EventBusConnection);

                    return(new DefaultServiceBusPersisterConnection(serviceBusConnection, logger));
                });
            }
            else
            {
                services.AddSingleton <IRabbitMQPersistentConnection>(sp =>
                {
                    var settings = sp.GetRequiredService <IOptions <ServiceCatalogSettings> >().Value;
                    var logger   = sp.GetRequiredService <ILogger <DefaultRabbitMQPersistentConnection> >();

                    var factory = new ConnectionFactory()
                    {
                        HostName = Configuration["EventBusConnection"]
                    };

                    if (!string.IsNullOrEmpty(Configuration["EventBusUserName"]))
                    {
                        factory.UserName = Configuration["EventBusUserName"];
                    }

                    if (!string.IsNullOrEmpty(Configuration["EventBusPassword"]))
                    {
                        factory.Password = Configuration["EventBusPassword"];
                    }

                    var retryCount = 5;
                    if (!string.IsNullOrEmpty(Configuration["EventBusRetryCount"]))
                    {
                        retryCount = int.Parse(Configuration["EventBusRetryCount"]);
                    }

                    return(new DefaultRabbitMQPersistentConnection(factory, logger, retryCount));
                });
            }

            RegisterEventBus(services);

            var container = new ContainerBuilder();

            container.Populate(services);
            return(new AutofacServiceProvider(container.Build()));
        }
예제 #30
0
        static void Run()
        {
            var properties = new Dictionary <string, string>
            {
                { servicebusNamespace, null },
                { servicebusEntityPath, null },
                { servicebusFqdnSuffix, null },
                { servicebusSendKey, null },
                { servicebusListenKey, null },
                { servicebusManageKey, null }
            };

            // read the settings file created by the ./setup.ps1 file
            var settingsFile = Path.Combine(
                Environment.GetFolderPath(Environment.SpecialFolder.UserProfile),
                samplePropertiesFileName);

            if (File.Exists(settingsFile))
            {
                using (var fs = new StreamReader(settingsFile))
                {
                    while (!fs.EndOfStream)
                    {
                        var readLine = fs.ReadLine();
                        if (readLine != null)
                        {
                            var propl = readLine.Trim();
                            var cmt   = propl.IndexOf('#');
                            if (cmt > -1)
                            {
                                propl = propl.Substring(0, cmt).Trim();
                            }
                            if (propl.Length > 0)
                            {
                                var propi = propl.IndexOf('=');
                                if (propi == -1)
                                {
                                    continue;
                                }
                                var propKey = propl.Substring(0, propi - 1).Trim();
                                var propVal = propl.Substring(propi + 1).Trim();
                                if (properties.ContainsKey(propKey))
                                {
                                    properties[propKey] = propVal;
                                }
                            }
                        }
                    }
                }
            }

            // get overrides from the environment
            foreach (var prop in properties)
            {
                var env = Environment.GetEnvironmentVariable(prop.Key);
                if (env != null)
                {
                    properties[prop.Key] = env;
                }
            }

            var hostName  = properties[servicebusNamespace] + "." + properties[servicebusFqdnSuffix];
            var rootUri   = new UriBuilder("http", hostName, -1, "/").ToString();
            var netTcpUri = new UriBuilder("sb", hostName, -1, properties[servicebusEntityPath] + "/NetTcp").ToString();
            var httpUri   = new UriBuilder("https", hostName, -1, properties[servicebusEntityPath] + "/Http").ToString();

            var program = Activator.CreateInstance(typeof(Program));

            if (program is ITcpListenerSampleUsingKeys)
            {
                ((ITcpListenerSampleUsingKeys)program).Run(
                    netTcpUri,
                    "samplelisten",
                    properties[servicebusListenKey])
                .GetAwaiter()
                .GetResult();
            }
            else if (program is ITcpSenderSampleUsingKeys)
            {
                ((ITcpSenderSampleUsingKeys)program).Run(netTcpUri, "samplesend", properties[servicebusSendKey])
                .GetAwaiter()
                .GetResult();
            }
            if (program is IHttpListenerSampleUsingKeys)
            {
                ((IHttpListenerSampleUsingKeys)program).Run(
                    httpUri,
                    "samplelisten",
                    properties[servicebusListenKey])
                .GetAwaiter()
                .GetResult();
            }
            else if (program is IHttpSenderSampleUsingKeys)
            {
                ((IHttpSenderSampleUsingKeys)program).Run(httpUri, "samplesend", properties[servicebusSendKey])
                .GetAwaiter()
                .GetResult();
            }

            if (program is ITcpListenerSample)
            {
                var token =
                    TokenProvider.CreateSharedAccessSignatureTokenProvider(
                        "samplelisten",
                        properties[servicebusListenKey])
                    .GetWebTokenAsync(netTcpUri, string.Empty, true, TimeSpan.FromHours(1)).GetAwaiter().GetResult();
                ((ITcpListenerSample)program).Run(netTcpUri, token).GetAwaiter().GetResult();
            }
            else if (program is ITcpSenderSample)
            {
                var token =
                    TokenProvider.CreateSharedAccessSignatureTokenProvider(
                        "samplesend",
                        properties[servicebusSendKey])
                    .GetWebTokenAsync(netTcpUri, string.Empty, true, TimeSpan.FromHours(1)).GetAwaiter().GetResult();
                ((ITcpSenderSample)program).Run(netTcpUri, token).GetAwaiter().GetResult();
            }
            if (program is IHttpListenerSample)
            {
                var token =
                    TokenProvider.CreateSharedAccessSignatureTokenProvider(
                        "samplelisten",
                        properties[servicebusListenKey])
                    .GetWebTokenAsync(httpUri, string.Empty, true, TimeSpan.FromHours(1)).GetAwaiter().GetResult();
                ((IHttpListenerSample)program).Run(httpUri, token).GetAwaiter().GetResult();
            }
            else if (program is IHttpSenderSample)
            {
                var token =
                    TokenProvider.CreateSharedAccessSignatureTokenProvider(
                        "samplesend",
                        properties[servicebusSendKey])
                    .GetWebTokenAsync(httpUri, string.Empty, true, TimeSpan.FromHours(1)).GetAwaiter().GetResult();
                ((IHttpSenderSample)program).Run(httpUri, token).GetAwaiter().GetResult();
            }
            else if (program is IDynamicSenderSample)
            {
                var token =
                    TokenProvider.CreateSharedAccessSignatureTokenProvider(
                        "rootsamplesend",
                        properties[servicebusSendKey])
                    .GetWebTokenAsync(rootUri, string.Empty, true, TimeSpan.FromHours(1)).GetAwaiter().GetResult();
                ((IDynamicSenderSample)program).Run(hostName, token).GetAwaiter().GetResult();
            }
            else if (program is IDynamicListenerSample)
            {
                var token =
                    TokenProvider.CreateSharedAccessSignatureTokenProvider(
                        "rootsamplelisten",
                        properties[servicebusListenKey])
                    .GetWebTokenAsync(rootUri, string.Empty, true, TimeSpan.FromHours(1)).GetAwaiter().GetResult();
                ((IDynamicListenerSample)program).Run(hostName, token).GetAwaiter().GetResult();
            }
            else if (program is IDynamicSample)
            {
                var token =
                    TokenProvider.CreateSharedAccessSignatureTokenProvider(
                        "rootsamplemanage",
                        properties[servicebusManageKey])
                    .GetWebTokenAsync(rootUri, string.Empty, true, TimeSpan.FromHours(1)).GetAwaiter().GetResult();
                ((IDynamicSample)program).Run(hostName, token).GetAwaiter().GetResult();
            }
            else if (program is IConnectionStringSample)
            {
                var connectionString =
                    ServiceBusConnectionStringBuilder.CreateUsingSharedAccessKey(
                        new Uri(rootUri), "rootsamplemanage",
                        properties[servicebusManageKey]);

                ((IConnectionStringSample)program).Run(connectionString).GetAwaiter().GetResult();
            }
        }
예제 #31
0
        private void btnSave_Click(object sender, EventArgs e)
        {
            try
            {
                if (string.IsNullOrWhiteSpace(txtUri.Text))
                {
                    MainForm.StaticWriteToLog("The connection string of the Service Bus namespace cannot be null.");
                    return;
                }
                ServiceBusConnectionStringBuilder serviceBusConnectionStringBuilder;
                try
                {
                    serviceBusConnectionStringBuilder = new ServiceBusConnectionStringBuilder(txtUri.Text);
                }
                catch (Exception)
                {
                    MainForm.StaticWriteToLog("The format of the connection string is invalid.");
                    return;
                }

                if (serviceBusConnectionStringBuilder.Endpoints == null ||
                    serviceBusConnectionStringBuilder.Endpoints.Count == 0)
                {
                    MainForm.StaticWriteToLog("The connection string does not contain any endpoint.");
                    return;
                }

                var host = serviceBusConnectionStringBuilder.Endpoints.ToArray()[0].Host;

                var index = host.IndexOf(".", StringComparison.Ordinal);

                var key = index > 0 ? CultureInfo.CurrentCulture.TextInfo.ToTitleCase(host.Substring(0, index)) : "MyNamespace";

                using (var parameterForm = new ParameterForm("Enter the key for the Service Bus namespace",
                                                             new List <string> {
                    "Key"
                },
                                                             new List <string> {
                    key
                },
                                                             new List <bool> {
                    false
                }))
                {
                    if (parameterForm.ShowDialog() != DialogResult.OK)
                    {
                        return;
                    }
                    key = parameterForm.ParameterValues[0];
                    if (string.IsNullOrWhiteSpace(key))
                    {
                        MainForm.StaticWriteToLog("The key of the Service Bus namespace cannot be null.");
                        return;
                    }
                    var value                = txtUri.Text;
                    var configuration        = ConfigurationManager.OpenExeConfiguration(ConfigurationUserLevel.None);
                    var configurationSection = configuration.Sections["serviceBusNamespaces"];
                    var directory            = Path.GetDirectoryName(configuration.FilePath);
                    if (string.IsNullOrEmpty(directory))
                    {
                        MainForm.StaticWriteToLog("The directory of the configuration file cannot be null.");
                        return;
                    }
                    var appConfig = Path.Combine(directory, "..\\..\\App.config");
                    configurationSection.SectionInformation.ForceSave = true;
                    var xml         = configurationSection.SectionInformation.GetRawXml();
                    var xmlDocument = new XmlDocument();
                    xmlDocument.LoadXml(xml);
                    var node = xmlDocument.CreateElement("add");
                    node.SetAttribute("key", key);
                    node.SetAttribute("value", value);
                    xmlDocument.DocumentElement?.AppendChild(node);
                    configurationSection.SectionInformation.SetRawXml(xmlDocument.OuterXml);
                    configuration.Save(ConfigurationSaveMode.Modified);
                    ConfigurationManager.RefreshSection("serviceBusNamespaces");

                    if (File.Exists(appConfig))
                    {
                        var exeConfigurationFileMap = new ExeConfigurationFileMap()
                        {
                            ExeConfigFilename = appConfig
                        };
                        configuration        = ConfigurationManager.OpenMappedExeConfiguration(exeConfigurationFileMap, ConfigurationUserLevel.None);
                        configurationSection = configuration.Sections["serviceBusNamespaces"];
                        configurationSection.SectionInformation.ForceSave = true;
                        xml         = configurationSection.SectionInformation.GetRawXml();
                        xmlDocument = new XmlDocument();
                        xmlDocument.LoadXml(xml);
                        node = xmlDocument.CreateElement("add");
                        node.SetAttribute("key", key);
                        node.SetAttribute("value", value);
                        xmlDocument.DocumentElement?.AppendChild(node);
                        configurationSection.SectionInformation.SetRawXml(xmlDocument.OuterXml);
                        configuration.Save(ConfigurationSaveMode.Modified);
                        ConfigurationManager.RefreshSection("serviceBusNamespaces");
                    }

                    serviceBusHelper.ServiceBusNamespaces.Add(key, MainForm.GetServiceBusNamespace(key, value));
                    cboServiceBusNamespace.Items.Clear();
                    // ReSharper disable once CoVariantArrayConversion
                    cboServiceBusNamespace.Items.AddRange(serviceBusHelper.ServiceBusNamespaces.Keys.OrderBy(s => s).ToArray());
                    cboServiceBusNamespace.Text = key;
                }
            }
            catch (Exception ex)
            {
                HandleException(ex);
            }
        }
예제 #32
0
        public static IServiceCollection AddCustomIntegrations(this IServiceCollection services, IConfiguration configuration)
        {
            services.AddSingleton <IHttpContextAccessor, HttpContextAccessor>();
            services.AddTransient <IIdentityService, IdentityService>();
            services.AddTransient <Func <DbConnection, IIntegrationEventLogService> >(
                sp => (DbConnection c) => new IntegrationEventLogService(c));

            services.AddTransient <IOrderingIntegrationEventService, OrderingIntegrationEventService>();

            if (configuration.GetValue <bool>("AzureServiceBusEnabled"))
            {
                services.AddSingleton <IServiceBusPersisterConnection>(sp =>
                {
                    var logger = sp.GetRequiredService <ILogger <DefaultServiceBusPersisterConnection> >();

                    var serviceBusConnectionString = configuration["EventBusConnection"];
                    var serviceBusConnection       = new ServiceBusConnectionStringBuilder(serviceBusConnectionString);

                    return(new DefaultServiceBusPersisterConnection(serviceBusConnection, logger));
                });
            }
            else if (configuration.GetValue <bool>("RabbitMQBusEnabled"))
            {
                services.AddSingleton <IRabbitMQPersistentConnection>(sp =>
                {
                    var logger = sp.GetRequiredService <ILogger <DefaultRabbitMQPersistentConnection> >();


                    var factory = new ConnectionFactory()
                    {
                        HostName = configuration["EventBusConnection"],
                        DispatchConsumersAsync = true
                    };

                    if (!string.IsNullOrEmpty(configuration["EventBusUserName"]))
                    {
                        factory.UserName = configuration["EventBusUserName"];
                    }

                    if (!string.IsNullOrEmpty(configuration["EventBusPassword"]))
                    {
                        factory.Password = configuration["EventBusPassword"];
                    }

                    var retryCount = 5;
                    if (!string.IsNullOrEmpty(configuration["EventBusRetryCount"]))
                    {
                        retryCount = int.Parse(configuration["EventBusRetryCount"]);
                    }

                    return(new DefaultRabbitMQPersistentConnection(factory, logger, retryCount));
                });
            }
            else
            {
                services.AddSingleton <INCachePersistantConnection>(sp =>
                {
                    var logger = sp.GetRequiredService <ILogger <DefaultNCachePersistentConnection> >();

                    var cacheID = "PubSubCache";
                    if (!string.IsNullOrEmpty(configuration["EventBusNCachID"]))
                    {
                        cacheID = configuration["EventBusNCachID"];
                    }

                    var topicID = "IntegrationEvents";
                    if (!string.IsNullOrEmpty(configuration["EventBusNCachTopicID"]))
                    {
                        topicID = configuration["EventBusNCachTopicID"];
                    }

                    var ipAddresses = configuration.GetValue <string>("PubSubCacheIPAddresses").Split('-');

                    if (ipAddresses.Length == 0)
                    {
                        throw new ArgumentNullException("No IP addresses given for Pub Sub Cache");
                    }

                    for (int i = 0; i < ipAddresses.Length; i++)
                    {
                        ipAddresses[i] = ipAddresses[i].Trim();
                    }

                    var enableNCacheClientLogs = configuration.GetValue <bool>("EnableNCacheClientLogs", false);
                    return(new DefaultNCachePersistentConnection(cacheID, topicID, logger, ipAddresses, enableNCacheClientLogs));
                });
            }

            return(services);
        }
예제 #33
0
        public int Run()
        {
            // Obtain management via .publishsettings file from https://manage.windowsazure.com/publishsettings/index?schemaversion=2.0
            var creds = new CertificateCloudCredentials(SubscriptionId, ManagementCertificate);

            // Create Namespace
            var sbMgmt = new ServiceBusManagementClient(creds);

            ServiceBusNamespaceResponse nsResponse = null;

            Console.WriteLine("Creating Service Bus namespace {0} in location {1}", SBNamespace, Location);
            try
            {
                var resultSb = sbMgmt.Namespaces.Create(SBNamespace, Location);
                if (resultSb.StatusCode != System.Net.HttpStatusCode.OK)
                {
                    Console.WriteLine("Error creating Service Bus namespace {0} in Location {1}: {2}", SBNamespace, Location, resultSb.StatusCode);
                    return(1);
                }
            }
            catch (CloudException)
            {
                try
                {
                    // There is (currently) no clean error code returned when the namespace already exists
                    // Check if it does
                    nsResponse = sbMgmt.Namespaces.Get(SBNamespace);
                    Console.WriteLine("Service Bus namespace {0} already existed.", SBNamespace);
                }
                catch (Exception)
                {
                    nsResponse = null;
                }
                if (nsResponse == null)
                {
                    throw;
                }
            }

            // Wait until the namespace is active
            while (nsResponse == null || nsResponse.Namespace.Status != "Active")
            {
                nsResponse = sbMgmt.Namespaces.Get(SBNamespace);
                if (nsResponse.Namespace.Status == "Active")
                {
                    break;
                }
                Console.WriteLine("Namespace {0} in state {1}. Waiting...", SBNamespace, nsResponse.Namespace.Status);
                System.Threading.Thread.Sleep(5000);
            }

            // Get the namespace connection string
            var nsDescription      = sbMgmt.Namespaces.GetNamespaceDescription(SBNamespace);
            var nsConnectionString = nsDescription.NamespaceDescriptions.First(
                (d) => String.Equals(d.AuthorizationType, "SharedAccessAuthorization")
                ).ConnectionString;

            // Create EHs + device keys + consumer keys (WebSite*)
            var nsManager = NamespaceManager.CreateFromConnectionString(nsConnectionString);

            var ehDescriptionDevices = new EventHubDescription(EventHubNameDevices)
            {
                PartitionCount = 8,
            };

            ehDescriptionDevices.Authorization.Add(new SharedAccessAuthorizationRule("D1", new List <AccessRights> {
                AccessRights.Send
            }));
            ehDescriptionDevices.Authorization.Add(new SharedAccessAuthorizationRule("D2", new List <AccessRights> {
                AccessRights.Send
            }));
            ehDescriptionDevices.Authorization.Add(new SharedAccessAuthorizationRule("D3", new List <AccessRights> {
                AccessRights.Send
            }));
            ehDescriptionDevices.Authorization.Add(new SharedAccessAuthorizationRule("D4", new List <AccessRights> {
                AccessRights.Send
            }));

            ehDescriptionDevices.Authorization.Add(new SharedAccessAuthorizationRule("WebSite", new List <AccessRights> {
                AccessRights.Manage, AccessRights.Listen, AccessRights.Send
            }));

            ehDescriptionDevices.Authorization.Add(new SharedAccessAuthorizationRule("StreamingAnalytics", new List <AccessRights> {
                AccessRights.Manage, AccessRights.Listen, AccessRights.Send
            }));

            Console.WriteLine("Creating Event Hub {0}", EventHubNameDevices);
            EventHubDescription ehDevices = null;

            do
            {
                try
                {
                    ehDevices = nsManager.CreateEventHubIfNotExists(ehDescriptionDevices);
                }
                catch (System.UnauthorizedAccessException)
                {
                    Console.WriteLine("Service Bus connection string not valid yet. Waiting...");
                    System.Threading.Thread.Sleep(5000);
                }
            } while (ehDevices == null);

            var ehDescriptionAlerts = new EventHubDescription(EventHubNameAlerts)
            {
                PartitionCount = 8,
            };

            ehDescriptionAlerts.Authorization.Add(new SharedAccessAuthorizationRule("WebSite", new List <AccessRights> {
                AccessRights.Manage, AccessRights.Listen, AccessRights.Send
            }));
            ehDescriptionAlerts.Authorization.Add(new SharedAccessAuthorizationRule("StreamingAnalytics", new List <AccessRights> {
                AccessRights.Manage, AccessRights.Listen, AccessRights.Send
            }));

            Console.WriteLine("Creating Event Hub {0}", EventHubNameAlerts);
            var ehAlerts = nsManager.CreateEventHubIfNotExists(ehDescriptionAlerts);

            // Create Storage Account for Event Hub Processor
            var stgMgmt = new StorageManagementClient(creds);

            try
            {
                Console.WriteLine("Creating Storage Account {0} in location {1}", StorageAccountName, Location);
                var resultStg = stgMgmt.StorageAccounts.Create(
                    new StorageAccountCreateParameters {
                    Name = StorageAccountName.ToLowerInvariant(), Location = Location, AccountType = "Standard_LRS"
                });

                if (resultStg.StatusCode != System.Net.HttpStatusCode.OK)
                {
                    Console.WriteLine("Error creating storage account {0} in Location {1}: {2}", StorageAccountName, Location, resultStg.StatusCode);
                    return(1);
                }
            }
            catch (CloudException ce)
            {
                if (String.Equals(ce.ErrorCode, "ConflictError", StringComparison.InvariantCultureIgnoreCase))
                {
                    Console.WriteLine("Storage account {0} already existed.", StorageAccountName);
                }
                else
                {
                    throw;
                }
            }
            var keyResponse = stgMgmt.StorageAccounts.GetKeys(StorageAccountName.ToLowerInvariant());

            if (keyResponse.StatusCode != System.Net.HttpStatusCode.OK)
            {
                Console.WriteLine("Error retrieving access keys for storage account {0} in Location {1}: {2}", StorageAccountName, Location, keyResponse.StatusCode);
                return(1);
            }

            var    storageKey = keyResponse.PrimaryKey;
            string ehDevicesWebSiteConnectionString = new ServiceBusConnectionStringBuilder(nsConnectionString)
            {
                SharedAccessKeyName = "WebSite",
                SharedAccessKey     = (ehDevices.Authorization.First((d)
                                                                     => String.Equals(d.KeyName, "WebSite", StringComparison.InvariantCultureIgnoreCase)) as SharedAccessAuthorizationRule).PrimaryKey,
            }.ToString();

            string ehAlertsWebSiteConnectionString = new ServiceBusConnectionStringBuilder(nsConnectionString)
            {
                SharedAccessKeyName = "WebSite",
                SharedAccessKey     = (ehAlerts.Authorization.First((d)
                                                                    => String.Equals(d.KeyName, "WebSite", StringComparison.InvariantCultureIgnoreCase)) as SharedAccessAuthorizationRule).PrimaryKey,
            }.ToString();

            // Write a new web.config template file
            var doc = new XmlDocument();

            doc.PreserveWhitespace = true;

            var inputFileName  = (this.Transform ? "\\web.PublishTemplate.config" : "\\web.config");
            var outputFileName = (this.Transform ? String.Format("\\web.{0}.config", NamePrefix) : "\\web.config");

            doc.Load(WebSiteDirectory + inputFileName);

            doc.SelectSingleNode("/configuration/appSettings/add[@key='Microsoft.ServiceBus.EventHubDevices']/@value").Value
                = EventHubNameDevices;
            doc.SelectSingleNode("/configuration/appSettings/add[@key='Microsoft.ServiceBus.EventHubAlerts']/@value").Value
                = EventHubNameAlerts;
            doc.SelectSingleNode("/configuration/appSettings/add[@key='Microsoft.ServiceBus.ConnectionString']/@value").Value
                = nsConnectionString;
            doc.SelectSingleNode("/configuration/appSettings/add[@key='Microsoft.ServiceBus.ConnectionStringDevices']/@value").Value
                = ehDevicesWebSiteConnectionString;
            doc.SelectSingleNode("/configuration/appSettings/add[@key='Microsoft.ServiceBus.ConnectionStringAlerts']/@value").Value
                = ehAlertsWebSiteConnectionString;
            doc.SelectSingleNode("/configuration/appSettings/add[@key='Microsoft.Storage.ConnectionString']/@value").Value =
                String.Format("DefaultEndpointsProtocol=https;AccountName={0};AccountKey={1}", StorageAccountName, storageKey);

            var outputFile = System.IO.Path.GetFullPath(WebSiteDirectory + outputFileName);

            doc.Save(outputFile);

            Console.WriteLine();
            Console.WriteLine("Service Bus management connection string (i.e. for use in Service Bus Explorer):");
            Console.WriteLine(nsConnectionString);
            Console.WriteLine();
            Console.WriteLine("Device AMQP address strings (for Raspberry PI/devices):");
            for (int i = 1; i <= 4; i++)
            {
                var deviceKeyName = String.Format("D{0}", i);
                var deviceKey     = (ehDevices.Authorization.First((d)
                                                                   => String.Equals(d.KeyName, deviceKeyName, StringComparison.InvariantCultureIgnoreCase)) as SharedAccessAuthorizationRule).PrimaryKey;

                Console.WriteLine("amqps://{0}:{1}@{2}.servicebus.windows.net", deviceKeyName, Uri.EscapeDataString(deviceKey), SBNamespace);

                //Console.WriteLine(new ServiceBusConnectionStringBuilder(nsConnectionString)
                //{
                //    SharedAccessKeyName = deviceKeyName,
                //    SharedAccessKey = deviceKey,
                //}.ToString());
            }
            Console.WriteLine();
            Console.WriteLine("Web.Config saved to {0}", outputFile);

#if AZURESTREAMANALYTICS
            // Create StreamAnalyticsJobs + inputs + outputs + enter keys

            // Untested code. May require AAD authentication, no support for management cert?

            // Create Resource Group for the Stream Analytics jobs
            var groupCreateRequest = WebRequest.Create(String.Format("https://management.azure.com/subscriptions/{0}/resourcegroups/{1}?api-version=2014-04-01-preview",
                                                                     SubscriptionId, StreamAnalyticsGroup)) as HttpWebRequest;

            groupCreateRequest.ClientCertificates.Add(creds.ManagementCertificate);
            groupCreateRequest.ContentType = "application/json";
            groupCreateRequest.Method      = "PUT";
            groupCreateRequest.KeepAlive   = true;

            var bytesGroup = Encoding.UTF8.GetBytes("{\"location\":\"Central US\"}");
            groupCreateRequest.ContentLength = bytesGroup.Length;
            groupCreateRequest.GetRequestStream().Write(bytesGroup, 0, bytesGroup.Length);

            var groupCreateResponse = groupCreateRequest.GetResponse();

            //var streamMgmt = new ManagementClient(creds); //, new Uri("https://management.azure.com"));
            //HttpClient client = streamMgmt.HttpClient;

            var createJob = new StreamAnalyticsJob()
            {
                location = Location,
                inputs   = new List <StreamAnalyticsEntity>
                {
                    new StreamAnalyticsEntity
                    {
                        name       = "devicesInput",
                        properties = new Dictionary <string, object>
                        {
                            { "type", "stream" },
                            { "serialization", new Dictionary <string, object>
                              {
                                  { "type", "JSON" },
                                  { "properties", new Dictionary <string, object>
                                    {
                                        { "encoding", "UTF8" },
                                    } }
                              } },
                            { "datasource", new Dictionary <string, object>
                              {
                                  { "type", "Microsoft.ServiceBus/EventHub" },
                                  { "properties", new Dictionary <string, object>
                                    {
                                        { "eventHubNamespace", Namespace },
                                        { "eventHubName", EventHubDevices },
                                        { "sharedAccessPolicyName", "StreamingAnalytics" },
                                        { "sharedAccessPolicyKey",
                                            (ehDevices.Authorization.First((d)
                                                                           => String.Equals(d.KeyName, "StreamingAnalytics", StringComparison.InvariantCultureIgnoreCase)) as SharedAccessAuthorizationRule).PrimaryKey },
                                    } }
                              } }
                        },
                    },
                },
                transformation = new StreamAnalyticsEntity()
                {
                    name       = "Aggregates",
                    properties = new Dictionary <string, object>
                    {
                        { "streamingUnits", 1 },
                        { "query", "select * from devicesInput" },
                    }
                },
                outputs = new List <StreamAnalyticsEntity>
                {
                    new StreamAnalyticsEntity
                    {
                        name       = "output",
                        properties = new Dictionary <string, object>
                        {
                            { "datasource", new Dictionary <string, object>
                              {
                                  { "type", "Microsoft.ServiceBus/EventHub" },
                                  { "properties", new Dictionary <string, object>
                                    {
                                        { "eventHubNamespace", Namespace },
                                        { "eventHubName", EventHubAlerts },
                                        { "sharedAccessPolicyName", "StreamingAnalytics" },
                                        { "sharedAccessPolicyKey",
                                            (ehAlerts.Authorization.First((d) => String.Equals(d.KeyName, "StreamingAnalytics", StringComparison.InvariantCultureIgnoreCase)) as SharedAccessAuthorizationRule).PrimaryKey },
                                    } }
                              } },
                            { "serialization", new Dictionary <string, object>
                              {
                                  { "type", "JSON" },
                                  { "properties", new Dictionary <string, object>
                                    {
                                        { "encoding", "UTF8" },
                                    } }
                              } },
                        },
                    },
                }
            };



            var jobCreateRequest = WebRequest.Create(String.Format("https://management.azure.com/subscriptions/{0}/resourcegroups/{1}/Microsoft.StreamAnalytics/streamingjobs/{2}?api-version=2014-10-01",
                                                                   SubscriptionId, StreamAnalyticsGroup, JobAggregates)) as HttpWebRequest;

            jobCreateRequest.ClientCertificates.Add(creds.ManagementCertificate);
            jobCreateRequest.ContentType = "application/json";
            jobCreateRequest.Method      = "PUT";
            jobCreateRequest.KeepAlive   = true;

            var bytes = Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(createJob));
            jobCreateRequest.ContentLength = bytes.Length;
            jobCreateRequest.GetRequestStream().Write(bytes, 0, bytes.Length);

            var jobCreateResponse = jobCreateRequest.GetResponse();

            //var jobCreateTask = streamMgmt.HttpClient.PutAsync(
            //    String.Format("https://management.azure.com/subscriptions/{0}/resourcegroups/{1}/Microsoft.StreamAnalytics/streamingjobs/{2}?api-version=2014-10-01",
            //    SubscriptionId, StreamAnalyticsGroup, JobAggregates),
            //    new StringContent(JsonConvert.SerializeObject(createJob)));
            //jobCreateTask.Wait();
            //var jobCreateResponse = jobCreateTask.Result;
#endif
            return(0);
        }
예제 #34
0
        // This method gets called by the runtime. Use this method to add services to the container.
        public IServiceProvider ConfigureServices(IServiceCollection services)
        {
            services.Configure <PaymentSettings>(Configuration);

            RegisterAppInsights(services);

            if (Configuration.GetValue <bool>("AzureServiceBusEnabled"))
            {
                services.AddSingleton <IServiceBusPersisterConnection>(sp =>
                {
                    var logger = sp.GetRequiredService <ILogger <DefaultServiceBusPersisterConnection> >();

                    var serviceBusConnectionString = Configuration["EventBusConnection"];
                    var serviceBusConnection       = new ServiceBusConnectionStringBuilder(serviceBusConnectionString);

                    return(new DefaultServiceBusPersisterConnection(serviceBusConnection));
                });
            }
            else
            {
                services.AddSingleton <IRabbitMqPersistentConnection>(sp =>
                {
                    var logger  = sp.GetRequiredService <ILogger <DefaultRabbitMqPersistentConnection> >();
                    var factory = new ConnectionFactory
                    {
                        HostName = Configuration["EventBusConnection"]
                    };

                    if (!string.IsNullOrEmpty(Configuration["EventBusUserName"]))
                    {
                        factory.UserName = Configuration["EventBusUserName"];
                    }

                    if (!string.IsNullOrEmpty(Configuration["EventBusPassword"]))
                    {
                        factory.Password = Configuration["EventBusPassword"];
                    }

                    var retryCount = 5;
                    if (!string.IsNullOrEmpty(Configuration["EventBusRetryCount"]))
                    {
                        retryCount = int.Parse(Configuration["EventBusRetryCount"]);
                    }

                    return(new DefaultRabbitMqPersistentConnection(factory, logger, retryCount));
                });
            }

            services.AddHealthChecks(checks =>
            {
                checks.AddValueTaskCheck("HTTP Endpoint",
                                         () => new ValueTask <IHealthCheckResult>(HealthCheckResult.Healthy("Ok")));
            });

            RegisterEventBus(services);

            var container = new ContainerBuilder();

            container.Populate(services);
            return(new AutofacServiceProvider(container.Build()));
        }
        /// <summary>
        /// Used to register Azure Service Bus as well as add a mapping for messages to topics or queues. This method takes in a connection string builder to configure the Service Bus connection.
        /// </summary>
        /// <param name="services"></param>
        /// <param name="serviceBusName"></param>
        /// <param name="connectionBuilder"></param>
        /// <param name="transportType"></param>
        /// <param name="retryPolicy"></param>
        public static void AddAzureServiceBusConnectionPool(this IServiceCollection services, ServiceBusConnectionStringBuilder connectionStringBuilder, Action <ServiceBusClientPoolBuilder> connectionBuilder)
        {
            services.AddSingleton(provider =>
            {
                var serviceBusConnection = new ServiceBusConnection(connectionStringBuilder);

                return(serviceBusConnection);
            });

            services.AddSingleton <IServiceBusClientPool>(provider =>
            {
                var serviceBusConnection = provider.GetRequiredService <ServiceBusConnection>();

                var poolBuilder = new ServiceBusClientPoolBuilder(serviceBusConnection);

                connectionBuilder(poolBuilder);

                return(new ServiceBusClientPool(poolBuilder));
            });
        }
 public OrdersQueueProcessor(IShipmentRepository shipmentRepository, ServiceBusConnectionStringBuilder serviceBusConnectionStringBuilder, IConfiguration configuration, ILogger <OrdersQueueProcessor> logger)
     : base(serviceBusConnectionStringBuilder, configuration, logger)
 {
     _shipmentRepository = shipmentRepository;
 }
예제 #37
0
        // This method gets called by the runtime. Use this method to add services to the container.
        public IServiceProvider ConfigureServices(IServiceCollection services)
        {
            //add health check for this service
            services.AddCustomHealthCheck(Configuration);

            //configure settings

            services.Configure <BackgroundTaskSettings>(Configuration);
            services.AddOptions();

            //configure background task

            services.AddSingleton <IHostedService, GracePeriodManagerService>();

            //configure event bus related services

            if (Configuration.GetValue <bool>("AzureServiceBusEnabled"))
            {
                services.AddSingleton <IServiceBusPersisterConnection>(sp =>
                {
                    var logger = sp.GetRequiredService <ILogger <DefaultServiceBusPersisterConnection> >();

                    var serviceBusConnectionString = Configuration["EventBusConnection"];
                    var serviceBusConnection       = new ServiceBusConnectionStringBuilder(serviceBusConnectionString);

                    return(new DefaultServiceBusPersisterConnection(serviceBusConnection, logger));
                });
            }
            else if (Configuration.GetValue <bool>("RabbitMQBusEnabled"))
            {
                services.AddSingleton <IRabbitMQPersistentConnection>(sp =>
                {
                    var logger = sp.GetRequiredService <ILogger <DefaultRabbitMQPersistentConnection> >();


                    var factory = new ConnectionFactory()
                    {
                        HostName = Configuration["EventBusConnection"],
                        DispatchConsumersAsync = true
                    };

                    if (!string.IsNullOrEmpty(Configuration["EventBusUserName"]))
                    {
                        factory.UserName = Configuration["EventBusUserName"];
                    }

                    if (!string.IsNullOrEmpty(Configuration["EventBusPassword"]))
                    {
                        factory.Password = Configuration["EventBusPassword"];
                    }

                    var retryCount = 5;
                    if (!string.IsNullOrEmpty(Configuration["EventBusRetryCount"]))
                    {
                        retryCount = int.Parse(Configuration["EventBusRetryCount"]);
                    }

                    return(new DefaultRabbitMQPersistentConnection(factory, logger, retryCount));
                });
            }
            else
            {
                services.AddSingleton <INCachePersistantConnection>(sp =>
                {
                    var logger = sp.GetRequiredService <ILogger <DefaultNCachePersistentConnection> >();

                    var cacheID = "PubSubCache";
                    if (!string.IsNullOrEmpty(Configuration["EventBusNCachID"]))
                    {
                        cacheID = Configuration["EventBusNCachID"];
                    }

                    var topicID = "IntegrationEvents";
                    if (!string.IsNullOrEmpty(Configuration["EventBusNCachTopicID"]))
                    {
                        topicID = Configuration["EventBusNCachTopicID"];
                    }

                    var ipAddresses = Configuration.GetValue <string>("PubSubCacheIPAddresses").Split('-');

                    if (ipAddresses.Length == 0)
                    {
                        throw new ArgumentNullException("No IP addresses given for Pub Sub Cache");
                    }

                    for (int i = 0; i < ipAddresses.Length; i++)
                    {
                        ipAddresses[i] = ipAddresses[i].Trim();
                    }

                    var enableNCacheClientLogs = Configuration.GetValue <bool>("EnableNCacheClientLogs", false);
                    return(new DefaultNCachePersistentConnection(cacheID, topicID, logger, ipAddresses, enableNCacheClientLogs));
                });
            }

            RegisterEventBus(services);

            //create autofac based service provider
            var container = new ContainerBuilder();

            container.Populate(services);


            return(new AutofacServiceProvider(container.Build()));
        }
예제 #38
0
        // This method gets called by the runtime. Use this method to add services to the container.
        public IServiceProvider ConfigureServices(IServiceCollection services)
        {
            services.AddMvc().SetCompatibilityVersion(CompatibilityVersion.Version_3_0);

            /*
             * Add Authentication.
             */
            services.AddMvcCore()
            .AddAuthorization()
            .AddNewtonsoftJson();
            services
            .AddAuthentication("Bearer")
            .AddIdentityServerAuthentication(options =>
            {
                options.Authority            = Configuration.GetSection("AuthenticationBearer:Authority").Value;
                options.RequireHttpsMetadata = true;
                options.ApiName   = Configuration.GetSection("AuthenticationBearer:ApiName").Value;
                options.ApiSecret = Configuration.GetSection("AuthenticationBearer:ApiSecret").Value;
            });

            /*
             * EventBus Setup.
             */
            if (Configuration["ClusterMode"] == Program.CLUSTER_AZURE)
            {
                /*
                 * Azure Service Bus.
                 */
                services.AddSingleton <IAzureServiceBusPersisterConnection>(sp =>
                {
                    var logger = sp.GetRequiredService <ILogger <AzureServiceBusPersisterConnection> >();

                    var serviceBusConnectionString = Configuration.GetSection("Azure:EventBusConnection").Value;
                    var serviceBusConnection       = new ServiceBusConnectionStringBuilder(serviceBusConnectionString);

                    if ((Configuration.GetSection("Azure:EventBusEntityPath").Exists()) &&
                        (!string.IsNullOrEmpty(Configuration.GetSection("Azure:EventBusEntityPath").Value)))
                    {
                        serviceBusConnection.EntityPath = Configuration.GetSection("Azure:EventBusEntityPath").Value;
                    }

                    return(new AzureServiceBusPersisterConnection(serviceBusConnection, logger));
                });
                services.AddSingleton <IEventBus, EventBusAzureServiceBus>(sp =>
                {
                    var serviceBusPersisterConnection = sp.GetRequiredService <IAzureServiceBusPersisterConnection>();
                    var iLifetimeScope = sp.GetRequiredService <ILifetimeScope>();
                    var logger         = sp.GetRequiredService <ILogger <EventBusAzureServiceBus> >();
                    var eventBusSubcriptionsManager = sp.GetRequiredService <IEventBusSubscriptionsManager>();
                    var subscriptionClientName      = Configuration.GetSection("Azure:SubscriptionClientName").Value;

                    return(new EventBusAzureServiceBus(serviceBusPersisterConnection, logger,
                                                       eventBusSubcriptionsManager, subscriptionClientName, iLifetimeScope));
                });
            }
            else
            {
                /*
                 * RabbitMq.
                 */
                services.AddSingleton <IRabbitMQPersistentConnection>(sp =>
                {
                    var logger = sp.GetRequiredService <ILogger <DefaultRabbitMQPersistentConnection> >();

                    var factory = new ConnectionFactory()
                    {
                        HostName = Configuration.GetSection("RabbitMqBus:Connection").Value
                    };
                    factory.UserName = Configuration.GetSection("RabbitMqBus:User").Value;
                    factory.Password = Configuration.GetSection("RabbitMqBus:Password").Value;

                    var retryCount = 5;
                    if ((Configuration.GetSection("RabbitMqBus:RetryCount").Exists()) &&
                        (!string.IsNullOrEmpty(Configuration.GetSection("RabbitMqBus:RetryCount").Value)))
                    {
                        retryCount = int.Parse(Configuration.GetSection("RabbitMqBus:RetryCount").Value);
                    }

                    return(new DefaultRabbitMQPersistentConnection(factory, logger, retryCount));
                });
                services.AddSingleton <IEventBus, EventBusRabbitMQ>(sp =>
                {
                    var rabbitMQConnexion  = sp.GetRequiredService <IRabbitMQPersistentConnection>();
                    var iLifetimeScope     = sp.GetRequiredService <ILifetimeScope>();
                    var logger             = sp.GetRequiredService <ILogger <EventBusRabbitMQ> >();
                    var eventBusAboManager = sp.GetRequiredService <IEventBusSubscriptionsManager>();

                    var retryCount = 5;
                    if ((Configuration.GetSection("RabbitMqBus:RetryCount").Exists()) &&
                        (!string.IsNullOrEmpty(Configuration.GetSection("RabbitMqBus:RetryCount").Value)))
                    {
                        retryCount = int.Parse(Configuration.GetSection("RabbitMqBus:RetryCount").Value);
                    }

                    var queueName = Configuration.GetSection("RabbitMqBus:QueueName").Value;

                    return(new EventBusRabbitMQ(rabbitMQConnexion, logger, iLifetimeScope,
                                                eventBusAboManager, queueName, retryCount));
                });
            }
            services.AddSingleton <IEventBusSubscriptionsManager, InMemoryEventBusSubscriptionsManager>();
            services.AddTransient <CheckOutEventHandler>();

            /*
             * MongoDB Setup.
             */
            services.Configure <MongoDbConfig>(Options =>
            {
                Options.IsAzure = (Configuration["ClusterMode"] == Program.CLUSTER_AZURE);

                Options.ConnectionString = Configuration.GetSection("MongoDbConfig:ConnectionString").Value;
                Options.Datebase         = Configuration.GetSection("MongoDbConfig:Datebase").Value;

                Options.User     = Configuration.GetSection("MongoDbConfig:User").Value;
                Options.Password = Configuration.GetSection("MongoDbConfig:Password").Value;
            });
            services.AddSingleton <IMongoDbClient>(sp =>
            {
                ILogger <MongoDbClient> logger   = sp.GetRequiredService <ILogger <MongoDbClient> >();
                IOptions <MongoDbConfig> options = sp.GetRequiredService <IOptions <MongoDbConfig> >();
                return(new MongoDbClient(options, logger));
            });
            services.AddSingleton <ICustomerServices>(sp =>
            {
                return(new CustomerServices(sp.GetRequiredService <IMongoDbClient>()));
            });

            /*
             * Custom Validator Setup.
             */
            services.AddSingleton <ICustomerFlowValid>(sp => { return(new CustomerFlowValid()); });

            /*
             * Register the Swagger generator.
             */
            services.AddSwaggerGen(c =>
            {
                c.SwaggerDoc("v1", new OpenApiInfo {
                    Title = "Customer.API", Version = "v1"
                });
                c.AddSecurityDefinition("oauth2", new OpenApiSecurityScheme
                {
                    Type  = SecuritySchemeType.OAuth2,
                    Flows = new OpenApiOAuthFlows
                    {
                        Password = new OpenApiOAuthFlow
                        {
                            AuthorizationUrl = new Uri($"{Configuration.GetSection("AuthenticationBearer:Authority").Value}/connect/authorize"),
                            TokenUrl         = new Uri($"{Configuration.GetSection("AuthenticationBearer:Authority").Value}/connect/token"),
                            Scopes           = new Dictionary <string, string>
                            {
                                { "customer", "Access Customer.API" }
                            }
                        }
                    }
                });
                c.AddSecurityRequirement(new OpenApiSecurityRequirement
                {
                    {
                        new OpenApiSecurityScheme
                        {
                            Reference = new OpenApiReference {
                                Type = ReferenceType.SecurityScheme, Id = "oauth2"
                            }
                        },
                        new[]
                        {
                            "customer"
                        }
                    }
                });
            });

            /*
             * Configuration de AutoFac.
             * Inversion de contrôle.
             */
            var container = new ContainerBuilder();

            container.Populate(services);
            return(new AutofacServiceProvider(container.Build()));
        }
예제 #39
0
        public IServiceProvider ConfigureServices(IServiceCollection services)
        {
            RegisterAppInsights(services);

            services.AddMvc(options =>
            {
                options.Filters.Add(typeof(HttpGlobalExceptionFilter));
            }).AddControllersAsServices();

            ConfigureAuthService(services);

            services.Configure <Settings>(Configuration);

            if (Configuration.GetValue <bool>("AzureServiceBusEnabled"))
            {
                services.AddSingleton <IServiceBusPersisterConnection>(sp =>
                {
                    var logger = sp.GetRequiredService <ILogger <DefaultServiceBusPersisterConnection> >();

                    var serviceBusConnectionString = Configuration["EventBusConnection"];
                    var serviceBusConnection       = new ServiceBusConnectionStringBuilder(serviceBusConnectionString);

                    return(new DefaultServiceBusPersisterConnection(serviceBusConnection, logger));
                });
            }
            else
            {
                services.AddSingleton <IRabbitMQPersistentConnection>(sp =>
                {
                    var logger = sp.GetRequiredService <ILogger <DefaultRabbitMQPersistentConnection> >();

                    var factory = new ConnectionFactory()
                    {
                        HostName = Configuration["EventBusConnection"]
                    };

                    if (!string.IsNullOrEmpty(Configuration["EventBusUserName"]))
                    {
                        factory.UserName = Configuration["EventBusUserName"];
                    }

                    if (!string.IsNullOrEmpty(Configuration["EventBusPassword"]))
                    {
                        factory.Password = Configuration["EventBusPassword"];
                    }

                    var retryCount = 5;
                    if (!string.IsNullOrEmpty(Configuration["EventBusRetryCount"]))
                    {
                        retryCount = int.Parse(Configuration["EventBusRetryCount"]);
                    }

                    return(new DefaultRabbitMQPersistentConnection(factory, logger, retryCount));
                });
            }

            services.AddHealthChecks(checks =>
            {
                checks.AddValueTaskCheck("HTTP Endpoint", () => new ValueTask <IHealthCheckResult>(HealthCheckResult.Healthy("Ok")));
            });

            RegisterEventBus(services);

            // Add framework services.
            services.AddSwaggerGen(options =>
            {
                options.DescribeAllEnumsAsStrings();
                options.SwaggerDoc("v1", new Swashbuckle.AspNetCore.Swagger.Info
                {
                    Title          = "LeadsPlus - CloudMallin webhook",
                    Version        = "v1",
                    Description    = "The Agent Microservice HTTP API. This is a Data-Driven/CRUD microservice sample",
                    TermsOfService = "Terms Of Service"
                });

                options.AddSecurityDefinition("oauth2", new OAuth2Scheme
                {
                    Type             = "oauth2",
                    Flow             = "implicit",
                    AuthorizationUrl = $"{Configuration.GetValue<string>("IdentityUrlExternal")}/connect/authorize",
                    TokenUrl         = $"{Configuration.GetValue<string>("IdentityUrlExternal")}/connect/token",
                    Scopes           = new Dictionary <string, string>()
                    {
                        { "CloudmailinWebhook", "Cloudmailin Webhook" }
                    }
                });

                options.OperationFilter <AuthorizeCheckOperationFilter>();
            });

            services.AddCors(options =>
            {
                options.AddPolicy("CorsPolicy",
                                  builder => builder.AllowAnyOrigin()
                                  .AllowAnyMethod()
                                  .AllowAnyHeader()
                                  .AllowCredentials());
            });

            services.AddSingleton <IHttpContextAccessor, HttpContextAccessor>();

            //configure autofac
            var container = new ContainerBuilder();

            container.Populate(services);

            return(new AutofacServiceProvider(container.Build()));
        }
        /// <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;
        }
예제 #41
0
        public static IServiceCollection AddCustomIntegrations(this IServiceCollection services, IConfiguration configuration)
        {
            services.AddSingleton <IHttpContextAccessor, HttpContextAccessor>();
            services.AddTransient <Func <DbConnection, IIntegrationEventLogService> >(
                sp => (DbConnection c) => new IntegrationEventLogService(c));


            if (configuration.GetValue <bool>("AzureServiceBusEnabled"))
            {
                services.AddSingleton <IServiceBusPersisterConnection>(sp =>
                {
                    var logger = sp.GetRequiredService <ILogger <DefaultServiceBusPersisterConnection> >();

                    var serviceBusConnectionString = configuration["EventBusConnection"];
                    var serviceBusConnection       = new ServiceBusConnectionStringBuilder(serviceBusConnectionString);

                    return(new DefaultServiceBusPersisterConnection(serviceBusConnection, logger));
                });
            }
            else
            {
                services.AddSingleton <IRabbitMQPersistentConnection>(sp =>
                {
                    var logger = sp.GetRequiredService <ILogger <DefaultRabbitMQPersistentConnection> >();


                    var factory = new ConnectionFactory()
                    {
                        HostName = configuration["EventBusConnection"]
                    };

                    if (!string.IsNullOrEmpty(configuration["EventBusUserName"]))
                    {
                        factory.UserName = configuration["EventBusUserName"];
                    }

                    if (!string.IsNullOrEmpty(configuration["EventBusPassword"]))
                    {
                        factory.Password = configuration["EventBusPassword"];
                    }

                    if (!string.IsNullOrEmpty(configuration["EventBusPort"]))
                    {
                        factory.Port = int.Parse(configuration["EventBusPort"]);
                    }

                    if (!string.IsNullOrEmpty(configuration["EventBusVirtualHost"]))
                    {
                        factory.VirtualHost = configuration["EventBusVirtualHost"];
                    }

                    var retryCount = 5;
                    if (!string.IsNullOrEmpty(configuration["EventBusRetryCount"]))
                    {
                        retryCount = int.Parse(configuration["EventBusRetryCount"]);
                    }

                    return(new DefaultRabbitMQPersistentConnection(factory, logger, retryCount));
                });
            }

            return(services);
        }
예제 #42
0
        /// <summary>
        /// Create servicebus connectionstring
        /// </summary>
        private void initServiceBusConnectionStringBuilder()
        {
            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);
        }
예제 #43
0
        public async Task Run(string connectionString)
        {
            var sbb = new ServiceBusConnectionStringBuilder(connectionString);

            try
            {
                // Create sender to Sequence Service
                using (var sendChannelFactory = new ChannelFactory <ISequenceServiceChannel>("sequenceSendClient"))
                {
                    sendChannelFactory.Endpoint.Address = new EndpointAddress(
                        new Uri(sbb.GetAbsoluteRuntimeEndpoints()[0], SessionQueueName));
                    sendChannelFactory.Endpoint.EndpointBehaviors.Add(
                        new TransportClientEndpointBehavior(TokenProvider.CreateSharedAccessSignatureTokenProvider(sbb.SharedAccessKeyName, sbb.SharedAccessKey)));

                    using (var clientChannel = sendChannelFactory.CreateChannel())
                    {
                        for (int j = 0; j < 3; j++)
                        {
                            var contextId = Guid.NewGuid().ToString();


                            // Send messages
                            var sequenceLength = new Random().Next(5, 10);
                            for (var i = 0; i < sequenceLength; i++)
                            {
                                // Generating a random sequence item
                                var sequenceItem = new SequenceItem(
                                    string.Format("{0:00000}", new Random().Next(0, 10000)),
                                    new Random().Next(1, 100));

                                // set the operation context for the subsequent call, this MUST be a new context
                                OperationContext.Current = new OperationContext(clientChannel)
                                {
                                    OutgoingMessageProperties = { { BrokeredMessageProperty.Name, new BrokeredMessageProperty {
                                                                        SessionId = contextId, TimeToLive = TimeSpan.FromMinutes(5)
                                                                    } } }
                                };
                                // Correlating ServiceBus SessionId to ContextId
                                await clientChannel.SubmitSequenceItemAsync(sequenceItem);

                                Console.WriteLine("Sequence: {0} [{1}] - ContextId {2}.", sequenceItem.ItemId, sequenceItem.Quantity, contextId);
                            }

                            // set the operation context for the subsequent call, this MUST be a new context
                            OperationContext.Current = new OperationContext(clientChannel)
                            {
                                OutgoingMessageProperties = { { BrokeredMessageProperty.Name, new BrokeredMessageProperty {
                                                                    SessionId = contextId, TimeToLive = TimeSpan.FromMinutes(5)
                                                                } } }
                            };
                            await clientChannel.TerminateSequenceAsync();
                        }
                        clientChannel.Close();
                    }
                    // Close sender
                    sendChannelFactory.Close();
                }
            }
            catch (Exception exception)
            {
                Console.WriteLine("Exception occurred: {0}", exception);
            }
        }
예제 #44
0
        private static void Main(string[] args)
        {
            ServerFQDN = System.Net.Dns.GetHostEntry(string.Empty).HostName;

            ServiceBusConnectionStringBuilder 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);

            MessagingFactory messageFactory   = MessagingFactory.CreateFromConnectionString(connBuilder.ToString());
            NamespaceManager namespaceManager = NamespaceManager.CreateFromConnectionString(connBuilder.ToString());

            if (namespaceManager == null)
            {
                Console.WriteLine("\nUnepected Error");
                return;
            }

            string queueName = "ServiceBusQueueSample";

            if (namespaceManager.QueueExists(queueName))
            {
                namespaceManager.DeleteQueue(queueName);
            }

            namespaceManager.CreateQueue(queueName);

            QueueClient myQueueClient = messageFactory.CreateQueueClient(queueName);

            try
            {
                BrokeredMessage sendMessage = new BrokeredMessage("Hello World!");
                myQueueClient.Send(sendMessage);

                //Receive the message from the queue
                BrokeredMessage receivedMessage = myQueueClient.Receive(TimeSpan.FromSeconds(5));

                if (receivedMessage != null)
                {
                    Console.WriteLine(string.Format($"Message received:{receivedMessage.GetBody<string>()}"));
                    receivedMessage.Complete();
                }
            }
            catch (Exception e)
            {
                Console.WriteLine($"Unexpected exception {e}");
                throw;
            }
            finally
            {
                if (messageFactory != null)
                {
                    messageFactory.Close();
                }
                Console.WriteLine("Press ENTER to clean up and exit.");
                Console.ReadLine();
            }
        }
예제 #45
0
        // This method gets called by the runtime. Use this method to add services to the container.
        public IServiceProvider ConfigureServices(IServiceCollection services)
        {
            //add health check for this service
            services.AddHealthChecks(checks =>
            {
                var minutes = 1;

                if (int.TryParse(Configuration["HealthCheck:Timeout"], out var minutesParsed))
                {
                    minutes = minutesParsed;
                }
                checks.AddSqlCheck("OrderingDb", Configuration["ConnectionString"], TimeSpan.FromMinutes(minutes));
            });

            //configure settings

            services.Configure <BackgroundTaskSettings>(Configuration);
            services.AddOptions();

            //configure background task

            services.AddSingleton <IHostedService, GracePeriodManagerService>();

            //configure event bus related services

            if (Configuration.GetValue <bool>("AzureServiceBusEnabled"))
            {
                services.AddSingleton <IServiceBusPersisterConnection>(sp =>
                {
                    var logger = sp.GetRequiredService <ILogger <DefaultServiceBusPersisterConnection> >();

                    var serviceBusConnectionString = Configuration["EventBusConnection"];
                    var serviceBusConnection       = new ServiceBusConnectionStringBuilder(serviceBusConnectionString);

                    return(new DefaultServiceBusPersisterConnection(serviceBusConnection));
                });
            }
            else
            {
                services.AddSingleton <IRabbitMqPersistentConnection>(sp =>
                {
                    var logger = sp.GetRequiredService <ILogger <DefaultRabbitMqPersistentConnection> >();


                    var factory = new ConnectionFactory()
                    {
                        HostName = Configuration["EventBusConnection"]
                    };

                    if (!string.IsNullOrEmpty(Configuration["EventBusUserName"]))
                    {
                        factory.UserName = Configuration["EventBusUserName"];
                    }

                    if (!string.IsNullOrEmpty(Configuration["EventBusPassword"]))
                    {
                        factory.Password = Configuration["EventBusPassword"];
                    }

                    var retryCount = 5;
                    if (!string.IsNullOrEmpty(Configuration["EventBusRetryCount"]))
                    {
                        retryCount = int.Parse(Configuration["EventBusRetryCount"]);
                    }

                    return(new DefaultRabbitMqPersistentConnection(factory, logger, retryCount));
                });
            }

            RegisterEventBus(services);

            //create autofac based service provider
            var container = new ContainerBuilder();

            container.Populate(services);


            return(new AutofacServiceProvider(container.Build()));
        }
예제 #46
0
 /// <summary>
 /// Create a topic client from a connection string
 /// </summary>
 /// <param name="connectionString">Connection string</param>
 /// <returns>Instace of TopicClient class</returns>
 public static TopicClient CreateFromConnectionString(string connectionString)
 {
     ServiceBusConnectionStringBuilder builder = new ServiceBusConnectionStringBuilder(connectionString);
     return CreateFromConnectionString(connectionString, builder.EntityPath);
 }
예제 #47
0
        // This method gets called by the runtime. Use this method to add services to the container.
        public IServiceProvider ConfigureServices(IServiceCollection services)
        {
            RegisterAppInsights(services);

            // Add framework services.
            services.AddMvc(options =>
            {
                options.Filters.Add(typeof(HttpGlobalExceptionFilter));
                options.Filters.Add(typeof(ValidateModelStateFilter));
            }).AddControllersAsServices();

            ConfigureAuthService(services);

            services.AddHealthChecks(checks =>
            {
                checks.AddValueTaskCheck("HTTP Endpoint", () => new ValueTask <IHealthCheckResult>(HealthCheckResult.Healthy("Ok")),
                                         TimeSpan.Zero  //No cache for this HealthCheck, better just for demos
                                         );
            });

            services.Configure <BasketSettings>(Configuration);

            //By connecting here we are making sure that our service
            //cannot start until redis is ready. This might slow down startup,
            //but given that there is a delay on resolving the ip address
            //and then creating the connection it seems reasonable to move
            //that cost to startup instead of having the first request pay the
            //penalty.
            services.AddSingleton <ConnectionMultiplexer>(sp =>
            {
                var settings      = sp.GetRequiredService <IOptions <BasketSettings> >().Value;
                var configuration = ConfigurationOptions.Parse(settings.ConnectionString, true);

                configuration.ResolveDns = true;

                return(ConnectionMultiplexer.Connect(configuration));
            });


            if (Configuration.GetValue <bool>("AzureServiceBusEnabled"))
            {
                services.AddSingleton <IServiceBusPersisterConnection>(sp =>
                {
                    var logger = sp.GetRequiredService <ILogger <DefaultServiceBusPersisterConnection> >();

                    var serviceBusConnectionString = Configuration["EventBusConnection"];
                    var serviceBusConnection       = new ServiceBusConnectionStringBuilder(serviceBusConnectionString);

                    return(new DefaultServiceBusPersisterConnection(serviceBusConnection, logger));
                });
            }
            else
            {
                services.AddSingleton <IRabbitMQPersistentConnection>(sp =>
                {
                    var logger = sp.GetRequiredService <ILogger <DefaultRabbitMQPersistentConnection> >();

                    var factory = new ConnectionFactory()
                    {
                        HostName = Configuration["EventBusConnection"]
                    };

                    if (!string.IsNullOrEmpty(Configuration["EventBusUserName"]))
                    {
                        factory.UserName = Configuration["EventBusUserName"];
                    }

                    if (!string.IsNullOrEmpty(Configuration["EventBusPassword"]))
                    {
                        factory.Password = Configuration["EventBusPassword"];
                    }

                    var retryCount = 5;
                    if (!string.IsNullOrEmpty(Configuration["EventBusRetryCount"]))
                    {
                        retryCount = int.Parse(Configuration["EventBusRetryCount"]);
                    }

                    return(new DefaultRabbitMQPersistentConnection(factory, logger, retryCount));
                });
            }

            RegisterEventBus(services);

            services.AddSwaggerGen(options =>
            {
                options.DescribeAllEnumsAsStrings();
                options.SwaggerDoc("v1", new Info
                {
                    Title          = "Basket HTTP API",
                    Version        = "v1",
                    Description    = "The Basket Service HTTP API",
                    TermsOfService = "Terms Of Service"
                });

                options.AddSecurityDefinition("oauth2", new OAuth2Scheme
                {
                    Type             = "oauth2",
                    Flow             = "implicit",
                    AuthorizationUrl = $"{Configuration.GetValue<string>("IdentityUrlExternal")}/connect/authorize",
                    TokenUrl         = $"{Configuration.GetValue<string>("IdentityUrlExternal")}/connect/token",
                    Scopes           = new Dictionary <string, string>()
                    {
                        { "basket", "Basket API" }
                    }
                });

                options.OperationFilter <AuthorizeCheckOperationFilter>();
            });

            services.AddCors(options =>
            {
                options.AddPolicy("CorsPolicy",
                                  builder => builder.AllowAnyOrigin()
                                  .AllowAnyMethod()
                                  .AllowAnyHeader()
                                  .AllowCredentials());
            });
            services.AddSingleton <IHttpContextAccessor, HttpContextAccessor>();
            services.AddTransient <IBasketRepository, RedisBasketRepository>();
            services.AddTransient <IIdentityService, IdentityService>();

            services.AddOptions();

            var container = new ContainerBuilder();

            container.Populate(services);

            return(new AutofacServiceProvider(container.Build()));
        }
예제 #48
0
        void ConnectionStringBuilderShouldParseTransportTypeIfWebSocket()
        {
            var csBuilder = new ServiceBusConnectionStringBuilder("Endpoint=sb://contoso.servicebus.windows.net;SharedAccessKeyName=keyname;SharedAccessKey=key;TransportType=AmqpWebSockets");

            Assert.Equal(TransportType.AmqpWebSockets, csBuilder.TransportType);
        }
        // This method gets called by the runtime. Use this method to add services to the container.
        public IServiceProvider ConfigureServices(IServiceCollection services)
        {
            RegisterAppInsights(services);

            // Add framework services.
            services
            .AddCustomHealthCheck(Configuration)
            .AddMvc(options =>
            {
                options.Filters.Add(typeof(HttpGlobalExceptionFilter));
            })
            .SetCompatibilityVersion(CompatibilityVersion.Version_2_2)
            .AddControllersAsServices();      //Injecting Controllers themselves thru DIFor further info see: http://docs.autofac.org/en/latest/integration/aspnetcore.html#controllers-as-services

            services.Configure <MarketingSettings>(Configuration);

            ConfigureAuthService(services);

            services.AddDbContext <MarketingContext>(options =>
            {
                options.UseSqlServer(Configuration["ConnectionString"],
                                     sqlServerOptionsAction: sqlOptions =>
                {
                    sqlOptions.MigrationsAssembly(typeof(Startup).GetTypeInfo().Assembly.GetName().Name);
                    //Configuring Connection Resiliency: https://docs.microsoft.com/en-us/ef/core/miscellaneous/connection-resiliency
                    sqlOptions.EnableRetryOnFailure(maxRetryCount: 10, maxRetryDelay: TimeSpan.FromSeconds(30), errorNumbersToAdd: null);
                });

                // Changing default behavior when client evaluation occurs to throw.
                // Default in EF Core would be to log a warning when client evaluation is performed.
                options.ConfigureWarnings(warnings => warnings.Throw(RelationalEventId.QueryClientEvaluationWarning));
                //Check Client vs. Server evaluation: https://docs.microsoft.com/en-us/ef/core/querying/client-eval
            });

            if (Configuration.GetValue <bool>("AzureServiceBusEnabled"))
            {
                services.AddSingleton <IServiceBusPersisterConnection>(sp =>
                {
                    var logger = sp.GetRequiredService <ILogger <DefaultServiceBusPersisterConnection> >();

                    var serviceBusConnectionString = Configuration["EventBusConnection"];
                    var serviceBusConnection       = new ServiceBusConnectionStringBuilder(serviceBusConnectionString);

                    return(new DefaultServiceBusPersisterConnection(serviceBusConnection, logger));
                });
            }
            else
            {
                services.AddSingleton <IRabbitMQPersistentConnection>(sp =>
                {
                    var logger = sp.GetRequiredService <ILogger <DefaultRabbitMQPersistentConnection> >();

                    var factory = new ConnectionFactory()
                    {
                        HostName = Configuration["EventBusConnection"]
                    };

                    if (!string.IsNullOrEmpty(Configuration["EventBusUserName"]))
                    {
                        factory.UserName = Configuration["EventBusUserName"];
                    }

                    if (!string.IsNullOrEmpty(Configuration["EventBusPassword"]))
                    {
                        factory.Password = Configuration["EventBusPassword"];
                    }

                    var retryCount = 5;
                    if (!string.IsNullOrEmpty(Configuration["EventBusRetryCount"]))
                    {
                        retryCount = int.Parse(Configuration["EventBusRetryCount"]);
                    }

                    return(new DefaultRabbitMQPersistentConnection(factory, logger, retryCount));
                });
            }

            // Add framework services.
            services.AddSwaggerGen(options =>
            {
                options.DescribeAllEnumsAsStrings();
                options.SwaggerDoc("v1", new Swashbuckle.AspNetCore.Swagger.Info
                {
                    Title          = "Marketing HTTP API",
                    Version        = "v1",
                    Description    = "The Marketing Service HTTP API",
                    TermsOfService = "Terms Of Service"
                });

                options.AddSecurityDefinition("oauth2", new OAuth2Scheme
                {
                    Type             = "oauth2",
                    Flow             = "implicit",
                    AuthorizationUrl = $"{Configuration.GetValue<string>("IdentityUrlExternal")}/connect/authorize",
                    TokenUrl         = $"{Configuration.GetValue<string>("IdentityUrlExternal")}/connect/token",
                    Scopes           = new Dictionary <string, string>()
                    {
                        { "marketing", "Marketing API" }
                    }
                });

                options.OperationFilter <AuthorizeCheckOperationFilter>();
            });

            services.AddCors(options =>
            {
                options.AddPolicy("CorsPolicy",
                                  builder => builder
                                  .SetIsOriginAllowed((host) => true)
                                  .AllowAnyMethod()
                                  .AllowAnyHeader()
                                  .AllowCredentials());
            });

            RegisterEventBus(services);

            services.AddTransient <IMarketingDataRepository, MarketingDataRepository>();
            services.AddSingleton <IHttpContextAccessor, HttpContextAccessor>();
            services.AddTransient <IIdentityService, IdentityService>();

            services.AddOptions();

            //configure autofac
            var container = new ContainerBuilder();

            container.Populate(services);

            return(new AutofacServiceProvider(container.Build()));
        }
 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();
 }
예제 #51
0
        public int Run()
        {
            // Obtain management via .publishsettings file from https://manage.windowsazure.com/publishsettings/index?schemaversion=2.0
            var creds = new CertificateCloudCredentials(SubscriptionId, ManagementCertificate);

            // Create Namespace
            var sbMgmt = new ServiceBusManagementClient(creds);

            ServiceBusNamespaceResponse nsResponse = null;

            Console.WriteLine("Creating Service Bus namespace {0} in location {1}", SBNamespace, Location);
            try
            {
                var resultSb = sbMgmt.Namespaces.Create(SBNamespace, Location);
                if (resultSb.StatusCode != System.Net.HttpStatusCode.OK)
                {
                    Console.WriteLine("Error creating Service Bus namespace {0} in Location {1}: {2}", SBNamespace, Location, resultSb.StatusCode);
                    return 1;
                }
            }
            catch (CloudException)
            {
                try
                {
                    // There is (currently) no clean error code returned when the namespace already exists
                    // Check if it does
                    nsResponse = sbMgmt.Namespaces.Get(SBNamespace);
                    Console.WriteLine("Service Bus namespace {0} already existed.", SBNamespace);
                }
                catch (Exception)
                {
                    nsResponse = null;
                }
                if (nsResponse == null)
                {
                    throw;
                }
            }

            // Wait until the namespace is active
            while (nsResponse == null || nsResponse.Namespace.Status != "Active")
            {
                nsResponse = sbMgmt.Namespaces.Get(SBNamespace);
                if (nsResponse.Namespace.Status == "Active")
                {
                    break;
                }
                Console.WriteLine("Namespace {0} in state {1}. Waiting...", SBNamespace, nsResponse.Namespace.Status);
                System.Threading.Thread.Sleep(5000);
            }

            // Get the namespace connection string
            var nsDescription = sbMgmt.Namespaces.GetNamespaceDescription(SBNamespace);
            var nsConnectionString = nsDescription.NamespaceDescriptions.First(
                (d) => String.Equals(d.AuthorizationType, "SharedAccessAuthorization")
                ).ConnectionString;

            // Create EHs + device keys + consumer keys (WebSite*)
            var nsManager = NamespaceManager.CreateFromConnectionString(nsConnectionString);

            var ehDescriptionDevices = new EventHubDescription(EventHubNameDevices)
            {
                PartitionCount = 8,
            };
            ehDescriptionDevices.Authorization.Add(new SharedAccessAuthorizationRule("D1", new List<AccessRights> { AccessRights.Send }));
            ehDescriptionDevices.Authorization.Add(new SharedAccessAuthorizationRule("D2", new List<AccessRights> { AccessRights.Send }));
            ehDescriptionDevices.Authorization.Add(new SharedAccessAuthorizationRule("D3", new List<AccessRights> { AccessRights.Send }));
            ehDescriptionDevices.Authorization.Add(new SharedAccessAuthorizationRule("D4", new List<AccessRights> { AccessRights.Send }));

            ehDescriptionDevices.Authorization.Add(new SharedAccessAuthorizationRule("WebSite", new List<AccessRights> { AccessRights.Manage, AccessRights.Listen, AccessRights.Send }));

            ehDescriptionDevices.Authorization.Add(new SharedAccessAuthorizationRule("StreamingAnalytics", new List<AccessRights> { AccessRights.Manage, AccessRights.Listen, AccessRights.Send }));

            Console.WriteLine("Creating Event Hub {0}", EventHubNameDevices);
            EventHubDescription ehDevices = null;
            do
            {
                try
                {
                    ehDevices = nsManager.CreateEventHubIfNotExists(ehDescriptionDevices);
                }
                catch (System.UnauthorizedAccessException)
                {
                    Console.WriteLine("Service Bus connection string not valid yet. Waiting...");
                    System.Threading.Thread.Sleep(5000);
                }
            } while (ehDevices == null);

            var ehDescriptionAlerts = new EventHubDescription(EventHubNameAlerts)
            {
                PartitionCount = 8,
            };
            ehDescriptionAlerts.Authorization.Add(new SharedAccessAuthorizationRule("WebSite", new List<AccessRights> { AccessRights.Manage, AccessRights.Listen, AccessRights.Send }));
            ehDescriptionAlerts.Authorization.Add(new SharedAccessAuthorizationRule("StreamingAnalytics", new List<AccessRights> { AccessRights.Manage, AccessRights.Listen, AccessRights.Send }));

            Console.WriteLine("Creating Event Hub {0}", EventHubNameAlerts);
            var ehAlerts = nsManager.CreateEventHubIfNotExists(ehDescriptionAlerts);

            // Create Storage Account for Event Hub Processor
            var stgMgmt = new StorageManagementClient(creds);
            try
            {
                Console.WriteLine("Creating Storage Account {0} in location {1}", StorageAccountName, Location);
                var resultStg = stgMgmt.StorageAccounts.Create(
                    new StorageAccountCreateParameters { Name = StorageAccountName.ToLowerInvariant(), Location = Location, AccountType = "Standard_LRS" });

                if (resultStg.StatusCode != System.Net.HttpStatusCode.OK)
                {
                    Console.WriteLine("Error creating storage account {0} in Location {1}: {2}", StorageAccountName, Location, resultStg.StatusCode);
                    return 1;
                }
            }
            catch (CloudException ce)
            {
                if (String.Equals(ce.ErrorCode, "ConflictError", StringComparison.InvariantCultureIgnoreCase))
                {
                    Console.WriteLine("Storage account {0} already existed.", StorageAccountName);
                }
                else
                {
                    throw;
                }
            }
            var keyResponse = stgMgmt.StorageAccounts.GetKeys(StorageAccountName.ToLowerInvariant());
            if (keyResponse.StatusCode != System.Net.HttpStatusCode.OK)
            {
                Console.WriteLine("Error retrieving access keys for storage account {0} in Location {1}: {2}", StorageAccountName, Location, keyResponse.StatusCode);
                return 1;
            }

            var storageKey = keyResponse.PrimaryKey;
            string ehDevicesWebSiteConnectionString = new ServiceBusConnectionStringBuilder(nsConnectionString)
            {
                SharedAccessKeyName = "WebSite",
                SharedAccessKey = (ehDevices.Authorization.First((d)
                   => String.Equals(d.KeyName, "WebSite", StringComparison.InvariantCultureIgnoreCase)) as SharedAccessAuthorizationRule).PrimaryKey,
            }.ToString();

            string ehAlertsWebSiteConnectionString = new ServiceBusConnectionStringBuilder(nsConnectionString)
            {
                SharedAccessKeyName = "WebSite",
                SharedAccessKey = (ehAlerts.Authorization.First((d)
                   => String.Equals(d.KeyName, "WebSite", StringComparison.InvariantCultureIgnoreCase)) as SharedAccessAuthorizationRule).PrimaryKey,
            }.ToString();

            // Write a new web.config template file
            var doc = new XmlDocument();
            doc.PreserveWhitespace = true;

            var inputFileName = (this.Transform ? "\\web.PublishTemplate.config" : "\\web.config");
            var outputFileName = (this.Transform ? String.Format("\\web.{0}.config", NamePrefix) : "\\web.config");

            doc.Load(WebSiteDirectory + inputFileName);

            doc.SelectSingleNode("/configuration/appSettings/add[@key='Microsoft.ServiceBus.EventHubDevices']/@value").Value
                = EventHubNameDevices;
            doc.SelectSingleNode("/configuration/appSettings/add[@key='Microsoft.ServiceBus.EventHubAlerts']/@value").Value
                = EventHubNameAlerts;
            doc.SelectSingleNode("/configuration/appSettings/add[@key='Microsoft.ServiceBus.ConnectionString']/@value").Value
                = nsConnectionString;
            doc.SelectSingleNode("/configuration/appSettings/add[@key='Microsoft.ServiceBus.ConnectionStringDevices']/@value").Value
                = ehDevicesWebSiteConnectionString;
            doc.SelectSingleNode("/configuration/appSettings/add[@key='Microsoft.ServiceBus.ConnectionStringAlerts']/@value").Value
                = ehAlertsWebSiteConnectionString;
            doc.SelectSingleNode("/configuration/appSettings/add[@key='Microsoft.Storage.ConnectionString']/@value").Value =
                String.Format("DefaultEndpointsProtocol=https;AccountName={0};AccountKey={1}", StorageAccountName, storageKey);

            var outputFile = System.IO.Path.GetFullPath(WebSiteDirectory + outputFileName);

            doc.Save(outputFile);

            Console.WriteLine();
            Console.WriteLine("Service Bus management connection string (i.e. for use in Service Bus Explorer):");
            Console.WriteLine(nsConnectionString);
            Console.WriteLine();
            Console.WriteLine("Device AMQP address strings (for Raspberry PI/devices):");
            for (int i = 1; i <= 4; i++)
            {
                var deviceKeyName = String.Format("D{0}", i);
                var deviceKey = (ehDevices.Authorization.First((d)
                        => String.Equals(d.KeyName, deviceKeyName, StringComparison.InvariantCultureIgnoreCase)) as SharedAccessAuthorizationRule).PrimaryKey;

                Console.WriteLine("amqps://{0}:{1}@{2}.servicebus.windows.net", deviceKeyName, Uri.EscapeDataString(deviceKey), SBNamespace);

                //Console.WriteLine(new ServiceBusConnectionStringBuilder(nsConnectionString)
                //{
                //    SharedAccessKeyName = deviceKeyName,
                //    SharedAccessKey = deviceKey,
                //}.ToString());
            }
            Console.WriteLine();
            Console.WriteLine("Web.Config saved to {0}", outputFile);

            #if AZURESTREAMANALYTICS
            // Create StreamAnalyticsJobs + inputs + outputs + enter keys

            // Untested code. May require AAD authentication, no support for management cert?

            // Create Resource Group for the Stream Analytics jobs
            var groupCreateRequest = WebRequest.Create(String.Format("https://management.azure.com/subscriptions/{0}/resourcegroups/{1}?api-version=2014-04-01-preview",
                SubscriptionId, StreamAnalyticsGroup)) as HttpWebRequest;

            groupCreateRequest.ClientCertificates.Add(creds.ManagementCertificate);
            groupCreateRequest.ContentType = "application/json";
            groupCreateRequest.Method = "PUT";
            groupCreateRequest.KeepAlive = true;

            var bytesGroup = Encoding.UTF8.GetBytes("{\"location\":\"Central US\"}");
            groupCreateRequest.ContentLength = bytesGroup.Length;
            groupCreateRequest.GetRequestStream().Write(bytesGroup, 0, bytesGroup.Length);

            var groupCreateResponse = groupCreateRequest.GetResponse();

            //var streamMgmt = new ManagementClient(creds); //, new Uri("https://management.azure.com"));
            //HttpClient client = streamMgmt.HttpClient;

            var createJob = new StreamAnalyticsJob()
            {
                location = Location,
                inputs = new List<StreamAnalyticsEntity>
                {
                    new StreamAnalyticsEntity
                    {
                        name = "devicesInput",
                        properties = new Dictionary<string,object>
                        {
                            { "type" , "stream" },
                            { "serialization" , new Dictionary<string,object>
                                {
                                    { "type", "JSON"},
                                    { "properties", new Dictionary<string, object>
                                        {
                                            { "encoding", "UTF8"},
                                        }
                                    }
                                }
                            },
                            { "datasource", new Dictionary<string,object>
                                {
                                    { "type", "Microsoft.ServiceBus/EventHub" },
                                    { "properties", new Dictionary<string,object>
                                        {
                                            { "eventHubNamespace", Namespace },
                                            { "eventHubName", EventHubDevices },
                                            { "sharedAccessPolicyName", "StreamingAnalytics" },
                                            { "sharedAccessPolicyKey",
                                                (ehDevices.Authorization.First( (d)
                                                    => String.Equals(d.KeyName, "StreamingAnalytics", StringComparison.InvariantCultureIgnoreCase)) as SharedAccessAuthorizationRule).PrimaryKey },
                                        }
                                    }
                                }
                             }
                        },
                    },
                },
                transformation = new StreamAnalyticsEntity()
                {
                    name = "Aggregates",
                    properties = new Dictionary<string,object>
                    {
                        { "streamingUnits", 1 },
                        { "query" , "select * from devicesInput" },
                    }
                },
                outputs = new List<StreamAnalyticsEntity>
                {
                    new StreamAnalyticsEntity
                    {
                        name = "output",
                        properties = new Dictionary<string,object>
                        {
                            { "datasource", new Dictionary<string,object>
                                {
                                    { "type", "Microsoft.ServiceBus/EventHub" },
                                    { "properties", new Dictionary<string,object>
                                        {
                                            { "eventHubNamespace", Namespace },
                                            { "eventHubName", EventHubAlerts },
                                            { "sharedAccessPolicyName", "StreamingAnalytics" },
                                            { "sharedAccessPolicyKey",
                                                (ehAlerts.Authorization.First( (d) => String.Equals(d.KeyName, "StreamingAnalytics", StringComparison.InvariantCultureIgnoreCase)) as SharedAccessAuthorizationRule).PrimaryKey },
                                        }
                                    }
                                }
                            },
                            { "serialization" , new Dictionary<string,object>
                                {
                                    { "type", "JSON"},
                                    { "properties", new Dictionary<string, object>
                                        {
                                            { "encoding", "UTF8"},
                                        }
                                    }
                                }
                            },
                        },
                    },
                }
            };

            var jobCreateRequest = WebRequest.Create(String.Format("https://management.azure.com/subscriptions/{0}/resourcegroups/{1}/Microsoft.StreamAnalytics/streamingjobs/{2}?api-version=2014-10-01",
                SubscriptionId, StreamAnalyticsGroup, JobAggregates)) as HttpWebRequest;

            jobCreateRequest.ClientCertificates.Add(creds.ManagementCertificate);
            jobCreateRequest.ContentType = "application/json";
            jobCreateRequest.Method = "PUT";
            jobCreateRequest.KeepAlive = true;

            var bytes = Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(createJob));
            jobCreateRequest.ContentLength = bytes.Length;
            jobCreateRequest.GetRequestStream().Write(bytes, 0, bytes.Length);

            var jobCreateResponse = jobCreateRequest.GetResponse();

            //var jobCreateTask = streamMgmt.HttpClient.PutAsync(
            //    String.Format("https://management.azure.com/subscriptions/{0}/resourcegroups/{1}/Microsoft.StreamAnalytics/streamingjobs/{2}?api-version=2014-10-01",
            //    SubscriptionId, StreamAnalyticsGroup, JobAggregates),
            //    new StringContent(JsonConvert.SerializeObject(createJob)));
            //jobCreateTask.Wait();
            //var jobCreateResponse = jobCreateTask.Result;
            #endif
            return 0;
        }
        private static WcfCommunicationListener <TServiceContract> ResolveCommunicationListener <TServiceContract>(
            StatelessServiceContext context,
            TServiceContract wcfServiceObject,
            NetMessagingBinding netMessagingBinding,
            Func <string> queueNameProvider,
            Func <ServiceContext, string> connectionStringResolver,
            IEndpointBehavior[] behaviors)
        {
            if (context == null)
            {
                throw new ArgumentNullException(nameof(context));
            }

            if (wcfServiceObject == null)
            {
                throw new ArgumentNullException(nameof(wcfServiceObject));
            }

            if (netMessagingBinding == null)
            {
                throw new ArgumentNullException(nameof(netMessagingBinding));
            }

            if (connectionStringResolver == null)
            {
                throw new ArgumentNullException(nameof(connectionStringResolver));
            }

            if (behaviors == null)
            {
                throw new ArgumentNullException(nameof(behaviors));
            }

            string listenConnectionString = connectionStringResolver(context);

            ServiceBusConnectionStringBuilder builder = new ServiceBusConnectionStringBuilder(listenConnectionString);

            Uri endpointUri;

            try
            {
                endpointUri = builder.Endpoints.SingleOrDefault();
            }
            catch (InvalidOperationException)
            {
                throw new InvalidOperationException("More than one endpoint was detected in connection string");
            }

            if (endpointUri == null)
            {
                throw new InvalidOperationException("No endpoint was detected in connection string");
            }

            UriBuilder uriBuilder = new UriBuilder(endpointUri);

            var listener = new WcfCommunicationListener <TServiceContract>(
                wcfServiceObject: wcfServiceObject,
                serviceContext: context,

                //
                // The name of the endpoint configured in the ServiceManifest under the Endpoints section
                // that identifies the endpoint that the WCF ServiceHost should listen on.
                //
                address: new EndpointAddress(ServiceBusEnvironment.CreateServiceUri("sb", uriBuilder.Host.Split('.').First(), queueNameProvider == null ? typeof(TServiceContract).Name : queueNameProvider.Invoke())),

                //
                // Populate the binding information that you want the service to use.
                //
                listenerBinding: netMessagingBinding
                );

            ServiceEndpoint serviceEndpoint = listener.ServiceHost.Description.Endpoints.Last();

            serviceEndpoint.Behaviors.Add(new TransportClientEndpointBehavior
            {
                TokenProvider = TokenProvider.CreateSharedAccessSignatureTokenProvider(
                    keyName: builder.SharedAccessKeyName,
                    sharedAccessKey: builder.SharedAccessKey
                    )
            });

            foreach (IEndpointBehavior behavior in behaviors)
            {
                serviceEndpoint.Behaviors.Add(behavior);
            }

            return(listener);
        }
예제 #53
0
        /// <summary>
        /// Create a messaging factory from a connection string
        /// </summary>
        /// <param name="connectionString">Connection string</param>
        /// <returns>Messaging factory</returns>
        public static MessagingFactory CreateFromConnectionString(string connectionString)
        {
            ServiceBusConnectionStringBuilder builder = new ServiceBusConnectionStringBuilder(connectionString);

            Uri endpointAddress = builder.Endpoint;
            string sharedAccessKeyName = builder.SharedAccessKeyName;
            string sharedAccessKey = builder.SharedAccessKey;
            string sharedAccessSignature = builder.SharedAccessSignature;

            TokenProvider tokenProvider = null;
            if ((sharedAccessKeyName != null) && (sharedAccessKeyName != string.Empty))
            {
                tokenProvider = TokenProvider.CreateSharedAccessSignatureTokenProvider(sharedAccessKeyName, sharedAccessKey);
            }
            if ((sharedAccessSignature != null) && (sharedAccessSignature != string.Empty))
            {
                tokenProvider = TokenProvider.CreateSharedAccessSignatureTokenProvider(sharedAccessSignature);
            }

            return Create(endpointAddress, tokenProvider);
        }
예제 #54
0
        private void AddEventing(IServiceCollection services)
        {
            services.AddSingleton <IEventBusSubscriptionsManager, InMemoryEventBusSubscriptionsManager>();
            var connection     = Configuration.GetValue <string>("ServiceBusConnection");
            var connectionBlob = Configuration.GetValue <string>("BlobConnection");

            if (string.IsNullOrWhiteSpace(connection))
            {
                //    _logger.LogError("Error configuring eventing. Service Bus connection settings are missing");
            }
            else
            {
                //  _logger.LogInformation($"Retrieved Service Bus connection settings");
            }



            services.AddSingleton <IBlobConnection>(sp =>
            {
                var logger = sp.GetRequiredService <ILogger <BlobConnection> >();
                return(new BlobConnection(connectionBlob));
            });
            services.AddSingleton <IEventStorage, EventsBlobStorage>(sp =>
            {
                var blobStoragePersisterConnection = sp.GetRequiredService <IBlobConnection>();
                var logger = sp.GetRequiredService <ILogger <EventsBlobStorage> >();

                return(new EventsBlobStorage(blobStoragePersisterConnection, logger));
            });



            // Configure Service Bus Provider - RabbitMq or Azure Service Bus based on environment variables
            if (Configuration.GetValue <bool>("UseAzureServiceBus"))
            {
                //   _logger.LogInformation($"Configuring Azure service bus");

                services.AddSingleton <IServiceBusPersisterConnection>(sp =>
                {
                    var logger = sp.GetRequiredService <ILogger <DefaultServiceBusPersisterConnection> >();
                    var serviceBusConnection = new ServiceBusConnectionStringBuilder(connection);

                    return(new DefaultServiceBusPersisterConnection(serviceBusConnection, logger));
                });

                services.AddSingleton <IEventBus, EventBusServiceBus>(sp =>
                {
                    var serviceBusPersisterConnection = sp.GetRequiredService <IServiceBusPersisterConnection>();
                    var logger = sp.GetRequiredService <ILogger <EventBusServiceBus> >();
                    var eventBusSubcriptionsManager = sp.GetRequiredService <IEventBusSubscriptionsManager>();
                    var subscriptionClientName      = Configuration["SubscriptionClientName"];

                    return(new EventBusServiceBus(serviceBusPersisterConnection, logger, eventBusSubcriptionsManager, subscriptionClientName, sp));
                });
            }
            else
            {
                //  _logger.LogInformation($"Configuring Rabbitmq");

                services.AddSingleton <IRabbitMQPersistentConnection>(sp =>
                {
                    var settings = sp.GetRequiredService <IOptions <AuthorConfigurationSettings> >().Value;
                    var logger   = sp.GetRequiredService <ILogger <DefaultRabbitMQPersistentConnection> >();

                    var factory = new ConnectionFactory()
                    {
                        HostName = settings.ServiceBusConnection //"my-rabbit"
                    };
                    //if (!string.IsNullOrEmpty(settings.ServiceBusUserName))
                    //{
                    //    factory.UserName = settings.ServiceBusUserName;
                    //}

                    //if (!string.IsNullOrEmpty(settings.ServiceBusUserPassword))
                    //{
                    //    factory.Password = settings.ServiceBusUserPassword;
                    //}
                    var retryCount = 5;

                    return(new DefaultRabbitMQPersistentConnection(factory, logger, retryCount));
                });

                services.AddSingleton <IEventBus, EventBusRabbitMQ>(sp =>
                {
                    var rabbitMQPersistentConnection = sp.GetRequiredService <IRabbitMQPersistentConnection>();
                    var logger = sp.GetRequiredService <ILogger <EventBusRabbitMQ> >();
                    var eventBusSubcriptionsManager = sp.GetRequiredService <IEventBusSubscriptionsManager>();

                    var retryCount = 5;

                    return(new EventBusRabbitMQ(rabbitMQPersistentConnection, logger, eventBusSubcriptionsManager, sp, retryCount));
                });
            }

            //   _logger.LogInformation($"Finished configuring service bus");

            // Register Event Handlers
            //EX:
        }
예제 #55
0
        private bool CreateWeb( CloudWebDeployInputs inputs )
        {
            Console.WriteLine( "Retrieving namespace metadata..." );
            // Create Namespace
            ServiceBusManagementClient sbMgmt = new ServiceBusManagementClient( inputs.Credentials );

            var nsDescription = sbMgmt.Namespaces.GetNamespaceDescription( inputs.SBNamespace );
            string nsConnectionString = nsDescription.NamespaceDescriptions.First(
                ( d ) => String.Equals( d.AuthorizationType, "SharedAccessAuthorization" )
                ).ConnectionString;

            NamespaceManager nsManager = NamespaceManager.CreateFromConnectionString( nsConnectionString );

            StorageManagementClient stgMgmt = new StorageManagementClient( inputs.Credentials );
            var keyResponse = stgMgmt.StorageAccounts.GetKeys( inputs.StorageAccountName.ToLowerInvariant( ) );
            if( keyResponse.StatusCode != System.Net.HttpStatusCode.OK )
            {
                Console.WriteLine( "Error retrieving access keys for storage account {0} in Location {1}: {2}",
                    inputs.StorageAccountName, inputs.Location, keyResponse.StatusCode );
                return false;
            }

            var storageKey = keyResponse.PrimaryKey;

            EventHubDescription ehDevices = nsManager.GetEventHub( inputs.EventHubNameDevices );
            string ehDevicesWebSiteConnectionString = new ServiceBusConnectionStringBuilder( nsConnectionString )
            {
                SharedAccessKeyName = "WebSite",
                SharedAccessKey = ( ehDevices.Authorization.First( ( d )
                    => String.Equals( d.KeyName, "WebSite", StringComparison.InvariantCultureIgnoreCase) ) as SharedAccessAuthorizationRule ).PrimaryKey,
            }.ToString( );

            string ehAlertsWebSiteConnectionString = string.Empty;
            try
            {
                EventHubDescription ehAlerts = nsManager.GetEventHub( inputs.EventHubNameAlerts );
                ehAlertsWebSiteConnectionString = new ServiceBusConnectionStringBuilder( nsConnectionString )
                {
                    SharedAccessKeyName = "WebSite",
                    SharedAccessKey = ( ehAlerts.Authorization.First( ( d )
                        => String.Equals( d.KeyName, "WebSite", StringComparison.InvariantCultureIgnoreCase ) ) as
                        SharedAccessAuthorizationRule ).PrimaryKey,
                }.ToString( );
            }
            catch
            {
            }

            Console.WriteLine( "Started processing..." );
            // Write a new web.config template file
            var doc = new XmlDocument { PreserveWhitespace = true };
            
            //var inputFileName = ( inputs.Transform ? "\\web.PublishTemplate.config" : "\\web.config" );
            string inputFileName = "web.PublishTemplate.config";
            //var outputFileName = ( inputs.Transform ? String.Format("\\web.{0}.config", inputs.NamePrefix) : "\\web.config" );
            string outputFileName = "web.config";

            //doc.Load( inputs.WebSiteDirectory + inputFileName );

            string inputFilePath = Environment.CurrentDirectory +@"\";
            Console.WriteLine("Opening and updating " + inputFilePath + inputFileName);

            doc.Load( inputFilePath + inputFileName );

            doc.SelectSingleNode(
                "/configuration/appSettings/add[@key='Microsoft.ServiceBus.EventHubDevices']/@value" ).Value
                = inputs.EventHubNameDevices;
            doc.SelectSingleNode( "/configuration/appSettings/add[@key='Microsoft.ServiceBus.EventHubAlerts']/@value" )
                .Value
                = inputs.EventHubNameAlerts;
            doc.SelectSingleNode(
                "/configuration/appSettings/add[@key='Microsoft.ServiceBus.ConnectionString']/@value" ).Value
                = nsConnectionString;
            doc.SelectSingleNode(
                "/configuration/appSettings/add[@key='Microsoft.ServiceBus.ConnectionStringDevices']/@value" ).Value
                = ehDevicesWebSiteConnectionString;
            doc.SelectSingleNode(
                "/configuration/appSettings/add[@key='Microsoft.ServiceBus.ConnectionStringAlerts']/@value" ).Value
                = ehAlertsWebSiteConnectionString;
            doc.SelectSingleNode( "/configuration/appSettings/add[@key='Microsoft.Storage.ConnectionString']/@value" )
                .Value =
                String.Format( "DefaultEndpointsProtocol=https;AccountName={0};AccountKey={1}", inputs.StorageAccountName,
                    storageKey );

            //var outputFile = System.IO.Path.GetFullPath( inputs.WebSiteDirectory + outputFileName );
            string outputFilePath = Environment.GetFolderPath( Environment.SpecialFolder.Desktop );
            //Console.WriteLine(outputFilePath);

            var outputFile = outputFilePath + @"\" + outputFileName;
            Console.WriteLine( "Writing updates to " + outputFile );

            doc.Save( outputFile );
            Console.WriteLine( " " );
            Console.WriteLine( "Web config saved to {0}", outputFile ); 
            Console.WriteLine( " " );
            return true;
        }
        public async Task RunTest()
        {
            var senderCxn = new ServiceBusConnectionStringBuilder(targetNamespaceConnectionString)
            {
                EntityPath = targetQueue
            };
            var sendSideClient = new Microsoft.Azure.ServiceBus.Core.MessageSender(senderCxn);

            var receiverCxn = new ServiceBusConnectionStringBuilder(sourceNamespaceConnectionString)
            {
                EntityPath = sourceQueue
            };
            var receiveSideClient = new Microsoft.Azure.ServiceBus.Core.MessageReceiver(receiverCxn);

            var start = DateTime.UtcNow;

            var sw = new Stopwatch();

            sw.Start();
            var tracker = new ConcurrentDictionary <string, long>();

            Console.WriteLine("sending");
            List <Task> sendTasks = new List <Task>();

            for (int j = 0; j < 1000; j++)
            {
                string msgid = Guid.NewGuid().ToString();
                tracker[msgid] = sw.ElapsedTicks;
                var message = new Message(new byte[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 0 });
                message.MessageId = msgid;
                sendTasks.Add(sendSideClient.SendAsync(message));
            }

            await Task.WhenAll(sendTasks);

            ConcurrentBag <long> durations = new ConcurrentBag <long>();

            Console.Write("receiving: ");
            var receiveTask = Task.Run(async() =>
            {
                while (!tracker.IsEmpty)
                {
                    var message = await receiveSideClient.ReceiveAsync(100, TimeSpan.FromSeconds(30));
                    if (message != null)
                    {
                        foreach (var msg in message)
                        {
                            string msgid = msg.MessageId;
                            if (tracker.TryRemove(msgid, out var swval))
                            {
                                durations.Add(sw.ElapsedTicks - swval);
                            }
                            await receiveSideClient.CompleteAsync(msg.SystemProperties.LockToken);
                        }
                    }
                    else
                    {
                        break;
                    }
                }
            });

            await receiveTask;

            Console.WriteLine();
            Assert.True(tracker.IsEmpty, $"tracker is not empty: {tracker.Count}");

            Console.WriteLine(((double)durations.Sum() / (double)durations.Count) / TimeSpan.TicksPerMillisecond);
        }
예제 #57
0
        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;
        }
예제 #58
0
        // This method gets called by the runtime. Use this method to add services to the container.
        // For more information on how to configure your application, visit https://go.microsoft.com/fwlink/?LinkID=398940
        public IServiceProvider ConfigureServices(IServiceCollection services)
        {
            services.AddCors(options =>
            {
                options.AddPolicy("CorsPolicy",
                                  builder => builder.AllowAnyOrigin()
                                  .AllowAnyMethod()
                                  .AllowAnyHeader()
                                  .AllowCredentials());
            });

            if (Configuration.GetValue <string>("IsClusterEnv") == bool.TrueString)
            {
                services
                .AddSignalR()
                .AddRedis(Configuration["SignalrStoreConnectionString"]);
            }
            else
            {
                services.AddSignalR();
            }

            if (Configuration.GetValue <bool>("AzureServiceBusEnabled"))
            {
                services.AddSingleton <IServiceBusPersisterConnection>(sp =>
                {
                    var logger = sp.GetRequiredService <ILogger <DefaultServiceBusPersisterConnection> >();

                    var serviceBusConnectionString = Configuration["EventBusConnection"];
                    var serviceBusConnection       = new ServiceBusConnectionStringBuilder(serviceBusConnectionString);

                    return(new DefaultServiceBusPersisterConnection(serviceBusConnection, logger));
                });
            }
            else
            {
                services.AddSingleton <IRabbitMQPersistentConnection>(sp =>
                {
                    var logger = sp.GetRequiredService <ILogger <DefaultRabbitMQPersistentConnection> >();


                    var factory = new ConnectionFactory()
                    {
                        HostName = Configuration["EventBusConnection"]
                    };

                    if (!string.IsNullOrEmpty(Configuration["EventBusUserName"]))
                    {
                        factory.UserName = Configuration["EventBusUserName"];
                    }

                    if (!string.IsNullOrEmpty(Configuration["EventBusPassword"]))
                    {
                        factory.Password = Configuration["EventBusPassword"];
                    }

                    var retryCount = 5;
                    if (!string.IsNullOrEmpty(Configuration["EventBusRetryCount"]))
                    {
                        retryCount = int.Parse(Configuration["EventBusRetryCount"]);
                    }

                    return(new DefaultRabbitMQPersistentConnection(factory, logger, retryCount));
                });
            }

            ConfigureAuthService(services);

            RegisterEventBus(services);

            services.AddOptions();

            //configure autofac
            var container = new ContainerBuilder();

            container.RegisterModule(new ApplicationModule());
            container.Populate(services);

            return(new AutofacServiceProvider(container.Build()));
        }
 public DefaultServiceBusPersisterConnection(ServiceBusConnectionStringBuilder serviceBusConnectionStringBuilder)
 {
     _serviceBusConnectionStringBuilder = serviceBusConnectionStringBuilder ??
                                          throw new ArgumentNullException(nameof(serviceBusConnectionStringBuilder));
     _topicClient = new TopicClient(_serviceBusConnectionStringBuilder, RetryPolicy.Default);
 }
예제 #60
0
        public static IServiceCollection AddCustomEventBus(this IServiceCollection services, IConfiguration Configuration)
        {
            var subscriptionClientName = Configuration["EventBus:SubscriptionClientName"];

            if (Configuration.GetValue <bool>("AzureServiceBusEnabled"))
            {
                services.AddSingleton <IServiceBusPersisterConnection>(sp =>
                {
                    var logger = sp.GetRequiredService <ILogger <DefaultServiceBusPersisterConnection> >();

                    var serviceBusConnectionString = Configuration["EventBus:Connection"];
                    var serviceBusConnection       = new ServiceBusConnectionStringBuilder(serviceBusConnectionString);

                    return(new DefaultServiceBusPersisterConnection(serviceBusConnection, logger));
                });
                services.AddSingleton <IEventBus, EventBusServiceBus>(sp =>
                {
                    var serviceBusPersisterConnection = sp.GetRequiredService <IServiceBusPersisterConnection>();
                    var iLifetimeScope = sp.GetRequiredService <ILifetimeScope>();
                    var logger         = sp.GetRequiredService <ILogger <EventBusServiceBus> >();
                    var eventBusSubcriptionsManager = sp.GetRequiredService <IEventBusSubscriptionsManager>();

                    return(new EventBusServiceBus(serviceBusPersisterConnection, logger,
                                                  eventBusSubcriptionsManager, subscriptionClientName, iLifetimeScope));
                });
            }
            else
            {
                services.AddSingleton <IRabbitMQPersistentConnection>(sp =>
                {
                    var logger  = sp.GetRequiredService <ILogger <DefaultRabbitMQPersistentConnection> >();
                    var factory = new ConnectionFactory()
                    {
                        HostName = Configuration["EventBus:Connection"],
                        DispatchConsumersAsync = true
                    };

                    if (!string.IsNullOrEmpty(Configuration["EventBus:UserName"]))
                    {
                        factory.UserName = Configuration["EventBus:UserName"];
                    }

                    if (!string.IsNullOrEmpty(Configuration["EventBus:Password"]))
                    {
                        factory.Password = Configuration["EventBus:Password"];
                    }

                    var retryCount = 5;
                    if (!string.IsNullOrEmpty(Configuration["EventBus:RetryCount"]))
                    {
                        retryCount = int.Parse(Configuration["EventBus:RetryCount"]);
                    }

                    return(new DefaultRabbitMQPersistentConnection(factory, logger, retryCount));
                });

                services.AddSingleton <IEventBus, EventBusRabbitMQ>(sp =>
                {
                    var rabbitMQPersistentConnection = sp.GetRequiredService <IRabbitMQPersistentConnection>();
                    var iLifetimeScope = sp.GetRequiredService <ILifetimeScope>();
                    var logger         = sp.GetRequiredService <ILogger <EventBusRabbitMQ> >();
                    var eventBusSubcriptionsManager = sp.GetRequiredService <IEventBusSubscriptionsManager>();

                    var retryCount = 5;
                    if (!string.IsNullOrEmpty(Configuration["EventBus:RetryCount"]))
                    {
                        retryCount = int.Parse(Configuration["EventBus:RetryCount"]);
                    }

                    return(new EventBusRabbitMQ(rabbitMQPersistentConnection, logger, iLifetimeScope, eventBusSubcriptionsManager, subscriptionClientName, retryCount));
                });
            }


            services.AddSingleton <IEventBusSubscriptionsManager, InMemoryEventBusSubscriptionsManager>();

            return(services);
        }