async Task NonExistantHCEntityTest() { HybridConnectionListener listener = null; try { TestUtility.Log("Setting ConnectionStringBuilder.EntityPath to a new GUID"); var fakeEndpointConnectionStringBuilder = new RelayConnectionStringBuilder(this.ConnectionString) { EntityPath = Guid.NewGuid().ToString() }; var fakeEndpointConnectionString = fakeEndpointConnectionStringBuilder.ToString(); listener = new HybridConnectionListener(fakeEndpointConnectionString); var client = new HybridConnectionClient(fakeEndpointConnectionString); #if NET451 await Assert.ThrowsAsync <EndpointNotFoundException>(() => listener.OpenAsync()); await Assert.ThrowsAsync <EndpointNotFoundException>(() => client.CreateConnectionAsync()); #else await Assert.ThrowsAsync <RelayException>(() => listener.OpenAsync()); await Assert.ThrowsAsync <RelayException>(() => client.CreateConnectionAsync()); #endif } finally { await this.SafeCloseAsync(listener); } }
private async Task InitializeDataChannel() { var dataChannelFactory = new HybridConnectionClient(_relay, _tokenProvider); var stream = await dataChannelFactory.CreateConnectionAsync(); _log.Information("Relay: {relay}. New data channel is established", _relay); try { await _tunnelPreamble.WriteAsync(stream); EnsureDownlinkPump(stream); _canAcceptUntil = DateTime.UtcNow.Add(_ttl); } catch (AuthorizationFailedException e) { _log.Error(e, "Relay: {relay}. Authorization failed", _relay); CloseDataChannel(); throw; } catch (Exception e) { _log.Error(e, "Relay: {relay}. Unable to establish data channel", _relay); CloseDataChannel(); throw; } }
private static async Task RunAsync() { // Create a new hybrid connection client. var tokenProvider = TokenProvider.CreateSharedAccessSignatureTokenProvider(KeyName, Key); var client = new HybridConnectionClient(new Uri(String.Format("sb://{0}/{1}", RelayNamespace, ConnectionName)), tokenProvider); // Initiate the connection. var relayConnection = await client.CreateConnectionAsync(); Console.WriteLine("Enter lines of text to send to the server with ENTER"); var reader = new StreamReader(relayConnection); var writer = new StreamWriter(relayConnection) { AutoFlush = true }; while (true) { var messageToSend = Console.ReadLine(); if (string.IsNullOrEmpty(messageToSend)) { break; } await writer.WriteLineAsync(messageToSend); var textFromListener = await reader.ReadLineAsync(); Console.WriteLine(textFromListener); } await relayConnection.CloseAsync(CancellationToken.None); }
static async Task TestStreaming(HybridConnectionListener listener, RelayConnectionStringBuilder connectionString, TraceSource traceSource) { traceSource.TraceInformation("Testing Streaming (WebSocket) mode"); RunAcceptPump(listener); var client = new HybridConnectionClient(connectionString.ToString()); var requestBytes = Encoding.UTF8.GetBytes("<data>Request payload from sender</data>"); HybridConnectionStream stream = await client.CreateConnectionAsync(); string connectionName = $"S:HybridConnectionStream({stream.TrackingContext.TrackingId})"; RelayTraceSource.TraceInfo($"{connectionName} initiated"); RunConnectionPump(stream, connectionName); for (int i = 0; i < 2; i++) { await stream.WriteAsync(requestBytes, 0, requestBytes.Length); RelayTraceSource.TraceVerbose($"{connectionName} wrote {requestBytes.Length} bytes"); } using (var closeCts = new CancellationTokenSource(TimeSpan.FromSeconds(5))) { RelayTraceSource.TraceVerbose($"{connectionName} closing"); await stream.CloseAsync(closeCts.Token); RelayTraceSource.TraceInfo($"{connectionName} closed"); } await Task.Delay(TimeSpan.FromMilliseconds(100)); }
async Task NonExistantNamespaceTest(EndpointTestType endpointTestType) { HybridConnectionListener listener = null; try { TestUtility.Log("Setting ConnectionStringBuilder.Endpoint to 'sb://fakeendpoint.com'"); var fakeEndpointConnectionStringBuilder = new RelayConnectionStringBuilder(this.ConnectionString) { Endpoint = new Uri("sb://fakeendpoint.com") }; if (endpointTestType == EndpointTestType.Authenticated) { fakeEndpointConnectionStringBuilder.EntityPath = Constants.AuthenticatedEntityPath; } else { fakeEndpointConnectionStringBuilder.EntityPath = Constants.UnauthenticatedEntityPath; } var fakeEndpointConnectionString = fakeEndpointConnectionStringBuilder.ToString(); listener = new HybridConnectionListener(fakeEndpointConnectionString); var client = new HybridConnectionClient(fakeEndpointConnectionString); // TODO: Remove this once .NET Core supports inspecting the StatusCode/Description. https://github.com/dotnet/corefx/issues/13773 #if NET451 await Assert.ThrowsAsync <EndpointNotFoundException>(() => listener.OpenAsync()); await Assert.ThrowsAsync <EndpointNotFoundException>(() => client.CreateConnectionAsync()); #else await Assert.ThrowsAsync <RelayException>(() => listener.OpenAsync()); await Assert.ThrowsAsync <RelayException>(() => client.CreateConnectionAsync()); #endif } finally { await this.SafeCloseAsync(listener); } }
public RecieveResponseFromRequest(string relayConnectionString, string relayName) { //https://docs.microsoft.com/en-us/azure/service-bus-relay/relay-hybrid-connections-dotnet-api-overview connectionStringBuilder = new RelayConnectionStringBuilder(relayConnectionString) { EntityPath = relayName }; client = new HybridConnectionClient(connectionStringBuilder.ToString()); connectionTask = client.CreateConnectionAsync(); this.relayName = relayName; }
/// <summary> /// We run two concurrent loops on the connection. One reads input from the console and writes it to the connection /// with a stream writer. The other reads lines of input from the connection with a stream reader and writes them to the console. /// Entering a blank line will shut down the write task after sending it to the server. The server will then cleanly shut down /// the connection which will terminate the read task. /// </summary> /// <returns></returns> protected async Task RunAsync() { // Initiate the connection _relayConnection = await _client.CreateConnectionAsync(); var reads = GetReads(_relayConnection); // Wait for both tasks to complete await Task.WhenAll(reads); await _relayConnection.CloseAsync(CancellationToken.None); }
private static async Task RunAsync() { Console.WriteLine("Enter lines of text to send to the server with ENTER"); // Create a new hybrid connection client var tokenProvider = TokenProvider.CreateSharedAccessSignatureTokenProvider(KeyName, Key); var client = new HybridConnectionClient(new Uri(String.Format("sb://{0}/{1}", RelayNamespace, ConnectionName)), tokenProvider); // Initiate the connection var relayConnection = await client.CreateConnectionAsync(); var reads = Task.Run(async() => { var reader = new StreamReader(relayConnection); var writer = Console.Out; do { // Read a full line of UTF-8 text up to newline string line = await reader.ReadLineAsync(); // if the string is empty or null, we are done. if (String.IsNullOrEmpty(line)) { break; } // Write to the console await writer.WriteLineAsync(line); } while (true); }); // Read from the console and write to the hybrid connection var writes = Task.Run(async() => { var reader = Console.In; var writer = new StreamWriter(relayConnection) { AutoFlush = true }; do { // Read a line form the console string line = await reader.ReadLineAsync(); await writer.WriteLineAsync(line); if (String.IsNullOrEmpty(line)) { break; } } while (true); }); await Task.WhenAll(reads, writes); await relayConnection.CloseAsync(CancellationToken.None); }
public async Task OpenAsync(CancellationToken token) { if (_connection != null) { throw new InvalidOperationException("Connection already open"); } _connection = await _client.CreateConnectionAsync(); token.ThrowIfCancellationRequested(); IsOpen = true; }
void EnsureConnection() { lock (connectLock) { if (dataChannel == null) { multiplexedOutputStream = new ThrottledQueueBufferedStream(10); QueueBufferedStream multiplexedInputStream = new QueueBufferedStream(); dataChannelFactory = new HybridConnectionClient(endpointVia, tokenProvider); dataChannel = dataChannelFactory.CreateConnectionAsync().GetAwaiter().GetResult(); try { var preambleWriter = new BinaryWriter(dataChannel); preambleWriter.Write("np:" + toPipe); rawInputPump = new StreamBufferWritePump(dataChannel, multiplexedInputStream.Write); rawInputPump.BeginRunPump(RawInputPumpCompleted, false); inputPump = new MultiplexConnectionInputPump(multiplexedInputStream.Read, CorrelateConnection, null); inputPump.Run(false); outputPump = new StreamBufferWritePump(multiplexedOutputStream, WriteToDataChannel); outputPump.BeginRunPump(MultiplexPumpCompleted, null); } catch (AuthorizationFailedException af) { Trace.TraceError("Authorization failed: {0}", af.Message); if (dataChannel != null) { DataChannelClose(); dataChannel = null; } throw; } catch (Exception ex) { Trace.TraceError("Unable to establish data channel: {0}", ex.Message); if (dataChannel != null) { DataChannelClose(); dataChannel = null; } throw; } } } }
private static async Task RunAsync() { Console.WriteLine("Enter lines of text to send to the server with ENTER"); var tokenProvider = TokenProvider.CreateSharedAccessSignatureTokenProvider(KeyName, Key); var client = new HybridConnectionClient(new Uri(String.Format("sb://{0}/{1}", RelayNamespace, ConnectionName)), tokenProvider); var relayConnection = await client.CreateConnectionAsync(); var reads = Task.Run(async() => { var reader = new StreamReader(relayConnection); var writer = Console.Out; do { string line = await reader.ReadLineAsync(); if (String.IsNullOrEmpty(line)) { break; } await writer.WriteLineAsync(line); }while (true); }); var writes = Task.Run(async() => { var reader = Console.In; var writer = new StreamWriter(relayConnection) { AutoFlush = true }; do { string line = await reader.ReadLineAsync(); await writer.WriteLineAsync(line); if (String.IsNullOrEmpty(line)) { break; } }while (true); }); await Task.WhenAll(reads, writes); await relayConnection.CloseAsync(CancellationToken.None); }
async Task NonExistantNamespaceTest(EndpointTestType endpointTestType) { string badAddress = $"sb://fakeendpoint.{Guid.NewGuid()}.com"; HybridConnectionListener listener = null; try { TestUtility.Log($"Setting ConnectionStringBuilder.Endpoint to '{badAddress}'"); var fakeEndpointConnectionStringBuilder = new RelayConnectionStringBuilder(this.ConnectionString) { Endpoint = new Uri(badAddress) }; if (endpointTestType == EndpointTestType.Authenticated) { fakeEndpointConnectionStringBuilder.EntityPath = Constants.AuthenticatedEntityPath; } else { fakeEndpointConnectionStringBuilder.EntityPath = Constants.UnauthenticatedEntityPath; } var fakeEndpointConnectionString = fakeEndpointConnectionStringBuilder.ToString(); listener = new HybridConnectionListener(fakeEndpointConnectionString); var client = new HybridConnectionClient(fakeEndpointConnectionString); TestUtility.Log($"Opening Listener"); var relayException = await Assert.ThrowsAsync <RelayException>(() => listener.OpenAsync()); TestUtility.Log($"Received Exception {relayException.ToStringWithoutCallstack()}"); Assert.True(relayException.IsTransient, "Listener.Open() should return a transient Exception"); TestUtility.Log($"Opening Client"); relayException = await Assert.ThrowsAsync <RelayException>(() => client.CreateConnectionAsync()); TestUtility.Log($"Received Exception {relayException.ToStringWithoutCallstack()}"); Assert.True(relayException.IsTransient, "Client.Open() should return a transient Exception"); } finally { await this.SafeCloseAsync(listener); } }
public async Task ExecuteAsync(IServiceProvider serviceProvider) { IPluginExecutionContext context = (IPluginExecutionContext)serviceProvider.GetService(typeof(IPluginExecutionContext)); IOrganizationServiceFactory factory = (IOrganizationServiceFactory)serviceProvider.GetService(typeof(IOrganizationServiceFactory)); IOrganizationService service = factory.CreateOrganizationService(context.UserId); Entity entity = (Entity)context.InputParameters["Target"]; GisObject gisObject = new GisObject { Latitude = (double)entity["Latitude"], Longitude = (double)entity["Longitude"] }; // Create a new hybrid connection client var tokenProvider = TokenProvider.CreateSharedAccessSignatureTokenProvider(keyName, key); var client = new HybridConnectionClient(new Uri($"sb://{relayNamespace}/{connectionName}"), tokenProvider); // Initiate the connection var relayConnection = await client.CreateConnectionAsync(); // Bi-directional sync of GIS data: // 1. Send a GIS object to the relay // 2. Receive a GIS object with the resolved address and update the entity // 3. Close the relay connection await new Task( () => SendToRelay(relayConnection, gisObject) .ContinueWith(async(t) => { GisObject resolved = await ReadFromRelay(relayConnection); ShowAddress(resolved); }) .ContinueWith(async(t) => await relayConnection.CloseAsync(CancellationToken.None)) .Start()); void ShowAddress(GisObject resolved) { var addr = resolved.Address; entity["Address"] = $"{addr.Line}, {addr.ZipCode} {addr.City}, {addr.Country}"; service.Update(entity); } }
static void Main(string[] args) { HybridConnectionClient client = new HybridConnectionClient("Endpoint=sb://relayzs.servicebus.windows.net/;SharedAccessKeyName=sas;SharedAccessKey=WBhKG1Fb51sYz4I1Nsv/mZsLhnru+O08YQxeq+SyRfo=;EntityPath=hybirdconn1"); Task <HybridConnectionStream> task = client.CreateConnectionAsync(); while (!task.IsCompleted) { } HybridConnectionStream stream = task.Result; StreamWriter writer = new StreamWriter(stream); StreamReader reader = new StreamReader(stream); writer.WriteLine("Hello Server!"); writer.Flush(); String line = reader.ReadLine(); Console.WriteLine(line); reader.Close(); writer.Close(); }
private HybridConnectionStream CreateConnection() { if (null == _hybridConnectionStream) { lock (_syncRoot) { if (null == _hybridConnectionStream) { try { _hybridConnectionStream = _hybridConnectionClient.CreateConnectionAsync().Result; } catch (Exception e) { _logger.LogError(e, $"Unable to create hybrid connection for {_relayNamespace}/{_connectionName}"); } } } } return(_hybridConnectionStream); }
public async Task ExecuteAsync(ParcelTrackingEntity parcel) { GisObject gisObject = new GisObject { Latitude = parcel.Latitude, Longitude = parcel.Longitude }; // Create a new hybrid connection client var tokenProvider = TokenProvider.CreateSharedAccessSignatureTokenProvider(keyName, key); var client = new HybridConnectionClient(new Uri($"sb://{relayNamespace}/{connectionName}"), tokenProvider); // Initiate the connection var relayConnection = await client.CreateConnectionAsync(); // Bi-directional sync of GIS data: // 1. Send a GIS object to the relay // 2. Receive a GIS object with the resolved address and update the entity // 3. Close the relay connection await new Task( () => SendToRelay(relayConnection, gisObject) .ContinueWith(async(t) => { GisObject resolved = await ReadFromRelay(relayConnection); ShowAddress(resolved); }) .ContinueWith(async(t) => await relayConnection.CloseAsync(CancellationToken.None)) .Start()); void ShowAddress(GisObject resolved) { var addr = resolved.Address; parcel.Address = $"{addr.Line}, {addr.ZipCode} {addr.City}, {addr.Country}"; Update(parcel); // Update the tracking information in the system } }
async Task NonExistantNamespaceTest(EndpointTestType endpointTestType) { HybridConnectionListener listener = null; try { TestUtility.Log("Setting ConnectionStringBuilder.Endpoint to 'sb://fakeendpoint.com'"); var fakeEndpointConnectionStringBuilder = new RelayConnectionStringBuilder(this.ConnectionString) { Endpoint = new Uri("sb://fakeendpoint.com") }; if (endpointTestType == EndpointTestType.Authenticated) { fakeEndpointConnectionStringBuilder.EntityPath = Constants.AuthenticatedEntityPath; } else { fakeEndpointConnectionStringBuilder.EntityPath = Constants.UnauthenticatedEntityPath; } var fakeEndpointConnectionString = fakeEndpointConnectionStringBuilder.ToString(); listener = new HybridConnectionListener(fakeEndpointConnectionString); var client = new HybridConnectionClient(fakeEndpointConnectionString); await Assert.ThrowsAsync <EndpointNotFoundException>(() => listener.OpenAsync()); await Assert.ThrowsAsync <EndpointNotFoundException>(() => client.CreateConnectionAsync()); } finally { await this.SafeCloseAsync(listener); } }
private static async Task RunAsync() { Console.BackgroundColor = ConsoleColor.Yellow; Console.ForegroundColor = ConsoleColor.Black; Console.WriteLine("Client ready"); Console.BackgroundColor = ConsoleColor.Black; Console.ForegroundColor = ConsoleColor.White; Console.WriteLine("Enter lines of text to send to the server with ENTER"); // Create a new hybrid connection client var tokenProvider = TokenProvider.CreateSharedAccessSignatureTokenProvider(KeyName, myKey); var client = new HybridConnectionClient(new Uri(String.Format("sb://{0}/{1}", RelayNamespace, ConnectionName)), tokenProvider); // Initiate the connection var relayConnection = await client.CreateConnectionAsync(); try { // We run two conucrrent loops on the connection. One // reads input from the console and writes it to the connection // with a stream writer. The other reads lines of input from the // connection with a stream reader and writes them to the console. // Entering a blank line will shut down the write task after // sending it to the server. The server will then cleanly shut down // the connection which will terminate the read task. var reads = Task.Run(async() => { // Initialize the stream reader over the connection var reader = new StreamReader(relayConnection); var writer = Console.Out; do { // Read a full line of UTF-8 text up to newline string line = await reader.ReadLineAsync(); // if the string is empty or null, we are done. if (String.IsNullOrEmpty(line)) { break; } // Write to the console Console.ForegroundColor = ConsoleColor.Yellow; await writer.WriteLineAsync(line); Console.ForegroundColor = ConsoleColor.White; }while (true); }); // Read from the console and write to the hybrid connection var writes = Task.Run(async() => { var reader = Console.In; var writer = new StreamWriter(relayConnection) { AutoFlush = true }; do { // Read a line form the console string line = await reader.ReadLineAsync(); // Write the line out, also when it's empty await writer.WriteLineAsync(line); // Quit when the line was empty if (String.IsNullOrEmpty(line)) { break; } }while (true); }); // Wait for both tasks to complete await Task.WhenAll(reads, writes); await relayConnection.CloseAsync(CancellationToken.None); } catch (Exception ex) { Console.WriteLine("\n\nAn error occurred trying to reach the server:\n" + ex.InnerException); Console.WriteLine("Hit ENTER to exit"); Console.ReadLine(); } }
static async Task RunAsync(string[] args) { if (args.Length < 4) { Console.WriteLine("client [ns] [hc] [keyname] [key]"); return; } Console.WriteLine("Enter lines of text to send to the server with ENTER"); var ns = args[0]; var hc = args[1]; var keyname = args[2]; var key = args[3]; // Create a new hybrid connection client var tokenProvider = TokenProvider.CreateSharedAccessSignatureTokenProvider(keyname, key); var client = new HybridConnectionClient(new Uri(String.Format("sb://{0}/{1}", ns, hc)), tokenProvider); // Initiate the connection var relayConnection = await client.CreateConnectionAsync(); // We run two conucrrent loops on the connection. One // reads input from the console and writes it to the connection // with a stream writer. The other reads lines of input from the // connection with a stream reader and writes them to the console. // Entering a blank line will shut down the write task after // sending it to the server. The server will then cleanly shut down // the connection will will terminate the read task. var reads = Task.Run(async() => { // initialize the stream reader over the connection var reader = new StreamReader(relayConnection); var writer = Console.Out; do { // read a full line of UTF-8 text up to newline string line = await reader.ReadLineAsync(); // if the string is empty or null, we are done. if (String.IsNullOrEmpty(line)) { break; } // write to the console await writer.WriteLineAsync(line); }while (true); }); // read from the console and write to the hybrid connection var writes = Task.Run(async() => { var reader = Console.In; var writer = new StreamWriter(relayConnection) { AutoFlush = true }; do { // read a line form the console string line = await reader.ReadLineAsync(); // write the line out, also when it's empty await writer.WriteLineAsync(line); // quit when the line was empty if (String.IsNullOrEmpty(line)) { break; } }while (true); }); // wait for both tasks to complete await Task.WhenAll(reads, writes); await relayConnection.CloseAsync(CancellationToken.None); }
async Task ClientNonExistantHybridConnectionTest() { TestUtility.Log("Setting ConnectionStringBuilder.EntityPath to a new GUID"); var fakeEndpointConnectionStringBuilder = new RelayConnectionStringBuilder(this.ConnectionString) { EntityPath = Guid.NewGuid().ToString() }; var client = new HybridConnectionClient(fakeEndpointConnectionStringBuilder.ToString()); // Endpoint does not exist. TrackingId:GUID_G52, SystemTracker:sb://contoso.servicebus.windows.net/GUID, Timestamp:5/7/2018 5:51:25 PM var exception = await Assert.ThrowsAsync <EndpointNotFoundException>(() => client.CreateConnectionAsync()); Assert.Contains("Endpoint does not exist", exception.Message); Assert.Contains(fakeEndpointConnectionStringBuilder.EntityPath, exception.Message); }
async Task ClientAuthenticationFailureTest() { var badAuthConnectionString = new RelayConnectionStringBuilder(this.ConnectionString) { EntityPath = Constants.AuthenticatedEntityPath }; if (!string.IsNullOrEmpty(badAuthConnectionString.SharedAccessKeyName)) { badAuthConnectionString.SharedAccessKey += "BAD"; } else if (!string.IsNullOrEmpty(badAuthConnectionString.SharedAccessSignature)) { badAuthConnectionString.SharedAccessSignature += "BAD"; } var client = new HybridConnectionClient(badAuthConnectionString.ToString()); // The token has an invalid signature. TrackingId:[Guid]_G63, SystemTracker:sb://contoso.servicebus.windows.net/authenticated, Timestamp:5/7/2018 5:20:05 PM var exception = await Assert.ThrowsAsync <AuthorizationFailedException>(() => client.CreateConnectionAsync()); Assert.Contains("token", exception.Message); Assert.Contains(badAuthConnectionString.EntityPath, exception.Message, StringComparison.OrdinalIgnoreCase); }
RelayClintObservableInitializeAsync( string relayNamespace, string connectionName, string keyName, string key) { if (_isInitialized) { throw new RelayClientException("Relay client can only be initialized once. Create a new instance, if multiple clients are needed."); } _isInitialized = true; var tokenProvider = TokenProvider.CreateSharedAccessSignatureTokenProvider(keyName, key); var client = new HybridConnectionClient(new Uri($"sb://{relayNamespace}/{connectionName}"), tokenProvider); // Initiate the connection. _relayConnection = await client.CreateConnectionAsync(); _writer = new StreamWriter(_relayConnection) { AutoFlush = true }; var reader = new StreamReader(_relayConnection); var readerObservable = Observable.FromAsync(reader.ReadLineAsync); var observableMessages = Observable.Create <string>(obs => { var disposableReader = Observable.While( () => true, readerObservable) .Subscribe(stringLine => { Debug.WriteLine(stringLine); // If there's no input data, signal that // you will no longer send data on this connection. // Then, break out of the processing loop. if (string.IsNullOrEmpty(stringLine)) { obs.OnCompleted(); } obs.OnNext(stringLine); }, ex => { Debug.WriteLine(ex.ToString()); if (ex is IOException) { // Catch an I/O exception. This likely occurred when // the client disconnected. } else { obs.OnError(ex); } }, obs.OnCompleted); return(new CompositeDisposable( disposableReader, Disposable.Create(() => { reader?.Dispose(); _writer?.Dispose(); _relayConnection?.Dispose(); }))); }).Publish().RefCount(); return(observableMessages); }
static async Task RunAsync(string[] args) { Console.WriteLine("Enter lines of text to send to the server with ENTER"); // Create a new hybrid connection client var client = new HybridConnectionClient("Endpoint=sb://vcrelay.servicebus.windows.net/;SharedAccessKeyName=RootManageSharedAccessKey;SharedAccessKey=lCl9YQGV+c/1SikptN9UaeGS8WoHBY5WlgxvhdS+83s=" , "demohc"); // Initiate the connection var relayConnection = await client.CreateConnectionAsync(); // We run two conucrrent loops on the connection. One // reads input from the console and writes it to the connection // with a stream writer. The other reads lines of input from the // connection with a stream reader and writes them to the console. // Entering a blank line will shut down the write task after // sending it to the server. The server will then cleanly shut down // the connection will will terminate the read task. var reads = Task.Run(async() => { // initialize the stream reader over the connection var reader = new StreamReader(relayConnection); var writer = Console.Out; do { // read a full line of UTF-8 text up to newline string line = await reader.ReadLineAsync(); // if the string is empty or null, we are done. if (String.IsNullOrEmpty(line)) { break; } // write to the console await writer.WriteLineAsync(line); }while (true); }); // read from the console and write to the hybrid connection var writes = Task.Run(async() => { var reader = Console.In; var writer = new StreamWriter(relayConnection) { AutoFlush = true }; do { // read a line form the console string line = await reader.ReadLineAsync(); // write the line out, also when it's empty await writer.WriteLineAsync(line); // quit when the line was empty if (String.IsNullOrEmpty(line)) { break; } }while (true); }); // wait for both tasks to complete await Task.WhenAll(reads, writes); await relayConnection.CloseAsync(CancellationToken.None); }
internal static async Task VerifySendAsync(RelayConnectionStringBuilder connectionString, int number, string httpMethod, string requestData, TraceSource traceSource) { Uri hybridHttpUri = new Uri($"https://{connectionString.Endpoint.GetComponents(UriComponents.HostAndPort, UriFormat.SafeUnescaped)}/{connectionString.EntityPath}"); var tokenProvider = GetTokenProvider(connectionString); if (string.Equals("WS", httpMethod, StringComparison.OrdinalIgnoreCase) || string.Equals("WEBSOCKET", httpMethod, StringComparison.OrdinalIgnoreCase)) { var client = new HybridConnectionClient(connectionString.ToString()); var requestBytes = Encoding.UTF8.GetBytes(requestData ?? string.Empty); HybridConnectionStream stream = await client.CreateConnectionAsync(); string connectionName = $"S:HybridConnectionStream({stream.TrackingContext.TrackingId})"; RelayTraceSource.TraceInfo($"{connectionName} initiated"); RunConnectionPump(stream, connectionName); for (int i = 0; i < number; i++) { await stream.WriteAsync(requestBytes, 0, requestBytes.Length); RelayTraceSource.TraceVerbose($"{connectionName} wrote {requestBytes.Length} bytes"); } await Task.Delay(TimeSpan.FromSeconds(1)); using (var cts = new CancellationTokenSource(TimeSpan.FromSeconds(5))) { RelayTraceSource.TraceVerbose($"{connectionName} closing"); await stream.CloseAsync(cts.Token); RelayTraceSource.TraceInfo($"{connectionName} closed"); } return; } string token = null; if (tokenProvider != null) { token = (await tokenProvider.GetTokenAsync(hybridHttpUri.AbsoluteUri, TimeSpan.FromDays(2))).TokenString; } var stopwatch = new Stopwatch(); using (var client = new HttpClient { BaseAddress = hybridHttpUri }) { client.DefaultRequestHeaders.ExpectContinue = false; for (int i = 0; i < number; i++) { stopwatch.Restart(); var httpRequest = new HttpRequestMessage(); if (token != null) { httpRequest.Headers.Add("ServiceBusAuthorization", token); } httpRequest.Method = new HttpMethod(httpMethod); if (requestData != null) { httpRequest.Content = new StringContent(requestData); } LogHttpRequest(httpRequest, client, traceSource); using (HttpResponseMessage response = await client.SendAsync(httpRequest)) { LogHttpResponse(response, traceSource); } traceSource.TraceInformation($"Elapsed: {stopwatch.ElapsedMilliseconds} ms"); } } }
private static async Task RunAsync() { Console.WriteLine("Enter lines of text to send to the server with ENTER"); // Create a new hybrid connection client var client = new HybridConnectionClient(ConnectionString); // Initiate the connection var relayConnection = await client.CreateConnectionAsync(); // We run two conucrrent loops on the connection. One // reads input from the console and writes it to the connection // with a stream writer. The other reads lines of input from the // connection with a stream reader and writes them to the console. // Entering a blank line will shut down the write task after // sending it to the server. The server will then cleanly shut down // the connection which will terminate the read task. var reads = Task.Run(async() => { // Initialize the stream reader over the connection var reader = new StreamReader(relayConnection); var writer = Console.Out; do { // Read a full line of UTF-8 text up to newline string line = await reader.ReadLineAsync(); // If the string is empty or null, we are done. if (String.IsNullOrEmpty(line)) { break; } // Write to the console await writer.WriteLineAsync(line); }while (true); }); // Read from the console and write to the hybrid connection var writes = Task.Run(async() => { var reader = Console.In; var writer = new StreamWriter(relayConnection) { AutoFlush = true }; do { // Read a line form the console string line = await reader.ReadLineAsync(); // Write the line out, also when it's empty await writer.WriteLineAsync(line); // Quit when the line was empty if (String.IsNullOrEmpty(line)) { break; } }while (true); }); // Wait for both tasks to complete await Task.WhenAll(reads, writes); await relayConnection.CloseAsync(CancellationToken.None); }
static void Main(string[] args) { if (args.Length < 4) { Console.WriteLine("server [ns] [hc] [keyname] [key]"); return; } var ns = args[0]; var hc = args[1]; var keyname = args[2]; var key = args[3]; var tokenProvider = TokenProvider.CreateSharedAccessSignatureTokenProvider(keyname, key); var sendAddress = new Uri($"sb://{ns}/{hc}"); var relayClient = new HybridConnectionClient(sendAddress, tokenProvider); try { var relayConnection = relayClient.CreateConnectionAsync().GetAwaiter().GetResult(); TTransport transport = new TStreamTransport(relayConnection, relayConnection); TProtocol protocol = new TBinaryProtocol(transport); Calculator.Client client = new Calculator.Client(protocol); transport.Open(); try { client.ping(); Console.WriteLine("ping()"); int sum = client.add(1, 1); Console.WriteLine("1+1={0}", sum); Work work = new Work(); work.Op = Operation.DIVIDE; work.Num1 = 1; work.Num2 = 0; try { int quotient = client.calculate(1, work); Console.WriteLine("Whoa we can divide by 0"); } catch (InvalidOperation io) { Console.WriteLine("Invalid operation: " + io.Why); } work.Op = Operation.SUBTRACT; work.Num1 = 15; work.Num2 = 10; try { int diff = client.calculate(1, work); Console.WriteLine("15-10={0}", diff); } catch (InvalidOperation io) { Console.WriteLine("Invalid operation: " + io.Why); } SharedStruct log = client.getStruct(1); Console.WriteLine("Check log: {0}", log.Value); } finally { transport.Close(); } } catch (TApplicationException x) { Console.WriteLine(x.StackTrace); } }
private static async Task RunAsync() { Console.WriteLine("Enter lines of text to send to the server with ENTER"); // Create a new hybrid connection client. var tokenProvider = TokenProvider.CreateSharedAccessSignatureTokenProvider(KeyName, Key); var client = new HybridConnectionClient(new Uri(String.Format("sb://{0}/{1}", RelayNamespace, ConnectionName)), tokenProvider); // Initiate the connection. var relayConnection = await client.CreateConnectionAsync(); // Run two concurrent loops on the connection. One // reads input from the console and then writes it to the connection // with a stream writer. The other reads lines of input from the // connection with a stream reader and then writes them to the console. // Entering a blank line shuts down the write task after // sending it to the server. The server then cleanly shuts down // the connection, which terminates the read task. var reads = Task.Run(async() => { // Initialize the stream reader over the connection. var reader = new StreamReader(relayConnection); var writer = Console.Out; do { // Read a full line of UTF-8 text up to newline. string line = await reader.ReadLineAsync(); // If the string is empty or null, you are done. if (String.IsNullOrEmpty(line)) { break; } // Write to the console. await writer.WriteLineAsync(line); }while (true); }); // Read from the console and write to the hybrid connection. var writes = Task.Run(async() => { var reader = Console.In; var writer = new StreamWriter(relayConnection) { AutoFlush = true }; do { // Read a line from the console. string line = await reader.ReadLineAsync(); // Write the line out, also when it's empty. await writer.WriteLineAsync(line); // Quit when the line is empty. if (String.IsNullOrEmpty(line)) { break; } }while (true); }); // Wait for both tasks to finish. await Task.WhenAll(reads, writes); await relayConnection.CloseAsync(CancellationToken.None); }
Task <HybridConnectionStream> ConnectClientSocketAsync(Uri address) { var client = new HybridConnectionClient(address, tokenProvider); return(client.CreateConnectionAsync()); }
static async Task Main(string[] args) { string hostAddress; string hybridConnectionName; string clientId = null; string tenantId = null; string clientSecret = null; RbacAuthenticationOption option; if (args.Length == 2) { option = RbacAuthenticationOption.ManagedIdentity; hostAddress = args[0]; hybridConnectionName = args[1]; } else if (args.Length == 3) { option = RbacAuthenticationOption.UserAssignedIdentity; hostAddress = args[0]; hybridConnectionName = args[1]; clientId = args[2]; } else if (args.Length == 5) { option = RbacAuthenticationOption.AAD; hostAddress = args[0]; hybridConnectionName = args[1]; clientId = args[2]; tenantId = args[3]; clientSecret = args[4]; } else { Console.WriteLine("Please run with parameters of the following format for the corresponding RBAC authentication method:"); Console.WriteLine("System Managed Identity: [HostAddress] [HybridConnectionName]"); Console.WriteLine("User Assigned Identity: [HostAddress] [HybridConnectionName] [ClientId]"); Console.WriteLine("Azure Active Directory: [HostAddress] [HybridConnectionName] [ClientId] [TenantId] [ClientSecret]"); Console.WriteLine("Press <Enter> to exit..."); Console.ReadLine(); return; } TokenProvider tokenProvider = null; switch (option) { case RbacAuthenticationOption.ManagedIdentity: tokenProvider = TokenProvider.CreateManagedIdentityTokenProvider(); break; case RbacAuthenticationOption.UserAssignedIdentity: var managedCredential = new ManagedIdentityCredential(clientId); tokenProvider = TokenProvider.CreateManagedIdentityTokenProvider(managedCredential); break; case RbacAuthenticationOption.AAD: tokenProvider = GetAadTokenProvider(clientId, tenantId, clientSecret); break; } var hybridConnectionUri = new Uri($"{hostAddress}/{hybridConnectionName}"); HybridConnectionListener listener = null; try { // The HybridConnection should be already created through Azure Portal or other means Console.WriteLine($"Creating the Relay listener instance with RBAC option: {option}"); listener = new HybridConnectionListener(hybridConnectionUri, tokenProvider); await listener.OpenAsync(TimeSpan.FromSeconds(10)); Console.WriteLine("Created and connected the Relay listener instance."); Console.WriteLine($"Creating the Relay sender instance with RBAC option: {option}"); var sender = new HybridConnectionClient(hybridConnectionUri, tokenProvider); var createSenderTask = sender.CreateConnectionAsync(); var listenerAcceptTask = listener.AcceptConnectionAsync(); using (HybridConnectionStream senderStream = await createSenderTask) using (HybridConnectionStream listenerStream = await listenerAcceptTask) { Console.WriteLine("Created and connected the Relay sender instance."); var senderCloseTask = senderStream.CloseAsync(CancellationToken.None); await listenerStream.CloseAsync(CancellationToken.None); await senderCloseTask; } // Configure a RequestHandler for HTTP request/response mode listener.RequestHandler = (context) => { context.Response.StatusCode = HttpStatusCode.OK; using (var sw = new StreamWriter(context.Response.OutputStream)) { sw.WriteLine("hello!"); } // The context must be closed to complete sending the response context.Response.Close(); }; Console.WriteLine($"Sending a HTTP request by setting the token in request header with RBAC option: {option}"); SecurityToken token = await tokenProvider.GetTokenAsync(hybridConnectionUri.AbsoluteUri, TimeSpan.FromMinutes(30)); var request = new HttpRequestMessage(); request.Headers.Add(HttpRequestHeader.Authorization.ToString(), token.TokenString); var requestUri = new UriBuilder(hybridConnectionUri) { Scheme = "https" }.Uri; using (HttpClient client = new HttpClient { BaseAddress = requestUri }) { using (var response = await client.SendAsync(request)) { Console.WriteLine($"Response status code: {response.StatusCode}. Response reason phrase: {response.ReasonPhrase}"); } } Console.WriteLine($"Sending a HTTP request by setting the token in query string with RBAC option: {option}"); token = await tokenProvider.GetTokenAsync(hybridConnectionUri.AbsoluteUri, TimeSpan.FromMinutes(30)); request = new HttpRequestMessage(); requestUri = new UriBuilder(requestUri) { Query = $"?sb-hc-token={token.TokenString}" }.Uri; using (HttpClient client = new HttpClient { BaseAddress = requestUri }) { using (var response = await client.SendAsync(request)) { Console.WriteLine($"Response status code: {response.StatusCode}. Response reason phrase: {response.ReasonPhrase}"); } } Console.WriteLine("Press <Enter> to exit..."); Console.ReadLine(); } finally { if (listener != null) { await listener.CloseAsync(); } } }