/// <summary>Initializes a new instance of the <see cref="UrsaHandler"/> class.</summary>
        /// <param name="next">Next middleware in the pipeline.</param>
        /// <param name="requestHandler">The request handler.</param>
        public UrsaHandler(OwinMiddleware next, IRequestHandler<RequestInfo, ResponseInfo> requestHandler) : base(next)
        {
            if (requestHandler == null)
            {
                throw new ArgumentNullException("requestHandler");
            }

            _requestHandler = requestHandler;
        }

		/// <summary>
		/// Регистрирует хэндлер для определенного адреса
		/// </summary>
		/// <param name="path"></param>
		/// <param name="handler"></param>
		public void Register(string path, IRequestHandler handler)
		{
			lock (this)
			{
				_cache[path] = handler;
			}
		}

 public BoxersController
     (
         IRequestHandler<CreateBoxerRequest, Boxer> createBoxerHandler
     )
 {
     this.createBoxerHandler = createBoxerHandler;
 }

 /// <summary>
 /// Instance a new Stack Client plugin container.
 /// </summary>
 /// <param name="defaults">Defaults values for queries executed against this client.</param>
 /// <param name="handler">A request handler for this client.</param>
 /// <param name="logger">Event log message dispatcher.</param>
 /// <param name="cache">API Response cache store.</param>
 /// <param name="throttler">Request throttler.</param>
 public StackClientPlugins(IDefaults defaults, IRequestHandler handler, IEventLog logger, IResponseCache cache, IRequestThrottler throttler)
 {
     if (defaults == null)
     {
         throw new ArgumentNullException("defaults");
     }
     if (handler == null)
     {
         throw new ArgumentNullException("handler");
     }
     if (logger == null)
     {
         throw new ArgumentNullException("logger");
     }
     if (cache == null)
     {
         throw new ArgumentNullException("cache");
     }
     if (throttler == null)
     {
         throw new ArgumentNullException("throttler");
     }
     Default = defaults;
     RequestHandler = handler;
     EventLog = logger;
     Cache = cache;
     Throttler = throttler;
 }

        public HmRpcServer(IRequestHandler requestHandler)
        {
            _requestHandler = new LoggingMessageHandler(new BufferedMessageHandler(requestHandler));

            _listener = new TcpListener(IPAddress.Any, 6300);
            _listener.Server.ReceiveTimeout = 3000 * 10;
        }

 public NanoHttpServer(int port)
 {
     _handlers = new Dictionary<string, IRequestHandler>();
     _tcp = new TcpServer(port);
     _tcp.ConnectionAdded += OnConnectionAdded;
     _root = new StubHandler("Page not ready yet".ToNoStyleHtmlBody());
 }

 public AccountService(IRequestHandler<WithdrawRequest, WithdrawResponse> wRequestHandler, 
     IRequestHandler<CheckBalanceRequest, CheckBalanceResponse> cRequestHandler 
     )
 {
     _wRequestHandler = wRequestHandler;
     _cRequestHandler = cRequestHandler;
 }

        public ChannelsApi(IRequestHandler requestHandler)
        {
            if (requestHandler == null)
                throw new ArgumentNullException(nameof(requestHandler));

            this.request = requestHandler;
        }

		internal BlockingFlushHandler(IBatchFactory batchFactory, 
		                         IRequestHandler requestHandler)
		{

			this._batchFactory = batchFactory;
			this._requestHandler = requestHandler;
		}

        /// <summary>
        /// Initializes a new instance of the <see cref="ProcessingContext"/> class.
        /// </summary>
        /// <param name="request">The request.</param>
        /// <param name="handler">The handler.</param>
        public ProcessingContext(IRequest request, IRequestHandler handler)
        {
            Contract.Requires(request != null);
            Contract.Requires(handler != null);

            this.Request = request;
            this.Handler = handler;
        }

        public JsonScraper(IRequestHandler requestHandler, ScrapeConfig scrapeConfig = null)
        {
            Log = LogManager.GetCurrentClassLogger();//todo: inject this in?
            _requestHandler = requestHandler;
            _scrapeConfig = scrapeConfig;

            _stopwatch = new Stopwatch();
        }

 /// <summary>
 /// </summary>
 /// <param name="baseUrl"></param>
 /// <param name="requestHandler"></param>
 /// <param name="requestLogger"></param>
 protected AbstractRestClient(string baseUrl, IRequestHandler requestHandler, IRequestLogger requestLogger)
 {
     RequestLogger = requestLogger;
     RequestHandler = requestHandler;
     BaseUrl = baseUrl;
     RequestHeaders = new Dictionary<string, string>();
     ConnectionTimeout = 2000; //Default 2s, deliberately short.
     ReadWriteTimeout = 8000; // Default 8s, reasonably short if accidentally called from the UI thread
 }

		private TcpHostConnection(TcpHost tcpHost, NetworkStream stream, IRequestHandler engine):base(stream)
		{
			if (tcpHost == null) throw new ArgumentNullException("tcpHost");
			if (stream == null) throw new ArgumentNullException("stream");
			if (engine == null) throw new ArgumentNullException("engine");
			_tcpHost = tcpHost;
			_stream = stream;
			_engine = engine;
		}

        public HttpServer(string prefix, int port, IRequestHandler[] handlers)
        {
            this.handlers = handlers ?? new IRequestHandler[0];

            listener = new HttpListener(prefix, port);
            listener.Start();

            var pool = new ThreadPool(defaultPoolSize, ProcessRequest);
        }

        /// <summary>
        /// Get hierarchy type from query string of current http request and save "HierarchyType" into TempVariables of IApplicationContext.
        /// </summary>
        /// <param name="requestHandler">Request handler.</param>
        /// <param name="e"></param>
        /// <param name="rediectToPageNotFoundUrlIfHierarchyTypeNotFound"></param>
        public static void SetupHierarchyType(IRequestHandler requestHandler, SetupApplicationContextVariablesEventArgs e, bool rediectToPageNotFoundUrlIfHierarchyTypeNotFound)
        {
            IPlatformConfiguration platformConfiguration = SpringContext.Current.GetObject<IPlatformConfiguration>();
            string hierarchyType = requestHandler.Parameters["HierarchyType"];
            if (string.IsNullOrEmpty(hierarchyType) && rediectToPageNotFoundUrlIfHierarchyTypeNotFound)
                throw new ResourceNotFoundException(string.Format(CultureInfo.InvariantCulture, Resources.InvalidHierarchyType, hierarchyType));

            e.TempVariables["HierarchyType"] = hierarchyType;
        }

        /// <summary>
        /// Get concrete data type from query string of current http request and save "ConcreteDataCategory" into TempVariables of IApplicationContext.
        /// </summary>
        /// <param name="requestHandler">Request handler.</param>
        /// <param name="e"></param>
        /// <param name="rediectToPageNotFoundUrlIfCategoryNotFound"></param>
        public static void SetupConcreteDataType(IRequestHandler requestHandler, SetupApplicationContextVariablesEventArgs e, bool rediectToPageNotFoundUrlIfCategoryNotFound)
        {
            string concreteDataType = requestHandler.Parameters["ConcreteDataType"];
            if (string.IsNullOrEmpty(concreteDataType) && rediectToPageNotFoundUrlIfCategoryNotFound)
                throw new ResourceNotFoundException(string.Format(CultureInfo.InvariantCulture, Resources.InvalidConcreteDataType, concreteDataType));

            if (!string.IsNullOrEmpty(concreteDataType))
                e.TempVariables["ConcreteDataType"] = concreteDataType;
        }

 public LoginsController
     (
         IRequestHandler<LoginRequest, string> loginHandler,
         ICommandHandler<LogoutRequest> logoutHandler
     )
 {
     this.loginHandler = loginHandler;
     this.logoutHandler = logoutHandler;
 }

        /// <summary>
        /// Validate query string "MetadataDataTypeName" and setup metadata data type name to IAuthenticationContext.TempVariables.
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        public override void SetupContextTempVariables(IRequestHandler sender, SetupApplicationContextVariablesEventArgs e)
        {
            string metadataDataTypeName = QueryStringUtility.MetadataDataTypeName(sender);
            IObjectMetadata metadata = metadataApi.GetType(metadataDataTypeName);
            if (metadata == null)
                throw new ResourceNotFoundException(string.Format(CultureInfo.InvariantCulture, Resources.InvalidMetadataTypeName, metadataDataTypeName));

            e.TempVariables["MetadataDataTypeId"] = metadata.Id;
            e.TempVariables["MetadataDataTypeName"] = metadata.Name;
        }

 private static bool MatchPath(IRequestHandler requestHandler, HttpRequestHead request)
 {
     var pathToMatch = request.Uri;
     int positionOfQueryStart = GetStartOfQueryString(request.Uri);
     if (positionOfQueryStart > -1)
     {
         pathToMatch = request.Uri.Substring(0, positionOfQueryStart);
     }
     var pathMatch = new Regex(string.Format(@"^{0}\/*$", requestHandler.Path));
     return pathMatch.IsMatch(pathToMatch);
 }

 public SessionContext(string sessionId, IRequestHandler requestHandler, IRegistrator<string, ISessionContext> publisherRegistrator)
 {
     this.publisherRegistrator = publisherRegistrator;
     SessionId = sessionId;
     RequestHandler = requestHandler;
     sessionStateEngine = SessionStateEngineFactory.Create(this);
     SessionTimeoutContext = new ElapsedTimerContext(SessionTimerConstants.SESSION_TIME_OUT);
     ResponseTimeoutContext = new ElapsedTimerContext(SessionTimerConstants.RESPONSE_TIME_OUT);
     sessionElapsedTimer = new SessionElaspedTimer(sessionStateEngine, this);
     UnRegister();
 }