public WsnProtocolAdapter(PiraeusConfig config, GraphManager graphManager, IChannel channel, HttpContext context, ILog logger = null) { this.config = config; this.graphManager = graphManager; this.Channel = channel; this.logger = logger; IdentityDecoder decoder = new IdentityDecoder(config.ClientIdentityNameClaimType, context, config.GetClientIndexes()); identity = decoder.Id; localIndexes = decoder.Indexes; MessageUri messageUri = new MessageUri(context.Request); this.contentType = messageUri.ContentType; this.cacheKey = messageUri.CacheKey; this.resource = messageUri.Resource; this.subscriptions = messageUri.Subscriptions != null ? new List <string>(messageUri.Subscriptions) : null; this.indexes = messageUri.Indexes != null ? new List <KeyValuePair <string, string> >(messageUri.Indexes) : null; auditFactory = AuditFactory.CreateSingleton(); if (config.AuditConnectionString != null && config.AuditConnectionString.Contains("DefaultEndpointsProtocol")) { auditFactory.Add(new AzureTableAuditor(config.AuditConnectionString, "messageaudit"), AuditType.Message); auditFactory.Add(new AzureTableAuditor(config.AuditConnectionString, "useraudit"), AuditType.User); } else if (config.AuditConnectionString != null) { auditFactory.Add(new FileAuditor(config.AuditConnectionString), AuditType.Message); auditFactory.Add(new FileAuditor(config.AuditConnectionString), AuditType.User); } messageAuditor = auditFactory.GetAuditor(AuditType.Message); userAuditor = auditFactory.GetAuditor(AuditType.User); }
private static IHostBuilder CreateHostBuilder(string[] args) => Host.CreateDefaultBuilder(args) .ConfigureWebHost((options) => { options.UseStartup <Startup>(); options.UseKestrel(); options.ConfigureKestrel(options => { PiraeusConfig config = GetPiraeusConfig(); options.Limits.MaxConcurrentConnections = config.MaxConnections; options.Limits.MaxConcurrentUpgradedConnections = config.MaxConnections; options.Limits.MaxRequestBodySize = config.MaxBufferSize; options.Limits.MinRequestBodyDataRate = new MinDataRate(bytesPerSecond: 100, gracePeriod: TimeSpan.FromSeconds(10)); options.Limits.MinResponseDataRate = new MinDataRate(bytesPerSecond: 100, gracePeriod: TimeSpan.FromSeconds(10)); if (!string.IsNullOrEmpty(config.ServerCertificateFilename)) { Console.WriteLine("Port for cert with filename"); options.ListenAnyIP(config.GetPorts()[0], (a) => a.UseHttps(config.ServerCertificateFilename, config.ServerCertificatePassword)); } else if (!string.IsNullOrEmpty(config.ServerCertificateStore)) { Console.WriteLine("Port for cert with store"); X509Certificate2 cert = config.GetServerCerticate(); options.ListenAnyIP(config.GetPorts()[0], (a) => a.UseHttps(cert)); } else { Console.WriteLine("Hard coded port 8081"); options.ListenAnyIP(8081); } }); });
private void InitializeAuditor(PiraeusConfig config) { if (!string.IsNullOrEmpty(config.AuditConnectionString) && AuditFactory.CreateSingleton().GetAuditor(AuditType.User) == null) { auditFactory = AuditFactory.CreateSingleton(); if (config.AuditConnectionString.ToLowerInvariant().Contains("AccountName=")) { auditFactory.Add(new AzureTableAuditor(config.AuditConnectionString, "messageaudit"), AuditType.Message); auditFactory.Add(new AzureTableAuditor(config.AuditConnectionString, "useraudit"), AuditType.User); } else { string pathString = config.AuditConnectionString.LastIndexOf("/") == config.AuditConnectionString.Length - 1 ? config.AuditConnectionString : config.AuditConnectionString + "/"; auditFactory.Add(new FileAuditor(string.Format($"{pathString}messageaudit.txt")), AuditType.Message); auditFactory.Add(new FileAuditor(string.Format($"{pathString}useraudit.txt")), AuditType.User); } } }
public static ILoggingBuilder AddLogging(this ILoggingBuilder builder, PiraeusConfig config) { LoggerType loggerTypes = config.GetLoggerTypes(); //if (loggerTypes.HasFlag(LoggerType.None)) //{ // return builder; //} LogLevel logLevel = Enum.Parse <LogLevel>(config.LogLevel, true); if (loggerTypes.HasFlag(LoggerType.Console)) { builder.AddConsole(); } if (loggerTypes.HasFlag(LoggerType.Debug)) { builder.AddDebug(); } builder.SetMinimumLevel(logLevel); return(builder); }
public CoapProtocolAdapter(PiraeusConfig config, IAuthenticator authenticator, IChannel channel, ILogger logger, HttpContext context = null) { this.context = context; this.logger = logger; CoapConfigOptions options = config.ObserveOption && config.NoResponseOption ? CoapConfigOptions.Observe | CoapConfigOptions.NoResponse : config.ObserveOption ? CoapConfigOptions.Observe : config.NoResponseOption ? CoapConfigOptions.NoResponse : CoapConfigOptions.None; CoapConfig coapConfig = new CoapConfig(authenticator, config.CoapAuthority, options, config.AutoRetry, config.KeepAliveSeconds, config.AckTimeoutSeconds, config.AckRandomFactor, config.MaxRetransmit, config.NStart, config.DefaultLeisure, config.ProbingRate, config.MaxLatencySeconds); coapConfig.IdentityClaimType = config.ClientIdentityNameClaimType; coapConfig.Indexes = config.GetClientIndexes(); InitializeAuditor(config); Channel = channel; Channel.OnClose += Channel_OnClose; Channel.OnError += Channel_OnError; Channel.OnOpen += Channel_OnOpen; Channel.OnReceive += Channel_OnReceive; Channel.OnStateChange += Channel_OnStateChange; session = new CoapSession(coapConfig, context); if (Channel.State != ChannelState.Open) { Channel.OpenAsync().GetAwaiter(); Channel.ReceiveAsync(); } }
public HttpResponseMessage Get() { try { SkunkLab.Security.Authentication.BasicAuthenticator authn = new SkunkLab.Security.Authentication.BasicAuthenticator(); HttpContext context = HttpContext.Current; if (context.IsWebSocketRequest || context.IsWebSocketRequestUpgrading) { PiraeusConfig config = Piraeus.Configuration.PiraeusConfigManager.Settings; adapter = ProtocolAdapterFactory.Create(config, Request, source.Token); adapter.OnClose += Adapter_OnClose; adapter.OnError += Adapter_OnError; adapter.Init(); return(new HttpResponseMessage(HttpStatusCode.SwitchingProtocols)); } else //long polling { adapter = ProtocolAdapterFactory.Create(config, Request, source.Token); adapter.OnObserve += Adapter_OnObserve; adapter.Init(); ThreadPool.QueueUserWorkItem(new WaitCallback(Listen), waitHandles[0]); WaitHandle.WaitAll(waitHandles); return(response); } } catch (Exception ex) { return(Request.CreateErrorResponse(HttpStatusCode.InternalServerError, ex)); } }
public void ConfigureServices(IServiceCollection services) { pconfig = GetPiraeusConfig(); config = GetOrleansConfig(); //services.AddMvc().SetCompatibilityVersion(CompatibilityVersion.Version_2_2); services.AddAuthentication(JwtBearerDefaults.AuthenticationScheme) .AddJwtBearer(options => { options.TokenValidationParameters = new TokenValidationParameters { ValidateIssuer = !string.IsNullOrEmpty(pconfig.ClientIssuer), ValidateAudience = !string.IsNullOrEmpty(pconfig.ClientAudience), ValidateLifetime = true, ValidateIssuerSigningKey = true, ValidIssuer = pconfig.ClientIssuer, ValidAudience = pconfig.ClientAudience, ClockSkew = TimeSpan.FromMinutes(5.0), IssuerSigningKey = new SymmetricSecurityKey(Convert.FromBase64String(pconfig.ClientSymmetricKey)) }; }); services.AddSingleton <PiraeusConfig>(pconfig); services.AddSingleton <IClusterClient>(CreateClusterClient); services.AddSingleton <IHttpContextAccessor, HttpContextAccessor>(); //services.AddPiraeusWebSocket(); services.AddRouting(); services.AddMvcCore(); }
private static IWebHostBuilder CreateWebHostBuilder(string[] args) => WebHost.CreateDefaultBuilder(args) .UseStartup <Startup>() .UseKestrel(options => { PiraeusConfig config = GetPiraeusConfig(); options.Limits.MaxConcurrentConnections = config.MaxConnections; options.Limits.MaxConcurrentUpgradedConnections = config.MaxConnections; options.Limits.MaxRequestBodySize = config.MaxBufferSize; options.Limits.MinRequestBodyDataRate = new MinDataRate(bytesPerSecond: 100, gracePeriod: TimeSpan.FromSeconds(10)); options.Limits.MinResponseDataRate = new MinDataRate(bytesPerSecond: 100, gracePeriod: TimeSpan.FromSeconds(10)); X509Certificate2 cert = config.GetServerCerticate(); int[] ports = config.GetPorts(); foreach (int port in ports) { if (cert != null) { options.ListenAnyIP(port, (a) => a.UseHttps(cert)); } else { options.ListenAnyIP(port); } } });
public ManageController(PiraeusConfig config, IClusterClient client) { this.config = config; if (!GraphManager.IsInitialized) { GraphManager.Initialize(client); } }
public UdpGatewayHost(PiraeusConfig config, OrleansConfig orleansConfig, Logger logger) { this.config = config; this.orleansConfig = orleansConfig; this.logger = logger; sources = new Dictionary <int, CancellationTokenSource>(); listeners = new Dictionary <int, UdpServerListener>(); }
public PiraeusHttpMiddleware(RequestDelegate next, PiraeusConfig config, IClusterClient client) { _next = next; this.config = config; if (!GraphManager.IsInitialized) { GraphManager.Initialize(client); } }
public PiraeusWebSocketMiddleware(RequestDelegate next, PiraeusConfig config, IClusterClient client, Logger logger, IOptions <WebSocketOptions> options) { container = new Dictionary <string, ProtocolAdapter>(); _next = next; _options = options.Value; this.config = config; this.graphManager = new GraphManager(client); this.logger = logger; }
public TcpGatewayService(PiraeusConfig piraeusConfig, IClusterClient clusterClient, ILogger <TcpGatewayService> logger = null) { this.config = piraeusConfig; this.clusterClient = clusterClient; this.logger = logger; if (!GraphManager.IsInitialized) { GraphManager.Initialize(this.clusterClient); } }
public static IConfigurationBuilder AddPiraeusConfiguration(this IConfigurationBuilder configure, out PiraeusConfig piraeusConfig) { configure.AddJsonFile("./piraeusconfig.json") .AddEnvironmentVariables("PI_"); IConfigurationRoot root = configure.Build(); piraeusConfig = new PiraeusConfig(); ConfigurationBinder.Bind(root, piraeusConfig); return(configure); }
public PiraeusWebSocketMiddleware(RequestDelegate next, PiraeusConfig config, IClusterClient client, IOptions <WebSocketOptions> options) { _next = next; _options = options.Value; this.config = config; if (!GraphManager.IsInitialized) { GraphManager.Initialize(client); } }
public ConnectController(PiraeusConfig config, IClusterClient client, ILogger logger) { this.config = config; BasicAuthenticator basicAuthn = new BasicAuthenticator(); SkunkLab.Security.Tokens.SecurityTokenType tokenType = Enum.Parse <SkunkLab.Security.Tokens.SecurityTokenType>(config.ClientTokenType, true); basicAuthn.Add(tokenType, config.ClientSymmetricKey, config.ClientIssuer, config.ClientAudience); authn = basicAuthn; this.graphManager = new GraphManager(client); this.logger = logger; }
public static ProtocolAdapter Create(PiraeusConfig config, GraphManager graphManager, IAuthenticator authenticator, TcpClient client, ILog logger = null, CancellationToken token = default) { TlsPskIdentityManager pskManager = null; if (!string.IsNullOrEmpty(config.PskStorageType)) { if (config.PskStorageType.ToLowerInvariant() == "redis") { pskManager = TlsPskIdentityManagerFactory.Create(config.PskRedisConnectionString); } if (config.PskStorageType.ToLowerInvariant() == "keyvault") { pskManager = TlsPskIdentityManagerFactory.Create(config.PskKeyVaultAuthority, config.PskKeyVaultClientId, config.PskKeyVaultClientSecret); } if (config.PskStorageType.ToLowerInvariant() == "environmentvariable") { pskManager = TlsPskIdentityManagerFactory.Create(config.PskIdentities, config.PskKeys); } } IChannel channel; if (pskManager != null) { channel = ChannelFactory.Create(config.UsePrefixLength, client, pskManager, config.BlockSize, config.MaxBufferSize, token); } else { channel = ChannelFactory.Create(config.UsePrefixLength, client, config.BlockSize, config.MaxBufferSize, token); } IPEndPoint localEP = (IPEndPoint)client.Client.LocalEndPoint; int port = localEP.Port; if (port == 5684) { return(new CoapProtocolAdapter(config, graphManager, authenticator, channel, logger)); } if (port == 1883 || port == 8883) { return(new MqttProtocolAdapter(config, graphManager, authenticator, channel, logger)); } throw new ProtocolAdapterPortException("TcpClient port does not map to a supported protocol."); }
private static PiraeusConfig GetPiraeusConfig() { var builder = new ConfigurationBuilder() .AddJsonFile(Environment.CurrentDirectory + "\\piraeusconfig.json") .AddEnvironmentVariables("PI_"); IConfigurationRoot root = builder.Build(); PiraeusConfig config = new PiraeusConfig(); ConfigurationBinder.Bind(root, config); return(config); }
internal static PiraeusConfig GetPiraeusConfig() { var builder = new ConfigurationBuilder() .AddJsonFile("./piraeusconfig.json") .AddEnvironmentVariables("PI_"); IConfigurationRoot root = builder.Build(); PiraeusConfig config = new PiraeusConfig(); root.Bind(config); return(config); }
private PiraeusConfig GetPiraeusConfig() { var builder = new ConfigurationBuilder() .AddJsonFile("./piraeusconfig.json") .AddEnvironmentVariables("PI_"); IConfigurationRoot root = builder.Build(); PiraeusConfig pc = new PiraeusConfig(); ConfigurationBinder.Bind(root, pc); return(pc); }
public CoapRequestDispatcher(CoapSession session, IChannel channel, PiraeusConfig config, GraphManager graphManager, ILog logger = null) { this.channel = channel; this.session = session; this.config = config; this.graphManager = graphManager; this.logger = logger; auditor = AuditFactory.CreateSingleton().GetAuditor(AuditType.Message); coapObserved = new Dictionary <string, byte[]>(); coapUnobserved = new HashSet <string>(); adapter = new OrleansAdapter(session.Identity, channel.TypeId, "CoAP", graphManager, logger); adapter.OnObserve += Adapter_OnObserve; LoadDurablesAsync().LogExceptions(logger); }
public UdpServerListener(PiraeusConfig config, IPEndPoint localEP, CancellationToken token) { this.config = config; this.localEP = localEP; this.token = token; cache = new Dictionary <string, Tuple <ProtocolAdapter, CancellationTokenSource> >(); container = new Dictionary <string, string>(); SecurityTokenType stt = System.Enum.Parse <SecurityTokenType>(config.ClientTokenType, true); BasicAuthenticator bauthn = new BasicAuthenticator(); bauthn.Add(stt, config.ClientSymmetricKey, config.ClientIssuer, config.ClientAudience); authn = bauthn; }
public static IServiceCollection AddPiraeusConfiguration(this IServiceCollection services) { IConfigurationBuilder builder = new ConfigurationBuilder(); builder.AddJsonFile(Environment.CurrentDirectory + "\\piraeusconfig.json") .AddEnvironmentVariables("PI_"); IConfigurationRoot root = builder.Build(); PiraeusConfig config = new PiraeusConfig(); ConfigurationBinder.Bind(root, config); services.AddSingleton <PiraeusConfig>(config); return(services); }
public void ConfigureServices(IServiceCollection services) { OrleansConfig oconfig = null; PiraeusConfig pconfig = null; //LoggerFactory loggerFactory = new LoggerFactory(); IConfigurationBuilder configBuilder = new ConfigurationBuilder(); configBuilder.AddOrleansConfiguration(out oconfig); configBuilder.AddPiraeusConfiguration(out pconfig); PiraeusGatewayOptions pgo = new PiraeusGatewayOptions(oconfig); //services.AddGatewayService(typeof(TcpGatewayService), null); //services.AddOrleansConfiguration(); //services.AddPiraeusConfiguration(); //services.AddOrleansClusterClient(loggerFactory, options => options.IsLocal = false); IServiceProvider sp = services.BuildServiceProvider(); LoggerType loggerType = oconfig.GetLoggerTypes(); if (!loggerType.HasFlag(LoggerType.None)) { services.AddLogging(builder => { if (loggerType.HasFlag(LoggerType.Console)) { builder.AddConsole(); } if (loggerType.HasFlag(LoggerType.Debug)) { builder.AddDebug(); } if (loggerType.HasFlag(LoggerType.AppInsights) && !string.IsNullOrEmpty(oconfig.AppInsightsKey)) { builder.AddApplicationInsights(oconfig.AppInsightsKey); } builder.SetMinimumLevel(LogLevel.Warning); }); } TcpGatewayService tgs = sp.GetRequiredService <TcpGatewayService>(); tgs.Init(oconfig.Dockerized); //services.AddSingleton<TcpGatewayService>((f) => f.GetRequiredService<TcpGatewayService>()); }
public ConnectController(PiraeusConfig config, IClusterClient client) { this.config = config; BasicAuthenticator basicAuthn = new BasicAuthenticator(); SkunkLab.Security.Tokens.SecurityTokenType tokenType = Enum.Parse<SkunkLab.Security.Tokens.SecurityTokenType>(config.ClientTokenType, true); basicAuthn.Add(tokenType, config.ClientSymmetricKey, config.ClientIssuer, config.ClientAudience); authn = basicAuthn; if (!GraphManager.IsInitialized) { GraphManager.Initialize(client); } }
public static IServiceCollection AddPiraeusConfiguration(this IServiceCollection services, out PiraeusConfig config) { IConfigurationBuilder builder = new ConfigurationBuilder(); builder.AddJsonFile("./piraeusconfig.json") .AddEnvironmentVariables("PI_"); IConfigurationRoot root = builder.Build(); config = new PiraeusConfig(); root.Bind(config); services.AddSingleton(config); return(services); }
public static IHostBuilder CreateHostBuilder(string[] args) { return(Host.CreateDefaultBuilder(args) .ConfigureServices(services => services.AddPiraeusConfiguration()) .ConfigureWebHostDefaults(webBuilder => { PiraeusConfig config = WebApiHelpers.GetPiraeusConfig(); webBuilder .ConfigureKestrel(options => { options.Limits.MaxConcurrentConnections = config.MaxConnections; options.Limits.MaxConcurrentUpgradedConnections = config.MaxConnections; options.Limits.MaxRequestBodySize = config.MaxBufferSize; options.Limits.MinRequestBodyDataRate = new MinDataRate(100, TimeSpan.FromSeconds(10)); options.Limits.MinResponseDataRate = new MinDataRate(100, TimeSpan.FromSeconds(10)); X509Certificate2 cert = config.GetServerCerticate(); int[] ports = config.GetPorts(); foreach (int port in ports) { if (cert != null) { options.ListenAnyIP(port, a => a.UseHttps(cert)); } else { IPAddress address = GetIPAddress(Dns.GetHostName()); options.Listen(address, port); } } if (!string.IsNullOrEmpty(config.ServerCertificateFilename)) { string[] portStrings = config.Ports.Split(";", StringSplitOptions.RemoveEmptyEntries); foreach (string portString in portStrings) { options.ListenAnyIP(Convert.ToInt32(portString), a => a.UseHttps(config.ServerCertificateFilename, config.ServerCertificatePassword)); } } }); webBuilder.UseStartup <Startup>(); })); }
/// <summary> /// Create protocol adapter for rest service or Web socket /// </summary> /// <param name="config"></param> /// <param name="request"></param> /// <param name="token"></param> /// <param name="authenticator"></param> /// <returns></returns> public static ProtocolAdapter Create(PiraeusConfig config, HttpContext context, ILogger logger = null, IAuthenticator authenticator = null, CancellationToken token = default(CancellationToken)) { IChannel channel = null; //HttpContext context = HttpContext.Current; //if (context.IsWebSocketRequest || // context.IsWebSocketRequestUpgrading) //if (HttpHelper.HttpContext.WebSockets.IsWebSocketRequest) if (context.WebSockets.IsWebSocketRequest) { //WebSocketConfig webSocketConfig = GetWebSocketConfig(config); WebSocketConfig webSocketConfig = new WebSocketConfig(config.MaxBufferSize, config.BlockSize, config.BlockSize); channel = ChannelFactory.Create(context, webSocketConfig, token); //channel = ChannelFactory.Create(request, webSocketConfig, token); //if (context.WebSocketRequestedProtocols.Contains("mqtt")) if (context.WebSockets.WebSocketRequestedProtocols.Contains("mqtt")) { return(new MqttProtocolAdapter(config, authenticator, channel, logger)); } else if (context.WebSockets.WebSocketRequestedProtocols.Contains("coapv1")) //(context.WebSocketRequestedProtocols.Contains("coapv1")) { return(new CoapProtocolAdapter(config, authenticator, channel, logger)); } //else if (context.WebSocketRequestedProtocols.Count == 0) //{ // //wsn protocol // //return new WsnProtocolAdapter(config, channel); //} else { throw new InvalidOperationException("invalid web socket subprotocol"); } } //if (request.Method != HttpMethod.Post && request.Method != HttpMethod.Get) if (context.Request.Method.ToUpperInvariant() != "POST" && context.Request.Method.ToUpperInvariant() != "GET") { throw new HttpRequestException("Protocol adapter requires HTTP get or post."); } else { //channel = ChannelFactory.Create(request); channel = ChannelFactory.Create(context); return(new RestProtocolAdapter(config, channel, context, logger)); } }
private void InitializeAuditor(PiraeusConfig config) { auditFactory = AuditFactory.CreateSingleton(); if (config.AuditConnectionString != null && config.AuditConnectionString.Contains("DefaultEndpointsProtocol")) { auditFactory.Add(new AzureTableAuditor(config.AuditConnectionString), AuditType.Message); auditFactory.Add(new AzureTableAuditor(config.AuditConnectionString), AuditType.User); } else if (config.AuditConnectionString != null) { auditFactory.Add(new FileAuditor(config.AuditConnectionString), AuditType.Message); auditFactory.Add(new FileAuditor(config.AuditConnectionString), AuditType.User); } userAuditor = auditFactory.GetAuditor(AuditType.User); }
public static IWebHostBuilder CreateWebHostBuilder(string[] args) => WebHost.CreateDefaultBuilder(args) .UseStartup <Startup>() .UseKestrel(options => { PiraeusConfig config = GetPiraeusConfig(); options.Limits.MaxConcurrentConnections = config.MaxConnections; options.Limits.MaxConcurrentUpgradedConnections = config.MaxConnections; options.Limits.MaxRequestBodySize = config.MaxBufferSize; options.Limits.MinRequestBodyDataRate = new MinDataRate(bytesPerSecond: 100, gracePeriod: TimeSpan.FromSeconds(10)); options.Limits.MinResponseDataRate = new MinDataRate(bytesPerSecond: 100, gracePeriod: TimeSpan.FromSeconds(10)); X509Certificate2 cert = config.GetServerCerticate(); int[] ports = config.GetPorts(); foreach (int port in ports) { if (cert != null) { options.ListenAnyIP(port, (a) => a.UseHttps(cert)); } else { IPAddress address = GetIPAddress(Dns.GetHostName()); options.Listen(address, port); //options.Listen(IPAddress.Loopback, port); //options.ListenAnyIP(port); } } if (!string.IsNullOrEmpty(config.ServerCertificateFilename)) { string[] portStrings = config.Ports.Split(";", StringSplitOptions.RemoveEmptyEntries); foreach (var portString in portStrings) { options.ListenAnyIP(Convert.ToInt32(portString), (a) => a.UseHttps(config.ServerCertificateFilename, config.ServerCertificatePassword)); } } //else //{ // options.ListenAnyIP(config.Channels.Http.ListenPort, (a) => a.UseHttps(".\\localhost.pfx", "pass@word1")); //} });