public void Writer_Restore_TwoServersWhenOneServerNotAvailable()
{
#region hell
var writer =
new HashWriter(new HashMapConfiguration("TestRestore", HashMapCreationMode.CreateNew, 2, 1,
HashFileType.Distributor));
writer.CreateMap();
writer.SetServer(0, "localhost", storageServer1, 157);
writer.SetServer(1, "localhost", storageServer2, 157);
writer.Save();
var common = new CommonConfiguration(1, 100);
var storageNet1 = new StorageNetConfiguration("localhost", storageServer1, 157, "testService", 10);
var storageConfig = new StorageConfiguration("TestRestore", 1, 10,
TimeSpan.FromMilliseconds(10000),
TimeSpan.FromMilliseconds(200), TimeSpan.FromHours(1), TimeSpan.FromHours(1), false);
var storage1 = new WriterApi(storageNet1, storageConfig, common);
var storageNet2 = new StorageNetConfiguration("localhost", storageServer2, 157, "testService", 10);
var storage2 = new WriterApi(storageNet2, storageConfig, common);
#endregion
_proxy.Start();
_distr.Start();
storage1.Build();
storage1.AddDbModule(new TestInMemoryDbFactory());
storage1.Start();
storage1.Api.Restore(new ServerAddress("localhost", distrServer12), false);
Thread.Sleep(4000);
Assert.IsTrue(storage1.Api.IsRestoreCompleted());
var list = storage1.Api.FailedServers();
Assert.AreEqual(1, list.Count);
storage2.Build();
storage2.AddDbModule(new TestInMemoryDbFactory());
storage2.Start();
storage1.Api.Restore(new ServerAddress("localhost", distrServer12), list, false);
Thread.Sleep(1000);
Assert.IsTrue(storage1.Api.IsRestoreCompleted());
Thread.Sleep(1000);
_proxy.Dispose();
_distr.Dispose();
storage1.Dispose();
storage2.Dispose();
}
public void DbModule_LocalAndRemoteData_Count()
{
var provider = new IntHashConvertor();
var writer =
new HashWriter(new HashMapConfiguration("TestLocalAndRemote", HashMapCreationMode.CreateNew, 2, 3,
HashFileType.Collector));
writer.CreateMap();
writer.SetServer(0, "localhost", 157, 157);
writer.SetServer(1, "localhost", 11011, 157);
writer.Save();
_writer1.Build(157, "TestLocalAndRemote", 1);
var list = new List <InnerData>();
const int count = 100;
for (int i = 0; i < count; i++)
{
var ev =
new InnerData(new Transaction(provider.CalculateHashFromKey(i), "")
{
OperationName = OperationName.Create
})
{
Data = CommonDataSerializer.Serialize(i),
Key = CommonDataSerializer.Serialize(i),
Transaction = { Distributor = new ServerId("localhost", 22188) }
};
ev.Transaction.TableName = "Int";
list.Add(ev);
}
TestHelper.OpenDistributorHostForDb(new ServerId("localhost", 22188), new ConnectionConfiguration("testService", 10));
_writer1.Start();
foreach (var data in list)
{
_writer1.Input.Process(data);
}
Thread.Sleep(1000);
var mem = _writer1.Db.GetDbModules.First() as TestDbInMemory;
Assert.AreNotEqual(count, mem.Local);
Assert.AreNotEqual(count, mem.Remote);
Assert.AreEqual(count, mem.Local + mem.Remote);
_writer1.Dispose();
}
public void Writer_ProcessDataFromDistributor_SendResultBack()
{
const int distrServer1 = 22180;
const int distrServer12 = 23180;
const int storageServer1 = 22181;
var writer =
new HashWriter(new HashMapConfiguration("TestTransaction1D1S", HashMapCreationMode.CreateNew, 1, 1,
HashFileType.Distributor));
writer.CreateMap();
writer.SetServer(0, "localhost", storageServer1, 157);
writer.Save();
_distributor1.Build(1, distrServer1, distrServer12, "TestTransaction1D1S");
_writer1.Build(storageServer1, "TestTransaction1D1S", 1);
_distributor1.Start();
_writer1.Start();
var list = new List <InnerData>();
const int count = 100;
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),
Key = CommonDataSerializer.Serialize(i),
Transaction = { TableName = "Int" }
};
list.Add(ev);
}
foreach (var data in list)
{
_distributor1.Input.ProcessAsync(data);
}
Thread.Sleep(TimeSpan.FromMilliseconds(1000));
foreach (var data in list)
{
var transaction = _distributor1.Main.GetTransactionState(data.Transaction.UserTransaction);
Assert.AreEqual(TransactionState.Complete, transaction.State);
}
var mem = _writer1.Db.GetDbModules.First() as TestDbInMemory;
Assert.AreEqual(count, mem.Local);
_writer1.Dispose();
_distributor1.Dispose();
}
public void ClientProxy_Dispose_DisposeWhenWriting()
{
const int distrServer1 = 22370;
const int distrServer12 = 22371;
const int storageServer = 22372;
#region hell
var writer = new HashWriter(new HashMapConfiguration("TestProxyDispose", HashMapCreationMode.CreateNew, 1, 1, HashFileType.Distributor));
writer.CreateMap();
writer.SetServer(0, "localhost", storageServer, 157);
writer.Save();
var common = new CommonConfiguration(1, 100);
var distr =
new DistributorApi(
new DistributorNetConfiguration("localhost", distrServer1, distrServer12, "testService"),
new DistributorConfiguration(1, "TestProxyDispose"), common);
var storage = new WriterApi(
new StorageNetConfiguration("localhost", storageServer, 157, "testService"),
new StorageConfiguration(1, "TestProxyDispose"),
new CommonConfiguration());
#endregion
distr.Build();
distr.Start();
var result = _proxy.Int.SayIAmHere("localhost", distrServer1);
Assert.AreEqual(RequestState.Complete, result.State, result.ToString());
storage.Build();
storage.AddDbModule(new TestInMemoryDbFactory());
storage.Start();
const int count = 500;
for (int i = 0; i < count; i++)
{
if (i == count / 4)
{
Task.Run(() => _proxy.Dispose());
}
var state = _proxy.Int.CreateSync(i, i);
if (!(state.State == RequestState.Complete || state.State == RequestState.Error &&
state.ErrorDescription == "System disposed" || i == count / 4))
{
Assert.Fail(state + " " + i);
}
}
distr.Dispose();
storage.Dispose();
}
public void CollectorModel_GetSystemState_CheckWritersState()
{
const int countReplics = 2;
var writer = new HashWriter(new HashMapConfiguration("TestCollectorModel", HashMapCreationMode.CreateNew, 4, 3, HashFileType.Distributor));
writer.CreateMap();
writer.SetServer(0, "localhost", 1, 157);
writer.SetServer(1, "localhost", 2, 157);
writer.SetServer(2, "localhost", 3, 157);
writer.SetServer(3, "localhost", 4, 157);
writer.Save();
var model = new CollectorModel(new DistributorHashConfiguration(countReplics),
new HashMapConfiguration("TestCollectorModel", HashMapCreationMode.ReadFromFile, 1, countReplics, HashFileType.Writer));
model.Start();
var state = model.GetSystemState();
Assert.AreEqual(SystemSearchStateInner.AllServersAvailable, state);
model.ServerNotAvailable(new ServerId("localhost", 1));
state = model.GetSystemState();
Assert.AreEqual(SystemSearchStateInner.AllDataAvailable, state);
model.ServerNotAvailable(new ServerId("localhost", 3));
state = model.GetSystemState();
Assert.AreEqual(SystemSearchStateInner.AllDataAvailable, state);
model.ServerNotAvailable(new ServerId("localhost", 2));
state = model.GetSystemState();
Assert.AreEqual(SystemSearchStateInner.SomeDataUnavailable, state);
model.ServerAvailable(new ServerId("localhost", 1));
state = model.GetSystemState();
Assert.AreEqual(SystemSearchStateInner.SomeDataUnavailable, state);
model.ServerNotAvailable(new ServerId("localhost", 4));
state = model.GetSystemState();
Assert.AreEqual(SystemSearchStateInner.SomeDataUnavailable, state);
model.ServerAvailable(new ServerId("localhost", 3));
state = model.GetSystemState();
Assert.AreEqual(SystemSearchStateInner.AllDataAvailable, state);
}
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 Writer_ProcessData_SendResultToDistributerMock()
{
const int distributorServer1 = 22171;
const int storageServer1 = 22172;
var writer =
new HashWriter(new HashMapConfiguration("TestDbTransaction", HashMapCreationMode.CreateNew, 1, 1,
HashFileType.Distributor));
writer.CreateMap();
writer.SetServer(0, "localhost", storageServer1, 157);
writer.Save();
_writer1.Build(storageServer1, "TestDbTransaction", 1);
_writer1.Start();
var s = TestHelper.OpenDistributorHostForDb(new ServerId("localhost", distributorServer1),
new ConnectionConfiguration("testService", 10));
var list = new List <InnerData>();
const int count = 100;
for (int i = 1; i < count + 1; i++)
{
var ev =
new InnerData(new Transaction(HashConvertor.GetString(i.ToString(CultureInfo.InvariantCulture)), "")
{
OperationName = OperationName.Create
})
{
Data = CommonDataSerializer.Serialize(i),
Key = CommonDataSerializer.Serialize(i),
Transaction = { Distributor = new ServerId("localhost", distributorServer1) }
};
ev.Transaction.TableName = "Int";
list.Add(ev);
}
foreach (var data in list)
{
_writer1.Q.DbInputProcessQueue.Add(data);
}
Thread.Sleep(TimeSpan.FromMilliseconds(1000));
Assert.AreEqual(count, s.SendValue);
_writer1.Dispose();
}
public static void Generate(string fileName, List <Tuple <string, int, int> > servers)
{
var writer =
new HashWriter(new HashMapConfiguration(fileName, HashMapCreationMode.CreateNew, servers.Count,
servers.Count, HashFileType.Distributor));
writer.CreateMap();
int index = 0;
foreach (var server in servers)
{
writer.SetServer(index, server.Item1, server.Item2, server.Item3);
index++;
}
writer.Save();
}
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 void CollectorNet_ReadFromWriter()
{
const int proxyServer = 22337;
const int distrServer1 = 22338;
const int distrServer12 = 22339;
const int st1 = 22335;
const int st2 = 22336;
#region hell
var writer = new HashWriter(new HashMapConfiguration("TestCollectorNet", HashMapCreationMode.CreateNew, 1, 1, HashFileType.Distributor));
writer.CreateMap();
writer.SetServer(0, "localhost", st1, st2);
writer.Save();
var common = new CommonConfiguration(1, 100);
var netconfig = new NetConfiguration("localhost", proxyServer, "testService", 10);
var toconfig = new ProxyConfiguration(TimeSpan.FromMinutes(10), TimeSpan.FromMinutes(1),
TimeSpan.FromMinutes(10), TimeSpan.FromMinutes(10));
var proxy = new TestGate(netconfig, toconfig, common);
var distrNet = new DistributorNetConfiguration("localhost",
distrServer1, distrServer12, "testService", 10);
var distrConf = new DistributorConfiguration(1, "TestCollectorNet",
TimeSpan.FromMilliseconds(100000), TimeSpan.FromMinutes(1), TimeSpan.FromMinutes(1), TimeSpan.FromMilliseconds(10000));
var distr = new DistributorApi(distrNet, distrConf, common);
var storageNet = new StorageNetConfiguration("localhost", st1, st2, "testService", 10);
var storageConfig = new StorageConfiguration("TestCollectorNet", 1, 10, TimeSpan.FromHours(1), TimeSpan.FromHours(1),
TimeSpan.FromHours(1), TimeSpan.FromHours(1), false);
var storage = new WriterApi(storageNet, storageConfig, common);
var async = new AsyncTaskModule(new QueueConfiguration(4, 10));
var distributor =
new DistributorModule(new CollectorModel(new DistributorHashConfiguration(1),
new HashMapConfiguration("TestCollectorNet", HashMapCreationMode.ReadFromFile, 1, 1,
HashFileType.Collector)), async, new AsyncTasksConfiguration(TimeSpan.FromMinutes(1)));
var net = new CollectorNetModule(new ConnectionConfiguration("testService", 10),
new ConnectionTimeoutConfiguration(Consts.OpenTimeout, Consts.SendTimeout), distributor);
distributor.SetNetModule(net);
var back = new BackgroundModule(new QueueConfiguration(5, 10));
var loader = new DataLoader(net, 100, back);
var parser = new TestIntParser();
parser.SetCommandsHandler(
new UserCommandsHandler <TestCommand, Type, TestCommand, int, int, TestDbReader>(
new TestUserCommandCreator(), new TestMetaDataCommandCreator()));
var merge = new OrderMerge(loader, parser);
var searchModule = new SearchTaskModule("Int", merge, loader, distributor, back, parser);
storage.Build();
proxy.Build();
distr.Build();
storage.AddDbModule(new TestInMemoryDbFactory());
storage.Start();
proxy.Start();
distr.Start();
searchModule.Start();
distributor.Start();
merge.Start();
back.Start();
net.Start();
async.Start();
#endregion
proxy.Int.SayIAmHere("localhost", distrServer1);
const int count = 20;
for (int i = 0; i < count; i++)
{
var request = proxy.Int.CreateSync(i, i);
Assert.AreEqual(RequestState.Complete, request.State);
}
var reader = searchModule.CreateReader("asc", -1, 20);
reader.Start();
for (int i = 0; i < count; i++)
{
Assert.IsTrue(reader.IsCanRead);
reader.ReadNext();
Assert.AreEqual(i, reader.GetValue(0));
}
reader.ReadNext();
Assert.IsFalse(reader.IsCanRead);
reader.Dispose();
back.Dispose();
net.Dispose();
storage.Dispose();
proxy.Dispose();
distr.Dispose();
async.Dispose();
}
public void SearchTaskModule_CreateReader_UnlimitDataReadAndUserPage()
{
var server1 = new ServerId("", 1);
var server2 = new ServerId("", 2);
var server3 = new ServerId("", 3);
const int pageSize = 5;
var writer = new HashWriter(new HashMapConfiguration("TestCollector4", HashMapCreationMode.CreateNew, 3, 3, HashFileType.Distributor));
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.Save();
var loader = new TestDataLoader(pageSize);
var parser = new TestIntParser();
parser.SetCommandsHandler(
new UserCommandsHandler <TestCommand, Type, TestCommand, int, int, TestDbReader>(
new TestUserCommandCreator(), new TestMetaDataCommandCreator()));
var merge = new OrderMerge(loader, parser);
var async = new AsyncTaskModule(new QueueConfiguration(4, 10));
var distributor =
new DistributorModule(new CollectorModel(new DistributorHashConfiguration(1),
new HashMapConfiguration("TestCollector4", HashMapCreationMode.ReadFromFile, 1, 1,
HashFileType.Writer)), async, new AsyncTasksConfiguration(TimeSpan.FromMinutes(1)));
var back = new BackgroundModule(new QueueConfiguration(5, 10));
var searchModule = new SearchTaskModule("", merge, loader, distributor, back, parser);
#region hell
loader.Data.Add(server1, new List <SearchData>
{
TestHelper.CreateData(1),
TestHelper.CreateData(2),
TestHelper.CreateData(4),
TestHelper.CreateData(5),
TestHelper.CreateData(6),
TestHelper.CreateData(7),
TestHelper.CreateData(8),
});
loader.Data.Add(server2, new List <SearchData>
{
TestHelper.CreateData(4),
TestHelper.CreateData(5),
TestHelper.CreateData(6),
TestHelper.CreateData(7),
TestHelper.CreateData(8),
TestHelper.CreateData(9),
TestHelper.CreateData(10),
TestHelper.CreateData(11),
});
loader.Data.Add(server3, new List <SearchData>
{
TestHelper.CreateData(2),
TestHelper.CreateData(3),
TestHelper.CreateData(5),
TestHelper.CreateData(7),
TestHelper.CreateData(8),
TestHelper.CreateData(9),
TestHelper.CreateData(10),
TestHelper.CreateData(11),
TestHelper.CreateData(12),
TestHelper.CreateData(13),
});
#endregion
searchModule.Start();
distributor.Start();
merge.Start();
back.Start();
async.Start();
var reader = searchModule.CreateReader("asc", -1, 5);
reader.Start();
const int count = 13;
for (int i = 0; i < count; i++)
{
Assert.IsTrue(reader.IsCanRead);
reader.ReadNext();
Assert.AreEqual(i + 1, reader.GetValue(0));
}
reader.ReadNext();
Assert.IsFalse(reader.IsCanRead);
reader.Dispose();
async.Dispose();
back.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 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 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 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();
}
public void Writer_RestoreAfterUpdateHashFile_ThreeServers()
{
var writer =
new HashWriter(new HashMapConfiguration("TestRestore3ServersUpdate", HashMapCreationMode.CreateNew, 2, 3,
HashFileType.Distributor));
writer.CreateMap();
writer.SetServer(0, "localhost", storageServer1, 157);
writer.SetServer(1, "localhost", storageServer2, 157);
writer.Save();
_distrTest.Build(1, distrServer1, distrServer12, "TestRestore3ServersUpdate");
_writer1.Build(storageServer1, "TestRestore3ServersUpdate", 1);
_writer2.Build(storageServer2, "TestRestore3ServersUpdate", 1);
_writer3.Build(storageServer3, "TestRestore3ServersUpdate", 1);
_distrTest.Start();
_writer1.Start();
_writer2.Start();
#region hell
var list = new List <InnerData>();
const int count = 50;
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),
Key = CommonDataSerializer.Serialize(i),
Transaction = { Distributor = new ServerId("localhost", distrServer1) }
};
ev.Transaction.TableName = "Int";
list.Add(ev);
}
foreach (var data in list)
{
_distrTest.Input.ProcessAsync(data);
}
Thread.Sleep(TimeSpan.FromMilliseconds(5000));
#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.AreNotEqual(count, mem2.Local);
Assert.AreNotEqual(count, mem2.Remote);
}
Assert.AreEqual(count, mem.Local + mem2.Local);
Assert.AreEqual(0, mem.Remote);
Assert.AreEqual(0, mem2.Remote);
writer =
new HashWriter(new HashMapConfiguration("TestRestore3ServersUpdate", 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();
_writer3.Start();
_distrTest.Distributor.UpdateModel();
_writer1.Distributor.UpdateModel();
_writer2.Distributor.UpdateModel();
_writer3.Distributor.Restore(new ServerId("localhost", distrServer1), true);
Thread.Sleep(TimeSpan.FromMilliseconds(1000));
Assert.AreEqual(0, mem.Remote);
Assert.AreEqual(0, mem2.Remote);
Assert.AreEqual(0, mem3.Remote);
Assert.AreNotEqual(0, mem3.Local);
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);
_writer1.Dispose();
_writer2.Dispose();
_writer3.Dispose();
_distrTest.Dispose();
}
public void Writer_Restore_TwoServers()
{
var writer =
new HashWriter(new HashMapConfiguration("test8", HashMapCreationMode.CreateNew, 2, 3,
HashFileType.Distributor));
writer.CreateMap();
writer.SetServer(0, "localhost", storageServer1, 157);
writer.SetServer(1, "localhost", storageServer2, 157);
writer.Save();
_distrTest.Build(1, distrServer1, distrServer12, "test8");
_writer1.Build(storageServer1, "test8", 1);
_writer2.Build(storageServer2, "test8", 1);
_distrTest.Start();
_writer1.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),
Key = CommonDataSerializer.Serialize(i),
Transaction = { Distributor = new ServerId("localhost", distrServer1) }
};
ev.Transaction.TableName = "Int";
list.Add(ev);
}
foreach (var data in list)
{
_distrTest.Input.ProcessAsync(data);
}
Thread.Sleep(TimeSpan.FromMilliseconds(6000));
foreach (var data in list)
{
var tr = _distrTest.Main.GetTransactionState(data.Transaction.UserTransaction);
if (tr.State != TransactionState.Complete)
{
data.Transaction = new Transaction(data.Transaction);
data.Transaction.ClearError();
_distrTest.Input.ProcessAsync(data);
}
}
Thread.Sleep(TimeSpan.FromMilliseconds(5000));
var mem = _writer1.Db.GetDbModules.First() as TestDbInMemory;
var mem2 = _writer2.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();
_writer2.Distributor.Restore(new ServerId("localhost", distrServer1), false);
Thread.Sleep(TimeSpan.FromMilliseconds(2000));
Assert.AreEqual(0, mem.Remote);
Assert.AreEqual(0, mem2.Remote);
Assert.AreEqual(count, mem.Local + mem2.Local);
Assert.AreEqual(false, _writer1.Restore.IsNeedRestore);
Assert.AreEqual(false, _writer2.Restore.IsNeedRestore);
_distrTest.Dispose();
_writer1.Dispose();
_writer2.Dispose();
}
public void Writer_Restore_TimeoutDelete()
{
#region hell
var writer =
new HashWriter(new HashMapConfiguration("TestRestore", HashMapCreationMode.CreateNew, 1, 1,
HashFileType.Distributor));
writer.CreateMap();
writer.SetServer(0, "localhost", storageServer1, 157);
writer.Save();
var storageNet1 = new StorageNetConfiguration("localhost", storageServer1, 157, "testService", 10);
var storageConfig = new StorageConfiguration("TestRestore", 1, 10,
TimeSpan.FromMilliseconds(10000),
TimeSpan.FromMilliseconds(200), TimeSpan.FromMilliseconds(1), TimeSpan.FromSeconds(1), false);
var factory = new TestInMemoryDbFactory();
var storage1 = new WriterApi(storageNet1, storageConfig, new CommonConfiguration(1, 10));
#endregion
_proxy.Start();
_distr.Start();
_proxy.Int.SayIAmHere("localhost", distrServer1);
storage1.Build();
storage1.AddDbModule(factory);
storage1.Start();
const int count = 50;
for (int i = 0; i < count; i++)
{
var wait = _proxy.Int.CreateSync(i, i);
Assert.AreEqual(RequestState.Complete, wait.State);
}
Assert.AreEqual(count, factory.Db.Local);
for (int i = 0; i < count / 2; i++)
{
var wait = _proxy.Int.DeleteSync(i);
Assert.AreEqual(RequestState.Complete, wait.State);
}
Assert.AreEqual(count / 2, factory.Db.Local);
Assert.AreEqual(count / 2, factory.Db.Deleted);
Thread.Sleep(4000);
Assert.AreEqual(count / 2, factory.Db.Local);
Assert.AreEqual(0, factory.Db.Deleted);
_proxy.Dispose();
_distr.Dispose();
storage1.Dispose();
}
public void DistributorApi_ProcessAsyncOperationsFromProxy()
{
const int proxyServer = 22213;
const int distrServer1 = 22214;
const int distrServer12 = 22215;
const int storageServer = 22216;
#region hell
var writer = new HashWriter(new HashMapConfiguration("TestClientDistributor", HashMapCreationMode.CreateNew, 1, 1, HashFileType.Distributor));
writer.CreateMap();
writer.SetServer(0, "localhost", storageServer, 157);
writer.Save();
var netconfig = new NetConfiguration("localhost", proxyServer, "testService", 10);
var toconfig = new ProxyConfiguration(TimeSpan.FromMinutes(10), TimeSpan.FromMinutes(1),
TimeSpan.FromMinutes(10), TimeSpan.FromMinutes(10));
var common = new CommonConfiguration(1, 100);
var proxy = new TestGate(netconfig, toconfig, common);
var distrNet = new DistributorNetConfiguration("localhost",
distrServer1, distrServer12, "testService", 10);
var distrConf = new DistributorConfiguration(1, "TestClientDistributor",
TimeSpan.FromMilliseconds(100000), TimeSpan.FromMinutes(1), TimeSpan.FromMinutes(1), TimeSpan.FromMilliseconds(10000));
var distr = new DistributorApi(distrNet, distrConf, common);
var storageNet = new StorageNetConfiguration("localhost", storageServer, 157, "testService", 10);
var storageConfig = new StorageConfiguration("TestClientDistributor", 1, 10, TimeSpan.FromHours(1), TimeSpan.FromHours(1),
TimeSpan.FromHours(1), TimeSpan.FromHours(1), false);
var storage = new WriterApi(storageNet, storageConfig, common);
#endregion
proxy.Build();
proxy.Start();
distr.Build();
distr.Start();
proxy.Int.SayIAmHere("localhost", distrServer1);
storage.Build();
storage.AddDbModule(new TestInMemoryDbFactory());
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);
}
proxy.Dispose();
distr.Dispose();
storage.Dispose();
}
public void Writer_SendRestoreCommandToDistributors_RestoreRemoteTable()
{
const int distrServer1 = 22113;
const int distrServer12 = 23113;
const int distrServer2 = 22114;
const int distrServer22 = 23114;
const int storageServer1 = 22115;
const int storageServer2 = 22116;
var writer =
new HashWriter(new HashMapConfiguration("test7", HashMapCreationMode.CreateNew, 2, 3,
HashFileType.Distributor));
writer.CreateMap();
writer.SetServer(0, "localhost", storageServer1, 157);
writer.SetServer(1, "localhost", storageServer2, 157);
writer.Save();
writer =
new HashWriter(new HashMapConfiguration("test6", HashMapCreationMode.CreateNew, 2, 3,
HashFileType.Writer));
writer.CreateMap();
writer.SetServer(0, "localhost", storageServer1, 157);
writer.SetServer(1, "localhost", storageServer2, 157);
writer.Save();
_distributor1.Build(2, distrServer1, distrServer12, "test7");
_distributor2.Build(2, distrServer2, distrServer22, "test6");
_writer1.Build(storageServer1, "test6", 2);
_writer2.Build(storageServer2, "test7", 2);
_proxy.Start();
_distributor1.Start();
_distributor2.Start();
_proxy.Distributor.SayIAmHere(new ServerId("localhost", distrServer12));
_proxy.Distributor.SayIAmHere(new ServerId("localhost", distrServer22));
_distributor2.Distributor.SayIAmHereRemoteResult(new ServerId("localhost", distrServer12));
Thread.Sleep(TimeSpan.FromMilliseconds(300));
Assert.AreEqual(1, _distributor1.Distributor.GetDistributors().Count);
Assert.AreEqual(1, _distributor2.Distributor.GetDistributors().Count);
var api = _proxy.CreateApi("Int", false, new IntHashConvertor());
var tr1 = api.CreateSync(10, 10);
var tr2 = api.CreateSync(11, 11);
tr1.Wait();
tr2.Wait();
_writer1.Start();
_writer2.Start();
_writer1.Distributor.Restore(new ServerId("localhost", distrServer1), false);
_writer2.Distributor.Restore(new ServerId("localhost", distrServer2), false);
Thread.Sleep(TimeSpan.FromMilliseconds(2000));
var tr3 = api.CreateSync(12, 12);
var tr4 = api.CreateSync(13, 13);
tr3.Wait();
tr4.Wait();
var mem = _writer1.Db.GetDbModules.First() as TestDbInMemory;
var mem2 = _writer2.Db.GetDbModules.First() as TestDbInMemory;
Assert.AreEqual(2, mem.Local);
Assert.AreEqual(2, mem2.Local);
_writer1.Dispose();
_writer2.Dispose();
_proxy.Dispose();
_distributor1.Dispose();
_distributor2.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 Proxy_Restore_HashFromValue()
{
const int distrServer1 = 22403;
const int distrServer12 = 22404;
const int st1 = 22405;
const int st2 = 22406;
const int st3 = 22407;
const int st4 = 22408;
#region hell
var writer =
new HashWriter(new HashMapConfiguration("TestHashFromValue", HashMapCreationMode.CreateNew, 2, 2,
HashFileType.Distributor));
writer.CreateMap();
writer.SetServer(0, "localhost", st1, st2);
writer.SetServer(1, "localhost", st3, st4);
writer.Save();
var common = new CommonConfiguration(1, 100);
var distrNet = new DistributorNetConfiguration("localhost",
distrServer1, distrServer12, "testService", 10);
var distrConf = new DistributorConfiguration(1, "TestHashFromValue",
TimeSpan.FromMilliseconds(100000), TimeSpan.FromMinutes(1), TimeSpan.FromMinutes(1),
TimeSpan.FromMilliseconds(10000));
var distr = new DistributorApi(distrNet, distrConf, common);
var storageNet1 = new StorageNetConfiguration("localhost", st1, st2, "testService", 10);
var storageNet2 = new StorageNetConfiguration("localhost", st3, st4, "testService", 10);
var storageConfig = new StorageConfiguration("TestHashFromValue", 1, 10, TimeSpan.FromHours(1),
TimeSpan.FromHours(1), TimeSpan.FromHours(1), TimeSpan.FromHours(1), false);
var storage1 = new WriterApi(storageNet1, storageConfig, common);
var storage2 = new WriterApi(storageNet2, storageConfig, common);
#endregion
storage1.Build();
storage2.Build();
distr.Build();
var f1 = new TestInMemoryDbFactory("Int3", new IntHashConvertor());
var f2 = new TestInMemoryDbFactory("Int3", new IntHashConvertor());
storage1.AddDbModule(f1);
storage2.AddDbModule(f2);
storage1.Start();
_proxy.Start();
distr.Start();
_proxy.Int.SayIAmHere("localhost", distrServer1);
const int count = 50;
for (int i = 0; i < count; i++)
{
_proxy.Int3.CreateSync(i, i);
_proxy.Int3.CreateSync(i, i);
}
for (int i = 0; i < count; i++)
{
RequestDescription result;
var value = _proxy.Int3.Read(i, out result);
Assert.AreEqual(RequestState.Complete, result.State);
Assert.AreEqual(i, value);
}
Assert.AreEqual(count, f1.Db.Local + f1.Db.Remote);
storage2.Start();
storage2.Api.Restore(new ServerAddress("localhost", distrServer12), false);
Thread.Sleep(TimeSpan.FromMilliseconds(2000));
Assert.AreEqual(count, f1.Db.Local + f2.Db.Local);
Assert.AreEqual(0, f1.Db.Remote);
Assert.AreEqual(0, f2.Db.Remote);
_proxy.Dispose();
distr.Dispose();
storage1.Dispose();
storage2.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 Proxy_CRUD_TwoTables()
{
const int distrServer1 = 22379;
const int distrServer12 = 22380;
const int st1 = 22381;
const int st2 = 22382;
#region hell
var writer = new HashWriter(new HashMapConfiguration("Test2Crud", HashMapCreationMode.CreateNew, 1, 1, HashFileType.Distributor));
writer.CreateMap();
writer.SetServer(0, "localhost", st1, st2);
writer.Save();
var common = new CommonConfiguration(1, 100);
var distrNet = new DistributorNetConfiguration("localhost",
distrServer1, distrServer12, "testService", 10);
var distrConf = new DistributorConfiguration(1, "Test2Crud",
TimeSpan.FromMilliseconds(100000), TimeSpan.FromMinutes(1), TimeSpan.FromMinutes(1), TimeSpan.FromMilliseconds(10000));
var distr = new DistributorApi(distrNet, distrConf, common);
var storageNet = new StorageNetConfiguration("localhost", st1, st2, "testService", 10);
var storageConfig = new StorageConfiguration("Test2Crud", 1, 10, TimeSpan.FromHours(1), TimeSpan.FromHours(1),
TimeSpan.FromHours(1), TimeSpan.FromHours(1), false);
var storage = new WriterApi(storageNet, storageConfig, common);
#endregion
storage.Build();
distr.Build();
var f = new TestInMemoryDbFactory();
var f2 = new TestInMemoryDbFactory("Int2");
storage.AddDbModule(f);
storage.AddDbModule(f2);
storage.Start();
_proxy.Start();
distr.Start();
_proxy.Int.SayIAmHere("localhost", distrServer1);
const int count = 5;
for (int i = 0; i < count; i++)
{
RequestDescription result;
_proxy.Int.Read(i, out result);
Assert.AreEqual(RequestState.DataNotFound, result.State);
_proxy.Int2.Read(i, out result);
Assert.AreEqual(RequestState.DataNotFound, result.State);
}
for (int i = 0; i < count; i++)
{
RequestDescription result = _proxy.Int.CreateSync(i, i);
Assert.AreEqual(RequestState.Complete, result.State);
result = _proxy.Int2.CreateSync(i, i);
Assert.AreEqual(RequestState.Complete, result.State);
}
for (int i = 0; i < count; i++)
{
RequestDescription result;
var value = _proxy.Int.Read(i, out result);
Assert.AreEqual(RequestState.Complete, result.State);
Assert.AreEqual(i, value);
value = _proxy.Int2.Read(i, out result);
Assert.AreEqual(i, value);
}
Assert.AreEqual(count, f.Db.Local);
Assert.AreEqual(count, f2.Db.Local);
_proxy.Dispose();
distr.Dispose();
storage.Dispose();
}
