private void OnTick()
        {
            for (int i = 0; i < m_taskRunners.Length; ++i)
            {
                ITaskRunner taskRunner = m_taskRunners[i];
                if (taskRunner != null)
                {
                    taskRunner.Tick();
                }
            }

            for (int i = 0; i < m_pathFinders.Length; ++i)
            {
                IPathFinder pathFinder = m_pathFinders[i];
                if (pathFinder != null)
                {
                    pathFinder.Tick();
                }
            }

            for (int i = 0; i < m_taskEngines.Length; ++i)
            {
                ITaskEngine taskEngine = m_taskEngines[i];
                if (taskEngine != null)
                {
                    taskEngine.Tick();
                }
            }
        }
Example #2
0
        public ConditionGroupsEditorViewModel(Func <IHistoryManager> historyCreator, IConditionDataProvider conditionDataProvider, IWindowManager windowManager,
                                              IMessageBoxService messageBoxService, ITaskRunner taskRunner)
        {
            this.conditionDataProvider = conditionDataProvider;
            this.windowManager         = windowManager;
            this.messageBoxService     = messageBoxService;

            SourceItems = new ObservableCollection <ConditionGroupsEditorData>();

            foreach (var item in conditionDataProvider.GetConditionGroups())
            {
                SourceItems.Add(new ConditionGroupsEditorData(in item));
            }

            Save = new DelegateCommand(() =>
            {
                taskRunner.ScheduleTask("Saving condition groups", SaveGroupsToFile);
            }, () => IsModified);
            AddGroup   = new AsyncCommand(AddGroupToSource);
            DeleteItem = new DelegateCommand <object>(DeleteItemFromSource);
            AddMember  = new AsyncCommand <ConditionGroupsEditorData>(AddItemToGroup);
            EditItem   = new AsyncCommand <ConditionGroupsEditorData>(EditSourceItem);
            // history setup
            historyHandler           = new ConditionGroupsEditorHistoryHandler(SourceItems !);
            History                  = historyCreator();
            undoCommand              = new DelegateCommand(History.Undo, () => History.CanUndo);
            redoCommand              = new DelegateCommand(History.Redo, () => History.CanRedo);
            History.PropertyChanged += (sender, args) =>
            {
                undoCommand.RaiseCanExecuteChanged();
                redoCommand.RaiseCanExecuteChanged();
                IsModified = !History.IsSaved;
            };
            History.AddHandler(historyHandler);
        }
 public CurrentMachineStateManager(IPerformanceManager performanceManager, IComponentProperties machineInfo,
                                   ITaskRunner <TJob> localBallancer)
 {
     this.performanceManager = performanceManager;
     this.machineInfo        = machineInfo;
     this.localBallancer     = localBallancer;
 }
Example #4
0
        protected BaseCallbackStore(IStoreProvider storeProvider, ITaskRunner taskRunner, ILogProvider logProvider, CancellationToken token)
        {
            Assert.IsNotNull(storeProvider, "Store Provider can't be null");
            Assert.IsNotNull(taskRunner, "Task Runner can't be null");
            Assert.IsNotNull(logProvider, "Log Provider can't be null");

            this.singleAccessLock = new SemaphoreSlim(1);
            this.callbackMap      = new Dictionary <NotifyFilter, IList <Func <ScenarioData, Task> > >();
            this.Logger           = logProvider.CreateLoggerInstance(this.GetType().ToString().Split('.').Last());
            this.taskRunner       = taskRunner;

            this.InternalTokenSource = CancellationTokenSource.CreateLinkedTokenSource(token);
            token = this.InternalTokenSource.Token;

            // Some signals may not show up immedietly so we don't want their last seen time bailing on us.
            this.callBackCheckPointTimeStore = storeProvider.CreatePersistentStoreForTimeAsync(CallbackTimeBookmarkStore, AgeBasedRetentionPolicy.OneDay, token)
                                               .GetAwaiter().GetResult();

            // This store keeps track of unique Ids of signals seen to avoid duplicate reporting. The entries in this
            // collection needs to be long lived. Consider a signal that is living in the system for a long time
            // If we don't track that this has been reported, we may try to report it again.
            this.reportedSignalsUniqueIdsStore = storeProvider
                                                 .CreatePersistentStoreKeyGuidValueStringAsync(ReportedSignalUniqueIdsStoreName, AgeBasedRetentionPolicy.OneWeek, token).GetAwaiter()
                                                 .GetResult();

            this.signalsInDispatchQueuePersistentStore = storeProvider
                                                         .CreatePersistentStoreKeyGuidValueStringAsync(SignalsInDispatchQueueStoreName, AgeBasedRetentionPolicy.OneHour, token).GetAwaiter().GetResult();

            this.producerConsumerBufferBlock = new BufferBlock <ScenarioNotificationData>();
            this.InitSignalSeenBookmarkStoreAsync(token).Wait(token);
        }
