private void InitManagers()
{
try
{
AccountManager = _objectFactory.GetAccountManager(_storage, Config);
BlockRepository = _objectFactory.GetBlockRepository(_storage);
PaymentRepository = _objectFactory.GetPaymentRepository(_storage);
MinerManager = _objectFactory.GetMinerManager(Config, _storage, AccountManager);
var jobTracker = _objectFactory.GetJobTracker(Config);
_shareManager = _objectFactory.GetShareManager(Config, Daemon, jobTracker, _storage);
_objectFactory.GetVardiffManager(Config, _shareManager);
_banningManager = _objectFactory.GetBanManager(Config, _shareManager);
_jobManager = _objectFactory.GetJobManager(Config, Daemon, jobTracker, _shareManager, MinerManager, HashAlgorithm);
_jobManager.Initialize(InstanceId);
var blockProcessor = _objectFactory.GetBlockProcessor(Config, Daemon, _storage);
var blockAccounter = _objectFactory.GetBlockAccounter(Config, _storage, AccountManager);
var paymentProcessor = _objectFactory.GetPaymentProcessor(Config, _storage, Daemon, AccountManager);
_objectFactory.GetPaymentManager(Config, blockProcessor, blockAccounter, paymentProcessor);
ProfitInfo = _objectFactory.GetProfitInfo(NetworkInfo, Config);
}
catch (Exception e)
{
_logger.Error("Pool initialization error: {0:l}", e.Message);
}
}
public PollResultsPageViewModel(
IObjectFactory <IPollResults> objectFactory,
IObjectFactory <IPoll> pollFactory,
IObjectFactory <IPollComment> pollCommentFactory,
IMessageBox messageBox,
ILogger logger
#if NETFX_CORE
, IShareManager shareManager,
ISecondaryPinner secondaryPinner
#endif // NETFX_CORE
)
{
this.objectFactory = objectFactory;
this.pollFactory = pollFactory;
this.pollCommentFactory = pollCommentFactory;
this.messageBox = messageBox;
this.logger = logger;
this.PollComments = new ObservableCollection <PollCommentViewModel>();
this.PollDataResults = new ObservableCollection <PollDataResultViewModel>();
#if NETFX_CORE
this.shareManager = shareManager;
this.secondaryPinner = secondaryPinner;
#endif // NETFX_CORE
}
public StlShare(IPathManager pathManager, ISiteRepository siteRepository, IContentRepository contentRepository, IShareManager shareManager)
{
_pathManager = pathManager;
_siteRepository = siteRepository;
_contentRepository = contentRepository;
_shareManager = shareManager;
}
public PollResultsPageViewModel(
INavigation navigation,
IObjectFactory<IPollResults> objectFactory,
IObjectFactory<IPoll> pollFactory,
IObjectFactory<IPollComment> pollCommentFactory,
IMessageBox messageBox
#if NETFX_CORE
, IShareManager shareManager,
ISecondaryPinner secondaryPinner
#endif // NETFX_CORE
)
: base(navigation)
{
this.objectFactory = objectFactory;
this.pollFactory = pollFactory;
this.pollCommentFactory = pollCommentFactory;
this.messageBox = messageBox;
this.PollComments = new ObservableCollection<PollCommentViewModel>();
#if NETFX_CORE
this.shareManager = shareManager;
this.secondaryPinner = secondaryPinner;
#endif // NETFX_CORE
}
private void InitManagers()
{
//try
//{
var storage = _objectFactory.GetStorage(Storages.Redis, Config);
_minerManager = _objectFactory.GetMinerManager(Config, _daemonClient);
var jobTracker = _objectFactory.GetJobTracker();
var blockProcessor = _objectFactory.GetBlockProcessor(Config, _daemonClient);
_shareManager = _objectFactory.GetShareManager(Config, _daemonClient, jobTracker, storage, blockProcessor);
var vardiffManager = _objectFactory.GetVardiffManager(Config, _shareManager);
_banningManager = _objectFactory.GetBanManager(Config, _shareManager);
_jobManager = _objectFactory.GetJobManager(Config, _daemonClient, jobTracker, _shareManager, _minerManager, _hashAlgorithm);
_jobManager.Initialize(InstanceId);
var paymentProcessor = _objectFactory.GetPaymentProcessor(Config, _daemonClient, storage, blockProcessor);
paymentProcessor.Initialize(Config.Payments);
var latestBlocks = _objectFactory.GetLatestBlocks(storage);
var blockStats = _objectFactory.GetBlockStats(latestBlocks, storage);
Statistics = _objectFactory.GetPerPoolStats(Config, _daemonClient, _minerManager, _hashAlgorithm, blockStats, storage);
//}
//catch (Exception e)
//{
// _logger.Error("Pool initialization error: {0:l}", e.Message);
//}
}
public StratumService(IPoolConfig poolConfig, IShareManager shareManager) :
base(poolConfig.Coin.Name)
{
_submitFrequency = 0;
_submitCounter = 1;
_shareManager = shareManager;
_poolConfig = poolConfig;
}
public StratumServiceTests()
{
_shareManager = Substitute.For<IShareManager>();
_poolConfig = Substitute.For<IPoolConfig>();
var miner = Substitute.For<IStratumMiner>();
_stratumContext = Substitute.For<StratumContext>(miner);
}
public IndexController(IAuthManager authManager, IPathManager pathManager, IWxManager wxManager, ISiteRepository siteRepository, IShareManager shareManager)
{
_authManager = authManager;
_pathManager = pathManager;
_wxManager = wxManager;
_siteRepository = siteRepository;
_shareManager = shareManager;
}
/// <summary>
/// Gets the specified service name.
/// </summary>
/// <param name="serviceName">Name of the service.</param>
/// <param name="shareManager">The share manager.</param>
/// <param name="daemonClient">The daemon client.</param>
/// <returns></returns>
public IRpcService Get(string serviceName, IShareManager shareManager, IDaemonClient daemonClient)
{
var @params = new NamedParameterOverloads
{
{"shareManager", shareManager},
{"daemonClient", daemonClient}
};
return _applicationContext.Container.Resolve<IRpcService>(serviceName, @params);
}
public DataBaseInitializer(
IClientManager clientManager,
IShareManager shareManager,
IBlockOfSharesManager blockOfSharesManager)
{
this.clientManager = clientManager;
this.shareManager = shareManager;
this.blockOfSharesManager = blockOfSharesManager;
}
public JobManager(IDaemonClient daemonClient, IJobTracker jobTracker, IShareManager shareManager, IMinerManager minerManager, IHashAlgorithm hashAlgorithm)
{
_daemonClient = daemonClient;
_jobTracker = jobTracker;
_shareManager = shareManager;
_minerManager = minerManager;
_hashAlgorithm = hashAlgorithm;
_jobCounter = new JobCounter();
}
public StratumServiceTests()
{
_shareManager = Substitute.For <IShareManager>();
_poolConfig = Substitute.For <IPoolConfig>();
var miner = Substitute.For <IStratumMiner>();
_stratumContext = Substitute.For <StratumContext>(miner);
}
public Win8FeedItemViewModel(
ISerializer serializer,
IStorage storage,
ISecondaryPinner secondaryPinner,
IShareManager shareManager)
: base(serializer, storage, secondaryPinner)
{
this.shareManager = shareManager;
}
public Win8FeedItemViewModel(
ISerializer serializer,
IStorage storage,
ISecondaryPinner secondaryPinner,
IShareManager shareManager)
: base(serializer, storage, secondaryPinner)
{
this.shareManager = shareManager;
}
public IVardiffManager GetVardiffManager(IPoolConfig poolConfig, IShareManager shareManager)
{
var @params = new NamedParameterOverloads
{
{ "poolConfig", poolConfig },
{ "shareManager", shareManager },
};
return(_applicationContext.Container.Resolve <IVardiffManager>(@params));
}
public IRpcService GetMiningService(string type, IPoolConfig poolConfig, IShareManager shareManager, IDaemonClient daemonClient)
{
var @params = new NamedParameterOverloads
{
{ "poolConfig", poolConfig },
{ "shareManager", shareManager },
{ "daemonClient", daemonClient }
};
return(_applicationContext.Container.Resolve <IRpcService>(type, @params));
}
public TableDrawer(
IOutputDevice outputDevice,
IBlockOfSharesManager blockOfSharesManager,
IClientManager clientManager,
IShareManager shareManager)
{
this.outputDevice = outputDevice;
this.blockOfSharesManager = blockOfSharesManager;
this.clientManager = clientManager;
this.shareManager = shareManager;
}
public IBanManager GetBanManager(string pool, IShareManager shareManager, IBanConfig banConfig)
{
var @params = new NamedParameterOverloads
{
{"pool", pool},
{"shareManager", shareManager},
{"banConfig", banConfig},
};
return _applicationContext.Container.Resolve<IBanManager>(@params);
}
/// <summary>
/// Gets the specified daemon client.
/// </summary>
/// <param name="daemonClient">The daemon client.</param>
/// <param name="jobTracker"></param>
/// <param name="shareManager"></param>
/// <param name="minerManager">The miner manager.</param>
/// <param name="hashAlgorithm"></param>
/// <returns></returns>
public IJobManager Get(IDaemonClient daemonClient, IJobTracker jobTracker, IShareManager shareManager, IMinerManager minerManager, IHashAlgorithm hashAlgorithm)
{
var @params = new NamedParameterOverloads
{
{"daemonClient", daemonClient},
{"jobTracker", jobTracker},
{"shareManager", shareManager},
{"minerManager", minerManager},
{"hashAlgorithm", hashAlgorithm}
};
return _applicationContext.Container.Resolve<IJobManager>(@params);
}
private Timer _blockPollerTimer; // timer for polling new blocks.
public JobManager(IPoolConfig poolConfig, IDaemonClient daemonClient, IJobTracker jobTracker, IShareManager shareManager,
IMinerManager minerManager, IHashAlgorithm hashAlgorithm)
{
_daemonClient = daemonClient;
_jobTracker = jobTracker;
_shareManager = shareManager;
_minerManager = minerManager;
_hashAlgorithm = hashAlgorithm;
_poolConfig = poolConfig;
_jobCounter = new JobCounter(); // todo make this ioc based too.
_logger = Log.ForContext <JobManager>().ForContext("Component", poolConfig.Coin.Name);
}
private Timer _reBroadcastTimer; // timer for rebroadcasting jobs after an pre-configured idle perioud.
#endregion Fields
#region Constructors
public JobManager(IPoolConfig poolConfig, IDaemonClient daemonClient, IJobTracker jobTracker, IShareManager shareManager,
IMinerManager minerManager, IHashAlgorithm hashAlgorithm)
{
_daemonClient = daemonClient;
_jobTracker = jobTracker;
_shareManager = shareManager;
_minerManager = minerManager;
_hashAlgorithm = hashAlgorithm;
_poolConfig = poolConfig;
_jobCounter = new JobCounter(); // todo make this ioc based too.
_logger = Log.ForContext<JobManager>().ForContext("Component", poolConfig.Coin.Name);
}
public BanManager(IPoolConfig poolConfig, IShareManager shareManager)
{
Config = poolConfig.Banning;
if (!Config.Enabled)
return;
_logger = Log.ForContext<BanManager>().ForContext("Component", poolConfig.Coin.Name);
_bannedIps = new Dictionary<IPAddress, int>();
_timer = new Timer(CheckBans, null, Timeout.Infinite, Timeout.Infinite); // create the timer as disabled.
shareManager.ShareSubmitted += OnShare;
CheckBans(null);
}
public JobManager(string pool, IDaemonClient daemonClient, IJobTracker jobTracker, IShareManager shareManager,
IMinerManager minerManager, IHashAlgorithm hashAlgorithm, IWalletConfig walletConfig,
IRewardsConfig rewardsConfig)
{
_daemonClient = daemonClient;
_jobTracker = jobTracker;
_shareManager = shareManager;
_minerManager = minerManager;
_hashAlgorithm = hashAlgorithm;
_walletConfig = walletConfig;
_rewardsConfig = rewardsConfig;
_jobCounter = new JobCounter(); // todo make this ioc based too.
_logger = Log.ForContext<JobManager>().ForContext("Component", pool);
}
public SimulationManager(
IOutputDevice outputDevice,
ITableDrawer tableDrawer,
ITransactionManager transactionManager,
IClientManager clientManager,
IShareManager shareManager,
IBlockOfSharesManager blockOfSharesManager)
{
this.outputDevice = outputDevice;
this.tableDrawer = tableDrawer;
this.transactionManager = transactionManager;
this.clientManager = clientManager;
this.shareManager = shareManager;
this.blockOfSharesManager = blockOfSharesManager;
}
public VardiffManager(IPoolConfig poolConfig, IShareManager shareManager)
{
_logger = Log.ForContext<VardiffManager>().ForContext("Component", poolConfig.Coin.Name);
Config = poolConfig.Stratum.Vardiff;
if (!Config.Enabled)
return;
shareManager.ShareSubmitted += OnShare;
var variance = Config.TargetTime * ((float)Config.VariancePercent / 100);
_bufferSize = Config.RetargetTime / Config.TargetTime * 4;
_tMin = Config.TargetTime - variance;
_tMax = Config.TargetTime + variance;
}
public VardiffManager(string pool, IShareManager shareManager, IVardiffConfig vardiffConfig)
{
_logger = Log.ForContext<VardiffManager>().ForContext("Component", pool);
Config = vardiffConfig;
if (!Config.Enabled)
return;
shareManager.ShareSubmitted += OnShare;
var variance = vardiffConfig.TargetTime*((float)vardiffConfig.VariancePercent/100);
_bufferSize = vardiffConfig.RetargetTime/vardiffConfig.TargetTime*4;
_tMin = vardiffConfig.TargetTime - variance;
_tMax = vardiffConfig.TargetTime + variance;
}
public BanManager(IPoolConfig poolConfig, IShareManager shareManager)
{
Config = poolConfig.Banning;
if (!Config.Enabled)
{
return;
}
_logger = Log.ForContext <BanManager>().ForContext("Component", poolConfig.Coin.Name);
_bannedIps = new Dictionary <IPAddress, int>();
_timer = new Timer(CheckBans, null, Timeout.Infinite, Timeout.Infinite); // create the timer as disabled.
shareManager.ShareSubmitted += OnShare;
CheckBans(null);
}
public UserInteractionManager(
IOutputDevice outputDevice,
IInputDevice inputDevice,
IClientManager clientManager,
IShareManager shareManager,
ITransactionManager transactionManager,
IBlockOfSharesManager blockOfSharesManager,
ICommandParser commandParse)
{
this.outputDevice = outputDevice;
this.inputDevice = inputDevice;
this.clientManager = clientManager;
this.shareManager = shareManager;
this.transactionManager = transactionManager;
this.blockOfSharesManager = blockOfSharesManager;
this.commandParse = commandParse;
}
public VardiffManager(IPoolConfig poolConfig, IShareManager shareManager)
{
_logger = Log.ForContext <VardiffManager>().ForContext("Component", poolConfig.Coin.Name);
Config = poolConfig.Stratum.Vardiff;
if (!Config.Enabled)
{
return;
}
shareManager.ShareSubmitted += OnShare;
var variance = Config.TargetTime * ((float)Config.VariancePercent / 100);
_bufferSize = Config.RetargetTime / Config.TargetTime * 4;
_tMin = Config.TargetTime - variance;
_tMax = Config.TargetTime + variance;
}
public ViewPollPageViewModel(
INavigation navigation,
IObjectFactory<IPollSubmissionCommand> objectFactory,
IObjectFactory<IPoll> pollFactory,
IMessageBox messageBox
#if NETFX_CORE
, IShareManager shareManager,
ISecondaryPinner secondaryPinner
#endif // NETFX_CORE
)
: base(navigation)
{
this.objectFactory = objectFactory;
this.pollFactory = pollFactory;
this.messageBox = messageBox;
#if NETFX_CORE
this.shareManager = shareManager;
this.secondaryPinner = secondaryPinner;
#endif // NETFX_CORE
}
public ViewPollPageViewModel(
IObjectFactory <IPollSubmissionCommand> objectFactory,
IObjectFactory <IPoll> pollFactory,
IMessageBox messageBox,
ILogger logger
#if NETFX_CORE
, IShareManager shareManager,
ISecondaryPinner secondaryPinner
#endif // NETFX_CORE
)
{
this.objectFactory = objectFactory;
this.pollFactory = pollFactory;
this.messageBox = messageBox;
this.logger = logger;
#if NETFX_CORE
this.shareManager = shareManager;
this.secondaryPinner = secondaryPinner;
#endif // NETFX_CORE
}
private bool InitCoreServices()
{
AccountManager = _objectFactory.GetAccountManager(_storage, Config);
MinerManager = _objectFactory.GetMinerManager(Config, _storage, AccountManager, Daemon);
var jobTracker = _objectFactory.GetJobTracker(Config);
_shareManager = _objectFactory.GetShareManager(Config, Daemon, jobTracker, _storage);
_objectFactory.GetVardiffManager(Config, _shareManager);
_banningManager = _objectFactory.GetBanManager(Config, _shareManager);
_jobManager = _objectFactory.GetJobManager(Config, Daemon, jobTracker, _shareManager, MinerManager, HashAlgorithm);
_jobManager.Initialize(InstanceId);
var blockProcessor = _objectFactory.GetBlockProcessor(Config, Daemon, _storage);
var blockAccounter = _objectFactory.GetBlockAccounter(Config, _storage, AccountManager);
var paymentProcessor = _objectFactory.GetPaymentProcessor(Config, _storage, Daemon, AccountManager);
_objectFactory.GetPaymentManager(Config, blockProcessor, blockAccounter, paymentProcessor);
return(true);
}
private void InitManagers()
{
try
{
BlocksCache = _objectFactory.GetBlocksCache(_storageLayer);
MinerManager = _objectFactory.GetMinerManager(Config, _storageLayer);
var jobTracker = _objectFactory.GetJobTracker(Config);
var blockProcessor = _objectFactory.GetBlockProcessor(Config, _daemonClient);
_shareManager = _objectFactory.GetShareManager(Config, _daemonClient, jobTracker, _storageLayer, blockProcessor);
_objectFactory.GetVardiffManager(Config, _shareManager);
_banningManager = _objectFactory.GetBanManager(Config, _shareManager);
_jobManager = _objectFactory.GetJobManager(Config, _daemonClient, jobTracker, _shareManager, MinerManager, HashAlgorithm);
_jobManager.Initialize(InstanceId);
var paymentProcessor = _objectFactory.GetPaymentProcessor(Config, _daemonClient, _storageLayer, blockProcessor);
paymentProcessor.Initialize();
}
catch (Exception e)
{
_logger.Error("Pool initialization error: {0:l}", e.Message);
}
}
public DatasetsController(IDatasetsManager datasetsManager, IShareManager shareManager, ILogger <DatasetsController> logger)
{
_datasetsManager = datasetsManager;
_shareManager = shareManager;
_logger = logger;
}
private bool InitCoreServices()
{
AccountManager = _objectFactory.GetAccountManager(_storage, Config);
MinerManager = _objectFactory.GetMinerManager(Config, _storage, AccountManager);
var jobTracker = _objectFactory.GetJobTracker(Config);
_shareManager = _objectFactory.GetShareManager(Config, Daemon, jobTracker, _storage);
_objectFactory.GetVardiffManager(Config, _shareManager);
_banningManager = _objectFactory.GetBanManager(Config, _shareManager);
_jobManager = _objectFactory.GetJobManager(Config, Daemon, jobTracker, _shareManager, MinerManager, HashAlgorithm);
_jobManager.Initialize(InstanceId);
var blockProcessor = _objectFactory.GetBlockProcessor(Config, Daemon, _storage);
var blockAccounter = _objectFactory.GetBlockAccounter(Config, _storage, AccountManager);
var paymentProcessor = _objectFactory.GetPaymentProcessor(Config, _storage, Daemon, AccountManager);
_objectFactory.GetPaymentManager(Config, blockProcessor, blockAccounter, paymentProcessor);
return true;
}
public StratumService(ICoinConfig coinConfig, IShareManager shareManager)
: base(coinConfig.Name)
{
_shareManager = shareManager;
}
public VanillaService(IPoolConfig poolConfig, IShareManager shareManager, IDaemonClient daemonClient) :
base(poolConfig.Coin.Name)
{
_daemonClient = daemonClient;
_shareManager = shareManager;
}
public StratumService(IShareManager shareManager)
{
_shareManager = shareManager;
}
public IJobManager GetJobManager(IPoolConfig poolConfig, IDaemonClient daemonClient, IJobTracker jobTracker, IShareManager shareManager, IMinerManager minerManager, IHashAlgorithm hashAlgorithm)
{
var @params = new NamedParameterOverloads
{
{ "poolConfig", poolConfig },
{ "daemonClient", daemonClient },
{ "jobTracker", jobTracker },
{ "shareManager", shareManager },
{ "minerManager", minerManager },
{ "hashAlgorithm", hashAlgorithm },
};
return(_applicationContext.Container.Resolve <IJobManager>(@params));
}
public ODataShareController(IShareManager sharesManager)
{
this.sharesManager = sharesManager;
}
private readonly IDaemonClient _daemonClient; // TODO: remove this!
public GetworkService(IPoolConfig poolConfig, IShareManager shareManager, IDaemonClient daemonClient) :
base(poolConfig.Coin.Name)
{
_daemonClient = daemonClient;
}
public WxController(IWxManager wxManager, IShareManager shareManager)
{
_wxManager = wxManager;
_shareManager = shareManager;
}
public IRpcService GetMiningService(string type, IPoolConfig poolConfig, IShareManager shareManager, IDaemonClient daemonClient)
{
var @params = new NamedParameterOverloads
{
{"poolConfig", poolConfig},
{"shareManager", shareManager},
{"daemonClient", daemonClient}
};
return _applicationContext.Container.Resolve<IRpcService>(type, @params);
}
public IVardiffManager GetVardiffManager(IPoolConfig poolConfig, IShareManager shareManager)
{
var @params = new NamedParameterOverloads
{
{"poolConfig", poolConfig},
{"shareManager", shareManager},
};
return _applicationContext.Container.Resolve<IVardiffManager>(@params);
}
public VanillaService(IShareManager shareManager, IDaemonClient daemonClient)
{
_daemonClient = daemonClient;
_shareManager = shareManager;
}
public PortfolioFundManager(IPortfolioManager portfolioManager, IShareManager shareManager, IBenchmarkIndexManager benchmarkIndexManager)
{
PortfolioManager = portfolioManager;
ShareManager = shareManager;
BenchmarkIndexManager = benchmarkIndexManager;
}
private void InitManagers()
{
// init the algorithm
_hashAlgorithm = _objectFactory.GetHashAlgorithm(Config.Coin.Algorithm);
_storage = _objectFactory.GetStorage(Storages.Redis, Config);
_paymentProcessor = _objectFactory.GetPaymentProcessor(Config.Coin.Name, _daemonClient, _storage, Config.Wallet);
_paymentProcessor.Initialize(Config.Payments);
_minerManager = _objectFactory.GetMiningManager(Config.Coin.Name, _daemonClient);
_jobTracker = _objectFactory.GetJobTracker();
_shareManager = _objectFactory.GetShareManager(Config.Coin.Name, _daemonClient, _jobTracker, _storage);
_vardiffManager = _objectFactory.GetVardiffManager(Config.Coin.Name, _shareManager, Config.Stratum.Vardiff);
_banningManager = _objectFactory.GetBanManager(Config.Coin.Name, _shareManager, Config.Banning);
_jobManager = _objectFactory.GetJobManager(Config.Coin.Name, _daemonClient, _jobTracker, _shareManager, _minerManager,
_hashAlgorithm, Config.Wallet, Config.Rewards);
_jobManager.Initialize(InstanceId);
var latestBlocks = _objectFactory.GetLatestBlocks(_storage);
var blockStats = _objectFactory.GetBlockStats(latestBlocks, _storage);
Statistics = _objectFactory.GetPerPoolStats(Config, _daemonClient, _minerManager, _hashAlgorithm, blockStats, _storage);
}
public ReadAllSharesStrategy(ILoggerService loggerService, ITableDrawer tableDrawer, IShareManager shareManager)
{
this.loggerService = loggerService;
this.tableDrawer = tableDrawer;
this.shareManager = shareManager;
}
private void InitManagers()
{
try
{
AccountManager = _objectFactory.GetAccountManager(_storage, Config);
BlockRepository = _objectFactory.GetBlockRepository(_storage);
PaymentRepository = _objectFactory.GetPaymentRepository(_storage);
MinerManager = _objectFactory.GetMinerManager(Config, _storage, AccountManager);
var jobTracker = _objectFactory.GetJobTracker(Config);
_shareManager = _objectFactory.GetShareManager(Config, Daemon, jobTracker, _storage);
_objectFactory.GetVardiffManager(Config, _shareManager);
_banningManager = _objectFactory.GetBanManager(Config, _shareManager);
_jobManager = _objectFactory.GetJobManager(Config, Daemon, jobTracker, _shareManager, MinerManager, HashAlgorithm);
_jobManager.Initialize(InstanceId);
var blockProcessor =_objectFactory.GetBlockProcessor(Config, Daemon, _storage);
var blockAccounter = _objectFactory.GetBlockAccounter(Config, _storage, AccountManager);
var paymentProcessor = _objectFactory.GetPaymentProcessor(Config, _storage, Daemon, AccountManager);
_objectFactory.GetPaymentManager(Config, blockProcessor, blockAccounter, paymentProcessor);
ProfitInfo = _objectFactory.GetProfitInfo(NetworkInfo, Config);
}
catch (Exception e)
{
_logger.Error("Pool initialization error: {0:l}", e.Message);
}
}
public StratumService(IPoolConfig poolConfig, IShareManager shareManager) :
base(poolConfig.Coin.Name)
{
_shareManager = shareManager;
}
private void InitManagers()
{
_storageManager = _storageManagerFactory.Get(Storages.Redis);
_minerManager = _minerManagerFactory.Get(_daemonClient);
_jobTracker = _jobTrackerFactory.Get();
_shareManager = _shareManagerFactory.Get(_daemonClient, _jobTracker, _storageManager);
_jobManager = _jobManagerFactory.Get(_daemonClient, _jobTracker, _shareManager, _minerManager, _hashAlgorithmFactory.Get(Config.Coin.Algorithm));
_jobManager.Initialize(InstanceId);
}
public VanillaService(ICoinConfig coinConfig, IShareManager shareManager, IDaemonClient daemonClient)
: base(coinConfig.Name)
{
_daemonClient = daemonClient;
_shareManager = shareManager;
}
public StratumService(IPoolConfig poolConfig, IShareManager shareManager)
: base(poolConfig.Coin.Name)
{
_shareManager = shareManager;
}
private readonly IDaemonClient _daemonClient; // TODO: remove this!
public GetworkService(IPoolConfig poolConfig, IShareManager shareManager, IDaemonClient daemonClient):
base(poolConfig.Coin.Name)
{
_daemonClient = daemonClient;
}
public ShareController(IShareManager shareManager)
{
ShareManager = shareManager;
}
/// <summary>
/// Initialize mock objects.
/// </summary>
public PoolTests()
{
_jobManagerFactory = Substitute.For<IJobManagerFactory>();
_jobTrackerFactory = Substitute.For<IJobTrackerFactory>();
_hashAlgorithmFactory = Substitute.For<IHashAlgorithmFactory>();
_shareManagerFactory = Substitute.For<IShareManagerFactory>();
_minerManagerFactory = Substitute.For<IMinerManagerFactory>();
_serverFactory = Substitute.For<IServerFactory>();
_serviceFactory = Substitute.For<IServiceFactory>();
_storageManagerFactory = Substitute.For<IStorageFactory>();
_globalConfigFactory = Substitute.For<IGlobalConfigFactory>();
_daemonClient = Substitute.For<IDaemonClient>();
_minerManager = Substitute.For<IMinerManager>();
_jobManager = Substitute.For<IJobManager>();
_jobTracker = Substitute.For<IJobTracker>();
_shareManager = Substitute.For<IShareManager>();
_miningServer = Substitute.For<IMiningServer>();
_rpcService = Substitute.For<IRpcService>();
_storage = Substitute.For<IStorage>();
}
public IJobManager GetJobManager(string pool, IDaemonClient daemonClient, IJobTracker jobTracker, IShareManager shareManager,
IMinerManager minerManager, IHashAlgorithm hashAlgorithm, IWalletConfig walletConfig, IRewardsConfig rewardsConfig)
{
var @params = new NamedParameterOverloads
{
{"pool", pool},
{"daemonClient", daemonClient},
{"jobTracker", jobTracker},
{"shareManager", shareManager},
{"minerManager", minerManager},
{"hashAlgorithm", hashAlgorithm},
{"walletConfig", walletConfig},
{"rewardsConfig", rewardsConfig},
};
return _applicationContext.Container.Resolve<IJobManager>(@params);
}
