public async Task <HealthCheckResult> Check(CancellationToken cancellationToken)
    {
        Option <ConfigElement> maybeFFmpegPath = await _configElementRepository.Get(ConfigElementKey.FFmpegPath);

        if (maybeFFmpegPath.IsNone)
        {
            return(FailResult("Unable to locate ffmpeg"));
        }

        string version = Assembly.GetEntryAssembly()?.GetCustomAttribute <AssemblyInformationalVersionAttribute>()
                         ?.InformationalVersion ?? "unknown";

        var accelerationKinds = new List <HardwareAccelerationKind>();

        if (version.Contains("docker", StringComparison.OrdinalIgnoreCase))
        {
            if (version.Contains("nvidia", StringComparison.OrdinalIgnoreCase))
            {
                accelerationKinds.Add(HardwareAccelerationKind.Nvenc);
            }
            else if (version.Contains("vaapi", StringComparison.OrdinalIgnoreCase))
            {
                accelerationKinds.Add(HardwareAccelerationKind.Vaapi);
            }
        }

        if (!accelerationKinds.Any())
        {
            accelerationKinds.AddRange(
                await GetSupportedAccelerationKinds(maybeFFmpegPath.ValueUnsafe().Value, cancellationToken));
        }

        if (!accelerationKinds.Any())
        {
            return(InfoResult("No compatible hardware acceleration kinds are supported by ffmpeg"));
        }

        Option <HealthCheckResult> maybeResult = await VerifyProfilesUseAcceleration(accelerationKinds);

        foreach (HealthCheckResult result in maybeResult)
        {
            return(result);
        }

        return(OkResult());
    }
Esempio n. 2
0
        public async Task <Unit> Handle(RebuildSearchIndex request, CancellationToken cancellationToken)
        {
            bool indexFolderExists = Directory.Exists(FileSystemLayout.SearchIndexFolder);

            if (!indexFolderExists ||
                await _configElementRepository.GetValue <int>(ConfigElementKey.SearchIndexVersion) <
                _searchIndex.Version)
            {
                _logger.LogDebug("Migrating search index to version {Version}", _searchIndex.Version);

                List <int> itemIds = await _searchRepository.GetItemIdsToIndex();

                await _searchIndex.Rebuild(itemIds);

                Option <ConfigElement> maybeVersion =
                    await _configElementRepository.Get(ConfigElementKey.SearchIndexVersion);

                await maybeVersion.Match(
                    version =>
                {
                    version.Value = _searchIndex.Version.ToString();
                    return(_configElementRepository.Update(version));
                },
                    () =>
                {
                    var configElement = new ConfigElement
                    {
                        Key   = ConfigElementKey.SearchIndexVersion.Key,
                        Value = _searchIndex.Version.ToString()
                    };
                    return(_configElementRepository.Add(configElement));
                });

                _logger.LogDebug("Done migrating search index");
            }
            else
            {
                _logger.LogDebug("Search index is already version {Version}", _searchIndex.Version);
            }

            return(Unit.Default);
        }