public WriterSystem(ServerId local, QueueConfiguration queueConfiguration,
NetReceiverConfiguration receiverConfigurationForWrite,
NetReceiverConfiguration receiverConfigurationForCollector,
HashMapConfiguration hashMapConfiguration,
ConnectionConfiguration connectionConfiguration,
RestoreModuleConfiguration transferRestoreConfiguration,
RestoreModuleConfiguration initiatorRestoreConfiguration,
ConnectionTimeoutConfiguration connectionTimeoutConfiguration,
RestoreModuleConfiguration timeoutRestoreConfiguration,
bool isNeedRestore = false,
QueueConfiguration queueConfigurationRestore = null)
{
Contract.Requires(local != null);
Contract.Requires(queueConfiguration != null);
Contract.Requires(receiverConfigurationForWrite != null);
Contract.Requires(receiverConfigurationForCollector != null);
Contract.Requires(hashMapConfiguration != null);
Contract.Requires(connectionConfiguration != null);
Contract.Requires(transferRestoreConfiguration != null);
Contract.Requires(initiatorRestoreConfiguration != null);
_queueConfigurationRestore = queueConfigurationRestore ?? new QueueConfiguration(1, 1000);
_queueConfiguration = queueConfiguration;
_receiverConfigurationForWrite = receiverConfigurationForWrite;
_receiverConfigurationForCollector = receiverConfigurationForCollector;
_hashMapConfiguration = hashMapConfiguration;
_connectionConfiguration = connectionConfiguration;
_initiatorRestoreConfiguration = initiatorRestoreConfiguration;
_connectionTimeoutConfiguration = connectionTimeoutConfiguration;
_timeoutRestoreConfiguration = timeoutRestoreConfiguration;
_isNeedRestore = isNeedRestore;
_transferRestoreConfiguration = transferRestoreConfiguration;
_local = local;
}
public InitiatorRestoreModule(RestoreModuleConfiguration configuration, WriterNetModule writerNet,
AsyncTaskModule asyncTaskModule) : base(writerNet, asyncTaskModule)
{
Contract.Requires(configuration != null);
_configuration = configuration;
_lock = new ReaderWriterLockSlim();
}
public TimeoutModule(WriterNetModule net, AsyncTaskModule asyncTaskModule,
QueueConfiguration queueConfiguration, DbModuleCollection db,
RestoreModuleConfiguration configuration)
: base(net, asyncTaskModule)
{
_queueConfiguration = queueConfiguration;
_db = db;
_queue = GlobalQueue.Queue.DbTimeoutQueue;
_deleteTimeout = configuration.DeleteTimeout;
_asyncTaskModule.AddAsyncTask(
new AsyncDataPeriod(configuration.PeriodRetry, PeriodMessage,
AsyncTasksNames.TimeoutDelete, -1), configuration.IsForceStart);
}
public TransferRestoreModule(RestoreModuleConfiguration configuration, WriterNetModule writerNet,
AsyncTaskModule asyncTaskModule, DbModuleCollection db, ServerId local,
QueueConfiguration queueConfiguration)
: base(writerNet, asyncTaskModule)
{
Contract.Requires(configuration != null);
Contract.Requires(db != null);
Contract.Requires(local != null);
Contract.Requires(queueConfiguration != null);
_queue = GlobalQueue.Queue;
_db = db;
_configuration = configuration;
_local = local;
_queueConfiguration = queueConfiguration;
}
public WriterApi(StorageNetConfiguration netConfiguration,
StorageConfiguration storageConfiguration, CommonConfiguration commonConfiguration,
TimeoutConfiguration timeoutConfiguration, bool isNeedRestore = false,
CommonConfiguration restoreConfiguration = null)
{
Contract.Requires(netConfiguration != null);
Contract.Requires(storageConfiguration != null);
Contract.Requires(commonConfiguration != null);
Contract.Requires(timeoutConfiguration != null);
_isStarted = false;
_isBuild = false;
_isDispose = false;
var server = new ServerId(netConfiguration.Host, netConfiguration.PortForDitributor);
var queue = new QueueConfiguration(commonConfiguration.CountThreads, commonConfiguration.QueueSize);
var queueRestore = restoreConfiguration == null
? new QueueConfiguration(1, 1000)
: new QueueConfiguration(restoreConfiguration.CountThreads, restoreConfiguration.QueueSize);
var netReceiveConfiguration = new NetReceiverConfiguration(netConfiguration.PortForDitributor,
netConfiguration.Host,
netConfiguration.WcfServiceName);
var netReceiveConfiguration2 = new NetReceiverConfiguration(netConfiguration.PortForCollector,
netConfiguration.Host,
netConfiguration.WcfServiceName);
var connection = new ConnectionConfiguration(netConfiguration.WcfServiceName,
netConfiguration.CountConnectionsToSingleServer);
var hashMap = new HashMapConfiguration(storageConfiguration.FileWithHashName,
HashMapCreationMode.ReadFromFile, 1,
storageConfiguration.CountReplics, HashFileType.Writer);
var restoreTransfer = new RestoreModuleConfiguration(1, storageConfiguration.TimeoutSendAnswerInRestore);
var restoreInitiator = new RestoreModuleConfiguration(storageConfiguration.CountRetryWaitAnswerInRestore,
storageConfiguration.TimeoutWaitAnswerInRestore);
var restoreTimeout = new RestoreModuleConfiguration(-1, storageConfiguration.PeriodStartDelete,
storageConfiguration.IsForceDelete, storageConfiguration.PeriodDeleteAfterRestore);
var timeout = new ConnectionTimeoutConfiguration(timeoutConfiguration.OpenTimeout,
timeoutConfiguration.SendTimeout);
_writerSystem = new WriterSystem(server, queue, netReceiveConfiguration,
netReceiveConfiguration2, hashMap,
connection, restoreTransfer, restoreInitiator, timeout, restoreTimeout, isNeedRestore, queueRestore);
_handler = new WriterHandler(_writerSystem);
}
public AsyncDbWorkModule(WriterNetModule writerNet, AsyncTaskModule async, DbModuleCollection db,
RestoreModuleConfiguration initiatorConfiguration,
RestoreModuleConfiguration transferConfiguration,
RestoreModuleConfiguration timeoutConfiguration,
QueueConfiguration queueConfiguration, ServerId local, bool isNeedRestore = false)
{
Contract.Requires(initiatorConfiguration != null);
Contract.Requires(transferConfiguration != null);
Contract.Requires(timeoutConfiguration != null);
Contract.Requires(queueConfiguration != null);
Contract.Requires(db != null);
Contract.Requires(writerNet != null);
Contract.Requires(async != null);
Contract.Requires(local != null);
_stateHelper = new RestoreStateHelper(isNeedRestore);
_initiatorRestore = new InitiatorRestoreModule(initiatorConfiguration, writerNet, async);
_transfer = new TransferRestoreModule(transferConfiguration, writerNet, async,
db, local, queueConfiguration);
_timeout = new TimeoutModule(writerNet, async, queueConfiguration,
db, timeoutConfiguration);
}
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();
}
