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 DistributorModule(
AsyncTasksConfiguration asyncPing,
AsyncTasksConfiguration asyncCheck,
DistributorHashConfiguration configuration,
QueueConfiguration queueConfiguration,
DistributorNetModule distributorNet,
ServerId localfordb,
ServerId localforproxy,
HashMapConfiguration hashMapConfiguration)
{
Contract.Requires(configuration != null);
Contract.Requires(queueConfiguration != null);
Contract.Requires(distributorNet != null);
Contract.Requires(localfordb != null);
Contract.Requires(localforproxy != null);
Contract.Requires(asyncPing != null);
_asyncPing = asyncPing;
_asyncTaskModule = new AsyncTaskModule(queueConfiguration);
_queueConfiguration = queueConfiguration;
_modelOfDbWriters = new WriterSystemModel(configuration, hashMapConfiguration);
_modelOfAnotherDistributors = new DistributorSystemModel();
_distributorNet = distributorNet;
_localfordb = localfordb;
_localforproxy = localforproxy;
_asyncCheck = asyncCheck;
_queue = GlobalQueue.Queue;
}
public TransactionPool(int maxElemCount, INetModule net, DistributorHashConfiguration configuration)
: base(maxElemCount)
{
Contract.Requires(_net != null);
Contract.Requires(configuration != null);
_net = net;
_countReplics = configuration.CountReplics;
}
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 WriterSystemModel(DistributorHashConfiguration configuration, HashMapConfiguration mapConfiguration)
{
Contract.Requires(configuration != null);
Contract.Requires(mapConfiguration != null);
_configuration = configuration;
_lock = new ReaderWriterLockSlim();
_servers = new List <WriterDescription>();
_map = new HashMap(mapConfiguration);
}
public void TransactionModule_ProcessSyncWithExecutor_RollbackNoEnoughServers()
{
var server1 = new ServerId("localhost", 21141);
var server2 = new ServerId("localhost", 21142);
var server3 = new ServerId("localhost", 21143);
var netconfig = new ConnectionConfiguration("testService", 10);
var queueconfig = new QueueConfiguration(1, 100);
var distrconfig = new DistributorHashConfiguration(2);
var distributor = new DistributorModule(new AsyncTasksConfiguration(TimeSpan.FromMinutes(5)),
new AsyncTasksConfiguration(TimeSpan.FromMinutes(5)), distrconfig,
queueconfig, null, new ServerId("localhost", 1),
new ServerId("localhost", 1),
new HashMapConfiguration("test10", HashMapCreationMode.CreateNew, 1, 1, HashFileType.Distributor));
var net = new DistributorNetModule(netconfig,
new ConnectionTimeoutConfiguration(Consts.OpenTimeout, Consts.SendTimeout));
net.SetDistributor(distributor);
distributor.Start();
net.Start();
GlobalQueue.Queue.Start();
var s1 = TestHelper.OpenWriterHost(server1, netconfig);
var s2 = TestHelper.OpenWriterHost(server2, netconfig);
net.ConnectToWriter(server1);
net.ConnectToWriter(server2);
Thread.Sleep(TimeSpan.FromMilliseconds(1000));
var ev = new InnerData(new Transaction("", ""))
{
Transaction = { Destination = new List <ServerId> {
server1, server2, server3
} }
};
var trm = new TransactionModule(new QueueConfiguration(1, 1000), net, new TransactionConfiguration(1),
new DistributorHashConfiguration(3));
trm.Start();
using (var trans = trm.Rent())
{
trm.ProcessSyncWithExecutor(ev, trans.Element);
}
Thread.Sleep(TimeSpan.FromMilliseconds(100));
Assert.IsTrue(s1.Value <= 0);
Assert.IsTrue(s2.Value <= 0);
Assert.IsTrue(ev.Transaction.IsError);
net.Dispose();
trm.Dispose();
}
public CollectorModel(DistributorHashConfiguration configuration, HashMapConfiguration mapConfiguration,
bool useStart = true)
{
UseStart = useStart;
Contract.Requires(configuration != null);
Contract.Requires(mapConfiguration != null);
_configuration = configuration;
_lock = new ReaderWriterLockSlim();
_servers = new List <WriterDescription>();
_map = new HashMap(mapConfiguration);
}
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 NetModule_Process_SendDatatoAvaliableAndUnavalilableServers()
{
var server1 = new ServerId("localhost", 21121);
var server2 = new ServerId("localhost", 21122);
var server3 = new ServerId("localhost", 21123);
var netconfig = new ConnectionConfiguration("testService", 10);
var queueconfig = new QueueConfiguration(1, 100);
var distrconfig = new DistributorHashConfiguration(2);
var s1 = TestHelper.OpenWriterHost(server1, netconfig);
var s2 = TestHelper.OpenWriterHost(server2, netconfig);
var net = new DistributorNetModule(netconfig,
new ConnectionTimeoutConfiguration(Consts.OpenTimeout, Consts.SendTimeout));
var distributor = new DistributorModule(new AsyncTasksConfiguration(TimeSpan.FromMinutes(5)),
new AsyncTasksConfiguration(TimeSpan.FromMinutes(5)), distrconfig,
queueconfig, net, new ServerId("localhost", 1),
new ServerId("localhost", 1),
new HashMapConfiguration("test12", HashMapCreationMode.CreateNew, 1,
1, HashFileType.Distributor));
net.SetDistributor(distributor);
distributor.Start();
net.Start();
GlobalQueue.Queue.Start();
net.ConnectToWriter(server1);
net.ConnectToWriter(server2);
var ev = new InnerData(new Transaction("", ""))
{
Transaction = { Destination = new List <ServerId> {
server1
} }
};
var ret1 = net.Process(server1, ev);
var ret2 = net.Process(server2, ev);
var ret3 = net.Process(server3, ev);
Assert.AreEqual(1, s1.Value);
Assert.AreEqual(1, s2.Value);
Assert.AreEqual(typeof(SuccessResult), ret1.GetType());
Assert.AreEqual(typeof(SuccessResult), ret2.GetType());
Assert.AreEqual(typeof(ServerNotFoundResult), ret3.GetType());
GlobalQueue.Queue.Dispose();
net.Dispose();
}
public TransactionModule(QueueConfiguration configuration, INetModule net, TransactionConfiguration transactionConfiguration,
DistributorHashConfiguration distributorHashConfiguration)
{
Contract.Requires(net != null);
Contract.Requires(transactionConfiguration != null);
Contract.Requires(distributorHashConfiguration != null);
Contract.Requires(configuration != null);
_queueConfiguration = configuration;
_transactionPool = new TransactionPool(transactionConfiguration.ElementsCount, net,
distributorHashConfiguration);
CountReplics = distributorHashConfiguration.CountReplics;
_net = net;
_queue = GlobalQueue.Queue;
}
public void WriterSystemModel_GetDestination_ChechAvailableServers()
{
var config = new DistributorHashConfiguration(1);
var writer = new HashWriter(new HashMapConfiguration("test", HashMapCreationMode.CreateNew, 6, 3, HashFileType.Distributor));
writer.CreateMap();
writer.SetServer(0, "local", 11010, 157);
writer.SetServer(1, "local", 11011, 157);
writer.SetServer(2, "local", 11012, 157);
writer.SetServer(3, "local", 11010, 157);
writer.SetServer(4, "local", 11011, 157);
writer.SetServer(5, "local", 11012, 157);
writer.Save();
var model = new WriterSystemModel(config,
new HashMapConfiguration("test", HashMapCreationMode.ReadFromFile, 1,
1, HashFileType.Distributor));
model.Start();
var ev = new InnerData(new Transaction("123", ""))
{
Transaction = new Transaction(HashConvertor.GetString("1"), "")
};
ev.Transaction.Destination = new List <ServerId>();
var ret = model.GetDestination(ev);
Assert.IsTrue(ret.Count == 1);
model.ServerNotAvailable(ret.First());
var ret2 = model.GetDestination(ev);
Assert.IsTrue(ret2.Count == 1);
Assert.AreNotEqual(ret.First(), ret2.First());
model.ServerNotAvailable(ret2.First());
var ret3 = model.GetDestination(ev);
Assert.IsTrue(ret3.Count == 1);
Assert.AreNotEqual(ret.First(), ret3.First());
Assert.AreNotEqual(ret3.First(), ret2.First());
model.ServerNotAvailable(ret3.First());
var ret4 = model.GetDestination(ev);
Assert.IsTrue(ret4.Count == 0);
}
public void WriterSystemModel_GetUnavailableServers_CheckAvailableAndUnAvailableServers()
{
var server1 = new ServerId("local", 11010);
var server2 = new ServerId("local", 11011);
var server3 = new ServerId("local", 11012);
var config = new DistributorHashConfiguration(1);
var writer =
new HashWriter(new HashMapConfiguration("TestDbModelGetUnavalibaleServers",
HashMapCreationMode.CreateNew, 6, 3, HashFileType.Collector));
writer.CreateMap();
writer.SetServer(0, server1.RemoteHost, server1.Port, 157);
writer.SetServer(1, server2.RemoteHost, server2.Port, 157);
writer.SetServer(2, server3.RemoteHost, server3.Port, 157);
writer.SetServer(3, server1.RemoteHost, server1.Port, 157);
writer.SetServer(4, server2.RemoteHost, server2.Port, 157);
writer.SetServer(5, server3.RemoteHost, server3.Port, 157);
writer.Save();
var model = new WriterSystemModel(config,
new HashMapConfiguration("TestDbModelGetUnavalibaleServers",
HashMapCreationMode.ReadFromFile, 1,
1, HashFileType.Writer));
model.Start();
model.ServerNotAvailable(server1);
Assert.AreEqual(1, model.GetUnavailableServers().Count);
model.ServerNotAvailable(server1);
Assert.AreEqual(1, model.GetUnavailableServers().Count);
model.ServerNotAvailable(server2);
Assert.AreEqual(2, model.GetUnavailableServers().Count);
model.ServerNotAvailable(server3);
Assert.AreEqual(3, model.GetUnavailableServers().Count);
model.ServerAvailable(server1);
Assert.AreEqual(2, model.GetUnavailableServers().Count);
model.ServerAvailable(server1);
Assert.AreEqual(2, model.GetUnavailableServers().Count);
model.ServerAvailable(server2);
Assert.AreEqual(1, model.GetUnavailableServers().Count);
model.ServerAvailable(server3);
Assert.AreEqual(0, model.GetUnavailableServers().Count);
}
public void WriterSystemModel_GetDestination_CountReplics()
{
var config = new DistributorHashConfiguration(4);
var writer = new HashWriter(new HashMapConfiguration("testhash", HashMapCreationMode.CreateNew, 6, 3, HashFileType.Distributor));
writer.CreateMap();
writer.SetServer(0, "local", 11010, 157);
writer.SetServer(1, "local", 11011, 157);
writer.SetServer(2, "local", 11012, 157);
writer.SetServer(3, "local", 11010, 157);
writer.SetServer(4, "local", 11011, 157);
writer.SetServer(5, "local", 11012, 157);
writer.Save();
var model = new WriterSystemModel(config,
new HashMapConfiguration("testhash", HashMapCreationMode.ReadFromFile,
1, 1, HashFileType.Distributor));
model.Start();
var ev = new InnerData(new Transaction("123", ""))
{
Transaction = new Transaction(HashConvertor.GetString("1"), "")
};
ev.Transaction.Destination = new List <ServerId>();
var ret = model.GetDestination(ev);
Assert.IsTrue(ret.Count == 0);
model = new WriterSystemModel(new DistributorHashConfiguration(3),
new HashMapConfiguration("testhash", HashMapCreationMode.ReadFromFile, 1,
1, HashFileType.Distributor));
model.Start();
ret = model.GetDestination(ev);
Assert.AreEqual(3, ret.Count);
Assert.AreNotEqual(ret[0], ret[1]);
Assert.AreNotEqual(ret[0], ret[2]);
Assert.AreNotEqual(ret[2], ret[1]);
}
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 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 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 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 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 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()
{
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 MainLogic_ProcessWithData_SendAllReplicsThenObsoleteDataInCache()
{
var writer = new HashWriter(new HashMapConfiguration("test9", HashMapCreationMode.CreateNew, 2, 3, HashFileType.Distributor));
writer.CreateMap();
writer.SetServer(0, "localhost", 21111, 157);
writer.SetServer(1, "localhost", 21112, 157);
writer.Save();
var cache = new DistributorTimeoutCache(TimeSpan.FromMilliseconds(400), TimeSpan.FromMilliseconds(1000));
var distrconfig = new DistributorHashConfiguration(2);
var queueconfig = new QueueConfiguration(1, 100);
var netconfig = new ConnectionConfiguration("testService", 10);
var net = new DistributorNetModule(netconfig,
new ConnectionTimeoutConfiguration(Consts.OpenTimeout, Consts.SendTimeout));
var distributor = new DistributorModule(new AsyncTasksConfiguration(TimeSpan.FromMinutes(5)),
new AsyncTasksConfiguration(TimeSpan.FromMinutes(5)), distrconfig,
queueconfig, net, new ServerId("localhost", 1),
new ServerId("localhost", 1),
new HashMapConfiguration("test9", HashMapCreationMode.ReadFromFile,
1, 1, HashFileType.Distributor));
net.SetDistributor(distributor);
var transaction = new TransactionModule(new QueueConfiguration(1, 1000), net, new TransactionConfiguration(1),
distrconfig);
var main = new MainLogicModule(cache, distributor, transaction);
cache.SetMainLogicModule(main);
var server1 = new ServerId("localhost", 21111);
var server2 = new ServerId("localhost", 21112);
var s1 = TestHelper.OpenWriterHost(server1, netconfig);
var s2 = TestHelper.OpenWriterHost(server2, netconfig);
cache.Start();
distributor.Start();
net.Start();
transaction.Start();
main.Start();
GlobalQueue.Queue.Start();
net.ConnectToWriter(server1);
net.ConnectToWriter(server2);
Thread.Sleep(TimeSpan.FromMilliseconds(300));
var ev = new InnerData(new Transaction("123", ""))
{
Transaction =
new Transaction(HashConvertor.GetString("1"), "")
{
OperationName = OperationName.Create,
OperationType = OperationType.Async
}
};
ev.Transaction.Destination = new List <ServerId>();
using (var trans = transaction.Rent())
{
main.ProcessWithData(ev, trans.Element);
}
GlobalQueue.Queue.TransactionQueue.Add(ev.Transaction);
GlobalQueue.Queue.TransactionQueue.Add(ev.Transaction);
Thread.Sleep(TimeSpan.FromMilliseconds(100));
Assert.IsTrue(s1.Value > 0);
Assert.IsTrue(s2.Value > 0);
Assert.AreEqual(main.GetTransactionState(ev.Transaction.UserTransaction).State, TransactionState.Complete);
Thread.Sleep(TimeSpan.FromMilliseconds(1000));
Assert.AreEqual(main.GetTransactionState(ev.Transaction.UserTransaction).State, TransactionState.DontExist);
net.Dispose();
distributor.Dispose();
transaction.Dispose();
}
public void AsyncTaskModule_PingServers_AvalilableAfterSomeTime()
{
const int storageServer1 = 22131;
const int storageServer2 = 22132;
const int distrServer1 = 22134;
const int distrServer12 = 23134;
var writer = new HashWriter(new HashMapConfiguration("TestAsyncPing", 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(1, 100);
var dnet = new DistributorNetModule(connection,
new ConnectionTimeoutConfiguration(Consts.OpenTimeout, Consts.SendTimeout));
var ddistributor = new DistributorModule(new AsyncTasksConfiguration(TimeSpan.FromMilliseconds(200)),
new AsyncTasksConfiguration(TimeSpan.FromMilliseconds(200)),
distrconfig,
queueconfig, dnet,
new ServerId("localhost", distrServer1),
new ServerId("localhost", distrServer12),
new HashMapConfiguration("TestAsyncPing", HashMapCreationMode.ReadFromFile, 1, 1, HashFileType.Distributor));
dnet.SetDistributor(ddistributor);
dnet.Start();
ddistributor.Start();
GlobalQueue.Queue.Start();
#endregion
var data1 = new InnerData(new Transaction("", ""));
var data2 = new InnerData(new Transaction("eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee", ""));
var dest = ddistributor.GetDestination(data1, false);
var dest2 = ddistributor.GetDestination(data2, false);
dnet.Process(dest.First(), data1);
dnet.Process(dest2.First(), data1);
Thread.Sleep(100);
dest = ddistributor.GetDestination(data1, false);
dest2 = ddistributor.GetDestination(data2, false);
Assert.AreEqual(null, dest);
Assert.AreEqual(null, dest2);
TestHelper.OpenWriterHost(new ServerId("localhost", storageServer1),
new ConnectionConfiguration("testService", 10));
TestHelper.OpenWriterHost(new ServerId("localhost", storageServer2),
new ConnectionConfiguration("testService", 10));
Thread.Sleep(TimeSpan.FromMilliseconds(800));
Assert.AreEqual(1, ddistributor.GetDestination(data1, false).Count);
Assert.AreEqual(1, ddistributor.GetDestination(data2, false).Count);
ddistributor.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 ProxyDistributorModule_SayIAmHere_AddDistributor()
{
const int server1 = 22250;
const int server2 = 22251;
const int server3 = 22252;
const int server4 = 22253;
const int server42 = 23253;
const int server5 = 22254;
const int server52 = 23254;
var q1 = new GlobalQueueInner();
var q2 = new GlobalQueueInner();
var q3 = new GlobalQueueInner();
GlobalQueue.SetQueue(q1);
var queue = new QueueConfiguration(1, 1000);
var netconfig = new ConnectionConfiguration("testService", 10);
var netReceive = new NetReceiverConfiguration(server1, "localhost", "testService");
var net = new ProxyNetModule(netconfig,
new ConnectionTimeoutConfiguration(Consts.OpenTimeout, Consts.SendTimeout));
var distributor = new ProxyDistributorModule(new AsyncProxyCache(TimeSpan.FromMinutes(100)), net, queue, new ServerId("localhost", server1),
new AsyncTasksConfiguration(TimeSpan.FromDays(1)),
new AsyncTasksConfiguration(TimeSpan.FromDays(1)));
net.SetDistributor(distributor);
var receive = new ProxyNetReceiver(distributor, netReceive);
GlobalQueue.SetQueue(q2);
var netReceive2 = new NetReceiverConfiguration(server2, "localhost", "testService");
var net2 = new ProxyNetModule(netconfig,
new ConnectionTimeoutConfiguration(Consts.OpenTimeout, Consts.SendTimeout));
var distributor2 = new ProxyDistributorModule(new AsyncProxyCache(TimeSpan.FromMinutes(100)), net2, queue, new ServerId("localhost", server2),
new AsyncTasksConfiguration(TimeSpan.FromDays(1)),
new AsyncTasksConfiguration(TimeSpan.FromDays(1)));
net2.SetDistributor(distributor2);
var receive2 = new ProxyNetReceiver(distributor2, netReceive2);
GlobalQueue.SetQueue(q3);
var netReceive3 = new NetReceiverConfiguration(server3, "localhost", "testService");
var net3 = new ProxyNetModule(netconfig,
new ConnectionTimeoutConfiguration(Consts.OpenTimeout, Consts.SendTimeout));
var distributor3 = new ProxyDistributorModule(new AsyncProxyCache(TimeSpan.FromMinutes(100)), net3, queue, new ServerId("localhost", server3),
new AsyncTasksConfiguration(TimeSpan.FromDays(1)),
new AsyncTasksConfiguration(TimeSpan.FromDays(1)));
net3.SetDistributor(distributor3);
var receive3 = new ProxyNetReceiver(distributor3, netReceive3);
var distrconfig = new DistributorHashConfiguration(2);
var queueconfig = new QueueConfiguration(1, 100);
var dnet = new DistributorNetModule(netconfig,
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", server4),
new ServerId("localhost", server42),
new HashMapConfiguration("test7", HashMapCreationMode.CreateNew, 1, 1, HashFileType.Distributor));
dnet.SetDistributor(ddistributor);
var tranc = new TransactionModule(new QueueConfiguration(1, 1000), dnet, new TransactionConfiguration(4),
new DistributorHashConfiguration(1));
var main = new MainLogicModule(new DistributorTimeoutCache(new TimeSpan(), new TimeSpan()), ddistributor,
tranc);
var netReceive4 = new NetReceiverConfiguration(server4, "localhost", "testService");
var netReceive42 = new NetReceiverConfiguration(server42, "localhost", "testService");
var input = new InputModuleWithParallel(new QueueConfiguration(1, 1), main, tranc);
var receiver4 = new NetDistributorReceiver(main, input, ddistributor, netReceive4, netReceive42);
GlobalQueue.SetQueue(q1);
var dnet2 = new DistributorNetModule(netconfig,
new ConnectionTimeoutConfiguration(Consts.OpenTimeout, Consts.SendTimeout));
var ddistributor2 = new DistributorModule(new AsyncTasksConfiguration(TimeSpan.FromMinutes(5)),
new AsyncTasksConfiguration(TimeSpan.FromMinutes(5)), distrconfig,
queueconfig, dnet2,
new ServerId("localhost", server5),
new ServerId("localhost", server52),
new HashMapConfiguration("test6", HashMapCreationMode.CreateNew, 1, 1, HashFileType.Distributor));
dnet2.SetDistributor(ddistributor2);
var netReceive5 = new NetReceiverConfiguration(server5, "localhost", "testService");
var netReceive52 = new NetReceiverConfiguration(server52, "localhost", "testService");
var receiver5 = new NetDistributorReceiver(main,
new InputModuleWithParallel(new QueueConfiguration(1, 1), main,
tranc),
ddistributor2, netReceive5, netReceive52);
receive.Start();
receive2.Start();
receive3.Start();
receiver4.Start();
receiver5.Start();
net.Start();
net2.Start();
net3.Start();
distributor.Start();
distributor2.Start();
distributor3.Start();
dnet.Start();
dnet2.Start();
ddistributor.Start();
ddistributor2.Start();
q1.Start();
q2.Start();
q3.Start();
distributor.SayIAmHere(new ServerId("localhost", server42));
distributor2.SayIAmHere(new ServerId("localhost", server42));
var privateObject = new PrivateObject(distributor);
var dsm1 = (DistributorSystemModel)privateObject.GetField("_distributorSystemModel");
privateObject = new PrivateObject(distributor2);
var dsm2 = (DistributorSystemModel)privateObject.GetField("_distributorSystemModel");
Assert.AreEqual(1, dsm1.GetDistributorsList().Count);
Assert.AreEqual(1, dsm2.GetDistributorsList().Count);
ddistributor2.SayIAmHereRemoteResult(new ServerId("localhost", server42));
Thread.Sleep(TimeSpan.FromMilliseconds(300));
privateObject = new PrivateObject(ddistributor);
var mad1 =
(Impl.DistributorModules.Model.DistributorSystemModel)
privateObject.GetField("_modelOfAnotherDistributors");
privateObject = new PrivateObject(ddistributor2);
var mad2 =
(Impl.DistributorModules.Model.DistributorSystemModel)
privateObject.GetField("_modelOfAnotherDistributors");
Thread.Sleep(400);
Assert.AreEqual(1, mad1.GetDistributorList().Count);
Assert.AreEqual(1, mad2.GetDistributorList().Count);
distributor3.SayIAmHere(new ServerId("localhost", server52));
privateObject = new PrivateObject(distributor3);
var dsm3 = (DistributorSystemModel)privateObject.GetField("_distributorSystemModel");
Assert.AreEqual(2, dsm3.GetDistributorsList().Count);
q1.Dispose();
q2.Dispose();
q3.Dispose();
net.Dispose();
net2.Dispose();
net3.Dispose();
dnet.Dispose();
dnet2.Dispose();
ddistributor.Dispose();
ddistributor2.Dispose();
distributor.Dispose();
distributor2.Dispose();
distributor3.Dispose();
}
