public WriterSystem(ServerId local, QueueConfiguration queueConfiguration,
NetReceiverConfiguration receiverConfigurationForWrite,
NetReceiverConfiguration receiverConfigurationForCollector,
HashMapConfiguration hashMapConfiguration,
ConnectionConfiguration connectionConfiguration,
RestoreModuleConfiguration transferRestoreConfiguration,
RestoreModuleConfiguration initiatorRestoreConfiguration,
ConnectionTimeoutConfiguration connectionTimeoutConfiguration,
RestoreModuleConfiguration timeoutRestoreConfiguration,
bool isNeedRestore = false,
QueueConfiguration queueConfigurationRestore = null)
{
Contract.Requires(local != null);
Contract.Requires(queueConfiguration != null);
Contract.Requires(receiverConfigurationForWrite != null);
Contract.Requires(receiverConfigurationForCollector != null);
Contract.Requires(hashMapConfiguration != null);
Contract.Requires(connectionConfiguration != null);
Contract.Requires(transferRestoreConfiguration != null);
Contract.Requires(initiatorRestoreConfiguration != null);
_queueConfigurationRestore = queueConfigurationRestore ?? new QueueConfiguration(1, 1000);
_queueConfiguration = queueConfiguration;
_receiverConfigurationForWrite = receiverConfigurationForWrite;
_receiverConfigurationForCollector = receiverConfigurationForCollector;
_hashMapConfiguration = hashMapConfiguration;
_connectionConfiguration = connectionConfiguration;
_initiatorRestoreConfiguration = initiatorRestoreConfiguration;
_connectionTimeoutConfiguration = connectionTimeoutConfiguration;
_timeoutRestoreConfiguration = timeoutRestoreConfiguration;
_isNeedRestore = isNeedRestore;
_transferRestoreConfiguration = transferRestoreConfiguration;
_local = local;
}
public static ChannelFactory <TApi> Connect <TApi>(ServerId server, string serviceName,
ConnectionTimeoutConfiguration timeoutConfiguration)
{
string endPointAddr = string.Format("net.tcp://{0}:{1}/{2}", server.RemoteHost, server.Port, serviceName);
var endpointAddress =
new EndpointAddress(endPointAddr);
var tcpBinding = new NetTcpBinding
{
Security = { Mode = SecurityMode.None },
MaxReceivedMessageSize = 2147483647,
MaxBufferSize = 2147483647,
OpenTimeout = timeoutConfiguration.OpenTimeout,
SendTimeout = timeoutConfiguration.SendTimeout,
};
try
{
var cf = new ChannelFactory <TApi>(tcpBinding, endpointAddress);
foreach (OperationDescription op in cf.Endpoint.Contract.Operations)
{
var dataContractBehavior = op.Behaviors.Find <DataContractSerializerOperationBehavior>();
if (dataContractBehavior != null)
{
dataContractBehavior.MaxItemsInObjectGraph = int.MaxValue;
}
}
return(cf);
}
catch (Exception e)
{
Logger.Logger.Instance.Error(e, "");
return(null);
}
}
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 ProxySystem(ServerId local, QueueConfiguration queueConfiguration,
ConnectionConfiguration connectionConfiguration,
ProxyCacheConfiguration cacheConfiguration,
ProxyCacheConfiguration asyncCacheConfiguration,
NetReceiverConfiguration receiverConfiguration,
AsyncTasksConfiguration asyncGetData,
AsyncTasksConfiguration asyncPing, ConnectionTimeoutConfiguration connectionTimeoutConfiguration)
{
Contract.Requires(queueConfiguration != null);
Contract.Requires(connectionConfiguration != null);
Contract.Requires(cacheConfiguration != null);
Contract.Requires(asyncCacheConfiguration != null);
Contract.Requires(receiverConfiguration != null);
Contract.Requires(asyncGetData != null);
Contract.Requires(local != null);
Contract.Requires(asyncPing != null);
_local = local;
_queueConfiguration = queueConfiguration;
_connectionConfiguration = connectionConfiguration;
_cacheConfiguration = cacheConfiguration;
_asyncCacheConfiguration = asyncCacheConfiguration;
_netReceiverConfiguration = receiverConfiguration;
_asyncGetData = asyncGetData;
_asyncPing = asyncPing;
_connectionTimeoutConfiguration = connectionTimeoutConfiguration;
}
protected SingleConnection(ServerId server, ConnectionConfiguration configuration,
ConnectionTimeoutConfiguration timeoutConfiguration)
{
Server = server;
_bPool =
new StableElementsDynamicConnectionPool <T>(
NetConnector.Connect <T>(Server, configuration.ServiceName, timeoutConfiguration),
-1, configuration.MaxElementCount);
}
protected NetModule(ConnectionConfiguration connectionConfiguration, ConnectionTimeoutConfiguration connectionTimeout)
{
Contract.Requires(connectionConfiguration != null);
Contract.Requires(connectionTimeout != null);
_configuration = connectionConfiguration;
_connectionTimeout = connectionTimeout;
_lock = new ReaderWriterLockSlim();
_servers = new Dictionary <ServerId, ISingleConnection>();
}
public TestProxySystem(ServerId local, QueueConfiguration queueConfiguration,
ConnectionConfiguration connectionConfiguration, ProxyCacheConfiguration cacheConfiguration,
ProxyCacheConfiguration asyncCacheConfiguration, NetReceiverConfiguration receiverConfiguration,
AsyncTasksConfiguration asyncGetData, AsyncTasksConfiguration asyncPing,
ConnectionTimeoutConfiguration connectionTimeoutConfiguration)
: base(
local, queueConfiguration, connectionConfiguration, cacheConfiguration, asyncCacheConfiguration,
receiverConfiguration, asyncGetData, asyncPing, connectionTimeoutConfiguration)
{
}
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 CollectorSystem(DistributorHashConfiguration distributorHashConfiguration,
HashMapConfiguration hashMapConfiguration,
ConnectionConfiguration connectionConfiguration,
ConnectionTimeoutConfiguration connectionTimeoutConfiguration,
QueueConfiguration queueConfiguration,
int serverPageSize, bool useHashFile = true)
{
Contract.Requires(distributorHashConfiguration != null);
Contract.Requires(hashMapConfiguration != null);
Contract.Requires(connectionConfiguration != null);
Contract.Requires(connectionTimeoutConfiguration != null);
Contract.Requires(queueConfiguration != null);
Contract.Requires(serverPageSize > 0);
_distributorHashConfiguration = distributorHashConfiguration;
_hashMapConfiguration = hashMapConfiguration;
_connectionConfiguration = connectionConfiguration;
_connectionTimeoutConfiguration = connectionTimeoutConfiguration;
_queueConfiguration = queueConfiguration;
_serverPageSize = serverPageSize;
_useHashFile = useHashFile;
}
public DistributorSystem(ServerId localfordb, ServerId localforproxy,
DistributorHashConfiguration distributorHashConfiguration,
QueueConfiguration queueConfiguration,
ConnectionConfiguration connectionConfiguration,
DistributorCacheConfiguration cacheConfiguration,
NetReceiverConfiguration receiverConfigurationForDb,
NetReceiverConfiguration receiverConfigurationForProxy,
TransactionConfiguration transactionConfiguration,
HashMapConfiguration hashMapConfiguration, AsyncTasksConfiguration pingConfig,
AsyncTasksConfiguration checkConfig, ConnectionTimeoutConfiguration connectionTimeoutConfiguration)
{
Contract.Requires(distributorHashConfiguration != null);
Contract.Requires(_queueConfiguration != null);
Contract.Requires(connectionConfiguration != null);
Contract.Requires(cacheConfiguration != null);
Contract.Requires(receiverConfigurationForDb != null);
Contract.Requires(receiverConfigurationForProxy != null);
Contract.Requires(transactionConfiguration != null);
Contract.Requires(localfordb != null);
Contract.Requires(localforproxy != null);
Contract.Requires(hashMapConfiguration != null);
Contract.Requires(pingConfig != null);
Contract.Requires(checkConfig != null);
_pingConfig = pingConfig;
_checkConfig = checkConfig;
_connectionTimeoutConfiguration = connectionTimeoutConfiguration;
_distributorHashConfiguration = distributorHashConfiguration;
_hashMapConfiguration = hashMapConfiguration;
_queueConfiguration = queueConfiguration;
_connectionConfiguration = connectionConfiguration;
_cacheConfiguration = cacheConfiguration;
_receiverConfigurationForDb = receiverConfigurationForDb;
_receiverConfigurationForProxy = receiverConfigurationForProxy;
_transactionConfiguration = transactionConfiguration;
_localfordb = localfordb;
_localforproxy = localforproxy;
}
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);
}
public CollectorNetModule(ConnectionConfiguration connectionConfiguration,
ConnectionTimeoutConfiguration connectionTimeout, DistributorModule distributor)
: base(connectionConfiguration, connectionTimeout)
{
_distributor = distributor;
}
public SingleConnectionToDistributor(ServerId server, ConnectionConfiguration configuration,
ConnectionTimeoutConfiguration timeoutConfiguration) : base(server, configuration, timeoutConfiguration)
{
}
public SingleConnectionToProxy(ServerId server, ConnectionConfiguration configuration,
ConnectionTimeoutConfiguration timeoutConfiguration) : base(server, configuration, timeoutConfiguration)
{
}
public DistributorNetModule(ConnectionConfiguration connectionConfiguration,
ConnectionTimeoutConfiguration connectionTimeout) : base(connectionConfiguration, connectionTimeout)
{
}
protected virtual ISingleConnection CreateConnectionToProxy(ServerId server,
ConnectionConfiguration configuration, ConnectionTimeoutConfiguration time)
{
return(new SingleConnectionToProxy(server, configuration, time));
}
public ProxyNetModule(ConnectionConfiguration connectionConfiguration,
ConnectionTimeoutConfiguration connectionTimeout) : base(connectionConfiguration, connectionTimeout)
{
}