Example #5
0
        public async Task <List <TaskRunnerInformation> > FindTasks(
            IWorkspaceFileObject workspaceFileObject,
            HashSet <FilePath> filesAdded)
        {
            List <TaskRunnerInformation> foundTasks = null;

            foreach (FilePath configFile in GetFiles(workspaceFileObject))
            {
                if (!filesAdded.Contains(configFile))
                {
                    ITaskRunner runner = taskRunnerProvider.GetTaskRunner(configFile);
                    if (runner != null)
                    {
                        ITaskRunnerConfig config = await runner.ParseConfig(null, configFile);

                        var info = new TaskRunnerInformation(workspaceFileObject, config, runner.Options, configFile);
                        if (foundTasks == null)
                        {
                            foundTasks = new List <TaskRunnerInformation> ();
                        }
                        foundTasks.Add(info);
                        filesAdded.Add(configFile);
                    }
                }
            }

            return(foundTasks);
        }
Example #6
0
        public void Execute(ITaskRunner taskRunner)
        {
            ProductFile file = taskRunner.GetProductFile(GeneratePreviewPolishFileTask.PolishPreviewFile);

            if (file == null)
            {
                consoleLogger.WriteLine(log, Level.Warn, "WARNING: there is no polish preview file to process, preview file will not be generated");
                return;
            }

            taskRunner.RunCPreview(
                "\"{0}\"",
                file.ProductFileName);

            string previewIntermediateFile = Path.GetFullPath(
                Path.Combine(
                    taskRunner.MapMakerSettings.TempDir,
                    String.Format(
                        CultureInfo.InvariantCulture,
                        "{0}.mp",
                        taskRunner.MapMakerSettings.ProductCode)));

            taskRunner.RunCGpsMapper(
                "\"{0}\"",
                previewIntermediateFile);

            taskRunner.RegisterProductFile(new ProductFile(PreviewImgFile, Path.ChangeExtension(previewIntermediateFile, ".img"), false));
            taskRunner.RegisterProductFile(new ProductFile(TdbFile, Path.ChangeExtension(previewIntermediateFile, ".tdb"), false));
        }
Example #7
0
        /// <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>
        private void Dispose(bool disposing)
        {
            if (m_Disposed)
            {
                return;
            }

            if (disposing)
            {
                try
                {
                    if (TaskRunners != null)
                    {
                        for (int i = 0; i < TaskRunners.Count; i++)
                        {
                            ITaskRunner taskRunner = TaskRunners[i];
                            taskRunner.Dispose();
                        }
                    }
                }
                finally
                {
                    m_IsRunning = false;
                    m_Disposed  = true;
                }
            }
        }
        public DbcStore(IParameterFactory parameterFactory,
                        ITaskRunner taskRunner,
                        IDbcSettingsProvider settingsProvider,
                        IMessageBoxService messageBoxService,
                        IEventAggregator eventAggregator,
                        ICurrentCoreVersion currentCoreVersion,
                        NullSpellService nullSpellService,
                        CataSpellService cataSpellService,
                        WrathSpellService wrathSpellService,
                        DBCD.DBCD dbcd)
        {
            this.parameterFactory   = parameterFactory;
            this.taskRunner         = taskRunner;
            dbcSettingsProvider     = settingsProvider;
            this.messageBoxService  = messageBoxService;
            this.eventAggregator    = eventAggregator;
            this.currentCoreVersion = currentCoreVersion;
            this.nullSpellService   = nullSpellService;
            this.cataSpellService   = cataSpellService;
            this.wrathSpellService  = wrathSpellService;
            this.dbcd = dbcd;

            spellServiceImpl = nullSpellService;
            Load();
        }
        public void GuidIndexer_IsNotExisting_ReturnNull()
        {
            runners.AddRange(new TaskRunner("Test1", () => { }));
            ITaskRunner taskRunner = runners[Guid.Empty];

            taskRunner.Should().BeNull();
        }
Example #10
0
        /// <summary>
        /// </summary>
        /// <param name="runtime"></param>
        /// <param name="token"></param>
        protected BaseCallbackStore(IInsightRuntime runtime, CancellationToken token)
        {
            this.singleAccessLock = new SemaphoreSlim(1);
            this.callbackMap      = new Dictionary <NotifyFilter, IList <Func <ScenarioData, Task> > >();
            this.Runtime          = runtime;
            string typeName = this.GetType().ToString();

            this.Logger     = this.Runtime.GetLogProvider().CreateLoggerInstance(typeName.Split('.').Last());
            this.taskRunner = runtime.TaskRunner;

            this.InternalTokenSource = CancellationTokenSource.CreateLinkedTokenSource(token);
            token = this.InternalTokenSource.Token;

            this.Query = this.Runtime.GetService(typeof(IClusterQuery)) as IClusterQuery;
            Assert.IsNotNull(this.Query, "Runtime doesn't contain valid Cluster Query object");

            // Some signals may not show up immedietly so we don't want their last seen time bailing on us.
            this.signalSeenTillThisTimeStore = this.Runtime.GetStoreProvider()
                                               .CreatePersistentStoreForTimeAsync(SignalSeenTillTimeStoreName, AgeBasedRetentionPolicy.TwoWeek, token).GetAwaiter().GetResult();

            // This store keeps track of unique Ids of signals seen to avoid duplicate reporting. The entries in this
            // collection needs to be long lived. Consider a signal that is living in the system for a long time
            // If we don't track that this has been reported, we may try to report it again.
            this.reportedSignalsUniqueIdsStore = this.Runtime.GetStoreProvider()
                                                 .CreatePersistentStoreForIntAsync(ReportedSignalUniqueIdsStoreName, AgeBasedRetentionPolicy.OneWeek, token).GetAwaiter().GetResult();

            this.signalsInDispatchQueuePersistentStore = this.Runtime.GetStoreProvider()
                                                         .CreatePersistentStoreForStringsAsync(SignalsInDispatchQueueStoreName, AgeBasedRetentionPolicy.OneHour, token).GetAwaiter().GetResult();

            this.producerConsumerBufferBlock = new BufferBlock <ScenarioNotificationData>();
            this.InitSignalSeenBookmarkStoreAsync(token).Wait(token);
        }
