protected override ITransportServer CreateTransport(KeyValueCollection parameters) { var queueServerName = parameters["QueueServerName"]; var enableGetDescriptors = parameters["EnableGetDescriptors"].ParseTo(true); var serializerMimeType = parameters["SerializerMimeType"]; var compressorEncoding = parameters["CompressorEncoding"]; var serializer = SerializerManager.GetByMimeType(serializerMimeType); if (serializer != null && compressorEncoding.IsNotNullOrEmpty()) { var compressor = CompressorManager.GetByEncodingType(compressorEncoding); if (compressor != null) { serializer.Compressor = compressor; } } Core.Log.LibDebug("Creating a new MessagingTransportServer with the parameters:"); Core.Log.LibDebug("\tQueueServerName: {0}", queueServerName.IsNotNullOrWhitespace() ? queueServerName : "Using Default QueueServer from configuration file."); Core.Log.LibDebug("\tEnableGetDescriptors: {0}", enableGetDescriptors); if (serializerMimeType != null) { Core.Log.LibDebug("\tSerializer: {0}", serializer); if (serializer?.Compressor != null) { Core.Log.LibDebug("\tCompressorEncoding: {0}", compressorEncoding); } } var queueServer = queueServerName.IsNotNullOrWhitespace() ? Core.Services.GetQueueServer(queueServerName) : Core.Services.GetQueueServer(); return(new MessagingTransportServer(queueServer, serializer)); }
/// <inheritdoc /> /// <summary> /// Create a new storage from a KeyValueCollection parameters /// </summary> /// <param name="parameters">Parameters to create the storage</param> /// <returns>Storage</returns> protected override StorageBase CreateStorage(KeyValueCollection parameters) { var basePath = parameters["BasePath"]; var indexSerializerMimeType = parameters["IndexSerializerMimeType"] ?? SerializerMimeTypes.WBinary; var numberOfSubFolder = parameters["NumberOfSubFolder"].ParseTo((byte)25); var transactionLogThreshold = parameters["TransactionLogThreshold"].ParseTo(250); var slowDownWriteThreshold = parameters["SlowDownWriteThreshold"].ParseTo(1000); var storageType = parameters["StorageType"].ParseTo(FileStorageType.Normal); var indexSerializer = SerializerManager.GetByMimeType <ISerializer>(indexSerializerMimeType); SerializerManager.SupressFileExtensionWarning = true; switch (storageType) { case FileStorageType.Normal: Core.Log.LibDebug("Creating a new FileStorage with the parameters:"); Core.Log.LibDebug("\tBasePath: {0}", basePath); Core.Log.LibDebug("\tNumberOfSubFolders: {0}", numberOfSubFolder); Core.Log.LibDebug("\tTransactionLogThreshold: {0}", transactionLogThreshold); Core.Log.LibDebug("\tSlowDownWriteThreshold: {0}", slowDownWriteThreshold); Core.Log.LibDebug("\tIndexSerializer: {0}", indexSerializer); return(new FileStorage(basePath) { NumberOfSubFolders = numberOfSubFolder, TransactionLogThreshold = transactionLogThreshold, SlowDownWriteThreshold = slowDownWriteThreshold, IndexSerializer = (BinarySerializer)indexSerializer }); } return(null); }
public void Init(MQPairConfig config, bool sendOnly) { if (config is null) { return; } Config = config; SendOnly = sendOnly; Name = Config.Name; Counters = new MQClientCounters(Name, Config.IgnoreClientCounters); SenderSerializer = SerializerManager.GetByMimeType(Config.RequestOptions?.SerializerMimeType); if (SenderSerializer != null && Config.RequestOptions?.CompressorEncodingType.IsNotNullOrEmpty() == true) { SenderSerializer.Compressor = CompressorManager.GetByEncodingType(Config.RequestOptions?.CompressorEncodingType); } ReceiverSerializer = SerializerManager.GetByMimeType(Config.ResponseOptions?.SerializerMimeType); if (ReceiverSerializer != null && Config.ResponseOptions?.CompressorEncodingType.IsNotNullOrEmpty() == true) { ReceiverSerializer.Compressor = CompressorManager.GetByEncodingType(Config.ResponseOptions?.CompressorEncodingType); } OnInit(); }
/// <summary> /// Adds all defined routes on a HttpController type /// </summary> /// <typeparam name="T">Type of HttpControllerBase</typeparam> /// <returns>SimpleHttpServer instance</returns> public SimpleHttpServer AddHttpControllerRoutes <T>() where T : HttpControllerBase { var type = typeof(T); var methods = type.GetRuntimeMethods(); methods.Each(m => { var routes = m.GetCustomAttributes <HttpRouteAttribute>().ToArray(); if (routes?.Any() == true) { routes.Each(route => AddRouteHandler(route.Method, route.Url, context => { var ctl = Activator.CreateInstance <T>(); ctl.Context = context; var mParams = m.GetParameters(); if (mParams.Length > 0) { ParameterInfo postObjectParam = null; object postObject = null; var ivkParams = new List <object>(); if (context.Request.HasPostObject) { postObjectParam = mParams.FirstOrDefault(p => p.GetCustomAttribute(typeof(PostObjectAttribute)) != null); if (postObjectParam == null && mParams.Length == 1) { postObjectParam = mParams[0]; } if (postObjectParam != null) { postObject = Try.Do(() => context.Request.GetPostObject(postObjectParam.ParameterType)); } } var dictionary = context.Route.GetRouteParameters(context.Request.Url.AbsolutePath); foreach (var mParam in mParams) { if (mParam == postObjectParam) { ivkParams.Add(postObject); } else if (dictionary.ContainsKey(mParam.Name)) { ivkParams.Add(dictionary[mParam.Name]); } else { ivkParams.Add(null); } } var response = m.Invoke(ctl, ivkParams.ToArray()); if (response == null) { return; } var serializer = SerializerManager.GetByMimeType(ctl.Context.Response.ContentType); switch (serializer) { case null when response is string: ctl.Context.Response.Write((string)response); break;
protected override ITransportClient CreateTransport(KeyValueCollection parameters) { var queueClientName = parameters["QueueClientName"]; var serializerMimeType = parameters["SerializerMimeType"]; var compressorEncoding = parameters["CompressorEncoding"]; var serializer = SerializerManager.GetByMimeType(serializerMimeType); if (serializer != null && compressorEncoding.IsNotNullOrEmpty()) { var compressor = CompressorManager.GetByEncodingType(compressorEncoding); if (compressor != null) { serializer.Compressor = compressor; } } Core.Log.LibDebug("Creating a new MessagingTransportServer with the parameters:"); Core.Log.LibDebug("\tQueueClientName: {0}", queueClientName); if (serializerMimeType != null) { Core.Log.LibDebug("\tSerializer: {0}", serializer); if (serializer?.Compressor != null) { Core.Log.LibDebug("\tCompressorEncoding: {0}", compressorEncoding); } } Ensure.ArgumentNotNull(queueClientName, "The QueueClientName parameter in the MessagingTransportClientFactory can't be null."); var queueClient = Core.Services.GetQueueClient(queueClientName); return(new MessagingTransportClient(queueClient, serializer)); }
protected override ITransportClient CreateTransport(KeyValueCollection parameters) { var url = parameters["Url"]; var serializerMimeType = parameters["SerializerMimeType"]; var serializer = SerializerManager.GetByMimeType(serializerMimeType); Core.Log.LibDebug("Creating a new HttpTransportClient with the parameters:"); Core.Log.LibDebug("\tUrl: {0}", url); Core.Log.LibDebug("\tSerializer: {0}", serializer); return(new HttpTransportClient(url, serializer)); }
protected override ITransportClient CreateTransport(KeyValueCollection parameters) { var host = parameters["Host"]; if (host == null || host == Factory.SkipInstanceValue) { Core.Log.Warning("Skipping transport instance by Host value."); return(null); } var strPort = parameters["Port"]; if (strPort == null || strPort == Factory.SkipInstanceValue) { Core.Log.Warning("Skipping transport instance by Port value."); return(null); } var port = strPort.ParseTo(0); var timeout = parameters["Timeout"].ParseTo(20000); var serializerMimeType = parameters["SerializerMimeType"]; var socketsPerClient = parameters["SocketsPerClient"].ParseTo <byte>(1); var compressorEncoding = parameters["CompressorEncoding"]; var serializer = SerializerManager.GetByMimeType(serializerMimeType); if (compressorEncoding.IsNotNullOrEmpty()) { var compressor = CompressorManager.GetByEncodingType(compressorEncoding); if (compressor != null) { serializer.Compressor = compressor; } } var lclient = new DefaultTransportClient(host, port, socketsPerClient, serializer) { InvokeMethodTimeout = timeout }; ITransportClient client = lclient; Core.Log.LibDebug("Creating a new DefaultTransportClient with parameters:"); Core.Log.LibDebug("\tHost: {0}", host); Core.Log.LibDebug("\tPort: {0}", port); Core.Log.LibDebug("\tSocketsPerClient: {0}", socketsPerClient); if (serializerMimeType == null) { return(client); } Core.Log.LibDebug("\tSerializer: {0}", serializer); if (serializer?.Compressor != null) { Core.Log.LibDebug("\tCompressorEncoding: {0}", compressorEncoding); } return(client); }
protected override ITransportServer CreateTransport(KeyValueCollection parameters) { var port = parameters["Port"].ParseTo(0); var enableGetDescriptors = parameters["EnableGetDescriptors"].ParseTo(true); var serializerMimeType = parameters["SerializerMimeType"]; var serializer = SerializerManager.GetByMimeType(serializerMimeType); Core.Log.LibDebug("Creating a new HttpTransportServer with the parameters:"); Core.Log.LibDebug("\tPort: {0}", port); Core.Log.LibDebug("\tEnableGetDescriptors: {0}", enableGetDescriptors); Core.Log.LibDebug("\tSerializer: {0}", serializer); return(new HttpTransportServer(port, serializer, enableGetDescriptors)); }
public RestClient(string baseUrl = null, ISerializer serializer = null) { var handler = new DecompressionHandler { InnerHandler = new HttpClientHandler() }; _client = new HttpClient(handler); if (baseUrl.IsNotNullOrEmpty()) { _client.BaseAddress = new Uri(baseUrl); } Serializer = serializer ?? (SerializerManager.GetByMimeType <ITextSerializer>(SerializerMimeTypes.Json) ?? SerializerManager.DefaultTextSerializer); }
public void Init(MQPairConfig config) { if (config == null) { return; } Config = config; Name = Config.Name; SenderSerializer = SerializerManager.GetByMimeType(Config.RequestOptions?.SerializerMimeType); if (SenderSerializer != null && Config.RequestOptions?.CompressorEncodingType.IsNotNullOrEmpty() == true) { SenderSerializer.Compressor = CompressorManager.GetByEncodingType(Config.RequestOptions?.CompressorEncodingType); } ReceiverSerializer = SerializerManager.GetByMimeType(Config.ResponseOptions?.SerializerMimeType); if (ReceiverSerializer != null && Config.ResponseOptions?.CompressorEncodingType.IsNotNullOrEmpty() == true) { ReceiverSerializer.Compressor = CompressorManager.GetByEncodingType(Config.ResponseOptions?.CompressorEncodingType); } OnInit(); }
protected override ITransportServer CreateTransport(KeyValueCollection parameters) { var strPort = parameters["Port"]; if (strPort == null || strPort == Factory.SkipInstanceValue) { Core.Log.Warning("Skipping transport instance by Port value."); return(null); } var port = strPort.ParseTo(0); var serializerMimeType = parameters["SerializerMimeType"]; var compressorEncoding = parameters["CompressorEncoding"]; var serializer = SerializerManager.GetByMimeType(serializerMimeType); if (compressorEncoding.IsNotNullOrEmpty()) { var compressor = CompressorManager.GetByEncodingType(compressorEncoding); if (compressor != null) { serializer.Compressor = compressor; } } var tServer = new DefaultTransportServer(port, serializer); Core.Log.LibDebug("Creating a new DefaultTransportServer with parameters:"); Core.Log.LibDebug("\tPort: {0}", port); if (serializerMimeType != null) { Core.Log.LibDebug("\tSerializer: {0}", serializer); if (serializer?.Compressor != null) { Core.Log.LibDebug("\tCompressorEncoding: {0}", compressorEncoding); } } return(tServer); }
public void StartListeners() { if (_tokenSource != null) { StopListeners(); } Core.Log.InfoBasic("Configuring server mode for {0} with ResponseServer = {1}", Name, ResponseServer); if (ResponseServer) { ReceiverSerializer = SerializerManager.GetByMimeType(Config.ResponseOptions?.SerializerMimeType); if (ReceiverSerializer != null && Config.ResponseOptions?.CompressorEncodingType.IsNotNullOrEmpty() == true) { ReceiverSerializer.Compressor = CompressorManager.GetByEncodingType(Config.ResponseOptions?.CompressorEncodingType); } SenderSerializer = null; Core.Log.InfoBasic("Adding queue client listener for {0}, Environment: {1}", Name, Core.EnvironmentName); _clientQueues = Config.ClientQueues?.FirstOf( c => c.EnvironmentName?.SplitAndTrim(",").Contains(Core.EnvironmentName) == true && c.MachineName?.SplitAndTrim(",").Contains(Core.MachineName) == true, c => c.EnvironmentName?.SplitAndTrim(",").Contains(Core.EnvironmentName) == true, c => c.MachineName?.SplitAndTrim(",").Contains(Core.MachineName) == true, c => c.EnvironmentName.IsNullOrWhitespace()); if (_clientQueues?.RecvQueue != null) { var queueListener = OnCreateQueueServerListener(_clientQueues.RecvQueue, ResponseServer); queueListener.ResponseReceived += QueueListener_ResponseReceived; QueueServerListeners.Add(queueListener); } else { Core.Log.Warning("There aren't any Receiver Queue for the Client Listener. Check the ClientQueues element on the queue config file."); } } else { ReceiverSerializer = SerializerManager.GetByMimeType(Config.RequestOptions?.SerializerMimeType); if (ReceiverSerializer != null && Config.RequestOptions?.CompressorEncodingType.IsNotNullOrEmpty() == true) { ReceiverSerializer.Compressor = CompressorManager.GetByEncodingType(Config.RequestOptions?.CompressorEncodingType); } SenderSerializer = SerializerManager.GetByMimeType(Config.ResponseOptions?.SerializerMimeType); if (SenderSerializer != null && Config.ResponseOptions?.CompressorEncodingType.IsNotNullOrEmpty() == true) { SenderSerializer.Compressor = CompressorManager.GetByEncodingType(Config.ResponseOptions?.CompressorEncodingType); } Core.Log.InfoBasic("Adding queue server listeners for {0}, Environment: {1}", Name, Core.EnvironmentName); _serverQueues = Config.ServerQueues?.FirstOf( c => c.EnvironmentName?.SplitAndTrim(",").Contains(Core.EnvironmentName) == true && c.MachineName?.SplitAndTrim(",").Contains(Core.MachineName) == true, c => c.EnvironmentName?.SplitAndTrim(",").Contains(Core.EnvironmentName) == true, c => c.MachineName?.SplitAndTrim(",").Contains(Core.MachineName) == true, c => c.EnvironmentName.IsNullOrWhitespace()); if (_serverQueues?.RecvQueues?.Any() == true) { _serverQueues.RecvQueues.Each(queue => { var queueListener = OnCreateQueueServerListener(queue, ResponseServer); queueListener.RequestReceived += QueueListener_RequestReceived; QueueServerListeners.Add(queueListener); }); } else { Core.Log.Warning("There aren't any Receiver Queue for the Server Listeners. Check the ServerQueues element on the queue config file."); } } if (QueueServerListeners.Count > 0) { Core.Log.InfoBasic("Starting queue server listeners for {0}", Name); _tokenSource = new CancellationTokenSource(); _listenerTasks.Clear(); foreach (var listener in QueueServerListeners) { _listenerTasks.Add(InitListener(listener)); } } else { Core.Log.Warning("There are not server listener to start."); } }
/// <summary> /// Gets the cache client connection pool /// </summary> /// <param name="name">Cache name</param> /// <returns>Cache client pool</returns> public async Task <CacheClientPoolAsync> GetCacheClientAsync(string name) { if (Caches?.Contains(name) != true) { return(null); } var cacheConfig = Caches[name]; var cConfig = cacheConfig.ClientOptionsList?.FirstOf( c => c.EnvironmentName?.SplitAndTrim(",").Contains(Core.EnvironmentName) == true && c.MachineName?.SplitAndTrim(",").Contains(Core.MachineName) == true, c => c.EnvironmentName?.SplitAndTrim(",").Contains(Core.EnvironmentName) == true, c => c.EnvironmentName.IsNullOrWhitespace()); if (cConfig?.Pool == null) { return(null); } var pingDelay = cConfig.Pool.PingDelay.ParseTo(5000); var pingDelayOnError = cConfig.Pool.PingDelayOnError.ParseTo(30000); var readMode = cConfig.Pool.ReadMode; var writeMode = cConfig.Pool.WriteMode; var selectionOrder = cConfig.Pool.SelectionOrder; var forceNetworkItem = cConfig.Pool.ForceAtLeastOneNetworkItemEnabled; ISerializer serializer; if (cConfig.Pool.SerializerMimeType.IsNotNullOrEmpty()) { serializer = SerializerManager.GetByMimeType(cConfig.Pool.SerializerMimeType); Ensure.ReferenceNotNull(serializer, $"The Serializer \"{cConfig.Pool.SerializerMimeType}\" couldn't be loaded."); if (cConfig.Pool.CompressorEncoding.IsNotNullOrEmpty()) { serializer.Compressor = CompressorManager.GetByEncodingType(cConfig.Pool.CompressorEncoding); } } else { serializer = SerializerManager.DefaultBinarySerializer; } var ccp = new CacheClientPoolAsync(name, pingDelay, pingDelayOnError, readMode, writeMode, selectionOrder) { Serializer = serializer, ForceAtLeastOneNetworkItemEnabled = forceNetworkItem }; if (cConfig.Pool.Items?.Any() != true) { return(ccp); } var idx = 0; foreach (var pitem in cConfig.Pool.Items) { idx++; if (!pitem.Enabled) { continue; } var objType = pitem.CreateInstance <object>(); switch (objType) { case ITransportClient transport: { var hostParam = pitem.Parameters?.FirstOrDefault(p => p.Key == "Host"); var portParam = pitem.Parameters?.FirstOrDefault(p => p.Key == "Port"); var proxy = await CacheClientProxy.GetClientAsync(transport).ConfigureAwait(false); var cppName = Core.EnvironmentName + "." + Core.MachineName + "." + name + ".Storage(" + transport.GetType().Name + "-" + hostParam?.Value + "-" + portParam?.Value + ")." + idx; ccp.Add(cppName, (IStorageAsync)proxy, pitem.Mode); break; } case StorageBase sto: { var cppName = Core.EnvironmentName + "." + Core.MachineName + "." + name + ".Storage(" + sto.Type + ")." + idx; ccp.Add(cppName, sto); break; } } } return(ccp); }
public T GetPostObject <T>() { var serializer = SerializerManager.GetByMimeType(ContentType); return(serializer != null?serializer.Deserialize <T>(PostData) : default);
public object GetPostObject(Type type) { var serializer = SerializerManager.GetByMimeType(ContentType); return(serializer?.Deserialize(PostData, type)); }
/// <summary> /// Adds all defined routes on a HttpController type /// </summary> /// <typeparam name="T">Type of HttpControllerBase</typeparam> /// <returns>SimpleHttpServer instance</returns> public SimpleHttpServer AddHttpControllerRoutes <T>() where T : HttpControllerBase { var type = typeof(T); var methods = type.GetRuntimeMethods(); foreach (var m in methods) { var routes = m.GetCustomAttributes <HttpRouteAttribute>().ToArray(); if (routes.Any()) { foreach (var route in routes) { AddRouteHandler(route.Method, route.Url, async context => { var ctl = Activator.CreateInstance <T>(); ctl.Context = context; var mParams = m.GetParameters(); if (mParams.Length > 0) { ParameterInfo postObjectParam = null; object postObject = null; var ivkParams = new List <object>(); if (context.Request.HasPostObject) { postObjectParam = mParams.FirstOrDefault(p => p.GetCustomAttribute(typeof(PostObjectAttribute)) != null); if (postObjectParam is null && mParams.Length == 1) { postObjectParam = mParams[0]; } if (postObjectParam != null) { postObject = Try.Do(() => context.Request.GetPostObject(postObjectParam.ParameterType)); } } var dictionary = context.Route.GetRouteParameters(context.Request.Url.AbsolutePath); foreach (var mParam in mParams) { if (mParam == postObjectParam) { ivkParams.Add(postObject); } else if (dictionary.ContainsKey(mParam.Name)) { ivkParams.Add(dictionary[mParam.Name]); } else { ivkParams.Add(null); } } var response = m.Invoke(ctl, ivkParams.ToArray()); if (response is null) { return; } var serializer = SerializerManager.GetByMimeType(ctl.Context.Response.ContentType); switch (serializer) { case null when response is string: await ctl.Context.Response.WriteAsync((string)response).ConfigureAwait(false); break; case null when response is ValueType: ctl.Context.Response.Write(response.ToString()); break; case null: serializer = SerializerManager.GetByMimeType(SerializerMimeTypes.Json); break; } if (serializer != null) { Try.Do(() => serializer.Serialize(response, response.GetType(), ctl.Context.Response.OutputStream), ex => { var sEx = new SerializableException(ex); serializer.Serialize(sEx, sEx.GetType(), ctl.Context.Response.OutputStream); }); await ctl.Context.Response.OutputStream.FlushAsync().ConfigureAwait(false); } } else { var response = m.Invoke(ctl, new object[0]); if (response is null) { return; } var serializer = SerializerManager.GetByMimeType(ctl.Context.Response.ContentType); switch (serializer) { case null when response is string: await ctl.Context.Response.WriteAsync((string)response).ConfigureAwait(false); break; case null when response is ValueType: ctl.Context.Response.Write(response.ToString()); break; case null: serializer = SerializerManager.GetByMimeType(SerializerMimeTypes.Json); break; } if (serializer != null) { Try.Do(() => serializer.Serialize(response, response.GetType(), ctl.Context.Response.OutputStream), ex => { var sEx = new SerializableException(ex); serializer.Serialize(sEx, sEx.GetType(), ctl.Context.Response.OutputStream); }); await ctl.Context.Response.OutputStream.FlushAsync().ConfigureAwait(false); } } }); } } } ; return(this); }