/*
* Print out all the timing info
*/
private void DumpTimings(Connection Parent)
{
lock ( PerfTimerInstance )
{
if (bPerfTimerInstanceActive)
{
string PerfMessage = PerfTimerInstance.DumpTimings();
Log(EVerbosityLevel.Simple, ELogColour.Blue, PerfMessage);
AgentInfoMessage Info = new AgentInfoMessage();
Info.TextMessage = PerfMessage;
SendMessageInternal(Parent, Info);
}
}
}
private void SendJobCompletedMessage( AgentInfoMessage AdditionalInfoMessage )
{
// Only send a message back if we're the Instigator - remote workers don't have
// enough information to make this determination
Debug.Assert( OwnerIsInstigator );
AgentJobState UpdatedStateMessage = null;
if( CurrentSuccessState == JobSuccessState.AGENT_JOB_SUCCESS )
{
Manager.Log( EVerbosityLevel.Informative, ELogColour.Green, "[Job] " + AdditionalInfoMessage.TextMessage );
UpdatedStateMessage = new AgentJobState( JobGuid, EJobTaskState.STATE_COMPLETE_SUCCESS );
}
else if( CurrentSuccessState == JobSuccessState.AGENT_JOB_FAILURE )
{
Manager.Log( EVerbosityLevel.Informative, ELogColour.Red, "[Job] " + AdditionalInfoMessage.TextMessage );
UpdatedStateMessage = new AgentJobState( JobGuid, EJobTaskState.STATE_COMPLETE_FAILURE );
}
// Only if we have an actual update should we send one
if( UpdatedStateMessage != null )
{
// Set the running time
TimeSpan JobRunningTime = DateTime.UtcNow - StartTime;
UpdatedStateMessage.JobRunningTime = JobRunningTime.TotalSeconds;
// Set the exit code, if there is one
UpdatedStateMessage.JobExitCode = ProcessObjectExitCode;
// Send the actual message and the additional state message
if( AdditionalInfoMessage != null )
{
Manager.SendMessageInternal( Owner, AdditionalInfoMessage );
}
Manager.SendMessageInternal( Owner, UpdatedStateMessage );
}
}
/**
* Sends a message to an Agent (return messages are sent via the FConnectionCallback)
*
* @param Message The message being sent
*
* @return Int32 error code (< 0 is error)
*/
public virtual Int32 SendMessage(IntPtr NativeMessagePtr)
{
StartTiming("SendMessage-Managed", true);
FMessage NativeMessage = (FMessage)Marshal.PtrToStructure(NativeMessagePtr, typeof(FMessage));
Int32 ReturnValue = Constants.INVALID;
if (Connection != null)
{
AgentMessage ManagedMessage = null;
// TODO: As we add additional versions, convert to a switch rather than if-else.
// For now, just use a simple if since we only have one version and a switch is
// overkill.
if (NativeMessage.Version == ESwarmVersionValue.VER_1_0)
{
switch (NativeMessage.Type)
{
case EMessageType.TASK_REQUEST_RESPONSE:
// Swallow this message, since it should not be sent along to a local connection
// since all Job and Task information is contained within the Agent itself
break;
case EMessageType.TASK_STATE:
{
FTaskState NativeTaskStateMessage = (FTaskState)Marshal.PtrToStructure(NativeMessagePtr, typeof(FTaskState));
AgentGuid ManagedTaskGuid = new AgentGuid(NativeTaskStateMessage.TaskGuid.A,
NativeTaskStateMessage.TaskGuid.B,
NativeTaskStateMessage.TaskGuid.C,
NativeTaskStateMessage.TaskGuid.D);
EJobTaskState TaskState = (EJobTaskState)NativeTaskStateMessage.TaskState;
AgentTaskState ManagedTaskStateMessage = new AgentTaskState(null, ManagedTaskGuid, TaskState);
ManagedTaskStateMessage.TaskExitCode = NativeTaskStateMessage.TaskExitCode;
ManagedTaskStateMessage.TaskRunningTime = NativeTaskStateMessage.TaskRunningTime;
// If there is a message, be sure copy and pass it on
if (NativeTaskStateMessage.TaskMessage != IntPtr.Zero)
{
ManagedTaskStateMessage.TaskMessage = FStringMarshaler.MarshalNativeToManaged(NativeTaskStateMessage.TaskMessage);
}
ManagedMessage = ManagedTaskStateMessage;
}
break;
case EMessageType.INFO:
{
// Create the managed version of the info message
FInfoMessage NativeInfoMessage = (FInfoMessage)Marshal.PtrToStructure(NativeMessagePtr, typeof(FInfoMessage));
AgentInfoMessage ManagedInfoMessage = new AgentInfoMessage();
if (NativeInfoMessage.TextMessage != IntPtr.Zero)
{
ManagedInfoMessage.TextMessage = FStringMarshaler.MarshalNativeToManaged(NativeInfoMessage.TextMessage);
}
ManagedMessage = ManagedInfoMessage;
}
break;
case EMessageType.ALERT:
{
// Create the managed version of the alert message
FAlertMessage NativeAlertMessage = (FAlertMessage)Marshal.PtrToStructure(NativeMessagePtr, typeof(FAlertMessage));
AgentGuid JobGuid = new AgentGuid(NativeAlertMessage.JobGuid.A,
NativeAlertMessage.JobGuid.B,
NativeAlertMessage.JobGuid.C,
NativeAlertMessage.JobGuid.D);
AgentAlertMessage ManagedAlertMessage = new AgentAlertMessage(JobGuid);
ManagedAlertMessage.AlertLevel = (EAlertLevel)(NativeAlertMessage.AlertLevel);
AgentGuid ObjectGuid = new AgentGuid(NativeAlertMessage.ObjectGuid.A,
NativeAlertMessage.ObjectGuid.B,
NativeAlertMessage.ObjectGuid.C,
NativeAlertMessage.ObjectGuid.D);
ManagedAlertMessage.ObjectGuid = ObjectGuid;
ManagedAlertMessage.TypeId = NativeAlertMessage.TypeId;
if (NativeAlertMessage.TextMessage != IntPtr.Zero)
{
ManagedAlertMessage.TextMessage = FStringMarshaler.MarshalNativeToManaged(NativeAlertMessage.TextMessage);
}
ManagedMessage = ManagedAlertMessage;
}
break;
case EMessageType.TIMING:
{
// Create the managed version of the info message
FTimingMessage NativeTimingMessage = (FTimingMessage)Marshal.PtrToStructure(NativeMessagePtr, typeof(FTimingMessage));
AgentTimingMessage ManagedTimingMessage = new AgentTimingMessage((EProgressionState)NativeTimingMessage.State, NativeTimingMessage.ThreadNum);
ManagedMessage = ManagedTimingMessage;
}
break;
default:
// By default, just pass the message version and type through, but
// any additional payload of a specialized type will be lost
ManagedMessage = new AgentMessage((EMessageType)NativeMessage.Type);
break;
}
}
if (ManagedMessage != null)
{
try
{
// Finally, send the message to the Agent
StartTiming("SendMessage-Remote", false);
Connection.SendMessage(ConnectionHandle, ManagedMessage);
StopTiming();
ReturnValue = Constants.SUCCESS;
}
catch (Exception Ex)
{
Log(EVerbosityLevel.Critical, ELogColour.Red, "[Interface:SendMessage] Error: " + Ex.Message);
ReturnValue = Constants.ERROR_CONNECTION_DISCONNECTED;
CleanupClosedConnection();
}
}
}
else
{
ReturnValue = Constants.ERROR_CONNECTION_NOT_FOUND;
}
StopTiming();
return( ReturnValue );
}
