public void CompleteWithError(long taskHandle, PlatformMemoryStream stream)
{
PortableReaderImpl reader = _compute.Marshaller.StartUnmarshal(stream);
Exception err;
try
{
if (reader.ReadBoolean())
{
PortableResultWrapper res = reader.ReadObject <PortableUserObject>()
.Deserialize <PortableResultWrapper>();
err = (Exception)res.Result;
}
else
{
err = ExceptionUtils.GetException(reader.ReadString(), reader.ReadString());
}
}
catch (Exception e)
{
err = new IgniteException("Task completed with error, but it cannot be unmarshalled: " + e.Message, e);
}
CompleteWithError(taskHandle, err);
}
public int JobResultRemote(ComputeJobHolder job, PlatformMemoryStream stream)
{
// 1. Unmarshal result.
PortableReaderImpl reader = _compute.Marshaller.StartUnmarshal(stream);
Guid nodeId = reader.ReadGuid().Value;
bool cancelled = reader.ReadBoolean();
try
{
object err;
var data = PortableUtils.ReadWrappedInvocationResult(reader, out err);
// 2. Process the result.
return((int)JobResult0(new ComputeJobResultImpl(data, (Exception)err, job.Job, nodeId, cancelled)));
}
catch (Exception e)
{
Finish(default(TR), e);
if (!(e is IgniteException))
{
throw new IgniteException("Failed to process job result: " + e.Message, e);
}
throw;
}
}
/// <summary>
/// Refresh projection nodes.
/// </summary>
/// <returns>Nodes.</returns>
private IList <IClusterNode> RefreshNodes()
{
long oldTopVer = Interlocked.Read(ref _topVer);
List <IClusterNode> newNodes = null;
DoOutInOp(OpNodes, writer =>
{
writer.WriteLong(oldTopVer);
}, input =>
{
PortableReaderImpl reader = Marshaller.StartUnmarshal(input);
if (reader.ReadBoolean())
{
// Topology has been updated.
long newTopVer = reader.ReadLong();
newNodes = IgniteUtils.ReadNodes(reader, _pred);
UpdateTopology(newTopVer, newNodes);
}
});
if (newNodes != null)
{
return(newNodes);
}
// No topology changes.
Debug.Assert(_nodes != null, "At least one topology update should have occurred.");
return(_nodes);
}
/// <summary>
/// Initializes a new instance of the <see cref="ContinuousQueryFilterHolder"/> class.
/// </summary>
/// <param name="reader">The reader.</param>
public ContinuousQueryFilterHolder(IPortableReader reader)
{
PortableReaderImpl rawReader = (PortableReaderImpl)reader.RawReader();
_keyTyp = PortableUtils.ReadPortableOrSerializable <Type>(rawReader);
_valTyp = PortableUtils.ReadPortableOrSerializable <Type>(rawReader);
_filter = PortableUtils.ReadPortableOrSerializable <object>(rawReader);
_keepPortable = rawReader.ReadBoolean();
}
/// <summary>
/// Process cache partial update exception.
/// </summary>
/// <param name="msg">Message.</param>
/// <param name="reader">Reader.</param>
/// <returns></returns>
private static Exception ProcessCachePartialUpdateException(string msg, PortableReaderImpl reader)
{
if (reader == null)
{
return(new CachePartialUpdateException(msg, new IgniteException("Failed keys are not available.")));
}
bool dataExists = reader.ReadBoolean();
Debug.Assert(dataExists);
if (reader.ReadBoolean())
{
bool keepPortable = reader.ReadBoolean();
PortableReaderImpl keysReader = reader.Marshaller.StartUnmarshal(reader.Stream, keepPortable);
try
{
return(new CachePartialUpdateException(msg, ReadNullableList(keysReader)));
}
catch (Exception e)
{
// Failed to deserialize data.
return(new CachePartialUpdateException(msg, e));
}
}
// Was not able to write keys.
string innerErrCls = reader.ReadString();
string innerErrMsg = reader.ReadString();
Exception innerErr = GetException(innerErrCls, innerErrMsg);
return(new CachePartialUpdateException(msg, innerErr));
}
/** <inheritDoc /> */
public IPortableMetadata Metadata(int typeId)
{
return(DoOutInOp <IPortableMetadata>(OpMetadata,
writer =>
{
writer.WriteInt(typeId);
},
stream =>
{
PortableReaderImpl reader = Marshaller.StartUnmarshal(stream, false);
return reader.ReadBoolean() ? new PortableMetadataImpl(reader) : null;
}
));
}
/// <summary>
/// Reads nullable list.
/// </summary>
/// <param name="reader">Reader.</param>
/// <returns>List.</returns>
private static List <object> ReadNullableList(PortableReaderImpl reader)
{
if (!reader.ReadBoolean())
{
return(null);
}
var size = reader.ReadInt();
var list = new List <object>(size);
for (int i = 0; i < size; i++)
{
list.Add(reader.ReadObject <object>());
}
return(list);
}
/// <summary>
/// Reads nullable list.
/// </summary>
/// <param name="reader">Reader.</param>
/// <returns>List.</returns>
private static List<object> ReadNullableList(PortableReaderImpl reader)
{
if (!reader.ReadBoolean())
return null;
var size = reader.ReadInt();
var list = new List<object>(size);
for (int i = 0; i < size; i++)
list.Add(reader.ReadObject<object>());
return list;
}
/// <summary>
/// Process cache partial update exception.
/// </summary>
/// <param name="msg">Message.</param>
/// <param name="reader">Reader.</param>
/// <returns></returns>
private static Exception ProcessCachePartialUpdateException(string msg, PortableReaderImpl reader)
{
if (reader == null)
return new CachePartialUpdateException(msg, new IgniteException("Failed keys are not available."));
bool dataExists = reader.ReadBoolean();
Debug.Assert(dataExists);
if (reader.ReadBoolean())
{
bool keepPortable = reader.ReadBoolean();
PortableReaderImpl keysReader = reader.Marshaller.StartUnmarshal(reader.Stream, keepPortable);
try
{
return new CachePartialUpdateException(msg, ReadNullableList(keysReader));
}
catch (Exception e)
{
// Failed to deserialize data.
return new CachePartialUpdateException(msg, e);
}
}
// Was not able to write keys.
string innerErrCls = reader.ReadString();
string innerErrMsg = reader.ReadString();
Exception innerErr = GetException(innerErrCls, innerErrMsg);
return new CachePartialUpdateException(msg, innerErr);
}
