/// <summary>
/// get context's status in protocol buffer
/// </summary>
/// <returns>this context's status in protocol buffer form.</returns>
public ContextStatusProto GetContextStatus()
{
lock (_contextLifeCycle)
{
var contextStatusProto = new ContextStatusProto
{
context_id = Id,
context_state = _contextState,
};
if (_parentContext.IsPresent())
{
contextStatusProto.parent_id = _parentContext.Value.Id;
}
foreach (var sourceMessage in _contextLifeCycle.ContextMessageSources.Where(src => src.Message.IsPresent()).Select(src => src.Message.Value))
{
var contextMessageProto = new ContextStatusProto.ContextMessageProto
{
source_id = sourceMessage.MessageSourceId,
message = ByteUtilities.CopyBytesFrom(sourceMessage.Bytes),
};
contextStatusProto.context_message.Add(contextMessageProto);
}
return(contextStatusProto);
}
}
/// <summary>
/// get context's status in protocol buffer
/// </summary>
/// <returns>this context's status in protocol buffer form.</returns>
public ContextStatusProto GetContextStatus()
{
lock (_contextLifeCycle)
{
var contextStatusProto = new ContextStatusProto
{
context_id = Id,
context_state = _contextState,
};
if (_parentContext.IsPresent())
{
contextStatusProto.parent_id = _parentContext.Value.Id;
}
foreach (var source in _contextLifeCycle.ContextMessageSources)
{
// Note: Please do not convert to LINQ expression, as source.Message
// may not return the same object in subsequent Get calls.
var sourceMessage = source.Message;
if (sourceMessage.IsPresent())
{
var contextMessageProto = new ContextStatusProto.ContextMessageProto
{
source_id = sourceMessage.Value.MessageSourceId,
message = ByteUtilities.CopyBytesFrom(sourceMessage.Value.Bytes),
};
contextStatusProto.context_message.Add(contextMessageProto);
}
}
return(contextStatusProto);
}
}
/// <summary>
/// get context's status in protocol buffer
/// </summary>
/// <returns>this context's status in protocol buffer form.</returns>
public ContextStatusProto GetContextStatus()
{
lock (_contextLifeCycle)
{
ContextStatusProto contextStatusProto = new ContextStatusProto()
{
context_id = Id,
context_state = _contextState,
};
if (_parentContext.IsPresent())
{
contextStatusProto.parent_id = _parentContext.Value.Id;
}
foreach (IContextMessageSource source in _contextLifeCycle.ContextMessageSources)
{
Optional <ContextMessage> contextMessageOptional = source.Message;
if (contextMessageOptional.IsPresent())
{
ContextStatusProto.ContextMessageProto contextMessageProto
= new ContextStatusProto.ContextMessageProto()
{
source_id = contextMessageOptional.Value.MessageSourceId,
};
contextMessageProto.message = ByteUtilities.CopyBytesFrom(contextMessageOptional.Value.Bytes);
contextStatusProto.context_message.Add(contextMessageProto);
}
}
return(contextStatusProto);
}
}
/// <summary>
/// get status of all contexts in the stack.
/// </summary>
/// <returns>the status of all contexts in the stack.</returns>
public ICollection <ContextStatusProto> GetContextStatusCollection()
{
ICollection <ContextStatusProto> result = new Collection <ContextStatusProto>();
foreach (ContextRuntime runtime in _contextStack)
{
ContextStatusProto contextStatusProto = runtime.GetContextStatus();
LOGGER.Log(Level.Verbose, string.Format(CultureInfo.InvariantCulture, "Add context status: {0}", contextStatusProto));
result.Add(contextStatusProto);
}
return(result);
}
/// <summary>
/// Called with a specific ContextStatusProto that must be delivered to the driver
/// </summary>
/// <param name="contextStatusProto"></param>
public void OnNext(ContextStatusProto contextStatusProto)
{
LOGGER.Log(Level.Verbose, "Before acquiring lock: HeartbeatManager::OnNext(ContextStatusProto)");
lock (this)
{
LOGGER.Log(Level.Verbose, "HeartbeatManager::OnNext(ContextStatusProto)");
List <ContextStatusProto> contextStatusProtos = new List <ContextStatusProto>();
contextStatusProtos.Add(contextStatusProto);
contextStatusProtos.AddRange(ContextManager.GetContextStatusCollection());
EvaluatorHeartbeatProto heartbeatProto = GetEvaluatorHeartbeatProto(
EvaluatorRuntime.GetEvaluatorStatus(),
contextStatusProtos,
Optional <TaskStatusProto> .Empty());
LOGGER.Log(Level.Info, string.Format(CultureInfo.InvariantCulture, "Triggered a heartbeat: {0}.", heartbeatProto));
Send(heartbeatProto);
}
}
/// <summary>
/// THIS ASSUMES THAT IT IS CALLED ON A THREAD HOLDING THE LOCK ON THE HeartBeatManager
/// </summary>
/// <param name="e"></param>
private void HandlContextException(ContextClientCodeException e)
{
LOGGER.Log(Level.Error, "ContextClientCodeException", e);
byte[] exception = ByteUtilities.StringToByteArrays(e.ToString());
ContextStatusProto contextStatusProto = new ContextStatusProto()
{
context_id = e.ContextId,
context_state = ContextStatusProto.State.FAIL,
error = exception
};
if (e.ParentId.IsPresent())
{
contextStatusProto.parent_id = e.ParentId.Value;
}
LOGGER.Log(Level.Error, string.Format(CultureInfo.InvariantCulture, "Sending Heartbeat for a failed context: {0}", contextStatusProto.ToString()));
_heartBeatManager.OnNext(contextStatusProto);
}
private void HandleContextException(Exception e, string contextId, string parentContextId)
{
lock (_heartBeatManager)
{
LOGGER.Log(Level.Warning, "ContextException", e);
byte[] exception = ByteUtilities.StringToByteArrays(e.ToString());
var contextStatusProto = new ContextStatusProto
{
context_id = contextId,
context_state = ContextStatusProto.State.FAIL,
parent_id = parentContextId,
error = exception
};
LOGGER.Log(Level.Error, "Sending Heartbeat for a failed context: {0}", contextStatusProto);
_heartBeatManager.OnNext(contextStatusProto);
}
}
/// <summary>
/// Handle a context status update
/// </summary>
/// <param name="contextStatusProto"></param>
/// <param name="notifyClientOnNewActiveContext"></param>
private void Handle(ContextStatusProto contextStatusProto, bool notifyClientOnNewActiveContext)
{
string contextId = contextStatusProto.context_id;
Optional <string> parentId = contextStatusProto.parent_id != null ?
Optional <string> .Of(contextStatusProto.parent_id) : Optional <string> .Empty();
if (ContextStatusProto.State.READY == contextStatusProto.context_state)
{
if (!_activeContextIds.Contains(contextId))
{
EvaluatorContext evaluatorContext = new EvaluatorContext(this, contextId, parentId);
AddEvaluatorContext(evaluatorContext);
if (notifyClientOnNewActiveContext)
{
LOGGER.Log(Level.Info, "TODO: REPLACE THIS " + evaluatorContext.ToString());
//TODO
//dispatcher.onNext(ActiveContext.class, context);
}
}
foreach (ContextStatusProto.ContextMessageProto contextMessageProto in contextStatusProto.context_message)
{
byte[] message = contextMessageProto.message;
string sourceId = contextMessageProto.source_id;
LOGGER.Log(Level.Info, "TODO: REPLACE THIS " + sourceId + message);
// this.dispatcher.onNext(ContextMessage.class,
//new ContextMessageImpl(theMessage, contextID, sourceID));
}
}
else
{
if (!_activeContextIds.Contains(contextId))
{
if (ContextStatusProto.State.FAIL == contextStatusProto.context_state)
{
AddEvaluatorContext(new EvaluatorContext(this, contextId, parentId));
}
else
{
var e = new InvalidOperationException("unknown context signaling state " + contextStatusProto.context_state);
Exceptions.Throw(e, LOGGER);
}
}
}
EvaluatorContext context = GetEvaluatorContext(contextId);
EvaluatorContext parentContext = context.ParentId.IsPresent() ?
GetEvaluatorContext(context.ParentId.Value) : null;
RemoveEvaluatorContext(context);
if (ContextStatusProto.State.FAIL == contextStatusProto.context_state)
{
// TODO
Exception reason = new InvalidOperationException(ByteUtilities.ByteArrarysToString(contextStatusProto.error));
Optional <IActiveContext> optionalParentContext = (null == parentContext) ?
Optional <IActiveContext> .Empty() : Optional <IActiveContext> .Of(parentContext);
LOGGER.Log(Level.Info, "TODO: REPLACE THIS " + reason.ToString() + optionalParentContext);
// TODO
//this.dispatcher.onNext(FailedContext.class,
//context.getFailedContext(optionalParentContext, reason));
}
else if (ContextStatusProto.State.DONE == contextStatusProto.context_state)
{
if (null != parentContext)
{
// TODO
//this.dispatcher.onNext(ClosedContext.class, context.getClosedContext(parentContext));
}
else
{
LOGGER.Log(Level.Info, "Root context closed. Evaluator closed will trigger final shutdown.");
}
}
else
{
var e = new InvalidOperationException(string.Format(CultureInfo.InvariantCulture, "Unknown context state {0} for context {1}", contextStatusProto.context_state, contextId));
Exceptions.Throw(e, LOGGER);
}
}
