/// <summary> /// Initializes a new instance of the <see cref="ServiceBusConnection"/> class. /// </summary> /// /// <param name="fullyQualifiedNamespace">The fully qualified Service Bus namespace to connect to. This is likely to be similar to <c>{yournamespace}.servicebus.windows.net</c>.</param> /// <param name="credential">The Azure managed identity credential to use for authorization. Access controls may be specified by the Service Bus namespace or the requested Service Bus entity, depending on Azure configuration.</param> /// <param name="options">A set of options to apply when configuring the connection.</param> internal ServiceBusConnection( string fullyQualifiedNamespace, TokenCredential credential, ServiceBusClientOptions options) { Argument.AssertWellFormedServiceBusNamespace(fullyQualifiedNamespace, nameof(fullyQualifiedNamespace)); Argument.AssertNotNull(credential, nameof(credential)); ValidateConnectionOptions(options); switch (credential) { case SharedAccessSignatureCredential _: break; case ServiceBusSharedKeyCredential sharedKeyCredential: credential = sharedKeyCredential.AsSharedAccessSignatureCredential(BuildAudienceResource(options.TransportType, fullyQualifiedNamespace, EntityPath)); break; } var tokenCredential = new ServiceBusTokenCredential(credential, BuildAudienceResource(options.TransportType, fullyQualifiedNamespace, EntityPath)); FullyQualifiedNamespace = fullyQualifiedNamespace; TransportType = options.TransportType; RetryOptions = options.RetryOptions; #pragma warning disable CA2214 // Do not call overridable methods in constructors. This internal method is virtual for testing purposes. _innerClient = CreateTransportClient(tokenCredential, options); #pragma warning restore CA2214 // Do not call overridable methods in constructors }
static SecurityContext AuthenticateClient(TransportClient client) { TransportStream stream = client.GetStream(); byte[] clientToken; byte[] serverToken; // create client context SecurityContext clientContext = authModule.CreateSecurityContext(clientCredentials, SecurityContextAttributes.Identify, null, out clientToken); while (true) { if (clientToken != null) { // send client token to server SendBuffer(stream, clientToken); } if (clientContext.State == SecurityContextState.Completed) { // authentication completed break; } // receive server token serverToken = ReceiveBuffer(stream); // update security context authModule.UpdateSecurityContext(clientContext, SecurityContextAttributes.Identify, serverToken, out clientToken); } return(clientContext); }
/// <summary> /// 创建客户端。 /// </summary> /// <param name="endPoint">终结点。</param> /// <returns>传输客户端实例。</returns> public async Task <ITransportClient> CreateClientAsync(EndPoint endPoint) { var key = endPoint; if (_logger.IsEnabled(LogLevel.Debug)) { _logger.LogDebug($"准备为服务端地址:{key}创建客户端。"); } try { return(await _clients.GetOrAdd(key, k => new Lazy <Task <ITransportClient> >(async() => { // 客户端对象 var bootstrap = _bootstrap; // 异步连接返回channel var channel = await bootstrap.ConnectAsync(k); var messageListener = new MessageListener(); // 设置监听 channel.GetAttribute(messageListenerKey).Set(messageListener); // 实例化发送者 var messageSender = new DotNettyMessageClientSender(_transportMessageEncoder, channel); // 设置channel属性 channel.GetAttribute(messageSenderKey).Set(messageSender); channel.GetAttribute(origEndPointKey).Set(k); // 创建客户端 var client = new TransportClient(messageSender, messageListener, _logger, _serviceExecutor); return client; })).Value); } catch { _clients.TryRemove(key, out var value); throw; } }
/// <summary> /// Initializes a new instance of the <see cref="ServiceBusConnection"/> class. /// </summary> /// /// <param name="fullyQualifiedNamespace">The fully qualified Service Bus namespace to connect to. This is likely to be similar to <c>{yournamespace}.servicebus.windows.net</c>.</param> /// <param name="credential">The Azure managed identity credential to use for authorization. Access controls may be specified by the Service Bus namespace or the requested Service Bus entity, depending on Azure configuration.</param> /// <param name="connectionOptions">A set of options to apply when configuring the connection.</param> /// internal ServiceBusConnection( string fullyQualifiedNamespace, TokenCredential credential, ServiceBusClientOptions connectionOptions = default) { Argument.AssertNotNullOrEmpty(fullyQualifiedNamespace, nameof(fullyQualifiedNamespace)); Argument.AssertNotNull(credential, nameof(credential)); connectionOptions = connectionOptions?.Clone() ?? new ServiceBusClientOptions(); ValidateConnectionOptions(connectionOptions); switch (credential) { case SharedAccessSignatureCredential _: break; case ServiceBusSharedKeyCredential sharedKeyCredential: credential = sharedKeyCredential.AsSharedAccessSignatureCredential(BuildAudienceResource(connectionOptions.TransportType, fullyQualifiedNamespace, EntityName)); break; } var tokenCredential = new ServiceBusTokenCredential(credential, BuildAudienceResource(connectionOptions.TransportType, fullyQualifiedNamespace, EntityName)); FullyQualifiedNamespace = fullyQualifiedNamespace; TransportType = connectionOptions.TransportType; _innerClient = CreateTransportClient(tokenCredential, connectionOptions); }
/// <summary> /// Initializes a new instance of the <see cref="ServiceBusConnection"/> class. /// </summary> /// /// <param name="connectionString">The connection string to use for connecting to the Service Bus namespace.</param> /// <param name="options">A set of options to apply when configuring the connection.</param> /// /// <remarks> /// If the connection string is copied from the Service Bus entity itself, it will contain the name of the desired Service Bus entity, /// and can be used directly without passing the name="entityName" />. The name of the Service Bus entity should be /// passed only once, either as part of the connection string or separately. /// </remarks> /// internal ServiceBusConnection( string connectionString, ServiceBusClientOptions options) { Argument.AssertNotNullOrEmpty(connectionString, nameof(connectionString)); Argument.AssertNotNull(options, nameof(options)); options = options.Clone(); ValidateConnectionOptions(options); var builder = new ServiceBusConnectionStringBuilder(connectionString); FullyQualifiedNamespace = builder.FullyQualifiedNamespace; TransportType = options.TransportType; EntityPath = builder.EntityName; var sharedAccessSignature = new SharedAccessSignature ( BuildAudienceResource(options.TransportType, FullyQualifiedNamespace, EntityPath), builder.SasKeyName, builder.SasKey ); var sharedCredentials = new SharedAccessSignatureCredential(sharedAccessSignature); var tokenCredentials = new ServiceBusTokenCredential( sharedCredentials, BuildAudienceResource(options.TransportType, FullyQualifiedNamespace, EntityPath)); _innerClient = CreateTransportClient(tokenCredentials, options); }
public HttpPilotClient() { _client = new TransportClient(); _marshaller = new Marshaller(new CallServiceAdapter(_client)); _unmarshaller = new Unmarshaller(this); _transportCallback = new CallbackReceiverAdapter(_unmarshaller, CallbackError); }
public void OnAcceptClient(TransportClient transportClient) { Console.WriteLine("Broadcaster.OnAcceptClient"); Client client = new Client(transportClient, SessionManager.Instance); clients.TryAdd(transportClient, client); }
public void TestTransportServer() { ICodec <string> codec = new StringCodec(); BlockingCollection <string> queue = new BlockingCollection <string>(); List <string> events = new List <string>(); IPEndPoint endpoint = new IPEndPoint(_localIpAddress, 0); var remoteHandler = Observer.Create <TransportEvent <string> >(tEvent => queue.Add(tEvent.Data)); using (var server = new TransportServer <string>(endpoint, remoteHandler, codec, _tcpPortProvider)) { server.Run(); IPEndPoint remoteEndpoint = new IPEndPoint(_localIpAddress, server.LocalEndpoint.Port); using (var client = new TransportClient <string>(remoteEndpoint, codec, _tcpClientFactory)) { client.Send("TestTransportServer - 1"); client.Send("TestTransportServer - 2"); client.Send("TestTransportServer - 3"); events.Add(queue.Take()); events.Add(queue.Take()); events.Add(queue.Take()); } } Assert.Equal(3, events.Count); Assert.Equal("TestTransportServer - 1", events[0]); Assert.Equal("TestTransportServer - 2", events[1]); Assert.Equal("TestTransportServer - 3", events[2]); }
// Sets up given transport client type public void SetTransport(TransportType transport) { // Stop existing transport client if any, when nulled out it will be collected // by garbage collecter after existing connections have been terminated. if (transportClient != null) { transportClient.Stop(); transportClient = null; } // Create new transport client instance switch (transport) { case TransportType.SHORTPOLLING: Func <string> getShortPollingEndpoint = () => { return(GetHttpPollingEndpoint("shortpolling")); }; transportClient = new ShortPolling(getShortPollingEndpoint, GetHttpHeaders, ProcessMessagesString); break; case TransportType.LONGPOLLING: Func <string> getLongPollingEndpoint = () => { return(GetHttpPollingEndpoint("longpolling")); }; transportClient = new LongPolling(getLongPollingEndpoint, GetHttpHeaders, ProcessMessagesString); break; default: throw new Exception("Invalid transport type: " + transport); } }
public void TestTransportServerEvent() { ICodec <TestEvent> codec = new TestEventCodec(); int port = NetworkUtils.GenerateRandomPort(6000, 7000); BlockingCollection <TestEvent> queue = new BlockingCollection <TestEvent>(); List <TestEvent> events = new List <TestEvent>(); IPEndPoint endpoint = new IPEndPoint(IPAddress.Any, port); var remoteHandler = Observer.Create <TransportEvent <TestEvent> >(tEvent => queue.Add(tEvent.Data)); using (var server = new TransportServer <TestEvent>(endpoint, remoteHandler, codec)) { server.Run(); IPEndPoint remoteEndpoint = new IPEndPoint(IPAddress.Parse("127.0.0.1"), port); using (var client = new TransportClient <TestEvent>(remoteEndpoint, codec)) { client.Send(new TestEvent("Hello")); client.Send(new TestEvent(", ")); client.Send(new TestEvent("World!")); events.Add(queue.Take()); events.Add(queue.Take()); events.Add(queue.Take()); } } Assert.AreEqual(3, events.Count); }
private StoreClient GetMockStoreClient() { Mock <IAddressResolver> mockAddressCache = this.GetMockAddressCache(); AddressSelector addressSelector = new AddressSelector(mockAddressCache.Object, Protocol.Tcp); TransportClient mockTransportClient = this.GetMockTransportClient(); ISessionContainer sessionContainer = new SessionContainer(string.Empty); StoreReader storeReader = new StoreReader(mockTransportClient, addressSelector, sessionContainer); Mock <IAuthorizationTokenProvider> mockAuthorizationTokenProvider = new Mock <IAuthorizationTokenProvider>(); // setup max replica set size on the config reader ReplicationPolicy replicationPolicy = new ReplicationPolicy(); replicationPolicy.MaxReplicaSetSize = 4; Mock <IServiceConfigurationReader> mockServiceConfigReader = new Mock <IServiceConfigurationReader>(); mockServiceConfigReader.SetupGet(x => x.UserReplicationPolicy).Returns(replicationPolicy); return(new StoreClient( mockAddressCache.Object, sessionContainer, mockServiceConfigReader.Object, mockAuthorizationTokenProvider.Object, Protocol.Tcp, mockTransportClient)); }
internal TransportClientWrapper( TransportClient client, Action <Uri, ResourceOperation, DocumentServiceRequest> interceptor, bool injectCpuMonitor = false) { Debug.Assert(client != null); Debug.Assert(interceptor != null); if (injectCpuMonitor) { CpuMonitor.OverrideRefreshInterval(TimeSpan.FromMilliseconds(100)); this.cpuMonitor = new CpuMonitor(); this.cpuMonitor.Start(); Stopwatch watch = Stopwatch.StartNew(); // Artifically burning some CPU to generate CPU load history CpuLoadHistory cpuLoadHistory = null; while ((cpuLoadHistory = this.cpuMonitor.GetCpuLoad()) == null || cpuLoadHistory.ToString() == emptyCpuLoadHistoryText) { Task.Delay(10).Wait(); } } this.baseClient = client; this.interceptor = interceptor; }
public void TransportClient_DoesThrowFor404WithReadSessionNotAvailable_WithUseStatusCodeForFailures() { using (DocumentServiceRequest request = DocumentServiceRequest.Create( OperationType.Query, ResourceType.Document, ExceptionlessTests.resourceUri, new MemoryStream(Encoding.UTF8.GetBytes("content1")), AuthorizationTokenType.PrimaryMasterKey, null)) { request.UseStatusCodeForFailures = true; StoreResponse mockStoreResponse404 = new StoreResponse(); mockStoreResponse404.ResponseHeaderNames = new string[1] { WFConstants.BackendHeaders.SubStatus }; mockStoreResponse404.ResponseHeaderValues = new string[1] { ((int)SubStatusCodes.ReadSessionNotAvailable).ToString() }; mockStoreResponse404.Status = (int)HttpStatusCode.NotFound; TransportClient.ThrowServerException( string.Empty, mockStoreResponse404, ExceptionlessTests.resourceUri, Guid.NewGuid(), request); } }
/// <summary> /// Initializes a new instance of the <see cref="EventHubConnection"/> class. /// </summary> /// /// <param name="fullyQualifiedNamespace">The fully qualified Event Hubs namespace to connect to. This is likely to be similar to <c>{yournamespace}.servicebus.windows.net</c>.</param> /// <param name="eventHubName">The name of the specific Event Hub to associate the connection with.</param> /// <param name="credential">The Azure managed identity credential to use for authorization. Access controls may be specified by the Event Hubs namespace or the requested Event Hub, depending on Azure configuration.</param> /// <param name="connectionOptions">A set of options to apply when configuring the connection.</param> /// public EventHubConnection(string fullyQualifiedNamespace, string eventHubName, TokenCredential credential, EventHubConnectionOptions connectionOptions = default) { Argument.AssertWellFormedEventHubsNamespace(fullyQualifiedNamespace, nameof(fullyQualifiedNamespace)); Argument.AssertNotNullOrEmpty(eventHubName, nameof(eventHubName)); Argument.AssertNotNull(credential, nameof(credential)); connectionOptions = connectionOptions?.Clone() ?? new EventHubConnectionOptions(); ValidateConnectionOptions(connectionOptions); switch (credential) { case SharedAccessSignatureCredential _: break; case EventHubSharedKeyCredential sharedKeyCredential: credential = sharedKeyCredential.AsSharedAccessSignatureCredential(BuildConnectionAudience(connectionOptions.TransportType, fullyQualifiedNamespace, eventHubName)); break; } var tokenCredential = new EventHubTokenCredential(credential, BuildConnectionAudience(connectionOptions.TransportType, fullyQualifiedNamespace, eventHubName)); FullyQualifiedNamespace = fullyQualifiedNamespace; EventHubName = eventHubName; Options = connectionOptions; #pragma warning disable CA2214 // Do not call overridable methods in constructors. This internal method is virtual for testing purposes. InnerClient = CreateTransportClient(fullyQualifiedNamespace, eventHubName, tokenCredential, connectionOptions); #pragma warning restore CA2214 // Do not call overridable methods in constructors. }
public HttpPilotClient(IMarshallingFactory factory) { _client = new TransportClient(); _marshaller = factory.GetMarshaller(new CallServiceAdapter(_client)); _unmarshaller = factory.GetUnmarshaller(this); _transportCallback = new CallbackReceiverAdapter(_unmarshaller, CallbackError); }
/// <summary> /// Initializes a new instance of the <see cref="ServiceBusConnection"/> class. /// </summary> /// /// <param name="fullyQualifiedNamespace">The fully qualified Service Bus namespace to connect to. This is likely to be similar to <c>{yournamespace}.servicebus.windows.net</c>.</param> /// <param name="credential">The Azure managed identity credential to use for authorization. Access controls may be specified by the Service Bus namespace or the requested Service Bus entity, depending on Azure configuration.</param> /// <param name="options">A set of options to apply when configuring the connection.</param> /// internal ServiceBusConnection( string fullyQualifiedNamespace, TokenCredential credential, ServiceBusClientOptions options) { Argument.AssertWellFormedServiceBusNamespace(fullyQualifiedNamespace, nameof(fullyQualifiedNamespace)); Argument.AssertNotNull(credential, nameof(credential)); options = options?.Clone() ?? new ServiceBusClientOptions(); ValidateConnectionOptions(options); switch (credential) { case SharedAccessSignatureCredential _: break; case ServiceBusSharedKeyCredential sharedKeyCredential: credential = sharedKeyCredential.AsSharedAccessSignatureCredential(BuildAudienceResource(options.TransportType, fullyQualifiedNamespace, EntityPath)); break; } var tokenCredential = new ServiceBusTokenCredential(credential, BuildAudienceResource(options.TransportType, fullyQualifiedNamespace, EntityPath)); FullyQualifiedNamespace = fullyQualifiedNamespace; TransportType = options.TransportType; Options = options; RetryOptions = options.RetryOptions; _innerClient = CreateTransportClient(tokenCredential, options); }
private StoreClient GetMockStoreClient() { Mock <IAddressResolver> mockAddressCache = this.GetMockAddressCache(); AddressSelector addressSelector = new AddressSelector(mockAddressCache.Object, Protocol.Tcp); TransportClient mockTransportClient = this.GetMockTransportClient(); ISessionContainer sessionContainer = new SessionContainer(string.Empty); StoreReader storeReader = new StoreReader(mockTransportClient, addressSelector, new AddressEnumerator(), sessionContainer); Mock <IAuthorizationTokenProvider> mockAuthorizationTokenProvider = new Mock <IAuthorizationTokenProvider>(); mockAuthorizationTokenProvider.Setup(provider => provider.AddSystemAuthorizationHeaderAsync( It.IsAny <DocumentServiceRequest>(), It.IsAny <string>(), It.IsAny <string>(), It.IsAny <string>())) .Returns(Task.FromResult(0)); // setup max replica set size on the config reader ReplicationPolicy replicationPolicy = new ReplicationPolicy(); replicationPolicy.MaxReplicaSetSize = 4; Mock <IServiceConfigurationReader> mockServiceConfigReader = new Mock <IServiceConfigurationReader>(); mockServiceConfigReader.SetupGet(x => x.UserReplicationPolicy).Returns(replicationPolicy); return(new StoreClient( mockAddressCache.Object, sessionContainer, mockServiceConfigReader.Object, mockAuthorizationTokenProvider.Object, Protocol.Tcp, mockTransportClient)); }
/// <summary> /// 创建客户端。 /// </summary> /// <param name="endPoint">终结点。</param> /// <returns>传输客户端实例。</returns> public ITransportClient CreateClient(EndPoint endPoint) { var key = endPoint.ToString(); if (_logger.IsEnabled(LogLevel.Debug)) { _logger.Debug($"准备为服务端地址:{key}创建客户端。"); } return(_clients.GetOrAdd(key , k => new Lazy <ITransportClient>(() => { var messageListener = new MessageListener(); _bootstrap.Handler(new ActionChannelInitializer <ISocketChannel>(c => { var pipeline = c.Pipeline; pipeline.AddLast(new LengthFieldPrepender(4)); pipeline.AddLast(new LengthFieldBasedFrameDecoder(int.MaxValue, 0, 4, 0, 4)); pipeline.AddLast(new DefaultChannelHandler(messageListener, _serializer)); })); var bootstrap = _bootstrap; var channel = bootstrap.ConnectAsync(endPoint); var messageSender = new DotNettyMessageClientSender(_serializer, channel); var client = new TransportClient(messageSender, messageListener, _logger, _serializer); return client; } )).Value); }
/// <summary> /// 创建客户端。 /// </summary> /// <param name="endPoint">终结点。</param> /// <returns>传输客户端实例。</returns> public ITransportClient CreateClient(EndPoint endPoint) { var key = endPoint; if (_logger.IsEnabled(LogLevel.Debug)) { _logger.LogDebug($"准备为服务端地址:{key}创建客户端。"); } try { return(_clients.GetOrAdd(key , k => new Lazy <ITransportClient>(() => { var bootstrap = _bootstrap; var channel = bootstrap.ConnectAsync(k).Result; var messageListener = new MessageListener(); channel.GetAttribute(messageListenerKey).Set(messageListener); var messageSender = new DotNettyMessageClientSender(_transportMessageEncoder, channel); channel.GetAttribute(messageSenderKey).Set(messageSender); channel.GetAttribute(origEndPointKey).Set(k); var client = new TransportClient(messageSender, messageListener, _logger, _serviceExecutor); return client; } )).Value); } catch { _clients.TryRemove(key, out var value); throw; } }
/// <summary> /// Initializes a new instance of the <see cref="EventHubConnection"/> class. /// </summary> /// /// <param name="fullyQualifiedNamespace">The fully qualified Event Hubs namespace to connect to. This is likely to be similar to <c>{yournamespace}.servicebus.windows.net</c>.</param> /// <param name="eventHubName">The name of the specific Event Hub to associate the connection with.</param> /// <param name="credential">The Azure managed identity credential to use for authorization. Access controls may be specified by the Event Hubs namespace or the requested Event Hub, depending on Azure configuration.</param> /// <param name="connectionOptions">A set of options to apply when configuring the connection.</param> /// public EventHubConnection(string fullyQualifiedNamespace, string eventHubName, TokenCredential credential, EventHubConnectionOptions connectionOptions = default) { Argument.AssertNotNullOrEmpty(fullyQualifiedNamespace, nameof(fullyQualifiedNamespace)); Argument.AssertNotNullOrEmpty(eventHubName, nameof(eventHubName)); Argument.AssertNotNull(credential, nameof(credential)); connectionOptions = connectionOptions?.Clone() ?? new EventHubConnectionOptions(); ValidateConnectionOptions(connectionOptions); switch (credential) { case SharedAccessSignatureCredential _: break; case EventHubSharedKeyCredential sharedKeyCredential: credential = sharedKeyCredential.AsSharedAccessSignatureCredential(BuildAudienceResource(connectionOptions.TransportType, fullyQualifiedNamespace, eventHubName)); break; } var tokenCredential = new EventHubTokenCredential(credential, BuildAudienceResource(connectionOptions.TransportType, fullyQualifiedNamespace, eventHubName)); FullyQualifiedNamespace = fullyQualifiedNamespace; EventHubName = eventHubName; Options = connectionOptions; InnerClient = CreateTransportClient(fullyQualifiedNamespace, eventHubName, tokenCredential, connectionOptions); }
public InjectableTransportClientMock(TransportClient transportClient, string connectionString, EventHubConnectionOptions clientOptions = default) : base(connectionString, clientOptions) { TransportClient = transportClient; SetTransportClient(transportClient); }
public void TransportClient_DoesNotThrowFor429_WithUseStatusCodeFor429() { using (DocumentServiceRequest request = DocumentServiceRequest.Create( OperationType.Query, ResourceType.Document, ExceptionlessTests.resourceUri, new MemoryStream(Encoding.UTF8.GetBytes("content1")), AuthorizationTokenType.PrimaryMasterKey, null)) { request.UseStatusCodeFor429 = true; StoreResponse mockStoreResponse429 = new StoreResponse { Status = (int)StatusCodes.TooManyRequests }; TransportClient.ThrowServerException( string.Empty, mockStoreResponse429, ExceptionlessTests.resourceUri, Guid.NewGuid(), request); } }
public void TestTransportSenderStage() { ICodec <string> codec = new StringCodec(); IPEndPoint endpoint = new IPEndPoint(_localIpAddress, 0); List <string> events = new List <string>(); BlockingCollection <string> queue = new BlockingCollection <string>(); // Server echoes the message back to the client var remoteHandler = Observer.Create <TransportEvent <string> >(tEvent => tEvent.Link.Write(tEvent.Data)); using (TransportServer <string> server = new TransportServer <string>(endpoint, remoteHandler, codec, _tcpPortProvider)) { server.Run(); var clientHandler = Observer.Create <TransportEvent <string> >(tEvent => queue.Add(tEvent.Data)); IPEndPoint remoteEndpoint = new IPEndPoint(_localIpAddress, server.LocalEndpoint.Port); using (var client = new TransportClient <string>(remoteEndpoint, codec, clientHandler)) { client.Send("Hello"); client.Send(", "); client.Send(" World"); events.Add(queue.Take()); events.Add(queue.Take()); events.Add(queue.Take()); } } Assert.Equal(3, events.Count); Assert.Equal(events[0], "Hello"); Assert.Equal(events[1], ", "); Assert.Equal(events[2], " World"); }
public void TestTransportServerEvent() { ICodec <TestEvent> codec = new TestEventCodec(); BlockingCollection <TestEvent> queue = new BlockingCollection <TestEvent>(); List <TestEvent> events = new List <TestEvent>(); IPEndPoint endpoint = new IPEndPoint(_localIpAddress, 0); var remoteHandler = Observer.Create <TransportEvent <TestEvent> >(tEvent => queue.Add(tEvent.Data)); using (var server = new TransportServer <TestEvent>(endpoint, remoteHandler, codec, _tcpPortProvider)) { server.Run(); IPEndPoint remoteEndpoint = new IPEndPoint(_localIpAddress, server.LocalEndpoint.Port); using (var client = new TransportClient <TestEvent>(remoteEndpoint, codec)) { client.Send(new TestEvent("Hello")); client.Send(new TestEvent(", ")); client.Send(new TestEvent("World!")); events.Add(queue.Take()); events.Add(queue.Take()); events.Add(queue.Take()); } } Assert.Equal(3, events.Count); Assert.Equal(events[0].Message, "Hello"); Assert.Equal(events[1].Message, ", "); Assert.Equal(events[2].Message, "World!"); }
/** * Is invoked when application launches. Connects the Client to the Server */ public void OnUserConnect(string address, int port) { ChannelDispatcher dispatcher = new ChannelDispatcher(); this.transport = new TransportClient(dispatcher); sessionClient = new SessionClient(this.transport, this); dispatcher.RegisterChannel(sessionClient); surfaceClient = new SurfaceClient(this, this.transport); dispatcher.RegisterChannel(surfaceClient); inputClient = new InputClient(this.transport); dispatcher.RegisterChannel(inputClient); try { this.transport.Connect(address, port); DisplayStatusText("Welcome! You are connected to Screenary server at " + address + " : " + port); } catch (TransportException e) { ExceptionDialog exception = new ExceptionDialog("Operation Fail", "Could not connect to Screenary server at " + address + " : " + port + "\nVerify connections."); } }
/// <summary> /// Initializes a new instance of the <see cref="ServiceBusConnection"/> class. /// </summary> /// /// <param name="connectionString">The connection string to use for connecting to the Service Bus namespace.</param> /// <param name="entityName">The name of the specific Service Bus entity to associate the connection with (if not contained in connectionString).</param> /// <param name="connectionOptions">A set of options to apply when configuring the connection.</param> /// /// <remarks> /// If the connection string is copied from the Service Bus entity itself, it will contain the name of the desired Service Bus entity, /// and can be used directly without passing the <paramref name="entityName" />. The name of the Service Bus entity should be /// passed only once, either as part of the connection string or separately. /// </remarks> /// public ServiceBusConnection( string connectionString, string entityName, ServiceBusConnectionOptions connectionOptions) { Argument.AssertNotNullOrEmpty(connectionString, nameof(connectionString)); connectionOptions = connectionOptions?.Clone() ?? new ServiceBusConnectionOptions(); ValidateConnectionOptions(connectionOptions); var builder = new ServiceBusConnectionStringBuilder(connectionString); var fullyQualifiedNamespace = builder.FullyQualifiedNamespace; if (string.IsNullOrEmpty(entityName)) { entityName = builder.EntityName; } var sharedAccessSignature = new SharedAccessSignature ( BuildAudienceResource(connectionOptions.TransportType, fullyQualifiedNamespace, entityName), builder.SasKeyName, builder.SasKey ); var sharedCredentials = new SharedAccessSignatureCredential(sharedAccessSignature); var tokenCredentials = new ServiceBusTokenCredential(sharedCredentials, BuildAudienceResource(connectionOptions.TransportType, fullyQualifiedNamespace, entityName)); FullyQualifiedNamespace = fullyQualifiedNamespace; EntityName = entityName; InnerClient = CreateTransportClient(fullyQualifiedNamespace, entityName, tokenCredentials, connectionOptions); TransportType = connectionOptions.TransportType; }
public void TestTransportSenderStage() { ICodec <string> codec = new StringCodec(); int port = NetworkUtils.GenerateRandomPort(6000, 7000); IPEndPoint endpoint = new IPEndPoint(IPAddress.Any, port); List <string> events = new List <string>(); BlockingCollection <string> queue = new BlockingCollection <string>(); // Server echoes the message back to the client var remoteHandler = Observer.Create <TransportEvent <string> >(tEvent => tEvent.Link.Write(tEvent.Data)); using (TransportServer <string> server = new TransportServer <string>(endpoint, remoteHandler, codec)) { server.Run(); var clientHandler = Observer.Create <TransportEvent <string> >(tEvent => queue.Add(tEvent.Data)); IPEndPoint remoteEndpoint = new IPEndPoint(IPAddress.Parse("127.0.0.1"), port); using (var client = new TransportClient <string>(remoteEndpoint, codec, clientHandler)) { client.Send("Hello"); client.Send(", "); client.Send(" World"); events.Add(queue.Take()); events.Add(queue.Take()); events.Add(queue.Take()); } } Assert.AreEqual(3, events.Count); }
/// <summary> /// Initializes a new instance of the <see cref="EventHubConnection"/> class. /// </summary> /// /// <param name="connectionString">The connection string to use for connecting to the Event Hubs namespace; it is expected that the shared key properties are contained in this connection string, but not the Event Hub name.</param> /// <param name="eventHubName">The name of the specific Event Hub to associate the connection with.</param> /// <param name="connectionOptions">A set of options to apply when configuring the connection.</param> /// /// <remarks> /// If the connection string is copied from the Event Hub itself, it will contain the name of the desired Event Hub, /// and can be used directly without passing the <paramref name="eventHubName" />. The name of the Event Hub should be /// passed only once, either as part of the connection string or separately. /// </remarks> /// public EventHubConnection(string connectionString, string eventHubName, EventHubConnectionOptions connectionOptions) { Argument.AssertNotNullOrEmpty(connectionString, nameof(connectionString)); connectionOptions = connectionOptions?.Clone() ?? new EventHubConnectionOptions(); ValidateConnectionOptions(connectionOptions); ConnectionStringProperties connectionStringProperties = ConnectionStringParser.Parse(connectionString); ValidateConnectionProperties(connectionStringProperties, eventHubName, nameof(connectionString)); var fullyQualifiedNamespace = connectionStringProperties.Endpoint.Host; if (string.IsNullOrEmpty(eventHubName)) { eventHubName = connectionStringProperties.EventHubName; } var sharedAccessSignature = new SharedAccessSignature ( BuildAudienceResource(connectionOptions.TransportType, fullyQualifiedNamespace, eventHubName), connectionStringProperties.SharedAccessKeyName, connectionStringProperties.SharedAccessKey ); var sharedCredentials = new SharedAccessSignatureCredential(sharedAccessSignature); var tokenCredentials = new EventHubTokenCredential(sharedCredentials, BuildAudienceResource(connectionOptions.TransportType, fullyQualifiedNamespace, eventHubName)); FullyQualifiedNamespace = fullyQualifiedNamespace; EventHubName = eventHubName; Options = connectionOptions; InnerClient = CreateTransportClient(fullyQualifiedNamespace, eventHubName, tokenCredentials, connectionOptions); }
public NameRegisterClient(TransportClient<NamingEvent> client, BlockingCollection<NamingRegisterResponse> registerQueue, BlockingCollection<NamingUnregisterResponse> unregisterQueue) { _client = client; _registerResponseQueue = registerQueue; _unregisterResponseQueue = unregisterQueue; }
/// <summary> /// Constructs a new NameLookupClient. /// </summary> /// <param name="client">The transport client used to connect to the NameServer</param> /// <param name="lookupQueue">The queue used to signal that a response /// has been received from the NameServer</param> /// <param name="getAllQueue">The queue used to signal that a GetAllResponse /// has been received from the NameServer</param> public NameLookupClient(TransportClient<NamingEvent> client, BlockingCollection<NamingLookupResponse> lookupQueue, BlockingCollection<NamingGetAllResponse> getAllQueue) { _client = client; _lookupResponseQueue = lookupQueue; _getAllResponseQueue = getAllQueue; }
/// <summary> /// Constructs a new NameLookupClient. /// </summary> /// <param name="client">The transport client used to connect to the NameServer</param> /// <param name="lookupQueue">The queue used to signal that a response /// has been received from the NameServer</param> /// <param name="getAllQueue">The queue used to signal that a GetAllResponse /// has been received from the NameServer</param> public NameLookupClient(TransportClient <NamingEvent> client, BlockingCollection <NamingLookupResponse> lookupQueue, BlockingCollection <NamingGetAllResponse> getAllQueue) { _client = client; _lookupResponseQueue = lookupQueue; _getAllResponseQueue = getAllQueue; }
/// <summary> /// Creates an instance of the Device Provisioning Client. /// </summary> /// <param name="globalDeviceEndpoint">The global device endpoint host-name.</param> /// <param name="idScope">The IDScope for the Device Provisioning Service.</param> /// <param name="securityClient">The security client instance.</param> /// <param name="transport">The type of transport (e.g. HTTP, AMQP, MQTT).</param> /// <returns>An instance of the DPSDeviceClient</returns> public static ProvisioningDeviceClient Create( string globalDeviceEndpoint, string idScope, SecurityClient securityClient, TransportClient transport) { throw new System.NotImplementedException(); }
public Session(TransportClient transport, ISessionResponseListener listener) : base(transport, listener) { }
public Surface(TransportClient transport) : base(transport) { }