Example #11
0
 private SqlEditorViewModel(IMySqlExecutor mySqlExecutor,
                            IStatusBar statusBar,
                            IDatabaseProvider databaseProvider,
                            ITaskRunner taskRunner,
                            INativeTextDocument sql)
 {
     Code       = sql;
     ExecuteSql = new DelegateCommand(() =>
     {
         taskRunner.ScheduleTask("Executing query",
                                 async() =>
         {
             statusBar.PublishNotification(new PlainNotification(NotificationType.Info, "Executing query"));
             try
             {
                 await mySqlExecutor.ExecuteSql(Code.ToString());
                 statusBar.PublishNotification(new PlainNotification(NotificationType.Success, "Query executed"));
             }
             catch (Exception e)
             {
                 statusBar.PublishNotification(new PlainNotification(NotificationType.Error, "Failure during query execution"));
                 Console.WriteLine(e);
             }
         });
     }, () => databaseProvider.IsConnected);
     IsLoading = false;
     Save      = new DelegateCommand(() =>
     {
         ExecuteSql.Execute(null);
     });
 }
Example #12
0
 public InjectionConfigurationViewModelFactory(
     DomainActionBuilder actionBuilder,
     ComponentViewModelFactory componentViewModelFactory,
     IFindFirstLaunchTimeQuery findFirstLaunchTimeQuery,
     IFindGamePackageByIdQuery findGamePackageByIdQuery,
     IFindGamesQuery findGamesQuery,
     IFindLastEditedGamePackageQuery findLastEditedGamePackageQuery,
     IDirectoryPicker directoryPicker,
     IEqualityComparer <ProxySettings> stateEqualityComparer,
     IEventPublisher eventPublisher,
     IFilePicker filePicker,
     IPluginFactory pluginFactory,
     INavigationService navigationService,
     ITaskRunner runner)
 {
     _actionBuilder                  = actionBuilder;
     _componentViewModelFactory      = componentViewModelFactory;
     _findFirstLaunchTimeQuery       = findFirstLaunchTimeQuery;
     _findGamePackageByIdQuery       = findGamePackageByIdQuery;
     _findGamesQuery                 = findGamesQuery;
     _findLastEditedGamePackageQuery = findLastEditedGamePackageQuery;
     _directoryPicker                = directoryPicker;
     _stateEqualityComparer          = stateEqualityComparer;
     _eventPublisher                 = eventPublisher;
     _filePicker        = filePicker;
     _pluginFactory     = pluginFactory;
     _navigationService = navigationService;
     _runner            = runner;
 }
Example #13
0
        public ConditionsDefinitionEditorViewModel(Func <IHistoryManager> historyCreator, IConditionDataProvider conditionDataProvider, IWindowManager windowManager,
                                                   ITaskRunner taskRunner, IParameterFactory parameterFactory)
        {
            this.conditionDataProvider = conditionDataProvider;
            SourceItems           = new ObservableCollection <ConditionJsonData>(conditionDataProvider.GetConditions().ToList());
            this.windowManager    = windowManager;
            this.parameterFactory = parameterFactory;
            SelectedIndex         = -1;

            Save = new DelegateCommand(() =>
            {
                taskRunner.ScheduleTask("Saving conditions definition list", SaveConditions);
            }, () => IsModified);
            Delete   = new DelegateCommand(DeleteItem);
            AddItem  = new AsyncCommand(AddNewItem);
            EditItem = new AsyncCommand <ConditionJsonData?>(EditCondition);
            // history setup
            historyHandler           = new ConditionsEditorHistoryHandler(SourceItems);
            History                  = historyCreator();
            undoCommand              = new DelegateCommand(History.Undo, () => History.CanUndo);
            redoCommand              = new DelegateCommand(History.Redo, () => History.CanRedo);
            History.PropertyChanged += (sender, args) =>
            {
                undoCommand.RaiseCanExecuteChanged();
                redoCommand.RaiseCanExecuteChanged();
                IsModified = !History.IsSaved;
            };
            History.AddHandler(historyHandler);
        }
