/// <summary>
/// Initializes a new instance of the <see cref="PlatformCacheManager"/> class.
/// </summary>
/// <param name="ignite">Ignite.</param>
public PlatformCacheManager(IIgniteInternal ignite)
{
Debug.Assert(ignite != null);
_ignite = ignite;
_ignite.GetIgnite().ClientDisconnected += OnClientDisconnected;
}
/// <summary>
/// Reads the schema, maintains stream position.
/// </summary>
public static int[] GetFieldIds(BinaryObjectHeader hdr, IIgniteInternal ignite, IBinaryStream stream,
int objectPos)
{
Debug.Assert(stream != null);
if (hdr.IsCompactFooter)
{
// Get schema from Java
return(GetFieldIds(hdr, ignite));
}
var pos = stream.Position;
stream.Seek(objectPos + hdr.SchemaOffset, SeekOrigin.Begin);
var count = hdr.SchemaFieldCount;
var offsetSize = hdr.SchemaFieldOffsetSize;
var res = new int[count];
for (var i = 0; i < count; i++)
{
res[i] = stream.ReadInt();
stream.Seek(offsetSize, SeekOrigin.Current); // Skip offsets.
}
stream.Seek(pos, SeekOrigin.Begin);
return(res);
}
/// <summary>
/// Constructor.
/// </summary>
/// <param name="grid">Grid.</param>
/// <param name="job">Job.</param>
public ComputeJobHolder(IIgniteInternal grid, IComputeJob job)
{
Debug.Assert(grid != null);
Debug.Assert(job != null);
_ignite = grid;
_job = job;
}
/// <summary>
/// Default ctor for marshalling.
/// </summary>
/// <param name="reader"></param>
public ComputeJobHolder(BinaryReader reader)
{
Debug.Assert(reader != null);
_ignite = reader.Marshaller.Ignite;
_job = reader.ReadObject <IComputeJob>();
}
/// <summary>
/// Creates exception according to native code class and message.
/// </summary>
/// <param name="igniteInt">The ignite.</param>
/// <param name="clsName">Exception class name.</param>
/// <param name="msg">Exception message.</param>
/// <param name="stackTrace">Native stack trace.</param>
/// <param name="reader">Error data reader.</param>
/// <param name="innerException">Inner exception.</param>
/// <returns>Exception.</returns>
public static Exception GetException(IIgniteInternal igniteInt, string clsName, string msg, string stackTrace,
BinaryReader reader = null, Exception innerException = null)
{
// Set JavaException as immediate inner.
var jex = new JavaException(clsName, msg, stackTrace, innerException);
return(GetException(igniteInt, jex, reader));
}
/// <summary>
/// Creates exception according to native code class and message.
/// </summary>
/// <param name="igniteInt">The ignite.</param>
/// <param name="innerException">Java exception.</param>
/// <param name="reader">Error data reader.</param>
/// <returns>Exception.</returns>
public static Exception GetException(IIgniteInternal igniteInt, JavaException innerException,
BinaryReader reader = null)
{
var ignite = igniteInt == null ? null : igniteInt.GetIgnite();
var msg = innerException.JavaMessage;
var clsName = innerException.JavaClassName;
ExceptionFactory ctor;
if (Exs.TryGetValue(clsName, out ctor))
{
var match = InnerClassRegex.Match(msg ?? string.Empty);
ExceptionFactory innerCtor;
if (match.Success && Exs.TryGetValue(match.Groups[1].Value, out innerCtor))
{
return(ctor(clsName, msg,
innerCtor(match.Groups[1].Value, match.Groups[2].Value, innerException, ignite),
ignite));
}
return(ctor(clsName, msg, innerException, ignite));
}
if (ClsNoClsDefFoundErr.Equals(clsName, StringComparison.OrdinalIgnoreCase))
{
return(new IgniteException("Java class is not found (did you set IGNITE_HOME environment " +
"variable?): " + msg, innerException));
}
if (ClsNoSuchMthdErr.Equals(clsName, StringComparison.OrdinalIgnoreCase))
{
return(new IgniteException("Java class method is not found (did you set IGNITE_HOME environment " +
"variable?): " + msg, innerException));
}
if (ClsCachePartialUpdateErr.Equals(clsName, StringComparison.OrdinalIgnoreCase))
{
return(ProcessCachePartialUpdateException(igniteInt, msg, innerException.Message, reader));
}
// Predefined mapping not found - check plugins.
if (igniteInt != null && igniteInt.PluginProcessor != null)
{
ctor = igniteInt.PluginProcessor.GetExceptionMapping(clsName);
if (ctor != null)
{
return(ctor(clsName, msg, innerException, ignite));
}
}
// Return default exception.
return(new IgniteException(string.Format("Java exception occurred [class={0}, message={1}]", clsName, msg),
innerException));
}
/// <summary>
/// Gets an instance of <see cref="PeerAssemblyResolver"/> when peer loading is enabled; otherwise null.
/// </summary>
public static PeerAssemblyResolver GetInstance(IIgniteInternal ignite, Guid originNodeId)
{
if (ignite == null || ignite.Configuration.PeerAssemblyLoadingMode == PeerAssemblyLoadingMode.Disabled)
{
return(null);
}
return(new PeerAssemblyResolver(ignite, originNodeId));
}
/// <summary>
/// Inject resources to the given target.
/// </summary>
/// <param name="target">Target object.</param>
/// <param name="grid">Grid.</param>
public static void Inject(object target, IIgniteInternal grid)
{
if (target != null)
{
var desc = Descriptor(target.GetType());
desc.InjectIgnite(target, grid);
}
}
/// <summary>
/// Initializes a new instance of the <see cref="MessageListenerHolder"/> class.
/// </summary>
/// <param name="reader">The reader.</param>
public MessageListenerHolder(BinaryReader reader)
{
_filter = reader.ReadObject <object>();
_invoker = GetInvoker(_filter);
_ignite = reader.Marshaller.Ignite;
ResourceProcessor.Inject(_filter, _ignite);
}
/// <summary>
/// Initializes a new instance of the <see cref="PeerAssemblyResolver"/> class.
/// </summary>
public PeerAssemblyResolver(IIgniteInternal ignite, Guid originNodeId)
{
Debug.Assert(ignite != null);
_handler = (sender, args) => GetAssembly(ignite, args.Name, originNodeId);
// AssemblyResolve handler is called only when aseembly can't be found via normal lookup,
// so we won't end up loading assemblies that are already present.
AppDomain.CurrentDomain.AssemblyResolve += _handler;
}
/// <summary>
/// Loads the assembly.
/// </summary>
private static Assembly LoadAssembly(IIgniteInternal ignite, string assemblyName, Guid originNodeId)
{
var res = RequestAssembly(assemblyName, ignite, originNodeId);
if (res == null)
{
return(null);
}
return(AssemblyLoader.LoadAssembly(res.AssemblyBytes, assemblyName));
}
/// <summary>
/// Gets the cached schema.
/// </summary>
private static int[] GetCachedSchema(BinaryObjectHeader hdr, IIgniteInternal ignite)
{
var cachedHolder = ignite.Marshaller.GetCachedBinaryTypeHolder(hdr.TypeId);
if (cachedHolder == null || cachedHolder.BinaryType == null || cachedHolder.BinaryType.Schema == null)
{
return(null);
}
return(cachedHolder.BinaryType.Schema.Get(hdr.SchemaId));
}
public ClusterGroupImpl(IPlatformTargetInternal target, Func <IClusterNode, bool> pred)
: base(target)
{
_ignite = target.Marshaller.Ignite;
_pred = pred;
_comp = new Lazy <ICompute>(() => CreateCompute());
_msg = new Lazy <IMessaging>(() => CreateMessaging());
_events = new Lazy <IEvents>(() => CreateEvents());
_services = new Lazy <IServices>(() => CreateServices());
}
/// <summary>
/// Performs compute-specific resource injection.
/// </summary>
public static void InjectResources(IIgniteInternal ignite, object job)
{
var injector = job as IComputeResourceInjector;
if (injector != null)
{
injector.Inject(ignite);
}
else
{
ResourceProcessor.Inject(job, ignite);
}
}
/// <summary>
/// Constructor.
/// </summary>
/// <param name="target">Target.</param>
/// <param name="flagSkipStore">Skip store flag.</param>
/// <param name="flagKeepBinary">Keep binary flag.</param>
/// <param name="flagNoRetries">No-retries mode flag.</param>
/// <param name="flagPartitionRecover">Partition recover mode flag.</param>
public CacheImpl(IPlatformTargetInternal target,
bool flagSkipStore, bool flagKeepBinary, bool flagNoRetries, bool flagPartitionRecover)
: base(target)
{
_ignite = target.Marshaller.Ignite;
_flagSkipStore = flagSkipStore;
_flagKeepBinary = flagKeepBinary;
_flagNoRetries = flagNoRetries;
_flagPartitionRecover = flagPartitionRecover;
_txManager = GetConfiguration().AtomicityMode == CacheAtomicityMode.Transactional
? new CacheTransactionManager(_ignite.GetIgnite().GetTransactions())
: null;
_readException = stream => ReadException(Marshaller.StartUnmarshal(stream));
}
/// <summary>
/// Initializes a new instance of the <see cref="MessageListenerHolder" /> class.
/// </summary>
/// <param name="grid">Grid.</param>
/// <param name="filter">The <see cref="IMessageListener{T}" /> to wrap.</param>
/// <param name="invoker">The invoker func that takes key and value and invokes wrapped IMessageListener.</param>
private MessageListenerHolder(Ignite grid, object filter, Func <Guid, object, bool> invoker)
{
Debug.Assert(filter != null);
Debug.Assert(invoker != null);
_invoker = invoker;
_filter = filter;
// 1. Set fields.
Debug.Assert(grid != null);
_ignite = grid;
_invoker = invoker;
// 2. Perform injections.
ResourceProcessor.Inject(filter, grid);
}
public static void ExecuteJobAndWriteResults <T>(IIgniteInternal ignite, PlatformMemoryStream stream, T job,
Func <T, object> execFunc)
{
Debug.Assert(stream != null);
Debug.Assert(ignite != null);
Debug.Assert(job != null);
Debug.Assert(execFunc != null);
// 0. Inject resources.
InjectResources(ignite, job);
// 1. Execute job.
object res;
bool success;
using (PeerAssemblyResolver.GetInstance(ignite, Guid.Empty))
{
try
{
res = execFunc(job);
success = true;
}
catch (Exception e)
{
res = e;
success = false;
}
}
// 2. Try writing result to the stream.
var writer = ignite.Marshaller.StartMarshal(stream);
try
{
// 3. Marshal results.
BinaryUtils.WriteInvocationResult(writer, success, res);
}
finally
{
// 4. Process metadata.
ignite.Marshaller.FinishMarshal(writer);
}
}
/// <summary>
/// Gets the field ids.
/// </summary>
private static int[] GetFieldIds(BinaryObjectHeader hdr, IIgniteInternal ignite)
{
Debug.Assert(hdr.TypeId != BinaryTypeId.Unregistered);
int[] fieldIds = null;
if (ignite != null)
{
fieldIds = ignite.BinaryProcessor.GetSchema(hdr.TypeId, hdr.SchemaId);
}
if (fieldIds == null)
{
throw new BinaryObjectException("Cannot find schema for object with compact footer [" +
"typeId=" + hdr.TypeId + ", schemaId=" + hdr.SchemaId + ']');
}
return(fieldIds);
}
/// <summary>
/// Gets the assembly from remote nodes.
/// </summary>
/// <param name="typeName">Assembly-qualified type name.</param>
/// <param name="ignite">Ignite.</param>
/// <param name="originNodeId">Originating node identifier.</param>
/// <returns>
/// Resulting type or null.
/// </returns>
public static Type LoadAssemblyAndGetType(string typeName, IIgniteInternal ignite, Guid originNodeId)
{
Debug.Assert(!string.IsNullOrEmpty(typeName));
var parsedName = TypeNameParser.Parse(typeName);
var assemblyName = parsedName.GetAssemblyName();
Debug.Assert(assemblyName != null);
var asm = GetAssembly(ignite, assemblyName, originNodeId);
if (asm == null)
{
return(null);
}
// Assembly.GetType does not work for assembly-qualified names. Full name is required without assembly.
return(asm.GetType(parsedName.GetFullName(), false));
}
/// <summary>
/// Gets the assembly from remote nodes.
/// </summary>
/// <param name="assemblyName">Name of the assembly.</param>
/// <param name="ignite">Ignite.</param>
/// <param name="originNodeId">The origin node identifier.</param>
/// <returns>
/// Successful result or null.
/// </returns>
/// <exception cref="IgniteException"></exception>
private static AssemblyRequestResult RequestAssembly(string assemblyName, IIgniteInternal ignite,
Guid originNodeId)
{
Debug.Assert(assemblyName != null);
Debug.Assert(ignite != null);
if (ignite.Configuration.PeerAssemblyLoadingMode == PeerAssemblyLoadingMode.Disabled)
{
return(null);
}
Debug.WriteLine("Requesting assembly from other nodes: " + assemblyName);
// New nodes are not tracked during the loop, since some of the existing nodes caused this call.
var func = new GetAssemblyFunc();
var req = new AssemblyRequest(assemblyName);
foreach (var node in GetDotNetNodes(ignite.GetIgnite(), originNodeId))
{
var compute = ignite.GetIgnite().GetCluster().ForNodeIds(node).GetCompute();
var result = ComputeApplySafe(compute, func, req);
if (result != null)
{
if (result.AssemblyBytes != null)
{
return(result);
}
if (result.Message != null)
{
throw new IgniteException(result.Message);
}
}
}
return(null);
}
private static Exception ProcessCachePartialUpdateException(IIgniteInternal ignite, string msg,
string stackTrace, BinaryReader reader)
{
if (reader == null)
{
return(new CachePartialUpdateException(msg, new IgniteException("Failed keys are not available.")));
}
bool dataExists = reader.ReadBoolean();
Debug.Assert(dataExists);
if (reader.ReadBoolean())
{
bool keepBinary = reader.ReadBoolean();
BinaryReader keysReader = reader.Marshaller.StartUnmarshal(reader.Stream, keepBinary);
try
{
return(new CachePartialUpdateException(msg, ReadNullableList(keysReader)));
}
catch (Exception e)
{
// Failed to deserialize data.
return(new CachePartialUpdateException(msg, e));
}
}
// Was not able to write keys.
string innerErrCls = reader.ReadString();
string innerErrMsg = reader.ReadString();
Exception innerErr = GetException(ignite, innerErrCls, innerErrMsg, stackTrace);
return(new CachePartialUpdateException(msg, innerErr));
}
/// <summary>
/// Gets the assembly.
/// </summary>
private static Assembly GetAssembly(IIgniteInternal ignite, string assemblyName, Guid originNodeId)
{
return(LoadedAssembliesResolver.Instance.GetAssembly(assemblyName)
?? AssemblyLoader.GetAssembly(assemblyName)
?? LoadAssembly(ignite, assemblyName, originNodeId));
}
/// <summary>
/// Inject resources to the given object.
/// </summary>
/// <param name="target">Target.</param>
/// <param name="ignite">Grid.</param>
public void InjectIgnite(object target, IIgniteInternal ignite)
{
Inject0(target, ignite, _igniteInjectors);
}
/** <inheritDoc /> */
public void Inject(IIgniteInternal grid)
{
ResourceProcessor.Inject(_clo, grid);
}
/// <summary>
/// Initializes a new instance of the <see cref="CacheAffinityImpl" /> class.
/// </summary>
/// <param name="target">Target.</param>
/// <param name="keepBinary">Keep binary flag.</param>
public CacheAffinityImpl(IPlatformTargetInternal target, bool keepBinary) : base(target)
{
_keepBinary = keepBinary;
_ignite = target.Marshaller.Ignite;
}
/// <summary>
/// Reads the schema according to this header data.
/// </summary>
/// <param name="stream">The stream.</param>
/// <param name="position">The position.</param>
/// <param name="hdr">The header.</param>
/// <param name="schema">The schema.</param>
/// <param name="ignite">The ignite.</param>
/// <returns>
/// Schema.
/// </returns>
public static BinaryObjectSchemaField[] ReadSchema(IBinaryStream stream, int position, BinaryObjectHeader hdr,
BinaryObjectSchema schema, IIgniteInternal ignite)
{
Debug.Assert(stream != null);
Debug.Assert(schema != null);
return(ReadSchema(stream, position, hdr, () => GetFieldIds(hdr, schema, ignite)));
}
/// <summary>
/// Gets the field ids.
/// </summary>
private static int[] GetFieldIds(BinaryObjectHeader hdr, BinaryObjectSchema schema, IIgniteInternal ignite)
{
return(schema.Get(hdr.SchemaId) ?? GetFieldIds(hdr, ignite));
}
