protected ProxyApi(NetConfiguration netConfiguration, ProxyConfiguration proxyConfiguration,
CommonConfiguration commonConfiguration, TimeoutConfiguration timeoutConfiguration)
{
Contract.Requires(netConfiguration != null);
Contract.Requires(proxyConfiguration != null);
Contract.Requires(commonConfiguration != null);
Contract.Requires(timeoutConfiguration != null);
_isStarted = false;
_isBuild = false;
_isDispose = false;
var server = new ServerId(netConfiguration.Host, netConfiguration.Port);
var queue = new QueueConfiguration(commonConfiguration.CountThreads, commonConfiguration.QueueSize);
var connection = new ConnectionConfiguration(netConfiguration.WcfServiceName,
netConfiguration.CountConnectionsToSingleServer);
var proxyCacheConfiguration = new ProxyCacheConfiguration(proxyConfiguration.ChangeDistributorTimeoutSec);
var proxyCacheConfiguration2 = new ProxyCacheConfiguration(proxyConfiguration.SyncOperationsTimeoutSec);
var netReceiveConfiguration = new NetReceiverConfiguration(netConfiguration.Port, netConfiguration.Host,
netConfiguration.WcfServiceName);
var async = new AsyncTasksConfiguration(proxyConfiguration.AsyncUpdateTimeout);
var ping = new AsyncTasksConfiguration(proxyConfiguration.AsyncPingTimeout);
var timeout = new ConnectionTimeoutConfiguration(timeoutConfiguration.OpenTimeout,
timeoutConfiguration.SendTimeout);
_proxySystem = new ProxySystem(server, queue, connection,
proxyCacheConfiguration, proxyCacheConfiguration2, netReceiveConfiguration, async, ping, timeout);
_apis = new Dictionary <string, ProxyHandlerBase>();
}
public CollectorGate(string tableName, DbFactory dbFactory,
CollectorConfiguration collectorConfiguration, CollectorNetConfiguration netConfiguration,
CommonConfiguration commonConfiguration, TimeoutConfiguration timeoutConfiguration)
: base(collectorConfiguration, netConfiguration, commonConfiguration, timeoutConfiguration)
{
Contract.Requires(!string.IsNullOrEmpty(tableName));
Contract.Requires(_dbFactory != null);
_tableName = tableName;
_dbFactory = dbFactory;
}
public static void Start(List <DbFactory> factory, string host, int port, int countReplics)
{
var net = new StorageNetConfiguration(host, port, port + 123, "testService", 10);
var st = new StorageConfiguration("ServersFile", countReplics, 10, TimeSpan.FromSeconds(60), TimeSpan.FromSeconds(60),
TimeSpan.FromSeconds(60), TimeSpan.FromSeconds(60), false);
var common = new CommonConfiguration(4, 10000);
var timeout = new TimeoutConfiguration(TimeSpan.FromMilliseconds(1000), TimeSpan.FromMilliseconds(1000));
var storage = new StorageApi(net, st, common, timeout);
Wait(storage, factory);
}
public static void Start(IDataProvider <TKey, TValue> dataProvider, List <DbFactory> factory, string[] args = null)
{
Tuple <string, int, int> tup = args == null?AskParams() : ReadParams(args);
var net = new StorageNetConfiguration(tup.Item1, tup.Item2, tup.Item2 + 123, "testService", 10);
var st = new StorageConfiguration("ServersFile", tup.Item3, 10, TimeSpan.FromSeconds(60), TimeSpan.FromSeconds(60),
TimeSpan.FromSeconds(60), TimeSpan.FromSeconds(60), false);
var common = new CommonConfiguration(4, 10000);
var timeout = new TimeoutConfiguration(TimeSpan.FromMilliseconds(1000), TimeSpan.FromMilliseconds(1000));
var storage = new StorageApi(net, st, common, timeout);
Wait(storage, factory);
}
public WriterApi(StorageNetConfiguration netConfiguration,
StorageConfiguration storageConfiguration, CommonConfiguration commonConfiguration,
TimeoutConfiguration timeoutConfiguration, bool isNeedRestore = false,
CommonConfiguration restoreConfiguration = null)
{
Contract.Requires(netConfiguration != null);
Contract.Requires(storageConfiguration != null);
Contract.Requires(commonConfiguration != null);
Contract.Requires(timeoutConfiguration != null);
_isStarted = false;
_isBuild = false;
_isDispose = false;
var server = new ServerId(netConfiguration.Host, netConfiguration.PortForDitributor);
var queue = new QueueConfiguration(commonConfiguration.CountThreads, commonConfiguration.QueueSize);
var queueRestore = restoreConfiguration == null
? new QueueConfiguration(1, 1000)
: new QueueConfiguration(restoreConfiguration.CountThreads, restoreConfiguration.QueueSize);
var netReceiveConfiguration = new NetReceiverConfiguration(netConfiguration.PortForDitributor,
netConfiguration.Host,
netConfiguration.WcfServiceName);
var netReceiveConfiguration2 = new NetReceiverConfiguration(netConfiguration.PortForCollector,
netConfiguration.Host,
netConfiguration.WcfServiceName);
var connection = new ConnectionConfiguration(netConfiguration.WcfServiceName,
netConfiguration.CountConnectionsToSingleServer);
var hashMap = new HashMapConfiguration(storageConfiguration.FileWithHashName,
HashMapCreationMode.ReadFromFile, 1,
storageConfiguration.CountReplics, HashFileType.Writer);
var restoreTransfer = new RestoreModuleConfiguration(1, storageConfiguration.TimeoutSendAnswerInRestore);
var restoreInitiator = new RestoreModuleConfiguration(storageConfiguration.CountRetryWaitAnswerInRestore,
storageConfiguration.TimeoutWaitAnswerInRestore);
var restoreTimeout = new RestoreModuleConfiguration(-1, storageConfiguration.PeriodStartDelete,
storageConfiguration.IsForceDelete, storageConfiguration.PeriodDeleteAfterRestore);
var timeout = new ConnectionTimeoutConfiguration(timeoutConfiguration.OpenTimeout,
timeoutConfiguration.SendTimeout);
_writerSystem = new WriterSystem(server, queue, netReceiveConfiguration,
netReceiveConfiguration2, hashMap,
connection, restoreTransfer, restoreInitiator, timeout, restoreTimeout, isNeedRestore, queueRestore);
_handler = new WriterHandler(_writerSystem);
}
public DistributorApi(DistributorNetConfiguration netConfiguration,
DistributorConfiguration distributorConfiguration, CommonConfiguration commonConfiguration,
TimeoutConfiguration timeoutConfiguration)
{
Contract.Requires(netConfiguration != null);
Contract.Requires(distributorConfiguration != null);
Contract.Requires(commonConfiguration != null);
Contract.Requires(timeoutConfiguration != null);
var dbServer = new ServerId(netConfiguration.Host, netConfiguration.PortForStorage);
var proxyServer = new ServerId(netConfiguration.Host, netConfiguration.PortForProxy);
var distrHash = new DistributorHashConfiguration(distributorConfiguration.CountReplics);
var queue = new QueueConfiguration(commonConfiguration.CountThreads, commonConfiguration.QueueSize);
var connection = new ConnectionConfiguration(netConfiguration.WcfServiceName,
netConfiguration.CountConnectionsToSingleServer);
var distrCache = new DistributorCacheConfiguration(distributorConfiguration.DataAliveTime,
distributorConfiguration.DataAliveAfterUpdate);
var dbNetReceive = new NetReceiverConfiguration(netConfiguration.PortForStorage,
netConfiguration.Host, netConfiguration.WcfServiceName);
var proxyNetReceive = new NetReceiverConfiguration(netConfiguration.PortForProxy,
netConfiguration.Host, netConfiguration.WcfServiceName);
var transaction = new TransactionConfiguration(commonConfiguration.CountThreads);
var hashMap = new HashMapConfiguration(distributorConfiguration.FileWithHashName,
HashMapCreationMode.ReadFromFile, 1,
distributorConfiguration.CountReplics, HashFileType.Distributor);
var asyncPing = new AsyncTasksConfiguration(distributorConfiguration.PingPeriod);
var asyncCheck = new AsyncTasksConfiguration(distributorConfiguration.CheckPeriod);
var timeou = new ConnectionTimeoutConfiguration(timeoutConfiguration.OpenTimeout,
timeoutConfiguration.SendTimeout);
_distributorSystem = new DistributorSystem(dbServer, proxyServer, distrHash, queue, connection, distrCache,
dbNetReceive, proxyNetReceive, transaction, hashMap, asyncPing, asyncCheck, timeou);
_handler = new DistributorHandler(_distributorSystem);
}
protected CollectorApi(CollectorConfiguration collectorConfiguration, CollectorNetConfiguration netConfiguration,
CommonConfiguration commonConfiguration, TimeoutConfiguration timeoutConfiguration)
{
Contract.Requires(collectorConfiguration != null);
Contract.Requires(netConfiguration != null);
Contract.Requires(commonConfiguration != null);
Contract.Requires(timeoutConfiguration != null);
_isStarted = false;
_isBuild = false;
_isDispose = false;
_collectorSystem = new CollectorSystem(
new DistributorHashConfiguration(collectorConfiguration.CountReplics),
new HashMapConfiguration(collectorConfiguration.FileWithHashName, HashMapCreationMode.ReadFromFile, 1,
collectorConfiguration.CountReplics, HashFileType.Collector),
new ConnectionConfiguration(netConfiguration.WcfServiceName,
netConfiguration.CountConnectionsToSingleServer),
new ConnectionTimeoutConfiguration(timeoutConfiguration.OpenTimeout, timeoutConfiguration.SendTimeout),
new QueueConfiguration(commonConfiguration.CountThreads, commonConfiguration.QueueSize),
collectorConfiguration.PageSize, collectorConfiguration.UseHashFile);
_apis = new Dictionary <string, CollectorHandlerTuple>();
}
private IBotPolicy <T> CreatePolicyWithTimeout <T>(TimeoutConfiguration timeoutConfig) =>
new BotPolicy <T>(config => config
.Configure(botconfig => botconfig
.Timeout(timeoutConfig)));
//private IStorage<int, DataWithBuffer> _data;
public TestGate(NetConfiguration netConfiguration, ProxyConfiguration proxyConfiguration,
CommonConfiguration commonConfiguration, TimeoutConfiguration timeoutConfiguration)
: base(netConfiguration, proxyConfiguration, commonConfiguration, timeoutConfiguration)
{
}
/// <summary>
/// Adds a timeout bot to a <see cref="IBotPolicy"/> with the given configuration.
/// </summary>
/// <typeparam name="TResult">The result type of the passed operation.</typeparam>
/// <param name="builder">The policy builder.</param>
/// <param name="configuration">The configuraton.</param>
/// <returns>The policy builder.</returns>
/// <example>
/// <code>
/// builder.Timeout(
/// new TimeoutConfiguration()
/// .After(TimeSpan.FromSeconds(15))
/// .OnTimeout(context => timeoutAction()));
/// </code>
/// </example>
public static IBotPolicyBuilder <TResult> Timeout <TResult>(this IBotPolicyBuilder <TResult> builder, TimeoutConfiguration configuration)
{
Shield.EnsureNotNull(configuration, nameof(configuration));
return(builder.AddBot((innerBot, config) => new TimeoutBot <TResult>(innerBot, config), configuration));
}
