private static void PublishWorkerResponse(ICoreClient client, InternalRequest internalRequest, string hostInstance) { if (internalRequest.Status == RequestStatusEnum.Undefined) { throw new ArgumentNullException("status"); } WorkerResponse response = new WorkerResponse() { RequestId = internalRequest.RequestId.ToString(), WorkerHostComputer = Environment.MachineName, WorkerHostInstance = hostInstance, Status = internalRequest.Status, FaultDetail = internalRequest.FaultDetail }; UserIdentity requesterId = null; if (internalRequest.ExternalRequest != null) { requesterId = internalRequest.ExternalRequest.RequesterId; } if ((requesterId == null) && (internalRequest.Cancellation != null)) { requesterId = internalRequest.Cancellation.RequesterId; } response.RequesterId = requesterId; if ((response.Status == RequestStatusEnum.Cancelled) && (internalRequest.Cancellation != null)) { response.CancelReason = internalRequest.Cancellation.CancelReason; } client.SaveObject <WorkerResponse>(response); }
public async Task UpdateSecurityClearance(PerformContext hangfireContext, WorkerResponse spdResponse, string id) { var filter = "adoxio_workerjobnumber eq '" + id + "'"; List <string> expand = new List <string> { "adoxio_WorkerId" }; MicrosoftDynamicsCRMadoxioPersonalhistorysummary response = null; try { response = _dynamics.Personalhistorysummaries.Get(filter: filter).Value.FirstOrDefault(); } catch (OdataerrorException odee) { hangfireContext.WriteLine("Unable to get personal history summary."); hangfireContext.WriteLine("Request:"); hangfireContext.WriteLine(odee.Request.Content); hangfireContext.WriteLine("Response:"); hangfireContext.WriteLine(odee.Response.Content); _logger.LogError("Unable to get personal history summary."); _logger.LogError("Request:"); _logger.LogError(odee.Request.Content); _logger.LogError("Response:"); _logger.LogError(odee.Request.Content); throw odee; } MicrosoftDynamicsCRMadoxioPersonalhistorysummary patchPHS = new MicrosoftDynamicsCRMadoxioPersonalhistorysummary { AdoxioSecuritystatus = (int)Enum.Parse(typeof(SecurityStatusPicklist), spdResponse.Result, true), AdoxioCompletedon = spdResponse.DateProcessed }; try { await _dynamics.Personalhistorysummaries.UpdateAsync(response.AdoxioPersonalhistorysummaryid, patchPHS); } catch (OdataerrorException odee) { hangfireContext.WriteLine("Unable to patch personal history summary."); hangfireContext.WriteLine("Request:"); hangfireContext.WriteLine(odee.Request.Content); hangfireContext.WriteLine("Response:"); hangfireContext.WriteLine(odee.Response.Content); _logger.LogError("Unable to patch personal history summary."); _logger.LogError("Request:"); _logger.LogError(odee.Request.Content); _logger.LogError("Response:"); _logger.LogError(odee.Request.Content); throw odee; } }
private CoffeeServiceResult ToCoffeeServiceResult(WorkerResponse response) { switch (response?.Status) { case WorkStatus.Ok: return(new CoffeeServiceResult(StatusCodes.Status200OK) { Progress = response.Progress }); case WorkStatus.BadLogin: return(new CoffeeServiceResult(StatusCodes.Status401Unauthorized) { Message = "Invalid user name or password" }); case WorkStatus.CafeClosed: return(new CoffeeServiceResult(StatusCodes.Status503ServiceUnavailable) { Message = "The café is closed" }); case WorkStatus.Conflict: return(new CoffeeServiceResult(StatusCodes.Status409Conflict) { Message = "An order is already in progress" }); case WorkStatus.Error: return(new CoffeeServiceResult(StatusCodes.Status500InternalServerError) { Message = "Internal server error" }); case null: return(new CoffeeServiceResult(StatusCodes.Status504GatewayTimeout) { Message = "Request timed out" }); default: _log.LogError("Unknown response status {Status}", response.Status); return(new CoffeeServiceResult(StatusCodes.Status500InternalServerError) { Message = "Internal server error" }); } }
public ProgressObj(Guid requestId, DateTimeOffset created, ProgressObj lastProgress, ResponseBase response) : this(requestId, created, lastProgress, response.RequesterId) { if (response.FaultDetail != null) { ExcpName = response.FaultDetail.ShortName; ExcpText = response.FaultDetail.Message; } // response subtypes HandlerResponse handlerResponse = response as HandlerResponse; if (handlerResponse != null) { if (response.Status == RequestStatusEnum.Undefined) { throw new ArgumentNullException("status"); } HandlerStatus = response.Status; if (handlerResponse.CommenceTime != null) { Commenced = DateTimeOffset.Parse(handlerResponse.CommenceTime); } ItemCount = handlerResponse.ItemCount; ItemsPassed = handlerResponse.ItemsPassed; ItemsFailed = handlerResponse.ItemsFailed; } WorkerResponse workerResponse = response as WorkerResponse; if (workerResponse != null) { if (response.Status == RequestStatusEnum.Undefined) { throw new ArgumentNullException("status"); } WorkerStatus = response.Status; WorkerHost = String.Format("{0}.{1}", workerResponse.WorkerHostComputer, workerResponse.WorkerHostInstance ?? "Default"); } ManagerResponse managerResponse = response as ManagerResponse; if (managerResponse != null) { if (response.Status == RequestStatusEnum.Undefined) { throw new ArgumentNullException("status"); } ManagerStatus = response.Status; } }
public void HandleResponse(WorkerResponse response) { lock (_pendingLock) { if (_pending.ContainsKey(response.Guid)) { WorkItem item = _pending[response.Guid]; item.Response = response; // The below cancellation must be inside the lock to ensure that the // CancellationTokenSource can not have been disposed in WorkAsync(). item.Cancellation.Cancel(); return; } } _log.LogWarning("Response {ResponseGuid} was discarded as no-one was waiting for it", response.Guid); }
/// <summary> /// Sends the response message to the master using HTTP Post. /// </summary> /// <param name="body">The body of the message. Should be a serialized "Response" model.</param> public void SendResponse(WorkerResponse response) { Task.Run(async() => { using (var client = GetClient()) { var tClient = new TelemetryClient(); var postAsJsonAsync = await client.PostAsJsonAsync(_masterUrl, response); var statusCode = postAsJsonAsync.StatusCode; if (statusCode == HttpStatusCode.OK) { tClient.TrackEvent(response.Guid + " Response sent"); Console.WriteLine("----- Message sent -----"); } else { tClient.TrackEvent("There was an error (CODE: " + statusCode.ToString() + ") while sending response " + response.Guid); } } }); }
public void CanMapDomainWorkerToResponse() { var domainWorker = TestHelpers.CreateWorker().ToDomain(true); var expectedResponse = new WorkerResponse { Id = domainWorker.Id, Role = domainWorker.Role, Email = domainWorker.Email, Teams = domainWorker.Teams, AllocationCount = domainWorker.AllocationCount, ContextFlag = domainWorker.ContextFlag, CreatedBy = domainWorker.CreatedBy, DateStart = domainWorker.DateStart?.ToString("s") ?? "", FirstName = domainWorker.FirstName, LastName = domainWorker.LastName }; var response = domainWorker.ToResponse(); response.Should().BeEquivalentTo(expectedResponse); }
public static List <Worker> GetWorkers(string address, SocketUser user) { if (address == null) { UserAccount userAccount = GetUser(user); if (userAccount != null) { address = userAccount.address; } else { address = ""; } } HttpWebRequest request = (HttpWebRequest)WebRequest.Create(Global.nanopoolWorkers + address); request.ContentType = "application/json; charset=utf-8"; HttpWebResponse response = request.GetResponse() as HttpWebResponse; string data = ""; using (Stream responseStream = response.GetResponseStream()) { StreamReader reader = new StreamReader(responseStream, Encoding.UTF8); data = reader.ReadToEnd(); } WorkerResponse r = JsonConvert.DeserializeObject <WorkerResponse>(data); List <Worker> workers = null; if (r.status != false) { workers = r.data; } else { return(null); } return(workers); }
private void HandleRequest(WorkerRequest request) { // Select the specific handler type. RequestHandlerBase handler = request.Order == null ? (RequestHandlerBase) new PeekRequestHandler() : new OrderRequestHandler(); WorkerResponse response; // Call the handler. try { response = handler.HandleAsync(request).Result; } catch (Exception ex) { _log.WriteEntry($"Exception: {ex}", EventLogEntryType.Error); response = new WorkerResponse(WorkStatus.Error); } // Send the response. response.Guid = request.Guid; _hubConnection.InvokeAsync("RespondAsync", response); _log.WriteEntry($"Sending response {response.Guid} for user {request.Username}"); }
public WorkerResponse ExecuteRequest(WorkerRequest request) { var commandNr = 1; var commandResults = new List <string>(); _driver.Navigate().GoToUrl(request.RootUrl); foreach (var command in request.Commands) { var success = command.Execute(_driver); commandResults.Add("Command nr " + commandNr + " '" + command.Cmd + "' - " + (success ? "success" : "failed")); commandNr++; } var response = new WorkerResponse { Assertions = commandResults, Guid = request.Guid, Timestamp = request.Timestamp }; if (request.ReturnHtml) { response.HtmlBody = _driver.PageSource; } return(response); }
public Task RespondAsync(WorkerResponse response) { _handler.HandleResponse(response); return(Task.CompletedTask); }
public override async Task <WorkerResponse> HandleAsync(WorkerRequest request) { // Validate request. string validationError = request.Order.Validate(); if (validationError != null) { throw new Exception("Validation error not caught by front end: " + validationError); } // Log in. WorkerResponse loginResult = await LogInAsync(request); if (loginResult.Status != WorkStatus.Ok) { return(loginResult); } // Make sure an order is not already in progress. if (loginResult.Progress.QueuePosition.HasValue) { return(new WorkerResponse(WorkStatus.Conflict)); } // Prepare the order. Dictionary <string, string> formValues = new Dictionary <string, string>(); PopulateFormValues(request.Order, formValues); AddCsrf(formValues); // Submit the order. Document = new HtmlDocument(); using (HttpRequestMessage orderPostRequest = new HttpRequestMessage(HttpMethod.Post, "/")) using (FormUrlEncodedContent form = new FormUrlEncodedContent(formValues)) { AddCookies(orderPostRequest.Headers); orderPostRequest.Content = form; using (HttpResponseMessage orderPostResponse = await Http.SendAsync(orderPostRequest)) { Document.Load(await orderPostResponse.Content.ReadAsStreamAsync()); } } // Make sure the order succeeded. if (Document.DocumentNode.SelectSingleNode("//h2[text()='Thankyou']") == null) { throw new Exception("Unexpected post-order page: " + Document.DocumentNode.OuterHtml); } // Using the same session, check the queue position. Document = new HtmlDocument(); using (HttpRequestMessage queueGetRequest = new HttpRequestMessage(HttpMethod.Get, "/")) { AddCookies(queueGetRequest.Headers); using (HttpResponseMessage queueGetResponse = await Http.SendAsync(queueGetRequest)) { Document.Load(await queueGetResponse.Content.ReadAsStreamAsync()); } } return(ExtractPosition()); }
private void ProcessRequests(object notUsed) { try { // process rules and run handlers as required BasicServerState state = this.GetState(); if (state != BasicServerState.Running) { return; } // subscription is ready and callback flood has stopped List <InternalRequest> existingRequests = new List <InternalRequest>(); List <InternalRequest> enqueuedRequests = new List <InternalRequest>(); List <InternalRequest> cancelledRequests = new List <InternalRequest>(); var requestItems = _AssignedRequestsCache.Items; var cancellationItems = _CancellationsCache.Items; var responseItems = _WorkerResponseCache.Items; _InternalRequests.Locked((internalRequests) => { // - process responses foreach (ICoreItem item in responseItems) { try { WorkerResponse response = (WorkerResponse)item.Data; Guid requestId = Guid.Parse(response.RequestId); InternalRequest internalRequest; if (!internalRequests.TryGetValue(requestId, out internalRequest)) { internalRequest = new InternalRequest(requestId); } internalRequest.Status = response.Status; internalRequests[requestId] = internalRequest; } catch (Exception excp) { Logger.Log(excp); } } // - process requests foreach (ICoreItem item in requestItems) { try { AssignedWorkflowRequest request = (AssignedWorkflowRequest)item.Data; Guid requestId = Guid.Parse(request.RequestId); InternalRequest internalRequest; if (!internalRequests.TryGetValue(requestId, out internalRequest)) { internalRequest = new InternalRequest(requestId); } internalRequest.ExternalRequest = request; internalRequests[requestId] = internalRequest; } catch (Exception excp) { Logger.Log(excp); } } // - process cancellations foreach (ICoreItem item in cancellationItems) { try { CancellationRequest cancellation = (CancellationRequest)item.Data; Guid requestId = Guid.Parse(cancellation.RequestId); InternalRequest internalRequest; if (!internalRequests.TryGetValue(requestId, out internalRequest)) { internalRequest = new InternalRequest(requestId); } internalRequest.Cancellation = cancellation; internalRequests[requestId] = internalRequest; } catch (Exception excp) { Logger.Log(excp); } } // determine requests to be launched or cancelled foreach (InternalRequest internalRequest in internalRequests.Values) { if ((internalRequest.ExternalRequest != null) && ((internalRequest.Status == RequestStatusEnum.Undefined) || (internalRequest.Status == RequestStatusEnum.Enqueued))) { // find requests to launch if (internalRequest.Cancellation == null) { if (internalRequest.Status != RequestStatusEnum.Enqueued) { // new request internalRequest.Status = RequestStatusEnum.Enqueued; enqueuedRequests.Add(internalRequest); } existingRequests.Add(internalRequest); } else { // cancelled internalRequest.Status = RequestStatusEnum.Cancelled; cancelledRequests.Add(internalRequest); } } } }); // publish status for cancelled and enqueued requests foreach (InternalRequest request in cancelledRequests) { PublishWorkerResponse(_IntClient.Target, request, HostInstance); } // now find handlers to launch foreach (InternalRequest request in enqueuedRequests) { // publish enqueued status PublishWorkerResponse(_IntClient.Target, request, HostInstance); } foreach (InternalRequest request in existingRequests) { // launch if handler available int count = Interlocked.Decrement(ref _HandlersAvailable); if (count >= 0) { Interlocked.Increment(ref _AvailabilityChangeCount); Interlocked.Increment(ref _HandlersExecuting); // publish launched status request.Status = RequestStatusEnum.Launched; PublishWorkerResponse(_IntClient.Target, request, HostInstance); // launch ThreadPool.QueueUserWorkItem(Launch, new LaunchPackage(_IntClient, request)); } else { Interlocked.Increment(ref _HandlersAvailable); } } // publish availability (throttled) int changeCount = Interlocked.Exchange(ref _AvailabilityChangeCount, 0); if ((changeCount > 0) || ((DateTimeOffset.Now - _AvailabilityLastPublished) > TimeSpan.FromSeconds(5))) { _IntClient.Target.SaveObject <WorkerAvailability>(new WorkerAvailability() { WorkerHostComputer = Environment.MachineName, WorkerHostInstance = this.HostInstance, AvailableNodeCount = Interlocked.Add(ref _HandlersAvailable, 0) }); _AvailabilityLastPublished = DateTimeOffset.Now; } } catch (Exception e) { Logger.Log(e); } }