ignite-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From sboi...@apache.org
Subject [26/50] [abbrv] incubator-ignite git commit: Merge remote-tracking branch 'remotes/origin/sprint-1' into ignite-67
Date Sat, 31 Jan 2015 12:36:03 GMT
http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/ed8d4d80/modules/core/src/main/java/org/apache/ignite/internal/IgniteKernal.java
----------------------------------------------------------------------
diff --cc modules/core/src/main/java/org/apache/ignite/internal/IgniteKernal.java
index 0000000,7854bd9..62be046
mode 000000,100644..100644
--- a/modules/core/src/main/java/org/apache/ignite/internal/IgniteKernal.java
+++ b/modules/core/src/main/java/org/apache/ignite/internal/IgniteKernal.java
@@@ -1,0 -1,3322 +1,3322 @@@
+ /*
+  * Licensed to the Apache Software Foundation (ASF) under one or more
+  * contributor license agreements.  See the NOTICE file distributed with
+  * this work for additional information regarding copyright ownership.
+  * The ASF licenses this file to You under the Apache License, Version 2.0
+  * (the "License"); you may not use this file except in compliance with
+  * the License.  You may obtain a copy of the License at
+  *
+  *      http://www.apache.org/licenses/LICENSE-2.0
+  *
+  * Unless required by applicable law or agreed to in writing, software
+  * distributed under the License is distributed on an "AS IS" BASIS,
+  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  * See the License for the specific language governing permissions and
+  * limitations under the License.
+  */
+ 
+ package org.apache.ignite.internal;
+ 
+ import org.apache.ignite.*;
+ import org.apache.ignite.cache.*;
+ import org.apache.ignite.cache.affinity.*;
+ import org.apache.ignite.cluster.*;
+ import org.apache.ignite.configuration.*;
+ import org.apache.ignite.internal.processors.*;
+ import org.apache.ignite.internal.processors.cache.*;
+ import org.apache.ignite.internal.processors.portable.*;
+ import org.apache.ignite.internal.util.*;
+ import org.apache.ignite.lang.*;
+ import org.apache.ignite.lifecycle.*;
+ import org.apache.ignite.marshaller.*;
+ import org.apache.ignite.marshaller.optimized.*;
+ import org.apache.ignite.mxbean.*;
+ import org.apache.ignite.plugin.*;
+ import org.apache.ignite.internal.product.*;
+ import org.apache.ignite.spi.*;
+ import org.apache.ignite.spi.authentication.*;
+ import org.apache.ignite.spi.authentication.noop.*;
+ import org.apache.ignite.hadoop.*;
+ import org.apache.ignite.internal.managers.*;
+ import org.apache.ignite.internal.managers.checkpoint.*;
+ import org.apache.ignite.internal.managers.collision.*;
+ import org.apache.ignite.internal.managers.communication.*;
+ import org.apache.ignite.internal.managers.deployment.*;
+ import org.apache.ignite.internal.managers.discovery.*;
+ import org.apache.ignite.internal.managers.eventstorage.*;
+ import org.apache.ignite.internal.managers.failover.*;
+ import org.apache.ignite.internal.managers.indexing.*;
+ import org.apache.ignite.internal.managers.loadbalancer.*;
+ import org.apache.ignite.internal.managers.securesession.*;
+ import org.apache.ignite.internal.managers.security.*;
+ import org.apache.ignite.internal.managers.swapspace.*;
+ import org.apache.ignite.internal.processors.affinity.*;
+ import org.apache.ignite.internal.processors.clock.*;
+ import org.apache.ignite.internal.processors.closure.*;
+ import org.apache.ignite.internal.processors.continuous.*;
+ import org.apache.ignite.internal.processors.dataload.*;
+ import org.apache.ignite.internal.processors.email.*;
+ import org.apache.ignite.internal.processors.interop.*;
+ import org.apache.ignite.internal.processors.job.*;
+ import org.apache.ignite.internal.processors.jobmetrics.*;
+ import org.apache.ignite.internal.processors.license.*;
+ import org.apache.ignite.internal.processors.offheap.*;
+ import org.apache.ignite.internal.processors.plugin.*;
+ import org.apache.ignite.internal.processors.port.*;
+ import org.apache.ignite.internal.processors.query.*;
+ import org.apache.ignite.internal.processors.resource.*;
+ import org.apache.ignite.internal.processors.rest.*;
+ import org.apache.ignite.internal.processors.segmentation.*;
+ import org.apache.ignite.internal.processors.service.*;
+ import org.apache.ignite.internal.processors.session.*;
+ import org.apache.ignite.internal.processors.streamer.*;
+ import org.apache.ignite.internal.processors.task.*;
+ import org.apache.ignite.internal.processors.timeout.*;
+ import org.apache.ignite.plugin.security.*;
+ import org.apache.ignite.spi.securesession.noop.*;
+ import org.apache.ignite.internal.util.future.*;
+ import org.apache.ignite.internal.util.lang.*;
+ import org.apache.ignite.internal.util.nodestart.*;
+ import org.apache.ignite.internal.util.tostring.*;
+ import org.apache.ignite.internal.util.typedef.*;
+ import org.apache.ignite.internal.util.typedef.internal.*;
+ import org.jetbrains.annotations.*;
+ 
+ import javax.management.*;
+ import java.io.*;
+ import java.lang.management.*;
+ import java.lang.reflect.*;
+ import java.net.*;
+ import java.text.*;
+ import java.util.*;
+ import java.util.concurrent.*;
+ import java.util.concurrent.atomic.*;
+ 
+ import static org.apache.ignite.internal.GridKernalState.*;
+ import static org.apache.ignite.lifecycle.LifecycleEventType.*;
+ import static org.apache.ignite.IgniteSystemProperties.*;
+ import static org.apache.ignite.internal.IgniteComponentType.*;
+ import static org.apache.ignite.internal.GridNodeAttributes.*;
+ import static org.apache.ignite.internal.GridProductImpl.*;
+ import static org.apache.ignite.internal.processors.license.GridLicenseSubsystem.*;
+ import static org.apache.ignite.internal.util.nodestart.GridNodeStartUtils.*;
+ 
+ /**
+  * GridGain kernal.
+  * <p/>
+  * See <a href="http://en.wikipedia.org/wiki/Kernal">http://en.wikipedia.org/wiki/Kernal</a> for information on the
+  * misspelling.
+  */
+ public class IgniteKernal extends ClusterGroupAdapter implements IgniteEx, IgniteMXBean {
+     /** */
+     private static final long serialVersionUID = 0L;
+ 
+     /** Compatible versions. */
+     private static final String COMPATIBLE_VERS = GridProperties.get("gridgain.compatible.vers");
+ 
+     /** GridGain site that is shown in log messages. */
+     static final String SITE = "www.gridgain.com";
+ 
+     /** System line separator. */
+     private static final String NL = U.nl();
+ 
+     /** Periodic version check delay. */
+     private static final long PERIODIC_VER_CHECK_DELAY = 1000 * 60 * 60; // Every hour.
+ 
+     /** Periodic version check delay. */
+     private static final long PERIODIC_VER_CHECK_CONN_TIMEOUT = 10 * 1000; // 10 seconds.
+ 
+     /** Periodic version check delay. */
+     private static final long PERIODIC_LIC_CHECK_DELAY = 1000 * 60; // Every minute.
+ 
+     /** Periodic starvation check interval. */
+     private static final long PERIODIC_STARVATION_CHECK_FREQ = 1000 * 30;
+ 
+     /** Shutdown delay in msec. when license violation detected. */
+     private static final int SHUTDOWN_DELAY = 60 * 1000;
+ 
+     /** */
+     private IgniteConfiguration cfg;
+ 
+     /** */
+     @SuppressWarnings({"FieldAccessedSynchronizedAndUnsynchronized"})
+     @GridToStringExclude
+     private GridLoggerProxy log;
+ 
+     /** */
+     private String gridName;
+ 
+     /** */
+     @GridToStringExclude
+     private ObjectName kernalMBean;
+ 
+     /** */
+     @GridToStringExclude
+     private ObjectName locNodeMBean;
+ 
+     /** */
+     @GridToStringExclude
+     private ObjectName pubExecSvcMBean;
+ 
+     /** */
+     @GridToStringExclude
+     private ObjectName sysExecSvcMBean;
+ 
+     /** */
+     @GridToStringExclude
+     private ObjectName mgmtExecSvcMBean;
+ 
+     /** */
+     @GridToStringExclude
+     private ObjectName p2PExecSvcMBean;
+ 
+     /** */
+     @GridToStringExclude
+     private ObjectName restExecSvcMBean;
+ 
+     /** Kernal start timestamp. */
+     private long startTime = U.currentTimeMillis();
+ 
+     /** Spring context, potentially {@code null}. */
+     private GridSpringResourceContext rsrcCtx;
+ 
+     /** */
+     @GridToStringExclude
+     private Timer updateNtfTimer;
+ 
+     /** */
+     @GridToStringExclude
+     private Timer starveTimer;
+ 
+     /** */
+     @GridToStringExclude
+     private Timer licTimer;
+ 
+     /** */
+     @GridToStringExclude
+     private Timer metricsLogTimer;
+ 
+     /** Indicate error on grid stop. */
+     @GridToStringExclude
+     private boolean errOnStop;
+ 
+     /** Node local store. */
+     @GridToStringExclude
+     private ClusterNodeLocalMap nodeLoc;
+ 
+     /** Scheduler. */
+     @GridToStringExclude
+     private IgniteScheduler scheduler;
+ 
+     /** Grid security instance. */
+     @GridToStringExclude
+     private GridSecurity security;
+ 
+     /** Portables instance. */
+     @GridToStringExclude
+     private IgnitePortables portables;
+ 
+     /** Kernal gateway. */
+     @GridToStringExclude
+     private final AtomicReference<GridKernalGateway> gw = new AtomicReference<>();
+ 
+     /** Data Grid edition usage registered flag. */
+     @GridToStringExclude
+     private volatile boolean dbUsageRegistered;
+ 
+     /** */
+     @GridToStringExclude
+     private final Collection<String> compatibleVers;
+ 
+     /** Stop guard. */
+     @GridToStringExclude
+     private final AtomicBoolean stopGuard = new AtomicBoolean();
+ 
+     /**
+      * No-arg constructor is required by externalization.
+      */
+     public IgniteKernal() {
+         this(null);
+     }
+ 
+     /**
+      * @param rsrcCtx Optional Spring application context.
+      */
+     public IgniteKernal(@Nullable GridSpringResourceContext rsrcCtx) {
+         super(null, null, null, (IgnitePredicate<ClusterNode>)null);
+ 
+         this.rsrcCtx = rsrcCtx;
+ 
+         String[] compatibleVers = COMPATIBLE_VERS.split(",");
+ 
+         for (int i = 0; i < compatibleVers.length; i++)
+             compatibleVers[i] = compatibleVers[i].trim();
+ 
+         this.compatibleVers = Collections.unmodifiableList(Arrays.asList(compatibleVers));
+     }
+ 
+     /** {@inheritDoc} */
+     @Override public IgniteCluster cluster() {
+         return this;
+     }
+ 
+     /** {@inheritDoc} */
+     @Override public final IgniteCompute compute(ClusterGroup prj) {
+         return ((ClusterGroupAdapter)prj).compute();
+     }
+ 
+     /** {@inheritDoc} */
+     @Override public final IgniteMessaging message(ClusterGroup prj) {
+         return ((ClusterGroupAdapter)prj).message();
+     }
+ 
+     /** {@inheritDoc} */
+     @Override public final IgniteEvents events(ClusterGroup prj) {
+         return ((ClusterGroupAdapter)prj).events();
+     }
+ 
+     /** {@inheritDoc} */
+     @Override public IgniteManaged managed(ClusterGroup prj) {
+         return ((ClusterGroupAdapter)prj).managed();
+     }
+ 
+     /** {@inheritDoc} */
+     @Override public ExecutorService executorService(ClusterGroup prj) {
+         return ((ClusterGroupAdapter)prj).executorService();
+     }
+ 
+     /** {@inheritDoc} */
+     @Override public String name() {
+         return gridName;
+     }
+ 
+     /** {@inheritDoc} */
+     @Override public String getCopyright() {
+         return ctx.product().copyright();
+     }
+ 
+     /** {@inheritDoc} */
+     @Override public String getLicenseFilePath() {
+         assert cfg != null;
+ 
+         return cfg.getLicenseUrl();
+     }
+ 
+     /** {@inheritDoc} */
+     @Override public long getStartTimestamp() {
+         return startTime;
+     }
+ 
+     /** {@inheritDoc} */
+     @Override public String getStartTimestampFormatted() {
+         return DateFormat.getDateTimeInstance().format(new Date(startTime));
+     }
+ 
+     /** {@inheritDoc} */
+     @Override public long getUpTime() {
+         return U.currentTimeMillis() - startTime;
+     }
+ 
+     /** {@inheritDoc} */
+     @Override public String getUpTimeFormatted() {
+         return X.timeSpan2HMSM(U.currentTimeMillis() - startTime);
+     }
+ 
+     /** {@inheritDoc} */
+     @Override public String getFullVersion() {
+         return COMPOUND_VER + '-' + BUILD_TSTAMP_STR;
+     }
+ 
+     /** {@inheritDoc} */
+     @Override public String getCheckpointSpiFormatted() {
+         assert cfg != null;
+ 
+         return Arrays.toString(cfg.getCheckpointSpi());
+     }
+ 
+     /** {@inheritDoc} */
+     @Override public String getSwapSpaceSpiFormatted() {
+         assert cfg != null;
+ 
+         return cfg.getSwapSpaceSpi().toString();
+     }
+ 
+     /** {@inheritDoc} */
+     @Override public String getCommunicationSpiFormatted() {
+         assert cfg != null;
+ 
+         return cfg.getCommunicationSpi().toString();
+     }
+ 
+     /** {@inheritDoc} */
+     @Override public String getDeploymentSpiFormatted() {
+         assert cfg != null;
+ 
+         return cfg.getDeploymentSpi().toString();
+     }
+ 
+     /** {@inheritDoc} */
+     @Override public String getDiscoverySpiFormatted() {
+         assert cfg != null;
+ 
+         return cfg.getDiscoverySpi().toString();
+     }
+ 
+     /** {@inheritDoc} */
+     @Override public String getEventStorageSpiFormatted() {
+         assert cfg != null;
+ 
+         return cfg.getEventStorageSpi().toString();
+     }
+ 
+     /** {@inheritDoc} */
+     @Override public String getCollisionSpiFormatted() {
+         assert cfg != null;
+ 
+         return cfg.getCollisionSpi().toString();
+     }
+ 
+     /** {@inheritDoc} */
+     @Override public String getFailoverSpiFormatted() {
+         assert cfg != null;
+ 
+         return Arrays.toString(cfg.getFailoverSpi());
+     }
+ 
+     /** {@inheritDoc} */
+     @Override public String getLoadBalancingSpiFormatted() {
+         assert cfg != null;
+ 
+         return Arrays.toString(cfg.getLoadBalancingSpi());
+     }
+ 
+     /** {@inheritDoc} */
+     @Override public String getAuthenticationSpiFormatted() {
+         assert cfg != null;
+ 
+         return cfg.getAuthenticationSpi().toString();
+     }
+ 
+     /** {@inheritDoc} */
+     @Override public String getSecureSessionSpiFormatted() {
+         assert cfg != null;
+ 
+         return cfg.getSecureSessionSpi().toString();
+     }
+ 
+     /** {@inheritDoc} */
+     @Override public String getOsInformation() {
+         return U.osString();
+     }
+ 
+     /** {@inheritDoc} */
+     @Override public String getJdkInformation() {
+         return U.jdkString();
+     }
+ 
+     /** {@inheritDoc} */
+     @Override public String getOsUser() {
+         return System.getProperty("user.name");
+     }
+ 
+     /** {@inheritDoc} */
+     @Override public String getVmName() {
+         return ManagementFactory.getRuntimeMXBean().getName();
+     }
+ 
+     /** {@inheritDoc} */
+     @Override public String getInstanceName() {
+         return gridName;
+     }
+ 
+     /** {@inheritDoc} */
+     @Override public String getExecutorServiceFormatted() {
+         assert cfg != null;
+ 
+         return cfg.getExecutorService().toString();
+     }
+ 
+     /** {@inheritDoc} */
+     @Override public String getGridGainHome() {
+         assert cfg != null;
+ 
+         return cfg.getGridGainHome();
+     }
+ 
+     /** {@inheritDoc} */
+     @Override public String getGridLoggerFormatted() {
+         assert cfg != null;
+ 
+         return cfg.getGridLogger().toString();
+     }
+ 
+     /** {@inheritDoc} */
+     @Override public String getMBeanServerFormatted() {
+         assert cfg != null;
+ 
+         return cfg.getMBeanServer().toString();
+     }
+ 
+     /** {@inheritDoc} */
+     @Override public UUID getLocalNodeId() {
+         assert cfg != null;
+ 
+         return cfg.getNodeId();
+     }
+ 
+     /** {@inheritDoc} */
+     @SuppressWarnings("unchecked")
+     @Override public Collection<String> getUserAttributesFormatted() {
+         assert cfg != null;
+ 
+         return F.transform(cfg.getUserAttributes().entrySet(), new C1<Map.Entry<String, ?>, String>() {
+             @Override public String apply(Map.Entry<String, ?> e) {
+                 return e.getKey() + ", " + e.getValue().toString();
+             }
+         });
+     }
+ 
+     /** {@inheritDoc} */
+     @Override public boolean isPeerClassLoadingEnabled() {
+         assert cfg != null;
+ 
+         return cfg.isPeerClassLoadingEnabled();
+     }
+ 
+     /** {@inheritDoc} */
+     @Override public Collection<String> getLifecycleBeansFormatted() {
+         LifecycleBean[] beans = cfg.getLifecycleBeans();
+ 
+         return F.isEmpty(beans) ? Collections.<String>emptyList() : F.transform(beans, F.<LifecycleBean>string());
+     }
+ 
+     /**
+      * @param attrs Current attributes.
+      * @param name  New attribute name.
+      * @param val New attribute value.
+      * @throws IgniteCheckedException If duplicated SPI name found.
+      */
+     private void add(Map<String, Object> attrs, String name, @Nullable Serializable val) throws IgniteCheckedException {
+         assert attrs != null;
+         assert name != null;
+ 
+         if (attrs.put(name, val) != null) {
+             if (name.endsWith(ATTR_SPI_CLASS))
+                 // User defined duplicated names for the different SPIs.
+                 throw new IgniteCheckedException("Failed to set SPI attribute. Duplicated SPI name found: " +
+                     name.substring(0, name.length() - ATTR_SPI_CLASS.length()));
+ 
+             // Otherwise it's a mistake of setting up duplicated attribute.
+             assert false : "Duplicate attribute: " + name;
+         }
+     }
+ 
+     /**
+      * Notifies life-cycle beans of grid event.
+      *
+      * @param evt Grid event.
+      * @throws IgniteCheckedException If user threw exception during start.
+      */
+     @SuppressWarnings({"CatchGenericClass"})
+     private void notifyLifecycleBeans(LifecycleEventType evt) throws IgniteCheckedException {
+         if (!cfg.isDaemon() && cfg.getLifecycleBeans() != null)
+             for (LifecycleBean bean : cfg.getLifecycleBeans())
+                 if (bean != null)
+                     bean.onLifecycleEvent(evt);
+     }
+ 
+     /**
+      * Notifies life-cycle beans of grid event.
+      *
+      * @param evt Grid event.
+      */
+     @SuppressWarnings({"CatchGenericClass"})
+     private void notifyLifecycleBeansEx(LifecycleEventType evt) {
+         try {
+             notifyLifecycleBeans(evt);
+         }
+         // Catch generic throwable to secure against user assertions.
+         catch (Throwable e) {
+             U.error(log, "Failed to notify lifecycle bean (safely ignored) [evt=" + evt +
+                 ", gridName=" + gridName + ']', e);
+         }
+     }
+ 
+     /**
+      * @param cfg Grid configuration to use.
+      * @param utilityCachePool Utility cache pool.
+      * @param errHnd Error handler to use for notification about startup problems.
+      * @throws IgniteCheckedException Thrown in case of any errors.
+      */
+     @SuppressWarnings({"CatchGenericClass", "unchecked"})
+     public void start(final IgniteConfiguration cfg, ExecutorService utilityCachePool, GridAbsClosure errHnd)
+         throws IgniteCheckedException {
+         gw.compareAndSet(null, new GridKernalGatewayImpl(cfg.getGridName()));
+ 
+         GridKernalGateway gw = this.gw.get();
+ 
+         gw.writeLock();
+ 
+         try {
+             switch (gw.getState()) {
+                 case STARTED: {
+                     U.warn(log, "Grid has already been started (ignored).");
+ 
+                     return;
+                 }
+ 
+                 case STARTING: {
+                     U.warn(log, "Grid is already in process of being started (ignored).");
+ 
+                     return;
+                 }
+ 
+                 case STOPPING: {
+                     throw new IgniteCheckedException("Grid is in process of being stopped");
+                 }
+ 
+                 case STOPPED: {
+                     break;
+                 }
+             }
+ 
+             gw.setState(STARTING);
+         }
+         finally {
+             gw.writeUnlock();
+         }
+ 
+         assert cfg != null;
+ 
+         // Make sure we got proper configuration.
+         validateCommon(cfg);
+ 
+         gridName = cfg.getGridName();
+ 
+         this.cfg = cfg;
+ 
+         log = (GridLoggerProxy)cfg.getGridLogger().getLogger(getClass().getName() +
+             (gridName != null ? '%' + gridName : ""));
+ 
+         RuntimeMXBean rtBean = ManagementFactory.getRuntimeMXBean();
+ 
+         // Ack various information.
+         ackAsciiLogo();
+         ackConfigUrl();
+         ackDaemon();
+         ackOsInfo();
+         ackLanguageRuntime();
+         ackRemoteManagement();
+         ackVmArguments(rtBean);
+         ackClassPaths(rtBean);
+         ackSystemProperties();
+         ackEnvironmentVariables();
+         ackSmtpConfiguration();
+         ackCacheConfiguration();
+         ackP2pConfiguration();
+ 
+         // Run background network diagnostics.
+         GridDiagnostic.runBackgroundCheck(gridName, cfg.getExecutorService(), log);
+ 
 -        boolean notifyEnabled = IgniteSystemProperties.getBoolean(GG_UPDATE_NOTIFIER, true);
++        boolean notifyEnabled = IgniteSystemProperties.getBoolean(IGNITE_UPDATE_NOTIFIER, true);
+ 
+         GridUpdateNotifier verChecker0 = null;
+ 
+         if (notifyEnabled) {
+             try {
+                 verChecker0 = new GridUpdateNotifier(gridName, VER, SITE, gw, false);
+ 
+                 verChecker0.checkForNewVersion(cfg.getExecutorService(), log);
+             }
+             catch (IgniteCheckedException e) {
+                 if (log.isDebugEnabled())
+                     log.debug("Failed to create GridUpdateNotifier: " + e);
+             }
+         }
+ 
+         final GridUpdateNotifier verChecker = verChecker0;
+ 
+         // Ack 3-rd party licenses location.
+         if (log.isInfoEnabled() && cfg.getGridGainHome() != null)
+             log.info("3-rd party licenses can be found at: " + cfg.getGridGainHome() + File.separatorChar + "libs" +
+                 File.separatorChar + "licenses");
+ 
+         // Check that user attributes are not conflicting
+         // with internally reserved names.
+         for (String name : cfg.getUserAttributes().keySet())
+             if (name.startsWith(ATTR_PREFIX))
+                 throw new IgniteCheckedException("User attribute has illegal name: '" + name + "'. Note that all names " +
+                     "starting with '" + ATTR_PREFIX + "' are reserved for internal use.");
+ 
+         // Ack local node user attributes.
+         logNodeUserAttributes();
+ 
+         // Ack configuration.
+         ackSpis();
+ 
+         Map<String, Object> attrs = createNodeAttributes(cfg, BUILD_TSTAMP_STR);
+ 
+         // Spin out SPIs & managers.
+         try {
+             GridKernalContextImpl ctx =
+                 new GridKernalContextImpl(log, this, cfg, gw, utilityCachePool, ENT);
+ 
+             nodeLoc = new ClusterNodeLocalMapImpl(ctx);
+ 
+             U.onGridStart();
+ 
+             // Set context into rich adapter.
+             setKernalContext(ctx);
+ 
+             // Start and configure resource processor first as it contains resources used
+             // by all other managers and processors.
+             GridResourceProcessor rsrcProc = new GridResourceProcessor(ctx);
+ 
+             rsrcProc.setSpringContext(rsrcCtx);
+ 
+             ctx.product(new GridProductImpl(ctx, verChecker));
+ 
+             scheduler = new IgniteSchedulerImpl(ctx);
+ 
+             startProcessor(ctx, rsrcProc, attrs);
+ 
+             // Inject resources into lifecycle beans.
+             if (!cfg.isDaemon() && cfg.getLifecycleBeans() != null)
+                 for (LifecycleBean bean : cfg.getLifecycleBeans())
+                     if (bean != null)
+                         rsrcProc.inject(bean);
+ 
+             // Lifecycle notification.
+             notifyLifecycleBeans(BEFORE_GRID_START);
+ 
+             // Starts lifecycle aware components.
+             U.startLifecycleAware(lifecycleAwares(cfg));
+ 
+             addHelper(ctx, GGFS_HELPER.create(F.isEmpty(cfg.getGgfsConfiguration())));
+ 
+             startProcessor(ctx, new IgnitePluginProcessor(ctx, cfg), attrs);
+ 
+             // Off-heap processor has no dependencies.
+             startProcessor(ctx, new GridOffHeapProcessor(ctx), attrs);
+ 
+             // Closure processor should be started before all others
+             // (except for resource processor), as many components can depend on it.
+             startProcessor(ctx, new GridClosureProcessor(ctx), attrs);
+ 
+             // Start some other processors (order & place is important).
+             startProcessor(ctx, (GridProcessor)EMAIL.create(ctx, cfg.getSmtpHost() == null), attrs);
+             startProcessor(ctx, new GridPortProcessor(ctx), attrs);
+             startProcessor(ctx, new GridJobMetricsProcessor(ctx), attrs);
+ 
+             // Timeout processor needs to be started before managers,
+             // as managers may depend on it.
+             startProcessor(ctx, new GridTimeoutProcessor(ctx), attrs);
+ 
+             // Start SPI managers.
+             // NOTE: that order matters as there are dependencies between managers.
+             startManager(ctx, createComponent(GridSecurityManager.class, ctx), attrs);
+             startManager(ctx, createComponent(GridSecureSessionManager.class, ctx), attrs);
+             startManager(ctx, new GridIoManager(ctx), attrs);
+             startManager(ctx, new GridCheckpointManager(ctx), attrs);
+ 
+             startManager(ctx, new GridEventStorageManager(ctx), attrs);
+             startManager(ctx, new GridDeploymentManager(ctx), attrs);
+             startManager(ctx, new GridLoadBalancerManager(ctx), attrs);
+             startManager(ctx, new GridFailoverManager(ctx), attrs);
+             startManager(ctx, new GridCollisionManager(ctx), attrs);
+             startManager(ctx, new GridSwapSpaceManager(ctx), attrs);
+             startManager(ctx, new GridIndexingManager(ctx), attrs);
+ 
+             ackSecurity(ctx);
+ 
+             // Start processors before discovery manager, so they will
+             // be able to start receiving messages once discovery completes.
+             startProcessor(ctx, new GridClockSyncProcessor(ctx), attrs);
+             startProcessor(ctx, createComponent(GridLicenseProcessor.class, ctx), attrs);
+             startProcessor(ctx, new GridAffinityProcessor(ctx), attrs);
+             startProcessor(ctx, createComponent(GridSegmentationProcessor.class, ctx), attrs);
+             startProcessor(ctx, new GridQueryProcessor(ctx), attrs);
+             startProcessor(ctx, new GridCacheProcessor(ctx), attrs);
+             startProcessor(ctx, new GridTaskSessionProcessor(ctx), attrs);
+             startProcessor(ctx, new GridJobProcessor(ctx), attrs);
+             startProcessor(ctx, new GridTaskProcessor(ctx), attrs);
+             startProcessor(ctx, (GridProcessor)SCHEDULE.createOptional(ctx), attrs);
+             startProcessor(ctx, createComponent(GridPortableProcessor.class, ctx), attrs);
+             startProcessor(ctx, createComponent(GridInteropProcessor.class, ctx), attrs);
+             startProcessor(ctx, new GridRestProcessor(ctx), attrs);
+             startProcessor(ctx, new GridDataLoaderProcessor(ctx), attrs);
+             startProcessor(ctx, new GridStreamProcessor(ctx), attrs);
+             startProcessor(ctx, (GridProcessor)GGFS.create(ctx, F.isEmpty(cfg.getGgfsConfiguration())), attrs);
+             startProcessor(ctx, new GridContinuousProcessor(ctx), attrs);
+             startProcessor(ctx, (GridProcessor)(cfg.isPeerClassLoadingEnabled() ?
+                 IgniteComponentType.HADOOP.create(ctx, true): // No-op when peer class loading is enabled.
+                 IgniteComponentType.HADOOP.createIfInClassPath(ctx, cfg.getHadoopConfiguration() != null)), attrs);
+             startProcessor(ctx, new GridServiceProcessor(ctx), attrs);
+ 
+             // Start plugins.
+             for (PluginProvider provider : ctx.plugins().allProviders()) {
+                 ctx.add(new GridPluginComponent(provider));
+ 
+                 provider.start(ctx.plugins().pluginContextForProvider(provider), attrs);
+             }
+ 
+             ctx.createMessageFactory();
+ 
+             if (ctx.isEnterprise()) {
+                 security = new GridSecurityImpl(ctx);
+                 portables = new GridPortablesImpl(ctx);
+             }
+ 
+             gw.writeLock();
+ 
+             try {
+                 gw.setState(STARTED);
+ 
+                 // Start discovery manager last to make sure that grid is fully initialized.
+                 startManager(ctx, new GridDiscoveryManager(ctx), attrs);
+             }
+             finally {
+                 gw.writeUnlock();
+             }
+ 
+             // Check whether physical RAM is not exceeded.
+             checkPhysicalRam();
+ 
+             // Suggest configuration optimizations.
+             suggestOptimizations(ctx, cfg);
+ 
+             if (!ctx.isEnterprise())
+                 warnNotSupportedFeaturesForOs(cfg);
+ 
+             // Notify discovery manager the first to make sure that topology is discovered.
+             ctx.discovery().onKernalStart();
+ 
+             // Notify IO manager the second so further components can send and receive messages.
+             ctx.io().onKernalStart();
+ 
+             // Callbacks.
+             for (GridComponent comp : ctx) {
+                 // Skip discovery manager.
+                 if (comp instanceof GridDiscoveryManager)
+                     continue;
+ 
+                 // Skip IO manager.
+                 if (comp instanceof GridIoManager)
+                     continue;
+ 
+                 comp.onKernalStart();
+             }
+ 
+             // Ack the license.
+             ctx.license().ackLicense();
+ 
+             // Register MBeans.
+             registerKernalMBean();
+             registerLocalNodeMBean();
+             registerExecutorMBeans();
+ 
+             // Lifecycle bean notifications.
+             notifyLifecycleBeans(AFTER_GRID_START);
+         }
+         catch (Throwable e) {
+             IgniteSpiVersionCheckException verCheckErr = X.cause(e, IgniteSpiVersionCheckException.class);
+ 
+             if (verCheckErr != null)
+                 U.error(log, verCheckErr.getMessage());
+             else if (X.hasCause(e, InterruptedException.class, IgniteInterruptedException.class))
+                 U.warn(log, "Grid startup routine has been interrupted (will rollback).");
+             else
+                 U.error(log, "Got exception while starting (will rollback startup routine).", e);
+ 
+             errHnd.apply();
+ 
+             stop(true);
+ 
+             if (e instanceof IgniteCheckedException)
+                 throw (IgniteCheckedException)e;
+             else
+                 throw new IgniteCheckedException(e);
+         }
+ 
+         // Mark start timestamp.
+         startTime = U.currentTimeMillis();
+ 
+         // Ack latest version information.
+         if (verChecker != null)
+             verChecker.reportStatus(log);
+ 
+         if (notifyEnabled) {
+             assert verChecker != null;
+ 
+             verChecker.reportOnlyNew(true);
+             verChecker.licenseProcessor(ctx.license());
+ 
+             updateNtfTimer = new Timer("gridgain-update-notifier-timer");
+ 
+             // Setup periodic version check.
+             updateNtfTimer.scheduleAtFixedRate(new GridTimerTask() {
+                 @Override public void safeRun() throws InterruptedException {
+                     verChecker.topologySize(nodes().size());
+ 
+                     verChecker.checkForNewVersion(cfg.getExecutorService(), log);
+ 
+                     // Just wait for 10 secs.
+                     Thread.sleep(PERIODIC_VER_CHECK_CONN_TIMEOUT);
+ 
+                     // Report status if one is available.
+                     // No-op if status is NOT available.
+                     verChecker.reportStatus(log);
+                 }
+             }, PERIODIC_VER_CHECK_DELAY, PERIODIC_VER_CHECK_DELAY);
+         }
+ 
 -        String intervalStr = IgniteSystemProperties.getString(GG_STARVATION_CHECK_INTERVAL);
++        String intervalStr = IgniteSystemProperties.getString(IGNITE_STARVATION_CHECK_INTERVAL);
+ 
+         // Start starvation checker if enabled.
+         boolean starveCheck = !isDaemon() && !"0".equals(intervalStr);
+ 
+         if (starveCheck) {
+             final long interval = F.isEmpty(intervalStr) ? PERIODIC_STARVATION_CHECK_FREQ : Long.parseLong(intervalStr);
+ 
+             starveTimer = new Timer("gridgain-starvation-checker");
+ 
+             starveTimer.scheduleAtFixedRate(new GridTimerTask() {
+                 /** Last completed task count. */
+                 private long lastCompletedCnt;
+ 
+                 @Override protected void safeRun() {
+                     ExecutorService e = cfg.getExecutorService();
+ 
+                     if (!(e instanceof ThreadPoolExecutor))
+                         return;
+ 
+                     ThreadPoolExecutor exec = (ThreadPoolExecutor)e;
+ 
+                     long completedCnt = exec.getCompletedTaskCount();
+ 
+                     // If all threads are active and no task has completed since last time and there is
+                     // at least one waiting request, then it is possible starvation.
+                     if (exec.getPoolSize() == exec.getActiveCount() && completedCnt == lastCompletedCnt &&
+                         !exec.getQueue().isEmpty())
+                         LT.warn(log, null, "Possible thread pool starvation detected (no task completed in last " +
+                             interval + "ms, is executorService pool size large enough?)");
+ 
+                     lastCompletedCnt = completedCnt;
+                 }
+             }, interval, interval);
+         }
+ 
+         if (!isDaemon()) {
+             licTimer = new Timer("gridgain-license-checker");
+ 
+             // Setup periodic license check.
+             licTimer.scheduleAtFixedRate(new GridTimerTask() {
+                 @Override public void safeRun() throws InterruptedException {
+                     try {
+                         ctx.license().checkLicense();
+                     }
+                     // This exception only happens when license processor was unable
+                     // to resolve license violation on its own and this grid instance
+                     // now needs to be shutdown.
+                     //
+                     // Note that in most production configurations the license will
+                     // have certain grace period and license processor will attempt
+                     // to reload the license during the grace period.
+                     //
+                     // This exception thrown here means that grace period, if any,
+                     // has expired and license violation is still unresolved.
+                     catch (IgniteProductLicenseException ignored) {
+                         U.error(log, "License violation is unresolved. GridGain node will shutdown in " +
+                             (SHUTDOWN_DELAY / 1000) + " sec.");
+                         U.error(log, "  ^-- Contact your support for immediate assistance (!)");
+ 
+                         // Allow interruption to break from here since
+                         // node is stopping anyways.
+                         Thread.sleep(SHUTDOWN_DELAY);
+ 
+                         G.stop(gridName, true);
+                     }
+                     // Safety net.
+                     catch (Throwable e) {
+                         U.error(log, "Unable to check the license due to system error.", e);
+                         U.error(log, "Grid instance will be stopped...");
+ 
+                         // Stop the grid if we get unknown license-related error.
+                         // Should never happen. Practically an assertion...
+                         G.stop(gridName, true);
+                     }
+                 }
+             }, PERIODIC_LIC_CHECK_DELAY, PERIODIC_LIC_CHECK_DELAY);
+         }
+ 
+         long metricsLogFreq = cfg.getMetricsLogFrequency();
+ 
+         if (metricsLogFreq > 0) {
+             metricsLogTimer = new Timer("gridgain-metrics-logger");
+ 
+             metricsLogTimer.scheduleAtFixedRate(new GridTimerTask() {
+                 /** */
+                 private final DecimalFormat dblFmt = new DecimalFormat("#.##");
+ 
+                 @Override protected void safeRun() {
+                     if (log.isInfoEnabled()) {
+                         ClusterMetrics m = localNode().metrics();
+ 
+                         double cpuLoadPct = m.getCurrentCpuLoad() * 100;
+                         double avgCpuLoadPct = m.getAverageCpuLoad() * 100;
+                         double gcPct = m.getCurrentGcCpuLoad() * 100;
+ 
+                         long heapUsed = m.getHeapMemoryUsed();
+                         long heapMax = m.getHeapMemoryMaximum();
+ 
+                         long heapUsedInMBytes = heapUsed / 1024 / 1024;
+                         long heapCommInMBytes = m.getHeapMemoryCommitted() / 1024 / 1024;
+ 
+                         double freeHeapPct = heapMax > 0 ? ((double)((heapMax - heapUsed) * 100)) / heapMax : -1;
+ 
+                         int hosts = 0;
+                         int nodes = 0;
+                         int cpus = 0;
+ 
+                         try {
+                             ClusterMetrics metrics = metrics();
+ 
+                             Collection<ClusterNode> nodes0 = nodes();
+ 
+                             hosts = U.neighborhood(nodes0).size();
+                             nodes = nodes0.size();
+                             cpus = metrics.getTotalCpus();
+                         }
+                         catch (IgniteCheckedException ignore) {
+                             // No-op.
+                         }
+ 
+                         int pubPoolActiveThreads = 0;
+                         int pubPoolIdleThreads = 0;
+                         int pubPoolQSize = 0;
+ 
+                         ExecutorService pubExec = cfg.getExecutorService();
+ 
+                         if (pubExec instanceof ThreadPoolExecutor) {
+                             ThreadPoolExecutor exec = (ThreadPoolExecutor)pubExec;
+ 
+                             int poolSize = exec.getPoolSize();
+ 
+                             pubPoolActiveThreads = Math.min(poolSize, exec.getActiveCount());
+                             pubPoolIdleThreads = poolSize - pubPoolActiveThreads;
+                             pubPoolQSize = exec.getQueue().size();
+                         }
+ 
+                         int sysPoolActiveThreads = 0;
+                         int sysPoolIdleThreads = 0;
+                         int sysPoolQSize = 0;
+ 
+                         ExecutorService sysExec = cfg.getSystemExecutorService();
+ 
+                         if (sysExec instanceof ThreadPoolExecutor) {
+                             ThreadPoolExecutor exec = (ThreadPoolExecutor)sysExec;
+ 
+                             int poolSize = exec.getPoolSize();
+ 
+                             sysPoolActiveThreads = Math.min(poolSize, exec.getActiveCount());
+                             sysPoolIdleThreads = poolSize - sysPoolActiveThreads;
+                             sysPoolQSize = exec.getQueue().size();
+                         }
+ 
+                         String msg = NL +
+                             "Metrics for local node (to disable set 'metricsLogFrequency' to 0)" + NL +
+                             "    ^-- H/N/C [hosts=" + hosts + ", nodes=" + nodes + ", CPUs=" + cpus + "]" + NL +
+                             "    ^-- CPU [cur=" + dblFmt.format(cpuLoadPct) + "%, avg=" +
+                                 dblFmt.format(avgCpuLoadPct) + "%, GC=" + dblFmt.format(gcPct) + "%]" + NL +
+                             "    ^-- Heap [used=" + dblFmt.format(heapUsedInMBytes) + "MB, free=" +
+                                 dblFmt.format(freeHeapPct) + "%, comm=" + dblFmt.format(heapCommInMBytes) + "MB]" + NL +
+                             "    ^-- Public thread pool [active=" + pubPoolActiveThreads + ", idle=" +
+                                 pubPoolIdleThreads + ", qSize=" + pubPoolQSize + "]" + NL +
+                             "    ^-- System thread pool [active=" + sysPoolActiveThreads + ", idle=" +
+                                 sysPoolIdleThreads + ", qSize=" + sysPoolQSize + "]" + NL +
+                             "    ^-- Outbound messages queue [size=" + m.getOutboundMessagesQueueSize() + "]";
+ 
+                         log.info(msg);
+                     }
+                 }
+             }, metricsLogFreq, metricsLogFreq);
+         }
+ 
+         ctx.performance().logSuggestions(log, gridName);
+ 
+         ackBenchmarks();
+         ackVisor();
+ 
+         ackStart(rtBean);
+ 
+         if (!isDaemon())
+             ctx.discovery().ackTopology();
+ 
+         // Send node start email notification, if enabled.
+         if (isSmtpEnabled() && isAdminEmailsSet() && cfg.isLifeCycleEmailNotification()) {
+             SB sb = new SB();
+ 
+             for (GridPortRecord rec : ctx.ports().records())
+                 sb.a(rec.protocol()).a(":").a(rec.port()).a(" ");
+ 
+             String nid = localNode().id().toString().toUpperCase();
+             String nid8 = U.id8(localNode().id()).toUpperCase();
+ 
+             IgniteProductLicense lic = ctx.license().license();
+ 
+             String body =
+                 "GridGain node started with the following parameters:" + NL +
+                 NL +
+                 "----" + NL +
+                 "GridGain ver. " + COMPOUND_VER + '#' + BUILD_TSTAMP_STR + "-sha1:" + REV_HASH + NL +
+                 "Grid name: " + gridName + NL +
+                 "Node ID: " + nid + NL +
+                 "Node order: " + localNode().order() + NL +
+                 "Node addresses: " + U.addressesAsString(localNode()) + NL +
+                 "Local ports: " + sb + NL +
+                 "OS name: " + U.osString() + NL +
+                 "OS user: " + System.getProperty("user.name") + NL +
+                 "CPU(s): " + localNode().metrics().getTotalCpus() + NL +
+                 "Heap: " + U.heapSize(localNode(), 2) + "GB" + NL +
+                 "JVM name: " + U.jvmName() + NL +
+                 "JVM vendor: " + U.jvmVendor() + NL +
+                 "JVM version: " + U.jvmVersion() + NL +
+                 "VM name: " + rtBean.getName() + NL;
+ 
+             if (lic != null) {
+                 body +=
+                     "License ID: " + lic.id().toString().toUpperCase() + NL +
+                     "Licensed to: " + lic.userOrganization() + NL;
+             }
+             else
+                 assert !ENT;
+ 
+             body +=
+                 "----" + NL +
+                 NL +
+                 "NOTE:" + NL +
+                 "This message is sent automatically to all configured admin emails." + NL +
+                 "To change this behavior use 'lifeCycleEmailNotify' grid configuration property." +
+                 NL + NL +
+                 "| " + SITE + NL +
+                 "| support@gridgain.com" + NL;
+ 
+             sendAdminEmailAsync("GridGain node started: " + nid8, body, false);
+         }
+     }
+ 
+     /**
+      * Validates common configuration parameters.
+      *
+      * @param cfg Configuration.
+      */
+     private void validateCommon(IgniteConfiguration cfg) {
+         A.notNull(cfg.getNodeId(), "cfg.getNodeId()");
+ 
+         A.notNull(cfg.getMBeanServer(), "cfg.getMBeanServer()");
+         A.notNull(cfg.getGridLogger(), "cfg.getGridLogger()");
+         A.notNull(cfg.getMarshaller(), "cfg.getMarshaller()");
+         A.notNull(cfg.getExecutorService(), "cfg.getExecutorService()");
+         A.notNull(cfg.getUserAttributes(), "cfg.getUserAttributes()");
+ 
+         // All SPIs should be non-null.
+         A.notNull(cfg.getSwapSpaceSpi(), "cfg.getSwapSpaceSpi()");
+         A.notNull(cfg.getCheckpointSpi(), "cfg.getCheckpointSpi()");
+         A.notNull(cfg.getCommunicationSpi(), "cfg.getCommunicationSpi()");
+         A.notNull(cfg.getDeploymentSpi(), "cfg.getDeploymentSpi()");
+         A.notNull(cfg.getDiscoverySpi(), "cfg.getDiscoverySpi()");
+         A.notNull(cfg.getEventStorageSpi(), "cfg.getEventStorageSpi()");
+         A.notNull(cfg.getAuthenticationSpi(), "cfg.getAuthenticationSpi()");
+         A.notNull(cfg.getSecureSessionSpi(), "cfg.getSecureSessionSpi()");
+         A.notNull(cfg.getCollisionSpi(), "cfg.getCollisionSpi()");
+         A.notNull(cfg.getFailoverSpi(), "cfg.getFailoverSpi()");
+         A.notNull(cfg.getLoadBalancingSpi(), "cfg.getLoadBalancingSpi()");
+         A.notNull(cfg.getIndexingSpi(), "cfg.getIndexingSpi()");
+ 
+         A.ensure(cfg.getNetworkTimeout() > 0, "cfg.getNetworkTimeout() > 0");
+         A.ensure(cfg.getNetworkSendRetryDelay() > 0, "cfg.getNetworkSendRetryDelay() > 0");
+         A.ensure(cfg.getNetworkSendRetryCount() > 0, "cfg.getNetworkSendRetryCount() > 0");
+ 
+         if (!F.isEmpty(cfg.getPluginConfigurations())) {
+             for (PluginConfiguration pluginCfg : cfg.getPluginConfigurations())
+                 A.notNull(pluginCfg.providerClass(), "PluginConfiguration.providerClass()");
+         }
+     }
+ 
+     /**
+      * Checks whether physical RAM is not exceeded.
+      */
+     @SuppressWarnings("ConstantConditions")
+     private void checkPhysicalRam() {
+         long ram = ctx.discovery().localNode().attribute(ATTR_PHY_RAM);
+ 
+         if (ram != -1) {
+             String macs = ctx.discovery().localNode().attribute(ATTR_MACS);
+ 
+             long totalHeap = 0;
+ 
+             for (ClusterNode node : ctx.discovery().allNodes()) {
+                 if (macs.equals(node.attribute(ATTR_MACS))) {
+                     long heap = node.metrics().getHeapMemoryMaximum();
+ 
+                     if (heap != -1)
+                         totalHeap += heap;
+                 }
+             }
+ 
+             if (totalHeap > ram) {
+                 U.quietAndWarn(log, "Attempting to start more nodes than physical RAM " +
+                     "available on current host (this can cause significant slowdown)");
+             }
+         }
+     }
+ 
+     /**
+      * @param ctx Context.
+      * @param cfg Configuration to check for possible performance issues.
+      */
+     private void suggestOptimizations(GridKernalContext ctx, IgniteConfiguration cfg) {
+         GridPerformanceSuggestions perf = ctx.performance();
+ 
+         if (ctx.collision().enabled())
+             perf.add("Disable collision resolution (remove 'collisionSpi' from configuration)");
+ 
+         if (ctx.checkpoint().enabled())
+             perf.add("Disable checkpoints (remove 'checkpointSpi' from configuration)");
+ 
+         if (cfg.isPeerClassLoadingEnabled())
+             perf.add("Disable peer class loading (set 'peerClassLoadingEnabled' to false)");
+ 
+         if (cfg.isMarshalLocalJobs())
+             perf.add("Disable local jobs marshalling (set 'marshalLocalJobs' to false)");
+ 
+         if (cfg.getIncludeEventTypes() != null && cfg.getIncludeEventTypes().length != 0)
+             perf.add("Disable grid events (remove 'includeEventTypes' from configuration)");
+ 
+         if (IgniteOptimizedMarshaller.available() && !(cfg.getMarshaller() instanceof IgniteOptimizedMarshaller))
+             perf.add("Enable optimized marshaller (set 'marshaller' to " +
+                 IgniteOptimizedMarshaller.class.getSimpleName() + ')');
+     }
+ 
+     /**
+      * Warns user about unsupported features which was configured in OS edition.
+      *
+      * @param cfg Grid configuration.
+      */
+     private void warnNotSupportedFeaturesForOs(IgniteConfiguration cfg) {
+         Collection<String> msgs = new ArrayList<>();
+ 
+         if (!F.isEmpty(cfg.getSegmentationResolvers()))
+             msgs.add("Network segmentation detection.");
+ 
+         if (cfg.getSecureSessionSpi() != null && !(cfg.getSecureSessionSpi() instanceof NoopSecureSessionSpi))
+             msgs.add("Secure session SPI.");
+ 
+         if (cfg.getAuthenticationSpi() != null && !(cfg.getAuthenticationSpi() instanceof NoopAuthenticationSpi))
+             msgs.add("Authentication SPI.");
+ 
+         if (!F.isEmpty(msgs)) {
+             U.quietAndInfo(log, "The following features are not supported in open source edition, " +
+                 "related configuration settings will be ignored " +
+                 "(consider downloading enterprise edition from http://www.gridgain.com):");
+ 
+             for (String s : msgs)
+                 U.quietAndInfo(log, "  ^-- " + s);
+ 
+             U.quietAndInfo(log, "");
+         }
+     }
+ 
+     /**
+      * Creates attributes map and fills it in.
+      *
+      * @param cfg Grid configuration.
+      * @param build Build string.
+      * @return Map of all node attributes.
+      * @throws IgniteCheckedException thrown if was unable to set up attribute.
+      */
+     @SuppressWarnings({"SuspiciousMethodCalls", "unchecked", "TypeMayBeWeakened"})
+     private Map<String, Object> createNodeAttributes(IgniteConfiguration cfg, String build) throws IgniteCheckedException {
+         Map<String, Object> attrs = new HashMap<>();
+ 
+         final String[] incProps = cfg.getIncludeProperties();
+ 
+         try {
+             // Stick all environment settings into node attributes.
+             attrs.putAll(F.view(System.getenv(), new P1<String>() {
+                 @Override public boolean apply(String name) {
+                     return incProps == null || U.containsStringArray(incProps, name, true) ||
+                         U.isVisorNodeStartProperty(name) || U.isVisorRequiredProperty(name);
+                 }
+             }));
+ 
+             if (log.isDebugEnabled())
+                 log.debug("Added environment properties to node attributes.");
+         }
+         catch (SecurityException e) {
+             throw new IgniteCheckedException("Failed to add environment properties to node attributes due to " +
+                 "security violation: " + e.getMessage());
+         }
+ 
+         try {
+             // Stick all system properties into node's attributes overwriting any
+             // identical names from environment properties.
+             for (Map.Entry<Object, Object> e : F.view(System.getProperties(), new P1<Object>() {
+                 @Override public boolean apply(Object o) {
+                     String name = (String)o;
+ 
+                     return incProps == null || U.containsStringArray(incProps, name, true) ||
+                         U.isVisorRequiredProperty(name);
+                 }
+             }).entrySet()) {
+                 Object val = attrs.get(e.getKey());
+ 
+                 if (val != null && !val.equals(e.getValue()))
+                     U.warn(log, "System property will override environment variable with the same name: "
+                         + e.getKey());
+ 
+                 attrs.put((String)e.getKey(), e.getValue());
+             }
+ 
+             if (log.isDebugEnabled())
+                 log.debug("Added system properties to node attributes.");
+         }
+         catch (SecurityException e) {
+             throw new IgniteCheckedException("Failed to add system properties to node attributes due to security " +
+                 "violation: " + e.getMessage());
+         }
+ 
+         // Add local network IPs and MACs.
+         String ips = F.concat(U.allLocalIps(), ", "); // Exclude loopbacks.
+         String macs = F.concat(U.allLocalMACs(), ", "); // Only enabled network interfaces.
+ 
+         // Ack network context.
+         if (log.isInfoEnabled()) {
+             log.info("Non-loopback local IPs: " + (F.isEmpty(ips) ? "N/A" : ips));
+             log.info("Enabled local MACs: " + (F.isEmpty(macs) ? "N/A" : macs));
+         }
+ 
+         // Warn about loopback.
+         if (ips.isEmpty() && macs.isEmpty())
+             U.warn(log, "GridGain is starting on loopback address... Only nodes on the same physical " +
+                 "computer can participate in topology.",
+                 "GridGain is starting on loopback address...");
+ 
+         // Stick in network context into attributes.
+         add(attrs, ATTR_IPS, (ips.isEmpty() ? "" : ips));
+         add(attrs, ATTR_MACS, (macs.isEmpty() ? "" : macs));
+ 
+         // Stick in some system level attributes
+         add(attrs, ATTR_JIT_NAME, U.getCompilerMx() == null ? "" : U.getCompilerMx().getName());
+         add(attrs, ATTR_BUILD_VER, COMPOUND_VER);
+         add(attrs, ATTR_BUILD_DATE, build);
+         add(attrs, ATTR_COMPATIBLE_VERS, (Serializable)compatibleVersions());
+         add(attrs, ATTR_MARSHALLER, cfg.getMarshaller().getClass().getName());
+         add(attrs, ATTR_USER_NAME, System.getProperty("user.name"));
+         add(attrs, ATTR_GRID_NAME, gridName);
+ 
+         add(attrs, ATTR_PEER_CLASSLOADING, cfg.isPeerClassLoadingEnabled());
+         add(attrs, ATTR_DEPLOYMENT_MODE, cfg.getDeploymentMode());
+         add(attrs, ATTR_LANG_RUNTIME, getLanguage());
+ 
+         add(attrs, ATTR_JVM_PID, U.jvmPid());
+ 
+         // Build a string from JVM arguments, because parameters with spaces are split.
+         SB jvmArgs = new SB(512);
+ 
+         for (String arg : U.jvmArgs()) {
+             if (arg.startsWith("-"))
+                 jvmArgs.a("@@@");
+             else
+                 jvmArgs.a(' ');
+ 
+             jvmArgs.a(arg);
+         }
+         // Add it to attributes.
+         add(attrs, ATTR_JVM_ARGS, jvmArgs.toString());
+ 
+         // Check daemon system property and override configuration if it's set.
+         if (isDaemon())
+             add(attrs, ATTR_DAEMON, "true");
+ 
+         // In case of the parsing error, JMX remote disabled or port not being set
+         // node attribute won't be set.
+         if (isJmxRemoteEnabled()) {
+             String portStr = System.getProperty("com.sun.management.jmxremote.port");
+ 
+             if (portStr != null)
+                 try {
+                     add(attrs, ATTR_JMX_PORT, Integer.parseInt(portStr));
+                 }
+                 catch (NumberFormatException ignore) {
+                     // No-op.
+                 }
+         }
+ 
+         // Whether restart is enabled and stick the attribute.
+         add(attrs, ATTR_RESTART_ENABLED, Boolean.toString(isRestartEnabled()));
+ 
+         // Save port range, port numbers will be stored by rest processor at runtime.
+         if (cfg.getClientConnectionConfiguration() != null)
+             add(attrs, ATTR_REST_PORT_RANGE, cfg.getClientConnectionConfiguration().getRestPortRange());
+ 
+         try {
+             AuthenticationSpi authSpi = cfg.getAuthenticationSpi();
+ 
+             boolean securityEnabled = authSpi != null && !U.hasAnnotation(authSpi.getClass(), IgniteSpiNoop.class);
+ 
+             GridSecurityCredentialsProvider provider = cfg.getSecurityCredentialsProvider();
+ 
+             if (provider != null) {
+                 GridSecurityCredentials cred = provider.credentials();
+ 
+                 if (cred != null)
+                     add(attrs, ATTR_SECURITY_CREDENTIALS, cred);
+                 else if (securityEnabled)
+                     throw new IgniteCheckedException("Failed to start node (authentication SPI is configured, " +
+                         "by security credentials provider returned null).");
+             }
+             else if (securityEnabled)
+                 throw new IgniteCheckedException("Failed to start node (authentication SPI is configured, " +
+                     "but security credentials provider is not set. Fix the configuration and restart the node).");
+         }
+         catch (IgniteCheckedException e) {
+             throw new IgniteCheckedException("Failed to create node security credentials", e);
+         }
+ 
+         // Stick in SPI versions and classes attributes.
+         addAttributes(attrs, cfg.getCollisionSpi());
+         addAttributes(attrs, cfg.getSwapSpaceSpi());
+         addAttributes(attrs, cfg.getDiscoverySpi());
+         addAttributes(attrs, cfg.getFailoverSpi());
+         addAttributes(attrs, cfg.getCommunicationSpi());
+         addAttributes(attrs, cfg.getEventStorageSpi());
+         addAttributes(attrs, cfg.getCheckpointSpi());
+         addAttributes(attrs, cfg.getLoadBalancingSpi());
+         addAttributes(attrs, cfg.getAuthenticationSpi());
+         addAttributes(attrs, cfg.getSecureSessionSpi());
+         addAttributes(attrs, cfg.getDeploymentSpi());
+ 
+         // Set user attributes for this node.
+         if (cfg.getUserAttributes() != null) {
+             for (Map.Entry<String, ?> e : cfg.getUserAttributes().entrySet()) {
+                 if (attrs.containsKey(e.getKey()))
+                     U.warn(log, "User or internal attribute has the same name as environment or system " +
+                         "property and will take precedence: " + e.getKey());
+ 
+                 attrs.put(e.getKey(), e.getValue());
+             }
+         }
+ 
+         return attrs;
+     }
+ 
+     /**
+      * Add SPI version and class attributes into node attributes.
+      *
+      * @param attrs Node attributes map to add SPI attributes to.
+      * @param spiList Collection of SPIs to get attributes from.
+      * @throws IgniteCheckedException Thrown if was unable to set up attribute.
+      */
+     private void addAttributes(Map<String, Object> attrs, IgniteSpi... spiList) throws IgniteCheckedException {
+         for (IgniteSpi spi : spiList) {
+             Class<? extends IgniteSpi> spiCls = spi.getClass();
+ 
+             add(attrs, U.spiAttribute(spi, ATTR_SPI_CLASS), spiCls.getName());
+         }
+     }
+ 
+     /** @throws IgniteCheckedException If registration failed. */
+     private void registerKernalMBean() throws IgniteCheckedException {
+         try {
+             kernalMBean = U.registerMBean(
+                 cfg.getMBeanServer(),
+                 cfg.getGridName(),
+                 "Kernal",
+                 getClass().getSimpleName(),
+                 this,
+                 IgniteMXBean.class);
+ 
+             if (log.isDebugEnabled())
+                 log.debug("Registered kernal MBean: " + kernalMBean);
+         }
+         catch (JMException e) {
+             kernalMBean = null;
+ 
+             throw new IgniteCheckedException("Failed to register kernal MBean.", e);
+         }
+     }
+ 
+     /** @throws IgniteCheckedException If registration failed. */
+     private void registerLocalNodeMBean() throws IgniteCheckedException {
+         ClusterLocalNodeMetricsMXBean mbean = new ClusterLocalNodeMetricsMXBeanImpl(ctx.discovery().localNode());
+ 
+         try {
+             locNodeMBean = U.registerMBean(
+                 cfg.getMBeanServer(),
+                 cfg.getGridName(),
+                 "Kernal",
+                 mbean.getClass().getSimpleName(),
+                 mbean,
+                 ClusterLocalNodeMetricsMXBean.class);
+ 
+             if (log.isDebugEnabled())
+                 log.debug("Registered local node MBean: " + locNodeMBean);
+         }
+         catch (JMException e) {
+             locNodeMBean = null;
+ 
+             throw new IgniteCheckedException("Failed to register local node MBean.", e);
+         }
+     }
+ 
+     /** @throws IgniteCheckedException If registration failed. */
+     private void registerExecutorMBeans() throws IgniteCheckedException {
+         pubExecSvcMBean = registerExecutorMBean(cfg.getExecutorService(), "GridExecutionExecutor");
+         sysExecSvcMBean = registerExecutorMBean(cfg.getSystemExecutorService(), "GridSystemExecutor");
+         mgmtExecSvcMBean = registerExecutorMBean(cfg.getManagementExecutorService(), "GridManagementExecutor");
+         p2PExecSvcMBean = registerExecutorMBean(cfg.getPeerClassLoadingExecutorService(), "GridClassLoadingExecutor");
+ 
+         ClientConnectionConfiguration clientCfg = cfg.getClientConnectionConfiguration();
+ 
+         if (clientCfg != null) {
+             restExecSvcMBean = clientCfg.getRestExecutorService() != null ?
+                 registerExecutorMBean(clientCfg.getRestExecutorService(), "GridRestExecutor") : null;
+         }
+     }
+ 
+     /**
+      * @param exec Executor service to register.
+      * @param name Property name for executor.
+      * @return Name for created MBean.
+      * @throws IgniteCheckedException If registration failed.
+      */
+     private ObjectName registerExecutorMBean(ExecutorService exec, String name) throws IgniteCheckedException {
+         assert exec != null;
+ 
+         try {
+             ObjectName res = U.registerMBean(
+                 cfg.getMBeanServer(),
+                 cfg.getGridName(),
+                 "Thread Pools",
+                 name,
+                 new IgniteThreadPoolMXBeanAdapter(exec),
+                 IgniteThreadPoolMXBean.class);
+ 
+             if (log.isDebugEnabled())
+                 log.debug("Registered executor service MBean: " + res);
+ 
+             return res;
+         }
+         catch (JMException e) {
+             throw new IgniteCheckedException("Failed to register executor service MBean [name=" + name + ", exec=" + exec + ']',
+                 e);
+         }
+     }
+ 
+     /**
+      * Unregisters given mbean.
+      *
+      * @param mbean MBean to unregister.
+      * @return {@code True} if successfully unregistered, {@code false} otherwise.
+      */
+     private boolean unregisterMBean(@Nullable ObjectName mbean) {
+         if (mbean != null)
+             try {
+                 cfg.getMBeanServer().unregisterMBean(mbean);
+ 
+                 if (log.isDebugEnabled())
+                     log.debug("Unregistered MBean: " + mbean);
+ 
+                 return true;
+             }
+             catch (JMException e) {
+                 U.error(log, "Failed to unregister MBean.", e);
+ 
+                 return false;
+             }
+ 
+         return true;
+     }
+ 
+     /**
+      * @param ctx Kernal context.
+      * @param mgr Manager to start.
+      * @param attrs SPI attributes to set.
+      * @throws IgniteCheckedException Throw in case of any errors.
+      */
+     private void startManager(GridKernalContextImpl ctx, GridManager mgr, Map<String, Object> attrs)
+         throws IgniteCheckedException {
+         mgr.addSpiAttributes(attrs);
+ 
+         // Set all node attributes into discovery manager,
+         // so they can be distributed to all nodes.
+         if (mgr instanceof GridDiscoveryManager)
+             ((GridDiscoveryManager)mgr).setNodeAttributes(attrs, ctx.product().version());
+ 
+         // Add manager to registry before it starts to avoid
+         // cases when manager is started but registry does not
+         // have it yet.
+         ctx.add(mgr);
+ 
+         try {
+             mgr.start();
+         }
+         catch (IgniteCheckedException e) {
+             throw new IgniteCheckedException("Failed to start manager: " + mgr, e);
+         }
+     }
+ 
+     /**
+      * @param ctx Kernal context.
+      * @param proc Processor to start.
+      * @param attrs Attributes.
+      * @throws IgniteCheckedException Thrown in case of any error.
+      */
+     private void startProcessor(GridKernalContextImpl ctx, GridProcessor proc, Map<String, Object> attrs)
+         throws IgniteCheckedException {
+         ctx.add(proc);
+ 
+         try {
+             proc.start();
+ 
+             proc.addAttributes(attrs);
+         }
+         catch (IgniteCheckedException e) {
+             throw new IgniteCheckedException("Failed to start processor: " + proc, e);
+         }
+     }
+ 
+     /**
+      * Add helper.
+      *
+      * @param ctx Context.
+      * @param helper Helper.
+      */
+     private void addHelper(GridKernalContextImpl ctx, Object helper) {
+         ctx.addHelper(helper);
+     }
+ 
+     /**
+      * Gets "on" or "off" string for given boolean value.
+      *
+      * @param b Boolean value to convert.
+      * @return Result string.
+      */
+     private String onOff(boolean b) {
+         return b ? "on" : "off";
+     }
+ 
+     /**
+      *
+      * @return Whether or not REST is enabled.
+      */
+     private boolean isRestEnabled() {
+         assert cfg != null;
+ 
+         return cfg.getClientConnectionConfiguration() != null;
+     }
+ 
+     /**
+      * Acks remote management.
+      */
+     private void ackRemoteManagement() {
+         assert log != null;
+ 
+         if (!log.isInfoEnabled())
+             return;
+ 
+         SB sb = new SB();
+ 
+         sb.a("Remote Management [");
+ 
+         boolean on = isJmxRemoteEnabled();
+ 
+         sb.a("restart: ").a(onOff(isRestartEnabled())).a(", ");
+         sb.a("REST: ").a(onOff(isRestEnabled())).a(", ");
+         sb.a("JMX (");
+         sb.a("remote: ").a(onOff(on));
+ 
+         if (on) {
+             sb.a(", ");
+ 
+             sb.a("port: ").a(System.getProperty("com.sun.management.jmxremote.port", "<n/a>")).a(", ");
+             sb.a("auth: ").a(onOff(Boolean.getBoolean("com.sun.management.jmxremote.authenticate"))).a(", ");
+ 
+             // By default SSL is enabled, that's why additional check for null is needed.
+             // See http://docs.oracle.com/javase/6/docs/technotes/guides/management/agent.html
+             sb.a("ssl: ").a(onOff(Boolean.getBoolean("com.sun.management.jmxremote.ssl") ||
+                 System.getProperty("com.sun.management.jmxremote.ssl") == null));
+         }
+ 
+         sb.a(")");
+ 
+         sb.a(']');
+ 
+         log.info(sb.toString());
+     }
+ 
+     /**
+      * Acks configuration URL.
+      */
+     private void ackConfigUrl() {
+         assert log != null;
+ 
+         if (log.isInfoEnabled())
 -            log.info("Config URL: " + System.getProperty(GG_CONFIG_URL, "n/a"));
++            log.info("Config URL: " + System.getProperty(IGNITE_CONFIG_URL, "n/a"));
+     }
+ 
+     /**
+      * Acks Visor instructions.
+      */
+     private void ackVisor() {
+         assert log != null;
+ 
+         if (isDaemon())
+             return;
+ 
+         if (ctx.isEnterprise())
+             U.quietAndInfo(log, "To start GUI Management & Monitoring run ggvisorui.{sh|bat}");
+         else
+             U.quietAndInfo(log, "To start Console Management & Monitoring run ggvisorcmd.{sh|bat}");
+     }
+ 
+     /**
+      * Acks benchmarking instructions.
+      */
+     private void ackBenchmarks() {
+         if (!isDaemon())
+             U.quietAndInfo(log, "If running benchmarks, see http://bit.ly/GridGain-Benchmarking");
+     }
+ 
+     /**
+      * Acks ASCII-logo. Thanks to http://patorjk.com/software/taag
+      */
+     private void ackAsciiLogo() {
+         assert log != null;
+ 
+         String fileName = log.fileName();
+ 
 -        if (System.getProperty(GG_NO_ASCII) == null) {
++        if (System.getProperty(IGNITE_NO_ASCII) == null) {
+             String ver = "ver. " + ACK_VER;
+ 
+             // Big thanks to: http://patorjk.com/software/taag
+             // Font name "Small Slant"
+             if (log.isQuiet()) {
+                 U.quiet(false,
+                     "   __________  ________________ ",
+                     "  /  _/ ___/ |/ /  _/_  __/ __/ ",
+                     " _/ // (_ /    // /  / / / _/   ",
+                     "/___/\\___/_/|_/___/ /_/ /___/  ",
+                     " ",
+                     ver,
+                     COPYRIGHT,
+                     "",
+                     "Quiet mode.");
+ 
+                 if (fileName != null)
+                     U.quiet(false, "  ^-- Logging to file '" +  fileName + '\'');
+ 
+                 U.quiet(false,
 -                    "  ^-- To see **FULL** console log here add -DGRIDGAIN_QUIET=false or \"-v\" to ggstart.{sh|bat}",
++                    "  ^-- To see **FULL** console log here add -DIGNITE_QUIET=false or \"-v\" to ggstart.{sh|bat}",
+                     "");
+             }
+ 
+             if (log.isInfoEnabled()) {
+                 log.info(NL + NL +
+                     ">>>    __________  ________________  " + NL +
+                     ">>>   /  _/ ___/ |/ /  _/_  __/ __/  " + NL +
+                     ">>>  _/ // (_ /    // /  / / / _/    " + NL +
+                     ">>> /___/\\___/_/|_/___/ /_/ /___/   " + NL +
+                     ">>> " + NL +
+                     ">>> " + ver + NL +
+                     ">>> " + COPYRIGHT + NL
+                 );
+             }
+         }
+     }
+ 
+     /**
+      * Prints start info.
+      *
+      * @param rtBean Java runtime bean.
+      */
+     private void ackStart(RuntimeMXBean rtBean) {
+         if (log.isQuiet()) {
+             U.quiet(false, "");
+             U.quiet(false, "GridGain node started OK (id=" + U.id8(localNode().id()) +
+                 (F.isEmpty(gridName) ? "" : ", grid=" + gridName) + ')');
+         }
+ 
+         if (log.isInfoEnabled()) {
+             log.info("");
+ 
+             String ack = "GridGain ver. " + COMPOUND_VER + '#' + BUILD_TSTAMP_STR + "-sha1:" + REV_HASH;
+ 
+             String dash = U.dash(ack.length());
+ 
+             SB sb = new SB();
+ 
+             for (GridPortRecord rec : ctx.ports().records())
+                 sb.a(rec.protocol()).a(":").a(rec.port()).a(" ");
+ 
+             String str =
+                 NL + NL +
+                     ">>> " + dash + NL +
+                     ">>> " + ack + NL +
+                     ">>> " + dash + NL +
+                     ">>> OS name: " + U.osString() + NL +
+                     ">>> CPU(s): " + localNode().metrics().getTotalCpus() + NL +
+                     ">>> Heap: " + U.heapSize(localNode(), 2) + "GB" + NL +
+                     ">>> VM name: " + rtBean.getName() + NL +
+                     ">>> Grid name: " + gridName + NL +
+                     ">>> Local node [" +
+                     "ID=" + localNode().id().toString().toUpperCase() +
+                     ", order=" + localNode().order() +
+                     "]" + NL +
+                     ">>> Local node addresses: " + U.addressesAsString(localNode()) + NL +
+                     ">>> Local ports: " + sb + NL;
+ 
+             str += ">>> GridGain documentation: http://" + SITE + "/documentation" + NL;
+ 
+             log.info(str);
+         }
+     }
+ 
+     /**
+      * Logs out OS information.
+      */
+     private void ackOsInfo() {
+         assert log != null;
+ 
+         if (log.isInfoEnabled()) {
+             log.info("OS: " + U.osString());
+             log.info("OS user: " + System.getProperty("user.name"));
+         }
+     }
+ 
+     /**
+      * Logs out language runtime.
+      */
+     private void ackLanguageRuntime() {
+         assert log != null;
+ 
+         if (log.isInfoEnabled()) {
+             log.info("Language runtime: " + getLanguage());
+             log.info("VM information: " + U.jdkString());
+             log.info("VM total memory: " + U.heapSize(2) + "GB");
+         }
+     }
+ 
+     /**
+      * @return Language runtime.
+      */
+     @SuppressWarnings("ThrowableInstanceNeverThrown")
+     private String getLanguage() {
+         boolean scala = false;
+         boolean groovy = false;
+         boolean clojure = false;
+ 
+         for (StackTraceElement elem : Thread.currentThread().getStackTrace()) {
+             String s = elem.getClassName().toLowerCase();
+ 
+             if (s.contains("scala")) {
+                 scala = true;
+ 
+                 break;
+             }
+             else if (s.contains("groovy")) {
+                 groovy = true;
+ 
+                 break;
+             }
+             else if (s.contains("clojure")) {
+                 clojure = true;
+ 
+                 break;
+             }
+         }
+ 
+         if (scala) {
+             try (InputStream in = getClass().getResourceAsStream("/library.properties")) {
+                 Properties props = new Properties();
+ 
+                 if (in != null)
+                     props.load(in);
+ 
+                 return "Scala ver. " + props.getProperty("version.number", "<unknown>");
+             }
+             catch (Throwable ignore) {
+                 return "Scala ver. <unknown>";
+             }
+         }
+ 
+         // How to get Groovy and Clojure version at runtime?!?
+         return groovy ? "Groovy" : clojure ? "Clojure" : U.jdkName() + " ver. " + U.jdkVersion();
+     }
+ 
+     /**
+      * Stops grid instance.
+      *
+      * @param cancel Whether or not to cancel running jobs.
+      */
+     public void stop(boolean cancel) {
+         // Make sure that thread stopping grid is not interrupted.
+         boolean interrupted = Thread.interrupted();
+ 
+         try {
+             stop0(cancel);
+         }
+         finally {
+             if (interrupted)
+                 Thread.currentThread().interrupt();
+         }
+     }
+ 
+     /**
+      * @param cancel Whether or not to cancel running jobs.
+      */
+     private void stop0(boolean cancel) {
+         String nid = getLocalNodeId().toString().toUpperCase();
+         String nid8 = U.id8(getLocalNodeId()).toUpperCase();
+ 
+         gw.compareAndSet(null, new GridKernalGatewayImpl(gridName));
+ 
+         GridKernalGateway gw = this.gw.get();
+ 
+         if (stopGuard.compareAndSet(false, true)) {
+             // Only one thread is allowed to perform stop sequence.
+             boolean firstStop = false;
+ 
+             GridKernalState state = gw.getState();
+ 
+             if (state == STARTED)
+                 firstStop = true;
+             else if (state == STARTING)
+                 U.warn(log, "Attempt to stop starting grid. This operation " +
+                     "cannot be guaranteed to be successful.");
+ 
+             if (firstStop) {
+                 // Notify lifecycle beans.
+                 if (log.isDebugEnabled())
+                     log.debug("Notifying lifecycle beans.");
+ 
+                 notifyLifecycleBeansEx(LifecycleEventType.BEFORE_GRID_STOP);
+             }
+ 
+             IgniteEmailProcessorAdapter email = ctx.email();
+ 
+             List<GridComponent> comps = ctx.components();
+ 
+             // Callback component in reverse order while kernal is still functional
+             // if called in the same thread, at least.
+             for (ListIterator<GridComponent> it = comps.listIterator(comps.size()); it.hasPrevious();) {
+                 GridComponent comp = it.previous();
+ 
+                 try {
+                     comp.onKernalStop(cancel);
+                 }
+                 catch (Throwable e) {
+                     errOnStop = true;
+ 
+                     U.error(log, "Failed to pre-stop processor: " + comp, e);
+                 }
+             }
+ 
+             // Cancel update notification timer.
+             if (updateNtfTimer != null)
+                 updateNtfTimer.cancel();
+ 
+             if (starveTimer != null)
+                 starveTimer.cancel();
+ 
+             // Cancel license timer.
+             if (licTimer != null)
+                 licTimer.cancel();
+ 
+             // Cancel metrics log timer.
+             if (metricsLogTimer != null)
+                 metricsLogTimer.cancel();
+ 
+             gw.writeLock();
+ 
+             try {
+                 assert gw.getState() == STARTED || gw.getState() == STARTING;
+ 
+                 // No more kernal calls from this point on.
+                 gw.setState(STOPPING);
+ 
+                 // Clear node local store.
+                 nodeLoc.clear();
+ 
+                 if (log.isDebugEnabled())
+                     log.debug("Grid " + (gridName == null ? "" : '\'' + gridName + "' ") + "is stopping.");
+             }
+             finally {
+                 gw.writeUnlock();
+             }
+ 
+             // Unregister MBeans.
+             if (!(
+                 unregisterMBean(pubExecSvcMBean) &
+                     unregisterMBean(sysExecSvcMBean) &
+                     unregisterMBean(mgmtExecSvcMBean) &
+                     unregisterMBean(p2PExecSvcMBean) &
+                     unregisterMBean(kernalMBean) &
+                     unregisterMBean(locNodeMBean) &
+                     unregisterMBean(restExecSvcMBean)
+             ))
+                 errOnStop = false;
+ 
+             // Stop components in reverse order.
+             for (ListIterator<GridComponent> it = comps.listIterator(comps.size()); it.hasPrevious();) {
+                 GridComponent comp = it.previous();
+ 
+                 try {
+                     comp.stop(cancel);
+ 
+                     if (log.isDebugEnabled())
+                         log.debug("Component stopped: " + comp);
+                 }
+                 catch (Throwable e) {
+                     errOnStop = true;
+ 
+                     U.error(log, "Failed to stop component (ignoring): " + comp, e);
+                 }
+             }
+ 
+             // Stops lifecycle aware components.
+             U.stopLifecycleAware(log, lifecycleAwares(cfg));
+ 
+             // Lifecycle notification.
+             notifyLifecycleBeansEx(LifecycleEventType.AFTER_GRID_STOP);
+ 
+             // Clean internal class/classloader caches to avoid stopped contexts held in memory.
+             IgniteOptimizedMarshaller.clearCache();
+             IgniteMarshallerExclusions.clearCache();
+             GridEnumCache.clear();
+ 
+             gw.writeLock();
+ 
+             try {
+                 gw.setState(STOPPED);
+             }
+             finally {
+                 gw.writeUnlock();
+             }
+ 
+             // Ack stop.
+             if (log.isQuiet()) {
+                 if (!errOnStop)
+                     U.quiet(false, "GridGain node stopped OK [uptime=" +
+                         X.timeSpan2HMSM(U.currentTimeMillis() - startTime) + ']');
+                 else
+                     U.quiet(true, "GridGain node stopped wih ERRORS [uptime=" +
+                         X.timeSpan2HMSM(U.currentTimeMillis() - startTime) + ']');
+             }
+ 
+             if (log.isInfoEnabled())
+                 if (!errOnStop) {
+                     String ack = "GridGain ver. " + COMPOUND_VER + '#' + BUILD_TSTAMP_STR + "-sha1:" + REV_HASH +
+                         " stopped OK";
+ 
+                     String dash = U.dash(ack.length());
+ 
+                     log.info(NL + NL +
+                         ">>> " + dash + NL +
+                         ">>> " + ack + NL +
+                         ">>> " + dash + NL +
+                         ">>> Grid name: " + gridName + NL +
+                         ">>> Grid uptime: " + X.timeSpan2HMSM(U.currentTimeMillis() - startTime) +
+                         NL +
+                         NL);
+                 }
+                 else {
+                     String ack = "GridGain ver. " + COMPOUND_VER + '#' + BUILD_TSTAMP_STR + "-sha1:" + REV_HASH +
+                         " stopped with ERRORS";
+ 
+                     String dash = U.dash(ack.length());
+ 
+                     log.info(NL + NL +
+                         ">>> " + ack + NL +
+                         ">>> " + dash + NL +
+                         ">>> Grid name: " + gridName + NL +
+                         ">>> Grid uptime: " + X.timeSpan2HMSM(U.currentTimeMillis() - startTime) +
+                         NL +
+                         ">>> See log above for detailed error message." + NL +
+                         ">>> Note that some errors during stop can prevent grid from" + NL +
+                         ">>> maintaining correct topology since this node may have" + NL +
+                         ">>> not exited grid properly." + NL +
+                         NL);
+                 }
+ 
+             // Send node start email notification, if enabled.
+             if (isSmtpEnabled() && isAdminEmailsSet() && cfg.isLifeCycleEmailNotification()) {
+                 String errOk = errOnStop ? "with ERRORS" : "OK";
+ 
+                 String headline = "GridGain ver. " + COMPOUND_VER + '#' + BUILD_TSTAMP_STR +
+                     " stopped " + errOk + ":";
+                 String subj = "GridGain node stopped " + errOk + ": " + nid8;
+ 
+                 IgniteProductLicense lic = ctx.license() != null ? ctx.license().license() : null;
+ 
+                 String body =
+                     headline + NL + NL +
+                     "----" + NL +
+                     "GridGain ver. " + COMPOUND_VER + '#' + BUILD_TSTAMP_STR + "-sha1:" + REV_HASH + NL +
+                     "Grid name: " + gridName + NL +
+                     "Node ID: " + nid + NL +
+                     "Node uptime: " + X.timeSpan2HMSM(U.currentTimeMillis() - startTime) + NL;
+ 
+                 if (lic != null) {
+                     body +=
+                         "License ID: " + lic.id().toString().toUpperCase() + NL +
+                         "Licensed to: " + lic.userOrganization() + NL;
+                 }
+                 else
+                     assert !ENT;
+ 
+                 body +=
+                     "----" + NL +
+                     NL +
+                     "NOTE:" + NL +
+                     "This message is sent automatically to all configured admin emails." + NL +
+                     "To change this behavior use 'lifeCycleEmailNotify' grid configuration property.";
+ 
+                 if (errOnStop)
+                     body +=
+                         NL + NL +
+                             "NOTE:" + NL +
+                             "See node's log for detailed error message." + NL +
+                             "Some errors during stop can prevent grid from" + NL +
+                             "maintaining correct topology since this node may " + NL +
+                             "have not exited grid properly.";
+ 
+                 body +=
+                     NL + NL +
+                         "| " + SITE + NL +
+                         "| support@gridgain.com" + NL;
+ 
+                 if (email != null) {
+                     try {
+                         email.sendNow(subj,
+                             body,
+                             false,
+                             Arrays.asList(cfg.getAdminEmails()));
+                     }
+                     catch (IgniteCheckedException e) {
+                         U.error(log, "Failed to send lifecycle email notification.", e);
+                     }
+                 }
+             }
+ 
+             U.onGridStop();
+         }
+         else {
+             // Proper notification.
+             if (log.isDebugEnabled()) {
+                 if (gw.getState() == STOPPED)
+                     log.debug("Grid is already stopped. Nothing to do.");
+                 else
+                     log.debug("Grid is being stopped by another thread. Aborting this stop sequence " +
+                         "allowing other thread to finish.");
+             }
+         }
+     }
+ 
+     /**
+      * USED ONLY FOR TESTING.
+      *
+      * @param <K> Key type.
+      * @param <V> Value type.
+      * @return Internal cache instance.
+      */
+     /*@java.test.only*/
+     public <K, V> GridCacheAdapter<K, V> internalCache() {
+         return internalCache(null);
+     }
+ 
+     /**
+      * USED ONLY FOR TESTING.
+      *
+      * @param name Cache name.
+      * @param <K>  Key type.
+      * @param <V>  Value type.
+      * @return Internal cache instance.
+      */
+     /*@java.test.only*/
+     public <K, V> GridCacheAdapter<K, V> internalCache(@Nullable String name) {
+         return ctx.cache().internalCache(name);
+     }
+ 
+     /**
+      * It's intended for use by internal marshalling implementation only.
+      *
+      * @return Kernal context.
+      */
+     public GridKernalContext context() {
+         return ctx;
+     }
+ 
+     /**
+      * Prints all system properties in debug mode.
+      */
+     private void ackSystemProperties() {
+         assert log != null;
+ 
+         if (log.isDebugEnabled())
+             for (Object key : U.asIterable(System.getProperties().keys()))
+                 log.debug("System property [" + key + '=' + System.getProperty((String) key) + ']');
+     }
+ 
+     /**
+      * Prints all user attributes in info mode.
+      */
+     private void logNodeUserAttributes() {
+         assert log != null;
+ 
+         if (log.isInfoEnabled())
+             for (Map.Entry<?, ?> attr : cfg.getUserAttributes().entrySet())
+                 log.info("Local node user attribute [" + attr.getKey() + '=' + attr.getValue() + ']');
+     }
+ 
+     /**
+      * Prints all environment variables in debug mode.
+      */
+     private void ackEnvironmentVariables() {
+         assert log != null;
+ 
+         if (log.isDebugEnabled())
+             for (Map.Entry<?, ?> envVar : System.getenv().entrySet())
+                 log.debug("Environment variable [" + envVar.getKey() + '=' + envVar.getValue() + ']');
+     }
+ 
+     /**
+      * Acks daemon mode status.
+      */
+     private void ackDaemon() {
+         assert log != null;
+ 
+         if (log.isInfoEnabled())
+             log.info("Daemon mode: " + (isDaemon() ? "on" : "off"));
+     }
+ 
+     /**
+      *
+      * @return {@code True} is this node is daemon.
+      */
+     private boolean isDaemon() {
+         assert cfg != null;
+ 
 -        return cfg.isDaemon() || "true".equalsIgnoreCase(System.getProperty(GG_DAEMON));
++        return cfg.isDaemon() || "true".equalsIgnoreCase(System.getProperty(IGNITE_DAEMON));
+     }
+ 
+     /**
+      * Whether or not remote JMX management is enabled for this node. Remote JMX management is
+      * enabled when the following system property is set:
+      * <ul>
+      *     <li>{@code com.sun.management.jmxremote}</li>
+      * </ul>
+      *
+      * @return {@code True} if remote JMX management is enabled - {@code false} otherwise.
+      */
+     @Override public boolean isJmxRemoteEnabled() {
+         return System.getProperty("com.sun.management.jmxremote") != null;
+     }
+ 
+     /**
+      * Whether or not node restart is enabled. Node restart us supported when this node was started
+      * with {@code bin/ggstart.{sh|bat}} script using {@code -r} argument. Node can be
+      * programmatically restarted using {@link org.apache.ignite.Ignition#restart(boolean)}} method.
+      *
+      * @return {@code True} if restart mode is enabled, {@code false} otherwise.
+      * @see org.apache.ignite.Ignition#restart(boolean)
+      */
+     @Override public boolean isRestartEnabled() {
 -        return System.getProperty(GG_SUCCESS_FILE) != null;
++        return System.getProperty(IGNITE_SUCCESS_FILE) != null;
+     }
+ 
+     /**
+      * Whether or not SMTP is configured. Note that SMTP is considered configured if
+      * SMTP host is provided in configuration (see {@link org.apache.ignite.configuration.IgniteConfiguration#getSmtpHost()}.
+      * <p>
+      * If SMTP is not configured all emails notifications will be disabled.
+      *
+      * @return {@code True} if SMTP is configured - {@code false} otherwise.
+      * @see org.apache.ignite.configuration.IgniteConfiguration#getSmtpFromEmail()
+      * @see org.apache.ignite.configuration.IgniteConfiguration#getSmtpHost()
+      * @see org.apache.ignite.configuration.IgniteConfiguration#getSmtpPassword()
+      * @see org.apache.ignite.configuration.IgniteConfiguration#getSmtpPort()
+      * @see org.apache.ignite.configuration.IgniteConfiguration#getSmtpUsername()
+      * @see org.apache.ignite.configuration.IgniteConfiguration#isSmtpSsl()
+      * @see org.apache.ignite.configuration.IgniteConfiguration#isSmtpStartTls()
+      * @see #sendAdminEmailAsync(String, String, boolean)
+      */
+     @Override public boolean isSmtpEnabled() {
+         assert cfg != null;
+ 
+         return cfg.getSmtpHost() != null;
+     }
+ 
+     /**
+      * Prints all configuration properties in info mode and SPIs in debug mode.
+      */
+     private void ackSpis() {
+         assert log != null;
+ 
+         if (log.isDebugEnabled()) {
+             log.debug("+-------------+");
+             log.debug("START SPI LIST:");
+             log.debug("+-------------+");
+             log.debug("Grid checkpoint SPI     : " + Arrays.toString(cfg.getCheckpointSpi()));
+             log.debug("Grid collision SPI      : " + cfg.getCollisionSpi());
+             log.debug("Grid communication SPI  : " + cfg.getCommunicationSpi());
+             log.debug("Grid deployment SPI     : " + cfg.getDeploymentSpi());
+             log.debug("Grid discovery SPI      : " + cfg.getDiscoverySpi());
+             log.debug("Grid event storage SPI  : " + cfg.getEventStorageSpi());
+             log.debug("Grid failover SPI       : " + Arrays.toString(cfg.getFailoverSpi()));
+           

<TRUNCATED>

Mime
View raw message