public byte[] SerializeOther(object value)
{
return(CommonDataSerializer.Serialize(value));
}
public byte[] SerializeKey(object key)
{
return(CommonDataSerializer.Serialize(key));
}
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_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 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 object DeserializeKey(byte[] key)
{
return(CommonDataSerializer.Deserialize <int>(key));
}
public object DeserializeValue(byte[] data)
{
return(CommonDataSerializer.Deserialize <StoredData>(data));
}
