internal static TaskClientCodeException CreateWithNonSerializableInnerException(
TaskClientCodeException e, SerializationException serializationException)
{
var nonSerializableTaskException = NonSerializableTaskException.UnableToSerialize(e.InnerException, serializationException);
return(new TaskClientCodeException(
e.TaskId,
e.ContextId,
string.Format("Unable to serialize Task control message. TaskClientCodeException message: {0}", e.Message),
nonSerializableTaskException));
}
internal static TaskClientCodeException CreateWithNonSerializableInnerException(
TaskClientCodeException e, SerializationException serializationException)
{
var nonSerializableTaskException = NonSerializableTaskException.UnableToSerialize(e.InnerException, serializationException);
return new TaskClientCodeException(
e.TaskId,
e.ContextId,
string.Format("Unable to serialize Task control message. TaskClientCodeException message: {0}", e.Message),
nonSerializableTaskException);
}
public void Deliver(byte[] message)
{
if (_currentStatus.IsNotRunning())
{
Logger.Log(Level.Warning, string.Format(CultureInfo.InvariantCulture, "Trying to send a message to an task that is in {0} state. Ignored.", _currentStatus.State));
return;
}
try
{
OnNext(new DriverMessageImpl(message));
}
catch (Exception e)
{
Utilities.Diagnostics.Exceptions.Caught(e, Level.Error, "Error during message delivery.", Logger);
_currentStatus.SetException(
TaskClientCodeException.Create(TaskId, ContextId, "Error during message delivery.", e));
}
}
public void Suspend(byte[] message)
{
Logger.Log(Level.Info, string.Format(CultureInfo.InvariantCulture, "Trying to suspend Task {0}", TaskId));
if (_currentStatus.IsNotRunning())
{
Logger.Log(Level.Warning, string.Format(CultureInfo.InvariantCulture, "Trying to suspend an task that is in {0} state. Ignored.", _currentStatus.State));
return;
}
try
{
OnNext(new SuspendEventImpl(message));
_currentStatus.SetSuspendRequested();
}
catch (Exception e)
{
Utilities.Diagnostics.Exceptions.Caught(e, Level.Error, "Error during Suspend.", Logger);
_currentStatus.SetException(
TaskClientCodeException.Create(TaskId, ContextId, "Error during Suspend().", e));
}
}
/// <summary>
/// THIS ASSUMES THAT IT IS CALLED ON A THREAD HOLDING THE LOCK ON THE HeartBeatManager
/// </summary>
/// <param name="e"></param>
private void HandleTaskException(TaskClientCodeException e)
{
LOGGER.Log(Level.Error, "TaskClientCodeException", e);
byte[] exception = ByteUtilities.StringToByteArrays(e.ToString());
TaskStatusProto taskStatus = new TaskStatusProto()
{
context_id = e.ContextId,
task_id = e.TaskId,
result = exception,
state = State.FAILED
};
LOGGER.Log(Level.Error, "Sending Heartbeat for a failed task: {0}", taskStatus);
_heartBeatManager.OnNext(taskStatus);
}
/// <summary>
/// Launches an Task on this context.
/// </summary>
/// <param name="taskConfiguration"></param>
/// <param name="contextId"></param>
/// <param name="heartBeatManager"></param>
public void StartTask(TaskConfiguration taskConfiguration, string contextId, HeartBeatManager heartBeatManager)
{
lock (_contextLifeCycle)
{
bool taskPresent = _task.IsPresent();
bool taskEnded = taskPresent && _task.Value.HasEnded();
LOGGER.Log(Level.Info, "ContextRuntime::StartTask(TaskConfiguration)" + "task is present: " + taskPresent + " task has ended: " + taskEnded);
if (taskPresent)
{
LOGGER.Log(Level.Info, "Task state: " + _task.Value.GetTaskState());
}
if (taskEnded)
{
// clean up state
_task = Optional<TaskRuntime>.Empty();
taskPresent = false;
}
if (taskPresent)
{
var e = new InvalidOperationException(
string.Format(CultureInfo.InvariantCulture, "Attempting to spawn a child context when an Task with id '{0}' is running", _task.Value.TaskId)); // note: java code is putting thread id here
Org.Apache.REEF.Utilities.Diagnostics.Exceptions.Throw(e, LOGGER);
}
if (_childContext.IsPresent())
{
var e = new InvalidOperationException("Attempting to instantiate a child context on a context that is not the topmost active context.");
Org.Apache.REEF.Utilities.Diagnostics.Exceptions.Throw(e, LOGGER);
}
try
{
IInjector taskInjector = _contextInjector.ForkInjector(taskConfiguration.TangConfig);
LOGGER.Log(Level.Info, "Trying to inject task with configuration" + taskConfiguration.ToString());
TaskRuntime taskRuntime = new TaskRuntime(taskInjector, contextId, taskConfiguration.TaskId, heartBeatManager); // taskInjector.getInstance(TaskRuntime.class);
taskRuntime.Initialize();
System.Threading.Tasks.Task.Run(new Action(taskRuntime.Start));
_task = Optional<TaskRuntime>.Of(taskRuntime);
}
catch (Exception e)
{
var ex = new TaskClientCodeException(taskConfiguration.TaskId, Id, "Unable to instantiate the new task", e);
Org.Apache.REEF.Utilities.Diagnostics.Exceptions.CaughtAndThrow(ex, Level.Error, "Task start error.", LOGGER);
}
}
}
/// <summary>
/// THIS ASSUMES THAT IT IS CALLED ON A THREAD HOLDING THE LOCK ON THE HeartBeatManager
/// </summary>
/// <param name="e"></param>
private void HandleTaskInitializationException(TaskClientCodeException e)
{
byte[] error;
try
{
error = ByteUtilities.SerializeToBinaryFormat(e);
}
catch (SerializationException se)
{
error = ByteUtilities.SerializeToBinaryFormat(
TaskClientCodeException.CreateWithNonSerializableInnerException(e, se));
}
var avroFailedTask = new AvroFailedTask
{
identifier = e.TaskId,
cause = error,
data = ByteUtilities.StringToByteArrays(e.ToString()),
message = e.Message
};
var taskStatus = new TaskStatusProto
{
context_id = e.ContextId,
task_id = e.TaskId,
result = AvroJsonSerializer<AvroFailedTask>.ToBytes(avroFailedTask),
state = State.FAILED
};
LOGGER.Log(Level.Error, "Sending Heartbeat for a failed task: {0}", taskStatus);
_heartBeatManager.OnNext(taskStatus);
}
private TaskRuntime GetDeprecatedTaskRuntime(
IInjector taskInjector, string contextId, IConfiguration taskConfiguration, IHeartBeatManager heartBeatManager)
{
var taskId = string.Empty;
try
{
taskId = taskInjector.GetNamedInstance<TaskConfigurationOptions.Identifier, string>();
}
catch (Exception e)
{
var ex = new TaskClientCodeException(string.Empty, Id, "Unable to instantiate the new task", e);
Utilities.Diagnostics.Exceptions.CaughtAndThrow(ex, Level.Error, "Cannot get instance of Task ID: " + e.StackTrace, LOGGER);
}
LOGGER.Log(Level.Info, "Trying to inject task with configuration" + taskConfiguration);
return new TaskRuntime(taskInjector, contextId, taskId, heartBeatManager);
}
/// <summary>
/// Launches an Task on this context.
/// </summary>
/// <param name="taskConfiguration"></param>
/// <param name="contextId"></param>
/// <param name="heartBeatManager"></param>
public void StartTask(IConfiguration taskConfiguration, string contextId, IHeartBeatManager heartBeatManager)
{
lock (_contextLifeCycle)
{
LOGGER.Log(Level.Info, "ContextRuntime::StartTask(TaskConfiguration) task is present: " + _task.IsPresent());
if (_task.IsPresent())
{
LOGGER.Log(Level.Info, "Task state: " + _task.Value.GetTaskState());
LOGGER.Log(Level.Info, "ContextRuntime::StartTask(TaskConfiguration) task has ended: " + _task.Value.HasEnded());
if (_task.Value.HasEnded())
{
// clean up state
_task = Optional<TaskRuntime>.Empty();
}
else
{
// note: java code is putting thread id here
var e = new InvalidOperationException(
string.Format(CultureInfo.InvariantCulture, "Attempting to spawn a child context when an Task with id '{0}' is running", _task.Value.TaskId));
Utilities.Diagnostics.Exceptions.Throw(e, LOGGER);
}
}
if (_childContext.IsPresent())
{
var e = new InvalidOperationException("Attempting to instantiate a child context on a context that is not the topmost active context.");
Utilities.Diagnostics.Exceptions.Throw(e, LOGGER);
}
var taskInjector = _contextInjector.ForkInjector(taskConfiguration);
var taskRuntime = _deprecatedTaskStart
? GetDeprecatedTaskRuntime(taskInjector, contextId, taskConfiguration, heartBeatManager)
: taskInjector.GetInstance<TaskRuntime>();
try
{
_task = Optional<TaskRuntime>.Of(taskRuntime);
taskRuntime.RunTask();
}
catch (Exception e)
{
var ex = new TaskClientCodeException(string.Empty, Id, "Unable to run the new task", e);
Utilities.Diagnostics.Exceptions.CaughtAndThrow(ex, Level.Error, "Task start error.", LOGGER);
}
}
}