Example #14
0
        public Host(IBusConfig busConfig, ITaskRunner taskRunner)
        {
            this.busConfig  = busConfig ?? throw new ArgumentNullException(nameof(busConfig));
            this.taskRunner = taskRunner ?? throw new ArgumentNullException(nameof(taskRunner));

            ConfigureLogging();
        }
 public Synchronizer(ITaskRunner taskRunner, IPlanetRunner planetRunner, IMotherRunner motherRunner, IServiceProvider svp)
 {
     _svp          = svp;
     _taskRunner   = taskRunner;
     _planetRunner = planetRunner;
     _motherRunner = motherRunner;
 }
        private void Update()
        {
            for (int i = 0; i < m_taskRunners.Length; ++i)
            {
                ITaskRunner taskRunner = m_taskRunners[i];
                if (taskRunner != null)
                {
                    taskRunner.Update();
                }
            }

            for (int i = 0; i < m_pathFinders.Length; ++i)
            {
                IPathFinder pathFinder = m_pathFinders[i];
                if (pathFinder != null)
                {
                    pathFinder.Update();
                }
            }

            if (m_bots != null)
            {
                for (int i = 0; i < m_bots.Length; ++i)
                {
                    IBotController bot = m_bots[i];
                    if (bot != null)
                    {
                        bot.Update(Time.realtimeSinceStartup);
                    }
                }
            }
        }
 private static RetryingTaskRunner SutFactoryWithNext(ITaskRunner next)
 {
     return(SutFactory(
                next,
                0,
                TimeSpan.Zero));
 }
