private void ProcessRequest(Request request, NetworkStream stream)
        {
            if (request == null)
            {
                return;
            }
            if (request.Path.Equals("/"))
                request.Path = floderPath+"/index.html";
            ParsePath(request);
            if (File.Exists(floderPath+request.Path))
            {
                if(Path.GetExtension(request.Path).ToUpper()==".HTML")
                { 
                    var fileContent = File.ReadAllText(floderPath + request.Path);
                    GenerateResponse(fileContent, stream, OK200);
                    return;
                }
                else
                {
                    
                    byte[] byteContents = File.ReadAllBytes(floderPath + request.Path.Replace(@"/",@"\"));
                    GenerateResponse(byteContents, stream, OK200);
                    return;
                }
            }

            GenerateResponse("Not found", stream, NOTFOUND404);
        }

        public static String QueryStringForTR(Request trParams, Request req, String postURL, BraintreeService service)
        {
            String trData = TrUtil.BuildTrData(trParams, "http://example.com", service);
            String postData = "tr_data=" + HttpUtility.UrlEncode(trData, Encoding.UTF8) + "&";
            postData += req.ToQueryString();

            var request = WebRequest.Create(postURL) as HttpWebRequest;

            request.Method = "POST";
            request.KeepAlive = false;

            byte[] buffer = Encoding.UTF8.GetBytes(postData);
            request.ContentType = "application/x-www-form-urlencoded";
            request.ContentLength = buffer.Length;
            Stream requestStream = request.GetRequestStream();
            requestStream.Write(buffer, 0, buffer.Length);
            requestStream.Close();

            var response = request.GetResponse() as HttpWebResponse;
            String query = response.ResponseUri.Query;

            response.Close();

            return query;
        }

        public Response.CsResponse Process(Request.CsRequest request)
        {
            string[] lines = File.ReadAllLines("serverlist.txt");
            CsResponse response = new CsResponse();

            foreach (var l in lines)
            {
                if (l.Trim().Length == 0 || l.Trim()[0] == '#')
                    continue;

                var ipPort = l.Trim().Split(new char[] { ':' });

                IPAddress ip;
                short port;
                if (ipPort.Length < 2 || !IPAddress.TryParse(ipPort[0], out ip) || !short.TryParse(ipPort[1], out port))
                    continue;

                response.Servers.Add(new CsResponseItem()
                {
                    IPAddress = ip,
                    Port = port
                });
            }

            return response;
        }

        /// <summary>
        /// Retrieve the UUID given a username
        /// This one is no longer used during auth since the new method get the UUID
        /// </summary>
        public static Guid GetUUID(string username)
        {
            using (WebClient client = new WebClient())
            {
                /*
            'header'  => "Content-type: application/json\r\n",
            'method'  => 'POST',
            'content' => '{"name":"'.$username.'","agent":"minecraft"}',

                context  = stream_context_create(options);
                result = file_get_contents(url, false, $context);
                return res;
                */

                var request = new Request();
                request.name = username;

                byte[] req = Json.Serialize(request);

                // Download data.
                byte[] resp = client.UploadData(url, req);
                var response = Json.Deserialize<Response>(resp);

                if(response.profiles.Count == 0)
                    throw new InvalidOperationException("Bad response: " + Encoding.UTF8.GetString(resp));
                Guid id = response.profiles[0].id;
                if (id == Guid.Empty)
                    throw new InvalidOperationException("Bad response: " + Encoding.UTF8.GetString(resp));
                return id;
            }
        }

        private static void JSONRequest(Request reqst)
        {
            DataContractJsonSerializer ser = new DataContractJsonSerializer(typeof(Request));
            MemoryStream mem = new MemoryStream();
            ser.WriteObject(mem, reqst);
            string jsonData = Encoding.UTF8.GetString(mem.ToArray(), 0, (int)mem.Length);
            byte[] byteArray = Encoding.UTF8.GetBytes(jsonData);
            mem.Close();
            mem.Dispose();

            Console.WriteLine(jsonData);

            string json = HTTPRequestResponse(string.Format("{0}/{1}/{2}", _URL, _userID, "json"), byteArray, "PUT", "application/json;charset=\"utf-8\"");
            Console.WriteLine(json);

            DataContractJsonSerializer respSer = new DataContractJsonSerializer(typeof(Response));
            Response resp = (Response)respSer.ReadObject(new MemoryStream(Encoding.Unicode.GetBytes(json)));

            if (resp.IsSuccessful)
            {
                string responseData = _aes.Decrypt(resp.Data, _key);
                Console.WriteLine(responseData);
            }
            else
                Console.WriteLine(resp.ErrorMessage);
        }

 public RequestWriter(IRequest rawRequest)
     : this()
 {
     Method = rawRequest.Method;
         Uri = rawRequest.Uri;
         TheRealBodyBytes = new Request(rawRequest).BodyBytes;
 }

        public PageResult Analyze(Request request, Response response)
        {
            Console.WriteLine(@"FakePageAnalyzer.Analyze 执行分析");

            request = new Request()
            {
                SiteId = SiteIndex.Usashopcn,
                Url = @"http://www.usashopcn.com/Product/Details/127824",
                HttpMethod = HttpMethod.Get,
                RemainRetryCount = 0
            };

            response = new Response()
            {
                Request = request,
                HttpStatusCode = HttpStatusCode.OK,
                ReasonPhrase = "OK",
                IsSuccessCode = true,
                Content = "测试文本",
                MillisecondTime = 1000,
                Downloader = "FakeDownloader"
            };

            return new PageResult()
            {
                Topic = TopicType.StaticHtml,
                Request = request,
                Response = response
            };
        }

        /// <summary>
        /// GetStream
        /// </summary>
        /// <param name="request">request</param>
        /// <returns>Stream</returns>
        internal static Stream GetStream(Request request)
        {
            HttpWebResponse response = null;
            Stream responseStream = null;
            try
            {
                var httpWebRequest = GetHttpWebRequest(request);
                response = (HttpWebResponse)httpWebRequest.GetResponse();
                responseStream = response.GetResponseStream();
                byte[] buffer = StreamToBytes(responseStream);
                Stream memoryStream = new MemoryStream(buffer);
                request.Cookie = httpWebRequest.CookieContainer;
                return memoryStream;
            }
            catch (Exception)
            {
                return null;
            }
            finally
            {
                if (responseStream != null)
                {
                    responseStream.Dispose();
                    responseStream.Close();
                }

                if (response != null)
                {
                    response.Dispose();
                    response.Close();
                }
            }
        }

        public RequestReceivedEventArgs(Request request, Socket client, int byteCount)
        {
            this.request = request;
            this.client = client;
            this.byteCount = byteCount;

            this.receiveTime = DateTime.Now;
        }

            public override Task<Response> ProcessRequest(Request request)
            {
                if (this.RequestReceived != null)
                {
                    return Task.FromResult(this.RequestReceived(request));
                }

                return Task.FromResult(request.CreateErrorResponse(HttpStatusCode.Gone, "Gone fishin'."));
            }

        public static AppAction App()
        {
            return (env, fault, result) => {
                var request = new Request(env);
                var response = new Response(result);
                if (string.IsNullOrWhiteSpace(request.GET["Url"])) {
                    response.ContentType = "text/html";
                    response
                        .Write("<form>")
                        .Write("Url <input type='text' name='Url' style='width:50%;' value='http://download.microsoft.com/download/f/e/6/fe6eb291-e187-4b06-ad78-bb45d066c30f/6.0.6001.18000.367-KRMSDK_EN.iso'/><br/>")
                        .Write("Save as <input type='text' name='SaveAs' style='width:50%;' value='6.0.6001.18000.367-KRMSDK_EN.iso'/><br/>")
                        .Write("<input type='submit' value='Go'/>")
                        .Write("</form>")
                        .Finish();
                }
                else {
                    // make remote request asynchronously
                    var remoteRequest = WebRequest.Create(request.GET["Url"]);

                    remoteRequest.BeginGetResponse(getResponseResult => fault.Guard(() => {
                        var remoteResponse = (HttpWebResponse)remoteRequest.EndGetResponse(getResponseResult);

                        // pass some response headers along
                        response.Status = (int)remoteResponse.StatusCode;
                        response.ContentType = remoteResponse.ContentType;
                        if (!string.IsNullOrWhiteSpace(request.GET["SaveAs"])) {
                            response.AddHeader("Content-Disposition", "attachment; filename=" + request.GET["SaveAs"]);
                        }

                        // pass response body along
                        var remoteStream = remoteResponse.GetResponseStream();
                        if (remoteStream == null) {
                            response.Finish();
                        }
                        else {
                            var buffer = new byte[4096];
                            response.Finish((next, error, complete) =>
                                Loop.Run((halted, continuation) => error.Guard(() =>
                                    remoteStream.BeginRead(buffer, 0, buffer.Length, streamResult => error.Guard(() => {
                                        var count = remoteStream.EndRead(streamResult);
                                        if (halted()) {
                                            return;
                                        }
                                        if (count <= 0) {
                                            complete();
                                            return;
                                        }
                                        if (!next.InvokeAsync(new ArraySegment<byte>(buffer, 0, count), continuation)) {
                                            continuation();
                                        }
                                    }), null))));
                        }
                    }), null);
                }
            };
        }

        public override Task<Response> ProcessRequest(Request request)
        {
            // The '.Servers' property actually returns a new list so this is totally reasonable.
            var response = new ListServerResponse {Servers = this.serverList.Servers};
            if (response.Servers.Count == 0)
            {
                return Task.FromResult(request.CreateErrorResponse(HttpStatusCode.NotFound, "No known servers."));
            }

            return Task.FromResult(Response.Create(request, HttpStatusCode.OK, response));
        }

        /// <summary>
        ///     Returns a collection of strings to the client advertizing features this provider supports.
        /// </summary>
        /// <param name="request">
        ///     An object passed in from the CORE that contains functions that can be used to interact with
        ///     the CORE and HOST
        /// </param>
        public void GetFeatures(Request request) {
            if (request == null) {
                throw new ArgumentNullException("request");
            }

            // Nice-to-have put a debug message in that tells what's going on.
            request.Debug("Calling '{0}::GetFeatures' ", ProviderName);
            foreach (var feature in _features) {
                request.Yield(feature);
            }
        }

        public void DoSendResponse(Request request, Response response)
        {
            // the http stack is intended to send back only coap responses

            // fill the exchanger with the incoming response
            WaitFuture<Request, Response> wf;
            if (_exchangeMap.TryRemove(request, out wf))
            {
                wf.Response = response;
            }
        }

 internal UInt32 AddStream(Request request, Type type)
 {
     var id = this.connection.KRPC ().AddStream (request);
     lock (accessLock) {
         if (!streamTypes.ContainsKey (id)) {
             streamTypes [id] = type;
             streamData [id] = this.connection.Invoke (request);
         }
     }
     return id;
 }

        public OAuthAccess(string consumerKey, string consumerSecret, string requestTokenURL, string accessTokenURL, string authorizeURL)
        {
            this.req = new Request();
            this.rnd = new Random();

            this.consumerKey = consumerKey;
            this.consumerSecret = consumerSecret;
            this.requestTokenURL = requestTokenURL;
            this.accessTokenURL = accessTokenURL;
            this.authorizeURL = authorizeURL;
        }

        public void Should_invoke_route_returned()
        {
            // Given
            var request = new Request("GET", "/", "http");

            // When
            this.engine.HandleRequest(request);

            // Then
            A.CallTo(() => this.route.Invoke()).MustHaveHappened();
        }

 public Dictionary<string, string> GetHeaders(Request request)
 {
     switch (Method)
     {
         case SignatureMethod.PLAINTEXT:
             return GeneratePlainOAuthHeaders(request);
         case SignatureMethod.HMACSHA1:
             return GenerateHmacOAuthHeaders(request);
         default:
             return null;
     }
 }

 public ClosureCodeRequest(string apiUrl, CompilationLevel level, string jsContent)
 {
     apiUrl = string.IsNullOrEmpty(apiUrl) ? DefaultApiUrl : apiUrl;
     request = new Request(apiUrl,
         new List<KeyValuePair<string, string>>
             {
                      new KeyValuePair<string, string>("compilation_level", level.ToString()),
                      new KeyValuePair<string, string>("js_code", jsContent),
                      new KeyValuePair<string, string>("output_format", "xml"),
                      new KeyValuePair<string, string>("output_info", "compiled_code"),
                 });
 }

 public UInt32 AddStream (Request request, Type type)
 {
     CheckDisposed ();
     var id = connection.KRPC ().AddStream (request);
     lock (accessLock) {
         if (!streamTypes.ContainsKey (id)) {
             streamTypes [id] = type;
             streamData [id] = connection.Invoke (request);
         }
     }
     return id;
 }