/** <inheritDoc /> */ internal override void Write(PortableWriterImpl writer, bool keepPortable) { writer.WriteBoolean(Local); writer.WriteInt(PageSize); writer.WriteBoolean(Partition.HasValue); if (Partition.HasValue) { writer.WriteInt(Partition.Value); } if (Filter == null) { writer.WriteObject <CacheEntryFilterHolder>(null); } else { var holder = new CacheEntryFilterHolder(Filter, (key, val) => Filter.Invoke( new CacheEntry <TK, TV>((TK)key, (TV)val)), writer.Marshaller, keepPortable); writer.WriteObject(holder); writer.WriteLong(holder.Handle); } }
/// <summary> /// Start execution. /// </summary> /// <param name="grid">Ignite instance.</param> /// <param name="writer">Writer.</param> /// <param name="cb">Callback invoked when all necessary data is written to stream.</param> /// <param name="qry">Query.</param> public void Start(Ignite grid, PortableWriterImpl writer, Func <IUnmanagedTarget> cb, ContinuousQuery <TK, TV> qry) { // 1. Inject resources. ResourceProcessor.Inject(_lsnr, grid); ResourceProcessor.Inject(_filter, grid); // 2. Allocate handle. _hnd = grid.HandleRegistry.Allocate(this); // 3. Write data to stream. writer.WriteLong(_hnd); writer.WriteBoolean(qry.Local); writer.WriteBoolean(_filter != null); ContinuousQueryFilterHolder filterHolder = _filter == null || qry.Local ? null : new ContinuousQueryFilterHolder(typeof(TK), typeof(TV), _filter, _keepPortable); writer.WriteObject(filterHolder); writer.WriteInt(qry.BufferSize); writer.WriteLong((long)qry.TimeInterval.TotalMilliseconds); writer.WriteBoolean(qry.AutoUnsubscribe); // 4. Call Java. _nativeQry = cb(); // 5. Initial query. var nativeInitialQryCur = UU.ContinuousQueryGetInitialQueryCursor(_nativeQry); _initialQueryCursor = nativeInitialQryCur == null ? null : new QueryCursor <TK, TV>(nativeInitialQryCur, _marsh, _keepPortable); }
/// <summary> /// Writes objects to the marshaller. /// </summary> /// <param name="cb">Optional callback.</param> /// <param name="grid">Grid.</param> /// <param name="objects">Objects.</param> private static void WriteObjects(IUnmanagedTarget cb, Ignite grid, params object[] objects) { using (var stream = IgniteManager.Memory.Allocate().Stream()) { PortableWriterImpl writer = grid.Marshaller.StartMarshal(stream); try { foreach (var obj in objects) { writer.DetachNext(); writer.WriteObject(obj); } } finally { grid.Marshaller.FinishMarshal(writer); } if (cb != null) { stream.SynchronizeOutput(); UnmanagedUtils.CacheStoreCallbackInvoke(cb, stream.MemoryPointer); } } }
/// <summary> /// Writes the job. /// </summary> /// <param name="job">The job.</param> /// <param name="writer">The writer.</param> /// <returns>Handle to the job holder</returns> private long WriteJob(IComputeJob job, PortableWriterImpl writer) { var jobHolder = new ComputeJobHolder((Ignite)_prj.Ignite, job); var jobHandle = Marshaller.Ignite.HandleRegistry.Allocate(jobHolder); writer.WriteLong(jobHandle); writer.WriteObject(jobHolder); return(jobHandle); }
/// <summary> /// Perform simple out-in operation accepting two arguments. /// </summary> /// <param name="type">Operation type.</param> /// <param name="val1">Value.</param> /// <param name="val2">Value.</param> /// <returns>Result.</returns> protected TR DoOutInOp <T1, T2, TR>(int type, T1 val1, T2 val2) { using (PlatformMemoryStream outStream = IgniteManager.Memory.Allocate().Stream()) { using (PlatformMemoryStream inStream = IgniteManager.Memory.Allocate().Stream()) { PortableWriterImpl writer = _marsh.StartMarshal(outStream); writer.WriteObject(val1); writer.WriteObject(val2); FinishMarshal(writer); UU.TargetInStreamOutStream(_target, type, outStream.SynchronizeOutput(), inStream.MemoryPointer); inStream.SynchronizeInput(); return(Unmarshal <TR>(inStream)); } } }
/// <summary> /// Write query arguments. /// </summary> /// <param name="writer">Writer.</param> /// <param name="args">Arguments.</param> internal static void WriteQueryArgs(PortableWriterImpl writer, object[] args) { if (args == null) writer.WriteInt(0); else { writer.WriteInt(args.Length); foreach (var arg in args) writer.WriteObject(arg); } }
/// <summary> /// Write query arguments. /// </summary> /// <param name="writer">Writer.</param> /// <param name="args">Arguments.</param> private static void WriteQueryArgs(PortableWriterImpl writer, object[] args) { if (args == null) { writer.WriteInt(0); } else { writer.WriteInt(args.Length); foreach (var arg in args) { writer.WriteObject(arg); } } }
/// <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); } }
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); } }
/// <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); }