private Result LockedMajorTransition(ServiceStatuses initialTransition, ServiceStatuses finalTransition,
Func <Result> serviceCall, bool statusCheck, string statusWarning, Result reason = null)
{
if (statusCheck)
{
return(Result.SingleWarning(statusWarning, ServiceName));
}
Result transition;
if (!(transition = TransitionStatus(initialTransition, reason)))
{
return(ErrorOut(transition));
}
if (!(transition += serviceCall()))
{
return(ErrorOut(transition));
}
if (Status != finalTransition)
{
transition += TransitionStatus(finalTransition, reason);
}
return(transition);
}
private void TriggerStatusChanged(ServiceStatuses oldStatus, ServiceStatuses newStatus, Result reason)
{
if (StatusChanged != null)
{
StatusChanged(this, new ServiceStatusTransition(oldStatus, newStatus, reason));
}
}
protected Result CheckService(IHService service)
{
if (service == null)
{
return(Result.SingleFatal(Fatals.KeepAliveServicePassedNullService, ServiceName));
}
var serviceId = service.ServiceName;
ServiceStatusInformation serviceInfo;
if (!(ServiceStatuses.ContainsKey(serviceId)) || (serviceInfo = ServiceStatuses[serviceId]) == null)
{
return(Result.SingleFatal(Fatals.KeepAliveServiceMissingService, service, ServiceName));
}
StatusTypes currentStatus;
// Nothing to do, if the service isn't failed.
if ((currentStatus = serviceInfo.CurrentStatus) != StatusTypes.Failed)
{
return(Result.Success);
}
// Status is failed.
Result revive;
bool shouldRevive;
TimeSpan?secondsToWait;
if (!(revive = CheckIfShouldRevive(serviceInfo, out shouldRevive, out secondsToWait)) || !shouldRevive)
{
return(revive);
}
// Status is failed and should be revived.
if (!(revive += TriggerRevivingService(service)))
{
return(revive);
}
// Setting reason information about start.
var reason = Result.SingleInfo(ServiceReasons.KeepAliveStartup, Debugs.StartedByKeepAliveMonitor, serviceInfo.FailedAttempts + 1);
if (!(Result)(serviceInfo.LastResult = service.Start(reason)))
{
// Failed to revive.
++serviceInfo.FailedAttempts;
serviceInfo.LastAttempt = DateTime.Now;
serviceInfo.CurrentWaitTicks = secondsToWait == null ? (long?)null : secondsToWait.Value.Ticks;
return(revive + TriggerReviveFailed(service));
}
// Service revived.
serviceInfo.CurrentStatus = service.Status;
serviceInfo.PriorStatus = currentStatus;
serviceInfo.FailedAttempts = 0;
serviceInfo.LastAttempt = null;
++serviceInfo.Revivals;
return(TriggerServiceRevived(service));
}
protected HServiceStatusBase(IServiceValidator serviceValidator = null)
{
_status = ServiceStatuses.Stopped;
_serviceValidator = serviceValidator ?? new ServiceValidator();
_userRequestedTransition = Result.SingleDebug(ServiceReasons.UserRequestedTransition, Debugs.UserRequestedTransition);
IsInitialized = false;
LastTransitionReason = UserRequestedTransition;
}
private Result CanTransitionTo(ServiceStatuses status)
{
var currentStatus = Status;
var acceptedTransitions = ServiceValidator.GetStatusTransitions(status);
return(acceptedTransitions.Contains(currentStatus)
? Result.Success
: Result.SingleError(Warnings.ServiceStatusTransitionNotAllowed, currentStatus, status));
}
private Result TransitionStatus(ServiceStatuses status, Result reason = null)
{
Result transition;
reason = reason ?? UserRequestedTransition;
if (!(transition = CanTransitionTo(status)))
{
return(transition);
}
return(transition + SetStatus(status, reason));
}
private void CloseService(ServiceStatuses status)
{
if (timer == null || !timer.Enabled)
{
return;
}
timer.Stop();
item.EndServiceDate = DateTime.Now;
item.Status = status;
UpdateItem();
FinishActivity();
}
private Result SetStatus(ServiceStatuses status, Result reason)
{
ServiceStatuses oldStatus;
if ((oldStatus = Status) == status)
{
return(Result.Success);
}
try
{
_status = status;
TriggerStatusChanged(oldStatus, Status, reason);
LastTransitionReason = reason;
return(Result.Success);
}
catch (Exception e)
{
return(reason + Result.Error(e));
}
}
protected Result UpdateServiceStatus(IHService service)
{
if (service == null)
{
return(Result.SingleFatal(Fatals.KeepAliveServicePassedNullService, ServiceName));
}
// Add any services that are missing.
var serviceId = service.ServiceName;
if (!(ServiceStatuses.ContainsKey(serviceId)))
{
ServiceStatuses.Add(serviceId, new ServiceStatusInformation(serviceId));
}
// Get reference to monitored service state.
var statusInfo = ServiceStatuses[serviceId];
StatusTypes currentStatus;
var priorStatus = statusInfo.CurrentStatus;
// If the service is not currently failed, clear failed attempts.
if ((currentStatus = service.Status) != StatusTypes.Failed)
{
statusInfo.FailedAttempts = 0;
}
// If the current status is not the prior status, then it was updated externally.
if (currentStatus != priorStatus)
{
statusInfo.LastResult = service.LastTransitionReason;
}
statusInfo.CurrentStatus = currentStatus;
statusInfo.PriorStatus = priorStatus;
return(Result.Success);
}
public Collection <ServiceStatuses> GetStatusTransitions(ServiceStatuses targetStatus)
{
ServiceStatuses[] statuses;
switch (targetStatus)
{
case ServiceStatuses.Failed:
statuses = FailedTransitions;
break;
case ServiceStatuses.Starting:
statuses = StartingTransitions;
break;
case ServiceStatuses.Stopping:
statuses = StoppingTransitions;
break;
case ServiceStatuses.Paused:
statuses = PauseTransitions;
break;
case ServiceStatuses.Stopped:
statuses = StopTransitions;
break;
case ServiceStatuses.Started:
statuses = StartTransitions;
break;
default:
statuses = DefaultTransitions;
break;
}
return(statuses.ToCollection());
}
public ServiceStatusTransition(ServiceStatuses priorStatus, ServiceStatuses currentStatus, Result reason)
{
_priorStatus = priorStatus;
_currentStatus = currentStatus;
_reason = reason;
}
private void onResponse(Response response)
{
switch (response.ResponseCase)
{
case Response.ResponseOneofCase.OrderReports:
OrderReports orderReports = response.OrderReports;
foreach (var orderReport in orderReports.OrderReport)
{
Debug.WriteLine("recieve the order/exeuction report message:{0}", orderReport);
}
break;
case Response.ResponseOneofCase.MarketDatas:
MarketDatas marketDatas = response.MarketDatas;
foreach (var marketData in marketDatas.MarketData)
{
Debug.WriteLine("recieve the market data update message:{0}", marketData);
}
break;
case Response.ResponseOneofCase.Ping:
Ping pingMsg = response.Ping;
Debug.WriteLine("recieve the ping message:{0}", pingMsg);
break;
case Response.ResponseOneofCase.Notice:
NoticeMessages noticeMsgs = response.Notice;
foreach (var noticeMsg in noticeMsgs.Notice)
{
Debug.WriteLine("recieve the notice message:{0}", noticeMsg);
}
break;
case Response.ResponseOneofCase.ServiceStatus:
ServiceStatuses serviceStatuses = response.ServiceStatus;
foreach (var status in serviceStatuses.Status)
{
Debug.WriteLine("recieve the service status message:{0}", status);
}
break;
case Response.ResponseOneofCase.Instruments:
Instruments instruments = response.Instruments;
foreach (var instrument in instruments.Instrument)
{
Debug.WriteLine("recieve the new instrument message:{0}", instrument);
}
break;
case Response.ResponseOneofCase.InstrumentStatus:
InstrumentStatuses instrumentStatuses = response.InstrumentStatus;
foreach (var instrumentStatus in instrumentStatuses.Status)
{
Debug.WriteLine("recieve the instrument status change message:{0}", instrumentStatus);
}
break;
case Response.ResponseOneofCase.Position:
AccountPosition acctPostion = response.Position;
foreach (var postioin in acctPostion.Positions)
{
Debug.WriteLine("recieve the position message:{0}", postioin);
}
break;
case Response.ResponseOneofCase.SpreaderID:
case Response.ResponseOneofCase.LogonResult:
case Response.ResponseOneofCase.QueryResult:
case Response.ResponseOneofCase.None:
case Response.ResponseOneofCase.Extension:
default:
Assert.Fail("this should not in broadcast message from server");
break;
}
}
