/// <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 TransactionsResetMetrics(IUnmanagedTarget target)
{
JNI.TxResetMetrics(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 QueryCursorClose(IUnmanagedTarget target)
{
JNI.QryCursorClose(target.Context, target.Target);
}
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 void QueryCursorIterator(IUnmanagedTarget target)
{
JNI.QryCursorIterator(target.Context, target.Target);
}
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 void TransactionsRollbackAsync(IUnmanagedTarget target, long id, long futId)
{
JNI.TxRollbackAsync(target.Context, target.Target, id, futId);
}
internal static void EventsLocalListen(IUnmanagedTarget target, long handle, int type)
{
JNI.EventsLocalListen(target.Context, target.Target, handle, 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 void Release(IUnmanagedTarget target)
{
JNI.Release(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 void ServicesCancelAll(IUnmanagedTarget target)
{
JNI.ServicesCancelAll(target.Context, target.Target);
}
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);
}
internal static void AtomicLongClose(IUnmanagedTarget target)
{
JNI.AtomicLongClose(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);
}
