private Owned <EngineRunner> CreateEngineRunner(string engineId) { var runner = new EngineRunner(_engineOptions, EngineRepository, BuildRepository, _smtModelFactory, _ruleEngineFactory, _textCorpusFactory, Substitute.For <ILogger <EngineRunner> >(), engineId); return(new Owned <EngineRunner>(runner, runner)); }
public async Task <Build> StartBuildAsync(EngineLocatorType locatorType, string locator) { CheckDisposed(); using (await _lock.ReaderLockAsync()) { Engine engine = await _engineRepo.GetByLocatorAsync(locatorType, locator); if (engine == null) { return(null); } EngineRunner runner = GetOrCreateRunner(engine.Id); return(await runner.StartBuildAsync(engine)); } }
public async Task <IEnumerable <TranslationResult> > TranslateAsync( EngineLocatorType locatorType, string locator, int n, IReadOnlyList <string> segment) { CheckDisposed(); using (await _lock.ReaderLockAsync()) { Engine engine = await _engineRepo.GetByLocatorAsync(locatorType, locator); if (engine == null) { return(null); } EngineRunner runner = GetOrCreateRunner(engine.Id); return(await runner.TranslateAsync(n, segment.Preprocess(Preprocessors.Lowercase))); } }
public async Task InitAsync() { // restart any builds that didn't finish before the last shutdown foreach (Build build in await _buildRepo.GetAllAsync()) { Engine engine = await _engineRepo.GetAsync(build.EngineId); if (engine != null) { EngineRunner runner = CreateRunner(engine.Id); await runner.RestartUnfinishedBuildAsync(build, engine); } else { // orphaned build, so delete it await _buildRepo.DeleteAsync(build); } } _commitTimer.Start(_options.Value.EngineCommitFrequency); }
public async Task <bool> TrainSegmentAsync(EngineLocatorType locatorType, string locator, IReadOnlyList <string> sourceSegment, IReadOnlyList <string> targetSegment) { CheckDisposed(); using (await _lock.ReaderLockAsync()) { Engine engine = await _engineRepo.GetByLocatorAsync(locatorType, locator); if (engine == null) { return(false); } EngineRunner runner = GetOrCreateRunner(engine.Id); await runner.TrainSegmentPairAsync(sourceSegment.Preprocess(Preprocessors.Lowercase), targetSegment.Preprocess(Preprocessors.Lowercase)); return(true); } }
public async Task CreateEngineAsync(TimeSpan inactiveTimeout = default(TimeSpan)) { Engine = new Engine { Id = "engine1", SourceLanguageTag = "es", TargetLanguageTag = "en", IsShared = false, Projects = { "project1" } }; await EngineRepository.InsertAsync(Engine); var options = new EngineOptions { InactiveEngineTimeout = inactiveTimeout }; EngineRunner = new EngineRunner(new OptionsWrapper <EngineOptions>(options), EngineRepository, BuildRepository, CreateSmtModelFactory(), CreateRuleEngineFactory(), CreateTextCorpusFactory(), Substitute.For <ILogger <EngineRunner> >(), Engine.Id); }
public async Task <bool> RemoveProjectAsync(string projectId) { CheckDisposed(); using (await _lock.WriterLockAsync()) { Engine engine = await _engineRepo.GetByProjectIdAsync(projectId); if (engine == null) { return(false); } EngineRunner runner = GetOrCreateRunner(engine.Id); if (engine.Projects.Count == 1 && engine.Projects.Contains(projectId)) { // the engine will have no associated projects, so remove it await _engineRepo.DeleteAsync(engine); _runners.TryRemove(engine.Id, out _); await runner.DeleteDataAsync(); runner.Dispose(); } else { // engine will still have associated projects, so just update it await _engineRepo.ConcurrentUpdateAsync(engine, e => e.Projects.Remove(projectId)); await runner.StartBuildAsync(engine); } await _projectRepo.DeleteAsync(projectId); return(true); } }