public SecureCookieProvider(ITimeProvider timeProvider)
{
string key = ConfigurationManager.AppSettings.Get("CookieKey");
string salt = ConfigurationManager.AppSettings.Get("CookieSalt");
crypto = CryptoFactory.Rijndael(key, salt);
this.timeProvider = timeProvider;
}
public static bool EvalDailyTrigger(this IDailyScheduledTask task, ITimeProvider timeProvider)
{
if (task.RepeatIntervalInDays <= 0 || ((Int32)(timeProvider.Time.Date - task.StartTime.Date).TotalDays % task.RepeatIntervalInDays != 0))
return false;
return TimeHelpers.AreTimesEqualToTheSecond(timeProvider.Time, task.StartTime);
}
protected override void Given()
{
_timeProvider = new FakeTimeProvider();
_mp = new ManagedProjection(
_bus, Guid.NewGuid(), 1, "name", true, null, _writeDispatcher, _readDispatcher, _bus, _bus, _handlerFactory,
_timeProvider);
}
public static bool EvalWeeklyTrigger(this IWeeklyScheduledTask task, ITimeProvider timeProvider)
{
if (task.RepeatIntervalInWeeks <= 0 || (((Int32)(timeProvider.Time.Date - task.StartTime.Date).TotalDays / 7) % task.RepeatIntervalInWeeks != 0)) return false;
var dayOfWeek = (int)timeProvider.Time.DayOfWeek;
var daysOfWeek = (DaysOfWeek)(1 << dayOfWeek);
return task.DaysOfWeekToActivate.HasFlag(daysOfWeek) && TimeHelpers.AreTimesEqualToTheSecond(timeProvider.Time, task.StartTime);
}
public BrowserExecutionContextCreator(IBrowserStepExecutionStrategyFactory stepExecutionStrategyFactory,
IWebDriverFactory webDriverFactory, ITimeProvider timeProvider)
{
_stepExecutionStrategyFactory = stepExecutionStrategyFactory;
_webDriverFactory = webDriverFactory;
_timeProvider = timeProvider;
}
public virtual void Init(Func<bool> shouldPauseCb, ITimeProvider time, WeaponConfig config, Rect levelBounds)
{
base.Init( shouldPauseCb, time);
Config = config;
LevelBounds = levelBounds;
ShotFiredTimeStamp = Time.Time;
}
public void Init(Func< bool > shouldPauseCb, ITimeProvider time, WeaponConfig config, Rect levelBounds, int shotDirection)
{
base.Init( shouldPauseCb, time, config, levelBounds );
PrefabPoolManager.Prepare( ShotPrefabLink, 8);
ShotDirection = shotDirection;
}
protected override void Context()
{
DBContext = new PRToolsEntities();
TimeProvider = new TimeProvider();
DocumentRepository = new DocumentRepository(DBContext, TimeProvider);
_testConntection = new SqlConnection("Server=SULPYWIN7;Database=PRTools;Integrated Security=True;");
_testConntection.Open();
_transactionScope = new TransactionScope();
using (_transactionScope)
{
var sql =
@"SET IDENTITY_INSERT Customers ON
INSERT INTO Customers ([CustomerId], [CustomerTypeKey], [GooglePlacesURL], [ListName], [Name], [ParentCustomerId], [Phone], [TwitterHandle], [WebsiteURL])
VALUES ("+CustomerId+@", 'CorporateClient', 'googlePlacesURL', 'ListName', 'Name', 0, '555-555-5555', '@twitterhandle', 'www.website.com')
SET IDENTITY_INSERT Customers OFF
SET IDENTITY_INSERT CustomLocalizationFields ON
INSERT INTO CustomLocalizationFields ([CustomLocalizationFieldId], [FieldName])
VALUES (1, '"+SomeCustomField+@"')
SET IDENTITY_INSERT CustomLocalizationFields OFF
SET IDENTITY_INSERT CustomLocalizationFieldValues ON
INSERT INTO CustomLocalizationFieldValues ([CustomLocalizationFieldValueId], [FieldValue], [CustomerId], [CustomLocalizationFieldId])
VALUES (1, '"+SomeCustomFieldValue+@"', 5, 1)
SET IDENTITY_INSERT CustomLocalizationFieldValues OFF";
var command = new SqlCommand(sql, _testConntection);
command.ExecuteNonQuery();
}
}
public static IReaderStrategy Create(
ISourceDefinitionConfigurator sources, ITimeProvider timeProvider, IPrincipal runAs)
{
var builder = new Builder();
sources.ConfigureSourceProcessingStrategy(builder);
return builder.Build(timeProvider, runAs);
}
public override sealed IProjectionProcessingPhase[] CreateProcessingPhases(
IPublisher publisher, Guid projectionCorrelationId, PartitionStateCache partitionStateCache,
Action updateStatistics, CoreProjection coreProjection, ProjectionNamesBuilder namingBuilder,
ITimeProvider timeProvider, IODispatcher ioDispatcher,
CoreProjectionCheckpointWriter coreProjectionCheckpointWriter)
{
var definesFold = _sourceDefinition.DefinesFold;
var readerStrategy = CreateReaderStrategy(timeProvider);
var zeroCheckpointTag = readerStrategy.PositionTagger.MakeZeroCheckpointTag();
var checkpointManager = CreateCheckpointManager(
projectionCorrelationId, publisher, ioDispatcher, namingBuilder, coreProjectionCheckpointWriter,
definesFold, readerStrategy);
var resultWriter = CreateFirstPhaseResultWriter(
checkpointManager as IEmittedEventWriter, zeroCheckpointTag, namingBuilder);
var firstPhase = CreateFirstProcessingPhase(
publisher, projectionCorrelationId, partitionStateCache, updateStatistics, coreProjection,
_subscriptionDispatcher, zeroCheckpointTag, checkpointManager, readerStrategy, resultWriter);
return CreateProjectionProcessingPhases(
publisher, projectionCorrelationId, namingBuilder, partitionStateCache, coreProjection, ioDispatcher,
firstPhase);
}
protected CommandCreator(IOutputManager outputManager, ITimeProvider timeProvider, IMessagesRepository messagesRepository, IFollowingRepository followingRepository)
{
OutputManager = outputManager;
TimeProvider = timeProvider;
MessagesRepository = messagesRepository;
FollowingRepository = followingRepository;
}
public void CalculateStoreOmittedOrPartlyCompletedShotPoints(DrillingDepartmentId id, ITimeProvider provider)
{
// Check if this was previously done
// Store the data
// TODO - SHOULD THIS BE VISUALISED
// Issue OmittedOrPartlyCompletedShotPointsStored event
}
public void AddPlannedWorkgroup(DrillingDepartmentId id, RequestId requestId, WorkgroupEntity we, ITimeProvider provider)
{
// Create the Planned Workgroup
DoWork("Create a Planned Workgroup and add to the Drilling Department Structure");
RecordAndRealizeThat(new PlannedWorkgroupAddedToDepartment(id, requestId, we, provider.GetUtcNow()));
}
protected ReaderSubscriptionBase(
IPublisher publisher,
Guid subscriptionId,
CheckpointTag @from,
IReaderStrategy readerStrategy,
ITimeProvider timeProvider,
long? checkpointUnhandledBytesThreshold,
int? checkpointProcessedEventsThreshold,
bool stopOnEof,
int? stopAfterNEvents)
{
if (publisher == null) throw new ArgumentNullException("publisher");
if (readerStrategy == null) throw new ArgumentNullException("readerStrategy");
if (timeProvider == null) throw new ArgumentNullException("timeProvider");
if (checkpointProcessedEventsThreshold > 0 && stopAfterNEvents > 0)
throw new ArgumentException("checkpointProcessedEventsThreshold > 0 && stopAfterNEvents > 0");
_publisher = publisher;
_readerStrategy = readerStrategy;
_timeProvider = timeProvider;
_checkpointUnhandledBytesThreshold = checkpointUnhandledBytesThreshold;
_checkpointProcessedEventsThreshold = checkpointProcessedEventsThreshold;
_stopOnEof = stopOnEof;
_stopAfterNEvents = stopAfterNEvents;
_subscriptionId = subscriptionId;
_lastPassedOrCheckpointedEventPosition = null;
_eventFilter = readerStrategy.EventFilter;
_positionTagger = readerStrategy.PositionTagger;
_positionTracker = new PositionTracker(_positionTagger);
_positionTracker.UpdateByCheckpointTagInitial(@from);
}
public SystemInformationProvider(ITimeProvider timeProvider, IMachineNameProvider machineNameProvider, ISystemPerformanceDataProvider systemPerformanceDataProvider, IHttpStatusCodeCheckResultProvider httpStatusCodeCheckResultProvider)
{
if (timeProvider == null)
{
throw new ArgumentNullException("timeProvider");
}
if (machineNameProvider == null)
{
throw new ArgumentNullException("machineNameProvider");
}
if (systemPerformanceDataProvider == null)
{
throw new ArgumentNullException("systemPerformanceDataProvider");
}
if (httpStatusCodeCheckResultProvider == null)
{
throw new ArgumentNullException("httpStatusCodeCheckResultProvider");
}
this.timeProvider = timeProvider;
this.machineNameProvider = machineNameProvider;
this.systemPerformanceDataProvider = systemPerformanceDataProvider;
this.httpStatusCodeCheckResultProvider = httpStatusCodeCheckResultProvider;
}
public MainWindow(ITimeProvider provider)
{
LogTimeCommand = new DelegateCommand( ActionLogTime );
_provider = provider;
DataContext = this;
Directory.CreateDirectory( "Work" );
var doc = XDocument.Load( "config.xml" );
_breakElements = doc.XPathSelectElements("//Break").ToList();
var catList = doc.XPathSelectElements("//Category").Select(e => e.Value).ToList();
Cats = new ObservableCollection< string >(catList);
#if DEBUG
for ( var i = 0; i < 10; ++i )
{
Cats.Add( "Project "+i );
}
#endif
InitializeComponent();
_dumpBreaks();
list.IsEnabled = false;
// Disable updater for now, fake time
/* {
startTime.Text = "8:00";
_doNotUpdate = true;
}*/
//_doNotUpdate = false;
_updater = Task.Run( () =>
{
while ( true )
{
if ( DoNotUpdate == false )
{
startTime.Dispatcher.Invoke( () => startTime.Text = DateTime.Now.ToString( "HH:mm:ss" ) );
}
//startTime.Dispatcher.Invoke(() => startTime.Text = SystemClock.Instance.Now.ToString("HH:mm", null));
Thread.Sleep( 1000 );
}
} ).ContinueWith( ErrorFunc );
}
public void setup()
{
_checkpointUnhandledBytesThreshold = 1000;
_checkpointProcessedEventsThreshold = 2000;
Given();
_bus = new InMemoryBus("bus");
_timeProvider = new RealTimeProvider();
_projectionCorrelationId = Guid.NewGuid();
_eventHandler = new TestHandler<EventReaderSubscriptionMessage.CommittedEventReceived>();
_checkpointHandler = new TestHandler<EventReaderSubscriptionMessage.CheckpointSuggested>();
_progressHandler = new TestHandler<EventReaderSubscriptionMessage.ProgressChanged>();
_subscriptionStartedHandler = new TestHandler<EventReaderSubscriptionMessage.SubscriptionStarted>();
_notAuthorizedHandler = new TestHandler<EventReaderSubscriptionMessage.NotAuthorized>();
_eofHandler = new TestHandler<EventReaderSubscriptionMessage.EofReached>();
_partitionEofHandler = new TestHandler<EventReaderSubscriptionMessage.PartitionEofReached>();
_partitionMeasuredHandler = new TestHandler<EventReaderSubscriptionMessage.PartitionMeasured>();
_partitionDeletedHandler = new TestHandler<EventReaderSubscriptionMessage.PartitionDeleted>();
_bus.Subscribe(_eventHandler);
_bus.Subscribe(_checkpointHandler);
_bus.Subscribe(_progressHandler);
_bus.Subscribe(_eofHandler);
_bus.Subscribe(_partitionEofHandler);
_bus.Subscribe(_partitionMeasuredHandler);
_readerStrategy = CreateCheckpointStrategy();
_subscription = CreateProjectionSubscription();
When();
}
protected override void Given()
{
_projectionName = "projection";
_coreProjectionId = Guid.NewGuid();
_timeProvider = new FakeTimeProvider();
_mp = new ManagedProjection(
Guid.NewGuid(),
Guid.NewGuid(),
1,
"name",
true,
null,
_writeDispatcher,
_readDispatcher,
_bus,
_timeProvider, new RequestResponseDispatcher
<CoreProjectionManagementMessage.GetState, CoreProjectionStatusMessage.StateReport>(
_bus,
v => v.CorrelationId,
v => v.CorrelationId,
new PublishEnvelope(_bus)), new RequestResponseDispatcher
<CoreProjectionManagementMessage.GetResult, CoreProjectionStatusMessage.ResultReport>(
_bus,
v => v.CorrelationId,
v => v.CorrelationId,
new PublishEnvelope(_bus)));
}
public void Register(
TFChunkDb db, QueuedHandler mainQueue, ISubscriber mainBus, TimerService timerService,
ITimeProvider timeProvider, IHttpForwarder httpForwarder, HttpService[] httpServices, IPublisher networkSendService)
{
_projections = new EventStore.Projections.Core.Projections(
db, mainQueue, mainBus, timerService, timeProvider, httpForwarder, httpServices, networkSendService,
projectionWorkerThreadCount: _projectionWorkerThreadCount, runProjections: _runProjections);
}
public override IProjectionProcessingPhase[] CreateProcessingPhases(
IPublisher publisher, Guid projectionCorrelationId, PartitionStateCache partitionStateCache,
Action updateStatistics, CoreProjection coreProjection, ProjectionNamesBuilder namingBuilder,
ITimeProvider timeProvider, IODispatcher ioDispatcher,
CoreProjectionCheckpointWriter coreProjectionCheckpointWriter)
{
return new IProjectionProcessingPhase[] {_phase1, _phase2};
}
public void DefineProject(Guid requestId, string name, ITimeProvider provider)
{
// filter request IDs
var time = provider.GetUtcNow();
var id = new ProjectId(NewGuidIfEmpty(requestId));
Apply(new ProjectDefined(_state.Id, id, name, time));
}
public DataCash3DSecureRequestBuilder(DataCash3DSecureConfiguration configuration, HttpRequestBase httpRequest)
: base(configuration)
{
if (httpRequest == null) throw new ArgumentNullException("httpRequest");
_configuration = configuration;
_httpRequest = httpRequest;
SystemTime = new TimeProvider();
}
public TimerBasedScheduler(ITimer timer, ITimeProvider timeProvider)
{
Ensure.NotNull(timer, "timer");
Ensure.NotNull(timeProvider, "timeProvider");
_timer = timer;
_timeProvider = timeProvider;
}
public MockWikiApplication(FederationConfiguration configuration, LinkMaker linkMaker,
OutputFormat outputFormat, ITimeProvider timeProvider)
{
_configuration = configuration;
_linkMaker = linkMaker;
_ouputFormat = outputFormat;
_timeProvider = timeProvider;
}
public ParallelQueryAllStreamsMasterReaderStrategy(
int phase, IPrincipal runAs, ITimeProvider timeProvider)
{
_runAs = runAs;
_timeProvider = timeProvider;
_eventFilter = new StreamEventFilter("$streams", true, null);
_positionTagger = new CatalogStreamPositionTagger(phase, "$streams");
}
public QueueListener(IQueueListenerConfiguration config, IQueue queue, IScenarioRunner scenarioRunner, IProgressReporter progressReporter, ITimeProvider timeProvider)
{
_config = config;
_queue = queue;
_scenarioRunner = scenarioRunner;
_progressReporter = progressReporter;
_timeProvider = timeProvider;
}
public void setup()
{
_timeProvider = new FakeTimeProvider();
_manager = new ProjectionManager(_bus, _bus, new IPublisher[] { _bus }, _timeProvider, RunProjections.All);
_bus.Subscribe<ClientMessage.WriteEventsCompleted>(_manager);
_bus.Subscribe<ClientMessage.ReadStreamEventsBackwardCompleted>(_manager);
_manager.Handle(new SystemMessage.BecomeMaster(Guid.NewGuid()));
}
public static CheckpointStrategy Create(
ISourceDefinitionConfigurator sources, ProjectionConfig config, ITimeProvider timeProvider)
{
var builder = new Builder();
sources.ConfigureSourceProcessingStrategy(builder);
return builder.Build(
config, config.RunAs, Processing.ReaderStrategy.Create(sources, timeProvider, config.RunAs));
}
public TransactionFileEventReader(IPublisher publisher, Guid distibutionPointCorrelationId, EventPosition @from, ITimeProvider timeProvider, bool stopOnEof = false, bool deliverEndOfTFPosition = true)
: base(publisher, distibutionPointCorrelationId, stopOnEof)
{
if (publisher == null) throw new ArgumentNullException("publisher");
_from = @from;
_deliverEndOfTfPosition = deliverEndOfTFPosition;
_timeProvider = timeProvider;
}
public void ArchiveAction(ActionId actionId, ITimeProvider time)
{
var action = GetActionOrThrow(actionId);
if (!action.Archived)
{
Apply(new ActionArchived(_aggState.Id, actionId, action.Project, time.GetUtcNow()));
}
}
public PassowrdResetValidator(IReadOnlyRepository readOnlyRepo, ITimeProvider timeProvider)
{
_readOnlyRepo = readOnlyRepo;
_timeProvider = timeProvider;
}
public NativeTaxRepository(ITimeProvider time)
{
_time = time;
}
public void SetFrameTimeProvider(ITimeProvider timeProvider) => FVVVVHost.SetTimeProvider(timeProvider);
private IDataFeed RunDataFeed(IAlgorithm algorithm, out FuncDataQueueHandler dataQueueHandler, ITimeProvider timeProvider = null, Func <FuncDataQueueHandler, IEnumerable <BaseData> > getNextTicksFunction = null)
{
getNextTicksFunction = getNextTicksFunction ?? (fdqh => fdqh.Subscriptions.Select(symbol => new Tick(DateTime.Now, symbol, 1, 2)
{
Quantity = 1
}));
// job is used to send into DataQueueHandler
var job = new LiveNodePacket();
// result handler is used due to dependency in SubscriptionDataReader
var resultHandler = new BacktestingResultHandler(); // new ResultHandlerStub();
dataQueueHandler = new FuncDataQueueHandler(getNextTicksFunction);
var feed = new TestableLiveTradingDataFeed(dataQueueHandler, timeProvider);
var mapFileProvider = new LocalDiskMapFileProvider();
var fileProvider = new DefaultDataProvider();
feed.Initialize(algorithm, job, resultHandler, mapFileProvider, new LocalDiskFactorFileProvider(mapFileProvider), fileProvider);
var feedThreadStarted = new ManualResetEvent(false);
Task.Factory.StartNew(() =>
{
feedThreadStarted.Set();
feed.Run();
});
// wait for feed.Run to actually begin
feedThreadStarted.WaitOne();
return(feed);
}
public VacancyTransferService(ITimeProvider timeProvider, IVacancyRepository vacancyRepository, IVacancyReviewQuery vacancyReviewQuery)
{
_timeProvider = timeProvider;
_vacancyRepository = vacancyRepository;
_vacancyReviewQuery = vacancyReviewQuery;
}
public ProjectionManager(
IPublisher inputQueue,
IPublisher publisher,
IDictionary <Guid, IPublisher> queueMap,
ITimeProvider timeProvider,
ProjectionType runProjections,
bool initializeSystemProjections = true)
{
if (inputQueue == null)
{
throw new ArgumentNullException("inputQueue");
}
if (publisher == null)
{
throw new ArgumentNullException("publisher");
}
if (queueMap == null)
{
throw new ArgumentNullException("queueMap");
}
if (queueMap.Count == 0)
{
throw new ArgumentException("At least one queue is required", "queueMap");
}
_inputQueue = inputQueue;
_publisher = publisher;
_queues = queueMap.Select(v => Tuple.Create(v.Key, v.Value)).ToArray();
_workers = _queues.Select(v => v.Item1).ToArray();
_timeProvider = timeProvider;
_runProjections = runProjections;
_initializeSystemProjections = initializeSystemProjections;
_writeDispatcher =
new RequestResponseDispatcher <ClientMessage.WriteEvents, ClientMessage.WriteEventsCompleted>(
publisher,
v => v.CorrelationId,
v => v.CorrelationId,
new PublishEnvelope(_inputQueue));
_readDispatcher =
new RequestResponseDispatcher
<ClientMessage.ReadStreamEventsBackward, ClientMessage.ReadStreamEventsBackwardCompleted>(
publisher,
v => v.CorrelationId,
v => v.CorrelationId,
new PublishEnvelope(_inputQueue));
_streamDispatcher =
new RequestResponseDispatcher <ClientMessage.DeleteStream, ClientMessage.DeleteStreamCompleted>(
publisher,
v => v.CorrelationId,
v => v.CorrelationId,
new PublishEnvelope(_inputQueue));
_projections = new Dictionary <string, ManagedProjection>();
_projectionsMap = new Dictionary <Guid, string>();
_publishEnvelope = new PublishEnvelope(_inputQueue, crossThread: true);
_getStateDispatcher =
new RequestResponseDispatcher
<CoreProjectionManagementMessage.GetState, CoreProjectionStatusMessage.StateReport>(
_publisher,
v => v.CorrelationId,
v => v.CorrelationId,
new PublishEnvelope(_inputQueue));
_getResultDispatcher =
new RequestResponseDispatcher
<CoreProjectionManagementMessage.GetResult, CoreProjectionStatusMessage.ResultReport>(
_publisher,
v => v.CorrelationId,
v => v.CorrelationId,
new PublishEnvelope(_inputQueue));
}
public Client(ITimeProvider timeProvider)
{
this.timeProvider = timeProvider;
}
public StartPageFactoryContentfulFactory(ITimeProvider timeProvider, IContentfulFactory <ContentfulAlert, Alert> alertFactory, IContentfulFactory <ContentfulReference, Crumb> crumbFactory)
{
_dateComparer = new DateComparer(timeProvider);
_alertFactory = alertFactory;
_crumbFactory = crumbFactory;
}
/// <summary>
/// Initializes a new instance of the <see cref="TimeTriggeredUniverseSubscriptionEnumeratorFactory"/> class
/// </summary>
/// <param name="universe">The user defined universe</param>
/// <param name="marketHoursDatabase">The market hours database</param>
/// <param name="timeProvider">The time provider</param>
public TimeTriggeredUniverseSubscriptionEnumeratorFactory(ITimeTriggeredUniverse universe, MarketHoursDatabase marketHoursDatabase, ITimeProvider timeProvider)
{
_universe = universe;
_timeProvider = timeProvider;
_marketHoursDatabase = marketHoursDatabase;
}
public AddCardCommandHandler(WordkiDbContext dbContext, ITimeProvider dateTimeProvider)
{
this.dbContext = dbContext;
this.dateTimeProvider = dateTimeProvider;
}
public DatesOrchestrator(IProviderVacancyClient client, IRecruitVacancyClient vacancyClient, ILogger <DatesOrchestrator> logger, ITimeProvider timeProvider, IReviewSummaryService reviewSummaryService, IApprenticeshipProgrammeProvider apprenticeshipProgrammeProvider) : base(logger)
{
_client = client;
_vacancyClient = vacancyClient;
_timeProvider = timeProvider;
_reviewSummaryService = reviewSummaryService;
_apprenticeshipProgrammeProvider = apprenticeshipProgrammeProvider;
}
public MongoDbReferenceDataRepository(ILoggerFactory loggerFactory, IOptions <MongoDbConnectionDetails> details, ITimeProvider timeProvider)
: base(loggerFactory, MongoDbNames.RecruitDb, MongoDbCollectionNames.ReferenceData, details)
{
_timeProvider = timeProvider;
_itemIdLookup = BuildLookup();
}
/// <summary>
/// Initializes the data feed for the specified job and algorithm
/// </summary>
public void Initialize(IAlgorithm algorithm, AlgorithmNodePacket job, IResultHandler resultHandler, IMapFileProvider mapFileProvider, IFactorFileProvider factorFileProvider, IDataFileProvider dataFileProvider)
{
if (!(job is LiveNodePacket))
{
throw new ArgumentException("The LiveTradingDataFeed requires a LiveNodePacket.");
}
_cancellationTokenSource = new CancellationTokenSource();
_algorithm = algorithm;
_job = (LiveNodePacket)job;
_resultHandler = resultHandler;
_timeProvider = GetTimeProvider();
_dataQueueHandler = GetDataQueueHandler();
_dataFileProvider = dataFileProvider;
_frontierTimeProvider = new ManualTimeProvider(_timeProvider.GetUtcNow());
_customExchange = new BaseDataExchange("CustomDataExchange")
{
SleepInterval = 10
};
// sleep is controlled on this exchange via the GetNextTicksEnumerator
_exchange = new BaseDataExchange("DataQueueExchange")
{
SleepInterval = 0
};
_exchange.AddEnumerator(DataQueueHandlerSymbol, GetNextTicksEnumerator());
_subscriptions = new SubscriptionCollection();
_bridge = new BusyBlockingCollection <TimeSlice>();
_universeSelection = new UniverseSelection(this, algorithm, job.Controls);
// run the exchanges
Task.Run(() => _exchange.Start(_cancellationTokenSource.Token));
Task.Run(() => _customExchange.Start(_cancellationTokenSource.Token));
// this value will be modified via calls to AddSubscription/RemoveSubscription
var ffres = Time.OneMinute;
_fillForwardResolution = Ref.Create(() => ffres, v => ffres = v);
// wire ourselves up to receive notifications when universes are added/removed
var start = _timeProvider.GetUtcNow();
algorithm.UniverseManager.CollectionChanged += (sender, args) =>
{
switch (args.Action)
{
case NotifyCollectionChangedAction.Add:
foreach (var universe in args.NewItems.OfType <Universe>())
{
var config = universe.Configuration;
var marketHoursDatabase = MarketHoursDatabase.FromDataFolder();
var exchangeHours = marketHoursDatabase.GetExchangeHours(config);
Security security;
if (!_algorithm.Securities.TryGetValue(config.Symbol, out security))
{
// create a canonical security object
security = new Security(exchangeHours, config, _algorithm.Portfolio.CashBook[CashBook.AccountCurrency], SymbolProperties.GetDefault(CashBook.AccountCurrency));
}
AddSubscription(new SubscriptionRequest(true, universe, security, config, start, Time.EndOfTime));
// Not sure if this is needed but left here because of this:
// https://github.com/QuantConnect/Lean/commit/029d70bde6ca83a1eb0c667bb5cc4444bea05678
UpdateFillForwardResolution();
}
break;
case NotifyCollectionChangedAction.Remove:
foreach (var universe in args.OldItems.OfType <Universe>())
{
RemoveSubscription(universe.Configuration);
}
break;
default:
throw new NotImplementedException("The specified action is not implemented: " + args.Action);
}
};
}
public PilotController(ILogger <PilotController> logger, IPilotService scheduleService, ITimeProvider timeProvider)
{
_logger = logger;
_scheduleService = scheduleService;
_timeProvider = timeProvider;
}
public HomeController(ApplicationDbContext context, ITimeProvider timeProvider)
{
this.timeProvider = timeProvider;
}
private ReaderStrategy(
bool allStreams, HashSet <string> categories, HashSet <string> streams, bool allEvents, bool includeLinks,
HashSet <string> events, int processingLag, bool reorderEvents, IPrincipal runAs, ITimeProvider timeProvider)
{
_allStreams = allStreams;
_categories = categories;
_streams = streams;
_allEvents = allEvents;
_includeLinks = includeLinks;
_events = events;
_processingLag = processingLag;
_reorderEvents = reorderEvents;
_runAs = runAs;
_eventFilter = CreateEventFilter();
_positionTagger = CreatePositionTagger();
_timeProvider = timeProvider;
}
public BackendFactory(IMessageHandler messageHandler, ITimeProvider timeProvider)
{
_messageHandler = messageHandler;
_timeProvider = timeProvider;
}
//NOTE: this is only for slave projections (TBD)
public CoreProjection(
ProjectionProcessingStrategy projectionProcessingStrategy,
ProjectionVersion version,
Guid projectionCorrelationId,
IPublisher inputQueue,
Guid workerId,
IPrincipal runAs,
IPublisher publisher,
IODispatcher ioDispatcher,
ReaderSubscriptionDispatcher subscriptionDispatcher,
ILogger logger,
ProjectionNamesBuilder namingBuilder,
CoreProjectionCheckpointWriter coreProjectionCheckpointWriter,
PartitionStateCache partitionStateCache,
string effectiveProjectionName,
ITimeProvider timeProvider)
{
if (publisher == null)
{
throw new ArgumentNullException("publisher");
}
if (ioDispatcher == null)
{
throw new ArgumentNullException("ioDispatcher");
}
if (subscriptionDispatcher == null)
{
throw new ArgumentNullException("subscriptionDispatcher");
}
_projectionProcessingStrategy = projectionProcessingStrategy;
_projectionCorrelationId = projectionCorrelationId;
_inputQueue = inputQueue;
_workerId = workerId;
_runAs = runAs;
_name = effectiveProjectionName;
_version = version;
_stopOnEof = projectionProcessingStrategy.GetStopOnEof();
_logger = logger ?? LogManager.GetLoggerFor <CoreProjection>();
_publisher = publisher;
_ioDispatcher = ioDispatcher;
_partitionStateCache = partitionStateCache;
_requiresRootPartition = projectionProcessingStrategy.GetRequiresRootPartition();
var useCheckpoints = projectionProcessingStrategy.GetUseCheckpoints();
_coreProjectionCheckpointWriter = coreProjectionCheckpointWriter;
_projectionProcessingPhases = projectionProcessingStrategy.CreateProcessingPhases(
publisher,
inputQueue,
projectionCorrelationId,
partitionStateCache,
UpdateStatistics,
this,
namingBuilder,
timeProvider,
ioDispatcher,
coreProjectionCheckpointWriter);
//NOTE: currently assuming the first checkpoint manager to be able to load any state
_checkpointReader = new CoreProjectionCheckpointReader(
publisher,
_projectionCorrelationId,
ioDispatcher,
namingBuilder.MakeCheckpointStreamName(),
_version,
useCheckpoints);
_enrichStatistics = projectionProcessingStrategy.EnrichStatistics;
GoToState(State.Initial);
}
public ClusterVNode(TFChunkDb db,
ClusterVNodeSettings vNodeSettings,
IGossipSeedSource gossipSeedSource,
InfoController infoController,
params ISubsystem[] subsystems)
{
Ensure.NotNull(db, "db");
Ensure.NotNull(vNodeSettings, "vNodeSettings");
Ensure.NotNull(gossipSeedSource, "gossipSeedSource");
var isSingleNode = vNodeSettings.ClusterNodeCount == 1;
_nodeInfo = vNodeSettings.NodeInfo;
_mainBus = new InMemoryBus("MainBus");
var forwardingProxy = new MessageForwardingProxy();
if (vNodeSettings.EnableHistograms)
{
HistogramService.CreateHistograms();
//start watching jitter
HistogramService.StartJitterMonitor();
}
// MISC WORKERS
_workerBuses = Enumerable.Range(0, vNodeSettings.WorkerThreads).Select(queueNum =>
new InMemoryBus(string.Format("Worker #{0} Bus", queueNum + 1),
watchSlowMsg: true,
slowMsgThreshold: TimeSpan.FromMilliseconds(200))).ToArray();
_workersHandler = new MultiQueuedHandler(
vNodeSettings.WorkerThreads,
queueNum => new QueuedHandlerThreadPool(_workerBuses[queueNum],
string.Format("Worker #{0}", queueNum + 1),
groupName: "Workers",
watchSlowMsg: true,
slowMsgThreshold: TimeSpan.FromMilliseconds(200)));
_subsystems = subsystems;
_controller = new ClusterVNodeController((IPublisher)_mainBus, _nodeInfo, db, vNodeSettings, this, forwardingProxy, _subsystems);
_mainQueue = QueuedHandler.CreateQueuedHandler(_controller, "MainQueue");
_controller.SetMainQueue(_mainQueue);
//SELF
_mainBus.Subscribe <SystemMessage.StateChangeMessage>(this);
_mainBus.Subscribe <SystemMessage.BecomeShutdown>(this);
// MONITORING
var monitoringInnerBus = new InMemoryBus("MonitoringInnerBus", watchSlowMsg: false);
var monitoringRequestBus = new InMemoryBus("MonitoringRequestBus", watchSlowMsg: false);
var monitoringQueue = new QueuedHandlerThreadPool(monitoringInnerBus, "MonitoringQueue", true, TimeSpan.FromMilliseconds(100));
var monitoring = new MonitoringService(monitoringQueue,
monitoringRequestBus,
_mainQueue,
db.Config.WriterCheckpoint,
db.Config.Path,
vNodeSettings.StatsPeriod,
_nodeInfo.ExternalHttp,
vNodeSettings.StatsStorage,
_nodeInfo.ExternalTcp,
_nodeInfo.ExternalSecureTcp);
_mainBus.Subscribe(monitoringQueue.WidenFrom <SystemMessage.SystemInit, Message>());
_mainBus.Subscribe(monitoringQueue.WidenFrom <SystemMessage.StateChangeMessage, Message>());
_mainBus.Subscribe(monitoringQueue.WidenFrom <SystemMessage.BecomeShuttingDown, Message>());
_mainBus.Subscribe(monitoringQueue.WidenFrom <SystemMessage.BecomeShutdown, Message>());
_mainBus.Subscribe(monitoringQueue.WidenFrom <ClientMessage.WriteEventsCompleted, Message>());
monitoringInnerBus.Subscribe <SystemMessage.SystemInit>(monitoring);
monitoringInnerBus.Subscribe <SystemMessage.StateChangeMessage>(monitoring);
monitoringInnerBus.Subscribe <SystemMessage.BecomeShuttingDown>(monitoring);
monitoringInnerBus.Subscribe <SystemMessage.BecomeShutdown>(monitoring);
monitoringInnerBus.Subscribe <ClientMessage.WriteEventsCompleted>(monitoring);
monitoringInnerBus.Subscribe <MonitoringMessage.GetFreshStats>(monitoring);
monitoringInnerBus.Subscribe <MonitoringMessage.GetFreshTcpConnectionStats>(monitoring);
var truncPos = db.Config.TruncateCheckpoint.Read();
if (truncPos != -1)
{
Log.Info("Truncate checkpoint is present. Truncate: {0} (0x{0:X}), Writer: {1} (0x{1:X}), Chaser: {2} (0x{2:X}), Epoch: {3} (0x{3:X})",
truncPos, db.Config.WriterCheckpoint.Read(), db.Config.ChaserCheckpoint.Read(), db.Config.EpochCheckpoint.Read());
var truncator = new TFChunkDbTruncator(db.Config);
truncator.TruncateDb(truncPos);
}
// STORAGE SUBSYSTEM
db.Open(vNodeSettings.VerifyDbHash);
var indexPath = vNodeSettings.Index ?? Path.Combine(db.Config.Path, "index");
var readerPool = new ObjectPool <ITransactionFileReader>(
"ReadIndex readers pool", ESConsts.PTableInitialReaderCount, ESConsts.PTableMaxReaderCount,
() => new TFChunkReader(db, db.Config.WriterCheckpoint, optimizeReadSideCache: db.Config.OptimizeReadSideCache));
var tableIndex = new TableIndex(indexPath,
new XXHashUnsafe(),
new Murmur3AUnsafe(),
() => new HashListMemTable(vNodeSettings.IndexBitnessVersion, maxSize: vNodeSettings.MaxMemtableEntryCount * 2),
() => new TFReaderLease(readerPool),
vNodeSettings.IndexBitnessVersion,
maxSizeForMemory: vNodeSettings.MaxMemtableEntryCount,
maxTablesPerLevel: 2,
inMem: db.Config.InMemDb,
skipIndexVerify: vNodeSettings.SkipIndexVerify,
indexCacheDepth: vNodeSettings.IndexCacheDepth);
var readIndex = new ReadIndex(_mainQueue,
readerPool,
tableIndex,
ESConsts.StreamInfoCacheCapacity,
Application.IsDefined(Application.AdditionalCommitChecks),
Application.IsDefined(Application.InfiniteMetastreams) ? int.MaxValue : 1,
vNodeSettings.HashCollisionReadLimit,
vNodeSettings.SkipIndexScanOnReads,
db.Config.ReplicationCheckpoint);
var writer = new TFChunkWriter(db);
var epochManager = new EpochManager(_mainQueue,
ESConsts.CachedEpochCount,
db.Config.EpochCheckpoint,
writer,
initialReaderCount: 1,
maxReaderCount: 5,
readerFactory: () => new TFChunkReader(db, db.Config.WriterCheckpoint, optimizeReadSideCache: db.Config.OptimizeReadSideCache));
epochManager.Init();
var storageWriter = new ClusterStorageWriterService(_mainQueue, _mainBus, vNodeSettings.MinFlushDelay,
db, writer, readIndex.IndexWriter, epochManager,
() => readIndex.LastCommitPosition); // subscribes internally
monitoringRequestBus.Subscribe <MonitoringMessage.InternalStatsRequest>(storageWriter);
var storageReader = new StorageReaderService(_mainQueue, _mainBus, readIndex, vNodeSettings.ReaderThreadsCount, db.Config.WriterCheckpoint);
_mainBus.Subscribe <SystemMessage.SystemInit>(storageReader);
_mainBus.Subscribe <SystemMessage.BecomeShuttingDown>(storageReader);
_mainBus.Subscribe <SystemMessage.BecomeShutdown>(storageReader);
monitoringRequestBus.Subscribe <MonitoringMessage.InternalStatsRequest>(storageReader);
var indexCommitterService = new IndexCommitterService(readIndex.IndexCommitter, _mainQueue, db.Config.ReplicationCheckpoint, db.Config.WriterCheckpoint, vNodeSettings.CommitAckCount);
_mainBus.Subscribe <SystemMessage.StateChangeMessage>(indexCommitterService);
_mainBus.Subscribe <SystemMessage.BecomeShuttingDown>(indexCommitterService);
_mainBus.Subscribe <StorageMessage.CommitAck>(indexCommitterService);
var chaser = new TFChunkChaser(db, db.Config.WriterCheckpoint, db.Config.ChaserCheckpoint, db.Config.OptimizeReadSideCache);
var storageChaser = new StorageChaser(_mainQueue, db.Config.WriterCheckpoint, chaser, indexCommitterService, epochManager);
#if DEBUG
QueueStatsCollector.InitializeCheckpoints(
_nodeInfo.DebugIndex, db.Config.WriterCheckpoint, db.Config.ChaserCheckpoint);
#endif
_mainBus.Subscribe <SystemMessage.SystemInit>(storageChaser);
_mainBus.Subscribe <SystemMessage.SystemStart>(storageChaser);
_mainBus.Subscribe <SystemMessage.BecomeShuttingDown>(storageChaser);
// AUTHENTICATION INFRASTRUCTURE - delegate to plugins
_internalAuthenticationProvider = vNodeSettings.AuthenticationProviderFactory.BuildAuthenticationProvider(_mainQueue, _mainBus, _workersHandler, _workerBuses);
Ensure.NotNull(_internalAuthenticationProvider, "authenticationProvider");
{
// EXTERNAL TCP
if (!vNodeSettings.DisableInsecureTCP)
{
var extTcpService = new TcpService(_mainQueue, _nodeInfo.ExternalTcp, _workersHandler,
TcpServiceType.External, TcpSecurityType.Normal, new ClientTcpDispatcher(),
vNodeSettings.ExtTcpHeartbeatInterval, vNodeSettings.ExtTcpHeartbeatTimeout,
_internalAuthenticationProvider, null, vNodeSettings.ConnectionPendingSendBytesThreshold);
_mainBus.Subscribe <SystemMessage.SystemInit>(extTcpService);
_mainBus.Subscribe <SystemMessage.SystemStart>(extTcpService);
_mainBus.Subscribe <SystemMessage.BecomeShuttingDown>(extTcpService);
}
// EXTERNAL SECURE TCP
if (_nodeInfo.ExternalSecureTcp != null)
{
var extSecTcpService = new TcpService(_mainQueue, _nodeInfo.ExternalSecureTcp, _workersHandler,
TcpServiceType.External, TcpSecurityType.Secure, new ClientTcpDispatcher(),
vNodeSettings.ExtTcpHeartbeatInterval, vNodeSettings.ExtTcpHeartbeatTimeout,
_internalAuthenticationProvider, vNodeSettings.Certificate, vNodeSettings.ConnectionPendingSendBytesThreshold);
_mainBus.Subscribe <SystemMessage.SystemInit>(extSecTcpService);
_mainBus.Subscribe <SystemMessage.SystemStart>(extSecTcpService);
_mainBus.Subscribe <SystemMessage.BecomeShuttingDown>(extSecTcpService);
}
if (!isSingleNode)
{
// INTERNAL TCP
if (!vNodeSettings.DisableInsecureTCP)
{
var intTcpService = new TcpService(_mainQueue, _nodeInfo.InternalTcp, _workersHandler,
TcpServiceType.Internal, TcpSecurityType.Normal,
new InternalTcpDispatcher(),
vNodeSettings.IntTcpHeartbeatInterval, vNodeSettings.IntTcpHeartbeatTimeout,
_internalAuthenticationProvider, null, ESConsts.UnrestrictedPendingSendBytes);
_mainBus.Subscribe <SystemMessage.SystemInit>(intTcpService);
_mainBus.Subscribe <SystemMessage.SystemStart>(intTcpService);
_mainBus.Subscribe <SystemMessage.BecomeShuttingDown>(intTcpService);
}
// INTERNAL SECURE TCP
if (_nodeInfo.InternalSecureTcp != null)
{
var intSecTcpService = new TcpService(_mainQueue, _nodeInfo.InternalSecureTcp, _workersHandler,
TcpServiceType.Internal, TcpSecurityType.Secure,
new InternalTcpDispatcher(),
vNodeSettings.IntTcpHeartbeatInterval, vNodeSettings.IntTcpHeartbeatTimeout,
_internalAuthenticationProvider, vNodeSettings.Certificate, ESConsts.UnrestrictedPendingSendBytes);
_mainBus.Subscribe <SystemMessage.SystemInit>(intSecTcpService);
_mainBus.Subscribe <SystemMessage.SystemStart>(intSecTcpService);
_mainBus.Subscribe <SystemMessage.BecomeShuttingDown>(intSecTcpService);
}
}
}
SubscribeWorkers(bus =>
{
var tcpSendService = new TcpSendService();
// ReSharper disable RedundantTypeArgumentsOfMethod
bus.Subscribe <TcpMessage.TcpSend>(tcpSendService);
// ReSharper restore RedundantTypeArgumentsOfMethod
});
var httpAuthenticationProviders = new List <HttpAuthenticationProvider>
{
new BasicHttpAuthenticationProvider(_internalAuthenticationProvider),
};
if (vNodeSettings.EnableTrustedAuth)
{
httpAuthenticationProviders.Add(new TrustedHttpAuthenticationProvider());
}
httpAuthenticationProviders.Add(new AnonymousHttpAuthenticationProvider());
var httpPipe = new HttpMessagePipe();
var httpSendService = new HttpSendService(httpPipe, forwardRequests: true);
_mainBus.Subscribe <SystemMessage.StateChangeMessage>(httpSendService);
_mainBus.Subscribe(new WideningHandler <HttpMessage.SendOverHttp, Message>(_workersHandler));
SubscribeWorkers(bus =>
{
bus.Subscribe <HttpMessage.HttpSend>(httpSendService);
bus.Subscribe <HttpMessage.HttpSendPart>(httpSendService);
bus.Subscribe <HttpMessage.HttpBeginSend>(httpSendService);
bus.Subscribe <HttpMessage.HttpEndSend>(httpSendService);
bus.Subscribe <HttpMessage.SendOverHttp>(httpSendService);
});
_mainBus.Subscribe <SystemMessage.StateChangeMessage>(infoController);
var adminController = new AdminController(_mainQueue);
var pingController = new PingController();
var histogramController = new HistogramController();
var statController = new StatController(monitoringQueue, _workersHandler);
var atomController = new AtomController(httpSendService, _mainQueue, _workersHandler, vNodeSettings.DisableHTTPCaching);
var gossipController = new GossipController(_mainQueue, _workersHandler, vNodeSettings.GossipTimeout);
var persistentSubscriptionController = new PersistentSubscriptionController(httpSendService, _mainQueue, _workersHandler);
var electController = new ElectController(_mainQueue);
// HTTP SENDERS
gossipController.SubscribeSenders(httpPipe);
electController.SubscribeSenders(httpPipe);
// EXTERNAL HTTP
_externalHttpService = new HttpService(ServiceAccessibility.Public, _mainQueue, new TrieUriRouter(),
_workersHandler, vNodeSettings.LogHttpRequests, vNodeSettings.GossipAdvertiseInfo.AdvertiseExternalIPAs,
vNodeSettings.GossipAdvertiseInfo.AdvertiseExternalHttpPortAs, vNodeSettings.ExtHttpPrefixes);
_externalHttpService.SetupController(persistentSubscriptionController);
if (vNodeSettings.AdminOnPublic)
{
_externalHttpService.SetupController(adminController);
}
_externalHttpService.SetupController(pingController);
_externalHttpService.SetupController(infoController);
if (vNodeSettings.StatsOnPublic)
{
_externalHttpService.SetupController(statController);
}
_externalHttpService.SetupController(atomController);
if (vNodeSettings.GossipOnPublic)
{
_externalHttpService.SetupController(gossipController);
}
_externalHttpService.SetupController(histogramController);
_mainBus.Subscribe <SystemMessage.SystemInit>(_externalHttpService);
_mainBus.Subscribe <SystemMessage.BecomeShuttingDown>(_externalHttpService);
_mainBus.Subscribe <HttpMessage.PurgeTimedOutRequests>(_externalHttpService);
// INTERNAL HTTP
if (!isSingleNode)
{
_internalHttpService = new HttpService(ServiceAccessibility.Private, _mainQueue, new TrieUriRouter(),
_workersHandler, vNodeSettings.LogHttpRequests, vNodeSettings.GossipAdvertiseInfo.AdvertiseInternalIPAs,
vNodeSettings.GossipAdvertiseInfo.AdvertiseInternalHttpPortAs, vNodeSettings.IntHttpPrefixes);
_internalHttpService.SetupController(adminController);
_internalHttpService.SetupController(pingController);
_internalHttpService.SetupController(infoController);
_internalHttpService.SetupController(statController);
_internalHttpService.SetupController(atomController);
_internalHttpService.SetupController(gossipController);
_internalHttpService.SetupController(electController);
_internalHttpService.SetupController(histogramController);
_internalHttpService.SetupController(persistentSubscriptionController);
}
// Authentication plugin HTTP
vNodeSettings.AuthenticationProviderFactory.RegisterHttpControllers(_externalHttpService, _internalHttpService, httpSendService, _mainQueue, _workersHandler);
if (_internalHttpService != null)
{
_mainBus.Subscribe <SystemMessage.SystemInit>(_internalHttpService);
_mainBus.Subscribe <SystemMessage.BecomeShuttingDown>(_internalHttpService);
_mainBus.Subscribe <HttpMessage.PurgeTimedOutRequests>(_internalHttpService);
}
SubscribeWorkers(bus =>
{
HttpService.CreateAndSubscribePipeline(bus, httpAuthenticationProviders.ToArray());
});
// REQUEST FORWARDING
var forwardingService = new RequestForwardingService(_mainQueue, forwardingProxy, TimeSpan.FromSeconds(1));
_mainBus.Subscribe <SystemMessage.SystemStart>(forwardingService);
_mainBus.Subscribe <SystemMessage.RequestForwardingTimerTick>(forwardingService);
_mainBus.Subscribe <ClientMessage.NotHandled>(forwardingService);
_mainBus.Subscribe <ClientMessage.WriteEventsCompleted>(forwardingService);
_mainBus.Subscribe <ClientMessage.TransactionStartCompleted>(forwardingService);
_mainBus.Subscribe <ClientMessage.TransactionWriteCompleted>(forwardingService);
_mainBus.Subscribe <ClientMessage.TransactionCommitCompleted>(forwardingService);
_mainBus.Subscribe <ClientMessage.DeleteStreamCompleted>(forwardingService);
// REQUEST MANAGEMENT
var requestManagement = new RequestManagementService(_mainQueue,
vNodeSettings.PrepareAckCount,
vNodeSettings.PrepareTimeout,
vNodeSettings.CommitTimeout,
vNodeSettings.BetterOrdering);
_mainBus.Subscribe <SystemMessage.SystemInit>(requestManagement);
_mainBus.Subscribe <ClientMessage.WriteEvents>(requestManagement);
_mainBus.Subscribe <ClientMessage.TransactionStart>(requestManagement);
_mainBus.Subscribe <ClientMessage.TransactionWrite>(requestManagement);
_mainBus.Subscribe <ClientMessage.TransactionCommit>(requestManagement);
_mainBus.Subscribe <ClientMessage.DeleteStream>(requestManagement);
_mainBus.Subscribe <StorageMessage.RequestCompleted>(requestManagement);
_mainBus.Subscribe <StorageMessage.CheckStreamAccessCompleted>(requestManagement);
_mainBus.Subscribe <StorageMessage.AlreadyCommitted>(requestManagement);
_mainBus.Subscribe <StorageMessage.CommitReplicated>(requestManagement);
_mainBus.Subscribe <StorageMessage.PrepareAck>(requestManagement);
_mainBus.Subscribe <StorageMessage.WrongExpectedVersion>(requestManagement);
_mainBus.Subscribe <StorageMessage.InvalidTransaction>(requestManagement);
_mainBus.Subscribe <StorageMessage.StreamDeleted>(requestManagement);
_mainBus.Subscribe <StorageMessage.RequestManagerTimerTick>(requestManagement);
// SUBSCRIPTIONS
var subscrBus = new InMemoryBus("SubscriptionsBus", true, TimeSpan.FromMilliseconds(50));
var subscrQueue = new QueuedHandlerThreadPool(subscrBus, "Subscriptions", false);
_mainBus.Subscribe(subscrQueue.WidenFrom <SystemMessage.SystemStart, Message>());
_mainBus.Subscribe(subscrQueue.WidenFrom <SystemMessage.BecomeShuttingDown, Message>());
_mainBus.Subscribe(subscrQueue.WidenFrom <TcpMessage.ConnectionClosed, Message>());
_mainBus.Subscribe(subscrQueue.WidenFrom <ClientMessage.SubscribeToStream, Message>());
_mainBus.Subscribe(subscrQueue.WidenFrom <ClientMessage.UnsubscribeFromStream, Message>());
_mainBus.Subscribe(subscrQueue.WidenFrom <SubscriptionMessage.PollStream, Message>());
_mainBus.Subscribe(subscrQueue.WidenFrom <SubscriptionMessage.CheckPollTimeout, Message>());
_mainBus.Subscribe(subscrQueue.WidenFrom <StorageMessage.EventCommitted, Message>());
var subscription = new SubscriptionsService(_mainQueue, subscrQueue, readIndex);
subscrBus.Subscribe <SystemMessage.SystemStart>(subscription);
subscrBus.Subscribe <SystemMessage.BecomeShuttingDown>(subscription);
subscrBus.Subscribe <TcpMessage.ConnectionClosed>(subscription);
subscrBus.Subscribe <ClientMessage.SubscribeToStream>(subscription);
subscrBus.Subscribe <ClientMessage.UnsubscribeFromStream>(subscription);
subscrBus.Subscribe <SubscriptionMessage.PollStream>(subscription);
subscrBus.Subscribe <SubscriptionMessage.CheckPollTimeout>(subscription);
subscrBus.Subscribe <StorageMessage.EventCommitted>(subscription);
// PERSISTENT SUBSCRIPTIONS
// IO DISPATCHER
var ioDispatcher = new IODispatcher(_mainQueue, new PublishEnvelope(_mainQueue));
_mainBus.Subscribe <ClientMessage.ReadStreamEventsBackwardCompleted>(ioDispatcher.BackwardReader);
_mainBus.Subscribe <ClientMessage.WriteEventsCompleted>(ioDispatcher.Writer);
_mainBus.Subscribe <ClientMessage.ReadStreamEventsForwardCompleted>(ioDispatcher.ForwardReader);
_mainBus.Subscribe <ClientMessage.DeleteStreamCompleted>(ioDispatcher.StreamDeleter);
_mainBus.Subscribe(ioDispatcher);
var perSubscrBus = new InMemoryBus("PersistentSubscriptionsBus", true, TimeSpan.FromMilliseconds(50));
var perSubscrQueue = new QueuedHandlerThreadPool(perSubscrBus, "PersistentSubscriptions", false);
_mainBus.Subscribe(perSubscrQueue.WidenFrom <SystemMessage.StateChangeMessage, Message>());
_mainBus.Subscribe(perSubscrQueue.WidenFrom <TcpMessage.ConnectionClosed, Message>());
_mainBus.Subscribe(perSubscrQueue.WidenFrom <ClientMessage.CreatePersistentSubscription, Message>());
_mainBus.Subscribe(perSubscrQueue.WidenFrom <ClientMessage.UpdatePersistentSubscription, Message>());
_mainBus.Subscribe(perSubscrQueue.WidenFrom <ClientMessage.DeletePersistentSubscription, Message>());
_mainBus.Subscribe(perSubscrQueue.WidenFrom <ClientMessage.ConnectToPersistentSubscription, Message>());
_mainBus.Subscribe(perSubscrQueue.WidenFrom <ClientMessage.UnsubscribeFromStream, Message>());
_mainBus.Subscribe(perSubscrQueue.WidenFrom <ClientMessage.PersistentSubscriptionAckEvents, Message>());
_mainBus.Subscribe(perSubscrQueue.WidenFrom <ClientMessage.PersistentSubscriptionNackEvents, Message>());
_mainBus.Subscribe(perSubscrQueue.WidenFrom <ClientMessage.ReplayAllParkedMessages, Message>());
_mainBus.Subscribe(perSubscrQueue.WidenFrom <ClientMessage.ReplayParkedMessage, Message>());
_mainBus.Subscribe(perSubscrQueue.WidenFrom <ClientMessage.ReadNextNPersistentMessages, Message>());
_mainBus.Subscribe(perSubscrQueue.WidenFrom <StorageMessage.EventCommitted, Message>());
_mainBus.Subscribe(perSubscrQueue.WidenFrom <MonitoringMessage.GetAllPersistentSubscriptionStats, Message>());
_mainBus.Subscribe(perSubscrQueue.WidenFrom <MonitoringMessage.GetStreamPersistentSubscriptionStats, Message>());
_mainBus.Subscribe(perSubscrQueue.WidenFrom <MonitoringMessage.GetPersistentSubscriptionStats, Message>());
_mainBus.Subscribe(perSubscrQueue.WidenFrom <SubscriptionMessage.PersistentSubscriptionTimerTick, Message>());
//TODO CC can have multiple threads working on subscription if partition
var consumerStrategyRegistry = new PersistentSubscriptionConsumerStrategyRegistry(_mainQueue, _mainBus, vNodeSettings.AdditionalConsumerStrategies);
var persistentSubscription = new PersistentSubscriptionService(subscrQueue, readIndex, ioDispatcher, _mainQueue, consumerStrategyRegistry);
perSubscrBus.Subscribe <SystemMessage.BecomeShuttingDown>(persistentSubscription);
perSubscrBus.Subscribe <SystemMessage.BecomeMaster>(persistentSubscription);
perSubscrBus.Subscribe <SystemMessage.StateChangeMessage>(persistentSubscription);
perSubscrBus.Subscribe <TcpMessage.ConnectionClosed>(persistentSubscription);
perSubscrBus.Subscribe <ClientMessage.ConnectToPersistentSubscription>(persistentSubscription);
perSubscrBus.Subscribe <ClientMessage.UnsubscribeFromStream>(persistentSubscription);
perSubscrBus.Subscribe <ClientMessage.PersistentSubscriptionAckEvents>(persistentSubscription);
perSubscrBus.Subscribe <ClientMessage.PersistentSubscriptionNackEvents>(persistentSubscription);
perSubscrBus.Subscribe <StorageMessage.EventCommitted>(persistentSubscription);
perSubscrBus.Subscribe <ClientMessage.DeletePersistentSubscription>(persistentSubscription);
perSubscrBus.Subscribe <ClientMessage.CreatePersistentSubscription>(persistentSubscription);
perSubscrBus.Subscribe <ClientMessage.UpdatePersistentSubscription>(persistentSubscription);
perSubscrBus.Subscribe <ClientMessage.ReplayAllParkedMessages>(persistentSubscription);
perSubscrBus.Subscribe <ClientMessage.ReplayParkedMessage>(persistentSubscription);
perSubscrBus.Subscribe <ClientMessage.ReadNextNPersistentMessages>(persistentSubscription);
perSubscrBus.Subscribe <MonitoringMessage.GetAllPersistentSubscriptionStats>(persistentSubscription);
perSubscrBus.Subscribe <MonitoringMessage.GetStreamPersistentSubscriptionStats>(persistentSubscription);
perSubscrBus.Subscribe <MonitoringMessage.GetPersistentSubscriptionStats>(persistentSubscription);
perSubscrBus.Subscribe <SubscriptionMessage.PersistentSubscriptionTimerTick>(persistentSubscription);
// STORAGE SCAVENGER
var storageScavenger = new StorageScavenger(db,
ioDispatcher,
tableIndex,
readIndex,
vNodeSettings.AlwaysKeepScavenged,
_nodeInfo.ExternalHttp.ToString(),
!vNodeSettings.DisableScavengeMerging,
vNodeSettings.ScavengeHistoryMaxAge,
unsafeIgnoreHardDeletes: vNodeSettings.UnsafeIgnoreHardDeletes);
// ReSharper disable RedundantTypeArgumentsOfMethod
_mainBus.Subscribe <ClientMessage.ScavengeDatabase>(storageScavenger);
_mainBus.Subscribe <UserManagementMessage.UserManagementServiceInitialized>(storageScavenger);
// ReSharper restore RedundantTypeArgumentsOfMethod
// TIMER
_timeProvider = new RealTimeProvider();
_timerService = new TimerService(new ThreadBasedScheduler(_timeProvider));
_mainBus.Subscribe <SystemMessage.BecomeShutdown>(_timerService);
_mainBus.Subscribe <TimerMessage.Schedule>(_timerService);
var gossipInfo = new VNodeInfo(_nodeInfo.InstanceId, _nodeInfo.DebugIndex,
vNodeSettings.GossipAdvertiseInfo.InternalTcp,
vNodeSettings.GossipAdvertiseInfo.InternalSecureTcp,
vNodeSettings.GossipAdvertiseInfo.ExternalTcp,
vNodeSettings.GossipAdvertiseInfo.ExternalSecureTcp,
vNodeSettings.GossipAdvertiseInfo.InternalHttp,
vNodeSettings.GossipAdvertiseInfo.ExternalHttp);
if (!isSingleNode)
{
// MASTER REPLICATION
var masterReplicationService = new MasterReplicationService(_mainQueue, gossipInfo.InstanceId, db, _workersHandler,
epochManager, vNodeSettings.ClusterNodeCount);
_mainBus.Subscribe <SystemMessage.SystemStart>(masterReplicationService);
_mainBus.Subscribe <SystemMessage.StateChangeMessage>(masterReplicationService);
_mainBus.Subscribe <ReplicationMessage.ReplicaSubscriptionRequest>(masterReplicationService);
_mainBus.Subscribe <ReplicationMessage.ReplicaLogPositionAck>(masterReplicationService);
monitoringInnerBus.Subscribe <ReplicationMessage.GetReplicationStats>(masterReplicationService);
// REPLICA REPLICATION
var replicaService = new ReplicaService(_mainQueue, db, epochManager, _workersHandler, _internalAuthenticationProvider,
gossipInfo, vNodeSettings.UseSsl, vNodeSettings.SslTargetHost, vNodeSettings.SslValidateServer,
vNodeSettings.IntTcpHeartbeatTimeout, vNodeSettings.ExtTcpHeartbeatInterval);
_mainBus.Subscribe <SystemMessage.StateChangeMessage>(replicaService);
_mainBus.Subscribe <ReplicationMessage.ReconnectToMaster>(replicaService);
_mainBus.Subscribe <ReplicationMessage.SubscribeToMaster>(replicaService);
_mainBus.Subscribe <ReplicationMessage.AckLogPosition>(replicaService);
_mainBus.Subscribe <StorageMessage.PrepareAck>(replicaService);
_mainBus.Subscribe <StorageMessage.CommitAck>(replicaService);
_mainBus.Subscribe <ClientMessage.TcpForwardMessage>(replicaService);
}
// ELECTIONS
var electionsService = new ElectionsService(_mainQueue, gossipInfo, vNodeSettings.ClusterNodeCount,
db.Config.WriterCheckpoint, db.Config.ChaserCheckpoint,
epochManager, () => readIndex.LastCommitPosition, vNodeSettings.NodePriority);
electionsService.SubscribeMessages(_mainBus);
if (!isSingleNode || vNodeSettings.GossipOnSingleNode)
{
// GOSSIP
var gossip = new NodeGossipService(_mainQueue, gossipSeedSource, gossipInfo, db.Config.WriterCheckpoint,
db.Config.ChaserCheckpoint, epochManager, () => readIndex.LastCommitPosition,
vNodeSettings.NodePriority, vNodeSettings.GossipInterval, vNodeSettings.GossipAllowedTimeDifference);
_mainBus.Subscribe <SystemMessage.SystemInit>(gossip);
_mainBus.Subscribe <GossipMessage.RetrieveGossipSeedSources>(gossip);
_mainBus.Subscribe <GossipMessage.GotGossipSeedSources>(gossip);
_mainBus.Subscribe <GossipMessage.Gossip>(gossip);
_mainBus.Subscribe <GossipMessage.GossipReceived>(gossip);
_mainBus.Subscribe <SystemMessage.StateChangeMessage>(gossip);
_mainBus.Subscribe <GossipMessage.GossipSendFailed>(gossip);
_mainBus.Subscribe <SystemMessage.VNodeConnectionEstablished>(gossip);
_mainBus.Subscribe <SystemMessage.VNodeConnectionLost>(gossip);
}
_workersHandler.Start();
_mainQueue.Start();
monitoringQueue.Start();
subscrQueue.Start();
if (subsystems != null)
{
foreach (var subsystem in subsystems)
{
var http = isSingleNode ? new [] { _externalHttpService } : new [] { _internalHttpService, _externalHttpService };
subsystem.Register(new StandardComponents(db, _mainQueue, _mainBus, _timerService, _timeProvider, httpSendService, http, _workersHandler));
}
}
}
public TestableLiveTradingDataFeed(IDataQueueHandler dataQueueHandler, ITimeProvider timeProvider = null)
{
_dataQueueHandler = dataQueueHandler;
_timeProvider = timeProvider ?? new RealTimeProvider();
}
public CandidateSkillsProvider(IReferenceDataReader referenceDataReader, ILogger <CandidateSkillsProvider> logger, ICache cache, ITimeProvider timeProvider)
{
_referenceDataReader = referenceDataReader;
_logger = logger;
_cache = cache;
_timeProvider = timeProvider;
}
public TestDataQueueUniverseProvider(ITimeProvider timeProvider)
{
_timeProvider = timeProvider;
}
/// <summary>
/// Resets to the default provider.
/// </summary>
public static void ResetToDefault()
{
TimeService.current = new DefaultTimeProvider();
}
/// <summary>
/// コンストラクタ
/// </summary>
/// <param name="logger">ロガー</param>
/// <param name="timePrivder">DateTimeの提供元</param>
/// <param name="dbPolly">DB接続用のPolly</param>
/// <param name="appSettings">アプリケーション設定</param>
public DtDeliveryResultRepository(ILogger <DtDeliveryResultRepository> logger, ITimeProvider timePrivder, DBPolly dbPolly, AppSettings appSettings)
{
Assert.IfNull(logger);
Assert.IfNull(timePrivder);
Assert.IfNull(dbPolly);
Assert.IfNull(appSettings);
_logger = logger;
_timePrivder = timePrivder;
_dbPolly = dbPolly;
_appSettings = appSettings;
}
/// <summary>
/// Returns the same client with a modified TimeProvider to make it unit-testable
/// This is not intended to be used in production code, if you find a valid usecase
/// for it outside of unit testing, please open an issue so we can integrate it properly.
/// As such, changes to this method will happen without any notice.
/// </summary>
/// <param name="customTimeProvider"></param>
/// <returns>A client with a custom <see cref=ITimeProvider/></returns>
internal Client AsTestable(ITimeProvider customTimeProvider)
{
_timeProvider = customTimeProvider;
return(this);
}
public ExpandingLinkBoxContentfulfactory(IContentfulFactory <ContentfulReference, SubItem> subitemFactory, ITimeProvider timeProvider)
{
_subitemFactory = subitemFactory;
_dateComparer = new DateComparer(timeProvider);
}
public FileRenamer(string urn, ITimeProvider timeProvider, ILogging logging) : base(urn, Type, timeProvider, logging)
{
}
/// <summary>
/// Initializes the data feed for the specified job and algorithm
/// </summary>
public void Initialize(IAlgorithm algorithm, AlgorithmNodePacket job, IResultHandler resultHandler, IMapFileProvider mapFileProvider, IFactorFileProvider factorFileProvider)
{
if (!(job is LiveNodePacket))
{
throw new ArgumentException("The LiveTradingDataFeed requires a LiveNodePacket.");
}
_cancellationTokenSource = new CancellationTokenSource();
_algorithm = algorithm;
_job = (LiveNodePacket)job;
_resultHandler = resultHandler;
_timeProvider = GetTimeProvider();
_dataQueueHandler = GetDataQueueHandler();
_frontierTimeProvider = new ManualTimeProvider(_timeProvider.GetUtcNow());
_customExchange = new BaseDataExchange("CustomDataExchange")
{
SleepInterval = 10
};
// sleep is controlled on this exchange via the GetNextTicksEnumerator
_exchange = new BaseDataExchange("DataQueueExchange")
{
SleepInterval = 0
};
_exchange.AddEnumerator(DataQueueHandlerSymbol, GetNextTicksEnumerator());
_subscriptions = new ConcurrentDictionary <Symbol, Subscription>();
_bridge = new BusyBlockingCollection <TimeSlice>();
_universeSelection = new UniverseSelection(this, algorithm, job.Controls);
// run the exchanges
Task.Run(() => _exchange.Start(_cancellationTokenSource.Token));
Task.Run(() => _customExchange.Start(_cancellationTokenSource.Token));
// this value will be modified via calls to AddSubscription/RemoveSubscription
var ffres = Time.OneSecond;
_fillForwardResolution = Ref.Create(() => ffres, v => ffres = v);
ffres = ResolveFillForwardResolution(algorithm);
// wire ourselves up to receive notifications when universes are added/removed
var start = _timeProvider.GetUtcNow();
algorithm.UniverseManager.CollectionChanged += (sender, args) =>
{
switch (args.Action)
{
case NotifyCollectionChangedAction.Add:
foreach (var universe in args.NewItems.OfType <Universe>())
{
_subscriptions[universe.Configuration.Symbol] = CreateUniverseSubscription(universe, start, Time.EndOfTime);
}
break;
case NotifyCollectionChangedAction.Remove:
foreach (var universe in args.OldItems.OfType <Universe>())
{
Subscription subscription;
if (_subscriptions.TryGetValue(universe.Configuration.Symbol, out subscription))
{
RemoveSubscription(subscription);
}
}
break;
default:
throw new NotImplementedException("The specified action is not implemented: " + args.Action);
}
};
}
/// <summary>
/// Initializes a new instance of the <see cref="TimestampProvider" /> class.
/// </summary>
/// <param name="provider">The provider.</param>
public TimestampProvider(ITimeProvider provider)
{
_provider = provider;
}
/// <summary>
/// Create a new instance
/// </summary>
public BaseRedisAlgorithm(IEnumerable <RateLimitRule> rules, ConnectionMultiplexer redisClient = null, ITimeProvider timeProvider = null, bool updatable = false)
: base(rules, timeProvider, updatable)
{
_redisClient = redisClient;
if (_redisClient == null)
{
_redisClient = ConnectionMultiplexer.Connect("127.0.0.1");
}
}
