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