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 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 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;
}
public void Build(int countReplics, int distrServer1, int distrServer12, string hashFile)
{
_q = new GlobalQueueInner();
GlobalQueue.SetQueue(_q);
var connection = new ConnectionConfiguration("testService", 10);
var distrconfig = new DistributorHashConfiguration(countReplics);
var queueconfig = new QueueConfiguration(1, 100);
_dnet = new DistributorNetModule(connection,
new ConnectionTimeoutConfiguration(Consts.OpenTimeout, Consts.SendTimeout));
Distributor = new DistributorModule(new AsyncTasksConfiguration(TimeSpan.FromMinutes(5)),
new AsyncTasksConfiguration(TimeSpan.FromMinutes(5)), distrconfig,
queueconfig, _dnet,
new ServerId("localhost", distrServer1),
new ServerId("localhost", distrServer12),
new HashMapConfiguration(hashFile,
HashMapCreationMode.ReadFromFile,
1, countReplics, HashFileType.Distributor));
_dnet.SetDistributor(Distributor);
_tranc = new TransactionModule(new QueueConfiguration(1, 1000), _dnet, new TransactionConfiguration(4),
distrconfig);
Main =
new MainLogicModule(new DistributorTimeoutCache(TimeSpan.FromSeconds(200), TimeSpan.FromSeconds(200)),
Distributor, _tranc);
var netReceive1 = new NetReceiverConfiguration(distrServer1, "localhost", "testService");
var netReceive2 = new NetReceiverConfiguration(distrServer12, "localhost", "testService");
Input = new InputModuleWithParallel(new QueueConfiguration(2, 100000), Main, _tranc);
_receiver = new NetDistributorReceiver(Main, Input, Distributor, netReceive1, netReceive2);
}
public NetDistributorReceiverForDb(DistributorModule distributorModule,
NetReceiverConfiguration receiverConfiguration)
: base(receiverConfiguration)
{
Contract.Requires(distributorModule != null);
_distributorModule = distributorModule;
}
public static ServiceHost CreateServer <T>(object server, NetReceiverConfiguration configuration)
{
var host = new ServiceHost(server,
new Uri(string.Format("net.tcp://{0}:{1}/{2}", configuration.Host, configuration.Port,
configuration.Service)));
var binding = new NetTcpBinding()
{
Security = { Mode = SecurityMode.None },
MaxBufferSize = 2147483647,
MaxReceivedMessageSize = 2147483647
};
var contractType = typeof(T);
host.AddServiceEndpoint(contractType, binding, "");
var behavior = host.Description.Behaviors.Find <ServiceBehaviorAttribute>();
behavior.InstanceContextMode = InstanceContextMode.Single;
behavior.ConcurrencyMode = ConcurrencyMode.Multiple;
behavior.MaxItemsInObjectGraph = 2147483647;
behavior.ReleaseServiceInstanceOnTransactionComplete = false;
var test = host.Description.Behaviors.Find <ServiceDebugBehavior>();
test.IncludeExceptionDetailInFaults = true;
host.Open();
return(host);
}
public NetDistributorReceiver(MainLogicModule main, IInputModule input, DistributorModule distributorModule,
NetReceiverConfiguration receiverConfigurationForDb,
NetReceiverConfiguration receiverConfigurationForFroxy)
{
_distributorReceiverForDb = new NetDistributorReceiverForDb(distributorModule, receiverConfigurationForDb);
_distributorReceiverForProxy = new NetDistributorReceiverForProxy(main, input, distributorModule,
receiverConfigurationForFroxy);
}
public void MainLogicModule_TransactionAnswerResult_ReceiveAnswersFromWriter()
{
const int distrServer1 = 22168;
const int distrServer2 = 23168;
#region hell
var connectionConf = new ConnectionConfiguration("testService", 10);
var distrconfig = new DistributorHashConfiguration(1);
var queueconfig = new QueueConfiguration(1, 100);
var dnet = new DistributorNetModule(connectionConf,
new ConnectionTimeoutConfiguration(Consts.OpenTimeout, Consts.SendTimeout));
var ddistributor = new DistributorModule(new AsyncTasksConfiguration(TimeSpan.FromMinutes(5)),
new AsyncTasksConfiguration(TimeSpan.FromMinutes(5)), distrconfig,
queueconfig, dnet,
new ServerId("localhost", distrServer1),
new ServerId("localhost", distrServer2),
new HashMapConfiguration("TestDistributorReceiveAndDbSendAsync",
HashMapCreationMode.ReadFromFile,
1, 1, HashFileType.Distributor));
dnet.SetDistributor(ddistributor);
var tranc = new TransactionModule(new QueueConfiguration(1, 1000), dnet, new TransactionConfiguration(4),
distrconfig);
var cache = new DistributorTimeoutCache(TimeSpan.FromMilliseconds(2000), TimeSpan.FromMilliseconds(200000));
var main = new MainLogicModule(cache, ddistributor, tranc);
cache.SetMainLogicModule(main);
var netReceive4 = new NetReceiverConfiguration(distrServer1, "localhost", "testService");
var netReceive42 = new NetReceiverConfiguration(distrServer2, "localhost", "testService");
var input = new InputModuleWithParallel(new QueueConfiguration(2, 100000), main, tranc);
var receiver4 = new NetDistributorReceiver(main, input,
ddistributor, netReceive4, netReceive42);
ddistributor.Start();
receiver4.Start();
#endregion
var t = 0;
GlobalQueue.Queue.TransactionQueue.Registrate(data => Interlocked.Increment(ref t));
GlobalQueue.Queue.Start();
var connection = new SingleConnectionToDistributor(
new ServerId("localhost", distrServer1), new ConnectionConfiguration("testService", 10),
new ConnectionTimeoutConfiguration(Consts.OpenTimeout, Consts.SendTimeout));
connection.Connect();
connection.TransactionAnswerResult(new Transaction("123", "123"));
Thread.Sleep(TimeSpan.FromMilliseconds(100));
connection.TransactionAnswerResult(new Transaction("1243", "1423"));
Thread.Sleep(TimeSpan.FromMilliseconds(100));
Assert.AreEqual(2, t);
connection.Dispose();
receiver4.Dispose();
}
public NetWriterReceiver(InputModule inputModule, DistributorModule distributor,
NetReceiverConfiguration receiverConfigurationForWrite,
NetReceiverConfiguration receiverConfigurationForCollector)
{
_writerReceiverForWrite = new NetWriterReceiverForWrite(inputModule, distributor,
receiverConfigurationForWrite);
_writerReceiverForCollector = new NetWriterReceiverForCollector(inputModule, distributor,
receiverConfigurationForCollector);
}
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 NetDistributorReceiverForProxy(MainLogicModule main, IInputModule input, DistributorModule distributorModule,
NetReceiverConfiguration receiverConfiguration) : base(receiverConfiguration)
{
Contract.Requires(main != null);
Contract.Requires(input != null);
Contract.Requires(distributorModule != null);
_mainLogic = main;
_input = input;
_distributorModule = distributorModule;
}
public void ProxySystem_Read_ReadFromFakeDistributor_ExpectedData()
{
var queue = new QueueConfiguration(1, 100);
var connection = new ConnectionConfiguration("testService", 10);
var ndrc2 = new NetReceiverConfiguration(32192, "localhost", "testService");
var pcc = new ProxyCacheConfiguration(TimeSpan.FromSeconds(20000000));
var proxy = new TestProxySystem(new ServerId("", 1), queue, connection, pcc, pcc,
ndrc2,
new AsyncTasksConfiguration(TimeSpan.FromMinutes(60000)),
new AsyncTasksConfiguration(TimeSpan.FromMinutes(60000)),
new ConnectionTimeoutConfiguration(Consts.OpenTimeout, Consts.SendTimeout));
proxy.Build();
proxy.Start();
var distr = new ServerId("localhost", 22194);
TestHelper.OpenDistributorHost(distr, connection);
proxy.Distributor.SayIAmHere(distr);
var provider = new IntHashConvertor();
var hash = provider.CalculateHashFromKey(10);
var transaction = new Transaction(hash, "")
{
OperationName = OperationName.Read,
OperationType = OperationType.Sync
};
Task.Factory.StartNew(() =>
{
Thread.Sleep(200);
transaction.Complete();
var data = new InnerData(transaction)
{
Data = provider.SerializeValue(10)
};
proxy.Queue.ProxyDistributorQueue.Add(new ReadOperationCompleteCommand(data));
});
try
{
UserTransaction userTransaction;
var api = proxy.CreateApi("", false, new IntHashConvertor());
var wait = api.Read(10, out userTransaction);
Assert.AreEqual(10, wait);
Assert.AreEqual(TransactionState.Complete, userTransaction.State);
}
catch (Exception e)
{
Assert.Fail(e.Message);
}
proxy.Dispose();
}
public void ProxyAndDistributor_Read_DirectReadFromOneServerMock()
{
const int storageServer = 22261;
var writer = new HashWriter(new HashMapConfiguration("TestProxyAndDistributorRead1Servers", HashMapCreationMode.CreateNew, 1, 3, HashFileType.Distributor));
writer.CreateMap();
writer.SetServer(0, "localhost", storageServer, 157);
writer.Save();
var dhc = new DistributorHashConfiguration(1);
var queue = new QueueConfiguration(1, 100);
var connection = new ConnectionConfiguration("testService", 10);
var dcc = new DistributorCacheConfiguration(TimeSpan.FromMilliseconds(600), TimeSpan.FromMilliseconds(1000));
var ndrc = new NetReceiverConfiguration(22260, "localhost", "testService");
var ndrc12 = new NetReceiverConfiguration(23260, "localhost", "testService");
var distr = new DistributorSystem(new ServerId("localhost", 22260),
new ServerId("localhost", 23260),
dhc, queue, connection, dcc, ndrc, ndrc12,
new TransactionConfiguration(1),
new HashMapConfiguration("TestProxyAndDistributorRead1Servers",
HashMapCreationMode.ReadFromFile, 1, 1, HashFileType.Distributor),
new AsyncTasksConfiguration(TimeSpan.FromMinutes(5)),
new AsyncTasksConfiguration(TimeSpan.FromMinutes(5)),
new ConnectionTimeoutConfiguration(Consts.OpenTimeout, Consts.SendTimeout));
var server = new ServerId("localhost", 23260);
distr.Build();
_proxy.Start();
distr.Start();
GlobalQueue.Queue.Start();
_proxy.Distributor.SayIAmHere(server);
var s = TestHelper.OpenWriterHost(new ServerId("localhost", storageServer), connection);
s.retData = TestHelper.CreateEvent(new StoredDataHashCalculator(), 10);
var api = _proxy.CreateApi("Event", false, new StoredDataHashCalculator());
UserTransaction transaction;
var read = (StoredData)api.Read(10, out transaction);
Assert.AreEqual(10, read.Id);
_proxy.Dispose();
distr.Dispose();
}
public void Initialize()
{
var queue = new QueueConfiguration(1, 100);
var connection = new ConnectionConfiguration("testService", 10);
var ndrc2 = new NetReceiverConfiguration(proxyServer, "localhost", "testService");
var pcc = new ProxyCacheConfiguration(TimeSpan.FromSeconds(2));
_proxy = new TestProxySystem(new ServerId("localhost", proxyServer),
queue, connection, pcc, pcc, ndrc2,
new AsyncTasksConfiguration(new TimeSpan()),
new AsyncTasksConfiguration(new TimeSpan()),
new ConnectionTimeoutConfiguration(Consts.OpenTimeout, Consts.SendTimeout));
_proxy.Build();
}
public void ProxySystem_CreateSync_SendSyncDataToFakeDistributor_NoError()
{
var queue = new QueueConfiguration(1, 100);
var connection = new ConnectionConfiguration("testService", 10);
var ndrc2 = new NetReceiverConfiguration(32190, "localhost", "testService");
var pcc = new ProxyCacheConfiguration(TimeSpan.FromSeconds(20000000));
var proxy = new TestProxySystem(new ServerId("", 1), queue, connection, pcc, pcc, ndrc2,
new AsyncTasksConfiguration(TimeSpan.FromMinutes(60000)),
new AsyncTasksConfiguration(TimeSpan.FromMinutes(60000)),
new ConnectionTimeoutConfiguration(Consts.OpenTimeout, Consts.SendTimeout));
proxy.Build();
proxy.Start();
var distr = new ServerId("localhost", 22190);
TestHelper.OpenDistributorHost(distr, connection);
proxy.Distributor.SayIAmHere(distr);
var provider = new StoredDataHashCalculator();
var hash = provider.CalculateHashFromKey(10);
var transaction = new Transaction(hash, "")
{
OperationName = OperationName.Create,
OperationType = OperationType.Sync
};
Task.Factory.StartNew(() =>
{
Thread.Sleep(200);
transaction.Complete();
proxy.Queue.ProxyDistributorQueue.Add(new OperationCompleteCommand(transaction));
});
try
{
var api = proxy.CreateApi("", false, provider);
var wait = api.CreateSync(10, TestHelper.CreateStoredData(10));
wait.Wait();
Assert.AreEqual(TransactionState.Complete, wait.Result.State);
}
catch (Exception e)
{
Assert.Fail(e.Message);
}
proxy.Dispose();
}
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 void Initialize()
{
const int proxyServer = 22020;
var queue = new QueueConfiguration(2, 100);
var connection = new ConnectionConfiguration("testService", 10);
var ndrc2 = new NetReceiverConfiguration(proxyServer, "localhost", "testService");
var pcc = new ProxyCacheConfiguration(TimeSpan.FromSeconds(20));
var pccc2 = new ProxyCacheConfiguration(TimeSpan.FromSeconds(40));
_proxy = new TestProxySystem(new ServerId("localhost", proxyServer),
queue, connection, pcc, pccc2, ndrc2,
new AsyncTasksConfiguration(new TimeSpan()),
new AsyncTasksConfiguration(new TimeSpan()),
new ConnectionTimeoutConfiguration(Consts.OpenTimeout, Consts.SendTimeout));
_proxy.Build();
_writer1 = new TestWriterGate();
_writer2 = new TestWriterGate();
_distributor1 = new TestDistributorGate();
_distributor2 = new TestDistributorGate();
}
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 void InputModuleWithParallel_ProcessAsync_SendToOneServersAndTimeoutInCache_Success()
{
const int distrServer1 = 22166;
const int distrServer2 = 23166;
const int storageServer1 = 22167;
var q1 = new GlobalQueueInner();
var writer =
new HashWriter(new HashMapConfiguration("testAsyncTrans1S", HashMapCreationMode.CreateNew, 1, 1, HashFileType.Distributor));
writer.CreateMap();
writer.SetServer(0, "localhost", storageServer1, 157);
writer.Save();
#region hell
GlobalQueue.SetQueue(q1);
var connection = new ConnectionConfiguration("testService", 10);
var distrconfig = new DistributorHashConfiguration(1);
var queueconfig = new QueueConfiguration(1, 100);
var dnet = new DistributorNetModule(connection,
new ConnectionTimeoutConfiguration(Consts.OpenTimeout, Consts.SendTimeout));
var ddistributor = new DistributorModule(new AsyncTasksConfiguration(TimeSpan.FromMinutes(5)),
new AsyncTasksConfiguration(TimeSpan.FromMinutes(5)), distrconfig,
queueconfig, dnet,
new ServerId("localhost", distrServer1),
new ServerId("localhost", distrServer2),
new HashMapConfiguration("testAsyncTrans1S",
HashMapCreationMode.ReadFromFile,
1, 1, HashFileType.Distributor));
dnet.SetDistributor(ddistributor);
var tranc = new TransactionModule(new QueueConfiguration(1, 1000), dnet, new TransactionConfiguration(4),
distrconfig);
var cache = new DistributorTimeoutCache(TimeSpan.FromMilliseconds(2000), TimeSpan.FromMilliseconds(200000));
var main = new MainLogicModule(cache, ddistributor, tranc);
cache.SetMainLogicModule(main);
var netReceive4 = new NetReceiverConfiguration(distrServer1, "localhost", "testService");
var netReceive42 = new NetReceiverConfiguration(distrServer2, "localhost", "testService");
var input = new InputModuleWithParallel(new QueueConfiguration(2, 100000), main, tranc);
var receiver4 = new NetDistributorReceiver(main, input, ddistributor, netReceive4, netReceive42);
#endregion
var s = TestHelper.OpenWriterHost(new ServerId("localhost", storageServer1),
new ConnectionConfiguration("testService", 10));
main.Start();
receiver4.Start();
input.Start();
dnet.Start();
ddistributor.Start();
q1.Start();
var list = new List <InnerData>();
const int count = 1;
for (int i = 1; i < count + 1; i++)
{
var ev =
new InnerData(new Transaction(HashConvertor.GetString(i.ToString(CultureInfo.InvariantCulture)), "")
{
OperationName = OperationName.Create,
OperationType = OperationType.Async
})
{
Data = CommonDataSerializer.Serialize(i)
};
list.Add(ev);
}
foreach (var data in list)
{
input.ProcessAsync(data);
}
Thread.Sleep(TimeSpan.FromMilliseconds(1000));
Assert.AreEqual(count, s.Value);
foreach (var data in list)
{
var transaction = main.GetTransactionState(data.Transaction.UserTransaction);
Assert.AreEqual(TransactionState.TransactionInProcess, transaction.State);
}
Thread.Sleep(TimeSpan.FromMilliseconds(2000));
foreach (var data in list)
{
var transaction = main.GetTransactionState(data.Transaction.UserTransaction);
if (transaction.State == TransactionState.DontExist)
{
Thread.Sleep(1000);
}
transaction = main.GetTransactionState(data.Transaction.UserTransaction);
Assert.AreEqual(TransactionState.Error, transaction.State);
}
q1.Dispose();
ddistributor.Dispose();
dnet.Dispose();
cache.Dispose();
}
public ProxyNetReceiver(ProxyDistributorModule distributorModule, NetReceiverConfiguration receiverConfiguration)
: base(receiverConfiguration)
{
Contract.Requires(distributorModule != null);
_distributorModule = distributorModule;
}
public void Writer_ProcessDataFromDistributor_CRUD_TwoWriters()
{
const int distrServer1 = 22201;
const int distrServer12 = 22202;
const int storageServer1 = 22203;
const int storageServer2 = 22204;
var writer =
new HashWriter(new HashMapConfiguration("TestCreateReadDelete", HashMapCreationMode.CreateNew, 2, 3,
HashFileType.Distributor));
writer.CreateMap();
writer.SetServer(0, "localhost", storageServer1, 157);
writer.SetServer(1, "localhost", storageServer2, 157);
writer.Save();
#region hell
var connection = new ConnectionConfiguration("testService", 10);
var distrconfig = new DistributorHashConfiguration(1);
var queueconfig = new QueueConfiguration(2, 100);
var netReceive4 = new NetReceiverConfiguration(distrServer1, "localhost", "testService");
var netReceive42 = new NetReceiverConfiguration(distrServer12, "localhost", "testService");
var d = new DistributorSystem(new ServerId("localhost", distrServer1),
new ServerId("localhost", distrServer12),
distrconfig, queueconfig, connection,
new DistributorCacheConfiguration(TimeSpan.FromSeconds(20), TimeSpan.FromSeconds(20)), netReceive4,
netReceive42, new TransactionConfiguration(4),
new HashMapConfiguration("TestCreateReadDelete", HashMapCreationMode.ReadFromFile,
1, 1, HashFileType.Distributor), new AsyncTasksConfiguration(TimeSpan.FromMinutes(5)),
new AsyncTasksConfiguration(TimeSpan.FromMinutes(5)),
new ConnectionTimeoutConfiguration(Consts.OpenTimeout, Consts.SendTimeout));
_writer1.Build(storageServer1, "TestCreateReadDelete", 2);
_writer2.Build(storageServer2, "TestCreateReadDelete", 2);
var mem = _writer1.Db.GetDbModules.First() as TestDbInMemory;
var mem2 = _writer2.Db.GetDbModules.First() as TestDbInMemory;
_proxy.Start();
d.Build();
d.Start();
_writer1.Start();
_writer2.Start();
_proxy.Distributor.SayIAmHere(new ServerId("localhost", distrServer12));
#endregion
const int count = 50;
var api = _proxy.CreateApi("Int", false, new IntHashConvertor());
for (int i = 0; i < count; i++)
{
var task = api.CreateSync(i, i);
task.Wait();
Assert.AreEqual(i + 1, mem.Local + mem2.Local);
}
for (int i = 0; i < count; i++)
{
UserTransaction user;
var data = api.Read(i, out user);
Assert.AreEqual(i, data);
}
for (int i = 0; i < count; i++)
{
var task = api.DeleteSync(i);
task.Wait();
Assert.AreEqual(count - i - 1, mem.Local + mem2.Local);
}
for (int i = 0; i < count; i++)
{
UserTransaction user;
var data = api.Read(i, out user);
Assert.IsNull(data);
}
_writer2.Dispose();
_writer1.Dispose();
d.Dispose();
_proxy.Dispose();
}
public void ProxyAndDistributor_Read_DirectReadFromOneServer()
{
const int storageServer1 = 22462;
const int distrServerForProxy = 23263;
const int distrServerForDb = 22263;
var writer = new HashWriter(new HashMapConfiguration("TestProxyAndDistributorRead1ServerFull", HashMapCreationMode.CreateNew, 1, 3, HashFileType.Distributor));
writer.CreateMap();
writer.SetServer(0, "localhost", storageServer1, 157);
writer.Save();
var dhc = new DistributorHashConfiguration(1);
var queue = new QueueConfiguration(1, 100);
var connection = new ConnectionConfiguration("testService", 10);
var dcc = new DistributorCacheConfiguration(TimeSpan.FromMilliseconds(600), TimeSpan.FromMilliseconds(1000));
var ndrc = new NetReceiverConfiguration(distrServerForDb, "localhost", "testService");
var ndrc12 = new NetReceiverConfiguration(distrServerForProxy, "localhost", "testService");
var distr = new DistributorSystem(new ServerId("localhost", distrServerForDb),
new ServerId("localhost", distrServerForProxy),
dhc, queue, connection, dcc, ndrc, ndrc12,
new TransactionConfiguration(1),
new HashMapConfiguration("TestProxyAndDistributorRead1ServerFull",
HashMapCreationMode.ReadFromFile, 1, 1, HashFileType.Distributor),
new AsyncTasksConfiguration(TimeSpan.FromMinutes(5)),
new AsyncTasksConfiguration(TimeSpan.FromMinutes(5)),
new ConnectionTimeoutConfiguration(Consts.OpenTimeout, Consts.SendTimeout));
var server = new ServerId("localhost", distrServerForProxy);
var storage = new WriterSystem(new ServerId("localhost", storageServer1), queue,
new NetReceiverConfiguration(storageServer1, "localhost", "testService")
, new NetReceiverConfiguration(1, "fake", "fake"),
new HashMapConfiguration("TestProxyAndDistributorRead1ServerFull",
HashMapCreationMode.ReadFromFile, 1, 1, HashFileType.Writer),
connection, new RestoreModuleConfiguration(10, new TimeSpan()),
new RestoreModuleConfiguration(10, new TimeSpan()),
new ConnectionTimeoutConfiguration(Consts.OpenTimeout, Consts.SendTimeout),
new RestoreModuleConfiguration(-1, TimeSpan.FromHours(1), false, TimeSpan.FromHours(1)));
storage.Build();
distr.Build();
storage.DbModule.AddDbModule(new TestDbInMemory());
storage.Start();
_proxy.Start();
distr.Start();
GlobalQueue.Queue.Start();
_proxy.Distributor.SayIAmHere(server);
const int count = 50;
var api = _proxy.CreateApi("Int", false, new IntHashConvertor());
for (int i = 1; i < count; i++)
{
var task = api.CreateSync(i, i);
task.Wait();
Assert.AreEqual(TransactionState.Complete, task.Result.State);
}
for (int i = 1; i < count; i++)
{
UserTransaction transaction;
var read = (int)api.Read(i, out transaction);
Assert.AreEqual(i, read);
}
_proxy.Dispose();
distr.Dispose();
storage.Dispose();
}
public void ClientProxy_CrudOperations()
{
const int distrServer1 = 22206;
const int distrServer12 = 22207;
const int storageServer = 22208;
#region hell
var writer = new HashWriter(new HashMapConfiguration("TestClientProxy", HashMapCreationMode.CreateNew, 1, 1, HashFileType.Distributor));
writer.CreateMap();
writer.SetServer(0, "localhost", storageServer, 157);
writer.Save();
var distrHash = new DistributorHashConfiguration(1);
var queue = new QueueConfiguration(1, 100);
var connection = new ConnectionConfiguration("testService", 10);
var distrCache = new DistributorCacheConfiguration(TimeSpan.FromMilliseconds(10000), TimeSpan.FromMilliseconds(1000000));
var netReceive1 = new NetReceiverConfiguration(distrServer1, "localhost", "testService");
var netReceive12 = new NetReceiverConfiguration(distrServer12, "localhost", "testService");
var trans = new TransactionConfiguration(1);
var hashMap = new HashMapConfiguration("TestClientProxy", HashMapCreationMode.ReadFromFile, 1, 1, HashFileType.Writer);
var async = new AsyncTasksConfiguration(TimeSpan.FromSeconds(10));
var distr = new DistributorSystem(new ServerId("localhost", distrServer1),
new ServerId("localhost", distrServer12),
distrHash, queue, connection, distrCache, netReceive1, netReceive12, trans,
new HashMapConfiguration("TestClientProxy", HashMapCreationMode.ReadFromFile, 1, 1,
HashFileType.Distributor), async, async,
new ConnectionTimeoutConfiguration(Consts.OpenTimeout, Consts.SendTimeout));
var netReceivedb = new NetReceiverConfiguration(storageServer, "localhost", "testService");
var restore = new RestoreModuleConfiguration(4, TimeSpan.FromMinutes(1));
var storage = new WriterSystem(new ServerId("localhost", storageServer), queue,
netReceivedb, new NetReceiverConfiguration(1, "fake", "fake"), hashMap, connection, restore, restore,
new ConnectionTimeoutConfiguration(Consts.OpenTimeout, Consts.SendTimeout),
new RestoreModuleConfiguration(-1, TimeSpan.FromHours(1), false, TimeSpan.FromHours(1)));
#endregion
distr.Build();
distr.Start();
_proxy.Int.SayIAmHere("localhost", distrServer12);
storage.Build();
storage.DbModule.AddDbModule(new TestDbInMemory());
storage.Start();
const int count = 50;
for (int i = 0; i < count; i++)
{
var state = _proxy.Int.CreateSync(i, i);
Assert.AreEqual(RequestState.Complete, state.State);
}
for (int i = 0; i < count; i++)
{
RequestDescription description;
var read = _proxy.Int.Read(i, out description);
Assert.AreEqual(i, read);
Assert.AreEqual(RequestState.Complete, description.State);
}
for (int i = 0; i < count; i++)
{
var state = _proxy.Int.DeleteSync(i);
Assert.AreEqual(RequestState.Complete, state.State);
}
for (int i = 0; i < count; i++)
{
RequestDescription description;
_proxy.Int.Read(i, out description);
Assert.AreEqual(RequestState.DataNotFound, description.State);
}
distr.Dispose();
storage.Dispose();
}
public NetWriterReceiverForCollector(InputModule inputModule, DistributorModule distributor, NetReceiverConfiguration configuration)
: base(configuration)
{
_inputModule = inputModule;
_distributor = distributor;
}
public NetWriterReceiverForWrite(InputModule inputModule, DistributorModule distributor, NetReceiverConfiguration receiverConfiguration)
: base(receiverConfiguration)
{
Contract.Requires(inputModule != null);
Contract.Requires(distributor != null);
_distributor = distributor;
_inputModule = inputModule;
}
public void ProxyAndDistributor_Create_WriterMock()
{
var writer = new HashWriter(new HashMapConfiguration("test5", HashMapCreationMode.CreateNew, 1, 3, HashFileType.Collector));
writer.CreateMap();
writer.SetServer(0, "localhost", 21181, 157);
writer.Save();
var dhc = new DistributorHashConfiguration(1);
var queue = new QueueConfiguration(1, 100);
var connection = new ConnectionConfiguration("testService", 10);
var dcc = new DistributorCacheConfiguration(TimeSpan.FromMilliseconds(600), TimeSpan.FromMilliseconds(1000));
var ndrc = new NetReceiverConfiguration(22222, "localhost", "testService");
var ndrc12 = new NetReceiverConfiguration(23222, "localhost", "testService");
var distr = new DistributorSystem(new ServerId("localhost", 22222),
new ServerId("localhost", 23222),
dhc, queue, connection, dcc, ndrc, ndrc12,
new TransactionConfiguration(1),
new HashMapConfiguration("test5", HashMapCreationMode.ReadFromFile, 1, 1, HashFileType.Distributor),
new AsyncTasksConfiguration(TimeSpan.FromMilliseconds(200)),
new AsyncTasksConfiguration(TimeSpan.FromMinutes(5)),
new ConnectionTimeoutConfiguration(Consts.OpenTimeout, Consts.SendTimeout));
var server = new ServerId("localhost", 23222);
try
{
distr.Build();
_proxy.Start();
distr.Start();
GlobalQueue.Queue.Start();
_proxy.Distributor.SayIAmHere(server);
var api = _proxy.CreateApi("", false, new StoredDataHashCalculator());
var transaction = api.Create(10, TestHelper.CreateStoredData(10));
Assert.IsNotNull(transaction);
Thread.Sleep(200);
transaction = _proxy.GetTransaction(transaction);
Assert.IsNotNull(transaction);
Assert.AreEqual(TransactionState.TransactionInProcess, transaction.State);
Thread.Sleep(1000);
transaction = _proxy.GetTransaction(transaction);
Assert.IsNotNull(transaction);
Assert.AreEqual(TransactionState.DontExist, transaction.State);
var server1 = new ServerId("localhost", 21181);
var netconfig = new ConnectionConfiguration("testService", 1);
TestHelper.OpenWriterHost(server1, netconfig);
Thread.Sleep(TimeSpan.FromMilliseconds(1000));
transaction = api.Create(11, TestHelper.CreateStoredData(11));
Assert.IsNotNull(transaction);
Thread.Sleep(200);
transaction = _proxy.GetTransaction(transaction);
GlobalQueue.Queue.TransactionQueue.Add(new Transaction(transaction));
Thread.Sleep(100);
transaction = _proxy.GetTransaction(transaction);
Assert.IsNotNull(transaction);
if (transaction.State == TransactionState.TransactionInProcess)
{
Thread.Sleep(100);
transaction = _proxy.GetTransaction(transaction);
}
Assert.AreEqual(TransactionState.Complete, transaction.State);
Thread.Sleep(1000);
transaction = _proxy.GetTransaction(transaction);
Assert.IsNotNull(transaction);
Assert.AreEqual(TransactionState.DontExist, transaction.State);
}
finally
{
_proxy.Dispose();
distr.Dispose();
}
}
public void ProxyAndDistributor_Read_DirectReadFromTwoServer_TwoReplics_LongRead()
{
const int storageServer1 = 22281;
const int storageServer2 = 22282;
const int distrServerForProxy = 23283;
const int distrServerForDb = 22283;
var writer =
new HashWriter(new HashMapConfiguration("TestProxyAndDistributorRead2Servers2ReplicsFullLongRead",
HashMapCreationMode.CreateNew, 2, 3, HashFileType.Distributor));
writer.CreateMap();
writer.SetServer(0, "localhost", storageServer1, 157);
writer.SetServer(1, "localhost", storageServer2, 157);
writer.Save();
var dhc = new DistributorHashConfiguration(2);
var queue = new QueueConfiguration(1, 100);
var connection = new ConnectionConfiguration("testService", 10);
var dcc = new DistributorCacheConfiguration(TimeSpan.FromMilliseconds(600), TimeSpan.FromMilliseconds(1000));
var ndrc = new NetReceiverConfiguration(distrServerForDb, "localhost", "testService");
var ndrc12 = new NetReceiverConfiguration(distrServerForProxy, "localhost", "testService");
var distr = new DistributorSystem(new ServerId("localhost", distrServerForDb),
new ServerId("localhost", distrServerForProxy),
dhc, queue, connection, dcc, ndrc, ndrc12,
new TransactionConfiguration(1),
new HashMapConfiguration("TestProxyAndDistributorRead2Servers2ReplicsFullLongRead",
HashMapCreationMode.ReadFromFile, 1, 2, HashFileType.Distributor),
new AsyncTasksConfiguration(TimeSpan.FromSeconds(2)),
new AsyncTasksConfiguration(TimeSpan.FromSeconds(2)),
new ConnectionTimeoutConfiguration(Consts.OpenTimeout, Consts.SendTimeout));
var server = new ServerId("localhost", distrServerForProxy);
var storage1 = new WriterSystem(new ServerId("localhost", storageServer1), queue,
new NetReceiverConfiguration(storageServer1, "localhost", "testService")
, new NetReceiverConfiguration(1, "fake", "fake"),
new HashMapConfiguration("TestProxyAndDistributorRead2Servers2ReplicsFullLongRead",
HashMapCreationMode.ReadFromFile, 1, 1, HashFileType.Writer),
connection, new RestoreModuleConfiguration(10, new TimeSpan()),
new RestoreModuleConfiguration(10, new TimeSpan()),
new ConnectionTimeoutConfiguration(Consts.OpenTimeout, Consts.SendTimeout),
new RestoreModuleConfiguration(-1, TimeSpan.FromHours(1), false, TimeSpan.FromHours(1)));
var storage2 = new WriterSystem(new ServerId("localhost", storageServer2), queue,
new NetReceiverConfiguration(storageServer2, "localhost", "testService")
, new NetReceiverConfiguration(1, "fake", "fake"),
new HashMapConfiguration("TestProxyAndDistributorRead2Servers2ReplicsFullLongRead",
HashMapCreationMode.ReadFromFile, 1, 1, HashFileType.Writer),
connection, new RestoreModuleConfiguration(10, new TimeSpan()),
new RestoreModuleConfiguration(10, new TimeSpan()),
new ConnectionTimeoutConfiguration(Consts.OpenTimeout, Consts.SendTimeout),
new RestoreModuleConfiguration(-1, TimeSpan.FromHours(1), false, TimeSpan.FromHours(1)));
storage1.Build();
storage2.Build();
distr.Build();
storage1.DbModule.AddDbModule(new TestDbInMemory());
storage2.DbModule.AddDbModule(new TestDbInMemory());
_proxy.Start();
distr.Start();
_proxy.Distributor.SayIAmHere(server);
var api = _proxy.CreateApi("Int", false, new IntHashConvertor());
var task = api.CreateSync(10, 10);
task.Wait();
storage1.Start();
storage2.Start();
Thread.Sleep(TimeSpan.FromMilliseconds(4000));
task = api.CreateSync(10, 10);
task.Wait();
Assert.AreEqual(TransactionState.Complete, task.Result.State);
UserTransaction transaction;
var data = api.Read(10, out transaction);
Assert.AreEqual(10, data);
_proxy.Dispose();
distr.Dispose();
storage1.Dispose();
storage2.Dispose();
}
public void ProxyAndDistributor_Create_WriterMock_TwoReplics()
{
var writer = new HashWriter(new HashMapConfiguration("test3", HashMapCreationMode.CreateNew, 2, 3, HashFileType.Writer));
writer.CreateMap();
writer.SetServer(0, "localhost", 21191, 157);
writer.SetServer(1, "localhost", 21192, 157);
writer.Save();
writer = new HashWriter(new HashMapConfiguration("test4", HashMapCreationMode.CreateNew, 2, 3, HashFileType.Writer));
writer.CreateMap();
writer.SetServer(0, "localhost", 21193, 157);
writer.SetServer(1, "localhost", 21192, 157);
writer.Save();
var dhc = new DistributorHashConfiguration(2);
var queue = new QueueConfiguration(1, 100);
var connection = new ConnectionConfiguration("testService", 10);
var dcc = new DistributorCacheConfiguration(TimeSpan.FromMilliseconds(400), TimeSpan.FromMilliseconds(1000));
var ndrc = new NetReceiverConfiguration(22223, "localhost", "testService");
var ndrc12 = new NetReceiverConfiguration(23223, "localhost", "testService");
var ndrc2 = new NetReceiverConfiguration(22224, "localhost", "testService");
var ndrc22 = new NetReceiverConfiguration(23224, "localhost", "testService");
var distr = new DistributorSystem(new ServerId("localhost", 22223),
new ServerId("localhost", 23223),
dhc, queue, connection, dcc, ndrc, ndrc12,
new TransactionConfiguration(1),
new HashMapConfiguration("test3", HashMapCreationMode.ReadFromFile, 1, 1, HashFileType.Distributor),
new AsyncTasksConfiguration(TimeSpan.FromMinutes(5)),
new AsyncTasksConfiguration(TimeSpan.FromMinutes(5)),
new ConnectionTimeoutConfiguration(Consts.OpenTimeout, Consts.SendTimeout));
var distr2 = new DistributorSystem(new ServerId("localhost", 22224),
new ServerId("localhost", 23224),
dhc, queue, connection, dcc, ndrc2, ndrc22,
new TransactionConfiguration(1),
new HashMapConfiguration("test4", HashMapCreationMode.ReadFromFile, 1, 1, HashFileType.Distributor),
new AsyncTasksConfiguration(TimeSpan.FromMinutes(5)),
new AsyncTasksConfiguration(TimeSpan.FromMinutes(5)),
new ConnectionTimeoutConfiguration(Consts.OpenTimeout, Consts.SendTimeout));
var ser = new ServerId("localhost", 23223);
var ser2 = new ServerId("localhost", 23224);
try
{
distr.Build();
distr2.Build();
_proxy.Start();
distr.Start();
distr2.Start();
_proxy.Distributor.SayIAmHere(ser);
_proxy.Distributor.SayIAmHere(ser2);
var server1 = new ServerId("localhost", 21191);
var server2 = new ServerId("localhost", 21192);
var server3 = new ServerId("localhost", 21193);
var netconfig = new ConnectionConfiguration("testService", 1);
var s1 = TestHelper.OpenWriterHost(server1, netconfig);
var s2 = TestHelper.OpenWriterHost(server2, netconfig);
var s3 = TestHelper.OpenWriterHost(server3, netconfig);
Thread.Sleep(TimeSpan.FromMilliseconds(300));
var api = _proxy.CreateApi("", false, new StoredDataHashCalculator());
api.Create(10, TestHelper.CreateStoredData(10));
api.Create(11, TestHelper.CreateStoredData(11));
Thread.Sleep(TimeSpan.FromMilliseconds(1000));
Assert.AreEqual(1, s1.Value);
Assert.AreEqual(2, s2.Value);
Assert.AreEqual(1, s3.Value);
}
finally
{
_proxy.Dispose();
distr.Dispose();
distr2.Dispose();
}
}
public void Writer_Restore_ThreeServers()
{
var writer =
new HashWriter(new HashMapConfiguration("test11", HashMapCreationMode.CreateNew, 3, 3,
HashFileType.Distributor));
writer.CreateMap();
writer.SetServer(0, "localhost", storageServer1, 157);
writer.SetServer(1, "localhost", storageServer2, 157);
writer.SetServer(2, "localhost", storageServer3, 157);
writer.Save();
#region hell
var queue = new QueueConfiguration(2, 100);
var connection = new ConnectionConfiguration("testService", 10);
var ndrc2 = new NetReceiverConfiguration(proxyServer, "localhost", "testService");
var pcc = new ProxyCacheConfiguration(TimeSpan.FromSeconds(20));
var pccc2 = new ProxyCacheConfiguration(TimeSpan.FromSeconds(40));
var proxy = new TestProxySystem(new ServerId("localhost", proxyServer),
queue, connection, pcc, pccc2, ndrc2,
new AsyncTasksConfiguration(new TimeSpan()),
new AsyncTasksConfiguration(new TimeSpan()),
new ConnectionTimeoutConfiguration(Consts.OpenTimeout, Consts.SendTimeout));
_distrTest.Build(1, distrServer1, distrServer12, "test11");
_writer1.Build(storageServer1, "test11", 1);
_writer2.Build(storageServer2, "test11", 1);
_writer3.Build(storageServer3, "test11", 1);
#endregion
#region hell2
proxy.Build();
proxy.Start();
_distrTest.Start();
_writer1.Start();
proxy.Distributor.SayIAmHere(new ServerId("localhost", distrServer12));
Thread.Sleep(TimeSpan.FromMilliseconds(200));
int count = 50;
int counter = 0;
var api = proxy.CreateApi("Int", false, new IntHashConvertor());
for (int i = 0; i < count; i++)
{
bool flag = false;
while (!flag && counter < 3)
{
var task = api.CreateSync(i + 1, i + 1);
task.Wait();
flag = true;
if (task.Result.IsError)
{
counter++;
flag = false;
}
}
}
Assert.AreEqual(2, counter);
#endregion
var mem = _writer1.Db.GetDbModules.First() as TestDbInMemory;
var mem2 = _writer2.Db.GetDbModules.First() as TestDbInMemory;
var mem3 = _writer3.Db.GetDbModules.First() as TestDbInMemory;
if (count > 1)
{
Assert.AreNotEqual(count, mem.Local);
Assert.AreNotEqual(count, mem.Remote);
}
Assert.AreEqual(count, mem.Local + mem.Remote);
_writer2.Start();
_writer3.Start();
_writer2.Distributor.Restore(new ServerId("localhost", distrServer1), false);
Thread.Sleep(TimeSpan.FromMilliseconds(4000));
_writer3.Distributor.Restore(new ServerId("localhost", distrServer1), false);
Thread.Sleep(TimeSpan.FromMilliseconds(3000));
Assert.AreEqual(0, mem.Remote);
Assert.AreEqual(0, mem2.Remote);
Assert.AreEqual(0, mem3.Remote);
Assert.AreEqual(count, mem.Local + mem2.Local + mem3.Local);
Assert.AreEqual(false, _writer1.Restore.IsNeedRestore);
Assert.AreEqual(false, _writer2.Restore.IsNeedRestore);
Assert.AreEqual(false, _writer3.Restore.IsNeedRestore);
_distrTest.Dispose();
_writer1.Dispose();
_writer2.Dispose();
_writer3.Dispose();
proxy.Dispose();
}
