protected ProxyApi(NetConfiguration netConfiguration, ProxyConfiguration proxyConfiguration,
CommonConfiguration commonConfiguration, TimeoutConfiguration timeoutConfiguration)
{
Contract.Requires(netConfiguration != null);
Contract.Requires(proxyConfiguration != null);
Contract.Requires(commonConfiguration != null);
Contract.Requires(timeoutConfiguration != null);
_isStarted = false;
_isBuild = false;
_isDispose = false;
var server = new ServerId(netConfiguration.Host, netConfiguration.Port);
var queue = new QueueConfiguration(commonConfiguration.CountThreads, commonConfiguration.QueueSize);
var connection = new ConnectionConfiguration(netConfiguration.WcfServiceName,
netConfiguration.CountConnectionsToSingleServer);
var proxyCacheConfiguration = new ProxyCacheConfiguration(proxyConfiguration.ChangeDistributorTimeoutSec);
var proxyCacheConfiguration2 = new ProxyCacheConfiguration(proxyConfiguration.SyncOperationsTimeoutSec);
var netReceiveConfiguration = new NetReceiverConfiguration(netConfiguration.Port, netConfiguration.Host,
netConfiguration.WcfServiceName);
var async = new AsyncTasksConfiguration(proxyConfiguration.AsyncUpdateTimeout);
var ping = new AsyncTasksConfiguration(proxyConfiguration.AsyncPingTimeout);
var timeout = new ConnectionTimeoutConfiguration(timeoutConfiguration.OpenTimeout,
timeoutConfiguration.SendTimeout);
_proxySystem = new ProxySystem(server, queue, connection,
proxyCacheConfiguration, proxyCacheConfiguration2, netReceiveConfiguration, async, ping, timeout);
_apis = new Dictionary <string, ProxyHandlerBase>();
}
public ProxySystem(ServerId local, QueueConfiguration queueConfiguration,
ConnectionConfiguration connectionConfiguration,
ProxyCacheConfiguration cacheConfiguration,
ProxyCacheConfiguration asyncCacheConfiguration,
NetReceiverConfiguration receiverConfiguration,
AsyncTasksConfiguration asyncGetData,
AsyncTasksConfiguration asyncPing, ConnectionTimeoutConfiguration connectionTimeoutConfiguration)
{
Contract.Requires(queueConfiguration != null);
Contract.Requires(connectionConfiguration != null);
Contract.Requires(cacheConfiguration != null);
Contract.Requires(asyncCacheConfiguration != null);
Contract.Requires(receiverConfiguration != null);
Contract.Requires(asyncGetData != null);
Contract.Requires(local != null);
Contract.Requires(asyncPing != null);
_local = local;
_queueConfiguration = queueConfiguration;
_connectionConfiguration = connectionConfiguration;
_cacheConfiguration = cacheConfiguration;
_asyncCacheConfiguration = asyncCacheConfiguration;
_netReceiverConfiguration = receiverConfiguration;
_asyncGetData = asyncGetData;
_asyncPing = asyncPing;
_connectionTimeoutConfiguration = connectionTimeoutConfiguration;
}
public TestProxySystem(ServerId local, QueueConfiguration queueConfiguration,
ConnectionConfiguration connectionConfiguration, ProxyCacheConfiguration cacheConfiguration,
ProxyCacheConfiguration asyncCacheConfiguration, NetReceiverConfiguration receiverConfiguration,
AsyncTasksConfiguration asyncGetData, AsyncTasksConfiguration asyncPing,
ConnectionTimeoutConfiguration connectionTimeoutConfiguration)
: base(
local, queueConfiguration, connectionConfiguration, cacheConfiguration, asyncCacheConfiguration,
receiverConfiguration, asyncGetData, asyncPing, connectionTimeoutConfiguration)
{
}
public void ProxySystem_Read_ReadFromFakeDistributor_ExpectedData()
{
var queue = new QueueConfiguration(1, 100);
var connection = new ConnectionConfiguration("testService", 10);
var ndrc2 = new NetReceiverConfiguration(32192, "localhost", "testService");
var pcc = new ProxyCacheConfiguration(TimeSpan.FromSeconds(20000000));
var proxy = new TestProxySystem(new ServerId("", 1), queue, connection, pcc, pcc,
ndrc2,
new AsyncTasksConfiguration(TimeSpan.FromMinutes(60000)),
new AsyncTasksConfiguration(TimeSpan.FromMinutes(60000)),
new ConnectionTimeoutConfiguration(Consts.OpenTimeout, Consts.SendTimeout));
proxy.Build();
proxy.Start();
var distr = new ServerId("localhost", 22194);
TestHelper.OpenDistributorHost(distr, connection);
proxy.Distributor.SayIAmHere(distr);
var provider = new IntHashConvertor();
var hash = provider.CalculateHashFromKey(10);
var transaction = new Transaction(hash, "")
{
OperationName = OperationName.Read,
OperationType = OperationType.Sync
};
Task.Factory.StartNew(() =>
{
Thread.Sleep(200);
transaction.Complete();
var data = new InnerData(transaction)
{
Data = provider.SerializeValue(10)
};
proxy.Queue.ProxyDistributorQueue.Add(new ReadOperationCompleteCommand(data));
});
try
{
UserTransaction userTransaction;
var api = proxy.CreateApi("", false, new IntHashConvertor());
var wait = api.Read(10, out userTransaction);
Assert.AreEqual(10, wait);
Assert.AreEqual(TransactionState.Complete, userTransaction.State);
}
catch (Exception e)
{
Assert.Fail(e.Message);
}
proxy.Dispose();
}
public void Initialize()
{
var queue = new QueueConfiguration(1, 100);
var connection = new ConnectionConfiguration("testService", 10);
var ndrc2 = new NetReceiverConfiguration(proxyServer, "localhost", "testService");
var pcc = new ProxyCacheConfiguration(TimeSpan.FromSeconds(2));
_proxy = new TestProxySystem(new ServerId("localhost", proxyServer),
queue, connection, pcc, pcc, ndrc2,
new AsyncTasksConfiguration(new TimeSpan()),
new AsyncTasksConfiguration(new TimeSpan()),
new ConnectionTimeoutConfiguration(Consts.OpenTimeout, Consts.SendTimeout));
_proxy.Build();
}
public void ProxySystem_CreateSync_SendSyncDataToFakeDistributor_NoError()
{
var queue = new QueueConfiguration(1, 100);
var connection = new ConnectionConfiguration("testService", 10);
var ndrc2 = new NetReceiverConfiguration(32190, "localhost", "testService");
var pcc = new ProxyCacheConfiguration(TimeSpan.FromSeconds(20000000));
var proxy = new TestProxySystem(new ServerId("", 1), queue, connection, pcc, pcc, ndrc2,
new AsyncTasksConfiguration(TimeSpan.FromMinutes(60000)),
new AsyncTasksConfiguration(TimeSpan.FromMinutes(60000)),
new ConnectionTimeoutConfiguration(Consts.OpenTimeout, Consts.SendTimeout));
proxy.Build();
proxy.Start();
var distr = new ServerId("localhost", 22190);
TestHelper.OpenDistributorHost(distr, connection);
proxy.Distributor.SayIAmHere(distr);
var provider = new StoredDataHashCalculator();
var hash = provider.CalculateHashFromKey(10);
var transaction = new Transaction(hash, "")
{
OperationName = OperationName.Create,
OperationType = OperationType.Sync
};
Task.Factory.StartNew(() =>
{
Thread.Sleep(200);
transaction.Complete();
proxy.Queue.ProxyDistributorQueue.Add(new OperationCompleteCommand(transaction));
});
try
{
var api = proxy.CreateApi("", false, provider);
var wait = api.CreateSync(10, TestHelper.CreateStoredData(10));
wait.Wait();
Assert.AreEqual(TransactionState.Complete, wait.Result.State);
}
catch (Exception e)
{
Assert.Fail(e.Message);
}
proxy.Dispose();
}
public void Initialize()
{
const int proxyServer = 22020;
var queue = new QueueConfiguration(2, 100);
var connection = new ConnectionConfiguration("testService", 10);
var ndrc2 = new NetReceiverConfiguration(proxyServer, "localhost", "testService");
var pcc = new ProxyCacheConfiguration(TimeSpan.FromSeconds(20));
var pccc2 = new ProxyCacheConfiguration(TimeSpan.FromSeconds(40));
_proxy = new TestProxySystem(new ServerId("localhost", proxyServer),
queue, connection, pcc, pccc2, ndrc2,
new AsyncTasksConfiguration(new TimeSpan()),
new AsyncTasksConfiguration(new TimeSpan()),
new ConnectionTimeoutConfiguration(Consts.OpenTimeout, Consts.SendTimeout));
_proxy.Build();
_writer1 = new TestWriterGate();
_writer2 = new TestWriterGate();
_distributor1 = new TestDistributorGate();
_distributor2 = new TestDistributorGate();
}
public 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();
}