Example #18
0
File: Bus.cs Project: Zapote/EzBus
 public Bus(IBroker broker, ITaskRunner taskRunner, ISubscriptionManager subscriptionManager, ILogger <Bus> logger)
 {
     this.broker              = broker ?? throw new ArgumentNullException(nameof(broker));
     this.taskRunner          = taskRunner ?? throw new ArgumentNullException(nameof(taskRunner));
     this.subscriptionManager = subscriptionManager ?? throw new ArgumentNullException(nameof(subscriptionManager));
     this.logger              = logger ?? throw new ArgumentNullException(nameof(logger));
 }
        public SmartDataEditorsProvider(ISmartRawDataProvider smartDataProvider, IParameterFactory parameterFactory, ISmartDataManager smartDataManager,
                                        ITaskRunner taskRunner, IMessageBoxService messageBoxService, IWindowManager windowManager, Func <IHistoryManager> historyCreator)
        {
            var editors = new List <IMenuItem> {
                new SmartDataCategoryMenuItemProvider <SmartDataDefinesListViewModel>("Events", new object[] { smartDataProvider, smartDataManager, parameterFactory,
                                                                                                               taskRunner, messageBoxService, windowManager, historyCreator, SmartDataSourceMode.SD_SOURCE_EVENTS }),
                new SmartDataCategoryMenuItemProvider <SmartDataDefinesListViewModel>("Actions", new object[] { smartDataProvider, smartDataManager, parameterFactory,
                                                                                                                taskRunner, messageBoxService, windowManager, historyCreator, SmartDataSourceMode.SD_SOURCE_ACTIONS }),
                new SmartDataCategoryMenuItemProvider <SmartDataDefinesListViewModel>("Targets", new object[] { smartDataProvider, smartDataManager, parameterFactory,
                                                                                                                taskRunner, messageBoxService, windowManager, historyCreator, SmartDataSourceMode.SD_SOURCE_TARGETS }),
                new SmartDataCategoryMenuItemProvider <SmartDataGroupsEditorViewModel>("Event Groups", new object[] { smartDataProvider, taskRunner,
                                                                                                                      messageBoxService, windowManager, historyCreator, SmartDataSourceMode.SD_SOURCE_EVENTS }),
                new SmartDataCategoryMenuItemProvider <SmartDataGroupsEditorViewModel>("Action Groups", new object[] { smartDataProvider, taskRunner,
                                                                                                                       messageBoxService, windowManager, historyCreator, SmartDataSourceMode.SD_SOURCE_ACTIONS }),
                new SmartDataCategoryMenuItemProvider <SmartDataGroupsEditorViewModel>("Target Groups", new object[] { smartDataProvider, taskRunner,
                                                                                                                       messageBoxService, windowManager, historyCreator, SmartDataSourceMode.SD_SOURCE_TARGETS }),
            };

            var saiCategory = new List <IMenuItem> {
                new SmartDataCategoryItem("Smart Scripts", editors)
            };
            IMenuCategoryItem obj = new SmartDataCategoryItem("Smart Data", saiCategory);

            SubItems = new List <IMenuItem>()
            {
                obj
            };
        }
 private static RetryingTaskRunner SutFactory(ITaskRunner next, int retryCount, TimeSpan timeBetweenRetries)
 {
     return(new RetryingTaskRunner(
                next,
                retryCount,
                timeBetweenRetries));
 }
        public UpdateViewModel(IUpdateService updateService,
                               ITaskRunner taskRunner,
                               IStatusBar statusBar,
                               IUpdaterSettingsProvider settingsProvider,
                               IAutoUpdatePlatformService platformService,
                               IFileSystem fileSystem,
                               IStandaloneUpdater standaloneUpdater,
                               IApplication application,
                               IMessageBoxService messageBoxService)
        {
            this.updateService     = updateService;
            this.taskRunner        = taskRunner;
            this.statusBar         = statusBar;
            this.settingsProvider  = settingsProvider;
            this.platformService   = platformService;
            this.fileSystem        = fileSystem;
            this.messageBoxService = messageBoxService;
            CheckForUpdatesCommand = new DelegateCommand(() =>
            {
                if (updateService.CanCheckForUpdates())
                {
                    taskRunner.ScheduleTask("Check for updates", UpdatesCheck);
                }
            }, updateService.CanCheckForUpdates);

            if (!settingsProvider.Settings.DisableAutoUpdates)
            {
                CheckForUpdatesCommand.Execute(null);
            }
        }
        public DatabaseProvider(TrinityMySqlDatabaseProvider trinityDatabase,
                                NullDatabaseProvider nullDatabaseProvider,
                                IDatabaseSettingsProvider settingsProvider,
                                IMessageBoxService messageBoxService,
                                ITaskRunner taskRunner) : base(nullDatabaseProvider)
        {
            if (settingsProvider.Settings.IsEmpty)
            {
                return;
            }

            try
            {
                var cachedDatabase = new CachedDatabaseProvider(trinityDatabase, taskRunner);
                cachedDatabase.TryConnect();
                impl = cachedDatabase;
            }
            catch (Exception e)
            {
                impl = nullDatabaseProvider;
                messageBoxService.ShowDialog(new MessageBoxFactory <bool>().SetTitle("Database error")
                                             .SetIcon(MessageBoxIcon.Error)
                                             .SetMainInstruction("Couldn't connect to the database")
                                             .SetContent(e.Message)
                                             .WithOkButton(true)
                                             .Build());
            }
        }
        public override bool Run()
        {
            Guard.AgainstException<RuntimeBinderException>(() =>
                this.folderToWatch = parameters.FolderToWatch,
                "The FolderToWatch parameter was not found in the parameters. Ensure that the configuration file is correct.");

            Guard.Catch<RuntimeBinderException>(() =>
            {
                if (bool.Parse(parameters.VerboseOutput))
                {
                    taskRunner = new VerboseOutputPluginRunner(taskRunner, notificationService);
                }
            });

            if (!Directory.Exists(folderToWatch))
            {
                notificationService.Notify(this.GetType().Name, String.Format("The directory {0} does not exist and cannot be watched", folderToWatch), NotificationType.Information);
                return false;
            }

            fileSystemWatcher = new FileSystemWatcher(folderToWatch, "*.*");
            fileSystemWatcher.IncludeSubdirectories = true;
            fileSystemWatcher.EnableRaisingEvents = true;
            fileSystemWatcher.NotifyFilter = NotifyFilters.LastAccess | NotifyFilters.LastWrite | NotifyFilters.FileName | NotifyFilters.DirectoryName;
            fileSystemWatcher.Changed += new FileSystemEventHandler(FileSystemChanged);
            fileSystemWatcher.Created += new FileSystemEventHandler(FileSystemChanged);
            fileSystemWatcher.Renamed += FileSystemChanged;

            notificationService.Notify(String.Format("watching {0}", folderToWatch));
            return true;
        }
        public TextureManagementWindowViewModel(
            DomainActionBuilder actionBuilder,
            IDirectoryPicker directoryPicker,
            IEventPublisher eventPublisher,
            IFilePicker filePicker,
            IFindTextureManagementSettingsQuery findTextureManagementSettingsQuery,
            IImageProvider emptyImageProvider,
            ITaskRunner dispatcher)
        {
            _actionBuilder   = actionBuilder;
            _directoryPicker = directoryPicker;
            _eventPublisher  = eventPublisher;
            _filePicker      = filePicker;
            _findTextureManagementSettingsQuery = findTextureManagementSettingsQuery;
            _eventPublisher.Register(this);

            StatusViewModel = new StatusViewModel(dispatcher);
            TexturePreview  = new TexturePreviewViewModel(_actionBuilder, _eventPublisher, this, emptyImageProvider);

            AbortCommand         = new ActionCommand(AbortConversion, IsAbortConversionEnabled);
            CheckAllCommand      = new ActionCommand(CheckAll, IsCheckAllEnabled);
            ConvertMultiCommand  = new ActionCommand(() => _queue.QueueTask(ConvertMultiAsync), IsMultiConversionEnabled);
            ConvertSingleCommand = new ActionCommand(() => _queue.QueueTask(ConvertSingleAsync), IsSingleConversionEnabled);
            MoveToDestinationDirectoryCommand = new ActionCommand(MoveToDestinationDirectory, () => !DestinationDirectory.IsNullOrEmpty());
            MoveToSourceDirectoryCommand      = new ActionCommand(MoveToSourceDirectory, () => !SourceDirectory.IsNullOrEmpty());
            MultiChangedCommand             = new ActionCommand(() => _queue.QueueTask(OnChangedAsync), () => true);
            PickDestinationDirectoryCommand = new ActionCommand(() => _queue.QueueTask(PickDestinationDirectoryAsync), () => true);
            PickSourceDirectoryCommand      = new ActionCommand(() => _queue.QueueTask(PickSourceDirectoryAsync), () => true);
            SingleChangedCommand            = new ActionCommand(() => _queue.QueueTask(OnSingleChangedAsync), () => true);
            UncheckAllCommand = new ActionCommand(UncheckAll, IsUncheckAllEnabled);
        }
