/// <summary>
/// Internal execute function to be called asynchronously.
/// </summary>
/// <param id="state">The server state object associated with the execution.</param>
private static void execute(ServerState state)
{
Interlocked.Increment(ref runningJobs);
//get the execution context
SerializationEngine serializer = new SerializationEngine();
Transfers.ExecutionContext context = (Transfers.ExecutionContext)serializer.Deserialize(state.GetDataArray());
byte[] res = DomainManager.ExecuteIncoming(context);
Transfers.ExecutionResult result = new Transfers.ExecutionResult(res, context.ContextID, context.DomainKey, ClusterManager.NodeID);
state.Write(MessageType.EXECUTION_COMPLETE, serializer.Serialize(result));
Interlocked.Decrement(ref runningJobs);
}
/// <summary>
/// Deploys an execution into the cluster.
/// </summary>
/// <param name="assemblyName">The full name of the assembly.</param>
/// <param name="typeName">The full name of the type.</param>
/// <param name="methodName">The full name of the method.</param>
/// <param name="param">the serialized parameter object.</param>
/// <param name="contextid">The context id of this execution.</param>
/// <param name="domainKey">The domain Key of this domain.</param>
public void Execute(string assemblyName, string typeName, string methodName, byte[] param, string contextid, string domainKey)
{
ExecutionContext context = new ExecutionContext(assemblyName, typeName, methodName, param, contextid, domainKey);
Nodes.BestNode(domainKey).Execute(context);
}
/// <summary>
/// Trigger an execution on this node.
/// </summary>
/// <param id="executionContext">The execution context of the job.</param>
public bool Execute(ExecutionContext executionContext)
{
RunningJobs++;
//first be sure that this node has the appropriate assembly loaded
if (!HasAssembly(executionContext.AssemblyName)) {
//get the assembly
byte[] assembly = DomainManager.GetAssemblyStream(executionContext.AssemblyName);
deliverAssembly(executionContext.AssemblyName, assembly, executionContext.DomainKey);
}
assemblyLoadReset.WaitOne();
//since we know that the other machine has the assembly loaded we can
//serialize the execution context and transport
SerializationEngine serializer = new SerializationEngine ();
client.Write(MessageType.EXECUTION_BEGIN, serializer.Serialize(executionContext));
return true;
}
/// <summary>
/// Execute an incoming job according to the passed in execution context.
/// </summary>
/// <param name="context">The context of the job.</param>
/// <returns>The result of the job serialized for transport.</returns>
public static byte[] ExecuteIncoming(ExecutionContext context)
{
DomainProxy proxy = proxies[context.DomainKey];
return proxy.ExecuteIncoming(context.MethodName, context.TypeName, context.AssemblyName, context.Parameter);
}