/// <summary>
/// see ref=<see cref="Open"/>
/// HttpServer.HttpRequesting += OnRequest
/// </summary>
private void OnRequest(object sender, EventHttpRequestArgs e)
{
try
{
if (OnRequesting(e.Request, e.Response))
{
var item = Routes.GetAgent(e.Request.BaseUrl);
if (item == null)
{
BadGateway result = new BadGateway("Cluster server unavailable");
EventResponseErrorArgs error = new EventResponseErrorArgs(
e.Request, e.Response, result, BadGateway.CLUSTER_SERVER_UNAVAILABLE
);
OnResponseError(error);
}
else
{
item.Execute(e.Request, e.Response);
}
}
}
catch (Exception e_)
{
if (HttpServer.EnableLog(BeetleX.EventArgs.LogType.Error))
{
HttpServer.Log(BeetleX.EventArgs.LogType.Error,
$"gateway process {e.Request.RemoteIPAddress} {e.Request.Method} {e.Request.BaseUrl} error {e_.Message}@{e_.StackTrace}");
}
}
finally
{
e.Cancel = true;
}
}
private void OnSocketError(IClient c, ClientErrorArgs e)
{
HttpApiServer httpApiServer = Server.Gateway.HttpServer;
if (httpApiServer.EnableLog(BeetleX.EventArgs.LogType.Error))
{
httpApiServer.Log(BeetleX.EventArgs.LogType.Error, $"gateway request {Server.Host}:{Server.Port} error {e.Message}@{e.Error.InnerException?.Message} status {Status}");
}
if (Status == RequestStatus.Requesting)
{
EventResponseErrorArgs erea;
if (e.Error is SocketException)
{
Code = Gateway.SERVER_SOCKET_ERROR;
erea = new EventResponseErrorArgs(Request, Response, UrlRoute.Gateway, e.Error.Message, Gateway.SERVER_SOCKET_ERROR);
}
else
{
Code = Gateway.SERVER_PROCESS_ERROR_CODE;
erea = new EventResponseErrorArgs(Request, Response, UrlRoute.Gateway, e.Error.Message, Gateway.SERVER_PROCESS_ERROR_CODE);
}
OnCompleted(erea);
}
else
{
Code = Gateway.SERVER_OTHRER_ERROR_CODE;
if (Status > RequestStatus.None)
{
OnCompleted(null);
}
}
}
private void OnCompleted(EventResponseErrorArgs error)
{
if (System.Threading.Interlocked.CompareExchange(ref mCompletedStatus, 1, 0) == 0)
{
mClientAgent.Client.ClientError = null;
mClientAgent.Client.DataReceive = null;
Server.Push(mClientAgent);
try
{
Completed?.Invoke(this);
}
catch (Exception e_)
{
if (Request.Server.EnableLog(BeetleX.EventArgs.LogType.Error))
{
Request.Server.Log(BeetleX.EventArgs.LogType.Error, $"gateway request {Server.Host}:{Server.Port} process completed event error {e_.Message}");
}
}
finally
{
Request.ClearStream();
if (error != null)
{
Server.Gateway.OnResponseError(error);
}
else
{
Request.Recovery();
}
}
}
}
internal void OnResponseError(EventResponseErrorArgs e)
{
if (HttpServer.EnableLog(BeetleX.EventArgs.LogType.Warring))
{
HttpServer.Log(BeetleX.EventArgs.LogType.Warring, $"Gateway {e.Request.ID} {e.Request.RemoteIPAddress} {e.Request.Method} {e.Request.Url} error {e.Message}");
}
if (Pluginer.RequestedEnabled)
{
EventRequestCompletedArgs se = new EventRequestCompletedArgs(
null,
e.Request,
e.Response,
this,
e.ErrorCode,
null,
1,
e.Request.ID,
e.Message
);
Pluginer.Requested(se);
}
IncrementRequestCompleted(e.Request, e.ErrorCode, 1, null);
this.Pluginer.ResponseError(e);
if (e.Result != null)
{
e.Response.Result(e.Result);
}
}
internal void OnResponseError(EventResponseErrorArgs e)
{
ResponseError?.Invoke(this, e);
if (e.Result != null)
{
e.Response.Result(e.Result);
}
}
internal void OnCompleted(EventResponseErrorArgs error)
{
if (System.Threading.Interlocked.CompareExchange(ref mCompletedStatus, 1, 0) == 0)
{
this.ResponseError = error;
Time = (long)(TimeWatch.GetTotalMilliseconds() - Request.RequestTime);
mClientAgent.Client.ClientError = null;
mClientAgent.Client.DataReceive = null;
mClientAgent.Status = TcpClientAgentStatus.ResponseSuccess;
//System.Threading.Interlocked.Decrement(ref RequestCount);
//mHistoryRequests.Remove(mRequestID, out RequestAgent value);
try
{
if (Code >= 500)
{
if (Request.Server.EnableLog(BeetleX.EventArgs.LogType.Warring))
{
Request.Server.Log(BeetleX.EventArgs.LogType.Warring, $"gateway {Request.ID} {Request.RemoteIPAddress} {Request.Method} {Request.Url} -> {Server.Host}:{Server.Port} completed code {Code} use time:{Time}ms");
}
}
else
{
if (Request.Server.EnableLog(BeetleX.EventArgs.LogType.Info))
{
Request.Server.Log(BeetleX.EventArgs.LogType.Info, $"gateway {Request.ID} {Request.RemoteIPAddress} {Request.Method} {Request.Url} -> {Server.Host}:{Server.Port} completed code {Code} use time:{Time}ms");
}
}
if (UrlRoute.Pluginer.RequestedEnabled)
{
UrlRoute.Pluginer.Requested(this.GetEventRequestCompletedArgs());
}
Completed?.Invoke(this);
}
catch (Exception e_)
{
if (Request.Server.EnableLog(BeetleX.EventArgs.LogType.Error))
{
Request.Server.Log(BeetleX.EventArgs.LogType.Error, $"gateway {Request.ID} {Request.RemoteIPAddress} {Request.Method} {Request.Url} -> {Server.Host}:{Server.Port} completed event error {e_.Message}@{e_.StackTrace}");
}
}
finally
{
Request.ClearStream();
if (error != null)
{
Server.Gateway.OnResponseError(error);
}
else
{
Request.Recovery();
}
FlushProxyStream(true);
Server.Push(mClientAgent);
}
}
}
public void Exeucte(EventResponseErrorArgs e)
{
var code = e.ErrorCode;
logger.Error(e.Result);
if (code == 591 || code == 590)//转发的接口地址不可访问
{
Console.WriteLine($"错误码：{e.ErrorCode}");
e.Result = new BadMessage("访问出错,所访问的地址不可用");
}
e.Result = new BadMessage("访问出错");
}
public void ResponseError(EventResponseErrorArgs e)
{
var items = responseErrorHandlers;
if (items.Length > 0)
{
for (int i = 0; i < items.Length; i++)
{
items[i].Exeucte(e);
}
}
}
internal void OnResponseError(EventResponseErrorArgs e)
{
if (HttpServer.EnableLog(BeetleX.EventArgs.LogType.Warring))
{
HttpServer.Log(BeetleX.EventArgs.LogType.Warring, $"gateway {e.Request.RemoteIPAddress} {e.Request.Method} {e.Request.Url} error {e.Message}");
}
HttpServer.RequestExecuted();
ResponseError?.Invoke(this, e);
if (e.Result != null)
{
e.Response.Result(e.Result);
}
}
public void ResponseError(EventResponseErrorArgs e)
{
var items = responseErrorHandlers;
if (items.Length > 0)
{
for (int i = 0; i < items.Length; i++)
{
if (Gateway.PluginCenter.PluginIsEnabled(items[i]))
{
items[i].Exeucte(e);
}
}
}
}
private void OnRequest(object sender, EventHttpRequestArgs e)
{
var url = e.Request.BaseUrl;
if (url.Length > 2 && url[1] == '_' && url[2] == '_')
{
return;
}
try
{
var ip = e.Request.RemoteIPAddress;
HttpServer.RequestExecting();
if (this.Pluginer.Requesting(e.Request, e.Response))
{
var item = Routes.GetAgent(e.Request);
if (item == null)
{
EventResponseErrorArgs error = new EventResponseErrorArgs(
e.Request, e.Response, this, "Cluster server unavailable", Gateway.CLUSTER_SERVER_UNAVAILABLE
);
OnResponseError(error);
}
else
{
if (item.UrlRoute.Pluginer.Requesting(e.Request, e.Response))
{
item.Execute(e.Request, e.Response);
}
}
}
}
catch (Exception e_)
{
if (HttpServer.EnableLog(BeetleX.EventArgs.LogType.Error))
{
HttpServer.Log(BeetleX.EventArgs.LogType.Error,
$"gateway process {e.Request.RemoteIPAddress} {e.Request.Method} {e.Request.BaseUrl} error {e_.Message}@{e_.StackTrace}");
}
}
finally
{
e.Cancel = true;
}
}
private void OnCompleted(EventResponseErrorArgs error)
{
if (System.Threading.Interlocked.CompareExchange(ref mCompletedStatus, 1, 0) == 0)
{
Time = TimeWatch.GetElapsedMilliseconds() - mStartTime;
mClientAgent.Client.ClientError = null;
mClientAgent.Client.DataReceive = null;
Server.Push(mClientAgent);
//System.Threading.Interlocked.Decrement(ref RequestCount);
//mHistoryRequests.Remove(mRequestID, out RequestAgent value);
try
{
if (Request.Server.EnableLog(BeetleX.EventArgs.LogType.Info))
{
Request.Server.Log(BeetleX.EventArgs.LogType.Info, $"gateway {Request.RemoteIPAddress} {Request.Method} {Request.Url} request {Server.Host}:{Server.Port} process completed code {Code} time:{Time}");
}
UrlRoute.Pluginer.Requested(this);
Completed?.Invoke(this);
}
catch (Exception e_)
{
if (Request.Server.EnableLog(BeetleX.EventArgs.LogType.Error))
{
Request.Server.Log(BeetleX.EventArgs.LogType.Error, $"gateway {Request.RemoteIPAddress} {Request.Method} {Request.Url} request {Server.Host}:{Server.Port} process completed event error {e_.Message}@{e_.StackTrace}");
}
}
finally
{
Request.ClearStream();
if (error != null)
{
Server.Gateway.OnResponseError(error);
}
else
{
Request.Recovery();
}
}
}
}
public void ResponseError(EventResponseErrorArgs e)
{
var items = responseErrorHandlers;
if (items.Length > 0)
{
for (int i = 0; i < items.Length; i++)
{
if (Gateway.PluginCenter.PluginIsEnabled(items[i]))
{
try
{
items[i].Exeucte(e);
}
catch (Exception e_)
{
Gateway.HttpServer.GetLog(LogType.Error)?
.Log(LogType.Error, $"gateway {e.Request.ID} {e.Request.RemoteIPAddress} {e.Request.Method} {e.Request.GetSourceUrl()} {items[i].Name} response error plugin process error {e_.Message}@{e_.StackTrace}");
}
}
}
}
}
private void OnRequest(object sender, EventHttpRequestArgs e)
{
try
{
e.Cancel = true;
var ip = e.Request.RemoteIPAddress;
if (HttpServer.EnableLog(LogType.Info))
{
HttpServer.Log(LogType.Info, $"Gateway {e.Request.ID} {e.Request.Method} {e.Request.Url} request from {ip}");
}
HttpServer.RequestExecting();
var result = this.Pluginer.Requesting(e.Request, e.Response);
if (result.Item1)
{
var item = Routes.GetAgent(e.Request);
if (item == null)
{
if (HttpServer.EnableLog(LogType.Info))
{
HttpServer.Log(LogType.Info, $"Gateway {e.Request.ID} {e.Request.RemoteIPAddress} {e.Request.Method} {e.Request.Url} request cluster server unavailable");
}
EventResponseErrorArgs error = new EventResponseErrorArgs(
e.Request, e.Response, this, "Cluster server unavailable", Gateway.CLUSTER_SERVER_UNAVAILABLE
);
OnResponseError(error);
}
else
{
result = item.UrlRoute.Pluginer.Requesting(e.Request, e.Response);
if (result.Item1)
{
if (HttpServer.EnableLog(LogType.Info))
{
HttpServer.Log(LogType.Info, $"Gateway {e.Request.ID} {e.Request.RemoteIPAddress} {e.Request.Method} {e.Request.Url} request {item.UrlRoute.Url}'s route executing");
}
if (IOQueue.Count > GatewayQueueSize)
{
Events.EventResponseErrorArgs erea = new Events.EventResponseErrorArgs(
e.Request, e.Response, this, $"The gateway queue overflow!", Gateway.GATEWAY_QUEUE_OVERFLOW);
this.OnResponseError(erea);
}
else
{
AddRequest(new Tuple <UrlRouteAgent, HttpRequest, HttpResponse>(item, e.Request, e.Response));
}
}
else
{
if (HttpServer.EnableLog(LogType.Info))
{
HttpServer.Log(LogType.Info, $"Gateway {e.Request.ID} {e.Request.RemoteIPAddress} {e.Request.Method} {e.Request.Url} request {item.UrlRoute.Url}'s route executing cancel!");
}
e.Cancel = result.Item2 == ResultType.Completed;
return;
}
}
}
else
{
if (HttpServer.EnableLog(LogType.Info))
{
HttpServer.Log(LogType.Info, $"Gateway {e.Request.ID} {e.Request.RemoteIPAddress} {e.Request.Method} {e.Request.Url} request gateway executing cancel!");
}
e.Cancel = result.Item2 == ResultType.Completed;
return;
}
}
catch (Exception e_)
{
if (HttpServer.EnableLog(BeetleX.EventArgs.LogType.Error))
{
HttpServer.Log(BeetleX.EventArgs.LogType.Error,
$"Gateway {e.Request.ID} {e.Request.RemoteIPAddress} {e.Request.Method} {e.Request.BaseUrl} process error {e_.Message}@{e_.StackTrace}");
}
}
}
public void Execute()
{
var request = Request;
if (!string.IsNullOrEmpty(this.UrlRoute.PrefixUrl))
{
System.Text.RegularExpressions.Regex r = new System.Text.RegularExpressions.Regex($"/{this.UrlRoute.PrefixUrl.Trim('/')}", System.Text.RegularExpressions.RegexOptions.IgnoreCase);
request.Url = r.Replace(request.Url, "", 1, 0);
request.BaseUrl = r.Replace(request.BaseUrl, "", 1, 0);
}
var response = Response;
Status = RequestStatus.Requesting;
mClientAgent.Client.Connect();
if (mClientAgent.Client.IsConnected)
{
try
{
PipeStream pipeStream = mClientAgent.Client.Stream.ToPipeStream();
byte[] buffer = mBuffer;
int offset = 0;
var len = Encoding.UTF8.GetBytes(request.Method, 0, request.Method.Length, buffer, offset);
offset += len;
buffer[offset] = HeaderTypeFactory._SPACE_BYTE;
offset++;
len = Encoding.UTF8.GetBytes(request.Url, 0, request.Url.Length, buffer, offset);
offset += len;
buffer[offset] = HeaderTypeFactory._SPACE_BYTE;
offset++;
for (int i = 0; i < HeaderTypeFactory.HTTP_V11_BYTES.Length; i++)
{
buffer[offset + i] = HeaderTypeFactory.HTTP_V11_BYTES[i];
}
offset += HeaderTypeFactory.HTTP_V11_BYTES.Length;
buffer[offset] = HeaderTypeFactory._LINE_R;
offset++;
buffer[offset] = HeaderTypeFactory._LINE_N;
offset++;
pipeStream.Write(buffer, 0, offset);
request.Header.Write(pipeStream);
pipeStream.Write(HeaderTypeFactory.LINE_BYTES, 0, 2);
int bodylength = request.Length;
while (bodylength > 0)
{
len = request.Stream.Read(buffer, 0, buffer.Length);
pipeStream.Write(buffer, 0, len);
bodylength -= len;
}
Status = RequestStatus.Responding;
mClientAgent.Client.Stream.Flush();
}
catch (Exception e_)
{
string error = $" request to {Server.Host}:{Server.Port} error {e_.Message}@{e_.StackTrace}";
EventResponseErrorArgs eventResponseErrorArgs =
new EventResponseErrorArgs(request, response, UrlRoute.Gateway, error, Gateway.SERVER_SOCKET_ERROR);
try
{
if (mClientAgent.Client != null)
{
mClientAgent.Client.DisConnect();
}
}
finally
{
OnCompleted(eventResponseErrorArgs);
}
return;
}
}
}
public void Execute()
{
var request = Request;
var response = Response;
Status = RequestStatus.Requesting;
mClientAgent.Client.Connect();
if (mClientAgent.Client.IsConnected)
{
try
{
if (Request.Server.EnableLog(BeetleX.EventArgs.LogType.Info))
{
Request.Server.Log(BeetleX.EventArgs.LogType.Info, $"gateway {Request.RemoteIPAddress} {Request.Method} {Request.Url} request {Server.Host}:{Server.Port} netstream writing");
}
PipeStream pipeStream = mClientAgent.Client.Stream.ToPipeStream();
byte[] buffer = mBuffer;
int offset = 0;
var len = Encoding.UTF8.GetBytes(request.Method, 0, request.Method.Length, buffer, offset);
offset += len;
buffer[offset] = HeaderTypeFactory._SPACE_BYTE;
offset++;
len = Encoding.UTF8.GetBytes(request.Url, 0, request.Url.Length, buffer, offset);
offset += len;
buffer[offset] = HeaderTypeFactory._SPACE_BYTE;
offset++;
for (int i = 0; i < HeaderTypeFactory.HTTP_V11_BYTES.Length; i++)
{
buffer[offset + i] = HeaderTypeFactory.HTTP_V11_BYTES[i];
}
offset += HeaderTypeFactory.HTTP_V11_BYTES.Length;
buffer[offset] = HeaderTypeFactory._LINE_R;
offset++;
buffer[offset] = HeaderTypeFactory._LINE_N;
offset++;
pipeStream.Write(buffer, 0, offset);
request.Header.Write(pipeStream);
pipeStream.Write(HeaderTypeFactory.LINE_BYTES, 0, 2);
int bodylength = request.Length;
while (bodylength > 0)
{
len = request.Stream.Read(buffer, 0, buffer.Length);
if (len == 0)
{
Code = Gateway.SERER_READ_STREAM_ERROR;
EventResponseErrorArgs eventResponseErrorArgs =
new EventResponseErrorArgs(request, response, UrlRoute.Gateway, "read request stream error", Gateway.SERVER_SOCKET_ERROR);
OnCompleted(eventResponseErrorArgs);
return;
}
else
{
pipeStream.Write(buffer, 0, len);
bodylength -= len;
}
}
Status = RequestStatus.Responding;
mClientAgent.Client.Stream.Flush();
if (Request.Server.EnableLog(BeetleX.EventArgs.LogType.Info))
{
Request.Server.Log(BeetleX.EventArgs.LogType.Info, $"gateway {Request.RemoteIPAddress} {Request.Method} {Request.Url} request {Server.Host}:{Server.Port} netstream writed");
}
}
catch (Exception e_)
{
string error = $" request to {Server.Host}:{Server.Port} error {e_.Message}";
EventResponseErrorArgs eventResponseErrorArgs =
new EventResponseErrorArgs(request, response, UrlRoute.Gateway, error, Gateway.SERVER_SOCKET_ERROR);
if (Request.Server.EnableLog(BeetleX.EventArgs.LogType.Info))
{
Request.Server.Log(BeetleX.EventArgs.LogType.Info, $"gateway {Request.RemoteIPAddress} {Request.Method} {Request.Url} request {Server.Host}:{Server.Port} netstream write error {e_.Message}{e_.StackTrace}");
}
try
{
if (mClientAgent.Client != null)
{
mClientAgent.Client.DisConnect();
}
}
finally
{
OnCompleted(eventResponseErrorArgs);
}
return;
}
}
}
public void Execute()
{
var request = Request;
var response = Response;
Status = RequestStatus.Requesting;
mClientAgent.Client.Connect();
if (mClientAgent.Client.IsConnected)
{
try
{
PipeStream pipeStream = mClientAgent.Client.Stream.ToPipeStream();
byte[] buffer = mBuffer;
int offset = 0;
var len = Encoding.UTF8.GetBytes(request.Method, 0, request.Method.Length, buffer, offset);
offset += len;
buffer[offset] = HeaderTypeFactory._SPACE_BYTE;
offset++;
len = Encoding.UTF8.GetBytes(request.Url, 0, request.Url.Length, buffer, offset);
offset += len;
buffer[offset] = HeaderTypeFactory._SPACE_BYTE;
offset++;
for (int i = 0; i < HeaderTypeFactory.HTTP_V11_BYTES.Length; i++)
{
buffer[offset + i] = HeaderTypeFactory.HTTP_V11_BYTES[i];
}
offset += HeaderTypeFactory.HTTP_V11_BYTES.Length;
buffer[offset] = HeaderTypeFactory._LINE_R;
offset++;
buffer[offset] = HeaderTypeFactory._LINE_N;
offset++;
pipeStream.Write(buffer, 0, offset);
request.Header.Write(pipeStream);
pipeStream.Write(HeaderTypeFactory.LINE_BYTES, 0, 2);
while (request.Length > 0)
{
len = request.Stream.Read(buffer, 0, buffer.Length);
pipeStream.Write(buffer, 0, len);
}
Status = RequestStatus.Responding;
mClientAgent.Client.Stream.Flush();
}
catch (Exception e_)
{
string error = $"gateway {request.RemoteIPAddress} {request.Method} {request.Url} to {Server.Host}:{Server.Port} error {e_.Message}@{e_.StackTrace}";
if (request.Server.EnableLog(BeetleX.EventArgs.LogType.Error))
{
request.Server.Log(BeetleX.EventArgs.LogType.Error, error);
}
BadGateway result = new BadGateway(error);
EventResponseErrorArgs eventResponseErrorArgs =
new EventResponseErrorArgs(request, response, result, BadGateway.SERVER_NET_ERROR);
try
{
if (mClientAgent.Client != null)
{
mClientAgent.Client.DisConnect();
}
}
finally
{
OnCompleted(eventResponseErrorArgs);
}
return;
}
}
}
private void OnRequest(object sender, EventHttpRequestArgs e)
{
try
{
e.Cancel = true;
var ip = e.Request.RemoteIPAddress;
if (HttpServer.EnableLog(LogType.Info))
{
HttpServer.Log(LogType.Info, $"gateway {e.Request.Method} {e.Request.Url} request from {ip}");
}
HttpServer.RequestExecting();
var result = this.Pluginer.Requesting(e.Request, e.Response);
if (result.Item1)
{
var item = Routes.GetAgent(e.Request);
if (item == null)
{
if (HttpServer.EnableLog(LogType.Info))
{
HttpServer.Log(LogType.Info, $"gateway {e.Request.RemoteIPAddress} {e.Request.Method} {e.Request.Url} request cluster server unavailable");
}
EventResponseErrorArgs error = new EventResponseErrorArgs(
e.Request, e.Response, this, "Cluster server unavailable", Gateway.CLUSTER_SERVER_UNAVAILABLE
);
OnResponseError(error);
}
else
{
result = item.UrlRoute.Pluginer.Requesting(e.Request, e.Response);
if (result.Item1)
{
if (HttpServer.EnableLog(LogType.Info))
{
HttpServer.Log(LogType.Info, $"gateway {e.Request.RemoteIPAddress} {e.Request.Method} {e.Request.Url} request {item.UrlRoute.Url}'s route executing");
}
item.Execute(e.Request, e.Response);
}
else
{
if (HttpServer.EnableLog(LogType.Info))
{
HttpServer.Log(LogType.Info, $"gateway {e.Request.RemoteIPAddress} {e.Request.Method} {e.Request.Url} request {item.UrlRoute.Url}'s route executing cancel!");
}
e.Cancel = result.Item2 == ResultType.Completed;
return;
}
}
}
else
{
e.Cancel = result.Item2 == ResultType.Completed;
return;
}
}
catch (Exception e_)
{
if (HttpServer.EnableLog(BeetleX.EventArgs.LogType.Error))
{
HttpServer.Log(BeetleX.EventArgs.LogType.Error,
$"gateway process {e.Request.RemoteIPAddress} {e.Request.Method} {e.Request.BaseUrl} error {e_.Message}@{e_.StackTrace}");
}
}
}
public void Execute()
{
var request = Request;
var response = Response;
Status = RequestStatus.Requesting;
mClientAgent.Client.Connect();
if (mClientAgent.Client.IsConnected)
{
try
{
if (Request.Server.EnableLog(BeetleX.EventArgs.LogType.Info))
{
Request.Server.Log(BeetleX.EventArgs.LogType.Info, $"gateway {Request.RemoteIPAddress} {Request.Method} {Request.Url} request {Server.Host}:{Server.Port} netstream writing");
}
PipeStream pipeStream = mClientAgent.Client.Stream.ToPipeStream();
byte[] buffer = mBuffer;
int offset = 0;
var len = Encoding.UTF8.GetBytes(request.Method, 0, request.Method.Length, buffer, offset);
offset += len;
buffer[offset] = HeaderTypeFactory._SPACE_BYTE;
offset++;
len = Encoding.UTF8.GetBytes(request.Url, 0, request.Url.Length, buffer, offset);
offset += len;
buffer[offset] = HeaderTypeFactory._SPACE_BYTE;
offset++;
for (int i = 0; i < HeaderTypeFactory.HTTP_V11_BYTES.Length; i++)
{
buffer[offset + i] = HeaderTypeFactory.HTTP_V11_BYTES[i];
}
offset += HeaderTypeFactory.HTTP_V11_BYTES.Length;
buffer[offset] = HeaderTypeFactory._LINE_R;
offset++;
buffer[offset] = HeaderTypeFactory._LINE_N;
offset++;
pipeStream.Write(buffer, 0, offset);
request.Header.Write(pipeStream);
//if (request.Cookies.Items.Count > 0)
//{
// HeaderTypeFactory.Write(HeaderTypeFactory.COOKIE, pipeStream);
// int _i = 0, _iLast = request.Cookies.Items.Count - 1;
// foreach (var _item in request.Cookies.Items)
// {
// if (_i == _iLast)
// {
// pipeStream.Write(
// Encoding.ASCII.GetBytes(
// $"{_item.Key}={_item.Value};".TrimEnd(';')
// )
// );
// }
// else
// {
// pipeStream.Write(
// Encoding.ASCII.GetBytes(
// $"{_item.Key}={_item.Value};"
// )
// );
// }
// _i++;
// }
////// pipeStream.Write(HeaderTypeFactory.LINE_BYTES, 0, 2);
//}
//if (request.Cookies.Items.Count > 0)
//{
// StringBuilder _sbuilder = new StringBuilder();
// foreach (var _item in request.Cookies.Items)
// {
// _sbuilder.Append($"{_item.Key}={_item.Value};");
// }
// new HeaderValue(
// HeaderTypeFactory.Find(HeaderTypeFactory.COOKIE),
// _sbuilder.ToString().TrimEnd(';')
// )
// .Write(pipeStream);
//}
//HTTP报文Head结尾需要再补个/r/n，也就是说报文Head结尾是两个/r/n
pipeStream.Write(HeaderTypeFactory.LINE_BYTES, 0, 2);
int bodylength = request.Length;
while (bodylength > 0)
{
len = request.Stream.Read(buffer, 0, buffer.Length);
pipeStream.Write(buffer, 0, len);
bodylength -= len;
}
Status = RequestStatus.Responding;
/* BeetleX.dll!BeetleX.Buffers.SocketAsyncEventArgsX.InvokeCompleted()
* BeetleX.dll!BeetleX.Buffers.SocketAsyncEventArgsX.AsyncTo(System.Net.Sockets.Socket socket, object userToken, int length)=>socket.SendAsyn
* BeetleX.dll!BeetleX.Buffers.Buffer.AsyncTo(BeetleX.Buffers.SocketAsyncEventArgsX argsX, System.Net.Sockets.Socket socket)
* BeetleX.dll!BeetleX.Clients.AsyncTcpClient.CommitBuffer(BeetleX.Buffers.IBuffer buffer)
* BeetleX.dll!BeetleX.Clients.AsyncTcpClient.ProcessSendMessages()
* BeetleX.dll!BeetleX.Clients.AsyncTcpClient.Send(object data)
* BeetleX.dll!BeetleX.Clients.AsyncTcpClient.OnWriterFlash(BeetleX.Buffers.IBuffer data)
* BeetleX.dll!BeetleX.Buffers.PipeStream.Flush()
* */
mClientAgent.Client.Stream.Flush(); ///<see cref="AsyncTcpClient.OnWriterFlash"/>
if (Request.Server.EnableLog(BeetleX.EventArgs.LogType.Info))
{
Request.Server.Log(BeetleX.EventArgs.LogType.Info, $"gateway {Request.RemoteIPAddress} {Request.Method} {Request.Url} request {Server.Host}:{Server.Port} netstream writed");
}
}
catch (Exception e_)
{
string error = $"gateway {request.RemoteIPAddress} {request.Method} {request.Url} to {Server.Host}:{Server.Port} error {e_.Message}@{e_.StackTrace}";
if (request.Server.EnableLog(BeetleX.EventArgs.LogType.Error))
{
request.Server.Log(BeetleX.EventArgs.LogType.Error, error);
}
BadGateway result = new BadGateway(error);
EventResponseErrorArgs eventResponseErrorArgs =
new EventResponseErrorArgs(request, response, result, BadGateway.SERVER_NET_ERROR);
try
{
if (mClientAgent.Client != null)
{
mClientAgent.Client.DisConnect();
}
}
finally
{
OnCompleted(eventResponseErrorArgs);
}
return;
}
}
}