Example #25
0
        public void Execute(ITaskRunner taskRunner)
        {
            string sendMapMapListFileName = Path.GetFullPath(
                Path.Combine(
                    taskRunner.MapMakerSettings.TempDir,
                    String.Format(
                        CultureInfo.InvariantCulture,
                        "filelist_{0}.txt",
                        taskRunner.MapMakerSettings.ProductCode)));

            using (FileStream stream = File.Open(sendMapMapListFileName, FileMode.Create))
            {
                using (StreamWriter writer = new StreamWriter(stream))
                {
                    writer.WriteLine(":region");
                    // first add the TYP file
                    writer.WriteLine(Path.GetFileName(
                                         taskRunner.GetProductFile(GenerateTypeFileTask.TypeFile).ProductFileName));

                    foreach (ProductFile file in taskRunner.ListProductFiles(GenerateMapImgFilesTask.MapImgFileName))
                    {
                        writer.WriteLine(Path.GetFileName(file.ProductFileName));
                    }
                }
            }

            taskRunner.RegisterProductFile(new ProductFile(SendMapListFileType, sendMapMapListFileName, false));
        }
Example #26
0
        /// <summary>
        /// Start crawl process
        /// </summary>
        public virtual async Task CrawlAsync()
        {
            if (this.m_OnlyOneCrawlPerInstance)
            {
                throw new InvalidOperationException("Crawler instance cannot be reused");
            }

            this.m_OnlyOneCrawlPerInstance = true;

            var parameters = new Parameter[]
            {
                new TypedParameter(typeof(Uri), this.m_BaseUri),
                new NamedParameter("crawlStart", this.m_BaseUri),
                new TypedParameter(typeof(Crawler), this),
            };

            this.m_CrawlerQueue   = this.m_LifetimeScope.Resolve <ICrawlerQueue>(parameters);
            parameters            = parameters.AddToEnd(new TypedParameter(typeof(ICrawlerQueue), this.m_CrawlerQueue)).ToArray();
            this.m_CrawlerHistory = this.m_LifetimeScope.Resolve <ICrawlerHistory>(parameters);
            parameters            = parameters.AddToEnd(new TypedParameter(typeof(ICrawlerHistory), this.m_CrawlerHistory)).ToArray();
            this.m_TaskRunner     = this.m_LifetimeScope.Resolve <ITaskRunner>(parameters);
            parameters            = parameters.AddToEnd(new TypedParameter(typeof(ITaskRunner), this.m_TaskRunner)).ToArray();
            this.m_Logger         = this.m_LifetimeScope.Resolve <ILog>(parameters);
            parameters            = parameters.AddToEnd(new TypedParameter(typeof(ILog), this.m_Logger)).ToArray();
            this.m_CrawlerRules   = this.m_LifetimeScope.Resolve <ICrawlerRules>(parameters);
            this.m_Logger.Verbose("Crawl started @ {0}", this.m_BaseUri);
            this.m_WebDownloaderFactory = this.m_LifetimeScope.Resolve <Func <IWebDownloader> >();
            using (this.m_CrawlCompleteEvent = new ManualResetEvent(false))
            {
                this.m_Crawling = true;
                this.m_Runtime  = Stopwatch.StartNew();

                if (this.m_CrawlerQueue.Count > 0)
                {
                    // Resume enabled
                    ProcessQueue();
                }
                else
                {
                    await this.AddStepAsync(this.m_BaseUri, 0);
                }

                if (!this.m_CrawlStopped)
                {
                    this.m_CrawlCompleteEvent.WaitOne();
                }

                this.m_Runtime.Stop();
                this.m_Crawling = false;
            }

            if (this.m_Cancelled)
            {
                OnCancelled();
            }

            this.m_Logger.Verbose("Crawl ended @ {0} in {1}", this.m_BaseUri, this.m_Runtime.Elapsed);
            OnCrawlFinished();
        }
Example #27
0
 private AsyncCommand(ITaskRunner <TParameter> runner, ICondition condition)
     : base(runner.Run, condition)
 {
     this.runner = runner;
     runner.ObservePropertyChangedSlim(nameof(runner.TaskCompletion))
     .Subscribe(_ => this.OnPropertyChanged(nameof(this.Execution)));
     this.CancelCommand = new ConditionRelayCommand(runner.Cancel, runner.CanCancelCondition);
 }
Example #28
0
 /// <summary>
 /// 执行日志队列
 /// </summary>
 /// <param name="runner">运行的目标Task</param>
 public void ExecLogQuenuen(ITaskRunner runner)
 {
     while (true)
     {
         SendQuenuenLog(runner);
         Thread.Sleep(1000);
     }
 }
Example #29
0
 public TaskHost(ITaskFactory factory, ITaskRunner runner, IWindowsServiceHandler windowsService, IScheduledTaskHandler scheduledTask, TextWriter textWriter)
 {
     this._factory        = factory;
     this._runner         = runner;
     this._windowsService = windowsService;
     this._scheduledTask  = scheduledTask;
     this._textWriter     = textWriter;
 }
Example #30
0
        public ExecuteTaskMessageHandler()
        {
            var runner = new TaskRunner(new TaskSerializer());

            runner.LoadXamarinTasks();

            this.runner = runner;
        }
Example #31
0
        public DbcStore(IParameterFactory parameterFactory, ITaskRunner taskRunner)
        {
            this.parameterFactory = parameterFactory;
            this.taskRunner       = taskRunner;
            dbcSettingsProvider   = new DbcSettingsProvider();

            Load();
        }
        public TaskScheduler(ITimer timer, ITaskRunner taskRunner)
        {
            _timer = timer;
            _taskRunner = taskRunner;

            ProcessTimeout = 1000 * 60 * 10;
            Granularity = 1000 * 5;
        }
