public void SendResponse <T>(RpcResponseHeader header, T results)
{
HttpListenerResponse response = _httpContext.Response;
response.StatusCode = 200;
response.ContentType = "multipart/byteranges";
if (!header.HasBody)
{
response.Headers.Add("Null", "true");
response.ContentLength64 = 0;
}
else
{
byte[] buffer = ProtoBufSerializer.ToByteArray <T>(results);
if (buffer.Length > 0)
{
response.ContentLength64 = buffer.Length;
response.OutputStream.Write(buffer, 0, buffer.Length);
response.OutputStream.Close();
}
else
{
response.ContentLength64 = 0;
}
}
response.Close();
}
void IRpcClientTransaction.SendRequest <T>(RpcRequestHeader request, T args, Action <RpcResponseHeader> callback, int timeout)
{
_callback = callback;
_serviceUrl = string.Format("{0}/{1}.{2}", request.ServerUri, request.Service, request.Method);
_webRequest = HttpWebRequest.Create(_serviceUrl);
_webRequest.Method = "POST";
_webRequest.Proxy = null;
_webRequest.ContentType = "multipart/byteranges";
_webRequest.Headers.Add(HttpRequestHeader.From, request.ServiceAtComputer);
_webRequest.Headers.Add(HttpRequestHeader.Pragma, _serviceUrl);
_webRequest.Headers.Add(HttpRequestHeader.Cookie, "to=" + ObjectHelper.ToString(request.ToUri));
byte[] buffer = null;
if (!request.HasBody)
{
_webRequest.Headers.Add("Null", "true");
_webRequest.ContentLength = 0;
}
else
{
buffer = ProtoBufSerializer.ToByteArray <T>(args);
_webRequest.ContentLength = buffer.Length;
}
timeout = timeout > 0 ? timeout : _channel.Timeout;
if (timeout > 0)
{
_waitHandle = new ManualResetEvent(false);
ThreadPool.RegisterWaitForSingleObject(_waitHandle, new WaitOrTimerCallback(TimeoutCallback), this, timeout, true);
}
if (_webRequest.ContentLength == 0)
{
_webRequest.BeginGetResponse(new AsyncCallback(ResponseCallback), this);
}
else
{
_webRequest.BeginGetRequestStream(
delegate(IAsyncResult asyncResult) {
try {
Stream stream = _webRequest.EndGetRequestStream(asyncResult);
stream.Write(buffer, 0, buffer.Length);
stream.Close();
_webRequest.BeginGetResponse(new AsyncCallback(ResponseCallback), this);
} catch (Exception ex) {
var resp = RpcResponseHeader.CreateError(RpcErrorCode.SendFailed, ex);
_callback(resp);
}
},
this
);
}
}
private static void ResponseCallback(IAsyncResult asyncResult)
{
RpcHttpClientTransaction trans = (RpcHttpClientTransaction)asyncResult.AsyncState;
RpcResponseHeader header = null;
try {
var response = trans._webRequest.EndGetResponse(asyncResult);
trans._webResponse = response;
string warn = response.Headers.Get("Warning");
if (!string.IsNullOrEmpty(warn))
{
RpcErrorCode errCode = (RpcErrorCode)Enum.Parse(typeof(RpcErrorCode), warn);
if (errCode != RpcErrorCode.OK)
{
Exception ex = null;
if (response.ContentLength > 0)
{
Stream stream = response.GetResponseStream();
ex = BinarySerializer.Deserialize <Exception>(stream);
}
header = RpcResponseHeader.CreateError(errCode, ex);
}
else
{
SystemLog.Error(LogEventID.RpcFailed, "Unexcepted Message");
header = RpcResponseHeader.CreateError(RpcErrorCode.Unknown, null);
}
}
else
{
bool hasBody = (response.Headers["Null"] != "true");
header = RpcResponseHeader.CreateSuccess(hasBody);
}
} catch (WebException ex) {
if (ex.Status == WebExceptionStatus.Timeout)
{
header = RpcResponseHeader.CreateError(RpcErrorCode.TransactionTimeout, ex);
}
else
{
header = RpcResponseHeader.CreateError(RpcErrorCode.SendFailed, ex);
}
} catch (Exception ex) {
header = RpcResponseHeader.CreateError(RpcErrorCode.SendFailed, ex);
}
trans._callback(header);
trans._waitHandle.Set();
}
public void SendError(RpcResponseHeader header)
{
_context.RetCode = header.ErrorCode;
if (header.Error != null)
{
_context.HasBody = true;
RpcPipeStreamHelper.WriteStreamEx(_stream, _context, header.Error);
}
else
{
_context.HasBody = false;
RpcPipeStreamHelper.WriteStream <RpcNull>(_stream, _context, null);
}
_stream.Disconnect();
_channel.RecycleServerStream(_stream);
}
public void SendResponse <T>(RpcResponseHeader header, T results)
{
_context.RetCode = RpcErrorCode.OK;
_context.HasBody = header.HasBody;
if (header.HasBody)
{
RpcPipeStreamHelper.WriteStream <T>(_stream, _context, results);
_stream.Disconnect();
_channel.RecycleServerStream(_stream);
}
else
{
RpcPipeStreamHelper.WriteStream <RpcNull>(_stream, _context, null);
_stream.Disconnect();
_channel.RecycleServerStream(_stream);
}
}
private static void TimeoutCallback(object state, bool setted)
{
RpcHttpClientTransaction trans = null;
try {
if (setted) // Timeout
{
trans = (RpcHttpClientTransaction)state;
var resp = RpcResponseHeader.CreateError(RpcErrorCode.TransactionTimeout, null);
trans._callback(resp);
}
} catch (Exception ex) {
SystemLog.Error(LogEventID.RpcFailed, ex, "TimeoutCallback");
} finally {
if (trans != null)
{
trans.Dispose();
}
}
}
public void SendError(RpcResponseHeader header)
{
HttpListenerResponse response = _httpContext.Response;
response.StatusCode = 200;
response.ContentType = "multipart/byteranges";
response.Headers.Add("Warning", header.ErrorCode.ToString());
if (header.Error == null)
{
response.ContentLength64 = 0;
}
else
{
byte[] buffer = BinarySerializer.ToByteArray(header.Error);
response.ContentLength64 = buffer.Length;
response.OutputStream.Write(buffer, 0, buffer.Length);
response.OutputStream.Close();
}
response.Close();
}
public void SendError(RpcResponseHeader header)
{
_response = header;
_callback(header);
}
public void SendResponse <T>(RpcResponseHeader header, T results)
{
_response = header;
_results = results;
_callback(header);
}
public void SendRequest <T>(RpcRequestHeader request, T args, Action <RpcResponseHeader> callback, int timeout)
{
_callback = callback;
_context = new RpcPipeContext();
_context.From = request.ServiceAtComputer;
_context.To = request.ToUri;
_context.ServiceName = request.Service;
_context.MethodName = request.Method;
_context.HasBody = request.HasBody;
_stream = new NamedPipeClientStream(_serverUri.Computer, _serverUri.PipeName, PipeDirection.InOut, PipeOptions.Asynchronous);
try {
timeout = timeout > 0 ? timeout : _channel.Timeout;
if (timeout > 0)
{
_stream.Connect(timeout);
}
else
{
_stream.Connect();
}
if (request.HasBody)
{
RpcPipeStreamHelper.WriteStream <T>(_stream, _context, args);
}
else
{
RpcPipeStreamHelper.WriteStream <RpcNull>(_stream, _context, null);
}
RpcResponseHeader header;
_context = RpcPipeStreamHelper.ReadStream(_stream, out _bodyBuffer);
if (_context.RetCode == RpcErrorCode.OK)
{
header = RpcResponseHeader.CreateSuccess(_context.HasBody);
}
else
{
if (_bodyBuffer != null)
{
Exception ex = BinarySerializer.FromByteArray <Exception>(_bodyBuffer);
header = RpcResponseHeader.CreateError(_context.RetCode, ex);
}
else
{
header = RpcResponseHeader.CreateError(_context.RetCode, null);
}
}
_callback(header);
} catch (Exception ex) {
var header = RpcResponseHeader.CreateError(RpcErrorCode.SendFailed, ex);
_callback(header);
} finally {
if (_stream != null)
{
_stream.Close();
}
}
}