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;
}
}
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);
}
/// <summary>
/// Kernal start callback.
/// </summary>
/// <param name="interopProc">Interop processor.</param>
/// <param name="stream">Stream.</param>
internal static void OnStart(IUnmanagedTarget interopProc, IPortableStream stream)
{
try
{
// 1. Read data and leave critical state ASAP.
PortableReaderImpl reader = PU.Marshaller.StartUnmarshal(stream);
// ReSharper disable once PossibleInvalidOperationException
var name = reader.ReadString();
// 2. Set ID and name so that Start() method can use them later.
_startup.Name = name;
if (Nodes.ContainsKey(new NodeKey(name)))
{
throw new IgniteException("Ignite with the same name already started: " + name);
}
_startup.Ignite = new Ignite(_startup.Configuration, _startup.Name, interopProc, _startup.Marshaller,
_startup.LifecycleBeans, _startup.Callbacks);
}
catch (Exception e)
{
// 5. Preserve exception to throw it later in the "Start" method and throw it further
// to abort startup in Java.
_startup.Error = 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);
}
/** <inheritdoc /> */
protected override ICacheEntry <TK, TV> Read(PortableReaderImpl reader)
{
TK key = reader.ReadObject <TK>();
TV val = reader.ReadObject <TV>();
return(new CacheEntry <TK, TV>(key, val));
}
/// <summary>
/// Creates exception according to native code class and message.
/// </summary>
/// <param name="clsName">Exception class name.</param>
/// <param name="msg">Exception message.</param>
/// <param name="reader">Error data reader.</param>
public static Exception GetException(string clsName, string msg, PortableReaderImpl reader = null)
{
ExceptionFactoryDelegate ctor;
if (EXS.TryGetValue(clsName, out ctor))
{
return(ctor(msg));
}
if (ClsNoClsDefFoundErr.Equals(clsName))
{
return(new IgniteException("Java class is not found (did you set IGNITE_HOME environment " +
"variable?): " + msg));
}
if (ClsNoSuchMthdErr.Equals(clsName))
{
return(new IgniteException("Java class method is not found (did you set IGNITE_HOME environment " +
"variable?): " + msg));
}
if (ClsCachePartialUpdateErr.Equals(clsName))
{
return(ProcessCachePartialUpdateException(msg, reader));
}
return(new IgniteException("Java exception occurred [class=" + clsName + ", message=" + msg + ']'));
}
/// <summary>
/// Initializes a new instance of the <see cref="ServiceDescriptor" /> class.
/// </summary>
/// <param name="name">Name.</param>
/// <param name="reader">Reader.</param>
/// <param name="services">Services.</param>
public ServiceDescriptor(string name, PortableReaderImpl reader, IServices services)
{
Debug.Assert(reader != null);
Debug.Assert(services != null);
Debug.Assert(!string.IsNullOrEmpty(name));
_services = services;
Name = name;
CacheName = reader.ReadString();
MaxPerNodeCount = reader.ReadInt();
TotalCount = reader.ReadInt();
OriginNodeId = reader.ReadGuid() ?? Guid.Empty;
AffinityKey = reader.ReadObject <object>();
var mapSize = reader.ReadInt();
var snap = new Dictionary <Guid, int>(mapSize);
for (var i = 0; i < mapSize; i++)
{
snap[reader.ReadGuid() ?? Guid.Empty] = reader.ReadInt();
}
TopologySnapshot = snap.AsReadOnly();
}
/// <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>
/// Read event.
/// </summary>
/// <param name="reader">Reader.</param>
/// <returns>Event.</returns>
private static ICacheEntryEvent <TK, TV> ReadEvent0 <TK, TV>(PortableReaderImpl reader)
{
reader.DetachNext();
TK key = reader.ReadObject <TK>();
reader.DetachNext();
TV oldVal = reader.ReadObject <TV>();
reader.DetachNext();
TV val = reader.ReadObject <TV>();
return(CreateEvent(key, oldVal, val));
}
/** <inheritdoc /> */
protected override IList Read(PortableReaderImpl reader)
{
int cnt = reader.ReadInt();
var res = new ArrayList(cnt);
for (int i = 0; i < cnt; i++)
{
res.Add(reader.ReadObject <object>());
}
return(res);
}
/** <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>
/// Create lifecycle bean.
/// </summary>
/// <param name="reader">Reader.</param>
/// <returns>Lifecycle bean.</returns>
internal static ILifecycleBean CreateLifecycleBean(PortableReaderImpl reader)
{
// 1. Instantiate.
string assemblyName = reader.ReadString();
string clsName = reader.ReadString();
object bean = IgniteUtils.CreateInstance(assemblyName, clsName);
// 2. Set properties.
IDictionary <string, object> props = reader.ReadGenericDictionary <string, object>();
IgniteUtils.SetProperties(bean, props);
return(bean as ILifecycleBean);
}
private void FutureError(void *target, long futPtr, long memPtr)
{
SafeCall(() =>
{
IPortableStream stream = IgniteManager.Memory.Get(memPtr).Stream();
PortableReaderImpl reader = _ignite.Marshaller.StartUnmarshal(stream);
string errCls = reader.ReadString();
string errMsg = reader.ReadString();
Exception err = ExceptionUtils.GetException(errCls, errMsg, reader);
ProcessFuture(futPtr, fut => { fut.OnError(err); });
});
}
/// <summary>
/// Prepare callback invoked from Java.
/// </summary>
/// <param name="inStream">Intput stream with data.</param>
/// <param name="outStream">Output stream.</param>
/// <param name="handleRegistry">Handle registry.</param>
internal static void OnPrepare(PlatformMemoryStream inStream, PlatformMemoryStream outStream,
HandleRegistry handleRegistry)
{
try
{
PortableReaderImpl reader = PU.Marshaller.StartUnmarshal(inStream);
PrepareConfiguration(reader.ReadObject <InteropDotNetConfiguration>());
PrepareLifecycleBeans(reader, outStream, handleRegistry);
}
catch (Exception e)
{
_startup.Error = e;
throw;
}
}
/// <summary>
/// Reads events from a portable reader.
/// </summary>
/// <typeparam name="T">Event type.</typeparam>
/// <param name="portableReader">Reader.</param>
/// <returns>Resulting list or null.</returns>
protected static List <T> ReadEvents <T>(PortableReaderImpl portableReader) where T : IEvent
{
var count = portableReader.RawReader().ReadInt();
if (count == -1)
{
return(null);
}
var result = new List <T>(count);
for (var i = 0; i < count; i++)
{
result.Add(EventReader.Read <T>(portableReader));
}
return(result);
}
/// <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>
/// Initializes a new instance of the <see cref="StreamReceiverHolder"/> class.
/// </summary>
/// <param name="reader">The reader.</param>
public StreamReceiverHolder(PortableReaderImpl reader)
{
var rcvType = reader.ReadByte();
_rcv = PortableUtils.ReadPortableOrSerializable <object>(reader);
Debug.Assert(_rcv != null);
var type = _rcv.GetType();
if (rcvType == RcvTransformer)
{
// rcv is a user ICacheEntryProcessor<K, V, A, R>, construct StreamTransformer from it.
// (we can't marshal StreamTransformer directly, because it is generic,
// and we do not know type arguments that user will have)
_rcv = DelegateTypeDescriptor.GetStreamTransformerCtor(type)(_rcv);
}
_invoke = DelegateTypeDescriptor.GetStreamReceiver(_rcv.GetType());
}
/// <summary>
/// Read dictionary returned by GET_ALL operation.
/// </summary>
/// <param name="reader">Reader.</param>
/// <returns>Dictionary.</returns>
private static IDictionary <TK, TV> ReadGetAllDictionary(PortableReaderImpl reader)
{
IPortableStream stream = reader.Stream;
if (stream.ReadBool())
{
int size = stream.ReadInt();
IDictionary <TK, TV> res = new Dictionary <TK, TV>(size);
for (int i = 0; i < size; i++)
{
TK key = reader.ReadObject <TK>();
TV val = reader.ReadObject <TV>();
res[key] = val;
}
return(res);
}
return(null);
}
/// <summary>
/// Initializes a new instance of the <see cref="ServiceDescriptor" /> class.
/// </summary>
/// <param name="name">Name.</param>
/// <param name="reader">Reader.</param>
/// <param name="services">Services.</param>
public ServiceDescriptor(string name, PortableReaderImpl reader, IServices services)
{
Debug.Assert(reader != null);
Debug.Assert(services != null);
Debug.Assert(!string.IsNullOrEmpty(name));
_services = services;
Name = name;
CacheName = reader.ReadString();
MaxPerNodeCount = reader.ReadInt();
TotalCount = reader.ReadInt();
OriginNodeId = reader.ReadGuid() ?? Guid.Empty;
AffinityKey = reader.ReadObject<object>();
var mapSize = reader.ReadInt();
var snap = new Dictionary<Guid, int>(mapSize);
for (var i = 0; i < mapSize; i++)
snap[reader.ReadGuid() ?? Guid.Empty] = reader.ReadInt();
TopologySnapshot = snap.AsReadOnly();
}
/// <summary>
/// Prepare lifecycle beans.
/// </summary>
/// <param name="reader">Reader.</param>
/// <param name="outStream">Output stream.</param>
/// <param name="handleRegistry">Handle registry.</param>
private static void PrepareLifecycleBeans(PortableReaderImpl reader, PlatformMemoryStream outStream,
HandleRegistry handleRegistry)
{
IList <LifecycleBeanHolder> beans = new List <LifecycleBeanHolder>();
// 1. Read beans defined in Java.
int cnt = reader.ReadInt();
for (int i = 0; i < cnt; i++)
{
beans.Add(new LifecycleBeanHolder(CreateLifecycleBean(reader)));
}
// 2. Append beans definied in local configuration.
ICollection <ILifecycleBean> nativeBeans = _startup.Configuration.LifecycleBeans;
if (nativeBeans != null)
{
foreach (ILifecycleBean nativeBean in nativeBeans)
{
beans.Add(new LifecycleBeanHolder(nativeBean));
}
}
// 3. Write bean pointers to Java stream.
outStream.WriteInt(beans.Count);
foreach (LifecycleBeanHolder bean in beans)
{
outStream.WriteLong(handleRegistry.AllocateCritical(bean));
}
outStream.SynchronizeOutput();
// 4. Set beans to STARTUP object.
_startup.LifecycleBeans = beans;
}
/// <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));
}
/// <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);
}
/// <summary>
/// Creates exception according to native code class and message.
/// </summary>
/// <param name="clsName">Exception class name.</param>
/// <param name="msg">Exception message.</param>
/// <param name="reader">Error data reader.</param>
public static Exception GetException(string clsName, string msg, PortableReaderImpl reader = null)
{
ExceptionFactoryDelegate ctor;
if (EXS.TryGetValue(clsName, out ctor))
return ctor(msg);
if (ClsNoClsDefFoundErr.Equals(clsName))
return new IgniteException("Java class is not found (did you set IGNITE_HOME environment " +
"variable?): " + msg);
if (ClsNoSuchMthdErr.Equals(clsName))
return new IgniteException("Java class method is not found (did you set IGNITE_HOME environment " +
"variable?): " + msg);
if (ClsCachePartialUpdateErr.Equals(clsName))
return ProcessCachePartialUpdateException(msg, reader);
return new IgniteException("Java exception occurred [class=" + clsName + ", message=" + msg + ']');
}
public void TestHandlesExclusive([Values(true, false)] bool detached, [Values(true, false)] bool asPortable)
{
var marsh = new PortableMarshaller(new PortableConfiguration
{
TypeConfigurations = new List<PortableTypeConfiguration>
{
new PortableTypeConfiguration(typeof (HandleInner)),
new PortableTypeConfiguration(typeof (HandleOuterExclusive))
}
});
var inner = new HandleInner
{
Before = "inBefore",
After = "inAfter",
RawBefore = "inRawBefore",
RawAfter = "inRawAfter"
};
var outer = new HandleOuterExclusive
{
Before = "outBefore",
After = "outAfter",
RawBefore = "outRawBefore",
RawAfter = "outRawAfter",
Inner = inner,
RawInner = inner
};
inner.Outer = outer;
inner.RawOuter = outer;
var bytes = asPortable
? marsh.Marshal(new PortablesImpl(marsh).ToPortable<IPortableObject>(outer))
: marsh.Marshal(outer);
IPortableObject outerObj;
if (detached)
{
var reader = new PortableReaderImpl(marsh, new Dictionary<long, IPortableTypeDescriptor>(),
new PortableHeapStream(bytes), PortableMode.ForcePortable, null);
reader.DetachNext();
outerObj = reader.Deserialize<IPortableObject>();
}
else
outerObj = marsh.Unmarshal<IPortableObject>(bytes, PortableMode.ForcePortable);
HandleOuter newOuter = outerObj.Deserialize<HandleOuter>();
Assert.IsFalse(newOuter == newOuter.Inner.Outer);
Assert.IsFalse(newOuter == newOuter.Inner.RawOuter);
Assert.IsFalse(newOuter == newOuter.RawInner.RawOuter);
Assert.IsFalse(newOuter == newOuter.RawInner.RawOuter);
Assert.IsFalse(newOuter.Inner == newOuter.RawInner);
Assert.IsTrue(newOuter.Inner.Outer == newOuter.Inner.RawOuter);
Assert.IsTrue(newOuter.RawInner.Outer == newOuter.RawInner.RawOuter);
Assert.IsTrue(newOuter.Inner == newOuter.Inner.Outer.Inner);
Assert.IsTrue(newOuter.Inner == newOuter.Inner.Outer.RawInner);
Assert.IsTrue(newOuter.RawInner == newOuter.RawInner.Outer.Inner);
Assert.IsTrue(newOuter.RawInner == newOuter.RawInner.Outer.RawInner);
}
/// <summary> /// Read entry from the reader. /// </summary> /// <param name="reader">Reader.</param> /// <returns>Entry.</returns> protected abstract T Read(PortableReaderImpl reader);
/// <summary>
/// Reads a node from stream.
/// </summary>
private IClusterNode ReadNode(PortableReaderImpl r)
{
return(GetNode(r.ReadGuid()));
}
/// <summary>
/// Create lifecycle bean.
/// </summary>
/// <param name="reader">Reader.</param>
/// <returns>Lifecycle bean.</returns>
internal static ILifecycleBean CreateLifecycleBean(PortableReaderImpl reader)
{
// 1. Instantiate.
string assemblyName = reader.ReadString();
string clsName = reader.ReadString();
object bean = IgniteUtils.CreateInstance(assemblyName, clsName);
// 2. Set properties.
IDictionary<string, object> props = reader.ReadGenericDictionary<string, object>();
IgniteUtils.SetProperties(bean, props);
return bean as ILifecycleBean;
}
/// <summary>
/// Reads the generic collection.
/// </summary>
public object ReadGeneric(PortableReaderImpl reader)
{
Debug.Assert(reader != null);
Debug.Assert(_readFunc != null);
return _readFunc(reader, null);
}
/// <summary>
/// Prepare lifecycle beans.
/// </summary>
/// <param name="reader">Reader.</param>
/// <param name="outStream">Output stream.</param>
/// <param name="handleRegistry">Handle registry.</param>
private static void PrepareLifecycleBeans(PortableReaderImpl reader, PlatformMemoryStream outStream,
HandleRegistry handleRegistry)
{
IList<LifecycleBeanHolder> beans = new List<LifecycleBeanHolder>();
// 1. Read beans defined in Java.
int cnt = reader.ReadInt();
for (int i = 0; i < cnt; i++)
beans.Add(new LifecycleBeanHolder(CreateLifecycleBean(reader)));
// 2. Append beans definied in local configuration.
ICollection<ILifecycleBean> nativeBeans = _startup.Configuration.LifecycleBeans;
if (nativeBeans != null)
{
foreach (ILifecycleBean nativeBean in nativeBeans)
beans.Add(new LifecycleBeanHolder(nativeBean));
}
// 3. Write bean pointers to Java stream.
outStream.WriteInt(beans.Count);
foreach (LifecycleBeanHolder bean in beans)
outStream.WriteLong(handleRegistry.AllocateCritical(bean));
outStream.SynchronizeOutput();
// 4. Set beans to STARTUP object.
_startup.LifecycleBeans = beans;
}
