private TReply Execute <TRequest, TReply>(TRequest request, TimeSpan?timeout = null) where TRequest : DxStoreRequestBase where TReply : DxStoreReplyBase
        {
            string text = null;
            TReply result;

            try
            {
                text = HttpConfiguration.FormClientUriPrefix(this.TargetInfo.TargetHost, this.TargetInfo.TargetNode, this.TargetInfo.GroupName);
                HttpWebRequest httpWebRequest = (HttpWebRequest)WebRequest.Create(text);
                if (timeout != null)
                {
                    httpWebRequest.Timeout = (int)timeout.Value.TotalMilliseconds;
                }
                else
                {
                    httpWebRequest.Timeout = this.TimeoutInMsec;
                }
                httpWebRequest.Method      = "PUT";
                httpWebRequest.ContentType = "application/octet-stream";
                HttpRequest.DxStoreRequest msg = new HttpRequest.DxStoreRequest(this.Self, request);
                MemoryStream memoryStream      = DxSerializationUtil.SerializeMessage(msg);
                httpWebRequest.ContentLength = memoryStream.Length;
                memoryStream.Position        = 0L;
                Stream requestStream = httpWebRequest.GetRequestStream();
                using (requestStream)
                {
                    memoryStream.CopyTo(requestStream);
                }
                using (HttpWebResponse httpWebResponse = (HttpWebResponse)httpWebRequest.GetResponse())
                {
                    using (Stream responseStream = httpWebResponse.GetResponseStream())
                    {
                        HttpReply httpReply = DxSerializationUtil.Deserialize <HttpReply>(responseStream);
                        HttpReply.DxStoreReply dxStoreReply = httpReply as HttpReply.DxStoreReply;
                        if (dxStoreReply != null)
                        {
                            TReply treply = dxStoreReply.Reply as TReply;
                            if (treply == null)
                            {
                                throw new DxStoreAccessClientException(string.Format("Unexpected DxStoreReply {0}", dxStoreReply.Reply.GetType().FullName));
                            }
                            result = treply;
                        }
                        else
                        {
                            HttpReply.ExceptionReply exceptionReply = httpReply as HttpReply.ExceptionReply;
                            if (exceptionReply != null)
                            {
                                Exception exception = exceptionReply.Exception;
                                throw new DxStoreServerException(exception.Message, exception);
                            }
                            throw new DxStoreServerException(string.Format("unexpected reply: {0}", httpReply.GetType().FullName));
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                ExTraceGlobals.AccessClientTracer.TraceError <string, string>(0L, "HttpSend failed. Uri={0} Req={1} Ex={2}", text, request.GetType().FullName);
                if (ex is DxStoreAccessClientException || ex is DxStoreServerException)
                {
                    throw;
                }
                throw new DxStoreAccessClientException(ex.Message, ex);
            }
            return(result);
        }
示例#2
0
        private void ListenerCallback(IAsyncResult asyncContext)
        {
            ThreadPool.QueueUserWorkItem(new WaitCallback(this.ListenForAnotherRequest));
            Exception arg = null;

            try
            {
                HttpListenerContext httpListenerContext = this.listener.EndGetContext(asyncContext);
                HttpListenerRequest request             = httpListenerContext.Request;
                using (HttpListenerResponse response = httpListenerContext.Response)
                {
                    using (Stream inputStream = request.InputStream)
                    {
                        int          num          = (int)request.ContentLength64;
                        MemoryStream memoryStream = new MemoryStream(num);
                        inputStream.CopyTo(memoryStream);
                        memoryStream.Position = 0L;
                        HttpRequest httpRequest = DxSerializationUtil.TryDeserialize <HttpRequest>(memoryStream, out arg);
                        if (httpRequest != null)
                        {
                            ExTraceGlobals.InstanceTracer.TraceDebug <string, int>(0L, "Listener got {0} of size {1}", httpRequest.GetType().FullName, num);
                            HttpReply httpReply = null;
                            try
                            {
                                httpReply = this.msgHandler(httpRequest);
                            }
                            catch (Exception ex)
                            {
                                ExTraceGlobals.InstanceTracer.TraceError <Exception>(0L, "Listener handler threw {0}", ex);
                                httpReply = new HttpReply.ExceptionReply(ex);
                            }
                            if (httpReply == null)
                            {
                                response.ContentLength64 = 0L;
                                response.Close();
                                return;
                            }
                            using (MemoryStream memoryStream2 = DxSerializationUtil.Serialize <HttpReply>(httpReply))
                            {
                                response.ContentLength64 = memoryStream2.Length;
                                memoryStream2.Position   = 0L;
                                using (Stream outputStream = response.OutputStream)
                                {
                                    memoryStream2.CopyTo(outputStream);
                                }
                                ExTraceGlobals.InstanceTracer.TraceDebug <string, long>(0L, "Listener returns {0} of size {1}", httpReply.GetType().FullName, memoryStream2.Length);
                                response.Close();
                                return;
                            }
                        }
                        response.StatusCode      = 400;
                        response.ContentLength64 = 0L;
                        response.Close();
                        EventLogger.LogErr("msg unhandled: {0}", new object[]
                        {
                            (httpRequest == null) ? "UnknownMsg" : httpRequest.GetType().FullName
                        });
                    }
                }
            }
            catch (Exception ex2)
            {
                arg = ex2;
                ExTraceGlobals.InstanceTracer.TraceError <Exception>(0L, "Listener caught {0}", arg);
            }
        }