private async Task<TenantInstance> GetTenantInstance(IOwinRequest request)
        {
            var requestIdentifier = configuration.IdentificationStrategy(request);

            if (requestIdentifier == null)
            {
                throw new InvalidOperationException("The identification strategy did not return an identifier for the request.");
            }

            var instance = runningInstances.Get(requestIdentifier);

            if (instance != null)
            {
                Log("Instance for '{0}' is already running.", requestIdentifier);
                return instance;
            }

            Log("Instance for '{0}' not running. Resolving tenant.", requestIdentifier);

            var tenant = await configuration.TenantResolver.Resolve(requestIdentifier);

            if (tenant != null)
            {
                Log("Tenant found with identifiers '{0}'", string.Join(",", tenant.RequestIdentifiers));
                instance = StartInstance(tenant);
            }

            return instance;
        }

        public async Task<System.Web.Cors.CorsPolicy> GetCorsPolicyAsync(IOwinRequest request)
        {
            var path = request.Path.ToString();
            var origin = request.Headers["Origin"];

            // see if the Origin is different than this server's origin. if so
            // that indicates a proper CORS request
            var ctx = new OwinContext(request.Environment);
            // using GetIdentityServerHost takes into account a configured PublicOrigin
            var thisOrigin = ctx.GetIdentityServerHost();
            if (origin != null && origin != thisOrigin)
            {
                if (IsPathAllowed(request))
                {
                    Logger.InfoFormat("CORS request made for path: {0} from origin: {1}", path, origin);

                    if (await IsOriginAllowed(origin, request.Environment))
                    {
                        Logger.Info("CorsPolicyService allowed origin");
                        return Allow(origin);
                    }
                    else
                    {
                        Logger.Info("CorsPolicyService did not allow origin");
                    }
                }
                else
                {
                    Logger.InfoFormat("CORS request made for path: {0} from origin: {1} but rejected because invalid CORS path", path, origin);
                }
            }

            return null;
        }

        public async Task<System.Web.Cors.CorsPolicy> GetCorsPolicyAsync(IOwinRequest request)
        {
            var path = request.Path.ToString();
            var origin = request.Headers["Origin"];

            // see if the Origin is different than this server's origin. if so
            // that indicates a proper CORS request
            var thisOrigin = request.Uri.Scheme + "://" + request.Uri.Authority;
            if (origin != null && origin != thisOrigin)
            {
                if (IsPathAllowed(request))
                {
                    Logger.InfoFormat("CORS request made for path: {0} from origin: {1}", path, origin);

                    if (await IsOriginAllowed(origin, request.Environment))
                    {
                        Logger.Info("CorsPolicyService allowed origin");
                        return Allow(origin);
                    }
                    else
                    {
                        Logger.Info("CorsPolicyService did not allow origin");
                    }
                }
                else
                {
                    Logger.WarnFormat("CORS request made for path: {0} from origin: {1} but rejected because invalid CORS path", path, origin);
                }
            }

            return null;
        }

        public async Task<AuthenticationTicket> ValidateTicket(IOwinRequest request, IOwinContext context, HttpClient httpClient,
            string ticket, AuthenticationProperties properties, string service)
        {
            // Now, we need to get the ticket validated
            string validateUrl = _options.CasServerUrlBase + "/validate" +
                                 "?service=" + service +
                                 "&ticket=" + Uri.EscapeDataString(ticket);

            HttpResponseMessage response = await httpClient.GetAsync(validateUrl, request.CallCancelled);

            response.EnsureSuccessStatusCode();
            string responseBody = await response.Content.ReadAsStringAsync();


            String validatedUserName = null;
            var responseParts = responseBody.Split('\n');
            if (responseParts.Length >= 2 && responseParts[0] == "yes")
                validatedUserName = responseParts[1];

            if (!String.IsNullOrEmpty(validatedUserName))
            {
                var identity = new ClaimsIdentity(_options.AuthenticationType);
                identity.AddClaim(new Claim(ClaimTypes.NameIdentifier, validatedUserName, "http://www.w3.org/2001/XMLSchema#string", _options.AuthenticationType));
                identity.AddClaim(new Claim(ClaimTypes.Name, validatedUserName, "http://www.w3.org/2001/XMLSchema#string", _options.AuthenticationType));

                var authenticatedContext = new CasAuthenticatedContext(context, identity, properties);

                await _options.Provider.Authenticated(authenticatedContext);

                return new AuthenticationTicket(authenticatedContext.Identity, authenticatedContext.Properties);
            }

            return new AuthenticationTicket(null, properties);
        }

 private void Inbound(IOwinRequest request, string beforeValue)
 {
     if (beforeValue != null)
     {
         RouteParams.Set(request.Environment, inRouteParam, beforeValue);
     }
 }

 public static string CheckRequiredRequestParameter(IOwinRequest request, IList<string> errors, string name)
 {
     if (string.IsNullOrEmpty(request.Query[name]))
     {
         errors.Add(string.Format("required property '{0}' is missing from metadata", name));
     }
     return request.Query[name];
 }

        private static ScimVersion GetScimVersion(IOwinRequest request, ScimServerConfiguration serverConfiguration)
        {
            var result = _VersionRegex.Match(request.Path.ToString());
            if (result.Success)
                return new ScimVersion(result.Groups[1].Value); // e.g. groups[] -> /v0/, v0

            return serverConfiguration.DefaultScimVersion;
        }

 private Boolean allowCompress(IOwinRequest req)
 {
     if (!EnableCompress)
         return false;
     var acceptEncoding = req.Headers.Get("Accept-Encoding");
     if (acceptEncoding == null)
         return false;
     return acceptEncoding.Contains("gzip");
 }

 private static bool IsAjaxRequest(IOwinRequest request)
 {
     IReadableStringCollection query = request.Query;
     if ((query != null) && (query["X-Requested-With"] == "XMLHttpRequest"))
     {
         return true;
     }
     IHeaderDictionary headers = request.Headers;
     return ((headers != null) && (headers["X-Requested-With"] == "XMLHttpRequest"));
 }

        public void Log(IOwinRequest request, IOwinResponse response, long responseTime)
        {
            var username = (string.IsNullOrEmpty(request.User?.Identity?.Name)) ? "-" : request.User.Identity.Name;
            var queryString = string.IsNullOrEmpty(request.QueryString.Value) ? "-" : request.QueryString.Value;
            var useragent = (request.Headers.Get("User-Agent") ?? "-").Replace(' ', '+');
            var referer = request.Headers.Get("Referer") ?? "-";
            var message = $"{DateTime.UtcNow:yyyy-MM-dd HH:mm:ss} {ApplicationName} {ComputerName} {request.LocalIpAddress} {request.Method} {request.Uri.GetLeftPart(UriPartial.Path)} {queryString} {request.LocalPort} {username} {request.RemoteIpAddress} {useragent} {referer} {response.StatusCode} 0 0 {responseTime}";

            RequestLog.Warn(message);
        }

        internal static bool HasValidHeaders(IOwinRequest request)
        {
            if (request.Accept == null || !request.Accept.ToLowerInvariant().Contains(ApplicationJsonMediaType))
                return false;

            if (!request.ContentType.ToLowerInvariant().StartsWith(ApplicationJsonMediaType))
                return false;

            return true;
        }

        private static async Task LogRequest(IOwinRequest request)
        {
            var reqLog = new
            {
                Method = request.Method,
                Url = request.Uri.AbsoluteUri,
                Headers = request.Headers,
                Body = await request.ReadBodyAsStringAsync()
            };

            Logger.Debug("HTTP Request" + Environment.NewLine + LogSerializer.Serialize(reqLog));
        }

        public IRequest GetRequest(IOwinRequest request)
        {
            using (StreamReader sr = new StreamReader(request.Body))
            {
                using (JsonReader reader = new JsonTextReader(sr))
                {
                    var iRequest = new Request(request.Query.Get("interface"), request.Query.Get("method"), JArray.Load(reader));

                    return iRequest;
                }
            }
        }

        /// <summary>
        /// Resolves a tenant request using hostname
        /// </summary>
        /// <param name="request">The request</param>
        /// <returns>The tenant or null</returns>
        public ITenant Resolve(IOwinRequest request)
        {
            var httpContext = request.Context.Get<HttpContextWrapper>("System.Web.HttpContextBase");
            var routeData = RouteTable.Routes.GetRouteData(httpContext);

            if (routeData == null || routeData.Values.ContainsKey(RouteName) == false)
                return Tenants.First();

            var tenant = Tenants.FirstOrDefault(x => x.Name == routeData.Values[RouteName].ToString());

            return tenant ?? Tenants.First();
        }

        private ICompressor GetCompressor(IOwinRequest request)
        {
            if(!request.Headers.ContainsKey(AcceptEncoding))
            {
                return null;
            }

            return (from c in compressors
                    from e in request.Headers.GetCommaSeparatedValues(AcceptEncoding).Select(x => StringWithQualityHeaderValue.Parse(x))
                    orderby e.Quality descending
                    where string.Compare(c.ContentEncoding, e.Value, StringComparison.InvariantCultureIgnoreCase) == 0
                    select c).FirstOrDefault();
        }

 /// <summary>
 /// 处理多段表单数据
 /// </summary>
 /// <param name="req"></param>
 /// <param name="parameterHandler"></param>
 /// <param name="fileHandler"></param>
 public static void HandleMultipartData(IOwinRequest req,
     StreamingMultipartFormDataParser.ParameterDelegate parameterHandler,
     StreamingMultipartFormDataParser.FileStreamDelegate fileHandler,
     StreamingMultipartFormDataParser.StreamClosedDelegate streamClosedDelegate = null)
 {
     if (!req.ContentType.StartsWith("multipart/form-data;"))
         throw new ArgumentException("'ContentType' not start with 'multipart/form-data;'.");
     var parser = new StreamingMultipartFormDataParser(req.Body);
     parser.ParameterHandler = parameterHandler;
     parser.FileHandler = fileHandler;
     parser.StreamClosedHandler = streamClosedDelegate;
     parser.Run();
 }

        public async Task<WebApiLogger> ExtractRequestParameters(IOwinRequest request)
        {
            logEntry.RequestHeaders = await request.RequestHeadersToJsonString();
            logEntry.RequestContentBody = await request.RequestBodyToString();
            logEntry.RequestContentType =  request.ContentType;
            logEntry.RequestIpAddress = request.RemoteIpAddress;
            logEntry.RequestMethod = request.Method;
            logEntry.RequestRouteData = "";
            logEntry.RequestRouteTemplate = "";
            logEntry.RequestUri = request.Uri.AbsoluteUri;

            return this;
        }

        private bool TryIsValidRequest(IOwinRequest request, out string requestAppId)
        {
            requestAppId = null;

            AuthenticationHeaderValue authHeader;
            if (!AuthenticationHeaderValue.TryParse(request.Headers["Authorization"], out authHeader) || authHeader.Scheme != "SOW")
            {
                return false;
            }

            var parameters = authHeader.Parameter.Split(':');
            if (parameters.Length != 3)
            {
                return false;
            }
            requestAppId = parameters[0];
            var requestSignature = parameters[1];
            var requestTimeStamp = parameters[2];

            var apiKey = _appKeyProvider.GetKey(requestAppId);
            if (apiKey == null)
            {
                return false;
            }

            // TODO check replay request

            // Compute hash
            var requestContent = string.Empty;
            var hash = ComputeHash(request);
            if (hash != null)
            {
                requestContent = Convert.ToBase64String(hash);
            }

            var requestMethod = request.Method;
            var requestUri = WebUtility.UrlEncode(request.Uri.ToString().ToLowerInvariant());
            var hmacData = string.Concat(requestAppId, requestMethod, requestUri, requestTimeStamp, requestContent);

            var secretKeyBytes = Convert.FromBase64String(apiKey);
            var signature = Encoding.UTF8.GetBytes(hmacData);

            using (var hmac = new HMACSHA256(secretKeyBytes))
            {
                var signatureBytes = hmac.ComputeHash(signature);
                var signatureString = Convert.ToBase64String(signatureBytes);
                return requestSignature.Equals(signatureString, StringComparison.Ordinal);
            }
        }

        private bool ClientCached(IOwinRequest request, DateTime contentModified)
        {
            string header = request.Headers["If-Modified-Since"];

            if (header != null)
            {
                DateTime isModifiedSince;
                if (DateTime.TryParse(header, out isModifiedSince))
                {
                    return isModifiedSince >= contentModified.AddSeconds(-1);
                }
            }

            return false;
        }

      private void SetRequestId(IOwinRequest request)
      {
         string requestId;

         string[] requestIds;
         if (request.Headers.TryGetValue(RequestIdHeaderName, out requestIds) && requestIds != null && requestIds.Length > 0)
         {
            requestId = requestIds[0];
         }
         else
         {
            requestId = Guid.NewGuid().ToString();
         }

         HttpContext.Current.Items[RequestIdHeaderName] = requestId;
      }