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
        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);
        }