/// <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>
/// 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 AccountService(IRequestHandler<WithdrawRequest, WithdrawResponse> wRequestHandler,
IRequestHandler<CheckBalanceRequest, CheckBalanceResponse> cRequestHandler
)
{
_wRequestHandler = wRequestHandler;
_cRequestHandler = cRequestHandler;
}
internal BlockingFlushHandler(IBatchFactory batchFactory,
IRequestHandler requestHandler)
{
this._batchFactory = batchFactory;
this._requestHandler = requestHandler;
}
public BoxersController
(
IRequestHandler<CreateBoxerRequest, Boxer> createBoxerHandler
)
{
this.createBoxerHandler = createBoxerHandler;
}
/// <summary>
/// Регистрирует хэндлер для определенного адреса
/// </summary>
/// <param name="path"></param>
/// <param name="handler"></param>
public void Register(string path, IRequestHandler handler)
{
lock (this)
{
_cache[path] = handler;
}
}
public Node(NodeSettings nodeSettings)
{
if (nodeSettings == null)
{
throw new ArgumentNullException("nodeSettings");
}
settings = nodeSettings;
requestHandler = new Follower(this);
electionTimeout = nodeSettings.ElectionTimeout;
Id = settings.NodeId;
LocalLog = new Log();
ServerLog = new Log();
Term = 1;
disposables.Add(nodeSettings.PeerObserver
.Subscribe(Observer.Create<IEnumerable<Peer>>(peers =>
{
Peers = peers.Where(p => p.Id != Id);
//Peers.ForEach(p => Debug.WriteLine("{0} new peer discovered: {1}", NodeInfo(), p.Id));
},
ex => Debug.WriteLine("OnError: {0}", ex.Message),
() => Debug.WriteLine("OnCompleted"))));
}
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 ChannelsApi(IRequestHandler requestHandler)
{
if (requestHandler == null)
throw new ArgumentNullException(nameof(requestHandler));
this.request = 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();
}
public BoxResourceManagerTestIntegration()
{
_auth = new OAuthSession("HrMywfaXCtAStbY9FTvoCbMZCBPeBgud", "Qx34izsfUuvbcm90x88gPs6ZiRXexxN3jbQGqNoY2r9to6mppRBoCD4iqlSVrm0F", 3600, "bearer");
_handler = new HttpRequestHandler();
_parser = new BoxJsonConverter();
_config = new BoxConfig(ClientId, ClientSecret, RedirectUri);
_client = new BoxClient(_config, _auth);
}
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;
}
/// <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;
}
public LoginsController
(
IRequestHandler<LoginRequest, string> loginHandler,
ICommandHandler<LogoutRequest> logoutHandler
)
{
this.loginHandler = loginHandler;
this.logoutHandler = logoutHandler;
}
/// <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;
}
/// <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
}
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);
}
//Check for the handlers and call their Handle method
//Get the first handler
public RequestHandlerGateway()
{
//Call the methods to compose the handlers
ComposeHandlers();
//Find the first handler, hanlder that is not a successor of any other handler
//Understand the use of Meta data here
first = Handlers.First(handler => handler.Metadata.SuccessorOf == null).Value;
}
public BoxResourceManagerTestIntegration()
{
_auth = new OAuthSession("YOUR_ACCESS_TOKEN", "YOUR_REFRESH_TOKEN", 3600, "bearer");
_handler = new HttpRequestHandler();
_parser = new BoxJsonConverter();
_config = new BoxConfig(ClientId, ClientSecret, RedirectUri);
_client = new BoxClient(_config, _auth);
}
/// <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;
}
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();
}
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 bool MatchQueryParams(IRequestHandler requestHandler, Dictionary<string, string> requestQueryParams)
{
foreach (var queryParam in requestHandler.QueryParams) {
if (!requestQueryParams.ContainsKey(queryParam.Key)) {
return false;
}
if (!String.Equals(requestQueryParams[queryParam.Key], queryParam.Value, StringComparison.OrdinalIgnoreCase)) {
return false;
}
}
return true;
}
public BoxResourceManagerTestIntegration()
{
_auth = new OAuthSession("YOUR_ACCESS_TOKEN", "YOUR_REFRESH_TOKEN", 3600, "bearer");
_handler = new HttpRequestHandler();
_parser = new BoxJsonConverter();
_config = new BoxConfig(ClientId, ClientSecret, RedirectUri);
_client = new BoxClient(_config, _auth);
_boxDeveloperEditionConfig = new BoxConfig(EnterpriseId, "enterprise", ClientId, ClientSecret, PrivateKey, PrivateKeyPassword);
_boxDeveloperEditionClient = new BoxClient(_boxDeveloperEditionConfig);
}
public SingleFileRoute(string urlPath, IRequestHandler handler)
{
if (handler == null)
{
throw new ArgumentNullException("handler");
}
if (string.IsNullOrWhiteSpace(urlPath))
{
throw new ArgumentNullException("urlPath");
}
this.urlPath = urlPath;
this.handler = handler;
}
/// <summary>
/// Erzeugt eine neue Instanz der Klasse
/// </summary>
/// <param name="requestHandler">Instanz von RequestHandler</param>
public EntityManager(IRequestHandler requestHandler)
{
this.requestHandler = requestHandler;
var request = new GetEntitiesRequest()
{
EntityType = "Configuration"
};
GetEntitiesResponse response = requestHandler.RequestResponse<GetEntitiesRequest, GetEntitiesResponse>(request);
logicalDevices = response.LogicalDevices;
locations = response.Locations;
profiles = response.Profiles;
}
public UsersController
(
IRequestHandler<GetAllUsersRequest, IEnumerable<User>> getAllHandler,
IRequestHandler<GetUserRequest, User> getSingleHandler,
ICommandHandler<DeleteUserRequest> deleteUserHandler,
IRequestHandler<CreateUserRequest, User> createUserHandler
)
{
this.getAllHandler = getAllHandler;
this.getSingleHandler = getSingleHandler;
this.deleteUserHandler = deleteUserHandler;
this.createUserHandler = createUserHandler;
}
public bool TryGetHandle(IHttpContext context, out IRequestHandler handeler)
{
foreach (var requestHandler in _requestHandlers)
{
if (requestHandler.WillHandle(context))
{
handeler = requestHandler;
return true;
}
}
handeler = null;
return false;
}
public static string GetReleases(IRequestHandler requestHandler)
{
return(requestHandler.GetReleases(RequestConstants.Url));
}
public SocketRemotingServer RegisterRequestHandler(int requestCode, IRequestHandler requestHandler)
{
_requestHandlerDict[requestCode] = requestHandler;
return(this);
}
public override HttpResponseMessage GetResponse(string url, long providerId, int validateSession, IRequestHandler reqHandler, CookieContainer container)
{
HttpResponseMessage resHttpResponseMessage;
string url_session = string.Empty;
bool error_session = false;
lock (PartslinkPortal.AutorizeLock)
{
if (PartslinkPortal.partslinkIsBlocked == true)
{
resHttpResponseMessage = null;
}
else
{
ConsoleHelper.Debug("PARTSLINK");
url_session = url;
if (validateSession == 1)
{
CloseSession();
}
else
{
;
}
if (!(validateSession == 0))
{
resHttpResponseMessage = reqHandler.OpenSessionAsync(url_session, container);
error_session = this.SessionHasError(resHttpResponseMessage);
if (error_session == false)
{
ConsoleHelper.Info(string.Format("Url Navigation to open session: {0}, RequestUri={1}, StatusCode={2}"
, url_session
, resHttpResponseMessage.RequestMessage.RequestUri.AbsoluteUri
, resHttpResponseMessage.StatusCode));
base.OpenSession(url_session, providerId, validateSession == 1);
return(resHttpResponseMessage);
}
else
{
;
}
ConsoleHelper.Error(string.Format("Open session error: url={0}, StatusCode={1}"
, resHttpResponseMessage.RequestMessage.RequestUri.AbsoluteUri
, resHttpResponseMessage.StatusCode));
this.CloseSession(CatalogApi.UrlConstants.Partslink24ComPartslink24UserLogoutTo);
PartslinkPortal.partslinkIsBlocked = true;
}
else
{
// без разницы force или не force, но сессию возвращать надо!
//if (forceSession == true) {
// url для подтверждения сессии
url_session = CatalogApi.UrlConstants.Partslink24ComPartslink24UserLoginDo;
Task <HttpResponseMessage> session2 = reqHandler.GetSessionAsync(url_session, container);
session2.Wait();
resHttpResponseMessage = session2.Result;
error_session = this.SessionHasError(resHttpResponseMessage);
if (error_session == false)
{
ConsoleHelper.Info(string.Format("Url Navigation to confirmed session: {0}, RequestUri={1}, StatusCode={2}"
, url_session
, resHttpResponseMessage.RequestMessage.RequestUri.AbsoluteUri
, resHttpResponseMessage.StatusCode));
return(resHttpResponseMessage);
}
else
{
;
}
ConsoleHelper.Warning(string.Format("Confirmed session error: url={0}, RequestUri={1}, StatusCode={2}"
, url_session
, resHttpResponseMessage.RequestMessage.RequestUri.AbsoluteUri
, resHttpResponseMessage.StatusCode));
CloseSession();
//// url для новой-повторной сессии - повторный код (см. выше, при отсутствии авторизации)
if ((resHttpResponseMessage.RequestMessage.RequestUri.AbsoluteUri.Contains("login.do") == true)
//|| (reqHandler.NeedAuthorization(url_session, container) == true)
)
{
resHttpResponseMessage = reqHandler.OpenSessionAsync(url_session, container);
error_session = this.SessionHasError(resHttpResponseMessage);
if (error_session == false)
{
ConsoleHelper.Info(string.Format("Url Navigation to reopen-forced session: {0}, RequestUri={1}, StatusCode={2}"
, url_session
, resHttpResponseMessage.RequestMessage.RequestUri.AbsoluteUri
, resHttpResponseMessage.StatusCode));
base.OpenSession(url_session, providerId, false);
return(resHttpResponseMessage);
}
else
{
;
}
ConsoleHelper.Error(string.Format("Reopen-forced session error: url={0}, StatusCode={1}"
, resHttpResponseMessage.RequestMessage.RequestUri.AbsoluteUri
, resHttpResponseMessage.StatusCode));
this.CloseSession(CatalogApi.UrlConstants.Partslink24ComPartslink24UserLogoutTo);
PartslinkPortal.partslinkIsBlocked = true;
}
else
{
;
}
}
//else
// ;
ConsoleHelper.Error("Session obtained faulty");
}
}
return(null);
}
/// <summary>
/// Construct a client with baseUrl and RequestHandler.
/// </summary>
/// <param name="baseUrl">Base Url</param>
/// <param name="requestHandler">Request Handler</param>
protected AbstractRestClient(string baseUrl, IRequestHandler requestHandler) : this(baseUrl, requestHandler, new ConsoleRequestLogger(true))
{
}
public void HandleEvent(IRequestHandler requestHandler, Culture culture)
{
requestHandler.GetService <ICultureManager>().InvalidateCache();
}
public GetInvoiceHandlerTests()
{
_systemUnderTest = new GetInvoiceQueryHandler(_appUnitOfWork, _mapper);
}
public BusResource(IRequestHandler requestHandler)
{
this.RequestHandler = requestHandler;
}
public CreateOrEditViewModelFactory(IRequestHandler requestHandler)
: base(requestHandler)
{
}
public CulturesViewModelFactory(IRequestHandler requestHandler)
: base(requestHandler)
{
}
public VariableViewModelFactory(IRequestHandler requestHandler)
: base(requestHandler)
{
}
public HandlerTests(MaterialQueryTestFixture fixture)
{
_context = fixture.Context;
_handler = new Handler(fixture.Context, fixture.Mapper);
}
public ValidationCommandQueryHandlerDecorator(IRequestHandler <TRequest, TResponse> handler, IEnumerable <IValidator <TRequest> > validators)
{
_handler = handler;
_validators = validators;
}
public BaseModule(IRequestHandler <TRequest, TResponse> requestHandler)
{
this.requestHandler = requestHandler;
}
public PatientFamilyMemberController()
{
requestHandler = new GbApiRequestHandler <PatientFamilyMember>();
}
public ReviewApi(ITmdbEasyClient client)
{
_client = client;
_requestHandler = new RequestHandler(_client);
}
public HandlerTests(UpdateMaterialCommandTestFixture fixture)
{
_context = fixture.Context;
_handler = new Handler(fixture.Context, fixture.Mapper, fixture.AdminRequestContext);
}
public ClassViewModelFactory(IRequestHandler requestHandler)
: base(requestHandler)
{
}
public void HandleEvent(IRequestHandler requestHandler, Variable variable)
{
requestHandler.GetService <IConfigurationManager>().InvalidateCache();
}
public MenuViewModelFactory(IRequestHandler requestHandler)
: base(requestHandler)
{
}
public void AddRoute(string route, HttpRequestMethod method, IRequestHandler handler)
{
this.routes[method].Add(route, handler);
}
public GenericHost(IRequestHandler handler)
{
_handler = handler;
}
public FieldViewModelFactory(IRequestHandler requestHandler)
: base(requestHandler)
{
}
private bool PerformRequest(SimpleHttpRequest request, SimpleHttpResponse response, IRequestHandler handler)
{
using (IContentResponse page = handler.GetResponse(
request.HttpMethod, request.RawUrl, request.Headers, request.InputStream))
{
response.StatusCode = page.Status;
if (page.Status == HttpStatusCode.Redirect || page.Status == HttpStatusCode.Moved ||
page.Status == HttpStatusCode.SeeOther)
{
response.RedirectLocation = page.Redirect;
}
if (!String.IsNullOrEmpty(page.ETag) && page.LastModified > new DateTime(1900, 1, 1))
{
response.LastModified = page.LastModified;
response.ETag = page.ETag;
if ((!String.IsNullOrEmpty(request.Headers["If-None-Match"]) &&
request.Headers["If-None-Match"].Trim('"') == page.ETag)
||
(!String.IsNullOrEmpty(request.Headers["If-Modified-Since"]) &&
request.Headers["If-Modified-Since"] == page.LastModified.ToString("r")))
{
response.StatusCode = HttpStatusCode.NotModified;
return true;
}
}
if (page.Status == HttpStatusCode.OK && (request.HttpMethod == "GET" || request.HttpMethod == "HEAD"))
{
string pb = String.Format("http://{0}{1}", request.Headers["Host"], PingbackHandler.PingbackUrl);
response.AddHeader("X-Pingback", pb);
}
if (page.ContentLength <= 0)
{
response.ContentLength = 0;
}
else
{
response.ContentType = page.ContentType;
bool decompress = page.Compressed;
if (decompress &&
(request.Headers["Accept-Encoding"] ?? "").IndexOf("gzip", StringComparison.OrdinalIgnoreCase) >=
0)
{
decompress = false;
response.ContentEncoding = "gzip";
}
else if (decompress &&
(request.Headers["TE"] ?? "").IndexOf("gzip", StringComparison.OrdinalIgnoreCase) >= 0)
{
decompress = false;
response.TransferEncoding = "gzip";
}
int contentLength = (page.Compressed && !decompress) ? page.CompressedLength : page.ContentLength;
response.ContentLength = contentLength;
if (request.HttpMethod == "HEAD")
{
//no-content
}
else if (page.Compressed && decompress)
{
response.Write(page.ContentBytes, 0, contentLength);
}
else if (page.HasFile)
{
response.TransmitFile(page.ContentFile, 0, contentLength);
}
else if (page.Compressed)
{
response.Write(page.CompressedBytes, 0, contentLength);
}
else
{
response.Write(page.ContentBytes, 0, contentLength);
}
}
return true;
}
}
/// <summary>
/// Instantiates a new BoxService with the provided handler
/// </summary>
/// <param name="handler"></param>
public BoxService(IRequestHandler handler)
{
_handler = handler;
}
public PatientController()
{
requestHandlerPatient = new GbApiRequestHandler <Patient>();
requestHandlerAddPatient = new GbApiRequestHandler <AddPatient>();
}
public DiagnosisCodeController()
{
requestHandler = new GbApiRequestHandler <DiagnosisCode>();
}
public PostRequest(IRequestHandler requestHandler, string endpoint)
: base(requestHandler, endpoint, HttpMethod.Post)
{
}
public CreateOrEditViewModelMapper(IRequestHandler requestHandler)
: base(requestHandler)
{
}
public GetAllCustomersQueryTests()
{
_getAllCustomersQueryHandler = new GetAllCustomersQueryHandler(AllMarktQueryContextIM);
}
public IndexViewModelFactory(IRequestHandler requestHandler)
: base(requestHandler)
{
}
