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);
}
}