Example #33
0
 public RecordingManager(ILogger log, ISettingsProvider settingsProvider, IVlcDriver vlcDriver, ILinearJobManager linearJobManager, ITaskRunner taskRunner)
 {
     _log = log;
     _settingsProvider = settingsProvider;
     _vlcDriver = vlcDriver;
     _linearJobManager = linearJobManager;
     _taskRunner = taskRunner;
     _hmDirSource = new HumaxDirSource
     {
         Location = _settingsProvider.GetSetting("HumaxDirSource")
     };
 }
Example #34
0
 public TaskExecutionController(SiteSettings siteSettings, ITaskRunner taskRunner)
 {
     _siteSettings = siteSettings;
     _taskRunner = taskRunner;
 }
Example #35
0
 public void PerTestSetUp()
 {
     _taskRunner = new TaskRunner();
 }
Example #36
0
        /// <summary>
        /// 	Start crawl process
        /// </summary>
        public virtual void Crawl()
        {
            using (var stream = new StreamReader(AppDomain.CurrentDomain.BaseDirectory + "OriginalWebSite.txt", Encoding.UTF8))
            {
                var jsonStr = stream.ReadToEnd();
                var policy = new CacheItemPolicy();
                policy.Priority = CacheItemPriority.NotRemovable;
                policy.AbsoluteExpiration = DateTimeOffset.Now.AddDays(1);
                cache.Set(AppDomain.CurrentDomain.BaseDirectory + "OriginalWebSite", jsonStr, policy);
                Console.WriteLine("cache --" + AppDomain.CurrentDomain.BaseDirectory + " :" + cache.Get(AppDomain.CurrentDomain.BaseDirectory + "OriginalWebSite"));
            }
            
            if (m_OnlyOneCrawlPerInstance)
            {
                throw new InvalidOperationException("Crawler instance cannot be reused");
            }

            m_OnlyOneCrawlPerInstance = true;

            Parameter[] parameters = new Parameter[]
				{
					new TypedParameter(typeof (Uri), m_BaseUri),
					new NamedParameter("crawlStart", m_BaseUri),
					new TypedParameter(typeof (Crawler), this),
				};
            m_CrawlerQueue = m_LifetimeScope.Resolve<ICrawlerQueue>(parameters);
            parameters = parameters.AddToEnd(new TypedParameter(typeof(ICrawlerQueue), m_CrawlerQueue)).ToArray();
            m_CrawlerHistory = m_LifetimeScope.Resolve<ICrawlerHistory>(parameters);
            parameters = parameters.AddToEnd(new TypedParameter(typeof(ICrawlerHistory), m_CrawlerHistory)).ToArray();
            m_TaskRunner = m_LifetimeScope.Resolve<ITaskRunner>(parameters);
            parameters = parameters.AddToEnd(new TypedParameter(typeof(ITaskRunner), m_TaskRunner)).ToArray();
            m_Logger = m_LifetimeScope.Resolve<ILog>(parameters);
            parameters = parameters.AddToEnd(new TypedParameter(typeof(ILog), m_Logger)).ToArray();
            m_CrawlerRules = m_LifetimeScope.Resolve<ICrawlerRules>(parameters);
            m_Logger.Verbose("Crawl started @ {0}", m_BaseUri);
            m_WebDownloaderFactory = m_LifetimeScope.Resolve<Func<IWebDownloader>>();
            using (m_CrawlCompleteEvent = new ManualResetEvent(false))
            {
                m_Crawling = true;
                m_Runtime = Stopwatch.StartNew();

                if (m_CrawlerQueue.Count > 0)
                {
                    // Resume enabled
                    ProcessQueue();
                }
                else
                {
                    AddStep(m_BaseUri, 0);
                }

                if (!m_CrawlStopped)
                {
                    m_CrawlCompleteEvent.WaitOne();
                }

                m_Runtime.Stop();
                m_Crawling = false;
            }

            if (m_Cancelled)
            {
                OnCancelled();
            }

            m_Logger.Verbose("Crawl ended @ {0} in {1}", m_BaseUri, m_Runtime.Elapsed);
            OnCrawlFinished();
        }
