private static async Task RunAsync() { var tokenProvider = TokenProvider.CreateSharedAccessSignatureTokenProvider(KeyName, Key); var listener = new HybridConnectionListener(new Uri(string.Format("sb://{0}/{1}", RelayNamespace, ConnectionName)), tokenProvider); // Subscribe to the status events. listener.Connecting += (o, e) => { Console.WriteLine("Connecting"); }; listener.Offline += (o, e) => { Console.WriteLine("Offline"); }; listener.Online += (o, e) => { Console.WriteLine("Online"); }; // Provide an HTTP request handler listener.RequestHandler = (context) => { var name = context.Request.Headers["PassThrough"]; // Do something with context.Request.Url, HttpMethod, Headers, InputStream... context.Response.StatusCode = HttpStatusCode.OK; context.Response.StatusDescription = "OK"; var env = new StringBuilder(); env.Append($"Machine Name = {Environment.MachineName}\r\n"); env.Append($"OS Version = {Environment.OSVersion}\r\n"); env.Append($"Current Directory = {Environment.CurrentDirectory}\r\n"); env.Append($"Current User = {Environment.UserName}\r\n"); using (var sw = new StreamWriter(context.Response.OutputStream)) { sw.WriteLine(env.ToString()); sw.WriteLine("hello, " + name); } Console.WriteLine("request from " + name); // The context MUST be closed here context.Response.Close(); }; // Opening the listener establishes the control channel to // the Azure Relay service. The control channel is continuously // maintained, and is reestablished when connectivity is disrupted. await listener.OpenAsync(); Console.WriteLine("Server listening"); // Start a new thread that will continuously read the console. await Console.In.ReadLineAsync(); // Close the listener after you exit the processing loop. await listener.CloseAsync(); }
public string Get() { ChannelFactory <IServiceContract> channelFactory; // Create shared access signature token credentials for authentication. channelFactory = new ChannelFactory <IServiceContract>(new BasicHttpRelayBinding(), RelayName); channelFactory.Endpoint.Behaviors.Add(new TransportClientEndpointBehavior { TokenProvider = TokenProvider.CreateSharedAccessSignatureTokenProvider(RelayPolicyKeyName, RelayPolicyKey) }); // Create Channel & Establish the Communication between relay IServiceContract channel = channelFactory.CreateChannel(); // Call WCF Method return(channel.Get()); }
private static QueueDescription CreateQueue() { Uri managementAddress = ServiceBusEnvironment.CreateServiceUri("https", Sender.serviceBusNamespace, string.Empty); namespaceManager = new NamespaceManager( managementAddress, TokenProvider.CreateSharedAccessSignatureTokenProvider(serviceBusKeyName, serviceBusKey)); Console.WriteLine("Creating queue \"OrdersQueue\"."); if (namespaceManager.QueueExists("OrdersQueue")) { namespaceManager.DeleteQueue("OrdersQueue"); } return(namespaceManager.CreateQueue("OrdersQueue")); }
static void Main(string[] args) { var cf = new ChannelFactory <IService1Channel>( new NetTcpRelayBinding(), new EndpointAddress(ServiceBusEnvironment.CreateServiceUri("sb", "testeservicebus2", "service"))); cf.Endpoint.Behaviors.Add(new TransportClientEndpointBehavior { TokenProvider = TokenProvider.CreateSharedAccessSignatureTokenProvider("RootManageSharedAccessKey", "Pbhaht1MCX873alTtcJM7GFkt4UrrdSKXgDfJbT9Fdg=") }); using (var ch = cf.CreateChannel()) { var turma = ch.DoWork(); Console.WriteLine($"Turma {turma}"); } }
void RegisterTokenProviderUsingMessagingFactorySettings(EndpointConfiguration endpointConfiguration) { #region asb-register-token-provider-messaging-factory-settings var transport = endpointConfiguration.UseTransport <AzureServiceBusTransport>(); var factories = transport.MessagingFactories(); factories.MessagingFactorySettingsFactory( factory: s => { return(new MessagingFactorySettings { TokenProvider = TokenProvider.CreateSharedAccessSignatureTokenProvider("sas") }); }); #endregion }
/// <summary> /// Create new client for servicebus connection. This method is slow! /// </summary> /// <param name="connectionString">Connection string</param> /// <param name="operationTimeoutForClients">Operation timeout for clients</param> /// <returns>Object that can handle messaging to the service bus</returns> internal static MessagingFactory CreateMessagingFactoryWithTimeout(string connectionString, TimeSpan operationTimeoutForClients) { var connBuilder = new ServiceBusConnectionStringBuilder(connectionString); var factorySettings = new MessagingFactorySettings { OperationTimeout = operationTimeoutForClients }; if (connBuilder.SharedAccessKey != null) { factorySettings.TokenProvider = TokenProvider.CreateSharedAccessSignatureTokenProvider(connBuilder.SharedAccessKeyName, connBuilder.SharedAccessKey); } else if (connBuilder.SharedSecretIssuerName != null) { factorySettings.TokenProvider = TokenProvider.CreateSharedSecretTokenProvider(connBuilder.SharedSecretIssuerName, connBuilder.SharedSecretIssuerSecret); } else if (connBuilder.OAuthUsername != null) { if (!string.IsNullOrEmpty(connBuilder.OAuthDomain)) { TokenProvider.CreateOAuthTokenProvider(connBuilder.StsEndpoints, new NetworkCredential(connBuilder.OAuthUsername, connBuilder.OAuthPassword, connBuilder.OAuthDomain)); } else { TokenProvider.CreateOAuthTokenProvider(connBuilder.StsEndpoints, new NetworkCredential(connBuilder.OAuthUsername, connBuilder.OAuthPassword)); } } else if (connBuilder.StsEndpoints.Count > 0) { factorySettings.TokenProvider = TokenProvider.CreateWindowsTokenProvider(connBuilder.StsEndpoints); } factorySettings.EnableAdditionalClientTimeout = true; MessagingFactory messageFactory = MessagingFactory.Create(connBuilder.GetAbsoluteRuntimeEndpoints(), factorySettings); messageFactory.RetryPolicy = RetryPolicy.Default; return(messageFactory); }
void RegisterTokenProviderUsingNamespaceManagerSettings(EndpointConfiguration endpointConfiguration) { #region asb-register-token-provider-namespace-manager-settings var transport = endpointConfiguration.UseTransport <AzureServiceBusTransport>(); var managers = transport.NamespaceManagers(); managers.NamespaceManagerSettingsFactory( factory: s => { return(new NamespaceManagerSettings { TokenProvider = TokenProvider.CreateSharedAccessSignatureTokenProvider("sas") }); }); #endregion }
protected void Application_Start() { GlobalConfiguration.Configure(WebApiConfig.Register); _bus = MassTransit.Bus.Factory.CreateUsingAzureServiceBus(x => { var serviceUri = ServiceBusEnvironment.CreateServiceUri("sb", ConfigurationManager.AppSettings["AzureSbNamespace"], ""); var host = x.Host(serviceUri, h => { h.TokenProvider = TokenProvider.CreateSharedAccessSignatureTokenProvider(ConfigurationManager.AppSettings["AzureSbKeyName"], ConfigurationManager.AppSettings["AzureSbSharedAccessKey"], TimeSpan.FromDays(1), TokenScope.Namespace); }); }); _busHandle = MassTransit.Util.TaskUtil.Await <BusHandle>(() => _bus.StartAsync()); }
public async Task UseITokenProviderWithSas() { // Generate SAS token provider. await using (var scope = await EventHubScope.CreateAsync(1)) { var connectionString = TestUtility.BuildEventHubsConnectionString(scope.EventHubName); var csb = new EventHubsConnectionStringBuilder(connectionString); var tokenProvider = TokenProvider.CreateSharedAccessSignatureTokenProvider(csb.SasKeyName, csb.SasKey); // Create new client with updated connection string. var ehClient = EventHubClient.CreateWithTokenProvider(csb.Endpoint, csb.EntityPath, tokenProvider); // Send one event TestUtility.Log($"Sending one message."); var ehSender = ehClient.CreatePartitionSender("0"); var eventData = new EventData(Encoding.UTF8.GetBytes("Hello EventHub!")); await ehSender.SendAsync(eventData); // Receive event. PartitionReceiver ehReceiver = null; try { TestUtility.Log($"Receiving one message."); ehReceiver = ehClient.CreateReceiver(PartitionReceiver.DefaultConsumerGroupName, "0", EventPosition.FromStart()); var msg = await ehReceiver.ReceiveAsync(1); Assert.True(msg != null, "Failed to receive message."); } finally { await ehReceiver?.CloseAsync(); } // Get EH runtime information. TestUtility.Log($"Getting Event Hub runtime information."); var ehInfo = await ehClient.GetRuntimeInformationAsync(); Assert.True(ehInfo != null, "Failed to get runtime information."); // Get EH partition runtime information. TestUtility.Log($"Getting Event Hub partition '0' runtime information."); var partitionInfo = await ehClient.GetPartitionRuntimeInformationAsync("0"); Assert.True(ehInfo != null, "Failed to get runtime partition information."); } }
public static async Task <HttpResponseMessage> getToken( [HttpTrigger(AuthorizationLevel.Anonymous, "get", Route = null)] HttpRequestMessage req, ClaimsPrincipal principal, ILogger log ) { if (principal is null) { return(req.CreateResponse(HttpStatusCode.Unauthorized)); } var sasProvider = TokenProvider.CreateSharedAccessSignatureTokenProvider(servicebusKeyName, servicebusKey, ttl); var subscriptionUri = HttpUtility.ParseQueryString(req.RequestUri.Query).Get("subscriptionUri"); var sasToken = await sasProvider.GetTokenAsync(subscriptionUri, new TimeSpan(0, 0, 15)); return(req.CreateResponse(HttpStatusCode.OK, sasToken.TokenValue)); }
static void Main(string[] args) { ChannelFactory <IServiceChannel> channelFactory; channelFactory = new ChannelFactory <IServiceChannel>(new BasicHttpRelayBinding(), "https://azurerelaytest.servicebus.windows.net/azurerelayservice"); channelFactory.Endpoint.Behaviors.Add(new TransportClientEndpointBehavior { TokenProvider = TokenProvider.CreateSharedAccessSignatureTokenProvider("SharedAccessKey", "5YEwr1YFY3V7AThi2k/Mldaezr+m6lg5PP5cumlkYUo=") }); // Create the Communication to the WCF IServiceChannel channel = channelFactory.CreateChannel(); // Call the Service Method using Channel Console.WriteLine("Approval for 50? ->" + channel.GetApproval(50)); Console.WriteLine("Approval for 500? ->" + channel.GetApproval(500)); Console.ReadLine(); }
private static async Task <string> Send(string q) { var tokenProvider = TokenProvider.CreateSharedAccessSignatureTokenProvider( KeyName, Key); var uri = new Uri($"https://{RelayNamespace}/{ConnectionName}"); var token = (await tokenProvider.GetTokenAsync(uri.AbsoluteUri, TimeSpan.FromHours(1))).TokenString; var client = new HttpClient(); client.DefaultRequestHeaders.Add("ServiceBusAuthorization", token); client.DefaultRequestHeaders.Add("X-Query", q); var res = await client.GetAsync(uri); res.EnsureSuccessStatusCode(); var body = await res.Content.ReadAsStringAsync(); return(body); }
internal AmqpClient( ServiceBusConnection servicebusConnection, string entityPath, MessagingEntityType entityType, RetryPolicy retryPolicy, ReceiveMode mode = ReceiveMode.ReceiveAndDelete) { this.ServiceBusConnection = servicebusConnection; this.EntityPath = entityPath; this.MessagingEntityType = entityType; this.ReceiveMode = mode; this.TokenProvider = TokenProvider.CreateSharedAccessSignatureTokenProvider( servicebusConnection.SasKeyName, servicebusConnection.SasKey); this.CbsTokenProvider = new TokenProviderAdapter(this.TokenProvider, servicebusConnection.OperationTimeout); this.RetryPolicy = retryPolicy; }
async Task SendMessagesAsync(string namespaceAddress, string topicName, string sendToken) { var senderFactory = MessagingFactory.Create( namespaceAddress, new MessagingFactorySettings { TransportType = TransportType.Amqp, TokenProvider = TokenProvider.CreateSharedAccessSignatureTokenProvider(sendToken) }); var sender = await senderFactory.CreateMessageSenderAsync(topicName); dynamic data = new[] { new { name = "Einstein", firstName = "Albert" }, new { name = "Heisenberg", firstName = "Werner" }, new { name = "Curie", firstName = "Marie" }, new { name = "Hawking", firstName = "Steven" }, new { name = "Newton", firstName = "Isaac" }, new { name = "Bohr", firstName = "Niels" }, new { name = "Faraday", firstName = "Michael" }, new { name = "Galilei", firstName = "Galileo" }, new { name = "Kepler", firstName = "Johannes" }, new { name = "Kopernikus", firstName = "Nikolaus" } }; for (int i = 0; i < data.Length; i++) { var message = new BrokeredMessage(new MemoryStream(Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(data[i])))) { ContentType = "application/json", Label = "Scientist", MessageId = i.ToString(), TimeToLive = TimeSpan.FromMinutes(2) }; await sender.SendAsync(message); lock (Console.Out) { Console.ForegroundColor = ConsoleColor.Yellow; Console.WriteLine("Message sent: Id = {0}", message.MessageId); Console.ResetColor(); } } }
private static async Task RunAsync() { var cts = new CancellationTokenSource(); var tokenProvider = TokenProvider.CreateSharedAccessSignatureTokenProvider(KeyName, Key); var listener = new HybridConnectionListener(new Uri(string.Format("sb://{0}/{1}", RelayNamespace, ConnectionName)), tokenProvider); // Subscribe to the status events. listener.Connecting += (o, e) => { Console.WriteLine("Connecting"); }; listener.Offline += (o, e) => { Console.WriteLine("Offline"); }; listener.Online += (o, e) => { Console.WriteLine("Online"); }; // Provide an HTTP request handler listener.RequestHandler = (context) => { // Do something with context.Request.Url, HttpMethod, Headers, InputStream... context.Response.StatusCode = HttpStatusCode.OK; context.Response.StatusDescription = "OK, This is pretty neat"; var bytes = new byte[context.Request.InputStream.Length]; var aaa = context.Request.InputStream.Read(bytes, 0, bytes.Length); var str = Encoding.UTF8.GetString(bytes); using (var sw = new StreamWriter(context.Response.OutputStream)) { sw.WriteLine(str); Console.WriteLine(str); } // The context MUST be closed here context.Response.Close(); }; // Opening the listener establishes the control channel to // the Azure Relay service. The control channel is continuously // maintained, and is reestablished when connectivity is disrupted. await listener.OpenAsync(); Console.WriteLine("Server listening"); // Start a new thread that will continuously read the console. await Console.In.ReadLineAsync(); // Close the listener after you exit the processing loop. await listener.CloseAsync(); }
public static IBusControl ConfigureBus(ServiceBusSettings settings, Action <IServiceBusBusFactoryConfigurator, IServiceBusHost> registrationAction = null) { return(Bus.Factory.CreateUsingAzureServiceBus(sbc => { var host = sbc.Host(settings.ServiceBusConnectionString, h => { h.TokenProvider = TokenProvider.CreateSharedAccessSignatureTokenProvider(settings.ServiceBusKeyName, settings.ServiceBusSharedAccessKey, TimeSpan.FromDays(1), TokenScope.Namespace); }); sbc.UseServiceBusMessageScheduler(); registrationAction?.Invoke(sbc, host); })); }
private static async Task RunAsync() { var cts = new CancellationTokenSource(); var tokenProvider = TokenProvider.CreateSharedAccessSignatureTokenProvider(KeyName, Key); var listener = new HybridConnectionListener(new Uri($"sb://{RelayNamespace}/{ConnectionName}"), tokenProvider); // Subscribe to the status events. listener.Connecting += (o, e) => { Console.WriteLine("Connecting"); }; listener.Offline += (o, e) => { Console.WriteLine("Offline"); }; listener.Online += (o, e) => { Console.WriteLine("Online"); }; // Provide an HTTP request handler listener.RequestHandler = (context) => { // Do something with context.Request.Url, HttpMethod, Headers, InputStream... var q = context.Request.Headers["X-Query"].Replace("_", " "); context.Response.StatusCode = HttpStatusCode.OK; context.Response.StatusDescription = "OK, Here's what I could find"; using var sw = new StreamWriter(context.Response.OutputStream); var queryResult = Search(q).GetAwaiter().GetResult(); Console.WriteLine("Source json content length", queryResult.Length); // sw.WriteLine(j); sw.WriteLine("Source json content", queryResult); // The context MUST be closed here context.Response.Close(); }; // Opening the listener establishes the control channel to // the Azure Relay service. The control channel is continuously // maintained, and is reestablished when connectivity is disrupted. await listener.OpenAsync(); Console.WriteLine("Server listening"); // Start a new thread that will continuously read the console. await Console.In.ReadLineAsync(); // Close the listener after you exit the processing loop. await listener.CloseAsync(); }
public IBusControl CreateBus(Action <IBusFactoryConfigurator, IHost> registrationAction = null) { var buz = Bus.Factory.CreateUsingAzureServiceBus(cfg => { var connUri = new Uri(Configuration.ConnectionUri); var host = cfg.Host(connUri, hst => { hst.TokenProvider = TokenProvider.CreateSharedAccessSignatureTokenProvider(Configuration.Login, Configuration.Password); }); cfg.UseJsonSerializer(); registrationAction?.Invoke(cfg, host); }); return(buz); }
internal static TokenProvider CreateTokenProvider() { var connectionString = Environment.GetEnvironmentVariable("RELAY_TEST_CONNECTIONSTRING_NOAUTH"); Assert.NotNull(connectionString); Assert.False(string.IsNullOrEmpty(connectionString)); var cb = new RelayConnectionStringBuilder(connectionString); if (!string.IsNullOrEmpty(cb.SharedAccessSignature)) { return(TokenProvider.CreateSharedAccessSignatureTokenProvider(cb.SharedAccessSignature)); } else { return(TokenProvider.CreateSharedAccessSignatureTokenProvider(cb.SharedAccessKeyName, cb.SharedAccessKey)); } }
private static void Main(string[] args) { var cts = new CancellationTokenSource(); for (var i = 0; i < 1; i++) { Task.Factory.StartNew(async partition => { LogEvent logEvent; var settings = new MessagingFactorySettings { TokenProvider = TokenProvider.CreateSharedAccessSignatureTokenProvider("LogProcessor", "0ihHa1HNpUyhTYELV+FjPbjJhtt0N5PgHoiPaCwuZNs="), TransportType = TransportType.Amqp }; var factory = MessagingFactory.Create(ServiceBusEnvironment.CreateServiceUri("sb", "logs-ns", string.Empty), settings); var client = factory.CreateEventHubClient("logs"); var group = client.GetDefaultConsumerGroup(); var receiver = await group.CreateReceiverAsync(partition.ToString(), DateTime.UtcNow); Console.WriteLine("Worker process started for partition {0} and consumer group {1}", partition, group.GroupName); while (!cts.IsCancellationRequested) { foreach (var eventData in await receiver.ReceiveAsync(10, new TimeSpan(0, 0, 0, 0, 200))) { logEvent = JsonConvert.DeserializeObject <LogEvent>(Encoding.Unicode.GetString(eventData.GetBytes())); Console.WriteLine("{0} [{1},{2}] {3}: {6}", DateTime.Now, eventData.PartitionKey, partition, logEvent.MachineName, logEvent.SiteName, logEvent.InstanceId, logEvent.Value); } } await receiver.CloseAsync(); Console.WriteLine("Worker process finished for partition: {0}", partition); }, i as object, TaskCreationOptions.LongRunning); } Console.ReadKey(); cts.Cancel(); Console.ReadKey(); }
private async Task InitializeInternalAsync(AzureServiceBusConfiguration configuration, CancellationToken cancellationToken) { cancellationToken.ThrowIfCancellationRequested(); _config = configuration; var tokenProvider = TokenProvider.CreateSharedAccessSignatureTokenProvider(_config.KeyName, _config.SharedAccessSignature, TimeSpan.FromDays(1)); _managementClient = new ManagementClient(_config.Endpoint, tokenProvider); if (!await _managementClient.QueueExistsAsync(_config.QueueName, cancellationToken)) { await _managementClient.CreateQueueAsync(_config.QueueName, cancellationToken); } if (!await _managementClient.TopicExistsAsync(_config.TopicName, cancellationToken)) { await _managementClient.CreateTopicAsync(_config.TopicName, cancellationToken); } if (!await _managementClient.SubscriptionExistsAsync(_config.TopicName, _config.TopicName, cancellationToken)) { await _managementClient.CreateSubscriptionAsync(new SubscriptionDescription(_config.TopicName, _config.TopicName) { ForwardTo = _config.QueueName }, cancellationToken); } var queueConnection = new ServiceBusConnection(_config.Endpoint, TransportType.Amqp, RetryPolicy.Default) { TokenProvider = tokenProvider }; _messageReceiver = AzureServiceBusReceiver.Create(_config, ReceiveMessageAsync, HandleErrorAsync); var topicConnection = new ServiceBusConnection(_config.Endpoint, TransportType.Amqp, RetryPolicy.Default) { TokenProvider = tokenProvider }; _messageSender = new TopicClient(topicConnection, _config.TopicName, RetryPolicy.Default); _messageSendTimer = new System.Timers.Timer(_config.PublishInterval); _messageSendTimer.Elapsed += SendMessageAsync; _messageSendTimer.Start(); }
private async Task RunAsync() { _cts = new CancellationTokenSource(); var tokenProvider = TokenProvider.CreateSharedAccessSignatureTokenProvider(_conn.SharedAccessKeyName, _conn.SharedAccessKey); var listener = new HybridConnectionListener(_conn.Endpoint, tokenProvider); // Subscribe to the status events listener.Connecting += Listener_Connecting; listener.Offline += Listener_Offline; listener.Online += Listener_Online; // Opening the listener will establish the control channel to // the Azure Relay service. The control channel will be continuously // maintained and reestablished when connectivity is disrupted. await listener.OpenAsync(_cts.Token); Console.WriteLine("Server listening"); // Providing callback for cancellation token that will close the listener. _cts.Token.Register(() => listener.CloseAsync(CancellationToken.None)); // Start a new thread that will continuously read the console. new Task(() => Console.In.ReadLineAsync().ContinueWith((s) => { _cts.Cancel(); })).Start(); // Accept the next available, pending connection request. // Shutting down the listener will allow a clean exit with // this method returning null while (true) { var relayConnection = await listener.AcceptConnectionAsync(); if (relayConnection == null) { break; } ProcessMessagesOnConnection(relayConnection, _cts); } // Close the listener after we exit the processing loop await listener.CloseAsync(_cts.Token); }
private async Task StartListeningImpl() { //Always use with _semaphoreStartStop if (_subscriptionClient != null) { return; } try { if (string.IsNullOrEmpty(_sasToken)) { var tokenProvider = TokenProvider.CreateSharedAccessSignatureTokenProvider(Config.ServiceBus.KeyName, Config.ServiceBus.SharedAccessKey, TimeSpan.FromMinutes(30)); _sasToken = (await tokenProvider.GetTokenAsync(Config.ServiceBus.Url, TimeSpan.FromMinutes(30))).TokenValue; } //TODO correct endpoints _subscriptionClient = new SubscriptionClient(Config.ServiceBus.Url, TopicPath, SubscriptionName, TokenProvider.CreateSharedAccessSignatureTokenProvider(_sasToken), receiveMode: ReceiveMode.PeekLock, retryPolicy: _retryPolicy); } catch (Exception ex) { Debug.WriteLine(ex); return; } // register the RegisterMessageHandler callback _subscriptionClient.RegisterMessageHandler( async(message, cancellationToken1) => { if (_subscriptionClient != null && !_subscriptionClient.IsClosedOrClosing) { await MessageHandler(message, cancellationToken1, _subscriptionClient); } }, new MessageHandlerOptions(LogMessageHandlerException) { AutoComplete = false, MaxConcurrentCalls = MAX_CONCURRENT_CALLS }); }
public ClientTcpHybridConnectionMultiplexer( string relayNamespace, string connectionName, string keyName, string key, ILogger logger) { _relayNamespace = relayNamespace; _connectionName = connectionName; _keyName = keyName; _key = key; _logger = logger; var tokenProvider = TokenProvider.CreateSharedAccessSignatureTokenProvider(_keyName, _key); _hybridConnectionClient = new HybridConnectionClient( new Uri(String.Format("sb://{0}/{1}", _relayNamespace, _connectionName)), tokenProvider); }
private static IEnumerable <Hotel> GetHotelsFromRelay() { Uri serviceUri = ServiceBusEnvironment.CreateServiceUri("sb", "sb20532[Your Name]", "lodging"); ChannelFactory <ILodgingService> cf = new ChannelFactory <ILodgingService>( new NetTcpRelayBinding(), new EndpointAddress(serviceUri) ); TransportClientEndpointBehavior endpointBehavior = new TransportClientEndpointBehavior(); endpointBehavior.TokenProvider = TokenProvider.CreateSharedAccessSignatureTokenProvider("RootManageSharedAccessKey", "<put your access key here>"); cf.Endpoint.EndpointBehaviors.Add(endpointBehavior); ILodgingService ch = cf.CreateChannel(); return(ch.GetHotels()); }
private IStockServiceChannel CreateChannel() { var serviceNamespace = System.Configuration.ConfigurationManager.AppSettings.Get("sb:namespace"); var servicePath = System.Configuration.ConfigurationManager.AppSettings.Get("sb:servicePath"); var keyName = System.Configuration.ConfigurationManager.AppSettings.Get("sb:keyName"); var sharedAccessKey = System.Configuration.ConfigurationManager.AppSettings.Get("sb:sharedAccessKey"); var cf = new ChannelFactory <IStockServiceChannel>( new NetTcpRelayBinding(), new EndpointAddress(ServiceBusEnvironment.CreateServiceUri("sb", serviceNamespace, servicePath))); cf.Endpoint.Behaviors.Add(new TransportClientEndpointBehavior { TokenProvider = TokenProvider.CreateSharedAccessSignatureTokenProvider(keyName, sharedAccessKey) }); return(cf.CreateChannel()); }
private static async Task RunAsync() { var tokenProvider = TokenProvider.CreateSharedAccessSignatureTokenProvider( KeyName, Key); var uri = new Uri(string.Format("https://{0}/{1}", RelayNamespace, ConnectionName)); var token = (await tokenProvider.GetTokenAsync(uri.AbsoluteUri, TimeSpan.FromHours(1))).TokenString; var client = new HttpClient(); var request = new HttpRequestMessage() { RequestUri = uri, Method = HttpMethod.Get, }; request.Headers.Add("ServiceBusAuthorization", token); var response = await client.SendAsync(request); Console.WriteLine(await response.Content.ReadAsStringAsync()); }
private static async Task RunAsync() { var cts = new CancellationTokenSource(); var tokenProvider = TokenProvider.CreateSharedAccessSignatureTokenProvider(KeyName, Key); var listener = new HybridConnectionListener(new Uri(string.Format("sb://{0}/{1}", RelayNamespace, ConnectionName)), tokenProvider); // Subscribe to the status events. listener.Connecting += (o, e) => { Console.WriteLine("Connecting"); }; listener.Offline += (o, e) => { Console.WriteLine("Offline"); }; listener.Online += (o, e) => { Console.WriteLine("Online"); }; // Opening the listener establishes the control channel to // the Azure Relay service. The control channel is continuously // maintained, and is reestablished when connectivity is disrupted. await listener.OpenAsync(cts.Token); Console.WriteLine("Listener is setup and ready for messages"); // Provide callback for a cancellation token that will close the listener. cts.Token.Register(() => listener.CloseAsync(CancellationToken.None)); // Start a new thread that will continuously read the console. // If anything is entered on console. it will shutdown this application new Task(() => Console.In.ReadLineAsync().ContinueWith((s) => { cts.Cancel(); })).Start(); // Accept the next available, pending connection request. // Shutting down the listener allows a clean exit. // This method returns null. while (true) { var relayConnection = await listener.AcceptConnectionAsync(); if (relayConnection == null) { break; } ProcessMessagesOnConnection(relayConnection, cts); } // Close the listener after you exit the processing loop. await listener.CloseAsync(cts.Token); }
public async Task UseSharedAccessSignatureApi() { await using (var scope = await EventHubScope.CreateAsync(1)) { var connectionString = TestUtility.BuildEventHubsConnectionString(scope.EventHubName); // Generate shared access token. var csb = new EventHubsConnectionStringBuilder(connectionString); var tokenProvider = TokenProvider.CreateSharedAccessSignatureTokenProvider(csb.SasKeyName, csb.SasKey); var token = await tokenProvider.GetTokenAsync(csb.Endpoint.ToString(), TimeSpan.FromSeconds(120)); var sharedAccessSignature = token.TokenValue.ToString(); // Create connection string builder by SharedAccessSignature overload. var csbNew = new EventHubsConnectionStringBuilder(csb.Endpoint, csb.EntityPath, sharedAccessSignature, TimeSpan.FromSeconds(60)); // Create new client with updated connection string. var ehClient = EventHubClient.CreateFromConnectionString(csbNew.ToString()); // Send one event TestUtility.Log("Sending one message."); var ehSender = ehClient.CreatePartitionSender("0"); var eventData = new EventData(Encoding.UTF8.GetBytes("Hello EventHub by partitionKey!")); await ehSender.SendAsync(eventData); // Receive event. TestUtility.Log("Receiving one message."); var ehReceiver = ehClient.CreateReceiver(PartitionReceiver.DefaultConsumerGroupName, "0", EventPosition.FromStart()); var msg = await ehReceiver.ReceiveAsync(1); Assert.True(msg != null, "Failed to receive message."); // Get EH runtime information. TestUtility.Log("Getting Event Hub runtime information."); var ehInfo = await ehClient.GetRuntimeInformationAsync(); Assert.True(ehInfo != null, "Failed to get runtime information."); // Get EH partition runtime information. TestUtility.Log("Getting Event Hub partition '0' runtime information."); var partitionInfo = await ehClient.GetPartitionRuntimeInformationAsync("0"); Assert.True(ehInfo != null, "Failed to get runtime partition information."); } }
AmqpServiceClient managementServiceClient; // serviceClient that handles management calls public AmqpEventHubClient(EventHubsConnectionStringBuilder csb) : base(csb) { this.ContainerId = Guid.NewGuid().ToString("N"); this.AmqpVersion = new Version(1, 0, 0, 0); this.MaxFrameSize = AmqpConstants.DefaultMaxFrameSize; if (!string.IsNullOrWhiteSpace(csb.SharedAccessSignature)) { this.InternalTokenProvider = TokenProvider.CreateSharedAccessSignatureTokenProvider(csb.SharedAccessSignature); } else { this.InternalTokenProvider = TokenProvider.CreateSharedAccessSignatureTokenProvider(csb.SasKeyName, csb.SasKey); } this.CbsTokenProvider = new TokenProviderAdapter(this); this.ConnectionManager = new FaultTolerantAmqpObject <AmqpConnection>(this.CreateConnectionAsync, this.CloseConnection); }