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);
}
}
