Пример #1
0
 private async Task TestItem(ChannelItemInfo item, ListingResults results, CancellationToken cancellationToken)
 {
     foreach (var media in (item.MediaSources ?? new List<ChannelMediaInfo>()))
     {
         try
         {
             await TestMediaInfo(media, results, cancellationToken).ConfigureAwait(false);
         }
         catch (Exception ex)
         {
             _logger.ErrorException("Error testing media info", ex);
         }
     }
 }
Пример #2
0
        private async Task TestMediaInfo(ChannelMediaInfo item, ListingResults results, CancellationToken cancellationToken)
        {
            var key = item.Path;

            if (string.IsNullOrEmpty(key))
            {
                return;
            }

            ListingResult result;
            if (results.TestResults.TryGetValue(key, out result))
            {
                // Was validated recently
                if (result.IsValid && (DateTime.UtcNow - result.DateTested).TotalDays <= 30)
                {
                    return;
                }

                // Already known to be bad
                if (!result.IsValid)
                {
                    return;
                }
            }

            var options = new HttpRequestOptions
            {
                Url = item.Path,
                CancellationToken = cancellationToken,
                BufferContent = false
            };

            foreach (var header in item.RequiredHttpHeaders)
            {
                options.RequestHeaders[header.Key] = header.Value;
            }

            var isOk = false;

            try
            {
                var response = await _httpClient.SendAsync(options, "HEAD").ConfigureAwait(false);

                try
                {
                    if (response.ContentType.StartsWith("video", StringComparison.OrdinalIgnoreCase))
                    {
                        isOk = true;
                    }
                }
                finally
                {
                    response.Content.Dispose();
                }
            }
            catch (HttpException ex)
            {
                if (!ex.StatusCode.HasValue)
                {
                    throw;
                }

                if (ex.StatusCode.Value != HttpStatusCode.NotFound &&
                    ex.StatusCode.Value != HttpStatusCode.Forbidden)
                {
                    throw;
                }
            }

            results.TestResults[key] = new ListingResult
            {
                IsValid = isOk,
                DateTested = DateTime.UtcNow
            };
        }
Пример #3
0
 private async Task TestItems(IEnumerable<ChannelItemInfo> items, ListingResults results, CancellationToken cancellationToken)
 {
     foreach (var item in items)
     {
         await TestItem(item, results, cancellationToken).ConfigureAwait(false);
     }
 }
Пример #4
0
        private async Task<ListingResults> TestResults(IEnumerable<ChannelItemInfo> items, string savePath, CancellationToken cancellationToken)
        {
            ListingResults results = null;

            try
            {
                using (var stream = GetType().Assembly.GetManifestResourceStream(GetType().Namespace + ".Listings.testresults.txt"))
                {
                    if (stream != null)
                    {
                        results = _json.DeserializeFromStream<ListingResults>(stream);
                    }
                }
            }
            catch
            {
            }

            if (results == null)
            {
                results = new ListingResults();
            }

            await TestItems(items, results, cancellationToken).ConfigureAwait(false);

            await _fileLock.WaitAsync(cancellationToken).ConfigureAwait(false);

            try
            {
                _json.SerializeToFile(results, Path.Combine(savePath, "testresults.txt"));
            }
            finally
            {
                _fileLock.Release();
            }

            return results;
        }
Пример #5
0
        private bool Filter(ChannelMediaInfo item, ListingResults results)
        {
            var key = item.Path;

            if (string.IsNullOrEmpty(key))
            {
                return false;
            }

            ListingResult result;
            if (results.TestResults.TryGetValue(key, out result))
            {
                return result.IsValid;
            }

            // Should never get here. return false
            return false;
        }
Пример #6
0
        private bool Filter(ChannelItemInfo item, ListingResults results)
        {
            item.MediaSources = item.MediaSources
                .Where(i => Filter(i, results))
                .ToList();

            return item.MediaSources.Count > 0;
        }
Пример #7
0
 private List<ChannelItemInfo> CreateFilteredListings(IEnumerable<ChannelItemInfo> items, ListingResults results)
 {
     return items.Where(i => Filter(i, results)).ToList();
 }