public JMXInterpret(IWebApplicationBase webApp, HttpRequest request, HttpReply reply)
        {
            this.request = request;
            this.reply   = reply;

            app = (DodoApplication)webApp;
        }
Example #2
0
        public HttpReply SendRequest(HttpRequest request)
        {
            HttpReply          ret = null;
            RequestAsyncResult rar = BeginSendRequest(request, null, null) as RequestAsyncResult;

            rar.AsyncWaitHandle.WaitOne();
            ret = (HttpReply)rar.Reply;
            return(ret);
        }
Example #3
0
        public static async Task <InstanceStatusInfo> GetStatusAsync(string targetServer, string targetNodeName, string groupName, string sendingNodeName)
        {
            InstanceStatusInfo reply;

            try
            {
                string         uri = HttpConfiguration.FormClientUriPrefix(targetServer, targetNodeName, groupName);
                HttpWebRequest req = (HttpWebRequest)WebRequest.Create(uri);
                req.Method      = "PUT";
                req.ContentType = "application/octet-stream";
                HttpRequest.GetStatusRequest reqMsg = new HttpRequest.GetStatusRequest(sendingNodeName);
                MemoryStream ms = DxSerializationUtil.SerializeMessage(reqMsg);
                req.ContentLength = ms.Length;
                ms.Position       = 0L;
                Stream outStream = await req.GetRequestStreamAsync();

                using (outStream)
                {
                    await ms.CopyToAsync(outStream);
                }
                using (HttpWebResponse httpResponse = (HttpWebResponse)(await req.GetResponseAsync()))
                {
                    using (Stream responseStream = httpResponse.GetResponseStream())
                    {
                        HttpReply httpReply = DxSerializationUtil.Deserialize <HttpReply>(responseStream);
                        if (httpReply is HttpReply.GetInstanceStatusReply)
                        {
                            reply = (httpReply as HttpReply.GetInstanceStatusReply).Reply;
                        }
                        else
                        {
                            if (httpReply is HttpReply.ExceptionReply)
                            {
                                Exception exception = (httpReply as HttpReply.ExceptionReply).Exception;
                                throw new DxStoreInstanceServerException(exception.Message, exception);
                            }
                            throw new DxStoreInstanceClientException(string.Format("unexpected reply: {0}", httpReply.GetType().FullName));
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                ExTraceGlobals.InstanceClientTracer.TraceError <string, Exception>(0L, "GetStatusAsync to {0} caught: {1}", targetNodeName, ex);
                if (ex is DxStoreInstanceClientException || ex is DxStoreInstanceServerException)
                {
                    throw;
                }
                throw new DxStoreInstanceClientException(ex.Message, ex);
            }
            return(reply);
        }
Example #4
0
        public void SendReply(HttpReply reply, NodeBind dest, bool closeConnection)
        {
            numSentReply++;
            RequestReplyTable.AddReply(dest, reply);

            WebMessage m = new WebMessage()
            {
                Source          = localBind,
                Destiny         = dest,
                Payload         = reply,
                CloseConnection = closeConnection
            };

            // put in wire
            ResumeRouting(m);
        }
        public override IHttpMessage Serialize()
        {
            IHttpMessage ret = null;

            if (Payload is OverlayRequest)
            {
                var tmp = new HttpRequest()
                {
                    Host = Destiny.ToString()
                };

                ret = (HttpRequest)tmp;
            }
            else if (Payload is OverlayReply)
            {
                var tmp = new HttpReply();

                ret = (HttpReply)tmp;
            }

            // head
            ret.Url = Payload.GetType().FullName;

            ret.AddField(new HttpField(HttpConst.MessageSource, Source));
            ret.AddField(new HttpField(HttpConst.MessageDestiny, Destiny));
            ret.AddField(new HttpField(HttpConst.MessagePath, Path));
            ret.AddField(new HttpField(HttpConst.MessageHops, Hops));

            // body
            ret.CreateBody();
            ret.Body.CreateStream();

            if (Payload != null)
            {
                var formatter = new BinaryFormatter();
                formatter.Serialize(ret.Body.ContentStream, Payload);
                ret.Body.ContentType = HttpConst.ContentTypeDodoNetObject;
            }
            else
            {
                ret.Body.ContentType = "";
            }

            return(ret);
        }
        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);
        }
Example #7
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);
            }
        }
 public void CheckSessionOpenId(HttpReply reply)
 {
 }