/// <summary>
/// Reads proxy method invocation data from the specified reader.
/// </summary>
/// <param name="stream">Stream.</param>
/// <param name="marsh">Marshaller.</param>
/// <param name="mthdName">Method name.</param>
/// <param name="mthdArgs">Method arguments.</param>
public static void ReadProxyMethod(IPortableStream stream, PortableMarshaller marsh,
out string mthdName, out object[] mthdArgs)
{
var reader = marsh.StartUnmarshal(stream);
var srvKeepPortable = reader.ReadBoolean();
mthdName = reader.ReadString();
if (reader.ReadBoolean())
{
mthdArgs = new object[reader.ReadInt()];
if (srvKeepPortable)
{
reader = marsh.StartUnmarshal(stream, true);
}
for (var i = 0; i < mthdArgs.Length; i++)
{
mthdArgs[i] = reader.ReadObject <object>();
}
}
else
{
mthdArgs = null;
}
}
/// <summary>
/// Read single event.
/// </summary>
/// <param name="stream">Stream to read data from.</param>
/// <param name="marsh">Marshaller.</param>
/// <param name="keepPortable">Keep portable flag.</param>
/// <returns>Event.</returns>
public static ICacheEntryEvent <TK, TV> ReadEvent <TK, TV>(IPortableStream stream,
PortableMarshaller marsh, bool keepPortable)
{
var reader = marsh.StartUnmarshal(stream, keepPortable);
return(ReadEvent0 <TK, TV>(reader));
}
/// <summary>
/// Reads method invocation result.
/// </summary>
/// <param name="stream">Stream.</param>
/// <param name="marsh">Marshaller.</param>
/// <param name="keepPortable">Portable flag.</param>
/// <returns>
/// Method invocation result, or exception in case of error.
/// </returns>
public static object ReadInvocationResult(IPortableStream stream, PortableMarshaller marsh, bool keepPortable)
{
Debug.Assert(stream != null);
Debug.Assert(marsh != null);
var mode = keepPortable ? PortableMode.ForcePortable : PortableMode.Deserialize;
var reader = marsh.StartUnmarshal(stream, mode);
object err;
var res = PortableUtils.ReadInvocationResult(reader, out err);
if (err == null)
{
return(res);
}
var portErr = err as IPortableObject;
throw portErr != null
? new ServiceInvocationException("Proxy method invocation failed with a portable error. " +
"Examine PortableCause for details.", portErr)
: new ServiceInvocationException("Proxy method invocation failed with an exception. " +
"Examine InnerException for details.", (Exception)err);
}
/// <summary>
/// Constructor.
/// </summary>
/// <param name="target">Target.</param>
/// <param name="marsh">Marshaller.</param>
/// <param name="cacheName">Cache name.</param>
/// <param name="keepPortable">Portable flag.</param>
public DataStreamerImpl(IUnmanagedTarget target, PortableMarshaller marsh, string cacheName, bool keepPortable)
: base(target, marsh)
{
_cacheName = cacheName;
_keepPortable = keepPortable;
// Create empty batch.
_batch = new DataStreamerBatch <TK, TV>();
// Allocate GC handle so that this data streamer could be easily dereferenced from native code.
WeakReference thisRef = new WeakReference(this);
_hnd = marsh.Ignite.HandleRegistry.Allocate(thisRef);
// Start topology listening. This call will ensure that buffer size member is updated.
UU.DataStreamerListenTopology(target, _hnd);
// Membar to ensure fields initialization before leaving constructor.
Thread.MemoryBarrier();
// Start flusher after everything else is initialized.
_flusher = new Flusher <TK, TV>(thisRef);
_flusher.RunThread();
}
/// <summary>
/// Constructor.
/// </summary>
/// <param name="cfg">Configuration.</param>
/// <param name="name">Grid name.</param>
/// <param name="proc">Interop processor.</param>
/// <param name="marsh">Marshaller.</param>
/// <param name="lifecycleBeans">Lifecycle beans.</param>
/// <param name="cbs">Callbacks.</param>
public Ignite(IgniteConfiguration cfg, string name, IUnmanagedTarget proc, PortableMarshaller marsh,
IList <LifecycleBeanHolder> lifecycleBeans, UnmanagedCallbacks cbs)
{
Debug.Assert(cfg != null);
Debug.Assert(proc != null);
Debug.Assert(marsh != null);
Debug.Assert(lifecycleBeans != null);
Debug.Assert(cbs != null);
_cfg = cfg;
_name = name;
_proc = proc;
_marsh = marsh;
_lifecycleBeans = lifecycleBeans;
_cbs = cbs;
marsh.Ignite = this;
_prj = new ClusterGroupImpl(proc, UU.ProcessorProjection(proc), marsh, this, null);
_portables = new PortablesImpl(marsh);
_proxy = new IgniteProxy(this);
cbs.Initialize(this);
// Grid is not completely started here, can't initialize interop transactions right away.
_transactions = new Lazy <TransactionsImpl>(
() => new TransactionsImpl(UU.ProcessorTransactions(proc), marsh, LocalNode.Id));
}
/// <summary>
/// Constructor.
/// </summary>
/// <param name="marsh">Marshaller.</param>
/// <param name="keepPortable">Keep portable.</param>
/// <param name="func">Converting function.</param>
public FutureConverter(PortableMarshaller marsh, bool keepPortable,
Func <PortableReaderImpl, T> func = null)
{
_marsh = marsh;
_keepPortable = keepPortable;
_func = func ?? (reader => reader.ReadObject <T>());
}
/// <summary>
/// Constructor.
/// </summary>
/// <param name="target">Target.</param>
/// <param name="marsh">Marshaller.</param>
/// <param name="prj">Projection.</param>
/// <param name="keepPortable">"keepPortable" flag.</param>
public ComputeImpl(IUnmanagedTarget target, PortableMarshaller marsh, ClusterGroupImpl prj, bool keepPortable)
: base(target, marsh)
{
_prj = prj;
_keepPortable.Value = keepPortable;
}
/// <summary>
/// Constructor.
/// </summary>
/// <param name="qry">Query.</param>
/// <param name="marsh">Marshaller.</param>
/// <param name="keepPortable">Keep portable flag.</param>
public ContinuousQueryHandleImpl(ContinuousQuery <TK, TV> qry, PortableMarshaller marsh, bool keepPortable)
{
_marsh = marsh;
_keepPortable = keepPortable;
_lsnr = qry.Listener;
_filter = qry.Filter;
}
/// <summary>
/// Initializes a new instance of the <see cref="Events"/> class.
/// </summary>
/// <param name="target">Target.</param>
/// <param name="marsh">Marshaller.</param>
/// <param name="clusterGroup">Cluster group.</param>
public Events(IUnmanagedTarget target, PortableMarshaller marsh, IClusterGroup clusterGroup)
: base(target, marsh)
{
Debug.Assert(clusterGroup != null);
ClusterGroup = clusterGroup;
Ignite = (Ignite)clusterGroup.Ignite;
}
/// <summary>
/// Initializes a new instance of the <see cref="Messaging" /> class.
/// </summary>
/// <param name="target">Target.</param>
/// <param name="marsh">Marshaller.</param>
/// <param name="prj">Cluster group.</param>
public Messaging(IUnmanagedTarget target, PortableMarshaller marsh, IClusterGroup prj)
: base(target, marsh)
{
Debug.Assert(prj != null);
ClusterGroup = prj;
_ignite = (Ignite)prj.Ignite;
}
/// <summary>
/// Initializes a new instance of the <see cref="CacheAffinityImpl" /> class.
/// </summary>
/// <param name="target">Target.</param>
/// <param name="marsh">Marshaller.</param>
/// <param name="keepPortable">Keep portable flag.</param>
/// <param name="ignite">Grid.</param>
public CacheAffinityImpl(IUnmanagedTarget target, PortableMarshaller marsh, bool keepPortable,
Ignite ignite) : base(target, marsh)
{
_keepPortable = keepPortable;
Debug.Assert(ignite != null);
_ignite = ignite;
}
/// <summary>
/// Constructor.
/// </summary>
/// <param name="grid">Grid.</param>
/// <param name="target">Target.</param>
/// <param name="marsh">Marshaller.</param>
/// <param name="flagSkipStore">Skip store flag.</param>
/// <param name="flagKeepPortable">Keep portable flag.</param>
/// <param name="flagAsync">Async mode flag.</param>
/// <param name="flagNoRetries">No-retries mode flag.</param>
public CacheImpl(Ignite grid, IUnmanagedTarget target, PortableMarshaller marsh,
bool flagSkipStore, bool flagKeepPortable, bool flagAsync, bool flagNoRetries) : base(target, marsh)
{
_ignite = grid;
_flagSkipStore = flagSkipStore;
_flagKeepPortable = flagKeepPortable;
_flagAsync = flagAsync;
_flagNoRetries = flagNoRetries;
}
/// <summary>
/// Writes method invocation result.
/// </summary>
/// <param name="stream">Stream.</param>
/// <param name="marsh">Marshaller.</param>
/// <param name="methodResult">Method result.</param>
/// <param name="invocationError">Method invocation error.</param>
public static void WriteInvocationResult(IPortableStream stream, PortableMarshaller marsh, object methodResult,
Exception invocationError)
{
Debug.Assert(stream != null);
Debug.Assert(marsh != null);
var writer = marsh.StartMarshal(stream);
PortableUtils.WriteInvocationResult(writer, invocationError == null, invocationError ?? methodResult);
}
/// <summary>
/// Initializes a new instance of the <see cref="Services" /> class.
/// </summary>
/// <param name="target">Target.</param>
/// <param name="marsh">Marshaller.</param>
/// <param name="clusterGroup">Cluster group.</param>
/// <param name="keepPortable">Invoker portable flag.</param>
/// <param name="srvKeepPortable">Server portable flag.</param>
public Services(IUnmanagedTarget target, PortableMarshaller marsh, IClusterGroup clusterGroup,
bool keepPortable, bool srvKeepPortable)
: base(target, marsh)
{
Debug.Assert(clusterGroup != null);
_clusterGroup = clusterGroup;
KeepPortable = keepPortable;
SrvKeepPortable = srvKeepPortable;
}
/// <summary>
/// Writes this instance to the stream.
/// </summary>
/// <param name="stream">Stream.</param>
/// <param name="marsh">Marshaller.</param>
public void Write(IPortableStream stream, PortableMarshaller marsh)
{
var writer = marsh.StartMarshal(stream);
try
{
Marshal(writer);
}
finally
{
marsh.FinishMarshal(writer);
}
}
/// <summary>
/// Writes this instance to the stream.
/// </summary>
/// <param name="stream">Stream.</param>
/// <param name="marsh">Marshaller.</param>
public void Write(IPortableStream stream, PortableMarshaller marsh)
{
var writer = marsh.StartMarshal(stream);
try
{
Marshal(writer);
}
finally
{
marsh.FinishMarshal(writer);
}
}
/// <summary>
/// Initializes a new instance of the <see cref="CacheEntryFilterHolder" /> class.
/// </summary>
/// <param name="pred">The <see cref="ICacheEntryFilter{TK,TV}" /> to wrap.</param>
/// <param name="invoker">The invoker func that takes key and value and invokes wrapped ICacheEntryFilter.</param>
/// <param name="marsh">Marshaller.</param>
/// <param name="keepPortable">Keep portable flag.</param>
public CacheEntryFilterHolder(object pred, Func <object, object, bool> invoker, PortableMarshaller marsh,
bool keepPortable)
{
Debug.Assert(pred != null);
Debug.Assert(invoker != null);
Debug.Assert(marsh != null);
_pred = pred;
_invoker = invoker;
_marsh = marsh;
_keepPortable = keepPortable;
_handle = marsh.Ignite.HandleRegistry.Allocate(this);
}
/// <summary>
/// Initializes a new instance of the <see cref="CacheEntryFilterHolder" /> class.
/// </summary>
/// <param name="pred">The <see cref="ICacheEntryFilter{TK,TV}" /> to wrap.</param>
/// <param name="invoker">The invoker func that takes key and value and invokes wrapped ICacheEntryFilter.</param>
/// <param name="marsh">Marshaller.</param>
/// <param name="keepPortable">Keep portable flag.</param>
public CacheEntryFilterHolder(object pred, Func<object, object, bool> invoker, PortableMarshaller marsh,
bool keepPortable)
{
Debug.Assert(pred != null);
Debug.Assert(invoker != null);
Debug.Assert(marsh != null);
_pred = pred;
_invoker = invoker;
_marsh = marsh;
_keepPortable = keepPortable;
_handle = marsh.Ignite.HandleRegistry.Allocate(this);
}
/// <summary>
/// Initializes a new instance of the <see cref="CacheEntryFilterHolder"/> class.
/// </summary>
/// <param name="reader">The reader.</param>
public CacheEntryFilterHolder(IPortableReader reader)
{
var reader0 = (PortableReaderImpl)reader.RawReader();
_pred = PortableUtils.ReadPortableOrSerializable <object>(reader0);
_keepPortable = reader0.ReadBoolean();
_marsh = reader0.Marshaller;
_invoker = GetInvoker(_pred);
_handle = _marsh.Ignite.HandleRegistry.Allocate(this);
}
public static ICacheEntryEvent <TK, TV>[] ReadEvents <TK, TV>(IPortableStream stream,
PortableMarshaller marsh, bool keepPortable)
{
var reader = marsh.StartUnmarshal(stream, keepPortable);
int cnt = reader.ReadInt();
ICacheEntryEvent <TK, TV>[] evts = new ICacheEntryEvent <TK, TV> [cnt];
for (int i = 0; i < cnt; i++)
{
evts[i] = ReadEvent0 <TK, TV>(reader);
}
return(evts);
}
/// <summary>
/// Constructor.
/// </summary>
/// <param name="proc">Processor.</param>
/// <param name="target">Target.</param>
/// <param name="marsh">Marshaller.</param>
/// <param name="ignite">Grid.</param>
/// <param name="pred">Predicate.</param>
public ClusterGroupImpl(IUnmanagedTarget proc, IUnmanagedTarget target, PortableMarshaller marsh,
Ignite ignite, Func <IClusterNode, bool> pred)
: base(target, marsh)
{
_proc = proc;
_ignite = ignite;
_pred = pred;
_comp = new Lazy <Compute>(() =>
new Compute(new ComputeImpl(UU.ProcessorCompute(proc, target), marsh, this, false)));
_msg = new Lazy <Messaging>(() => new Messaging(UU.ProcessorMessage(proc, target), marsh, this));
_events = new Lazy <Events>(() => new Events(UU.ProcessorEvents(proc, target), marsh, this));
_services = new Lazy <IServices>(() =>
new Services(UU.ProcessorServices(proc, target), marsh, this, false, false));
}
/// <summary>
/// Initializes a new instance of the <see cref="TransactionsImpl" /> class.
/// </summary>
/// <param name="target">Target.</param>
/// <param name="marsh">Marshaller.</param>
/// <param name="localNodeId">Local node id.</param>
public TransactionsImpl(IUnmanagedTarget target, PortableMarshaller marsh,
Guid localNodeId) : base(target, marsh)
{
_localNodeId = localNodeId;
TransactionConcurrency concurrency = default(TransactionConcurrency);
TransactionIsolation isolation = default(TransactionIsolation);
TimeSpan timeout = default(TimeSpan);
DoInOp(OpCacheConfigParameters, stream =>
{
var reader = marsh.StartUnmarshal(stream).RawReader();
concurrency = reader.ReadEnum <TransactionConcurrency>();
isolation = reader.ReadEnum <TransactionIsolation>();
timeout = TimeSpan.FromMilliseconds(reader.ReadLong());
});
_dfltConcurrency = concurrency;
_dfltIsolation = isolation;
_dfltTimeout = timeout;
}
/// <summary>
/// Reads proxy method invocation data from the specified reader.
/// </summary>
/// <param name="stream">Stream.</param>
/// <param name="marsh">Marshaller.</param>
/// <param name="mthdName">Method name.</param>
/// <param name="mthdArgs">Method arguments.</param>
public static void ReadProxyMethod(IPortableStream stream, PortableMarshaller marsh,
out string mthdName, out object[] mthdArgs)
{
var reader = marsh.StartUnmarshal(stream);
var srvKeepPortable = reader.ReadBoolean();
mthdName = reader.ReadString();
if (reader.ReadBoolean())
{
mthdArgs = new object[reader.ReadInt()];
if (srvKeepPortable)
reader = marsh.StartUnmarshal(stream, true);
for (var i = 0; i < mthdArgs.Length; i++)
mthdArgs[i] = reader.ReadObject<object>();
}
else
mthdArgs = null;
}
public void TestPrimitiveFieldsRawSerializer()
{
ICollection<PortableTypeConfiguration> typeCfgs =
new List<PortableTypeConfiguration>();
PortableTypeConfiguration typeCfg =
new PortableTypeConfiguration(typeof(PrimitiveFieldType));
typeCfg.Serializer = new PrimitiveFieldsRawSerializer();
typeCfgs.Add(typeCfg);
PortableConfiguration cfg = new PortableConfiguration();
cfg.TypeConfigurations = typeCfgs;
PortableMarshaller marsh = new PortableMarshaller(cfg);
PrimitiveFieldType obj = new PrimitiveFieldType();
CheckPrimitiveFields(marsh, obj);
}
/// <summary>
/// Constructor.
/// </summary>
/// <param name="target">Target.</param>
/// <param name="marsh">Marshaller.</param>
/// <param name="keepPortable">Keep portable flag.</param>
public CacheEnumerator(IUnmanagedTarget target, PortableMarshaller marsh, bool keepPortable) :
base(target, marsh)
{
_keepPortable = keepPortable;
}
/// <summary>
/// Constructor.
/// </summary>
/// <param name="target">Target.</param>
/// <param name="marsh">Marshaller.</param>
protected PlatformDisposableTarget(IUnmanagedTarget target, PortableMarshaller marsh) : base(target, marsh)
{
// No-op.
}
/// <summary>
/// Constructor.
/// </summary>
/// <param name="target">Target.</param>
/// <param name="marsh">Marshaller.</param>
/// <param name="keepPortable">Keep portable flag.</param>
protected AbstractQueryCursor(IUnmanagedTarget target, PortableMarshaller marsh, bool keepPortable) :
base(target, marsh)
{
_keepPortable = keepPortable;
}
public void TestEnumsReflective()
{
PortableMarshaller marsh =
new PortableMarshaller(new PortableConfiguration
{
TypeConfigurations =
new List<PortableTypeConfiguration> {new PortableTypeConfiguration(typeof (EnumType))}
});
EnumType obj = new EnumType
{
PEnum = TestEnum.Val1,
PEnumArray = new[] {TestEnum.Val2, TestEnum.Val3}
};
byte[] bytes = marsh.Marshal(obj);
IPortableObject portObj = marsh.Unmarshal<IPortableObject>(bytes, PortableMode.ForcePortable);
Assert.AreEqual(obj.GetHashCode(), portObj.GetHashCode());
EnumType newObj = portObj.Deserialize<EnumType>();
Assert.AreEqual(obj.PEnum, newObj.PEnum);
Assert.AreEqual(obj.PEnumArray, newObj.PEnumArray);
}
public void TestObjectReflective()
{
ICollection<PortableTypeConfiguration> typeCfgs =
new List<PortableTypeConfiguration>();
typeCfgs.Add(new PortableTypeConfiguration(typeof(OuterObjectType)));
typeCfgs.Add(new PortableTypeConfiguration(typeof(InnerObjectType)));
PortableConfiguration cfg = new PortableConfiguration();
cfg.TypeConfigurations = typeCfgs;
PortableMarshaller marsh = new PortableMarshaller(cfg);
CheckObject(marsh, new OuterObjectType(), new InnerObjectType());
}
private static void CheckKeepSerialized(PortableConfiguration cfg, bool expKeep)
{
if (cfg.TypeConfigurations == null)
{
cfg.TypeConfigurations = new List<PortableTypeConfiguration>
{
new PortableTypeConfiguration(typeof(PropertyType))
};
}
PortableMarshaller marsh = new PortableMarshaller(cfg);
byte[] data = marsh.Marshal(new PropertyType());
IPortableObject portNewObj = marsh.Unmarshal<IPortableObject>(data, PortableMode.ForcePortable);
PropertyType deserialized1 = portNewObj.Deserialize<PropertyType>();
PropertyType deserialized2 = portNewObj.Deserialize<PropertyType>();
Assert.NotNull(deserialized1);
Assert.AreEqual(expKeep, deserialized1 == deserialized2);
}
public void TestSpecialArrays()
{
ICollection<PortableTypeConfiguration> typeCfgs =
new List<PortableTypeConfiguration>();
typeCfgs.Add(new PortableTypeConfiguration(typeof(SpecialArray)));
typeCfgs.Add(new PortableTypeConfiguration(typeof(SpecialArrayMarshalAware)));
PortableConfiguration cfg = new PortableConfiguration();
cfg.TypeConfigurations = typeCfgs;
PortableMarshaller marsh = new PortableMarshaller(cfg);
Guid[] guidArr = { Guid.NewGuid() };
Guid?[] nGuidArr = { Guid.NewGuid() };
DateTime[] dateArr = { DateTime.Now.ToUniversalTime() };
DateTime?[] nDateArr = { DateTime.Now.ToUniversalTime() };
// Use special object.
SpecialArray obj1 = new SpecialArray();
obj1.GuidArr = guidArr;
obj1.NGuidArr = nGuidArr;
obj1.DateArr = dateArr;
obj1.NDateArr = nDateArr;
byte[] bytes = marsh.Marshal(obj1);
IPortableObject portObj = marsh.Unmarshal<IPortableObject>(bytes, PortableMode.ForcePortable);
Assert.AreEqual(guidArr, portObj.Field<Guid[]>("guidArr"));
Assert.AreEqual(nGuidArr, portObj.Field<Guid?[]>("nGuidArr"));
Assert.AreEqual(dateArr, portObj.Field<DateTime[]>("dateArr"));
Assert.AreEqual(nDateArr, portObj.Field<DateTime?[]>("nDateArr"));
obj1 = portObj.Deserialize<SpecialArray>();
Assert.AreEqual(guidArr, obj1.GuidArr);
Assert.AreEqual(nGuidArr, obj1.NGuidArr);
Assert.AreEqual(dateArr, obj1.DateArr);
Assert.AreEqual(nDateArr, obj1.NDateArr);
// Use special with IGridPortableMarshalAware.
SpecialArrayMarshalAware obj2 = new SpecialArrayMarshalAware();
obj2.GuidArr = guidArr;
obj2.NGuidArr = nGuidArr;
obj2.DateArr = dateArr;
obj2.NDateArr = nDateArr;
bytes = marsh.Marshal(obj2);
portObj = marsh.Unmarshal<IPortableObject>(bytes, PortableMode.ForcePortable);
Assert.AreEqual(guidArr, portObj.Field<Guid[]>("a"));
Assert.AreEqual(nGuidArr, portObj.Field<Guid?[]>("b"));
Assert.AreEqual(dateArr, portObj.Field<DateTime[]>("c"));
Assert.AreEqual(nDateArr, portObj.Field<DateTime?[]>("d"));
obj2 = portObj.Deserialize<SpecialArrayMarshalAware>();
Assert.AreEqual(guidArr, obj2.GuidArr);
Assert.AreEqual(nGuidArr, obj2.NGuidArr);
Assert.AreEqual(dateArr, obj2.DateArr);
Assert.AreEqual(nDateArr, obj2.NDateArr);
}
/// <summary>
/// Initializes a new instance of the <see cref="MessagingAsync" /> class.
/// </summary>
/// <param name="target">Target.</param>
/// <param name="marsh">Marshaller.</param>
/// <param name="prj">Cluster group.</param>
public MessagingAsync(IUnmanagedTarget target, PortableMarshaller marsh,
IClusterGroup prj) : base(target, marsh, prj)
{
// No-op.
}
/// <summary>
/// Initializes a new instance of the <see cref="CacheEntryFilterHolder"/> class.
/// </summary>
/// <param name="reader">The reader.</param>
public CacheEntryFilterHolder(IPortableReader reader)
{
var reader0 = (PortableReaderImpl)reader.RawReader();
_pred = PortableUtils.ReadPortableOrSerializable<object>(reader0);
_keepPortable = reader0.ReadBoolean();
_marsh = reader0.Marshaller;
_invoker = GetInvoker(_pred);
_handle = _marsh.Ignite.HandleRegistry.Allocate(this);
}
private void CheckPrimitiveFields(PortableMarshaller marsh, PrimitiveFieldType obj)
{
obj.PBool = true;
obj.PByte = 2;
obj.PSbyte = 3;
obj.PShort = 4;
obj.PUshort = 5;
obj.PInt = 6;
obj.PUint = 7;
obj.PLong = 8;
obj.PUlong = 9;
obj.PChar = 'a';
obj.PFloat = 10;
obj.PDouble = 11;
obj.PString = "abc";
obj.PGuid = Guid.NewGuid();
obj.PnGuid = Guid.NewGuid();
//CheckPrimitiveFieldsSerialization(marsh, obj);
//obj.PString = "";
//CheckPrimitiveFieldsSerialization(marsh, obj);
//obj.PString = null;
//CheckPrimitiveFieldsSerialization(marsh, obj);
//obj.PString = null;
//obj.PNGuid = null;
CheckPrimitiveFieldsSerialization(marsh, obj);
}
private void CheckPrimitiveFieldsSerialization(PortableMarshaller marsh, PrimitiveFieldType obj)
{
byte[] bytes = marsh.Marshal(obj);
IPortableObject portObj = marsh.Unmarshal<IPortableObject>(bytes, PortableMode.ForcePortable);
Assert.AreEqual(obj.GetHashCode(), portObj.GetHashCode());
PrimitiveFieldType newObj = portObj.Deserialize<PrimitiveFieldType>();
Assert.AreEqual(obj, newObj);
}
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);
}
public void TestCollectionsReflective()
{
ICollection<PortableTypeConfiguration> typeCfgs =
new List<PortableTypeConfiguration>();
typeCfgs.Add(new PortableTypeConfiguration(typeof(CollectionsType)));
typeCfgs.Add(new PortableTypeConfiguration(typeof(InnerObjectType)));
PortableConfiguration cfg = new PortableConfiguration();
cfg.TypeConfigurations = typeCfgs;
PortableMarshaller marsh = new PortableMarshaller(cfg);
CollectionsType obj = new CollectionsType();
ArrayList list = new ArrayList();
list.Add(true);
list.Add((byte)1);
list.Add((short)2);
list.Add('a');
list.Add(3);
list.Add((long)4);
list.Add((float)5);
list.Add((double)6);
list.Add("string");
list.Add(Guid.NewGuid());
InnerObjectType innerObj = new InnerObjectType();
innerObj.PInt1 = 1;
innerObj.PInt2 = 2;
list.Add(innerObj);
obj.Col1 = list;
byte[] bytes = marsh.Marshal(obj);
IPortableObject portObj = marsh.Unmarshal<IPortableObject>(bytes, PortableMode.ForcePortable);
Assert.AreEqual(obj.GetHashCode(), portObj.GetHashCode());
CollectionsType newObj = portObj.Deserialize<CollectionsType>();
Assert.AreEqual(obj, newObj);
obj.Col1 = null;
Assert.AreEqual(obj, marsh.Unmarshal<CollectionsType>(marsh.Marshal(obj)));
obj.Col1 = list;
obj.Col2 = list;
Assert.AreEqual(obj, marsh.Unmarshal<CollectionsType>(marsh.Marshal(obj)));
obj.Col2 = new TestList();
Assert.AreEqual(obj, marsh.Unmarshal<CollectionsType>(marsh.Marshal(obj)));
}
/// <summary>
/// Initializes a new instance of the <see cref="Events"/> class.
/// </summary>
/// <param name="target">Target.</param>
/// <param name="marsh">Marshaller.</param>
/// <param name="clusterGroup">Cluster group.</param>
public EventsAsync(IUnmanagedTarget target, PortableMarshaller marsh, IClusterGroup clusterGroup)
: base(target, marsh, clusterGroup)
{
// No-op.
}
public void TestHandles()
{
ICollection<PortableTypeConfiguration> typeCfgs =
new List<PortableTypeConfiguration>();
typeCfgs.Add(new PortableTypeConfiguration(typeof(HandleInner)));
typeCfgs.Add(new PortableTypeConfiguration(typeof(HandleOuter)));
PortableConfiguration cfg = new PortableConfiguration();
cfg.TypeConfigurations = typeCfgs;
PortableMarshaller marsh = new PortableMarshaller(cfg);
HandleOuter outer = new HandleOuter();
outer.Before = "outBefore";
outer.After = "outAfter";
outer.RawBefore = "outRawBefore";
outer.RawAfter = "outRawAfter";
HandleInner inner = new HandleInner();
inner.Before = "inBefore";
inner.After = "inAfter";
inner.RawBefore = "inRawBefore";
inner.RawAfter = "inRawAfter";
outer.Inner = inner;
outer.RawInner = inner;
inner.Outer = outer;
inner.RawOuter = outer;
byte[] bytes = marsh.Marshal(outer);
IPortableObject outerObj = marsh.Unmarshal<IPortableObject>(bytes, PortableMode.ForcePortable);
HandleOuter newOuter = outerObj.Deserialize<HandleOuter>();
HandleInner newInner = newOuter.Inner;
CheckHandlesConsistency(outer, inner, newOuter, newInner);
// Get inner object by field.
IPortableObject innerObj = outerObj.Field<IPortableObject>("inner");
newInner = innerObj.Deserialize<HandleInner>();
newOuter = newInner.Outer;
CheckHandlesConsistency(outer, inner, newOuter, newInner);
// Get outer object from inner object by handle.
outerObj = innerObj.Field<IPortableObject>("outer");
newOuter = outerObj.Deserialize<HandleOuter>();
newInner = newOuter.Inner;
CheckHandlesConsistency(outer, inner, newOuter, newInner);
}
public void BeforeTest()
{
_marsh = new PortableMarshaller(null);
}
public void SetUp()
{
TestUtils.KillProcesses();
var cfg = new IgniteConfiguration
{
PortableConfiguration = new PortableConfiguration
{
TypeConfigurations = new List<PortableTypeConfiguration>
{
new PortableTypeConfiguration(typeof (Empty)),
new PortableTypeConfiguration(typeof (Primitives)),
new PortableTypeConfiguration(typeof (PrimitiveArrays)),
new PortableTypeConfiguration(typeof (StringDateGuidEnum)),
new PortableTypeConfiguration(typeof (WithRaw)),
new PortableTypeConfiguration(typeof (MetaOverwrite)),
new PortableTypeConfiguration(typeof (NestedOuter)),
new PortableTypeConfiguration(typeof (NestedInner)),
new PortableTypeConfiguration(typeof (MigrationOuter)),
new PortableTypeConfiguration(typeof (MigrationInner)),
new PortableTypeConfiguration(typeof (InversionOuter)),
new PortableTypeConfiguration(typeof (InversionInner)),
new PortableTypeConfiguration(typeof (CompositeOuter)),
new PortableTypeConfiguration(typeof (CompositeInner)),
new PortableTypeConfiguration(typeof (CompositeArray)),
new PortableTypeConfiguration(typeof (CompositeContainer)),
new PortableTypeConfiguration(typeof (ToPortable)),
new PortableTypeConfiguration(typeof (Remove)),
new PortableTypeConfiguration(typeof (RemoveInner)),
new PortableTypeConfiguration(typeof (BuilderInBuilderOuter)),
new PortableTypeConfiguration(typeof (BuilderInBuilderInner)),
new PortableTypeConfiguration(typeof (BuilderCollection)),
new PortableTypeConfiguration(typeof (BuilderCollectionItem)),
new PortableTypeConfiguration(typeof (DecimalHolder)),
new PortableTypeConfiguration(TypeEmpty),
TypeConfigurationNoMeta(typeof (EmptyNoMeta)),
TypeConfigurationNoMeta(typeof (ToPortableNoMeta))
},
DefaultIdMapper = new IdMapper()
},
JvmClasspath = TestUtils.CreateTestClasspath(),
JvmOptions = new List<string>
{
"-ea",
"-Xcheck:jni",
"-Xms4g",
"-Xmx4g",
"-DIGNITE_QUIET=false",
"-Xnoagent",
"-Djava.compiler=NONE",
"-Xdebug",
"-Xrunjdwp:transport=dt_socket,server=y,suspend=n,address=5005",
"-XX:+HeapDumpOnOutOfMemoryError"
},
SpringConfigUrl = "config\\portable.xml"
};
_grid = (Ignite) Ignition.Start(cfg);
_marsh = _grid.Marshaller;
}
public void TestDateObject()
{
ICollection<PortableTypeConfiguration> typeCfgs =
new List<PortableTypeConfiguration>();
typeCfgs.Add(new PortableTypeConfiguration(typeof(DateTimeType)));
PortableConfiguration cfg = new PortableConfiguration {TypeConfigurations = typeCfgs};
PortableMarshaller marsh = new PortableMarshaller(cfg);
DateTime now = DateTime.Now;
DateTimeType obj = new DateTimeType(now);
DateTimeType otherObj = marsh.Unmarshal<DateTimeType>(marsh.Marshal(obj));
Assert.AreEqual(obj.Loc, otherObj.Loc);
Assert.AreEqual(obj.Utc, otherObj.Utc);
Assert.AreEqual(obj.LocNull, otherObj.LocNull);
Assert.AreEqual(obj.UtcNull, otherObj.UtcNull);
Assert.AreEqual(obj.LocArr, otherObj.LocArr);
Assert.AreEqual(obj.UtcArr, otherObj.UtcArr);
Assert.AreEqual(obj.LocRaw, otherObj.LocRaw);
Assert.AreEqual(obj.UtcRaw, otherObj.UtcRaw);
Assert.AreEqual(obj.LocNullRaw, otherObj.LocNullRaw);
Assert.AreEqual(obj.UtcNullRaw, otherObj.UtcNullRaw);
Assert.AreEqual(obj.LocArrRaw, otherObj.LocArrRaw);
Assert.AreEqual(obj.UtcArrRaw, otherObj.UtcArrRaw);
}
/// <summary>
/// Writes method invocation result.
/// </summary>
/// <param name="stream">Stream.</param>
/// <param name="marsh">Marshaller.</param>
/// <param name="methodResult">Method result.</param>
/// <param name="invocationError">Method invocation error.</param>
public static void WriteInvocationResult(IPortableStream stream, PortableMarshaller marsh, object methodResult,
Exception invocationError)
{
Debug.Assert(stream != null);
Debug.Assert(marsh != null);
var writer = marsh.StartMarshal(stream);
PortableUtils.WriteInvocationResult(writer, invocationError == null, invocationError ?? methodResult);
}
/// <summary>
/// Constructor.
/// </summary>
/// <param name="target">Target.</param>
/// <param name="marsh">Marshaler.</param>
/// <param name="keepPortable">Keep poratble flag.</param>
public QueryCursor(IUnmanagedTarget target, PortableMarshaller marsh,
bool keepPortable) : base(target, marsh, keepPortable)
{
// No-op.
}
/// <summary>
/// Constructor.
/// </summary>
/// <param name="target">Target.</param>
/// <param name="marsh">Marshaller.</param>
protected PlatformTarget(IUnmanagedTarget target, PortableMarshaller marsh)
{
_target = target;
_marsh = marsh;
}
/// <summary>
/// Reads method invocation result.
/// </summary>
/// <param name="stream">Stream.</param>
/// <param name="marsh">Marshaller.</param>
/// <param name="keepPortable">Portable flag.</param>
/// <returns>
/// Method invocation result, or exception in case of error.
/// </returns>
public static object ReadInvocationResult(IPortableStream stream, PortableMarshaller marsh, bool keepPortable)
{
Debug.Assert(stream != null);
Debug.Assert(marsh != null);
var mode = keepPortable ? PortableMode.ForcePortable : PortableMode.Deserialize;
var reader = marsh.StartUnmarshal(stream, mode);
object err;
var res = PortableUtils.ReadInvocationResult(reader, out err);
if (err == null)
return res;
var portErr = err as IPortableObject;
throw portErr != null
? new ServiceInvocationException("Proxy method invocation failed with a portable error. " +
"Examine PortableCause for details.", portErr)
: new ServiceInvocationException("Proxy method invocation failed with an exception. " +
"Examine InnerException for details.", (Exception) err);
}
/// <summary>
/// Initializes a new instance of the <see cref="ServicesAsync" /> class.
/// </summary>
/// <param name="target">Target.</param>
/// <param name="marsh">Marshaller.</param>
/// <param name="clusterGroup">Cluster group.</param>
/// <param name="keepPortable">Portable flag.</param>
/// <param name="srvKeepPortable">Server portable flag.</param>
public ServicesAsync(IUnmanagedTarget target, PortableMarshaller marsh, IClusterGroup clusterGroup,
bool keepPortable, bool srvKeepPortable)
: base(target, marsh, clusterGroup, keepPortable, srvKeepPortable)
{
// No-op
}
public void TestPrimitiveFieldsSerializer()
{
var typeCfgs = new List<PortableTypeConfiguration>
{
new PortableTypeConfiguration(typeof (PrimitiveFieldType))
{
Serializer = new PrimitiveFieldsSerializer()
}
};
PortableConfiguration cfg = new PortableConfiguration {TypeConfigurations = typeCfgs};
PortableMarshaller marsh = new PortableMarshaller(cfg);
PrimitiveFieldType obj = new PrimitiveFieldType();
CheckPrimitiveFields(marsh, obj);
}
public void TestProperty()
{
ICollection<PortableTypeConfiguration> typeCfgs =
new List<PortableTypeConfiguration>();
typeCfgs.Add(new PortableTypeConfiguration(typeof(PropertyType)));
PortableConfiguration cfg = new PortableConfiguration {TypeConfigurations = typeCfgs};
PortableMarshaller marsh = new PortableMarshaller(cfg);
PropertyType obj = new PropertyType
{
Field1 = 1,
Field2 = 2
};
byte[] data = marsh.Marshal(obj);
PropertyType newObj = marsh.Unmarshal<PropertyType>(data);
Assert.AreEqual(obj.Field1, newObj.Field1);
Assert.AreEqual(obj.Field2, newObj.Field2);
IPortableObject portNewObj = marsh.Unmarshal<IPortableObject>(data, PortableMode.ForcePortable);
Assert.AreEqual(obj.Field1, portNewObj.Field<int>("field1"));
Assert.AreEqual(obj.Field2, portNewObj.Field<int>("Field2"));
}
public void TestDecimalFields()
{
PortableConfiguration cfg = new PortableConfiguration
{
TypeConfigurations = new List<PortableTypeConfiguration>
{
new PortableTypeConfiguration(typeof (DecimalReflective)),
new PortableTypeConfiguration(typeof (DecimalMarshalAware))
}
};
PortableMarshaller marsh = new PortableMarshaller(cfg);
// 1. Test reflective stuff.
DecimalReflective obj1 = new DecimalReflective
{
Val = decimal.Zero,
ValArr = new[] {decimal.One, decimal.MinusOne}
};
IPortableObject portObj = marsh.Unmarshal<IPortableObject>(marsh.Marshal(obj1), PortableMode.ForcePortable);
Assert.AreEqual(obj1.Val, portObj.Field<decimal>("val"));
Assert.AreEqual(obj1.ValArr, portObj.Field<decimal[]>("valArr"));
Assert.AreEqual(obj1.Val, portObj.Deserialize<DecimalReflective>().Val);
Assert.AreEqual(obj1.ValArr, portObj.Deserialize<DecimalReflective>().ValArr);
// 2. Test marshal aware stuff.
DecimalMarshalAware obj2 = new DecimalMarshalAware();
obj2.Val = decimal.Zero;
obj2.ValArr = new[] { decimal.One, decimal.MinusOne };
obj2.RawVal = decimal.MaxValue;
obj2.RawValArr = new[] { decimal.MinusOne, decimal.One} ;
portObj = marsh.Unmarshal<IPortableObject>(marsh.Marshal(obj2), PortableMode.ForcePortable);
Assert.AreEqual(obj2.Val, portObj.Field<decimal>("val"));
Assert.AreEqual(obj2.ValArr, portObj.Field<decimal[]>("valArr"));
Assert.AreEqual(obj2.Val, portObj.Deserialize<DecimalMarshalAware>().Val);
Assert.AreEqual(obj2.ValArr, portObj.Deserialize<DecimalMarshalAware>().ValArr);
Assert.AreEqual(obj2.RawVal, portObj.Deserialize<DecimalMarshalAware>().RawVal);
Assert.AreEqual(obj2.RawValArr, portObj.Deserialize<DecimalMarshalAware>().RawValArr);
}
private static void CheckObject(PortableMarshaller marsh, OuterObjectType outObj, InnerObjectType inObj)
{
inObj.PInt1 = 1;
inObj.PInt2 = 2;
outObj.InObj = inObj;
byte[] bytes = marsh.Marshal(outObj);
IPortableObject portOutObj = marsh.Unmarshal<IPortableObject>(bytes, PortableMode.ForcePortable);
Assert.AreEqual(outObj.GetHashCode(), portOutObj.GetHashCode());
OuterObjectType newOutObj = portOutObj.Deserialize<OuterObjectType>();
Assert.AreEqual(outObj, newOutObj);
}
public void TestPrimitiveFieldsReflective()
{
ICollection<PortableTypeConfiguration> typeCfgs =
new List<PortableTypeConfiguration>();
typeCfgs.Add(new PortableTypeConfiguration(typeof(PrimitiveFieldType)));
PortableConfiguration cfg = new PortableConfiguration {TypeConfigurations = typeCfgs};
PortableMarshaller marsh = new PortableMarshaller(cfg);
PrimitiveFieldType obj = new PrimitiveFieldType();
CheckPrimitiveFields(marsh, obj);
}
