public void GetOutputAsync(Action <Exception, string> callback)
{
Ensure.NotNull(callback, "callback");
_callback = callback;
var info = new ProcessStartInfo
{
RedirectStandardOutput = true,
UseShellExecute = false,
CreateNoWindow = true,
FileName = Command,
Arguments = Args ?? string.Empty
};
// note MM: takes time to start a process. no async API available
ThreadPool.QueueUserWorkItem(_ =>
{
Stream inputStream;
try
{
_process = Process.Start(info);
inputStream = _process.StandardOutput.BaseStream;
}
catch (Exception ex)
{
OnCompleted(ex, null);
return;
}
var copier = new AsyncStreamCopier <object>(inputStream, _outputStream, null);
copier.Completed += OnStreamCopied;
copier.Start();
});
}
/// <inheritdoc />
public override void ReverseProcessDataStream(Stream inStream, Stream outStream, Dictionary <string, string> options, out long writtenBytes)
{
using (GZipInputStream zip = new GZipInputStream(inStream))
AsyncStreamCopier.CopyStreamTo(zip, outStream);
writtenBytes = outStream.Position;
}
private void ResponseAcquired(IAsyncResult ar)
{
var state = (ClientOperationState)ar.AsyncState;
try
{
var response = (HttpWebResponse)state.Request.EndGetResponseExtended(ar);
var networkStream = response.GetResponseStream();
if (networkStream == null)
{
throw new ArgumentNullException("networkStream", "Response stream was null");
}
state.Response = new HttpResponse(response);
state.InputStream = networkStream;
state.OutputStream = new MemoryStream();
var copier = new AsyncStreamCopier <ClientOperationState>(state.InputStream, state.OutputStream, state);
copier.Completed += ResponseRead;
copier.Start();
}
catch (Exception e)
{
state.DisposeIOStreams();
state.OnError(e);
}
}
private void RequestRead(AsyncStreamCopier <ManagerOperationState> copier)
{
var state = copier.AsyncState;
if (copier.Error != null)
{
state.Dispose();
CloseConnection(exc =>
Log.Debug("Close connection error (after crash in read request): {e}", exc.Message));
state.OnError(copier.Error);
return;
}
state.OutputStream.Seek(0, SeekOrigin.Begin);
var memory = (MemoryStream)state.OutputStream;
var request = memory.GetBuffer();
if (memory.Length != memory.GetBuffer().Length)
{
request = new byte[memory.Length];
Buffer.BlockCopy(memory.GetBuffer(), 0, request, 0, (int)memory.Length);
}
LogRequest(request);
state.OnReadSuccess(this, request);
}
public async Task CopyToAsync(Stream outputStream, CancellationToken cancellationToken)
{
if (!_enableFileBuffer)
{
await _multicastStream.CopyToAsync(outputStream, cancellationToken).ConfigureAwait(false);
return;
}
var path = _tempFilePath;
long startPosition = -20000;
if (startPosition < 0)
{
var length = FileSystem.GetFileInfo(path).Length;
startPosition = Math.Max(length - startPosition, 0);
}
_logger.Info("Live stream starting position is {0} bytes", startPosition.ToString(CultureInfo.InvariantCulture));
var allowAsync = Environment.OperatingSystem != MediaBrowser.Model.System.OperatingSystem.Windows;
// use non-async filestream along with read due to https://github.com/dotnet/corefx/issues/6039
using (var inputStream = GetInputStream(path, startPosition, allowAsync))
{
if (startPosition > 0)
{
inputStream.Position = startPosition;
}
while (!cancellationToken.IsCancellationRequested)
{
long bytesRead;
if (allowAsync)
{
bytesRead = await AsyncStreamCopier.CopyStream(inputStream, outputStream, 81920, 2, cancellationToken).ConfigureAwait(false);
}
else
{
StreamHelper.CopyTo(inputStream, outputStream, 81920, cancellationToken);
bytesRead = 1;
}
//var position = fs.Position;
//_logger.Debug("Streamed {0} bytes to position {1} from file {2}", bytesRead, position, path);
if (bytesRead == 0)
{
await Task.Delay(100, cancellationToken).ConfigureAwait(false);
}
}
}
}
/// <inheritdoc />
public override void ForwardProcessDataStream(Stream inStream, Stream outStream, Dictionary <string, string> options, out long writtenBytes)
{
using (GZipOutputStream gzStream = new GZipOutputStream(outStream))
{
gzStream.IsStreamOwner = false;
AsyncStreamCopier.CopyStreamTo(inStream, gzStream);
}
writtenBytes = outStream.Position;
}
public void ReadRequestAsync(Action<HttpEntityManager, byte[]> onReadSuccess, Action<Exception> onError)
{
Ensure.NotNull(onReadSuccess, "OnReadSuccess");
Ensure.NotNull(onError, "onError");
var state = new ManagerOperationState(
HttpEntity.Request.InputStream, new MemoryStream(), onReadSuccess, onError);
var copier = new AsyncStreamCopier<ManagerOperationState>(
state.InputStream, state.OutputStream, state, RequestRead);
copier.Start();
}
public static void NetToFile_Option2(NetworkStream net, FileStream file)
{
var completedEvent = new ManualResetEvent(false);
// copy as usual but listen for completion
var copier = new AsyncStreamCopier(net, file);
copier.Completed += (s, e) => completedEvent.Set();
copier.Start();
completedEvent.WaitOne();
}
//Will be a post if postPayload is not blank otherwise it will be a get
public static JObject Http(String sUrl, String sUsername, String sPassword, JObject postObj, AddMessageCallback AMessageCallback)
{
ServicePointManager.SecurityProtocol = SecurityProtocolType.Tls12;
try
{
//Build the web request that will act as a "web service client"
AMessageCallback(sUrl);
HttpWebRequest loHttp = (HttpWebRequest)WebRequest.Create(sUrl);
loHttp.Timeout = 5 * 60 * 1000;
loHttp.Credentials = new NetworkCredential(sUsername, sPassword);
if (postObj != null)
{
// set request body
String postPayload = JsonConvert.SerializeObject(postObj, Formatting.Indented);
loHttp.ContentType = "application/json";
loHttp.Method = "POST";
AMessageCallback(postPayload);
using (StreamWriter writer = new StreamWriter(loHttp.GetRequestStream())) writer.Write(postPayload);
}
else
{
loHttp.Method = "GET";
}
ServicePointManager.ServerCertificateValidationCallback += delegate(object sender, X509Certificate certificate, X509Chain chain, SslPolicyErrors sslPolicyErrors)
{
return(true);
};
//Get the response and load it into a buffer stream
HttpWebResponse loWebResponse = (HttpWebResponse)loHttp.GetResponse();
//Copy the contents asynchronously for fastest performance
MemoryStream memSt = new MemoryStream();
AsyncStreamCopier aCopy = new AsyncStreamCopier(loWebResponse.GetResponseStream(), memSt);
aCopy.StartAndWaitForCompletion();
//Send the response conent back to the caller
loWebResponse.Close();
JObject retVal = JsonConvert.DeserializeObject <JObject>(ASCIIEncoding.ASCII.GetString(memSt.ToArray()));
//Format the json to be "pretty"
AMessageCallback(JsonConvert.SerializeObject(retVal, Formatting.Indented));
return(retVal);
}
catch (WebException exp)
{
throw new Exception(String.Format("Error processing request: {0}, Response: {1}", exp.Message, GetResponseContent(exp.Response)));
}
}
private void WriteResponseAsync(byte[] response, Action <Exception> onError)
{
SetResponseLength(response.Length);
var state = new ManagerOperationState(HttpEntity, (sender, e) => {}, onError)
{
InputStream = new MemoryStream(response),
OutputStream = HttpEntity.Response.OutputStream
};
var copier = new AsyncStreamCopier <ManagerOperationState>(state.InputStream, state.OutputStream, state);
copier.Completed += ResponseWritten;
copier.Start();
}
private void RequestWrote(AsyncStreamCopier <ClientOperationState> copier)
{
var state = copier.AsyncState;
var httpRequest = state.Request;
if (copier.Error != null)
{
state.DisposeIOStreams();
state.OnError(copier.Error);
return;
}
state.DisposeIOStreams();
httpRequest.BeginGetResponse(ResponseAcquired, state);
}
public void ReadRequestAsync(Action <HttpEntityManager, string> onSuccess, Action <Exception> onError)
{
Ensure.NotNull(onSuccess, "onSuccess");
Ensure.NotNull(onError, "onError");
var state = new ManagerOperationState(HttpEntity, onSuccess, onError)
{
InputStream = HttpEntity.Request.InputStream,
OutputStream = new MemoryStream()
};
var copier = new AsyncStreamCopier <ManagerOperationState>(state.InputStream, state.OutputStream, state);
copier.Completed += RequestRead;
copier.Start();
}
private void GotRequestStream(IAsyncResult ar)
{
var state = (ClientOperationState)ar.AsyncState;
try
{
var networkStream = state.Request.EndGetRequestStream(ar);
state.OutputStream = networkStream;
var copier = new AsyncStreamCopier <ClientOperationState>(state.InputStream, networkStream, state, RequestWrote);
copier.Start();
}
catch (Exception e)
{
state.DisposeIOStreams();
state.OnError(e);
}
}
private void ResponseRead(AsyncStreamCopier <ClientOperationState> copier)
{
var state = copier.AsyncState;
if (copier.Error != null)
{
state.DisposeIOStreams();
state.OnError(copier.Error);
return;
}
state.OutputStream.Seek(0, SeekOrigin.Begin);
var memStream = (MemoryStream)state.OutputStream;
state.Response.Body = Helper.UTF8NoBom.GetString(memStream.GetBuffer(), 0, (int)memStream.Length);
state.DisposeIOStreams();
state.OnSuccess(state.Response);
}
public void ReadRequestAsync(Action<HttpEntityManager, byte[]> onReadSuccess, Action<Exception> onError)
{
Ensure.NotNull(onReadSuccess, "OnReadSuccess");
Ensure.NotNull(onError, "onError");
var state = new ManagerOperationState(
HttpEntity.Request.InputStream, new MemoryStream(), onReadSuccess, onError);
var copier = new AsyncStreamCopier<ManagerOperationState>(
state.InputStream, state.OutputStream, state, RequestRead);
copier.Start();
}
public static void NetToFile(NetworkStream net, FileStream file)
{
var copier = new AsyncStreamCopier(net, file);
copier.Start();
}
private void RequestWrote(AsyncStreamCopier<ClientOperationState> copier)
{
var state = copier.AsyncState;
var httpRequest = state.Request;
if (copier.Error != null)
{
state.DisposeIOStreams();
state.OnError(copier.Error);
return;
}
state.DisposeIOStreams();
httpRequest.BeginGetResponse(ResponseAcquired, state);
}
private void ResponseRead(AsyncStreamCopier<ClientOperationState> copier)
{
var state = copier.AsyncState;
if (copier.Error != null)
{
state.DisposeIOStreams();
state.OnError(copier.Error);
return;
}
state.OutputStream.Seek(0, SeekOrigin.Begin);
var memStream = (MemoryStream)state.OutputStream;
state.Response.Body = Helper.UTF8NoBom.GetString(memStream.GetBuffer(), 0, (int) memStream.Length);
state.DisposeIOStreams();
state.OnSuccess(state.Response);
}
private void TransformAndRun(System.Net.HttpListenerRequest clientRequest, ServerResponse serverResponse, Func<Uri, Uri> transformUri, Action<WebResponse, ServerResponse> OnComplete)
{
var proxyRequest = (HttpWebRequest)HttpWebRequest.Create(transformUri(clientRequest.Url));
proxyRequest.SendChunked = false;
proxyRequest.Accept = clientRequest.Headers["Accept"];
proxyRequest.UserAgent = clientRequest.Headers["User-Agent"];
proxyRequest.Referer = clientRequest.Headers["Referer"];
proxyRequest.CookieContainer = new CookieContainer();
foreach (Cookie cookie in clientRequest.Cookies)
{
try
{
cookie.Domain = proxyRequest.RequestUri.Host;
proxyRequest.CookieContainer.Add(cookie);
}
catch (Exception ex)
{
_log.Warning("Falied to proxy cookie {0} \r\n {1}", cookie, ex.Message);
}
}
foreach (string item in clientRequest.Headers)
{
try
{
if (!_excludedRequestHeaders.Contains(item))
proxyRequest.Headers.Add(item, clientRequest.Headers[item]);
}
catch (Exception)
{
_log.Warning("Failed to copy Header {0} with Value {1}", item, clientRequest.Headers[item]);
}
}
proxyRequest.Method = clientRequest.HttpMethod;
proxyRequest.ContentLength = clientRequest.ContentLength64;
proxyRequest.ContentType = clientRequest.ContentType;
proxyRequest.Headers.Add("X-Forwarded-For", clientRequest.UserHostAddress);
AsyncCallback callback = (requestResult) =>
{
var asyncState = requestResult.AsyncState as Tuple<ServerResponse, Action<WebResponse, ServerResponse>>;
var response = asyncState.Item1;
var OnCompleteCallback = asyncState.Item2;
try
{
var requestResponse = proxyRequest.EndGetResponse(requestResult);
OnCompleteCallback(requestResponse, response);
}
catch (WebException ex)
{
var httpresponse = ex.Response as HttpWebResponse;
if (httpresponse != null)
{
_log.Info("Server returned Status {0} for URL {1}", httpresponse.StatusCode, httpresponse.ResponseUri);
response.StatusCode = (int)httpresponse.StatusCode;
response.StatusDescription = httpresponse.StatusDescription;
var copier = new AsyncStreamCopier(httpresponse.GetResponseStream(), response.OutputStream);
copier.Completed += (sender, e) =>
{
response.Close();
httpresponse.Close();
};
copier.Copy();
}
else
{
_log.Error(ex);
ex.Response.Close();
response.Do503(ex).Close();
}
}
catch (Exception ex)
{
_log.Error(ex);
response.Do503(ex).Close();
}
};
var state = Tuple.Create(serverResponse, OnComplete);
if (proxyRequest.Method != "GET")
{
var copier = new AsyncStreamCopier(clientRequest.InputStream, proxyRequest.GetRequestStream());
copier.Completed += (sender, a) => proxyRequest.BeginGetResponse(callback, state);
copier.Copy();
}
else
{
proxyRequest.BeginGetResponse(callback, state);
}
}
private void ResponseAcquired(IAsyncResult ar)
{
var state = (ClientOperationState)ar.AsyncState;
try
{
var response = (HttpWebResponse)state.Request.EndGetResponseExtended(ar);
var networkStream = response.GetResponseStream();
if (networkStream == null)
throw new ArgumentNullException("networkStream", "Response stream was null");
state.Response = new HttpResponse(response);
state.InputStream = networkStream;
state.OutputStream = new MemoryStream();
var copier = new AsyncStreamCopier<ClientOperationState>(state.InputStream, state.OutputStream, state);
copier.Completed += ResponseRead;
copier.Start();
}
catch (Exception e)
{
state.DisposeIOStreams();
state.OnError(e);
}
}
private void GotRequestStream(IAsyncResult ar)
{
var state = (ClientOperationState)ar.AsyncState;
try
{
var networkStream = state.Request.EndGetRequestStream(ar);
state.OutputStream = networkStream;
var copier = new AsyncStreamCopier<ClientOperationState>(state.InputStream, networkStream, state);
copier.Completed += RequestWrote;
copier.Start();
}
catch (Exception e)
{
state.DisposeIOStreams();
state.OnError(e);
}
}
public void HandleRequest(System.Net.HttpListenerRequest req, ServerResponse res)
{
try
{
_log.Verbose("Handling request for {0} from {1}", req.Url, req.RemoteEndPoint.Address);
TransformAndRun(req, res, (toTransform) => new Uri(_config.UpstreamUrl + toTransform.PathAndQuery),
(requestResponse, serverResponse) =>
{
try
{
if (requestResponse.ContentLength > -1)
serverResponse.ContentLength64 = requestResponse.ContentLength;
foreach (string item in requestResponse.Headers)
{
try
{
if (!_excludedResponseHeaders.Contains(item))
serverResponse.Headers.Add(item, requestResponse.Headers[item]);
}
catch (Exception ex)
{
_log.Warning("Failed to copy Header {0} with Value {1} \r\n {2}", item, requestResponse.Headers[item], ex.Message);
}
}
if(requestResponse.ContentType.StartsWith("text/html", StringComparison.InvariantCultureIgnoreCase)
|| requestResponse.ContentType.StartsWith("text/javascript", StringComparison.InvariantCultureIgnoreCase)
|| requestResponse.ContentType.StartsWith("text/css", StringComparison.InvariantCultureIgnoreCase))
{
var buffer = new MemoryStream();
var rewriter = new AsyncUrlRewriter(requestResponse.GetResponseStream(), buffer,
Encoding.UTF8, _config.UpstreamUrl, _config.OwnUrl);
rewriter.OnException += (sender, e) =>
{
e.Data.Cancel = true;
_log.Error(e.Data.Exception);
try
{
serverResponse.Close();
requestResponse.Close();
}
catch (Exception ex)
{
_log.Error(ex);
}
};
rewriter.Completed += (sender, e) =>
{
serverResponse.ContentLength64 = buffer.Length;
buffer.Position = 0;
var copier = new AsyncStreamCopier(buffer, serverResponse.OutputStream);
copier.Completed += (s, a) =>
{
buffer.Close();
serverResponse.Close();
requestResponse.Close();
};
copier.Copy();
};
rewriter.Copy();
}
else
{
var copier = new AsyncStreamCopier(requestResponse.GetResponseStream(), serverResponse.OutputStream);
copier.Completed += (sender, e) =>
{
serverResponse.Close();
requestResponse.Close();
};
copier.Copy();
}
}
catch (Exception ex)
{
_log.Error(ex);
serverResponse.Do503(ex).Close();
requestResponse.Close();
}
});
}
catch (Exception ex)
{
_log.Error(ex);
res.Do503(ex).Close(); ;
}
}
private void WriteResponseAsync(byte[] response, Action<Exception> onError)
{
SetResponseLength(response.Length);
var state = new ManagerOperationState(HttpEntity, (sender, e) => {}, onError)
{
InputStream = new MemoryStream(response),
OutputStream = HttpEntity.Response.OutputStream
};
var copier = new AsyncStreamCopier<ManagerOperationState>(state.InputStream, state.OutputStream, state);
copier.Completed += ResponseWritten;
copier.Start();
}
public void ReadRequestAsync(Action<HttpEntityManager, string> onSuccess, Action<Exception> onError)
{
Ensure.NotNull(onSuccess, "onSuccess");
Ensure.NotNull(onError, "onError");
var state = new ManagerOperationState(HttpEntity, onSuccess, onError)
{
InputStream = HttpEntity.Request.InputStream,
OutputStream = new MemoryStream()
};
var copier = new AsyncStreamCopier<ManagerOperationState>(state.InputStream, state.OutputStream, state);
copier.Completed += RequestRead;
copier.Start();
}
private void RequestRead(AsyncStreamCopier<ManagerOperationState> copier)
{
var state = copier.AsyncState;
if (copier.Error != null)
{
state.Dispose();
CloseConnection(exc => Log.Debug("Close connection error (after crash in read request): {0}", exc.Message));
state.OnError(copier.Error);
return;
}
state.OutputStream.Seek(0, SeekOrigin.Begin);
var memory = (MemoryStream) state.OutputStream;
var request = memory.GetBuffer();
if (memory.Length != memory.GetBuffer().Length)
{
request = new byte[memory.Length];
Buffer.BlockCopy(memory.GetBuffer(), 0, request, 0, (int) memory.Length);
}
state.OnReadSuccess(this, request);
}
public void GetOutputAsync(Action<Exception, string> callback)
{
Ensure.NotNull(callback, "callback");
_callback = callback;
var info = new ProcessStartInfo
{
RedirectStandardOutput = true,
UseShellExecute = false,
CreateNoWindow = true,
FileName = Command,
Arguments = Args ?? string.Empty
};
// note MM: takes time to start a process. no async API available
ThreadPool.QueueUserWorkItem(_ =>
{
Stream inputStream;
try
{
_process = Process.Start(info);
inputStream = _process.StandardOutput.BaseStream;
}
catch (Exception ex)
{
OnCompleted(ex, null);
return;
}
var copier = new AsyncStreamCopier<object>(inputStream, _outputStream, null);
copier.Completed += OnStreamCopied;
copier.Start();
});
}
