public void TestIgniteGetVersionAndNodeVersionAreEqual()
        {
            IgniteProductVersion version     = Ignite.GetVersion();
            IgniteProductVersion nodeVersion = Ignite.GetCluster().GetLocalNode().Version;

            Assert.AreEqual(version, nodeVersion);
        }
        public void TestLocalNodeGetVersion()
        {
            IgniteProductVersion nodeVersion = Ignite.GetCluster().GetLocalNode().Version;

            Assert.GreaterOrEqual(nodeVersion.Major, 2);
            Assert.GreaterOrEqual(nodeVersion.Minor, 0);
            Assert.GreaterOrEqual(nodeVersion.Maintenance, 0);
            Assert.GreaterOrEqual(nodeVersion.Stage, "SNAPSHOT");
        }
        /// <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, Ignite 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, originNodeId))
            {
                var compute = ignite.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);
        }
Exemple #4
0
        /// <summary>
        /// Unpacks elements of the request argument that are represented as byte arrays in the Ignite request
        /// </summary>
        protected void PrepareArgument()
        {
            var originatingIgniteNodeId = Ignite.GetCluster().GetLocalNode().Id;

            Log.LogInformation($"Preparing argument with OriginatingIgniteNodeId = {originatingIgniteNodeId}, TRexNodeId = {TRexNodeId}");

            arg = new TSubGridsRequestArgument
            {
                ProjectID    = SiteModelID,
                RequestID    = RequestID,
                GridDataType = RequestedGridDataType,
                IncludeSurveyedSurfaceInformation = IncludeSurveyedSurfaceInformation,
                ProdDataMaskBytes            = ProdDataMask.ToBytes(),
                SurveyedSurfaceOnlyMaskBytes = SurveyedSurfaceOnlyMask.ToBytes(),
                Filters = Filters,
                OriginatingIgniteNodeId = originatingIgniteNodeId,
                TRexNodeID                  = TRexNodeId,
                ReferenceDesign             = ReferenceDesign,
                AreaControlSet              = AreaControlSet,
                SubGridsRequestComputeStyle = SubGridsRequestComputeStyle
            };

            CustomArgumentInitializer?.Invoke(arg);
        }