/// <summary> /// Initializes a new instance of the <see cref="Apache.Ignite.Core.Impl.DataStructures.AtomicLong"/> class. /// </summary> /// <param name="target">The target.</param> /// <param name="marsh">The marshaller.</param> /// <param name="name">The name.</param> public AtomicSequence(IUnmanagedTarget target, Marshaller marsh, string name) : base(target, marsh) { Debug.Assert(!string.IsNullOrEmpty(name)); _name = name; }
/// <summary> /// Initializes a new instance of the <see cref="CacheLock"/> class. /// </summary> /// <param name="id">Lock id.</param> /// <param name="cache">Cache.</param> public CacheLock(long id, IUnmanagedTarget cache) { Debug.Assert(cache != null); _id = id; _cache = cache; }
/// <summary> /// Sets the processor. /// </summary> /// <param name="proc">The proc.</param> public void SetProcessor(IUnmanagedTarget proc) { Debug.Assert(proc != null); lock (_syncRoot) { _proc = proc; // Preload enabled levels. _enabledLevels.AddRange( new[] { LogLevel.Trace, LogLevel.Debug, LogLevel.Info, LogLevel.Warn, LogLevel.Error } .Where(x => UnmanagedUtils.ProcessorLoggerIsLevelEnabled(proc, (int)x))); foreach (var log in _pendingLogs) { Log(log.Item1, log.Item2, log.Item3, log.Item4); } } }
/// <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, Marshaller 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).GetRawReader(); concurrency = (TransactionConcurrency) reader.ReadInt(); isolation = (TransactionIsolation) reader.ReadInt(); timeout = TimeSpan.FromMilliseconds(reader.ReadLong()); }); _dfltConcurrency = concurrency; _dfltIsolation = isolation; _dfltTimeout = timeout; }
internal static IUnmanagedTarget ProjectionForOthers(IUnmanagedTarget target, IUnmanagedTarget prj) { void *res = JNI.ProjectionForOthers(target.Context, target.Target, prj.Target); return(target.ChangeTarget(res)); }
internal static int DataStreamerPerNodeParallelOperationsGet(IUnmanagedTarget target) { return(JNI.DataStreamerPerNodeParallelOpsGet(target.Context, target.Target)); }
internal static long AtomicLongCompareAndSetAndGet(IUnmanagedTarget target, long expVal, long newVal) { return JNI.AtomicLongCompareAndSetAndGet(target.Context, target.Target, expVal, newVal); }
internal static void EventsLocalListen(IUnmanagedTarget target, long handle, int type) { JNI.EventsLocalListen(target.Context, target.Target, handle, type); }
internal static void ServicesCancelAll(IUnmanagedTarget target) { JNI.ServicesCancelAll(target.Context, target.Target); }
internal static long TransactionsStart(IUnmanagedTarget target, int concurrency, int isolation, long timeout, int txSize) { return(JNI.TxStart(target.Context, target.Target, concurrency, isolation, timeout, txSize)); }
internal static void TransactionsResetMetrics(IUnmanagedTarget target) { JNI.TxResetMetrics(target.Context, target.Target); }
internal static void QueryCursorIterator(IUnmanagedTarget target) { JNI.QryCursorIterator(target.Context, target.Target); }
internal static void QueryCursorClose(IUnmanagedTarget target) { JNI.QryCursorClose(target.Context, target.Target); }
internal static IUnmanagedTarget ProjectionOutOpRet(IUnmanagedTarget target, int type, long memPtr) { void *res = JNI.ProjectionOutOpRet(target.Context, target.Target, type, memPtr); return(target.ChangeTarget(res)); }
internal static void ProjectionResetMetrics(IUnmanagedTarget target) { JNI.ProjectionResetMetrics(target.Context, target.Target); }
internal static IUnmanagedTarget ProjectionForYoungest(IUnmanagedTarget target) { void *res = JNI.ProjectionForYoungest(target.Context, target.Target); return(target.ChangeTarget(res)); }
internal static int TransactionsRollback(IUnmanagedTarget target, long id) { return JNI.TxRollback(target.Context, target.Target, id); }
internal static int TransactionsRollback(IUnmanagedTarget target, long id) { return(JNI.TxRollback(target.Context, target.Target, id)); }
internal static int TransactionsState(IUnmanagedTarget target, long id) { return JNI.TxState(target.Context, target.Target, id); }
internal static void TransactionsRollbackAsync(IUnmanagedTarget target, long id, long futId) { JNI.TxRollbackAsync(target.Context, target.Target, id, futId); }
internal static bool EventsStopLocalListen(IUnmanagedTarget target, long handle) { return JNI.EventsStopLocalListen(target.Context, target.Target, handle); }
internal static int TransactionsState(IUnmanagedTarget target, long id) { return(JNI.TxState(target.Context, target.Target, id)); }
internal static IUnmanagedTarget ServicesWithServerKeepBinary(IUnmanagedTarget target) { return target.ChangeTarget(JNI.ServicesWithServerKeepBinary(target.Context, target.Target)); }
internal static bool TransactionsSetRollbackOnly(IUnmanagedTarget target, long id) { return(JNI.TxSetRollbackOnly(target.Context, target.Target, id)); }
internal static long AtomicLongDecrementAndGet(IUnmanagedTarget target) { return JNI.AtomicLongDecrementAndGet(target.Context, target.Target); }
internal static void AtomicLongClose(IUnmanagedTarget target) { JNI.AtomicLongClose(target.Context, target.Target); }
internal static void DataStreamerPerNodeParallelOperationsSet(IUnmanagedTarget target, int val) { JNI.DataStreamerPerNodeParallelOpsSet(target.Context, target.Target, val); }
/// <summary> /// Invokes a store operation. /// </summary> /// <param name="input">Input stream.</param> /// <param name="cb">Callback.</param> /// <param name="grid">Grid.</param> /// <returns>Invocation result.</returns> /// <exception cref="IgniteException">Invalid operation type: + opType</exception> public int Invoke(IBinaryStream input, IUnmanagedTarget cb, Ignite grid) { IBinaryReader reader = grid.Marshaller.StartUnmarshal(input, _convertBinary ? BinaryMode.Deserialize : BinaryMode.ForceBinary); IBinaryRawReader rawReader = reader.GetRawReader(); int opType = rawReader.ReadByte(); // Setup cache sessoin for this invocation. long sesId = rawReader.ReadLong(); CacheStoreSession ses = grid.HandleRegistry.Get<CacheStoreSession>(sesId, true); ses.CacheName = rawReader.ReadString(); _sesProxy.SetSession(ses); try { // Perform operation. switch (opType) { case OpLoadCache: _store.LoadCache((k, v) => WriteObjects(cb, grid, k, v), rawReader.ReadArray<object>()); break; case OpLoad: object val = _store.Load(rawReader.ReadObject<object>()); if (val != null) WriteObjects(cb, grid, val); break; case OpLoadAll: var keys = rawReader.ReadCollection(); var result = _store.LoadAll(keys); foreach (DictionaryEntry entry in result) WriteObjects(cb, grid, entry.Key, entry.Value); break; case OpPut: _store.Write(rawReader.ReadObject<object>(), rawReader.ReadObject<object>()); break; case OpPutAll: _store.WriteAll(rawReader.ReadDictionary()); break; case OpRmv: _store.Delete(rawReader.ReadObject<object>()); break; case OpRmvAll: _store.DeleteAll(rawReader.ReadCollection()); break; case OpSesEnd: grid.HandleRegistry.Release(sesId); _store.SessionEnd(rawReader.ReadBoolean()); break; default: throw new IgniteException("Invalid operation type: " + opType); } return 0; } finally { _sesProxy.ClearSession(); } }
internal static void Release(IUnmanagedTarget target) { JNI.Release(target.Target); }
internal static IUnmanagedTarget MessagingWithASync(IUnmanagedTarget target) { void *res = JNI.MessagingWithAsync(target.Context, target.Target); return(target.ChangeTarget(res)); }
internal static bool EventsStopLocalListen(IUnmanagedTarget target, long handle) { return(JNI.EventsStopLocalListen(target.Context, target.Target, handle)); }
internal static long TransactionsStart(IUnmanagedTarget target, int concurrency, int isolation, long timeout, int txSize) { return JNI.TxStart(target.Context, target.Target, concurrency, isolation, timeout, txSize); }
internal static bool EventsIsEnabled(IUnmanagedTarget target, int type) { return(JNI.EventsIsEnabled(target.Context, target.Target, type)); }
internal static bool TransactionsSetRollbackOnly(IUnmanagedTarget target, long id) { return JNI.TxSetRollbackOnly(target.Context, target.Target, id); }
internal static IUnmanagedTarget ServicesWithAsync(IUnmanagedTarget target) { return(target.ChangeTarget(JNI.ServicesWithAsync(target.Context, target.Target))); }
internal static IUnmanagedTarget ServicesWithServerKeepBinary(IUnmanagedTarget target) { return(target.ChangeTarget(JNI.ServicesWithServerKeepBinary(target.Context, target.Target))); }
internal static bool EventsIsEnabled(IUnmanagedTarget target, int type) { return JNI.EventsIsEnabled(target.Context, target.Target, type); }
internal static IUnmanagedTarget ServicesWithAsync(IUnmanagedTarget target) { return target.ChangeTarget(JNI.ServicesWithAsync(target.Context, target.Target)); }
internal static long AtomicLongDecrementAndGet(IUnmanagedTarget target) { return(JNI.AtomicLongDecrementAndGet(target.Context, target.Target)); }
internal static void ServicesCancel(IUnmanagedTarget target, string name) { var nameChars = (char*)IgniteUtils.StringToUtf8Unmanaged(name); try { JNI.ServicesCancel(target.Context, target.Target, nameChars); } finally { Marshal.FreeHGlobal(new IntPtr(nameChars)); } }
internal static long AtomicLongGetAndSet(IUnmanagedTarget target, long value) { return(JNI.AtomicLongGetAndSet(target.Context, target.Target, value)); }
internal static IUnmanagedTarget ServicesGetServiceProxy(IUnmanagedTarget target, string name, bool sticky) { var nameChars = (char*)IgniteUtils.StringToUtf8Unmanaged(name); try { return target.ChangeTarget(JNI.ServicesGetServiceProxy(target.Context, target.Target, nameChars, sticky)); } finally { Marshal.FreeHGlobal(new IntPtr(nameChars)); } }
internal static long AtomicLongCompareAndSetAndGet(IUnmanagedTarget target, long expVal, long newVal) { return(JNI.AtomicLongCompareAndSetAndGet(target.Context, target.Target, expVal, newVal)); }
internal static long AtomicLongGetAndSet(IUnmanagedTarget target, long value) { return JNI.AtomicLongGetAndSet(target.Context, target.Target, value); }
internal static bool AtomicLongIsClosed(IUnmanagedTarget target) { return(JNI.AtomicLongIsClosed(target.Context, target.Target)); }
internal static bool AtomicLongIsClosed(IUnmanagedTarget target) { return JNI.AtomicLongIsClosed(target.Context, target.Target); }
/// <summary> /// Initializes a new instance of the <see cref="Listenable"/> class. /// </summary> /// <param name="target">Target.</param> /// <param name="marsh">Marshaller.</param> public Listenable(IUnmanagedTarget target, Marshaller marsh) : base(target, marsh) { // No-op. }
/// <summary> /// Starts Ignite with given configuration. /// </summary> /// <returns>Started Ignite.</returns> public static unsafe IIgnite Start(IgniteConfiguration cfg) { IgniteArgumentCheck.NotNull(cfg, "cfg"); lock (SyncRoot) { // 1. Check GC settings. CheckServerGc(cfg); // 2. Create context. IgniteUtils.LoadDlls(cfg.JvmDllPath); var cbs = new UnmanagedCallbacks(); IgniteManager.CreateJvmContext(cfg, cbs); var gridName = cfg.GridName; // 3. Create startup object which will guide us through the rest of the process. _startup = new Startup(cfg, cbs); IUnmanagedTarget interopProc = null; try { // 4. Initiate Ignite start. UU.IgnitionStart(cbs.Context, cfg.SpringConfigUrl, gridName, ClientMode); // 5. At this point start routine is finished. We expect STARTUP object to have all necessary data. var node = _startup.Ignite; interopProc = node.InteropProcessor; // 6. On-start callback (notify lifecycle components). node.OnStart(); Nodes[new NodeKey(_startup.Name)] = node; return(node); } catch (Exception) { // 1. Perform keys cleanup. string name = _startup.Name; if (name != null) { NodeKey key = new NodeKey(name); if (Nodes.ContainsKey(key)) { Nodes.Remove(key); } } // 2. Stop Ignite node if it was started. if (interopProc != null) { UU.IgnitionStop(interopProc.Context, gridName, true); } // 3. Throw error further (use startup error if exists because it is more precise). if (_startup.Error != null) { throw _startup.Error; } throw; } finally { _startup = null; if (interopProc != null) { UU.ProcessorReleaseStart(interopProc); } } } }
/// <summary> /// Kernal start callback. /// </summary> /// <param name="interopProc">Interop processor.</param> /// <param name="stream">Stream.</param> internal static void OnStart(IUnmanagedTarget interopProc, IBinaryStream stream) { try { // 1. Read data and leave critical state ASAP. BinaryReader reader = BinaryUtils.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> /// Gets cache from specified native cache object. /// </summary> /// <param name="nativeCache">Native cache.</param> /// <param name="keepBinary">Keep binary flag.</param> /// <returns> /// New instance of cache wrapping specified native cache. /// </returns> public ICache <TK, TV> Cache <TK, TV>(IUnmanagedTarget nativeCache, bool keepBinary = false) { return(new CacheImpl <TK, TV>(this, nativeCache, _marsh, false, keepBinary, false, false)); }
/// <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().GetStream()) { BinaryWriter writer = grid.Marshaller.StartMarshal(stream); try { foreach (var obj in objects) { var obj0 = obj; writer.WithDetach(w => w.WriteObject(obj0)); } } finally { grid.Marshaller.FinishMarshal(writer); } if (cb != null) { stream.SynchronizeOutput(); UnmanagedUtils.CacheStoreCallbackInvoke(cb, stream.MemoryPointer); } } }
internal static void DataStreamerPerNodeBufferSizeSet(IUnmanagedTarget target, int val) { JNI.DataStreamerPerNodeBufferSizeSet(target.Context, target.Target, val); }