public DistributorModule(AsyncTaskModule async, AsyncDbWorkModule asyncDbWork,
WriterNetModule writerNet,
ServerId local,
HashMapConfiguration hashMapConfiguration,
QueueConfiguration configuration,
DbModuleCollection dbModuleCollection,
AsyncTasksConfiguration pingConfiguration = null)
{
Contract.Requires(local != null);
Contract.Requires(writerNet != null);
Contract.Requires(configuration != null);
Contract.Requires(asyncDbWork != null);
Contract.Requires(async != null);
Contract.Assert(dbModuleCollection != null);
_async = async;
_asyncDbWork = asyncDbWork;
_model = new WriterModel(local, hashMapConfiguration);
_writerNet = writerNet;
_queueConfiguration = configuration;
_dbModuleCollection = dbModuleCollection;
_queue = GlobalQueue.Queue;
var ping = TimeSpan.FromMinutes(1);
if (pingConfiguration != null)
{
ping = pingConfiguration.TimeoutPeriod;
}
_async.AddAsyncTask(
new AsyncDataPeriod(ping, Ping, AsyncTasksNames.AsyncPing, -1), false);
}
public void Build(int storageServer, string hashFile, int countReplics)
{
Q = new GlobalQueueInner();
GlobalQueue.SetQueue(Q);
var queueConfiguration = new QueueConfiguration(1, 1000);
var hashMapConfiguration = new HashMapConfiguration(hashFile,
HashMapCreationMode.ReadFromFile, 1, countReplics, HashFileType.Writer);
var local = new ServerId("localhost", storageServer);
_net = new WriterNetModule(new ConnectionConfiguration("testService", 10),
new ConnectionTimeoutConfiguration(Consts.OpenTimeout, Consts.SendTimeout));
Db = new DbModuleCollection();
Db.AddDbModule(new TestDbInMemory());
_async = new AsyncTaskModule(new QueueConfiguration(1, 10));
Restore = new AsyncDbWorkModule(_net, _async, Db,
new RestoreModuleConfiguration(10, TimeSpan.FromMinutes(100)),
new RestoreModuleConfiguration(10, TimeSpan.FromMilliseconds(100)),
new RestoreModuleConfiguration(-1, TimeSpan.FromHours(1), false, TimeSpan.FromHours(1)),
new QueueConfiguration(1, 100), local);
Distributor = new DistributorModule(_async, Restore, _net, local,
hashMapConfiguration, new QueueConfiguration(2, 10), Db);
_mainŠ” = new MainLogicModule(Distributor, Db);
Input = new InputModule(_mainŠ”, queueConfiguration);
_netRc = new NetWriterReceiver(Input, Distributor,
new NetReceiverConfiguration(storageServer, "localhost", "testService"),
new NetReceiverConfiguration(1, "fake", "fake"));
}
public InitiatorRestoreModule(RestoreModuleConfiguration configuration, WriterNetModule writerNet,
AsyncTaskModule asyncTaskModule) : base(writerNet, asyncTaskModule)
{
Contract.Requires(configuration != null);
_configuration = configuration;
_lock = new ReaderWriterLockSlim();
}
public CommonAsyncWorkModule(WriterNetModule writerNet, AsyncTaskModule asyncTaskModule)
{
Contract.Requires(writerNet != null);
Contract.Requires(asyncTaskModule != null);
_asyncTaskModule = asyncTaskModule;
WriterNet = writerNet;
_isStart = false;
}
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 override void Build()
{
var q = new GlobalQueueInner();
GlobalQueue.SetQueue(q);
var db = new DbModuleCollection();
var net = new WriterNetModule(_connectionConfiguration, _connectionTimeoutConfiguration);
var async = new AsyncTaskModule(_queueConfiguration);
var restore = new AsyncDbWorkModule(net, async, db, _initiatorRestoreConfiguration,
_transferRestoreConfiguration, _timeoutRestoreConfiguration,
_queueConfigurationRestore, _local, _isNeedRestore);
var distributor = new DistributorModule(async, restore, net, _local, _hashMapConfiguration,
_queueConfiguration, db);
Distributor = distributor;
DbModule = db;
var main = new MainLogicModule(distributor, db);
var input = new InputModule(main, _queueConfiguration);
var receiver = new NetWriterReceiver(input, distributor, _receiverConfigurationForWrite,
_receiverConfigurationForCollector);
AddModule(distributor);
AddModule(input);
AddModule(db);
AddModule(async);
AddModule(restore);
AddModule(main);
AddModule(receiver);
AddModule(q);
AddModuleDispose(receiver);
AddModuleDispose(restore);
AddModuleDispose(async);
AddModuleDispose(q);
AddModuleDispose(input);
AddModuleDispose(main);
AddModuleDispose(distributor);
AddModuleDispose(db);
AddModuleDispose(net);
}
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);
}
