public Erc20DepositTransactionService(IQueueFactory queueFactory,
ILog logger,
IExchangeContractService coinContractService,
IBaseSettings baseSettings,
IErc20DepositContractService erc20DepositContractService,
TransferContractService transferContractService,
IUserTransferWalletRepository userTransferWalletRepository,
IUserPaymentHistoryRepository userPaymentHistoryRepository,
ICoinTransactionService cointTransactionService,
ICoinTransactionRepository coinTransactionRepository,
ICoinEventService coinEventService,
IEventTraceRepository eventTraceRepository,
IErcInterfaceService ercInterfaceService,
SettingsWrapper settingsWrapper,
IHotWalletService hotWalletService)
{
_eventTraceRepository = eventTraceRepository;
_logger = logger;
_baseSettings = baseSettings;
_queue = queueFactory.Build(Constants.Erc20DepositCashinTransferQueue);
_erc20DepositContractService = erc20DepositContractService;
_transferContractService = transferContractService;
_userTransferWalletRepository = userTransferWalletRepository;
_userPaymentHistoryRepository = userPaymentHistoryRepository;
_cointTransactionService = cointTransactionService;
_coinTransactionRepository = coinTransactionRepository;
_coinEventService = coinEventService;
_ercInterfaceService = ercInterfaceService;
_hotWalletAddress = settingsWrapper.Ethereum.HotwalletAddress;
_hotWalletService = hotWalletService;
}
public LykkePayErc20DepositContractService(
[KeyFilter(Constants.LykkePayKey)] IErc223DepositContractRepository contractRepository,
[KeyFilter(Constants.LykkePayKey)] IHotWalletOperationRepository operationsRepository,
IContractService contractService,
IErc20DepositContractQueueServiceFactory poolFactory,
IBaseSettings settings,
ILog log,
IWeb3 web3,
AppSettings appSettings,
IQueueFactory factory,
IErcInterfaceService ercInterfaceService,
IUserTransferWalletRepository userTransferWalletRepository)
{
_contractRepository = contractRepository;
_contractService = contractService;
_poolFactory = poolFactory;
_settings = settings;
_log = log;
_web3 = web3;
_appSettings = appSettings;
_transferQueue = factory.Build(Constants.LykkePayErc223TransferQueue);
_ercInterfaceService = ercInterfaceService;
_operationsRepository = operationsRepository;
_userTransferWalletRepository = userTransferWalletRepository;
}
public DefaultConsumingProcess(IIdGenerator idGenerator,
IExchangeResolver exchangeResolver,
IMessageSerializer serializer,
IMessageTypeResolver messageTypeResolver,
IConsumerContainer consumerContainer,
IMessageFilter messageFilters,
IQueueFactory queueFactory,
IConsumerInvoker consumerInvoker,
RogerOptions options,
IAggregator aggregator)
{
this.consumerContainer = consumerContainer;
this.queueFactory = queueFactory;
this.consumerInvoker = consumerInvoker;
this.options = options;
this.aggregator = aggregator;
this.exchangeResolver = exchangeResolver;
bindingKeyResolver = new DefaultRoutingKeyResolver();
this.messageTypeResolver = messageTypeResolver;
this.serializer = serializer;
this.idGenerator = idGenerator;
supportedMessageTypesResolver = new DefaultSupportedMessageTypesResolver();
this.messageFilters = messageFilters;
aggregator.Subscribe(this);
}
public CoinEventResubmittJob(
ILog log,
IBaseSettings settings,
IPendingOperationService pendingOperationService,
IExchangeContractService exchangeContractService,
ICoinEventService coinEventService,
ITransferContractService transferContractService,
IEventTraceRepository eventTraceRepository,
IEthereumTransactionService ethereumTransactionService,
IQueueFactory queueFactory,
ISlackNotifier slackNotifier,
IOperationResubmittRepository operationResubmittRepository)
{
_eventTraceRepository = eventTraceRepository;
_exchangeContractService = exchangeContractService;
_pendingOperationService = pendingOperationService;
_settings = settings;
_log = log;
_coinEventService = coinEventService;
_transferContractService = transferContractService;
_ethereumTransactionService = ethereumTransactionService;
_transactionMonitoringQueue = queueFactory.Build(Constants.TransactionMonitoringQueue);
_slackNotifier = slackNotifier;
_operationResubmittRepository = operationResubmittRepository;
}
public AirlinesHotWalletMonitoringTransactionJob(ILog log,
ICoinTransactionService coinTransactionService,
AppSettings settings,
ISlackNotifier slackNotifier,
IEthereumTransactionService ethereumTransactionService,
[KeyFilter(Constants.AirLinesKey)] IHotWalletTransactionRepository hotWalletCashoutTransactionRepository,
[KeyFilter(Constants.AirLinesKey)] IHotWalletOperationRepository hotWalletCashoutRepository,
IRabbitQueuePublisher rabbitQueuePublisher,
ILykkePayEventsService transactionEventsService,
IUserTransferWalletRepository userTransferWalletRepository,
[KeyFilter(Constants.AirLinesKey)] IAirlinesErc20DepositContractService erc20DepositContractService,
IQueueFactory queueFactory)
{
_transactionEventsService = transactionEventsService;
_ethereumTransactionService = ethereumTransactionService;
_settings = settings;
_log = log;
_coinTransactionService = coinTransactionService;
_slackNotifier = slackNotifier;
_hotWalletCashoutTransactionRepository = hotWalletCashoutTransactionRepository;
_hotWalletCashoutRepository = hotWalletCashoutRepository;
_rabbitQueuePublisher = rabbitQueuePublisher;
_userTransferWalletRepository = userTransferWalletRepository;
_erc20DepositContractService = erc20DepositContractService;
_transferStartQueue = queueFactory.Build(Constants.AirlinesErc223TransferQueue);
}
public HotWalletService(IBaseSettings baseSettings,
IQueueFactory queueFactory,
IHotWalletOperationRepository hotWalletCashoutRepository,
IPrivateWalletService privateWalletService,
IErc20PrivateWalletService erc20PrivateWalletService,
ISignatureService signatureService,
ILog log,
Web3 web3,
IHotWalletTransactionRepository hotWalletCashoutTransactionRepository,
[KeyFilter(Constants.DefaultKey)] IErc20DepositContractService erc20DepositContractService,
AppSettings settingsWrapper,
IUserTransferWalletRepository userTransferWalletRepository,
IGasPriceRepository gasPriceRepository)
{
_hotWalletTransactionMonitoringQueue = queueFactory.Build(Constants.HotWalletTransactionMonitoringQueue);
_hotWalletCashoutQueue = queueFactory.Build(Constants.HotWalletCashoutQueue);
_baseSettings = baseSettings;//.HotWalletAddress
_hotWalletCashoutRepository = hotWalletCashoutRepository;
_privateWalletService = privateWalletService;
_erc20PrivateWalletService = erc20PrivateWalletService;
_log = log;
_web3 = web3;
_hotWalletCashoutTransactionRepository = hotWalletCashoutTransactionRepository;
_signatureService = signatureService;
_erc20DepositContractService = erc20DepositContractService;
_settingsWrapper = settingsWrapper;
_userTransferWalletRepository = userTransferWalletRepository;
_semaphores = new ConcurrentDictionary <string, SemaphoreSlim>();
_gasPriceRepository = gasPriceRepository;
}
public MonitoringTransferContracts(IBaseSettings settings,
IErcInterfaceService ercInterfaceService,
ITransferContractRepository transferContractsRepository,
ILog logger,
IPaymentService paymentService,
IUserPaymentRepository userPaymentRepository,
TransferContractService transferContractService,
IUserTransferWalletRepository userTransferWalletRepository,
ITransferContractTransactionService transferContractTransactionService,
IEthereumTransactionService ethereumTransactionService,
ITransferContractUserAssignmentQueueService transferContractUserAssignmentQueueService,
IUserAssignmentFailRepository userAssignmentFailRepository,
IQueueFactory queueFactory,
ISlackNotifier slackNotifier
)
{
_util = new AddressUtil();
_ethereumTransactionService = ethereumTransactionService;
_ercInterfaceService = ercInterfaceService;
_settings = settings;
_transferContractsRepository = transferContractsRepository;
_logger = logger;
_paymentService = paymentService;
_userPaymentRepository = userPaymentRepository;
_transferContractService = transferContractService;
_userTransferWalletRepository = userTransferWalletRepository;
_transferContractTransactionService = transferContractTransactionService;
_transferContractUserAssignmentQueueService = transferContractUserAssignmentQueueService;
_userAssignmentFailRepository = userAssignmentFailRepository;
_queueUserAssignment = queueFactory.Build(Constants.TransferContractUserAssignmentQueueName);
_slackNotifier = slackNotifier;
}
public Erc20DepositContractQueueServiceFactory(
IQueueFactory queueFactory,
ISlackNotifier slackNotifier)
{
_queueFactory = queueFactory;
_slackNotifier = slackNotifier;
}
public RedditModule(IQueueFactory queueFactory,
IGuildSettingsFactory guildSettingsFactory, ISubRedditHistoryFactory subRedditHistoryFactory, ISubRedditFactory subRedditFactory)
{
_queueFactory = queueFactory;
_guildSettingsFactory = guildSettingsFactory;
_subRedditHistoryFactory = subRedditHistoryFactory;
_subRedditFactory = subRedditFactory;
}
private LocalConfig(string queuesFolder, string projectionsFolder)
{
_queuesFolder = queuesFolder;
_projectionsFolder = projectionsFolder;
_serializer = new JsonValueSerializer();
_projectionsStore = new FileSystemDocumentStore(projectionsFolder, _serializer);
_queueFactory = new FileSystemQueueFactory(queuesFolder);
}
public AzureQueueFactory(IQueueFactory queueFactory,
IQueueSerializer queueSerializer,
IConnectionStringProvider connectionStringProvider)
{
_queueFactory = queueFactory;
_queueSerializer = queueSerializer;
_connectionStringProvider = connectionStringProvider;
}
public AmqpQueueManager(IExchangeLocator exchangeLocator, IQueueFactory queueFactory)
{
_exchangeLocator = exchangeLocator;
_queueFactory = queueFactory;
_bindingCount = new Dictionary<AmqpBinding, int>();
_boundQueues = new Dictionary<IExchange, IQueue>();
}
public TransferContractQueueServiceFactory(IQueueFactory queueFactory,
ITransferContractRepository transferContractRepository, ISlackNotifier slackNotifier,
ICoinRepository coinRepository)
{
_queueFactory = queueFactory;
_transferContractRepository = transferContractRepository;
_slackNotifier = slackNotifier;
_coinRepository = coinRepository;
}
private IQueue CreateQueue(IQueueFactory queueFactory, Uri queueUri)
{
var result = queueFactory.Create(queueUri);
Guard.AgainstNull(result,
string.Format(ESBResources.QueueFactoryCreatedNullQueue, queueFactory.GetType().FullName, queueUri));
return(result);
}
/// <inheritdoc />
public MessageBroker(ILogger logger, MessageBusConfig messageBusConfig, IQueueFactory queueFactory, IProcessInformation processInformation, IQueueNameUtility queueNameUtility)
{
_logger = logger;
_messageBusConfig = messageBusConfig;
_queueFactory = queueFactory;
_processInformation = processInformation;
_queueNameUtility = queueNameUtility;
_messageBrokerQueue = _queueFactory.CreateLocale(MessageBrokerConfig.LocaleQueueName, true, LocaleQueueMode.Durable, true, AccessMode.Send);
}
public QueueDispatcher(IQueueFactory <T> queueFactory)
{
if (queueFactory == null)
{
throw new ArgumentNullException(nameof(queueFactory));
}
_client = queueFactory.Create();
}
private static void Run(
IQueueFactory queueFactory,
IStatisticsProcesser processer,
IStatisticsWriter writer)
{
var q = queueFactory.Create();
q.OnMessageAsync(msg => MessageProcessor.ProcessAsync(processer, writer, msg),
new OnMessageOptions {AutoComplete = false});
}
public IntegrationEventQueue(IQueueChannelManager responseQueueChannelManager,
IQueueSettingsResolver queueSettingsResolver,
IQueueFactory responseQueueFactory,
ILoggerFactory loggerFactory)
{
_logger = loggerFactory.GetLogger <IntegrationEventQueue>();
_responseQueueChannelManager = responseQueueChannelManager;
_settings = queueSettingsResolver.GetSettings(nameof(IntegrationEventQueue));
responseQueueFactory.SetupQueue(_settings);
}
public QueueHandlerSyncTests()
{
_queue = Substitute.For <ILocaleQueue>();
_queueFactory = Substitute.For <IQueueFactory>();
_queueFactory.CreateLocale(Arg.Any <string>(), Arg.Any <bool>(), Arg.Any <LocaleQueueMode>(), Arg.Any <bool>(), Arg.Any <AccessMode>()).Returns(_queue);
_taskFactory = Substitute.For <ITaskFactory>();
_taskFactory.Create().Returns(new SyncTestTask());
_cancellationToken = new CancellationToken();
}
/// <inheritdoc />
public QueueHandler(ILogger logger, IQueueFactory queueFactory, ITaskFactory taskFactory)
{
_queueFactory = queueFactory;
_taskFactory = taskFactory;
_logger = logger;
_workTasks = new List <ITask>();
_heartRateMonitor = new Stopwatch();
_messageReceived = true;
}
public TransactionProcessorIntegrationEventQueue(IQueueChannelManager responseQueueChannelManager,
IQueueSettingsResolver queueSettingsResolver,
IQueueFactory responseQueueFactory,
ILoggerFactory loggerFactory)
{
_logger = loggerFactory.GetLogger <IntegrationEventQueue>();
_responseQueueChannelManager = responseQueueChannelManager;
_settings = queueSettingsResolver.GetSettings(nameof(IntegrationEventQueue));
responseQueueFactory.CreateExchange(_settings);
}
public BusConfigurationBuilder(IQueueFactory queueFactory, ITopicFactory topicFactory, ISubscriptionFactory subscriptionFactory)
{
_queueFactory = queueFactory;
_topicFactory = topicFactory;
_subscriptionFactory = subscriptionFactory;
_queuesRequiringCreation = new List <IQueueInstance>();
_eventsRequiringCreation = new List <Type>();
_eventSubscriptions = new List <EventSubscription>();
}
public LargeMessageQueueFactory(
IQueueFactory queueFactory,
IBlobRepositoryFactory blobRepositoryFactory,
IQueueSerializer serializer,
ILoggerFactory loggerFactory)
{
_queueFactory = queueFactory;
_blobRepositoryFactory = blobRepositoryFactory;
_serializer = serializer;
_loggerFactory = loggerFactory;
}
public QueueObservable(ILogger <ManagedObservable <T> > logger,
IQueueFactory <T> queueFactory) : base(logger)
{
if (queueFactory == null)
{
throw new ArgumentNullException(nameof(queueFactory));
}
_queueClient = queueFactory.Create();
_queueClient.RegisterCallback(Notify);
}
/// <summary>
/// Base constructor must be called from your derrived class
/// </summary>
/// <param name="queueFactory"></param>
public ReusableObjectFactory(IQueueFactory queueFactory)
{
_queueFactory = queueFactory;
DisposeAction = reusable =>
{
if (reusable.IsReusable)
{
Queue.Enqueue(reusable);
}
};
}
public void RegisterQueueFactory(IQueueFactory queueFactory)
{
Guard.AgainstNull(queueFactory, "queueFactory");
if (ContainsQueueFactory(queueFactory.Scheme))
{
throw new DuplicateQueueFactoryException(queueFactory);
}
queueFactories.Add(queueFactory);
}
public QueueHandlerAsyncTests()
{
_queue = Substitute.For <ILocaleQueue>();
_queue.Receive(Arg.Any <int>(), Arg.Any <CancellationToken>()).Returns(e => CreateMessage("Message1"), e => CreateMessage("Message2"), e => CreateMessage("Message3"), e => null);
_queueFactory = Substitute.For <IQueueFactory>();
_queueFactory.CreateLocale(Arg.Any <string>(), Arg.Any <bool>(), Arg.Any <LocaleQueueMode>(), Arg.Any <bool>(), Arg.Any <AccessMode>()).Returns(_queue);
_taskFactory = new TaskFactory();
_cancellationTokenSource = new CancellationTokenSource();
_cancellationToken = _cancellationTokenSource.Token;
}
public FileReader(ISettingReaderFactory settingReaderFactory,
IXmlSettingsProviderFactory settingsProviderFactory,
IInternalLogger internalLogger,
IOutput[] outputs, IQueueFactory queueFactory, string filePath)
{
_settingReaderFactory = settingReaderFactory;
_settingsProviderFactory = settingsProviderFactory;
_internalLogger = internalLogger;
_outputs = outputs;
_queueFactory = queueFactory;
_filePath = filePath;
}
private bool disposedValue = false; // To detect redundant calls
/// <summary>
/// Releases unmanaged and - optionally - managed resources.
/// </summary>
/// <param name="disposing"><c>true</c> to release both managed and unmanaged resources; <c>false</c> to release only unmanaged resources.</param>
protected virtual void Dispose(bool disposing)
{
if (!this.disposedValue)
{
if (disposing)
{
this.queueFactory.Dispose();
this.queueFactory = null;
}
this.disposedValue = true;
}
}
protected void InitilizeServices()
{
if (Environment.UserInteractive)
{
Logger = new ConsoleLogger();
}
else
{
Logger = new FileLogger("", Severity.Debug);
}
HealthReporter = new ConsoleHealthReporter();
QueueFactory = new InMemoryConcurrentQueueFactory(Logger);
}
public NamespaceBasedCommandRouter(string queueNamePrefix, IQueueFactory queueFactory, ISerializer serializer)
{
if (queueFactory == null) throw new ArgumentNullException("queueFactory");
if (serializer == null) throw new ArgumentNullException("serializer");
//prefix for namespace-based queue names
_queueNamePrefix = MakePrefix(queueNamePrefix);
_queueFactory = queueFactory;
//this guy again :(
_serializer = new QueueMessageSerializer(serializer);
}
public QueueListener(ILoggerFactory loggerFactory,
IQueueChannelManager queueChannelManager,
IQueueSettingsResolver queueSettingsResolver,
IQueueFactory queueFactory,
IServiceProvider serviceProvider)
{
_serviceProvider = serviceProvider;
_logger = loggerFactory.GetLogger <QueueListener>();
_settings = queueSettingsResolver.GetSettings(nameof(QueueListener));
_channel = queueChannelManager.GetChannel();
_consumer = new EventingBasicConsumer(_channel);
queueFactory.SetupQueue(_settings);
}
public ArrayFactory(IQueueFactory queueFactory)
{
_queueFactory = queueFactory;
// Define standard array sizes, this increases chances of reuse
_arraySizes = new long[40];
_arraySizes[0] = 32;
for (var i = 1; i < _arraySizes.Length; i++)
{
_arraySizes[i] = _arraySizes[i - 1] * 2;
}
_pools = new ThreadSafeDictionary <Type, object>();
}
public DataContextFactory(
IQueueFactory queueFactory,
IDictionaryFactory dictionaryFactory,
IDataDependencyFactory dataDependencyFactory,
IIdManager idManager)
: base(queueFactory)
{
_dictionaryFactory = dictionaryFactory;
_dataDependencyFactory = dataDependencyFactory;
_idManager = idManager;
Initialize(100);
}
public EventStoreToQueueDistributor(
string queueName,
IQueueFactory queueFactory,
IEventStore eventStore,
IDocumentStore projectionStore,
ISerializer serializer)
{
_markerReader = projectionStore.GetReader<string, EventStoreMarker>();
_markerWriter = projectionStore.GetWriter<string, EventStoreMarker>();
_queueName = queueName;
_eventStore = eventStore;
_queueWriter = queueFactory.CreateWriter(queueName);
_serializer = new QueueMessageSerializer(serializer);
}
public void Setup()
{
connection = Substitute.For<IReliableConnection>();
model = Substitute.For<IModelWithConnection>();
connection.CreateModel().Returns(model);
queueFactory = Substitute.For<IQueueFactory>();
aggregator = new Aggregator();
sut = new DefaultConsumingProcess(Substitute.For<IIdGenerator>(),
Substitute.For<IExchangeResolver>(),
Substitute.For<IMessageSerializer>(),
Substitute.For<IMessageTypeResolver>(),
Substitute.For<IConsumerContainer>(),
Substitute.For<IMessageFilter>(),
queueFactory,
Substitute.For<IConsumerInvoker>(),
new RogerOptions(), aggregator);
}
public QueueSender(IQueueFactory queueFactory)
{
_factory = queueFactory;
}
public void RegisterQueueFactory(IQueueFactory queueFactory)
{
Guard.AgainstNull(queueFactory, "queueFactory");
var factory = GetQueueFactory(queueFactory.Scheme);
if (factory != null)
{
QueueFactories().Remove(factory);
_log.Warning(string.Format(ESBResources.DuplicateQueueFactoryReplaced, queueFactory.Scheme, factory.GetType().FullName, queueFactory.GetType().FullName));
}
QueueFactories().Add(queueFactory);
}
public void RegisterQueueFactory(IQueueFactory queueFactory)
{
Guard.AgainstNull(queueFactory, "queueFactory");
if (
queueFactories.Find(
factory => factory.Scheme.Equals(queueFactory.Scheme, StringComparison.InvariantCultureIgnoreCase)) !=
null)
{
throw new DuplicateQueueFactoryException(queueFactory);
}
queueFactories.Add(queueFactory);
}
public NamespaceBasedCommandRouter(IQueueFactory queueFactory, ISerializer serializer)
: this(String.Empty, queueFactory, serializer)
{
}
public DuplicateQueueFactoryException(IQueueFactory factory)
: base(string.Format(ESBResources.DuplicateQueueFactoryException, factory.Scheme, factory.GetType().FullName))
{
}
public QueueReceiver(IQueueFactory queueFactory, IMailProcessor mailProcessor)
{
_factory = queueFactory;
_mailProcessor = mailProcessor;
}
private IQueue CreateQueue(IQueueFactory queueFactory, Uri queueUri)
{
var result = queueFactory.Create(queueUri);
Guard.AgainstNull(result,
string.Format(ESBResources.QueueFactoryCreatedNullQueue, queueFactory.GetType().FullName, queueUri));
return result;
}