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