public IDevice CreateDevice(ILogger logger, ITransportFactory transportFactory, ITelemetryFactory telemetryFactory, IConfigurationProvider configurationProvider, InitialDeviceConfig config) { var device = new DeviceBase(logger, transportFactory, telemetryFactory, configurationProvider); device.Init(config); return device; }
public WeatherShieldDevice(ILogger logger, ITransportFactory transportFactory, ITelemetryFactory telemetryFactory, IConfigurationProvider configurationProvider, CancellationToken token) : base(logger, transportFactory, telemetryFactory, configurationProvider) { this.DeviceSensors = new SensorsCollection<AbstractSensor>(); this._token = token; this._mutex = new Mutex(); }
public void Setup() { mockTransport = new MockWampTransport(); mockTransportFactory = new MockTransportFactory(mockTransport); var connectionTask = WampClient.ConnectAsync("ws://localhost:3000", mockTransportFactory); connectionTask.Wait(); this.connection = connectionTask.Result; }
internal WeatherShieldDeviceFactory() { this._logger = new TraceLogger(); this._configProvider = new ConfigurationProvider(); var serializer = new JsonSerialize(); this._transportFactory = new IotHubTransportFactory(serializer, this._logger, this._configProvider); }
/// <summary> /// /// </summary> /// <param name="logger">Logger where this device will log information to</param> /// <param name="transport">Transport where the device will send and receive data to/from</param> /// <param name="config">Config to start this device with</param> public DeviceBase(ILogger logger, ITransportFactory transportFactory, ITelemetryFactory telemetryFactory, IConfigurationProvider configurationProvider) { ConfigProvider = configurationProvider; Logger = logger; TransportFactory = transportFactory; TelemetryFactory = telemetryFactory; TelemetryEvents = new List<ITelemetry>(); }
public BulkDeviceTester(ITransportFactory transportFactory, ILogger logger, IConfigurationProvider configProvider, ITelemetryFactory telemetryFactory, IDeviceFactory deviceFactory, IVirtualDeviceStorage virtualDeviceStorage) { _transportFactory = transportFactory; _logger = logger; _configProvider = configProvider; _telemetryFactory = telemetryFactory; _deviceFactory = deviceFactory; _deviceStorage = virtualDeviceStorage; _deviceList = new List<InitialDeviceConfig>(); _devicePollIntervalSeconds = Convert.ToInt32(_configProvider.GetConfigurationSettingValueOrDefault("DevicePollIntervalSeconds", DEFAULT_DEVICE_POLL_INTERVAL_SECONDS.ToString())); }
public static Uri GetUriFor(ITransportFactory fac) { var asbAccountDetails = new AccountDetails(); return new Dictionary<Type, Uri> { { typeof (TransportFactoryImpl), asbAccountDetails.WithApplication("TransportSpecs").BuildUri() }, { typeof(MsmqTransportFactory), new Uri(fac.Scheme + "://localhost/TransportSpecs") }, { typeof(RabbitMqTransportFactory), new Uri(fac.Scheme + "://localhost/TransportSpecs") }, { typeof(LoopbackTransportFactory), new Uri(fac.Scheme + "://localhost/TransportSpecs")} } [fac.GetType()]; }
public IEndpoint CreateEndpoint(ITransportFactory transportFactory) { try { IDuplexTransport transport = _transportFactory(transportFactory, _settings); IOutboundTransport errorTransport = _errorTransportFactory(transportFactory, _errorSettings); var endpoint = new Endpoint(transport.Address, _settings.Serializer, transport, errorTransport); return endpoint; } catch (Exception ex) { throw new EndpointException(_uri, "Failed to create endpoint", ex); } }
private static HttpConnection CreateConnection( HttpMessageHandler httpHandler = null, ILoggerFactory loggerFactory = null, string url = null, ITransport transport = null, ITransportFactory transportFactory = null, HttpTransportType transportType = HttpTransportType.LongPolling, Func <string> accessTokenFactory = null) { var httpOptions = new HttpOptions { HttpMessageHandlerFactory = (httpMessageHandler) => httpHandler ?? TestHttpMessageHandler.CreateDefault(), AccessTokenFactory = accessTokenFactory, }; return(CreateConnection(httpOptions, loggerFactory, url, transport, transportFactory, transportType)); }
public IEndpoint CreateEndpoint(ITransportFactory transportFactory) { try { IDuplexTransport transport = _transportFactory(transportFactory, _settings); IOutboundTransport errorTransport = _errorTransportFactory(transportFactory, _errorSettings); IInboundMessageTracker tracker = _messageTrackerFactory(); var endpoint = new Endpoint(transport.Address, _settings.Serializer, transport, errorTransport, tracker); return(endpoint); } catch (Exception ex) { throw new EndpointException(_uri, "Failed to create endpoint", ex); } }
public BulkDeviceTester(ITransportFactory transportFactory, ILogger logger, IConfigurationProvider configProvider, ITelemetryFactory telemetryFactory, IDeviceFactory deviceFactory, IVirtualDeviceStorage virtualDeviceStorage) { _transportFactory = transportFactory; _logger = logger; _configProvider = configProvider; _telemetryFactory = telemetryFactory; _deviceFactory = deviceFactory; _deviceStorage = virtualDeviceStorage; _deviceList = new List <InitialDeviceConfig>(); string pollingIntervalString = _configProvider.GetConfigurationSettingValueOrDefault( "DevicePollIntervalSeconds", DEFAULT_DEVICE_POLL_INTERVAL_SECONDS.ToString(CultureInfo.InvariantCulture)); _devicePollIntervalSeconds = Convert.ToInt32(pollingIntervalString, CultureInfo.InvariantCulture); }
public HttpConnection(Uri url, TransportType transportType, ILoggerFactory loggerFactory, HttpOptions httpOptions) { Url = url ?? throw new ArgumentNullException(nameof(url)); _loggerFactory = loggerFactory ?? NullLoggerFactory.Instance; _logger = _loggerFactory.CreateLogger <HttpConnection>(); _httpOptions = httpOptions; _requestedTransportType = transportType; if (_requestedTransportType != TransportType.WebSockets) { _httpClient = httpOptions?.HttpMessageHandler == null ? new HttpClient() : new HttpClient(httpOptions.HttpMessageHandler); _httpClient.Timeout = HttpClientTimeout; } _transportFactory = new DefaultTransportFactory(transportType, _loggerFactory, _httpClient, httpOptions); }
public bool Configure <TPackageInfo, TPipelineFilter>(ServerOptions options, ITransportFactory transportFactory, IServiceCollection services = null, Action <IAppSession, TPackageInfo> packageHandler = null) where TPackageInfo : class where TPipelineFilter : IPipelineFilter <TPackageInfo>, new() { if (options == null) { throw new ArgumentNullException(nameof(options)); } Options = options; if (transportFactory == null) { throw new ArgumentNullException(nameof(transportFactory)); } _transportFactory = transportFactory; if (services == null) { services = new ServiceCollection(); } // prepare service collections _serviceCollection = services.AddOptions() // activate options .AddLogging(); // add logging // build service provider _serviceProvider = services.BuildServiceProvider(); // initialize logger factory LoggerFactory = _serviceProvider .GetService <ILoggerFactory>() .AddConsole(LogLevel.Debug); _logger = LoggerFactory.CreateLogger("SuperSocket"); _transports = new List <ITransport>(); foreach (var l in options.Listeners) { _transports.Add(_transportFactory.Create(new EndPointInformation(l), new ConnectionDispatcher())); } return(_configured = true); }
public IProcessor Configure(ISubscriptionManager subscriptionManager, ITransportFactory messagingFactory, ILoggerFactory loggerFactory, IDependencyResolver resolver) { this.configurer(this); var processor = new Processor(this.EndpointName, this.ConcurrencyLevel, subscriptionManager, messagingFactory, loggerFactory, resolver); // handlers can be registered here if (this.Configuring != null) { this.Configuring(processor); } return(processor); }
public HttpConnection(Uri url, TransportType transportType, ILoggerFactory loggerFactory, HttpOptions httpOptions) { Url = url ?? throw new ArgumentNullException(nameof(url)); _loggerFactory = loggerFactory ?? NullLoggerFactory.Instance; _logger = _loggerFactory.CreateLogger <HttpConnection>(); _httpOptions = httpOptions; _requestedTransportType = transportType; if (_requestedTransportType != TransportType.WebSockets) { _httpClient = CreateHttpClient(); } _transportFactory = new DefaultTransportFactory(transportType, _loggerFactory, _httpClient, httpOptions); _logScope = new ConnectionLogScope(); _scopeDisposable = _logger.BeginScope(_logScope); }
// For testing internal KestrelServer(ITransportFactory transportFactory, ServiceContext serviceContext) { if (transportFactory == null) { throw new ArgumentNullException(nameof(transportFactory)); } _transportFactory = transportFactory; ServiceContext = serviceContext; var httpHeartbeatManager = new HttpHeartbeatManager(serviceContext.ConnectionManager); _heartbeat = new Heartbeat( new IHeartbeatHandler[] { serviceContext.DateHeaderValueManager, httpHeartbeatManager }, serviceContext.SystemClock, Trace); Features = new FeatureCollection(); _serverAddresses = new ServerAddressesFeature(); Features.Set(_serverAddresses); }
/// <summary> /// Configures the current processor instance with the previously specified settings. /// </summary> /// <param name="subscriptionManager">subscriptionManager</param> /// <param name="transportFactory">transportFactory</param> /// <param name="loggerFactory">loggerFactory</param> /// <param name="resolver">resolver</param> /// <returns>A configured IProcessor instance</returns> public IProcessor Configure(ISubscriptionManager subscriptionManager, ITransportFactory transportFactory, ILoggerFactory loggerFactory, IDependencyResolver resolver) { this.configurer(this); var options = new InboundTransportOptions(this.endpoint, this.maxDeliveryCount, this.deadLetterMessages); var processor = new Processor(options, this.concurrencyLevel, subscriptionManager, transportFactory, loggerFactory, resolver); // handlers can be registered here if (this.Configuring != null) { this.Configuring(processor); } return(processor); }
/// <summary> /// Create a transport factory for the scheme. If we do not support the transport protocol, /// an NMSConnectionException will be thrown. /// </summary> /// <param name="location"></param> /// <returns></returns> private static ITransportFactory CreateTransportFactory(Uri location) { string scheme = location.Scheme; if (null == scheme || 0 == scheme.Length) { throw new NMSConnectionException(String.Format("Transport scheme invalid: [{0}]", location.ToString())); } ITransportFactory factory = null; try { switch (scheme.ToLower()) { case "tcp": factory = new TcpTransportFactory(); break; case "ssl": factory = new SslTransportFactory(); break; default: throw new NMSConnectionException(String.Format("The transport {0} is not supported.", scheme)); } } catch (NMSConnectionException) { throw; } catch { throw new NMSConnectionException("Error creating transport."); } if (null == factory) { throw new NMSConnectionException("Unable to create a transport."); } return(factory); }
public DefaultRpcClient( ITransportFactory <TMessage> factory, IRouter <TMessage> router, IClientMessageHandler <TMessage> handler, IServiceActorLocator <TMessage> actorLocator, ILogger <DefaultRpcClient <TMessage> > logger ) { //注册消息拦截器 收到消息时的处理函数 this._router = router; this._handler = handler; this._factory = factory; logger.LogDebug("注册客户端拦截器消息"); this._handler.Recieved -= Message_Recieved; this._handler.Recieved += Message_Recieved; this._actorLocator = actorLocator; this.Logger = logger; }
public Processor(string endpoint, int concurrencyLevel, ISubscriptionManager subscriptionManager, ITransportFactory transportFactory, ILoggerFactory loggerFactory, IDependencyResolver resolver) { this.endpoint = endpoint; this.subscriptionManager = subscriptionManager; this.resolver = resolver; this.subscriptions = new HashSet <Subscription>(); this.registry = new Dictionary <string, Dictionary <string, IMessageHandler> >(); this.worker = new MessageWorker( transportFactory.CreateInboundTransport(endpoint: endpoint), new DiagnosticsDispatcher(this), // TODO: build proper pipeline support loggerFactory, concurrencyLevel); }
public async Task RunAsync(ITransportFactory transportFactory, IEndPointInformation endPointInformation, ApplicationLifetime lifetime) { Console.CancelKeyPress += (sender, e) => lifetime.StopApplication(); var serverOptions = new KestrelServerOptions(); serverOptions.Listen(endPointInformation.IPEndPoint); var server = new KestrelServer(Options.Create(serverOptions), transportFactory, NullLoggerFactory.Instance); await server.StartAsync(this, CancellationToken.None); Console.WriteLine($"Server ({nameof(PlainTextApplication)}) listening on http://{endPointInformation.IPEndPoint}"); lifetime.ApplicationStopping.WaitHandle.WaitOne(); await server.StopAsync(CancellationToken.None); }
public BlipClientBuilder(ITransportFactory transportFactory, ILogger logger = null) { _transportFactory = transportFactory ?? throw new ArgumentNullException(nameof(transportFactory)); _logger = logger; // Initialize the defaults Domain = Constants.DEFAULT_DOMAIN; Scheme = Constants.DEFAULT_SCHEME; HostName = Constants.DEFAULT_HOST_NAME; Port = Constants.DEFAULT_PORT; SendTimeout = TimeSpan.FromSeconds(60); MaxConnectionRetries = 3; Compression = SessionCompression.None; Encryption = SessionEncryption.TLS; RoutingRule = RoutingRule.Identity; RoundRobin = true; AutoNotify = true; ChannelCount = 1; ReceiptEvents = new [] { Event.Accepted, Event.Dispatched, Event.Received, Event.Consumed, Event.Failed }; }
public DeviceManager(ILogger logger, CancellationToken token) { _logger = logger; _token = token; _mutex = new Mutex(true, mutexId); _cancellationTokens = new Dictionary<string, CancellationTokenSource>(); _devices = new Dictionary<string, IDevice >(); // Sensors = new SensorsCollection<AbstractSensor>(); //We may need leave only one sensor collection _configProvider = new ConfigurationProvider(); _deviceConfiguration = new DeviceConfigTableStorage(_configProvider); var serializer = new JsonSerialize(); _transportFactory = new IotHubTransportFactory(serializer, _logger, _configProvider); _telemetryFactory = new WeatherShieldTelemetryFactory(_logger); RunReadSensorsThread(); }
public Connection(Uri connectionUri, ITransport transport, IdGenerator clientIdGenerator, [NotNull] StompConnectionSettings stompConnectionSettings) { stompConnectionSettings.ThrowIfNull(nameof(stompConnectionSettings)); _stompConnectionSettings = stompConnectionSettings; _transportFactory = new TransportFactory(_stompConnectionSettings); BrokerUri = connectionUri; _clientIdGenerator = clientIdGenerator; SetTransport(transport); _info = new ConnectionInfo { ConnectionId = new ConnectionId { Value = ConnectionIdGenerator.GenerateId() }, Host = BrokerUri.Host, UserName = _stompConnectionSettings.UserName, Password = _stompConnectionSettings.Password }; MessageTransformation = new StompMessageTransformation(this); }
private void OnConfiguring(ContextBuilder builder) { var subscriptionStore = this.SubscriptionStore ?? new LocalSubscriptionStore(); var subscriptionBroker = this.SubscriptionBroker ?? new LocalSubscriptionBroker(); var subscriptionManager = new SubscriptionManager(subscriptionStore, subscriptionBroker); this.TransportFactory = this.TransportFactory ?? new LocalTransportFactory(); var transport = this.TransportFactory.CreateOutboundTransport(); builder.SubscriptionManager = new Lazy <ISubscriptionManager>(() => subscriptionManager); builder.MessageBus = new Lazy <IMessageBus>( () => new MessageBus(subscriptionManager, transport, builder.LoggerFactory.Value)); builder.Processors = new Lazy <IEnumerable <IProcessor> >( () => this.processorConfigurators .Select(p => p.Configure(subscriptionManager, this.TransportFactory, builder.LoggerFactory.Value, builder.Resolver.Value)).ToArray()); }
private static HttpConnection CreateConnection( HttpMessageHandler httpHandler = null, ILoggerFactory loggerFactory = null, string url = null, ITransport transport = null, ITransportFactory transportFactory = null, HttpTransportType?transportType = null, Func <Task <string> > accessTokenFactory = null) { var httpOptions = new HttpConnectionOptions { Transports = transportType ?? HttpTransportType.LongPolling, HttpMessageHandlerFactory = (httpMessageHandler) => httpHandler ?? TestHttpMessageHandler.CreateDefault(), AccessTokenFactory = accessTokenFactory, }; if (url != null) { httpOptions.Url = new Uri(url); } return(CreateConnection(httpOptions, loggerFactory, transport, transportFactory)); }
public MTProtoConnection(TransportConfig transportConfig, [NotNull] ITransportFactory transportFactory, [NotNull] TLRig tlRig, [NotNull] IMessageIdGenerator messageIdGenerator, [NotNull] IHashServices hashServices, [NotNull] IEncryptionServices encryptionServices) { Argument.IsNotNull(() => transportFactory); Argument.IsNotNull(() => tlRig); Argument.IsNotNull(() => messageIdGenerator); Argument.IsNotNull(() => hashServices); Argument.IsNotNull(() => encryptionServices); _transportFactory = transportFactory; _tlRig = tlRig; _messageIdGenerator = messageIdGenerator; _hashServices = hashServices; _encryptionServices = encryptionServices; DefaultRpcTimeout = Defaults.RpcTimeout; DefaultConnectTimeout = Defaults.ConnectTimeout; _tlRig.PrepareSerializersForAllTLObjectsInAssembly(typeof(ITLAsyncMethods).GetAssemblyEx()); _sessionId = GetNextSessionId(); // Init transport. _transport = _transportFactory.CreateTransport(transportConfig); // History of messages in/out. _inMessages.ObserveOn(DefaultScheduler.Instance).Subscribe(_inMessagesHistory); _outMessages.ObserveOn(DefaultScheduler.Instance).Subscribe(_outMessagesHistory); // Connector in/out. _transport.ObserveOn(DefaultScheduler.Instance).Do(bytes => LogMessageInOut(bytes, "IN")).Subscribe(ProcessIncomingMessageBytes); _outMessages.ObserveOn(DefaultScheduler.Instance) .Do(message => LogMessageInOut(message.MessageBytes, "OUT")) .Subscribe(message => _transport.Send(message.MessageBytes)); _inMessages.ObserveOn(DefaultScheduler.Instance).Subscribe(ProcessIncomingMessage); }
static Application ConfigureApplication() { Application app; ITransportFactory transportFactory = null; string company = "lime"; if (company == "uber") { transportFactory = new UberTransport(); } else if (company == "ninenine") { transportFactory = new NineNineTransport(); } else if (company == "lime") { transportFactory = new LimeTransport(); } app = new Application(transportFactory); return(app); }
static IDuplexTransport DefaultTransportFactory(ITransportFactory transportFactory, ITransportSettings settings) { return(transportFactory.BuildLoopback(settings)); }
public void Setup() { this.factory = CreateFactory(); this.OnSetUp(); }
public SwimNode(ILogger <SwimNode> logger, IMediator mediator, ITransportFactory transportFactory) { this.logger = logger; this.mediator = mediator; this.transportFactory = transportFactory; }
public void AddTransportFactory(ITransportFactory factory) { string scheme = factory.Scheme.ToLowerInvariant(); _transportFactories[scheme] = factory; }
static IOutboundTransport DefaultErrorTransportFactory(ITransportFactory transportFactory, ITransportSettings settings) { return transportFactory.BuildError(settings); }
//List<Thread> client_threads; public ThreadedServer(Protocol.IProcessorFactory processorFactory, ITransportFactory transportFactory) : base(processorFactory, transportFactory) { //client_threads = new List<Thread>(); }
public SimpleServer(Protocol.IProcessorFactory processorFactory, ITransportFactory transportFactory) : base(processorFactory, transportFactory) { }
/// <summary> /// Creates a new WampSession by invoking the create method on the provided factory then asynchronously connects /// Equivalent to:<br> /// <code> /// var session = new WampSession(factory.Create()); /// await session.ConnectAsync(url); /// </code> /// </br> /// </summary> /// <param name="url"></param> /// <param name="factory"></param> /// <returns></returns> public static Task<WampSession> ConnectAsync(string url, ITransportFactory factory) { return ConnectAsync(url, () => factory.Create()); }
public Application(ITransportFactory factory) { _aircraft = factory.CreateTransportAircraft(); _landvehicle = factory.CreateTransportVehicle(); }
public void AddTransportFactory(ITransportFactory factory) { _endpointFactory.AddTransportFactory(factory); }
internal WeatherShieldDeviceFactory(ILogger logger, ITransportFactory transportFactory, ITelemetryFactory telemetryFactory, IConfigurationProvider configurationProvider, InitialDeviceConfig config) { }
public CoolerDevice(ILogger logger, ITransportFactory transportFactory, ITelemetryFactory telemetryFactory, IConfigurationProvider configurationProvider) : base(logger, transportFactory, telemetryFactory, configurationProvider) { }
public CourierBuilder UseTransport(ITransportFactory transportFactory) { this.transportFactories.TryAdd(transportFactory); return this; }
public MessageBusFactory(ITransportFactory transportFactory) { _transportFactory = transportFactory; }
static IOutboundTransport DefaultErrorTransportFactory(ITransportFactory transportFactory, ITransportSettings settings) { return(transportFactory.BuildError(settings)); }
public EngineDevice(ILogger logger, ITransportFactory transportFactory, ITelemetryFactory telemetryFactory, IConfigurationProvider configurationProvider) : base(logger, transportFactory, telemetryFactory, configurationProvider) { }
public ClientChannelPreheating(IOptions <RemoteServicesOption> options, ITransportFactory <TMessage> factory) { this._factory = factory; this._options = options; }
public BaseServer(Protocol.IProcessorFactory processorFactory, ITransportFactory transportFactory) { this.processorFactory = processorFactory; this.transportFactory = transportFactory; }
public KestrelServer(IOptions <KestrelServerOptions> options, ITransportFactory transportFactory, ILoggerFactory loggerFactory) : this(transportFactory, CreateServiceContext(options, loggerFactory)) { }
public static ITransport CompositeConnect(Uri location) { ITransportFactory tf = TransportFactory.CreateTransportFactory(location); return(tf.CompositeConnect(location)); }
static IDuplexTransport DefaultTransportFactory(ITransportFactory transportFactory, ITransportSettings settings) { return transportFactory.BuildLoopback(settings); }