/// <summary>Initializes a new instance of the <see cref="ResponseMessageResult"/> class.</summary>
/// <param name="response">The response message.</param>
public ResponseMessageResult(HandlerResponse response)
{
if (response == null)
{
throw new ArgumentNullException("response");
}
this.response = response;
}
/// <summary>Initializes a new instance of the <see cref="ResponseMessageResult"/> class.</summary>
/// <param name="response">The response message.</param>
public ResponseMessageResult(HandlerResponse response)
{
if (response == null)
{
throw new ArgumentNullException("response");
}
this.response = response;
}
/// <summary>
/// Value and Test the portfolio
/// </summary>
/// <param name="portfolioId"></param>
/// <param name="irScenarios">Optional IR Scenarios</param>
/// <param name="fxScenarios">Optional FX Scenarios</param>
private static void ValueAndTestPortfolio(string portfolioId, string[] irScenarios = null, string[] fxScenarios = null)
{
foreach (var testMarketName in TestMarketNames)
{
PortfolioValuationRequest request = CreateRequest(portfolioId, testMarketName, null, irScenarios, fxScenarios);
HandlerResponse result = ExecuteTradeValuation(request);
AssertValuation(result);
}
}
public InternalPortfRevalRequest(Guid requestId, DateTimeOffset created)
{
RequestId = requestId;
Created = created;
LatestResult = new HandlerResponse
{
RequestId = requestId.ToString()
};
}
private static async Task <HandlerResponse> InvokeActionAsyncCore(CommandHandlerContext context, CancellationToken cancellationToken)
{
Contract.Requires(context != null);
Contract.Requires(context.Descriptor != null);
CommandHandlerDescriptor handlerDescriptor = context.Descriptor;
try
{
object result = await handlerDescriptor.ExecuteAsync(context, cancellationToken);
// This is cached in a local for performance reasons. ReturnType is a virtual property on CommandHandlerDescriptor,
// or else we'd want to cache this as part of that class.
bool isDeclaredTypeHandlerResult = typeof(ICommandHandlerResult).IsAssignableFrom(handlerDescriptor.ReturnType);
if (result == null && isDeclaredTypeHandlerResult)
{
// If the return type of the action descriptor is IHandlerResult, it's not valid to return null
throw Error.InvalidOperation(Resources.DefaultHandlerInvoker_NullHandlerResult);
}
if (isDeclaredTypeHandlerResult || handlerDescriptor.ReturnType == typeof(object))
{
ICommandHandlerResult actionResult = result as ICommandHandlerResult;
if (actionResult == null && isDeclaredTypeHandlerResult)
{
// If the return type of the action descriptor is IHandlerResult, it's not valid to return an
// object that doesn't implement IHandlerResult
throw Error.InvalidOperation(Resources.DefaultHandlerInvoker_InvalidHandlerResult, result.GetType());
}
if (actionResult != null)
{
HandlerResponse response = await actionResult.ExecuteAsync(cancellationToken);
if (response == null)
{
throw Error.InvalidOperation(Resources.DefaultHandlerInvoker_NullHandlerResponse);
}
HandlerResponse.EnsureResponseHasRequest(response, context.Request);
return(response);
}
}
// This is a non-IHandlerResult, so run the converter
return(handlerDescriptor.ResultConverter.Convert(context, result));
}
catch (HandlerResponseException handlerResponseException)
{
HandlerResponse response = handlerResponseException.Response;
HandlerResponse.EnsureResponseHasRequest(response, context.Request);
return(response);
}
}
public async Task <HandlerResponse> Move(Position position)
{
Console.WriteLine($"Move (X={position.X}, Y={position.Y}, Z={position.Z})");
var response = new HandlerResponse()
{
Status = CommandStatus.Ack, Type = "Move", position = position
};
return(response);
}
public static void ExecuteHandler(string controllerName, HttpContext context, string actionName)
{
//if (!context.Request.ContentType.StartsWith("application/json", StringComparison.OrdinalIgnoreCase))
//{
// context.Response.Write(new HandlerResponse() { Message = "只支持json传输协议", Result = 0 }.ToString());
// return;
//}
IAppHandler handler;
if (s_Handlers.TryGetValue(controllerName, out handler))
{
handler.HttpContext = context;
//下一步找到Action的参数
bool hasAction = false;
foreach (var action in handler.ActionMethods)
{
if (action.Name.ToLower() == actionName.ToLower())
{// 有操作的方法action
hasAction = true;
ActionExcute excute = new ActionExcute();
HandlerResponse handlerResponse = excute.BindParamToAction(action, context, handler);
if (handlerResponse != null)
{
if (handlerResponse.Result == 101)
{
context.Response.Write(handlerResponse.Message);
}
else
{
context.Response.Write(handlerResponse.ToString());
}
}
break;
}
}
if (!hasAction)
{
context.Response.Write(new HandlerResponse()
{
Message = "不存在操作方法", Result = 0
}.ToString());
return;
}
}
else
{
context.Response.Write(new HandlerResponse()
{
Message = "不存在操作对象", Result = 0
}.ToString());
}
// context.Response.Write(handler.CreateInstance().ProcessRequest(context).ToString());
}
HandlerResponse IMessageHandler.Handle(PersistedMessage message)
{
TestMessage m = JsonConvert.DeserializeObject <TestMessage>(message.PayLoad);
//if (message.RetryCount == 0) {
// Console.WriteLine("Recieved {0}, rescheduling", m.Property);
// return HandlerResponse.Retry(TimeSpan.FromMinutes(1));
//} else {
Console.WriteLine("processing {0}", m.Property);
return(HandlerResponse.Handled());
//}
}
public InternalTradeRevalRequest(Guid requestId, DateTimeOffset created, TradeValuationRequest pvReq)
{
RequestId = requestId;
Created = created;
Request = pvReq;
LatestResult = new HandlerResponse
{
RequestId = pvReq.RequestId,
//RequesterData = pvReq.TradeId,
Status = RequestStatusEnum.Received
};
}
/// <summary>
/// Value and Test the portfolio
/// </summary>
/// <param name="portfolioId"></param>
private static void ValueTradeDebug(string portfolioId)
{
var irScenarios = new[] { ScenarioConst.Unstressed };
//var curveTypes = new[] { "RateCurve" };
//ExecuteCurveStressing(TestMarketNames, curveTypes, Generate_All_RateCurveNames());
foreach (var testMarketName in TestMarketNames)
{
PortfolioValuationRequest request = CreateRequest(portfolioId, testMarketName, null, irScenarios);
HandlerResponse result = ExecuteTradeValuation(request);
PrintValuation(result);
}
}
private static void AssertValuation(HandlerResponse result)
{
// Load valuationItems for the current request Id
List <ICoreItem> rawValuationItems =
Engine.Cache.LoadItems <ValuationReport>(Expr.BoolAND(Expr.IsNull(ValueProp.Aggregation),
Expr.IsEQU(RequestBase.Prop.RequestId, Guid.Parse(result.RequestId))));
foreach (ICoreItem valuationItem in rawValuationItems)
{
// Extract the valuation report
var valuation = (ValuationReport)valuationItem.Data;
// Check that the valuation returned successfully
var excpName = valuationItem.AppProps.GetValue <string>(WFPropName.ExcpName, null);
if (excpName != null)
{
// valuation failed - log details
var excpText = valuationItem.AppProps.GetValue <string>(WFPropName.ExcpText, null);
UTE.Logger.LogError(
"Valuation failed:" +
"{0} UniqueId : {1}" +
"{0} Exception: {2}: '{3}'",
Environment.NewLine,
valuationItem.Name, excpName, excpText);
Assert.Fail(excpName, $"Workflow error ({excpName})");
}
// check for errors
var tradeSource = valuationItem.AppProps.GetValue <string>(TradeProp.TradeSource);
var tradeId = valuationItem.AppProps.GetValue <string>(TradeProp.TradeId);
var marketName = valuationItem.AppProps.GetValue <string>(CurveProp.Market);
var key = $"{tradeSource}_{tradeId}_{marketName}_{InstrumentMetrics.NPV}".ToLower();
// Assert expected value has been supplied
Assert.IsTrue(ExpectedValues.ContainsKey(key), $"ExpectedValue for key:({key}) is missing.");
ExpectedValue expectedValue = ExpectedValues[key];
Quotation quote = valuation.GetFirstQuotationForMetricName(InstrumentMetrics.NPV.ToString());
Assert.IsNotNull(quote, $"CalculatedValue for key:({key}) is missing.");
Assert.IsTrue(quote.valueSpecified, $"CalculatedValue for key:({key}) is missing.");
decimal calculatedNPV = quote.value;
decimal differenceNPV = expectedValue.OutputNPV - calculatedNPV;
Assert.IsFalse(System.Math.Abs(differenceNPV) > ToleranceNPV,
$"ToleranceExceeded(|{differenceNPV:F0}| > {ToleranceNPV:F0})");
}
}
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;
}
}
private static void PrintValuation(HandlerResponse result)
{
// Load valuationItems for the current request Id
List <ICoreItem> rawValuationItems =
Engine.Cache.LoadItems <ValuationReport>(Expr.BoolAND(Expr.IsNull(ValueProp.Aggregation),
Expr.IsEQU(RequestBase.Prop.RequestId, Guid.Parse(result.RequestId))));
foreach (ICoreItem valuationItem in rawValuationItems)
{
Debug.Print(XmlSerializerHelper.SerializeToString(valuationItem.AppProps.Serialise()));
// Extract the valuation report
var valuation = (ValuationReport)valuationItem.Data;
XmlSerializerHelper.SerializeToFile(valuation, valuationItem.Name);
//Debug.Print(valuationItem.Text);
}
}
public async Task <HandlerResponse <IEnumerable <User> > > Handle(GetUsersRequest request, CancellationToken cancellationToken)
{
HandlerResponse <IEnumerable <User> > response;
try
{
var users = await _dataContext.Users.AsNoTracking().OrderBy(u => u.Id).ToListAsync();
response = new HandlerResponse <IEnumerable <User> >(users);
}
catch (DbException)
{
response = new HandlerResponse <IEnumerable <User> >($"Unable to get Users");
}
return(response);
}
/// <summary>
/// Converts the result of an handler to an instance of <see cref="HandlerResponse"/>.
/// </summary>
/// <param name="context">The conversion context.</param>
/// <param name="handlerResult">The result to convert.</param>
/// <returns>A <see cref="HandlerResponse"/>.</returns>
/// <exception cref="InvalidOperationException"></exception>
public HandlerResponse Convert(CommandHandlerContext context, object handlerResult)
{
if (context == null)
{
throw Error.ArgumentNull("context");
}
HandlerResponse response = (HandlerResponse)handlerResult;
if (response == null)
{
throw Error.InvalidOperation(Resources.DefaultHandlerInvoker_NullHandlerResponse);
}
HandlerResponse.EnsureResponseHasRequest(response, context.Request);
return(response);
}
private void ReceivePortfolioValuationRequest(ICoreItem item)
{
DateTimeOffset created = item.Created;
var pvRequest = (PortfolioValuationRequest)item.Data;
var requestId = new Guid(pvRequest.RequestId);
// ignore requests if we are not running
// ignore requests not processed by this server instance
if ((GetState() != BasicServerState.Running) ||
((requestId.GetHashCode() % ServerFarmSize) != ServerInstance))
{
return;
}
InternalPortfRevalRequest newRequest = null;
_outstandingRequests.Locked(requests =>
{
InternalPortfRevalRequest oldRequest;
if (!requests.TryGetValue(requestId, out oldRequest))
{
// not found
newRequest = new InternalPortfRevalRequest(requestId, created);
}
if (newRequest != null)
{
newRequest.Request = pvRequest;
newRequest.LatestResult.Status = RequestStatusEnum.Received;
requests[requestId] = newRequest;
}
});
var response = new HandlerResponse
{
RequestId = newRequest.RequestId.ToString(),
RequesterId = newRequest.Request.RequesterId ?? new UserIdentity {
Name = IntClient.Target.ClientInfo.Name, DisplayName = "Unknown"
},
//RequesterData = newRequest.Request.PortfolioId,
Status = newRequest.LatestResult.Status
};
_workContext.Cache.SaveObject(response);
// dispatch worker request
_workerEventQueue.Dispatch(null);
}
private void ReceiveCancellationRequest(ICoreItem item)
{
//DateTimeOffset created = item.Created;
var cancelRequest = (CancellationRequest)item.Data;
var requestId = new Guid(cancelRequest.RequestId);
// ignore requests if we are not running
if (GetState() != BasicServerState.Running)
{
return;
}
// get current request and cancel it
InternalPortfRevalRequest internalRequest = null;
_outstandingRequests.Locked(requests =>
{
if (!requests.TryGetValue(requestId, out internalRequest))
{
return; // does not exist or is not ours - just exit
}
internalRequest.Cancellation = cancelRequest;
internalRequest.LatestResult.Status = RequestStatusEnum.Cancelled;
});
WFCalculatePortfolioStressValuation workflow = internalRequest.Workflow;
workflow?.Cancel(cancelRequest.CancelReason);
var response = new HandlerResponse
{
RequestId = internalRequest.RequestId.ToString(),
RequesterId = internalRequest.Request.RequesterId ?? new UserIdentity {
Name = IntClient.Target.ClientInfo.Name, DisplayName = "Unknown"
},
//RequesterData = internalRequest.Request.PortfolioId,
Status = internalRequest.LatestResult.Status
};
_workContext.Cache.SaveObject(response);
// dispatch worker request
_workerEventQueue.Dispatch(null);
}
private static void HandleSpecificRequest <R, W>(ILogger logger, ICoreCache cache, string requestItemName)
where R : RequestBase
where W : WorkstepBase <RequestBase, HandlerResponse>, IRequestHandler <RequestBase, HandlerResponse>, new()
{
R request = cache.LoadObject <R>(requestItemName);
if (request == null)
{
throw new ApplicationException(String.Format("Request not found (type={0},name='{1}')", typeof(R).Name, requestItemName));
}
// publish 'initial' status
HandlerResponse response = new HandlerResponse()
{
RequestId = request.RequestId,
RequesterId = request.RequesterId,
Status = RequestStatusEnum.Commencing,
CommenceTime = DateTimeOffset.Now.ToString("o")
};
cache.SaveObject <HandlerResponse>(response);
try
{
using (IRequestHandler <RequestBase, HandlerResponse> handler = new W() as IRequestHandler <RequestBase, HandlerResponse>)
{
handler.InitialiseRequest(logger, cache);
handler.ProcessRequest(request, response);
}
}
catch (OperationCanceledException cancelExcp)
{
response.Status = RequestStatusEnum.Cancelled;
response.CancelReason = cancelExcp.Message;
}
catch (Exception outerExcp)
{
response.Status = RequestStatusEnum.Faulted;
response.FaultDetail = new ExceptionDetail(outerExcp);
logger.Log(outerExcp);
}
// publish 'completed' status
cache.SaveObject <HandlerResponse>(response);
}
private void ReceiveTradeValuationRequest(ICoreItem pvReqItem)
{
DateTimeOffset created = pvReqItem.Created;
var pvReq = (TradeValuationRequest)pvReqItem.Data;
var requestId = new Guid(pvReq.RequestId);
// ignore requests if we are not running
// ignore requests not processed by this server instance
if ((GetState() != BasicServerState.Running) ||
((requestId.GetHashCode() % ServerFarmSize) != ServerInstance))
{
return;
}
var newRequest = new InternalTradeRevalRequest(requestId, created, pvReq);
InternalTradeRevalRequest oldRequest = null;
_outstandingRequests.Locked(requests =>
{
if (requests.TryGetValue(requestId, out oldRequest))
{
// exists
newRequest.LatestResult = oldRequest.LatestResult;
}
requests[requestId] = newRequest;
});
if (oldRequest == null)
{
var response = new HandlerResponse
{
RequestId = pvReq.RequestId,
RequesterId = pvReq.RequesterId ?? new UserIdentity {
Name = IntClient.Target.ClientInfo.Name, DisplayName = "Unknown"
},
//RequesterData = pvReq.TradeId,
Status = RequestStatusEnum.Received
};
_workContext.Cache.SaveObject(response);
}
// dispatch worker request
_workerEventQueue.Dispatch(null);
}
public HandlerResponse Create(TCommand input)
{
// do validation
var validationResults = _businessRules.ToList().Select(br => br.IsValid(input)).ToList();
var isNotValid = validationResults.Any(vr => !vr.IsValid);
if (isNotValid)
{
return(HandlerResponse.Failed(
string.Join(", ",
validationResults.Select(vr => string.Join(", ", vr.Messages)))));
}
var entity = _tRepository.Get(input.Id);
_tRepository.Delete(entity);
return(HandlerResponse.Success("Delete!", 1));
}
static void Main(string[] args)
{
IMessageHandler rookie = new MessageHandler(new Checker("rookie", 5000));
IMessageHandler sophomore = new MessageHandler(new Checker("sophomore", 10000));
IMessageHandler junior = new MessageHandler(new Checker("junior", 15000));
IMessageHandler senior = new MessageHandler(new Checker("senior", 20000));
rookie.RegisterNext(sophomore);
sophomore.RegisterNext(junior);
junior.RegisterNext(senior);
Console.WriteLine("Put some money to prove the service:");
var total = Console.ReadLine();
ICheckReport report = new CheckReport(int.Parse(total));
HandlerResponse response = rookie.Check(report);
Console.WriteLine("The response is {0}!", response);
Console.ReadKey();
}
public HandlerResponse Create(TCommand input)
{
// do validation
var validationResults = _businessRules.ToList().Select(br => br.IsValid(input)).ToList();
var isNotValid = validationResults.Any(vr => !vr.IsValid);
if (isNotValid)
{
return(HandlerResponse.Failed(
string.Join(", ",
validationResults.Select(vr => string.Join(", ", vr.Messages)))));
}
var mapper = _commandMapperFactory.Create <TCommand, TEntity>();
var entity = mapper.Create(input);
var id = _tRepository.InsertAndGetId(entity);
return(HandlerResponse.Success("Created", id));
}
private bool HandlerResponseRequester(string response)
{
Dictionary <string, dynamic> result;
try
{
result = JsonConvert.DeserializeObject <Dictionary <string, dynamic> >(response);
}
catch (JsonException e)
{
throw new InternalException("SlicingDice: Internal error");
}
var handlerResponse = new HandlerResponse(result);
if (handlerResponse.RequestSuccessful())
{
return(true);
}
return(false);
}
public void TestExecuteActionAndGetResponse()
{
CatalogApp app = new CatalogApp();
Dictionary <string, string> parameters = new Dictionary <string, string>();
parameters.Add("Name", "Python");
string action = "NEW_WORKSHOP";
HandlerResponse response = app.ExecuteActionAndGetResponse(action, parameters);
string result =
"<workshops>" +
"<workshop id='efcv4d' name='C++' status='Open' duration='22 Jan. 2019 ~ 15 Feb. 2019'></workshop>" +
"<workshop id='74d5jh' name='C#' status='Closed' duration='2 May. 2018 ~ 19 May. 2018'></workshop>" +
"<workshop id='r982jk' name='DDD' status='Open' duration='15 Dec. 2019 ~ 15 Mar. 2020'></workshop>" +
"<workshop id='57adf0' name='Python' status='Open' duration='Unknown'></workshop>" +
"</workshops>";
Assert.AreEqual(result, response.GetXmlString());
}
public HandlerResponse Convert(CommandHandlerContext context, object handlerResult)
{
if (context == null)
{
throw Error.ArgumentNull("context");
}
HandlerResponse resultAsResponse = handlerResult as HandlerResponse;
if (resultAsResponse != null)
{
HandlerResponse.EnsureResponseHasRequest(resultAsResponse, context.Request);
return(resultAsResponse);
}
#if LOOSE_CQRS
T value = (T)handlerResult;
return(context.Request.CreateResponse(value));
#else
return(context.Request.CreateResponse());
#endif
}
private static async Task <HandlerResponse> HandleAsyncCore(IExceptionHandler handler, ExceptionHandlerContext context, CancellationToken cancellationToken)
{
Contract.Assert(handler != null);
Contract.Assert(context != null);
await handler.HandleAsync(context, cancellationToken);
ICommandHandlerResult result = context.Result;
if (result == null)
{
return(null);
}
HandlerResponse response = await result.ExecuteAsync(cancellationToken);
if (response == null)
{
throw Error.ArgumentNull(Resources.TypeMethodMustNotReturnNull, typeof(ICommandHandlerResult).Name, "ExecuteAsync");
}
return(response);
}
public void ProcessRequest(HttpContext context)
{
try
{
context.Response.ContentType = "text/plain";
HttpRequest Request = context.Request;
HttpResponse Response = context.Response;
//防止数据泄露，以后可以去掉
if (Request.RequestType.Trim().ToLower() == "get" && Request.QueryString["controller"] != "gloab" && Request.QueryString["controller"] != "checkcode")
{
HandlerResponse hresult = new HandlerResponse {
Result = -1, Message = "不支持GET请求"
};
Response.Write(hresult.ToString());
}
else
{
string handlerName = Request.Params["controller"];
if (string.IsNullOrEmpty(handlerName) && string.IsNullOrEmpty(Request.QueryString["controller"]))
{
return;
}
AppHandlerManager.ExecuteHandler(handlerName, HttpContext.Current, Request.QueryString["action"]);
}
context.ApplicationInstance.CompleteRequest();
}
catch (Exception ex)
{
if (ex is ThreadAbortException)
{
}
Logger.CurrentLog.Error(ex.Message, ex);
}
}
public async Task <HandlerResponse <bool> > Handle(UpdateUserRequest request, CancellationToken cancellationToken)
{
HandlerResponse <bool> response;
var user = await _dataContext.Users.SingleOrDefaultAsync(u => u.Id == request.Id, cancellationToken);
if (user is null)
{
response = new HandlerResponse <bool>("Unable to find User");
}
else
{
var existingUserName = await _dataContext.Users.AsNoTracking().SingleOrDefaultAsync(u => u.Username.Equals(request.Username, StringComparison.InvariantCultureIgnoreCase), cancellationToken);
if (existingUserName != null)
{
response = new HandlerResponse <bool>($"Please supply an unique username");
}
else
{
try
{
user.Username = request.Username;
await _dataContext.SaveChangesAsync(cancellationToken);
response = new HandlerResponse <bool>(true);
}
catch (DbException)
{
response = new HandlerResponse <bool>($"Unable to update User");
}
}
}
return(response);
}
private void AcquireRequestState(object sender, EventArgs e)
{
HttpContext context = ((HttpApplication)sender).Context;
string requestPath = context.Request.Path.Trim('/').ToLower();
if (requestPath.Contains("ajax/"))
{//符合ajax请求的内容
string[] controls = requestPath.Substring(requestPath.IndexOf("ajax/"),
requestPath.IndexOf('?') > 0 ? requestPath.IndexOf('?') : requestPath.Length - requestPath.IndexOf("ajax/")).Split('/');
context.Response.ContentType = "text/plain";
HttpRequest Request = context.Request;
HttpResponse Response = context.Response;
//防止数据泄露，以后可以去掉
if (Request.RequestType.Trim().ToLower() == "get" && controls[1] != "gloab" &&
controls[1] != "checkcode")
{
HandlerResponse hresult = new HandlerResponse {
Result = -1, Message = "不支持GET请求"
};
Response.Write(hresult.ToString());
}
else
{
/*control的操作对象*/
string handlerName = controls[1];
if (string.IsNullOrEmpty(handlerName))
{
return;
}
AppHandlerManager.ExecuteHandler(handlerName, HttpContext.Current, controls[2]);
}
context.ApplicationInstance.CompleteRequest();
}
}
/// <summary>
/// Initializes a new instance of the <see cref="ExceptionContext"/> class using the values provided.
/// </summary>
/// <param name="exceptionInfo">The exception caught.</param>
/// <param name="catchBlock">The catch block where the exception was caught.</param>
/// <param name="request">The request being processed when the exception was caught.</param>
/// <param name="response">The repsonse being returned when the exception was caught.</param>
public ExceptionContext(ExceptionDispatchInfo exceptionInfo, ExceptionContextCatchBlock catchBlock, CommandHandlerRequest request, HandlerResponse response)
{
if (exceptionInfo == null)
{
throw new ArgumentNullException("exceptionInfo");
}
this.ExceptionInfo = exceptionInfo;
if (catchBlock == null)
{
throw new ArgumentNullException("catchBlock");
}
this.CatchBlock = catchBlock;
if (request == null)
{
throw new ArgumentNullException("request");
}
this.Request = request;
if (response == null)
{
throw new ArgumentNullException("response");
}
this.Response = response;
}
public InternalTradeRevalRequest(Guid requestId, HandlerResponse pvRes)
{
RequestId = requestId;
Created = DateTimeOffset.Now;
LatestResult = pvRes;
}
private void DequeueWorkerRequests(object notUsed)
{
// throttle callbacks to once per timer period
DateTime dtNow = DateTime.Now;
if ((dtNow - _lastManagedAt) < _requestManagerPeriod)
{
return;
}
_lastManagedAt = dtNow;
try
{
// processing algorithm
// - find oldest unprocessed (status==received) request and process it
bool workToDo = true;
while (workToDo && (GetState() == BasicServerState.Running))
{
workToDo = false;
InternalTradeRevalRequest activeRequest = null;
DateTimeOffset oldestRequestCreated = DateTimeOffset.MaxValue;
_outstandingRequests.Locked(requests =>
{
foreach (InternalTradeRevalRequest request in requests.Values)
{
if ((request.LatestResult.Status == RequestStatusEnum.Received) &&
(request.Created < oldestRequestCreated) &&
(request.Request != null))
{
activeRequest = request;
oldestRequestCreated = request.Created;
}
}
if (activeRequest != null)
{
// we have found a request to process
workToDo = true;
}
});
if (activeRequest != null)
{
// process request
TradeValuationRequest request = activeRequest.Request;
try
{
// run the valuation workflow
using (var workflow = new WFCalculateTradeValuation())
{
workflow.Initialise(_workContext);
activeRequest.Workflow = workflow;
_activeWorkflow = workflow;
try
{
WorkflowOutput <HandlerResponse> output = workflow.Execute(request);
WorkflowHelper.LogErrors(Logger, output.Errors);
}
finally
{
activeRequest.Workflow = null;
_activeWorkflow = null;
}
}
}
catch (Exception innerExcp)
{
Logger.Log(innerExcp);
// publish 'faulted' result
var response = new HandlerResponse
{
RequestId = request.RequestId,
RequesterId = request.RequesterId,
//RequesterData = request.TradeId,
Status = RequestStatusEnum.Faulted,
FaultDetail = new ExceptionDetail(innerExcp)
};
_workContext.Cache.SaveObject(response);
}
}
} // while there is work to do
}
catch (Exception outerExcp)
{
// deserialisation error?
Logger.Log(outerExcp);
}
}
