/// <summary>
/// [2020.7.7] For the purpose of resuming failed transcriptions, all the captions of the failed transcription would now be stored in the database.
/// Before resuming, all the old captions would be queried out from the database and stored in a dictionary, which will be passed to the
/// transcription function along with the resume time point.
/// </summary>
/// <param name="videoId"></param>
/// <param name="taskParameters"></param>
/// <returns></returns>
protected async override Task OnConsume(string videoId, TaskParameters taskParameters, ClientActiveTasks cleanup)
{
registerTask(cleanup, videoId); // may throw AlreadyInProgress exception
if (Globals.appSettings.MOCK_RECOGNITION == "MOCK")
{
buildMockCaptions(videoId);
}
using (var _context = CTDbContext.CreateDbContext())
{
// TODO: taskParameters.Force should wipe all captions and reset the Transcription Status
Video video = await _context.Videos.Include(v => v.Video1).Where(v => v.Id == videoId).FirstAsync();
// ! Note the 'Include' ; we don't build the whole tree of related Entities
if (video.TranscriptionStatus == Video.TranscriptionStatusMessages.NOERROR)
{
GetLogger().LogInformation($"{videoId}:Skipping Transcribing of- already complete");
return;
}
// GetKey can throw if the video.Id is currently being transcribed
// However registerTask should have already detected that
Key key = TaskEngineGlobals.KeyProvider.GetKey(video.Id);
video.TranscribingAttempts += 10;
await _context.SaveChangesAsync();
try
{
// create Dictionary and pass it to the recognition function
var captionsMap = new Dictionary <string, List <Caption> >();
// Set Source Language and Target (translation) Languages
var sourceLanguage = String.IsNullOrWhiteSpace(Globals.appSettings.SPEECH_RECOGNITION_DIALECT) ?
Languages.ENGLISH_AMERICAN : Globals.appSettings.SPEECH_RECOGNITION_DIALECT.Trim();
var translations = new List <string> {
Languages.ENGLISH_AMERICAN, Languages.SIMPLIFIED_CHINESE, Languages.KOREAN, Languages.SPANISH, Languages.FRENCH
};
if (!String.IsNullOrWhiteSpace(Globals.appSettings.LANGUAGE_TRANSLATIONS))
{
translations = Globals.appSettings.LANGUAGE_TRANSLATIONS.Split(',').ToList();
}
GetLogger().LogInformation($"{videoId}: ({sourceLanguage}). Translation(s) = ({String.Join(',', translations)})");
// Different languages may not be as complete
// So find the minimum timespan of the max observed ending for each language
TimeSpan shortestTime = TimeSpan.MaxValue; // Cant use TimeSpan.Zero to mean unset
var startAfterMap = new Dictionary <string, TimeSpan>();
var allLanguages = new List <string>(translations);
allLanguages.Add(sourceLanguage);
foreach (string language in allLanguages)
{
var existing = await _captionQueries.GetCaptionsAsync(video.Id, language);
captionsMap[language] = existing;
startAfterMap[language] = TimeSpan.Zero;
if (existing.Any())
{
TimeSpan lastCaptionTime = existing.Select(c => c.End).Max();
startAfterMap[language] = lastCaptionTime;
GetLogger().LogInformation($"{ videoId}:{language}. Last Caption at {lastCaptionTime}");
}
}
//var lastSuccessTime = shortestTime < TimeSpan.MaxValue ? shortestTime : TimeSpan.Zero;
//if (video.JsonMetadata != null && video.JsonMetadata["LastSuccessfulTime"] != null)
//{
// lastSuccessTime = TimeSpan.Parse(video.JsonMetadata["LastSuccessfulTime"].ToString());
//}
var result = await _msTranscriptionService.RecognitionWithVideoStreamAsync(videoId, video.Video1, key, captionsMap, sourceLanguage, startAfterMap);
if (video.JsonMetadata == null)
{
video.JsonMetadata = new JObject();
}
TaskEngineGlobals.KeyProvider.ReleaseKey(key, video.Id);
foreach (var captionsInLanguage in result.Captions)
{
var theLanguage = captionsInLanguage.Key;
var theCaptions = captionsInLanguage.Value;
if (theCaptions.Any())
{
var t = _context.Transcriptions.SingleOrDefault(t => t.VideoId == video.Id && t.Language == theLanguage);
GetLogger().LogInformation($"Find Existing Transcriptions null={t == null}");
// Did we get the default or an existing Transcription entity?
if (t == null)
{
t = new Transcription()
{
Captions = theCaptions,
Language = theLanguage,
VideoId = video.Id
};
_context.Add(t);
}
else
{
// Transcriptions already existed, we are just completing them, so add only the new ones
// TODO/TOREVIEW: Does this filter actually help, if existing caption entries were edited by hand?
var newCaptions = theCaptions.Where(c => c.Id == null);
t.Captions.AddRange(newCaptions);
}
}
}
video.TranscriptionStatus = result.ErrorCode;
video.JsonMetadata["LastSuccessfulTime"] = result.LastSuccessTime.ToString();
await _context.SaveChangesAsync();
_sceneDetectionTask.Publish(video.Id);
video.Transcriptions.ForEach(t => _generateVTTFileTask.Publish(t.Id));
}
catch (Exception ex)
{
GetLogger().LogError(ex, $"{videoId}: Transcription Exception:${ex.StackTrace}");
video.TranscribingAttempts += 1000;
await _context.SaveChangesAsync();
throw;
}
}
}
/// <summary>Finds incomplete tasks and adds them all a TaskItem table.
/// This appears to be defunct and not yet used code - grep FindPendingJobs, found no callers of this function
/// </summary>
// private async Task FindPendingJobs()
// {
// using (var context = CTDbContext.CreateDbContext())
// {
// // Medias for which no videos have downloaded
// var toDownloadMediaIds = await context.Medias.Where(m => m.Video == null).Select(m =>
// new TaskItem
// {
// UniqueId = m.Id,
// ResultData = new JObject(),
// TaskParameters = new JObject(),
// TaskType = TaskType.DownloadMedia,
// Attempts = 0
// }).ToListAsync();
// // Videos which haven't been converted to wav
// var toConvertVideoIds = await context.Videos.Where(v => v.Medias.Any() && v.Audio == null).Select(v =>
// new TaskItem
// {
// UniqueId = v.Id,
// ResultData = new JObject(),
// TaskParameters = new JObject(),
// TaskType = TaskType.ConvertMedia,
// Attempts = 0
// }).ToListAsync();
// // Transcribe pending videos.
// var toTranscribeVideoIds = await context.Videos.Where(v => v.TranscribingAttempts < 3 &&
// v.TranscriptionStatus != "NoError" &&
// v.Medias.Any() && v.Audio != null).Select(v =>
// new TaskItem
// {
// UniqueId = v.Id,
// ResultData = new JObject(),
// TaskParameters = new JObject(),
// TaskType = TaskType.Transcribe,
// Attempts = 0
// }).ToListAsync();
// // Completed Transcriptions which haven't generated vtt files
// var toGenerateVTTsTranscriptionIds = await context.Transcriptions.Where(t => t.Captions.Count > 0 && t.File == null)
// .Select(t =>
// new TaskItem
// {
// UniqueId = t.Id,
// ResultData = new JObject(),
// TaskParameters = new JObject(),
// TaskType = TaskType.GenerateVTTFile,
// Attempts = 0
// }).ToListAsync();
// var allTaskItems = new List<TaskItem>();
// allTaskItems.AddRange(toDownloadMediaIds);
// allTaskItems.AddRange(toConvertVideoIds);
// allTaskItems.AddRange(toTranscribeVideoIds);
// allTaskItems.AddRange(toGenerateVTTsTranscriptionIds);
// foreach(var taskItem in allTaskItems)
// {
// if(!await context.TaskItems.AnyAsync(t => t.TaskType == taskItem.TaskType && t.UniqueId == taskItem.UniqueId))
// {
// await context.TaskItems.AddAsync(taskItem);
// }
// }
// await context.SaveChangesAsync();
// }
// }
/// <summary> Used by the PeriodicCheck to identify and enqueue missing tasks.
/// This Task is started after all playlists are updated.
/// </summary>
private async Task PendingJobs()
{
// Update Box Token every few hours
_updateBoxTokenTask.Publish("");
//We will use these outside of the DB scope
List <String> todoVTTs;
List <String> todoProcessVideos;
List <String> todoTranscriptions;
List <String> todoDownloads;
using (var context = CTDbContext.CreateDbContext())
{
// Most tasks are created directly from within a task when it normally completed.
// This code exists to detect missing items and to publish tasks to complete them
// A redesigned taskengine should not have the direct coupling inside each task
// Since downloading a video could also create a Video, it is better to do these with little time delay in-between and then publish all the tasks
// I believe there is still a race condition: Prior to this, we've just polled all active playlists and at least one of these may have already completed
// So let's only consider items that are older than 10 minutes
// Okay this is bandaid on the current design until we redesign the taskengine
// Ideas For the future:
// * Consider setting TTL on these messages to be 5 minutes short of thethe Periodic Refresh?
// * If/when we drop the direct appoach consider: Random ordering. Most recent first (or randomly choosing either)
// If an object was created during the middle of a periodic cycle, give it a full cycle to queue, and another cycle to complete its tasks
int minutesCutOff = Math.Max(1, Convert.ToInt32(Globals.appSettings.PERIODIC_CHECK_OLDER_THAN_MINUTES));
var tooRecentCutoff = DateTime.Now.AddMinutes(-minutesCutOff);
// This is the first use of 'AsNoTracking' in this project; let's check it works in Production as expected
// TODO/TOREVIEW: Does EF create the complete entity and then project out the ID column in dot Net, or does it request only the ID from the database?
// TODO/TOREVIEW: Since this code just pulls the IDs from the database, I expect this will be harmless no-op, however all DB reads should use AsNoTracking as a best practice
// See https://code-maze.com/queries-in-entity-framework-core/
// See https://docs.microsoft.com/en-us/ef/core/querying/tracking
// Completed Transcriptions which haven't generated vtt files
// TODO: Should also check dates too
GetLogger().LogInformation($"Finding incomplete VTTs, Transcriptions and Downloads from before {tooRecentCutoff}, minutesCutOff=({minutesCutOff})");
// Todo Could also check for secondary video too
todoProcessVideos = await context.Videos.AsNoTracking().Where(
v => (v.Duration == null && !String.IsNullOrEmpty(v.Video1Id))
).OrderByDescending(t => t.CreatedAt).Select(e => e.Id).ToListAsync();
todoVTTs = await context.Transcriptions.AsNoTracking().Where(
t => t.Captions.Count > 0 && t.File == null && t.CreatedAt < tooRecentCutoff
).OrderByDescending(t => t.CreatedAt).Select(e => e.Id).ToListAsync();
todoTranscriptions = await context.Videos.AsNoTracking().Where(
v => v.TranscribingAttempts < 1 && v.TranscriptionStatus != "NoError" && v.Medias.Any() && v.CreatedAt < tooRecentCutoff
).OrderByDescending(t => t.CreatedAt).Select(e => e.Id).ToListAsync();
// Medias for which no videos have downloaded
todoDownloads = await context.Medias.AsNoTracking().Where(
m => m.Video == null && m.CreatedAt < tooRecentCutoff
).OrderByDescending(t => t.CreatedAt).Select(e => e.Id).ToListAsync();
}
// We have a list of outstanding tasks
// However some of these may already be in progress
// So don't queue theses
GetLogger().LogInformation($"Found {todoProcessVideos.Count},{todoVTTs.Count},{todoTranscriptions.Count},{todoDownloads.Count} counts before filtering");
ClientActiveTasks currentProcessVideos = _processVideoTask.GetCurrentTasks();
todoProcessVideos.RemoveAll(e => currentProcessVideos.Contains(e));
ClientActiveTasks currentVTTs = _generateVTTFileTask.GetCurrentTasks();
todoVTTs.RemoveAll(e => currentVTTs.Contains(e));
ClientActiveTasks currentTranscription = _transcriptionTask.GetCurrentTasks();
todoTranscriptions.RemoveAll(e => currentTranscription.Contains(e));
ClientActiveTasks currentDownloads = _transcriptionTask.GetCurrentTasks();
todoDownloads.RemoveAll(e => currentDownloads.Contains(e));
GetLogger().LogInformation($"Current In progress {currentProcessVideos.Count},{currentVTTs.Count},{currentTranscription.Count},{currentDownloads.Count} counts after filtering");
GetLogger().LogInformation($"Found {todoProcessVideos.Count},{todoVTTs.Count},{todoTranscriptions.Count},{todoDownloads.Count} counts after filtering");
// Now we have a list of new things we want to do
GetLogger().LogInformation($"Publishing processingVideos ({String.Join(",", todoProcessVideos)})");
todoProcessVideos.ForEach(t => _processVideoTask.Publish(t));
GetLogger().LogInformation($"Publishing todoVTTs ({String.Join(",", todoVTTs)})");
todoVTTs.ForEach(t => _generateVTTFileTask.Publish(t));
GetLogger().LogInformation($"Publishing todoTranscriptions ({String.Join(",", todoTranscriptions)})");
todoTranscriptions.ForEach(v => _transcriptionTask.Publish(v));
GetLogger().LogInformation($"Publishing todoDownloads ({String.Join(",", todoDownloads)})");
todoDownloads.ForEach(m => _downloadMediaTask.Publish(m));
//// Not used Videos which haven't been converted to wav
/// Code Not deleted because one day we will just reuse the one wav file and use an offset into that file
//(await context.Videos.Where(v => v.Medias.Any() && v.Audio == null).ToListAsync()).ForEach(v => _convertVideoToWavTask.Publish(v.Id));
// Videos which have failed in transcribing
GetLogger().LogInformation("Pending Jobs - completed");
}