/// <summary>
/// Put metadata to Grid.
/// </summary>
/// <param name="metas">Metadatas.</param>
internal void PutMetadata(IDictionary <int, IPortableMetadata> metas)
{
DoOutOp(OpMeta, stream =>
{
PortableWriterImpl metaWriter = _marsh.StartMarshal(stream);
metaWriter.WriteInt(metas.Count);
foreach (var meta in metas.Values)
{
PortableMetadataImpl meta0 = (PortableMetadataImpl)meta;
metaWriter.WriteInt(meta0.TypeId);
metaWriter.WriteString(meta0.TypeName);
metaWriter.WriteString(meta0.AffinityKeyFieldName);
IDictionary <string, int> fields = meta0.FieldsMap();
metaWriter.WriteInt(fields.Count);
foreach (var field in fields)
{
metaWriter.WriteString(field.Key);
metaWriter.WriteInt(field.Value);
}
}
_marsh.FinishMarshal(metaWriter);
});
_marsh.OnMetadataSent(metas);
}
internal bool Serialize(IPortableStream stream)
{
ClusterGroupImpl prj = _ignite.ClusterGroup;
PortableWriterImpl writer = prj.Marshaller.StartMarshal(stream);
try
{
writer.Write(this);
return(true);
}
catch (Exception e)
{
writer.WriteString("Failed to marshal job [job=" + _job + ", errType=" + e.GetType().Name +
", errMsg=" + e.Message + ']');
return(false);
}
finally
{
// 4. Process metadata.
prj.FinishMarshal(writer);
}
}
/** <inheritDoc /> */
internal override void Write(PortableWriterImpl writer, bool keepPortable)
{
if (string.IsNullOrEmpty(Text))
{
throw new ArgumentException("Text cannot be null or empty");
}
if (string.IsNullOrEmpty(Type))
{
throw new ArgumentException("Type cannot be null or empty");
}
writer.WriteBoolean(Local);
writer.WriteString(Text);
writer.WriteString(Type);
writer.WriteInt(PageSize);
}
/// <summary>
/// Write task to the writer.
/// </summary>
/// <param name="writer">Writer.</param>
/// <param name="taskName">Task name.</param>
/// <param name="taskArg">Task arg.</param>
/// <param name="nodes">Nodes.</param>
private void WriteTask(PortableWriterImpl writer, string taskName, object taskArg,
ICollection <IClusterNode> nodes)
{
writer.WriteString(taskName);
writer.WriteBoolean(_keepPortable.Value);
writer.Write(taskArg);
WriteNodeIds(writer, nodes);
}
private void Marshal(PortableWriterImpl writer)
{
var pos = writer.Stream.Position;
try
{
if (Error == null)
{
writer.WriteByte((byte)Entry.State);
if (Entry.State == MutableCacheEntryState.ValueSet)
{
writer.Write(Entry.Value);
}
writer.Write(ProcessResult);
}
else
{
writer.WriteByte((byte)MutableCacheEntryState.ErrPortable);
writer.Write(new PortableResultWrapper(Error));
}
}
catch (Exception marshErr)
{
writer.Stream.Seek(pos, SeekOrigin.Begin);
writer.WriteByte((byte)MutableCacheEntryState.ErrString);
if (Error == null)
{
writer.WriteString(string.Format(
"CacheEntryProcessor completed with error, but result serialization failed [errType={0}, " +
"err={1}, serializationErrMsg={2}]", marshErr.GetType().Name, marshErr, marshErr.Message));
}
else
{
writer.WriteString(string.Format(
"CacheEntryProcessor completed with error, and error serialization failed [errType={0}, " +
"err={1}, serializationErrMsg={2}]", marshErr.GetType().Name, marshErr, marshErr.Message));
}
}
}
/** <inheritDoc /> */
internal override void Write(PortableWriterImpl writer, bool keepPortable)
{
if (string.IsNullOrEmpty(Sql))
{
throw new ArgumentException("Sql cannot be null or empty");
}
if (string.IsNullOrEmpty(Type))
{
throw new ArgumentException("Type cannot be null or empty");
}
// 2. Prepare.
writer.WriteBoolean(Local);
writer.WriteString(Sql);
writer.WriteString(Type);
writer.WriteInt(PageSize);
WriteQueryArgs(writer, Arguments);
}
/// <summary>
/// Writes proxy method invocation data to the specified writer.
/// </summary>
/// <param name="writer">Writer.</param>
/// <param name="method">Method.</param>
/// <param name="arguments">Arguments.</param>
public static void WriteProxyMethod(PortableWriterImpl writer, MethodBase method, object[] arguments)
{
Debug.Assert(writer != null);
Debug.Assert(method != null);
writer.WriteString(method.Name);
if (arguments != null)
{
writer.WriteBoolean(true);
writer.WriteInt(arguments.Length);
foreach (var arg in arguments)
writer.WriteObject(arg);
}
else
writer.WriteBoolean(false);
}
/// <summary>
/// Writes proxy method invocation data to the specified writer.
/// </summary>
/// <param name="writer">Writer.</param>
/// <param name="method">Method.</param>
/// <param name="arguments">Arguments.</param>
public static void WriteProxyMethod(PortableWriterImpl writer, MethodBase method, object[] arguments)
{
Debug.Assert(writer != null);
Debug.Assert(method != null);
writer.WriteString(method.Name);
if (arguments != null)
{
writer.WriteBoolean(true);
writer.WriteInt(arguments.Length);
foreach (var arg in arguments)
{
writer.WriteObject(arg);
}
}
else
{
writer.WriteBoolean(false);
}
}
/** <inheritDoc /> */
internal override void Write(PortableWriterImpl writer, bool keepPortable)
{
if (string.IsNullOrEmpty(Text))
throw new ArgumentException("Text cannot be null or empty");
if (string.IsNullOrEmpty(Type))
throw new ArgumentException("Type cannot be null or empty");
writer.WriteBoolean(Local);
writer.WriteString(Text);
writer.WriteString(Type);
writer.WriteInt(PageSize);
}
private void Marshal(PortableWriterImpl writer)
{
var pos = writer.Stream.Position;
try
{
if (Error == null)
{
writer.WriteByte((byte) Entry.State);
if (Entry.State == MutableCacheEntryState.ValueSet)
writer.Write(Entry.Value);
writer.Write(ProcessResult);
}
else
{
writer.WriteByte((byte) MutableCacheEntryState.ErrPortable);
writer.Write(new PortableResultWrapper(Error));
}
}
catch (Exception marshErr)
{
writer.Stream.Seek(pos, SeekOrigin.Begin);
writer.WriteByte((byte) MutableCacheEntryState.ErrString);
if (Error == null)
{
writer.WriteString(string.Format(
"CacheEntryProcessor completed with error, but result serialization failed [errType={0}, " +
"err={1}, serializationErrMsg={2}]", marshErr.GetType().Name, marshErr, marshErr.Message));
}
else
{
writer.WriteString(string.Format(
"CacheEntryProcessor completed with error, and error serialization failed [errType={0}, " +
"err={1}, serializationErrMsg={2}]", marshErr.GetType().Name, marshErr, marshErr.Message));
}
}
}
public void Map(PlatformMemoryStream inStream, PlatformMemoryStream outStream)
{
IList <IClusterNode> subgrid;
ClusterGroupImpl prj = (ClusterGroupImpl)_compute.ClusterGroup;
var ignite = (Ignite)prj.Ignite;
// 1. Unmarshal topology info if topology changed.
var reader = prj.Marshaller.StartUnmarshal(inStream);
if (reader.ReadBoolean())
{
long topVer = reader.ReadLong();
List <IClusterNode> nodes = new List <IClusterNode>(reader.ReadInt());
int nodesCnt = reader.ReadInt();
subgrid = new List <IClusterNode>(nodesCnt);
for (int i = 0; i < nodesCnt; i++)
{
IClusterNode node = ignite.GetNode(reader.ReadGuid());
nodes.Add(node);
if (reader.ReadBoolean())
{
subgrid.Add(node);
}
}
// Update parent projection to help other task callers avoid this overhead.
// Note that there is a chance that topology changed even further and this update fails.
// It means that some of subgrid nodes could have left the Grid. This is not critical
// for us, because Java will handle it gracefully.
prj.UpdateTopology(topVer, nodes);
}
else
{
IList <IClusterNode> nodes = prj.NodesNoRefresh();
Debug.Assert(nodes != null, "At least one topology update should have occurred.");
subgrid = IgniteUtils.Shuffle(nodes);
}
// 2. Perform map.
IDictionary <IComputeJob <T>, IClusterNode> map;
Exception err;
try
{
map = _task.Map(subgrid, _arg);
err = null;
}
catch (Exception e)
{
map = null;
err = e;
// Java can receive another exception in case of marshalling failure but it is not important.
Finish(default(TR), e);
}
// 3. Write map result to the output stream.
PortableWriterImpl writer = prj.Marshaller.StartMarshal(outStream);
try
{
if (err == null)
{
writer.WriteBoolean(true); // Success flag.
if (map == null)
{
writer.WriteBoolean(false); // Map produced no result.
}
else
{
writer.WriteBoolean(true); // Map produced result.
writer.WriteInt(map.Count); // Amount of mapped jobs.
var jobHandles = new List <long>(map.Count);
foreach (KeyValuePair <IComputeJob <T>, IClusterNode> mapEntry in map)
{
var job = new ComputeJobHolder(_compute.ClusterGroup.Ignite as Ignite, mapEntry.Key.ToNonGeneric());
IClusterNode node = mapEntry.Value;
var jobHandle = ignite.HandleRegistry.Allocate(job);
jobHandles.Add(jobHandle);
writer.WriteLong(jobHandle);
if (node.IsLocal)
{
writer.WriteBoolean(false); // Job is not serialized.
}
else
{
writer.WriteBoolean(true); // Job is serialized.
writer.WriteObject(job);
}
writer.WriteGuid(node.Id);
}
_jobHandles = jobHandles;
}
}
else
{
writer.WriteBoolean(false); // Map failed.
// Write error as string because it is not important for Java, we need only to print
// a message in the log.
writer.WriteString("Map step failed [errType=" + err.GetType().Name +
", errMsg=" + err.Message + ']');
}
}
catch (Exception e)
{
// Something went wrong during marshaling.
Finish(default(TR), e);
outStream.Reset();
writer.WriteBoolean(false); // Map failed.
writer.WriteString(e.Message); // Write error message.
}
finally
{
prj.Marshaller.FinishMarshal(writer);
}
}
/** <inheritDoc /> */
internal override void Write(PortableWriterImpl writer, bool keepPortable)
{
if (string.IsNullOrEmpty(Sql))
throw new ArgumentException("Sql cannot be null or empty");
if (string.IsNullOrEmpty(Type))
throw new ArgumentException("Type cannot be null or empty");
// 2. Prepare.
writer.WriteBoolean(Local);
writer.WriteString(Sql);
writer.WriteString(Type);
writer.WriteInt(PageSize);
WriteQueryArgs(writer, Arguments);
}
/// <summary>
/// Writes the affinity info.
/// </summary>
/// <param name="writer">The writer.</param>
/// <param name="cacheName">Name of the cache to use for affinity co-location.</param>
/// <param name="affinityKey">Affinity key.</param>
private static void WriteAffinity(PortableWriterImpl writer, string cacheName, object affinityKey)
{
writer.WriteString(cacheName);
writer.WriteObject(affinityKey);
}
