/** <inheritDoc /> */
public Task <ICollection <ICacheEntry <TK, TV> > > GetAllAsync(IEnumerable <TK> keys)
{
IgniteArgumentCheck.NotNull(keys, "keys");
return(DoOutOpAsync(CacheOp.GetAllAsync, w => w.WriteEnumerable(keys), r => ReadGetAllDictionary(r)));
}
/// <summary>
/// Deserializes IgniteConfiguration from the XML reader.
/// </summary>
/// <param name="reader">The reader.</param>
/// <returns>Deserialized instance.</returns>
public static IgniteConfiguration FromXml(XmlReader reader)
{
IgniteArgumentCheck.NotNull(reader, "reader");
return(IgniteConfigurationXmlSerializer.Deserialize(reader));
}
/// <summary>
/// Starts Ignite with given configuration.
/// </summary>
/// <returns>Started Ignite.</returns>
public static IIgnite Start(IgniteConfiguration cfg)
{
IgniteArgumentCheck.NotNull(cfg, "cfg");
cfg = new IgniteConfiguration(cfg); // Create a copy so that config can be modified and reused.
lock (SyncRoot)
{
// 0. Init logger
var log = cfg.Logger ?? new JavaLogger();
log.Debug("Starting Ignite.NET " + Assembly.GetExecutingAssembly().GetName().Version);
// 1. Check GC settings.
CheckServerGc(cfg, log);
// 2. Create context.
JvmDll.Load(cfg.JvmDllPath, log);
var cbs = IgniteManager.CreateJvmContext(cfg, log);
var env = cbs.Jvm.AttachCurrentThread();
log.Debug("JVM started.");
var gridName = cfg.IgniteInstanceName;
if (cfg.AutoGenerateIgniteInstanceName)
{
gridName = (gridName ?? "ignite-instance-") + Guid.NewGuid();
}
// 3. Create startup object which will guide us through the rest of the process.
_startup = new Startup(cfg, cbs);
PlatformJniTarget interopProc = null;
try
{
// 4. Initiate Ignite start.
UU.IgnitionStart(env, cfg.SpringConfigUrl, gridName, ClientMode, cfg.Logger != null, cbs.IgniteId,
cfg.RedirectJavaConsoleOutput);
// 5. At this point start routine is finished. We expect STARTUP object to have all necessary data.
var node = _startup.Ignite;
interopProc = (PlatformJniTarget)node.InteropProcessor;
var javaLogger = log as JavaLogger;
if (javaLogger != null)
{
javaLogger.SetIgnite(node);
}
// 6. On-start callback (notify lifecycle components).
node.OnStart();
Nodes[new NodeKey(_startup.Name)] = node;
return(node);
}
catch (Exception ex)
{
// 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(gridName, true);
}
// 3. Throw error further (use startup error if exists because it is more precise).
if (_startup.Error != null)
{
// Wrap in a new exception to preserve original stack trace.
throw new IgniteException("Failed to start Ignite.NET, check inner exception for details",
_startup.Error);
}
var jex = ex as JavaException;
if (jex == null)
{
throw;
}
throw ExceptionUtils.GetException(null, jex);
}
finally
{
var ignite = _startup.Ignite;
_startup = null;
if (ignite != null)
{
ignite.ProcessorReleaseStart();
}
}
}
}
/** <inheritdoc /> */
public T GetPlugin <T>(string name) where T : class
{
IgniteArgumentCheck.NotNullOrEmpty(name, "name");
return(PluginProcessor.GetProvider(name).GetPlugin <T>());
}
/// <summary>
/// Initializes a new instance of the <see cref="Endpoint"/> class.
/// </summary>
private Endpoint(string host, int port = IgniteClientConfiguration.DefaultPort, int portRange = 0)
{
Host = IgniteArgumentCheck.NotNullOrEmpty(host, "host");
Port = port;
PortRange = portRange;
}
/** <inheritdoc /> */
public IClusterGroup ForHost(IClusterNode node)
{
IgniteArgumentCheck.NotNull(node, "node");
return(_prj.ForHost(node));
}
/** <inheritdoc /> */
public void DestroyCache(string name)
{
IgniteArgumentCheck.NotNull(name, "name");
UU.ProcessorDestroyCache(_proc, name);
}
/** <inheritdoc /> */
public ICache <TK, TV> GetOrCreateCache <TK, TV>(string name)
{
IgniteArgumentCheck.NotNull(name, "name");
return(GetCache <TK, TV>(DoOutOpObject((int)Op.GetOrCreateCache, w => w.WriteString(name))));
}
/** <inheritdoc /> */
public void DestroyCache(string name)
{
IgniteArgumentCheck.NotNull(name, "name");
DoOutOp((int)Op.DestroyCache, w => w.WriteString(name));
}
/** <inheritdoc /> */
public void LocalClearAll(IEnumerable <TK> keys)
{
IgniteArgumentCheck.NotNull(keys, "keys");
DoOutOp(CacheOp.LocalClearAll, writer => writer.WriteEnumerable(keys));
}
/// <summary>
/// Initializes a new instance of the <see cref="IgniteLog4NetLogger"/> class.
/// </summary>
/// <param name="log">The log.</param>
public IgniteLog4NetLogger(ILog log)
{
IgniteArgumentCheck.NotNull(log, "log");
_log = log;
}
/** <inheritdoc /> */
public void LocalClear(TK key)
{
IgniteArgumentCheck.NotNull(key, "key");
DoOutOp(CacheOp.LocalClear, key);
}
/** <inheritDoc /> */
public Task ClearAllAsync(IEnumerable <TK> keys)
{
IgniteArgumentCheck.NotNull(keys, "keys");
return(DoOutOpAsync(CacheOp.ClearAllAsync, writer => writer.WriteEnumerable(keys)));
}
/** <inheritDoc /> */
public Task ClearAsync(TK key)
{
IgniteArgumentCheck.NotNull(key, "key");
return(DoOutOpAsync(CacheOp.ClearAsync, key));
}
/// <summary>
/// Gets the <see cref="CategoryLogger"/> with a specified category that wraps provided logger.
/// </summary>
/// <param name="logger">The logger.</param>
/// <param name="category">The category.</param>
/// <returns>Logger that uses specified category when no other category is provided.</returns>
public static ILogger GetLogger(this ILogger logger, string category)
{
IgniteArgumentCheck.NotNull(logger, "logger");
return(new CategoryLogger(logger, category));
}
/** <inheritdoc /> */
public IDataStreamer <TK, TV> GetDataStreamer <TK, TV>(string cacheName)
{
IgniteArgumentCheck.NotNull(cacheName, "cacheName");
return(GetDataStreamer <TK, TV>(cacheName, false));
}
/** <inheritdoc /> */
public IClusterGroup ForPredicate(Func <IClusterNode, bool> p)
{
IgniteArgumentCheck.NotNull(p, "p");
return(_prj.ForPredicate(p));
}
/** <inheritdoc /> */
public IMemoryMetrics GetMemoryMetrics(string memoryPolicyName)
{
IgniteArgumentCheck.NotNullOrEmpty(memoryPolicyName, "memoryPolicyName");
return(_prj.GetMemoryMetrics(memoryPolicyName));
}
/** <inheritdoc /> */
public ICache <TK, TV> CreateCache <TK, TV>(string name)
{
IgniteArgumentCheck.NotNull(name, "name");
return(Cache <TK, TV>(UU.ProcessorCreateCache(_proc, name)));
}
/** <inheritdoc /> */
public void EnableWal(string cacheName)
{
IgniteArgumentCheck.NotNull(cacheName, "cacheName");
DoOutOp((int)Op.EnableWal, w => w.WriteString(cacheName));
}
/** <inheritdoc /> */
public ICacheAffinity GetAffinity(string cacheName)
{
IgniteArgumentCheck.NotNull(cacheName, "cacheName");
return(new CacheAffinityImpl(UU.ProcessorAffinity(_proc, cacheName), _marsh, false, this));
}
/** <inheritdoc /> */
public bool IsWalEnabled(string cacheName)
{
IgniteArgumentCheck.NotNull(cacheName, "cacheName");
return(DoOutOp((int)Op.IsWalEnabled, w => w.WriteString(cacheName)) == True);
}
/** <inheritdoc /> */
public void ResetLostPartitions(IEnumerable <string> cacheNames)
{
IgniteArgumentCheck.NotNull(cacheNames, "cacheNames");
_prj.ResetLostPartitions(cacheNames);
}
/** <inheritDoc /> */
public IClientClusterGroup ForAttribute(string name, string val)
{
IgniteArgumentCheck.NotNullOrEmpty(name, "name");
return(new ClientClusterGroup(_ignite, _marsh, _projection.ForAttribute(name, val)));
}
/** <inheritDoc /> */
public void Cancel(string name)
{
IgniteArgumentCheck.NotNullOrEmpty(name, "name");
UU.ServicesCancel(Target, name);
}
/// <summary>
/// Logs the message.
/// </summary>
/// <param name="logger">The logger.</param>
/// <param name="level">The level.</param>
/// <param name="ex">The exception.</param>
/// <param name="message">The message.</param>
public static void Log(this ILogger logger, LogLevel level, Exception ex, string message)
{
IgniteArgumentCheck.NotNull(logger, "logger");
logger.Log(level, message, null, null, null, null, ex);
}
/** <inheritdoc /> */
public void Send(object message, object topic = null)
{
IgniteArgumentCheck.NotNull(message, "message");
DoOutOp((int)Op.Send, topic, message);
}
/// <summary>
/// Logs the message.
/// </summary>
/// <param name="logger">The logger.</param>
/// <param name="level">The level.</param>
/// <param name="ex">The exception.</param>
/// <param name="message">The message.</param>
/// <param name="args">The arguments.</param>
public static void Log(this ILogger logger, LogLevel level, Exception ex, string message, params object[] args)
{
IgniteArgumentCheck.NotNull(logger, "logger");
logger.Log(level, message, args, CultureInfo.InvariantCulture, null, null, ex);
}
/** <inheritDoc /> */
public TV Get(TK key)
{
IgniteArgumentCheck.NotNull(key, "key");
return(DoOutInOpAffinity(ClientOp.CacheGet, key, UnmarshalNotNull <TV>));
}
/** <inheritDoc /> */
public Task <CacheResult <TV> > TryGetAsync(TK key)
{
IgniteArgumentCheck.NotNull(key, "key");
return(DoOutOpAsync(CacheOp.GetAsync, w => w.WriteObject(key), reader => GetCacheResult(reader)));
}