Example #37
0
        /// <summary>
        /// 	Start crawl process
        /// </summary>
        public virtual void Crawl()
        {
            if (m_OnlyOneCrawlPerInstance)
            {
                throw new InvalidOperationException("Crawler instance cannot be reused");
            }

            m_OnlyOneCrawlPerInstance = true;

            Parameter[] parameters = new Parameter[]
                {
                    new TypedParameter(typeof (Uri), m_BaseUri),
                    new NamedParameter("crawlStart", m_BaseUri),
                    new TypedParameter(typeof (Crawler), this),
                };
            m_CrawlerQueue = m_LifetimeScope.Resolve<ICrawlerQueue>(parameters);
            parameters = parameters.AddToEnd(new TypedParameter(typeof (ICrawlerQueue), m_CrawlerQueue)).ToArray();
            m_CrawlerHistory = m_LifetimeScope.Resolve<ICrawlerHistory>(parameters);
            parameters = parameters.AddToEnd(new TypedParameter(typeof (ICrawlerHistory), m_CrawlerHistory)).ToArray();
            m_TaskRunner = m_LifetimeScope.Resolve<ITaskRunner>(parameters);
            parameters = parameters.AddToEnd(new TypedParameter(typeof (ITaskRunner), m_TaskRunner)).ToArray();
            m_Logger = m_LifetimeScope.Resolve<ILog>(parameters);
            parameters = parameters.AddToEnd(new TypedParameter(typeof (ILog), m_Logger)).ToArray();
            m_CrawlerRules = m_LifetimeScope.Resolve<ICrawlerRules>(parameters);
            m_Logger.Verbose("Crawl started @ {0}", m_BaseUri);
            m_WebDownloaderFactory = m_LifetimeScope.Resolve<Func<IWebDownloader>>();
            using (m_CrawlCompleteEvent = new ManualResetEvent(false))
            {
                m_Crawling = true;
                m_Runtime = Stopwatch.StartNew();

                if (m_CrawlerQueue.Count > 0)
                {
                    // Resume enabled
                    ProcessQueue();
                }
                else
                {
                    AddStep(m_BaseUri, 0);
                }

                if (!m_CrawlStopped)
                {
                    m_CrawlCompleteEvent.WaitOne();
                }

                m_Runtime.Stop();
                m_Crawling = false;
            }

            if (m_Cancelled)
            {
                OnCancelled();
            }

            m_Logger.Verbose("Crawl ended @ {0} in {1}", m_BaseUri, m_Runtime.Elapsed);
            OnCrawlFinished();
        }
Example #38
0
 public BounceRunner(ITaskRunner taskRunner)
 {
     TaskRunner = taskRunner;
 }
 private SplunkAppender Create(ITaskRunner taskRunner = null,
                                 ISplunkWriterFactory factory = null,
                                 ILogBufferItemRepositoryFactory bufferItemRepositoryFactory = null,
                                 ITimerFactory timerFactory = null)
 {
     // ReSharper disable once UseObjectOrCollectionInitializer
     var splunkAppender = new SplunkAppender(taskRunner ?? CreateImmediateTaskRunner(),
         factory ?? Substitute.For<ISplunkWriterFactory>(),
         bufferItemRepositoryFactory ?? Substitute.For<ILogBufferItemRepositoryFactory>(),
         timerFactory ?? Substitute.For<ITimerFactory>());
     splunkAppender.Name = RandomValueGen.GetRandomString(10, 20);
     return splunkAppender;
 }
 public FileSystemWatchingRunner(INotificationService notificationService, ITaskProvider taskProvider)
 {
     this.notificationService = notificationService;
     this.taskProvider = taskProvider;
     this.taskRunner = new TaskRunner();
 }
Example #41
0
 public TestRunner()
 {
     _testMethodProvider = VitaUnitRunner.GetService<ITestMethodProvider>();
     _taskRunner = VitaUnitRunner.GetService<ITaskRunner>();
 }
Example #42
0
        /// <summary>
        /// Start crawl process
        /// </summary>
        public virtual void Crawl()
        {
            if (m_Crawling)
            {
                throw new InvalidOperationException("Crawler already running");
            }

            Parameter[] parameters = new Parameter[]
                {
                    new TypedParameter(typeof (Uri), m_BaseUri),
                    new NamedParameter("crawlStart", m_BaseUri),
                    new NamedParameter("resume", false),
                    new NamedParameter("crawler", this),
                };
            m_CrawlerQueue = m_LifetimeScope.Resolve<ICrawlerQueue>(parameters);
            m_CrawlerHistory = m_LifetimeScope.Resolve<ICrawlerHistory>(parameters);
            m_Robot = AdhereToRobotRules ? m_LifetimeScope.Resolve<IRobot>(parameters) : new DummyRobot();
            m_TaskRunner = m_LifetimeScope.Resolve<ITaskRunner>(parameters);
            m_Logger = m_LifetimeScope.Resolve<ILog>(parameters);

            m_Logger.Verbose("Crawl started @ {0}", m_BaseUri);
            using (m_CrawlCompleteEvent = new ManualResetEvent(false))
            {
                m_Crawling = true;
                m_Runtime = Stopwatch.StartNew();
                AddStep(m_BaseUri, 0);
                if (!m_CrawlStopped)
                {
                    m_CrawlCompleteEvent.WaitOne();
                }

                m_Runtime.Stop();
                m_Crawling = false;
            }

            if (m_Cancelled)
            {
                OnCancelled();
            }

            m_Logger.Verbose("Crawl ended @ {0} in {1}", m_BaseUri, m_Runtime.Elapsed);
            OnCrawlFinished();
        }
 public void SetUp() 
 {
     taskQueue = MockRepository.GenerateStub<ITaskQueue>();
     taskRunner = MockRepository.GenerateStub<ITaskRunner>();
     taskManager = new TaskManager(taskQueue, taskRunner);
 }
Example #44
0
 ///<summary>
 /// Default constructor.
 ///</summary>
 ///<param name="taskQueue">A task queue.</param>
 ///<param name="taskRunner">A task runner.</param>
 public TaskManager(ITaskQueue taskQueue, ITaskRunner taskRunner)
 {
     this.taskQueue = taskQueue;
     this.taskRunner = taskRunner;
 }