public static async Task <TReturn> ReadStreamAsync <TReturn>(this IWebReader webReader, Uri url, Retry retry, Func <Uri, Stream, CancellationToken, Task <TReturn> > reader, CancellationToken cancellationToken) { TReturn @return; while (true) { using (IWebStreamResponse webStreamAsync = await webReader.GetWebStreamAsync(url, false, cancellationToken, (Uri)null, new long?(), new long?(), (WebResponse)null)) { if (webStreamAsync.IsSuccessStatusCode) { Uri actualUrl = webStreamAsync.ActualUrl; using (Stream stream = await webStreamAsync.GetStreamAsync(cancellationToken).ConfigureAwait(false)) { @return = await reader(actualUrl, stream, cancellationToken).ConfigureAwait(false); break; } } else { if (!RetryPolicy.IsRetryable((HttpStatusCode)webStreamAsync.HttpStatusCode)) { webStreamAsync.EnsureSuccessStatusCode(); } bool canRetry = await retry.CanRetryAfterDelayAsync(cancellationToken).ConfigureAwait(false); if (!canRetry) { webStreamAsync.EnsureSuccessStatusCode(); } } } } return(@return); }
public void Close() { bool flag = object.ReferenceEquals((object)this._readStream, (object)this._responseStream); try { Stream stream = this._readStream; if (null != stream) { this._readStream = (Stream)null; using (stream) ; } } catch (Exception ex) { Debug.WriteLine("SegmentReader.Close() readStream cleanup failed: " + ex.Message); } if (!flag) { try { Stream stream = this._responseStream; if (null != stream) { this._responseStream = (Stream)null; using (stream) ; } } catch (Exception ex) { Debug.WriteLine("SegmentReader.Close() responseStream cleanup failed: " + ex.Message); } } try { IWebStreamResponse webStreamResponse = this._response; if (null == webStreamResponse) { return; } this._response = (IWebStreamResponse)null; using (webStreamResponse) ; } catch (Exception ex) { Debug.WriteLine("SegmentReader.Close() response cleanup failed: " + ex.Message); } }
private IWebStreamResponse FilterColumns <T>(IWebStreamResponse response, string[] columns, string address, bool async) where T : PrtgObject { if (columns != null) { var defaultProperties = ContentParameters <T> .GetDefaultProperties(); var defaultPropertiesStr = defaultProperties.Select(p => p.GetDescription().ToLower()).ToList(); var missing = defaultPropertiesStr.Where(p => !columns.Contains(p)).ToList(); if (missing.Count > 0) { string responseStr; if (async) { responseStr = response.GetResponseTextStream(address).Result; } else { responseStr = response.GetResponseText(ref address); } var xDoc = XDocument.Parse(responseStr); var toRemove = xDoc.Descendants("item").Descendants().Where( e => { var str = e.Name.ToString(); if (str.EndsWith("_raw")) { str = str.Substring(0, str.Length - "_raw".Length); } return(missing.Contains(str)); }).ToList(); foreach (var elm in toRemove) { elm.Remove(); } return(new BasicResponse(xDoc.ToString())); } } return(response); }
public virtual async Task <ISegmentManager> CreateAsync(ISegmentManagerParameters parameters, ContentType contentType, CancellationToken cancellationToken) { ISegmentManager segmentManager1; foreach (Uri uri in (IEnumerable <Uri>)parameters.Source) { Uri localUrl = uri; IRetry retry = RetryManagerExtensions.CreateWebRetry(this._retryManager, 3, 333); ISegmentManager segmentManager = await retry.CallAsync <ISegmentManager>((Func <Task <ISegmentManager> >)(async() => { IWebReader webReader = this._webReaderManager.CreateReader(localUrl, ContentTypes.Pls.Kind, (IWebReader)null, ContentTypes.Pls); ISegmentManager segmentManager2; try { using (IWebStreamResponse webStreamResponse = await webReader.GetWebStreamAsync(localUrl, false, cancellationToken, (Uri)null, new long?(), new long?(), (WebResponse)null).ConfigureAwait(false)) { if (!webStreamResponse.IsSuccessStatusCode) { webReader.Dispose(); segmentManager2 = (ISegmentManager)null; } else { using (Stream stream = await webStreamResponse.GetStreamAsync(cancellationToken).ConfigureAwait(false)) segmentManager2 = await this.ReadPlaylistAsync(webReader, webStreamResponse.ActualUrl, stream, cancellationToken).ConfigureAwait(false); } } } catch (Exception ex) { webReader.Dispose(); throw; } return(segmentManager2); }), cancellationToken); if (null != segmentManager) { segmentManager1 = segmentManager; goto label_10; } } segmentManager1 = (ISegmentManager)null; label_10: return(segmentManager1); }
public static async Task <TReturn> ReadStreamAsync <TReturn>(this IWebReader webReader, Uri url, IRetry retry, Func <Uri, Stream, TReturn> reader, CancellationToken cancellationToken) { TReturn @return; while (true) { using (IWebStreamResponse webStreamResponse = await webReader.GetWebStreamAsync(url, true, cancellationToken, (Uri)null, new long?(), new long?(), (WebResponse)null).ConfigureAwait(false)) { if (webStreamResponse.IsSuccessStatusCode) { Uri actualUrl = webStreamResponse.ActualUrl; using (Stream stream = await webStreamResponse.GetStreamAsync(cancellationToken).ConfigureAwait(false)) { using (MemoryStream memoryStream = new MemoryStream((int)(webStreamResponse.ContentLength ?? 4096L))) { await stream.CopyToAsync((Stream)memoryStream, 4096, cancellationToken).ConfigureAwait(false); memoryStream.Position = 0L; @return = reader(actualUrl, (Stream)memoryStream); break; } } } else { if (!RetryPolicy.IsRetryable((HttpStatusCode)webStreamResponse.HttpStatusCode)) { webStreamResponse.EnsureSuccessStatusCode(); } bool canRetry = await retry.CanRetryAfterDelayAsync(cancellationToken).ConfigureAwait(false); if (!canRetry) { webStreamResponse.EnsureSuccessStatusCode(); } } } } return(@return); }
private async Task ReadResponseAsync(IMediaParser mediaParser, IWebStreamResponse webStreamResponse, WebResponse webResponse, SingleStreamMediaManager.QueueThrottle throttle, CancellationToken cancellationToken) { byte[] buffer = new byte[16384]; Task cancellationTask = CancellationTokenExtensions.AsTask(cancellationToken); try { ISegmentMetadata segmentMetadata = this._webMetadataFactory.CreateSegmentMetadata(webResponse, (ContentType)null); mediaParser.StartSegment(segmentMetadata); using (Stream stream = await webStreamResponse.GetStreamAsync(cancellationToken).ConfigureAwait(false)) { while (true) { Task waitTask = throttle.WaitAsync(); if (!waitTask.IsCompleted) { Task task = await TaskEx.WhenAny(waitTask, cancellationTask).ConfigureAwait(false); cancellationToken.ThrowIfCancellationRequested(); } int length = await stream.ReadAsync(buffer, 0, buffer.Length, cancellationToken).ConfigureAwait(false); if (length > 0) { mediaParser.ProcessData(buffer, 0, length); } else { break; } } } } finally { mediaParser.ProcessEndOfData(); } }
private Task OpenStream(Action <ISegmentMetadata> setMetadata, CancellationToken cancellationToken) { this.ThrowIfDisposed(); WebResponse webResponse = new WebResponse(); IRetry retry = this._retryManager.CreateRetry(2, 200, new Func <Exception, bool>(RetryPolicy.IsWebExceptionRetryable)); return(RetryExtensions.CallAsync(retry, (Func <Task>)(async() => { long?nullable1; long?nullable2; while (true) { if (this._startOffset.HasValue && this._endOffset.HasValue) { nullable1 = this._endOffset; nullable2 = this._startOffset; nullable1 = nullable1.HasValue & nullable2.HasValue ? new long?(nullable1.GetValueOrDefault() - nullable2.GetValueOrDefault()) : new long?(); long?nullable3; if (!nullable1.HasValue) { nullable2 = new long?(); nullable3 = nullable2; } else { nullable3 = new long?(nullable1.GetValueOrDefault() + 1L); } this._expectedBytes = nullable3; } else { this._expectedBytes = new long?(); } this._response = await this._webReader.GetWebStreamAsync(this._actualUrl ?? this._segment.Url, false, cancellationToken, this._segment.ParentUrl, this._startOffset, this._endOffset, webResponse).ConfigureAwait(false); if (!this._response.IsSuccessStatusCode) { HttpStatusCode statusCode = (HttpStatusCode)this._response.HttpStatusCode; if (HttpStatusCode.NotFound != statusCode && !RetryPolicy.IsRetryable(statusCode)) { this._response.EnsureSuccessStatusCode(); } bool canRetry = await retry.CanRetryAfterDelayAsync(cancellationToken).ConfigureAwait(false); if (!canRetry) { if ((Uri)null != this._actualUrl && this._actualUrl != this._segment.Url) { this._actualUrl = (Uri)null; } else { this._response.EnsureSuccessStatusCode(); } } this._response.Dispose(); this._response = (IWebStreamResponse)null; } else { break; } } this._actualUrl = this._response.ActualUrl; long?contentLength = this._response.ContentLength; if (!this._endOffset.HasValue) { nullable1 = contentLength; long?nullable3; if (!nullable1.HasValue) { nullable2 = new long?(); nullable3 = nullable2; } else { nullable3 = new long?(nullable1.GetValueOrDefault() - 1L); } this._endOffset = nullable3; } if (!this._expectedBytes.HasValue) { this._expectedBytes = contentLength; } SegmentReader segmentReader1 = this; ConfiguredTaskAwaitable <Stream> configuredTaskAwaitable = this._response.GetStreamAsync(cancellationToken).ConfigureAwait(false); PositionStream positionStream = new PositionStream(await configuredTaskAwaitable); segmentReader1._responseStream = (Stream)positionStream; Task <Stream> filterStreamTask = this._segment.CreateFilterAsync(this._responseStream, cancellationToken); if (null != filterStreamTask) { SegmentReader segmentReader2 = this; configuredTaskAwaitable = filterStreamTask.ConfigureAwait(false); Stream stream = await configuredTaskAwaitable; segmentReader2._readStream = stream; } else { this._readStream = this._responseStream; } ISegmentMetadata segmentMetadata = this._webMetadataFactory.CreateSegmentMetadata(webResponse, (ContentType)null); setMetadata(segmentMetadata); }), cancellationToken)); }
private async Task SimplePlayAsync(ContentType contentType, IWebReader webReader, IWebStreamResponse webStreamResponse, WebResponse webResponse, TaskCompletionSource <bool> configurationTaskCompletionSource, CancellationToken cancellationToken) { try { this._mediaStreamConfigurator.Initialize(); this._mediaStreamConfigurator.MediaManager = (IMediaManager)this; IMediaParser mediaParser = await this._mediaParserFactory.CreateAsync((IMediaParserParameters) new MediaParserParameters(), contentType, cancellationToken).ConfigureAwait(false); if (null == mediaParser) { throw new NotSupportedException("Unsupported content type: " + (object)contentType); } this.State = MediaManagerState.Opening; EventHandler configurationComplete = (EventHandler)null; configurationComplete = (EventHandler)((sender, args) => { mediaParser.ConfigurationComplete -= configurationComplete; configurationTaskCompletionSource.TrySetResult(true); }); mediaParser.ConfigurationComplete += configurationComplete; using (IBufferingManager bufferingManager = this._bufferingManagerFactory()) { SingleStreamMediaManager.QueueThrottle throttle = new SingleStreamMediaManager.QueueThrottle(); bufferingManager.Initialize((IQueueThrottling)throttle, new Action(this._mediaStreamConfigurator.CheckForSamples)); mediaParser.Initialize(bufferingManager, (Action <IProgramStreams>)null); IStreamMetadata streamMetadata = this._webMetadataFactory.CreateStreamMetadata(webResponse, (ContentType)null); mediaParser.InitializeStream(streamMetadata); Task reader = (Task)null; try { using (webReader) { try { if (null == webStreamResponse) { webStreamResponse = await webReader.GetWebStreamAsync((Uri)null, false, cancellationToken, (Uri)null, new long?(), new long?(), webResponse).ConfigureAwait(false); } reader = this.ReadResponseAsync(mediaParser, webStreamResponse, webResponse, throttle, cancellationToken); Task task = await TaskEx.WhenAny((Task)configurationTaskCompletionSource.Task, CancellationTokenExtensions.AsTask(cancellationToken)).ConfigureAwait(false); cancellationToken.ThrowIfCancellationRequested(); await MediaStreamSourceExtensions.PlayAsync(this._mediaStreamConfigurator, (IEnumerable <IMediaParserMediaStream>) mediaParser.MediaStreams, new TimeSpan?(), cancellationToken).ConfigureAwait(false); this.State = MediaManagerState.Playing; await reader.ConfigureAwait(false); reader = (Task)null; } finally { if (null != webStreamResponse) { webStreamResponse.Dispose(); } } } } catch (OperationCanceledException ex) { } catch (Exception ex) { string message = ExceptionExtensions.ExtendedMessage(ex); Debug.WriteLine("SingleStreamMediaManager.SimplePlayAsync() failed: " + message); this.SetMediaState(MediaManagerState.Error, message); } this.State = MediaManagerState.Closing; if (null != reader) { try { await reader.ConfigureAwait(false); } catch (OperationCanceledException ex) { } catch (Exception ex) { Debug.WriteLine("SingleStreamMediaManager.SimplePlayAsync() reader failed: " + ExceptionExtensions.ExtendedMessage(ex)); } } mediaParser.ConfigurationComplete -= configurationComplete; mediaParser.EnableProcessing = false; mediaParser.FlushBuffers(); bufferingManager.Flush(); bufferingManager.Shutdown((IQueueThrottling)throttle); await this._mediaStreamConfigurator.CloseAsync().ConfigureAwait(false); } } catch (Exception ex) { Debug.WriteLine("SingleStreamMediaManager.SimplePlayAsync() cleanup failed: " + ExceptionExtensions.ExtendedMessage(ex)); } this._mediaStreamConfigurator.MediaManager = (IMediaManager)null; if (!configurationTaskCompletionSource.Task.IsCompleted) { configurationTaskCompletionSource.TrySetCanceled(); } this.State = MediaManagerState.Closed; await this._reportStateTask.WaitAsync().ConfigureAwait(false); }
public async Task <IMediaStreamConfigurator> OpenMediaAsync(ICollection <Uri> source, CancellationToken cancellationToken) { this.State = MediaManagerState.OpenMedia; WebResponse response = new WebResponse(); IMediaStreamConfigurator streamConfigurator; using (IWebReader rootReader = WebReaderManagerExtensions.CreateRootReader(this._webReaderManager, (ContentType)null)) { using (IEnumerator <Uri> enumerator = source.GetEnumerator()) { label_25: if (enumerator.MoveNext()) { Uri url = enumerator.Current; IWebReader webReader = (IWebReader)null; IWebStreamResponse webStream = (IWebStreamResponse)null; CancellationTokenSource playCancellationTokenSource = (CancellationTokenSource)null; Task playTask = (Task)null; try { webReader = WebReaderExtensions.CreateChild(rootReader, url, ContentKind.Unknown, this.ContentType); webStream = await webReader.GetWebStreamAsync((Uri)null, false, cancellationToken, (Uri)null, new long?(), new long?(), response).ConfigureAwait(false); if (webStream.IsSuccessStatusCode) { ContentType contentType = response.ContentType; if (!((ContentType)null == contentType)) { if ((ContentType)null == contentType || ContentKind.Playlist == contentType.Kind) { throw new FileNotFoundException("Content not supported with this media manager"); } TaskCompletionSource <bool> configurationTaskCompletionSource = new TaskCompletionSource <bool>(); playCancellationTokenSource = new CancellationTokenSource(); CancellationTokenSource localPlayCancellationTokenSource = playCancellationTokenSource; Task cancelPlayTask = configurationTaskCompletionSource.Task.ContinueWith((Action <Task <bool> >)(t => { if (!t.IsFaulted && !t.IsCanceled) { return; } localPlayCancellationTokenSource.Cancel(); })); TaskCollector.Default.Add(cancelPlayTask, "SingleStreamMediaManager play cancellation"); IWebReader localWebReader = webReader; IWebStreamResponse localWebStream = webStream; CancellationToken playCancellationToken = playCancellationTokenSource.Token; playTask = TaskEx.Run((Func <Task>)(() => this.SimplePlayAsync(contentType, localWebReader, localWebStream, response, configurationTaskCompletionSource, playCancellationToken)), playCancellationToken); bool lockTaken = false; object obj; try { Monitor.Enter(obj = this._lock, ref lockTaken); this._playCancellationTokenSource = playCancellationTokenSource; playCancellationTokenSource = (CancellationTokenSource)null; this._playTask = playTask; playTask = (Task)null; } finally { if (lockTaken) { Monitor.Exit(obj); } } bool isConfigured = await configurationTaskCompletionSource.Task.ConfigureAwait(false); if (isConfigured) { webReader = (IWebReader)null; webStream = (IWebStreamResponse)null; streamConfigurator = this._mediaStreamConfigurator; goto label_33; } else { goto label_25; } } else { goto label_25; } } else { goto label_25; } } finally { if (null != webStream) { webStream.Dispose(); } if (null != webReader) { webReader.Dispose(); } if (null != playCancellationTokenSource) { playCancellationTokenSource.Cancel(); } if (null != playTask) { TaskCollector.Default.Add(playTask, "SingleStreamMediaManager play task"); } } } } } throw new FileNotFoundException(); label_33: return(streamConfigurator); }
async Task ReadResponseAsync(IMediaParser mediaParser, IWebStreamResponse webStreamResponse, WebResponse webResponse, QueueThrottle throttle, CancellationToken cancellationToken) { //Debug.WriteLine("SingleStreamMediaManager.ReadResponseAsync()"); var buffer = new byte[16 * 1024]; var cancellationTask = cancellationToken.AsTask(); try { var segmentMetadata = _webMetadataFactory.CreateSegmentMetadata(webResponse); mediaParser.StartSegment(segmentMetadata); using (var stream = await webStreamResponse.GetStreamAsync(cancellationToken).ConfigureAwait(false)) { for (; ; ) { var waitTask = throttle.WaitAsync(); if (!waitTask.IsCompleted) { await Task.WhenAny(waitTask, cancellationTask).ConfigureAwait(false); cancellationToken.ThrowIfCancellationRequested(); } var length = await stream.ReadAsync(buffer, 0, buffer.Length, cancellationToken).ConfigureAwait(false); if (length <= 0) return; mediaParser.ProcessData(buffer, 0, length); } } } finally { mediaParser.ProcessEndOfData(); //Debug.WriteLine("SingleStreamMediaManager.ReadResponseAsync() done"); } }
async Task SimplePlayAsync(ContentType contentType, IWebReader webReader, IWebStreamResponse webStreamResponse, WebResponse webResponse, TaskCompletionSource<bool> configurationTaskCompletionSource, CancellationToken cancellationToken) { try { _mediaStreamConfigurator.Initialize(); _mediaStreamConfigurator.MediaManager = this; var mediaParser = await _mediaParserFactory.CreateAsync(new MediaParserParameters(), contentType, cancellationToken).ConfigureAwait(false); if (null == mediaParser) throw new NotSupportedException("Unsupported content type: " + contentType); State = MediaManagerState.Opening; EventHandler configurationComplete = null; configurationComplete = (sender, args) => { // ReSharper disable once AccessToModifiedClosure mediaParser.ConfigurationComplete -= configurationComplete; configurationTaskCompletionSource.TrySetResult(true); }; mediaParser.ConfigurationComplete += configurationComplete; using (var bufferingManager = _bufferingManagerFactory()) { var throttle = new QueueThrottle(); bufferingManager.Initialize(throttle, _mediaStreamConfigurator.CheckForSamples); mediaParser.Initialize(bufferingManager); var streamMetadata = _webMetadataFactory.CreateStreamMetadata(webResponse); mediaParser.InitializeStream(streamMetadata); Task reader = null; try { using (webReader) { try { if (null == webStreamResponse) webStreamResponse = await webReader.GetWebStreamAsync(null, false, cancellationToken, response: webResponse).ConfigureAwait(false); reader = ReadResponseAsync(mediaParser, webStreamResponse, webResponse, throttle, cancellationToken); await Task.WhenAny(configurationTaskCompletionSource.Task, cancellationToken.AsTask()).ConfigureAwait(false); cancellationToken.ThrowIfCancellationRequested(); await _mediaStreamConfigurator.PlayAsync(mediaParser.MediaStreams, null, cancellationToken).ConfigureAwait(false); State = MediaManagerState.Playing; await reader.ConfigureAwait(false); reader = null; } finally { if (null != webStreamResponse) webStreamResponse.Dispose(); } } } catch (OperationCanceledException) { } catch (Exception ex) { var message = ex.ExtendedMessage(); Debug.WriteLine("SingleStreamMediaManager.SimplePlayAsync() failed: " + message); SetMediaState(MediaManagerState.Error, message); } State = MediaManagerState.Closing; if (null != reader) { try { await reader.ConfigureAwait(false); } catch (OperationCanceledException) { } catch (Exception ex) { Debug.WriteLine("SingleStreamMediaManager.SimplePlayAsync() reader failed: " + ex.ExtendedMessage()); } } mediaParser.ConfigurationComplete -= configurationComplete; mediaParser.EnableProcessing = false; mediaParser.FlushBuffers(); bufferingManager.Flush(); bufferingManager.Shutdown(throttle); await _mediaStreamConfigurator.CloseAsync().ConfigureAwait(false); } } catch (Exception ex) { Debug.WriteLine("SingleStreamMediaManager.SimplePlayAsync() cleanup failed: " + ex.ExtendedMessage()); } _mediaStreamConfigurator.MediaManager = null; if (!configurationTaskCompletionSource.Task.IsCompleted) configurationTaskCompletionSource.TrySetCanceled(); State = MediaManagerState.Closed; await _reportStateTask.WaitAsync().ConfigureAwait(false); }
Task OpenStream(Action<ISegmentMetadata> setMetadata, CancellationToken cancellationToken) { ThrowIfDisposed(); var webResponse = new WebResponse(); var retry = _retryManager.CreateRetry(2, 200, RetryPolicy.IsWebExceptionRetryable); return retry.CallAsync( async () => { for (;;) { if (_startOffset.HasValue && _endOffset.HasValue) _expectedBytes = _endOffset - _startOffset + 1; else _expectedBytes = null; _response = await _webReader.GetWebStreamAsync(_actualUrl ?? _segment.Url, false, cancellationToken, _segment.ParentUrl, _startOffset, _endOffset, webResponse) .ConfigureAwait(false); if (_response.IsSuccessStatusCode) { _actualUrl = _response.ActualUrl; var contentLength = _response.ContentLength; if (!_endOffset.HasValue) _endOffset = contentLength - 1; if (!_expectedBytes.HasValue) _expectedBytes = contentLength; _responseStream = new PositionStream(await _response.GetStreamAsync(cancellationToken).ConfigureAwait(false)); var filterStreamTask = _segment.CreateFilterAsync(_responseStream, cancellationToken); if (null != filterStreamTask) _readStream = await filterStreamTask.ConfigureAwait(false); else _readStream = _responseStream; var segmentMetadata = _webMetadataFactory.CreateSegmentMetadata(webResponse); setMetadata(segmentMetadata); return; } // Special-case 404s. var statusCode = (HttpStatusCode)_response.HttpStatusCode; if ((HttpStatusCode.NotFound != statusCode) && !RetryPolicy.IsRetryable(statusCode)) _response.EnsureSuccessStatusCode(); var canRetry = await retry.CanRetryAfterDelayAsync(cancellationToken) .ConfigureAwait(false); if (!canRetry) if ((null != _actualUrl) && (_actualUrl != _segment.Url)) _actualUrl = null; else _response.EnsureSuccessStatusCode(); _response.Dispose(); _response = null; } }, cancellationToken); }
public void Close() { var oneStream = ReferenceEquals(_readStream, _responseStream); try { var readStream = _readStream; if (null != readStream) { _readStream = null; using (readStream) { } } } catch (Exception ex) { Debug.WriteLine("SegmentReader.Close() readStream cleanup failed: " + ex.Message); } if (!oneStream) try { var responseStream = _responseStream; if (null != responseStream) { _responseStream = null; using (responseStream) { } } } catch (Exception ex) { Debug.WriteLine("SegmentReader.Close() responseStream cleanup failed: " + ex.Message); } try { var response = _response; if (null != response) { _response = null; using (response) { } } } catch (Exception ex) { Debug.WriteLine("SegmentReader.Close() response cleanup failed: " + ex.Message); } }