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 SimpleServer(Protocol.IProcessorFactory processorFactory, ITransportFactory transportFactory) :
base(processorFactory, transportFactory)
{
}
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 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))
{
}
//List<Thread> client_threads;
public ThreadedServer(Protocol.IProcessorFactory processorFactory, ITransportFactory transportFactory)
: base(processorFactory, transportFactory)
{
//client_threads = new List<Thread>();
}
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);
}
