private static EnhancedServiceParams BuildBaseParams(string connectionString, int poolSize,
PoolParams poolParams = null, ConnectionParams connectionParams = null,
CachingParams cachingParams = null)
{
var parameters =
new EnhancedServiceParams
{
ConnectionParams = connectionParams ?? new ConnectionParams {
ConnectionString = connectionString
},
PoolParams = poolParams ?? new PoolParams {
PoolSize = poolSize
}
};
if (cachingParams != null)
{
parameters.IsCachingEnabled = true;
parameters.CachingParams = cachingParams;
}
if (AutoSetMaxPerformanceParams)
{
parameters.AutoSetMaxPerformanceParams();
}
return(parameters);
}
public static EnhancedServicePool <AsyncOrgService> GetAsyncPool(string connectionString, int poolSize = 10,
EnhancedServiceParams serviceParams = null, bool isHoldAppForAsync = true)
{
var builder = EnhancedServiceBuilder.NewBuilder.Initialise(connectionString);
if (serviceParams?.IsCachingEnabled == true)
{
builder.AddCaching(serviceParams.CachingParams);
}
if (serviceParams?.IsConcurrencyEnabled != false)
{
builder.AddConcurrency(serviceParams?.ConcurrencyParams);
if (isHoldAppForAsync)
{
builder.HoldAppForAsync();
}
}
if (serviceParams?.IsTransactionsEnabled == true)
{
builder.AddTransactions(serviceParams.TransactionParams);
}
var build = builder.Finalise().GetBuild();
var factory = new EnhancedServiceFactory <AsyncOrgService>(build);
return(new EnhancedServicePool <AsyncOrgService>(factory, poolSize));
}
public static EnhancedServicePool <Services.EnhancedOrgService> GetPool(string connectionString,
EnhancedServiceParams serviceParams = null)
{
var builder = EnhancedServiceBuilder.NewBuilder.Initialise(connectionString);
if (serviceParams?.IsCachingEnabled == true)
{
serviceParams.CachingParams = serviceParams.CachingParams
?? new CachingParams
{
CacheMode = CacheMode.PrivatePerInstance
};
builder.AddCaching(serviceParams.CachingParams);
}
if (serviceParams?.IsConcurrencyEnabled == true)
{
builder.AddConcurrency(serviceParams.ConcurrencyParams);
}
if (serviceParams?.IsTransactionsEnabled == true)
{
builder.AddTransactions(serviceParams.TransactionParams);
}
var build = builder.Finalise().GetBuild();
var factory = new EnhancedServiceFactory <Services.EnhancedOrgService>(build);
return(new EnhancedServicePool <Services.EnhancedOrgService>(factory));
}
public AsyncOrgServiceBase(EnhancedServiceParams parameters) : base(parameters)
{
if (!parameters.IsConcurrencyEnabled)
{
throw new UnsupportedException("Cannot initiate an async org service"
+ " unless concurrency is enabled.");
}
isAsyncAppHold = parameters.ConcurrencyParams.IsAsyncAppHold;
}
public EnhancedServiceFactory(EnhancedServiceParams parameters)
{
var enhancedOrgType = typeof(TEnhancedOrgService);
if (enhancedOrgType.IsAbstract)
{
throw new NotSupportedException("Given Enhanced Org type must be concrete.");
}
parameters.Require(nameof(parameters));
var isCachingService = typeof(ICachingOrgService).IsAssignableFrom(typeof(TEnhancedOrgService));
if (parameters.IsCachingEnabled == true && !isCachingService)
{
throw new NotSupportedException("Cannot create a caching service factory unless the given service is caching.");
}
SetPerformanceParams(parameters);
parameters.IsLocked = true;
Parameters = parameters;
customCacheFactory = parameters.CachingParams.CustomCacheFactory;
if (parameters.IsCachingEnabled == true)
{
switch (parameters.CachingParams.CacheScope)
{
case CacheScope.Global:
factoryCache = customCacheFactory == null ? MemoryCache.Default : customCacheFactory(this, Parameters, null);
break;
case CacheScope.Factory:
factoryCache = customCacheFactory == null
? (parameters.CachingParams.ObjectCache ?? new MemoryCache(parameters.ConnectionParams.ConnectionString))
: customCacheFactory(this, Parameters, null);
break;
case CacheScope.Service:
break;
default:
throw new ArgumentOutOfRangeException(nameof(parameters.CachingParams.CacheScope));
}
}
customServiceFactory = parameters.ConnectionParams.CustomIOrgSvcFactory ?? customServiceFactory;
}
public virtual INodeService AddNode(EnhancedServiceParams serviceParams, int weight = 1)
{
serviceParams.Require(nameof(serviceParams), "Service Parameters must be set first.");
weight.RequireAtLeast(1, nameof(weight));
var node = new NodeService(serviceParams, weight);
if (NodeQueue.IsEmpty)
{
SetPrimaryNode(node);
}
NodeQueue.Enqueue(node);
return(node);
}
private static void SetPerformanceParams(EnhancedServiceParams parameters)
{
if (parameters.ConnectionParams?.DotNetDefaultConnectionLimit.HasValue == true)
{
ServicePointManager.DefaultConnectionLimit = parameters.ConnectionParams.DotNetDefaultConnectionLimit.Value;
}
if (parameters.PoolParams?.DotNetSetMinAppReservedThreads.HasValue == true)
{
var minThreads = parameters.PoolParams.DotNetSetMinAppReservedThreads.Value;
ThreadPool.SetMinThreads(minThreads, minThreads);
}
if (parameters.ConnectionParams?.IsDotNetDisableWaitForConnectConfirm.HasValue == true)
{
ServicePointManager.Expect100Continue =
!parameters.ConnectionParams.IsDotNetDisableWaitForConnectConfirm.Value;
}
if (parameters.ConnectionParams?.IsDotNetDisableNagleAlgorithm.HasValue == true)
{
ServicePointManager.UseNagleAlgorithm = !parameters.ConnectionParams.IsDotNetDisableNagleAlgorithm.Value;
}
}
public EnhancedServiceFactory(EnhancedServiceParams parameters)
{
this.parameters = parameters;
if (parameters.IsCachingEnabled)
{
switch (parameters.CachingParams.CacheMode)
{
case CacheMode.Global:
factoryCache = MemoryCache.Default;
break;
case CacheMode.Private:
factoryCache = parameters.CachingParams.ObjectCache ?? new MemoryCache(parameters.ConnectionString);
break;
case CacheMode.PrivatePerInstance:
break;
default:
throw new ArgumentOutOfRangeException(nameof(parameters.CachingParams.CacheMode));
}
}
var isAsyncService = typeof(IAsyncOrgService).IsAssignableFrom(typeof(TEnhancedOrgService));
if (parameters.IsConcurrencyEnabled && !isAsyncService)
{
throw new UnsupportedException("Cannot create an async service factory unless the given service is async.");
}
if (!parameters.IsConcurrencyEnabled && isAsyncService)
{
throw new UnsupportedException("Cannot create an async service factory unless concurrency is enabled.");
}
}
public static IEnhancedServicePool <ICachingOrgService> GetPoolCaching(EnhancedServiceParams serviceParams)
{
var factory = new EnhancedServiceFactory <ICachingOrgService, CachingOrgService>(serviceParams);
return(new EnhancedServicePool <ICachingOrgService, CachingOrgService>(factory));
}
public static IEnhancedServicePool <IEnhancedOrgService> GetPool(EnhancedServiceParams serviceParams)
{
var factory = new EnhancedServiceFactory <IEnhancedOrgService, Services.Enhanced.EnhancedOrgService>(serviceParams);
return(new EnhancedServicePool <IEnhancedOrgService, Services.Enhanced.EnhancedOrgService>(factory));
}
protected internal EnhancedOrgService(EnhancedServiceParams parameters) : base(parameters)
{
}
public AsyncOrgService(EnhancedServiceParams parameters) : base(parameters)
{
}
protected EnhancedOrgServiceBase(EnhancedServiceParams parameters)
{
Parameters = parameters;
}
protected internal NodeService(EnhancedServiceParams @params, int weight = 1)
{
Params = @params;
Weight = weight;
LatencyEvaluator =
new Thread(
() =>
{
var downtime = new Stopwatch();
while (true)
{
try
{
var stopwatch = new Stopwatch();
stopwatch.Start();
if (Status == NodeStatus.Offline)
{
Downtime += downtime.Elapsed;
}
downtime.Reset();
downtime.Start();
var thread =
new Thread(
() =>
{
try
{
LatencyEvaluatorService.Execute(new WhoAmIRequest());
}
catch (ThreadAbortException)
{ }
});
if (!thread.Join(TimeSpan.FromSeconds(10)))
{
thread.Abort();
LatencyHistory.Enqueue(TimeSpan.MaxValue);
Status = NodeStatus.Unknown;
LatencyEvaluatorService.Execute(new WhoAmIRequest());
}
stopwatch.Stop();
LatencyHistory.Enqueue(stopwatch.Elapsed);
Status = NodeStatus.Online;
}
catch
{
LatencyHistory.Enqueue(TimeSpan.MaxValue);
Status = NodeStatus.Offline;
}
finally
{
Thread.Sleep((int?)LatencyInterval?.TotalMilliseconds ?? 10000);
}
}
});
}
