http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/c5247ab3/modules/core/src/main/java/org/apache/ignite/internal/IgnitionEx.java ---------------------------------------------------------------------- diff --git a/modules/core/src/main/java/org/apache/ignite/internal/IgnitionEx.java b/modules/core/src/main/java/org/apache/ignite/internal/IgnitionEx.java new file mode 100644 index 0000000..acab6d0 --- /dev/null +++ b/modules/core/src/main/java/org/apache/ignite/internal/IgnitionEx.java @@ -0,0 +1,2399 @@ +/* + * 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.rendezvous.*; +import org.apache.ignite.configuration.*; +import org.apache.ignite.fs.*; +import org.apache.ignite.internal.util.*; +import org.apache.ignite.lang.*; +import org.apache.ignite.lifecycle.*; +import org.apache.ignite.logger.*; +import org.apache.ignite.logger.java.*; +import org.apache.ignite.marshaller.*; +import org.apache.ignite.marshaller.jdk.*; +import org.apache.ignite.marshaller.optimized.*; +import org.apache.ignite.mxbean.*; +import org.apache.ignite.spi.*; +import org.apache.ignite.spi.authentication.*; +import org.apache.ignite.spi.authentication.noop.*; +import org.apache.ignite.spi.indexing.*; +import org.apache.ignite.streamer.*; +import org.apache.ignite.thread.*; +import org.apache.ignite.internal.processors.resource.*; +import org.apache.ignite.internal.processors.spring.*; +import org.apache.ignite.plugin.segmentation.*; +import org.apache.ignite.spi.checkpoint.*; +import org.apache.ignite.spi.checkpoint.noop.*; +import org.apache.ignite.spi.collision.*; +import org.apache.ignite.spi.collision.noop.*; +import org.apache.ignite.spi.communication.*; +import org.apache.ignite.spi.communication.tcp.*; +import org.apache.ignite.spi.deployment.*; +import org.apache.ignite.spi.deployment.local.*; +import org.apache.ignite.spi.discovery.*; +import org.apache.ignite.spi.discovery.tcp.*; +import org.apache.ignite.spi.discovery.tcp.ipfinder.multicast.*; +import org.apache.ignite.spi.eventstorage.*; +import org.apache.ignite.spi.eventstorage.memory.*; +import org.apache.ignite.spi.failover.*; +import org.apache.ignite.spi.failover.always.*; +import org.apache.ignite.spi.loadbalancing.*; +import org.apache.ignite.spi.loadbalancing.roundrobin.*; +import org.apache.ignite.spi.securesession.*; +import org.apache.ignite.spi.securesession.noop.*; +import org.apache.ignite.spi.swapspace.*; +import org.apache.ignite.spi.swapspace.file.*; +import org.apache.ignite.spi.swapspace.noop.*; +import org.apache.ignite.internal.util.typedef.*; +import org.apache.ignite.internal.util.typedef.internal.*; +import org.jdk8.backport.*; +import org.jetbrains.annotations.*; + +import javax.management.*; +import java.io.*; +import java.lang.management.*; +import java.lang.reflect.*; +import java.net.*; +import java.util.*; +import java.util.Map.*; +import java.util.concurrent.*; +import java.util.concurrent.atomic.*; +import java.util.logging.*; + +import static org.apache.ignite.configuration.IgniteConfiguration.*; +import static org.apache.ignite.IgniteState.*; +import static org.apache.ignite.IgniteSystemProperties.*; +import static org.apache.ignite.cache.CacheAtomicityMode.*; +import static org.apache.ignite.cache.CacheDistributionMode.*; +import static org.apache.ignite.cache.CacheMode.*; +import static org.apache.ignite.cache.CachePreloadMode.*; +import static org.apache.ignite.cache.CacheWriteSynchronizationMode.*; +import static org.apache.ignite.internal.IgniteComponentType.*; +import static org.apache.ignite.plugin.segmentation.GridSegmentationPolicy.*; + +/** + * This class defines a factory for the main GridGain API. It controls Grid life cycle + * and allows listening for grid events. + * <h1 class="header">Grid Loaders</h1> + * Although user can apply grid factory directly to start and stop grid, grid is + * often started and stopped by grid loaders. Grid loaders can be found in + * {@link org.apache.ignite.startup} package, for example: + * <ul> + * <li>{@code GridCommandLineStartup}</li> + * <li>{@code GridServletStartup}</li> + * </ul> + * <h1 class="header">Examples</h1> + * Use {@link #start()} method to start grid with default configuration. You can also use + * {@link org.apache.ignite.configuration.IgniteConfiguration} to override some default configuration. Below is an + * example on how to start grid with <strong>URI deployment</strong>. + * <pre name="code" class="java"> + * GridConfiguration cfg = new GridConfiguration(); + */ +public class IgnitionEx { + /** Default configuration path relative to GridGain home. */ + public static final String DFLT_CFG = "config/default-config.xml"; + + /** Map of named grids. */ + private static final ConcurrentMap<Object, IgniteNamedInstance> grids = new ConcurrentHashMap8<>(); + + /** Map of grid states ever started in this JVM. */ + private static final Map<Object, IgniteState> gridStates = new ConcurrentHashMap8<>(); + + /** Mutex to synchronize updates of default grid reference. */ + private static final Object dfltGridMux = new Object(); + + /** Default grid. */ + private static volatile IgniteNamedInstance dfltGrid; + + /** Default grid state. */ + private static volatile IgniteState dfltGridState; + + /** List of state listeners. */ + private static final Collection<IgniteListener> lsnrs = new GridConcurrentHashSet<>(4); + + /** */ + private static volatile boolean daemon; + + /** + * Checks runtime version to be 1.7.x or 1.8.x. + * This will load pretty much first so we must do these checks here. + */ + static { + // Check 1.8 just in case for forward compatibility. + if (!U.jdkVersion().contains("1.7") && + !U.jdkVersion().contains("1.8")) + throw new IllegalStateException("GridGain requires Java 7 or above. Current Java version " + + "is not supported: " + U.jdkVersion()); + + // To avoid nasty race condition in UUID.randomUUID() in JDK prior to 6u34. + // For details please see: + // http://bugs.sun.com/bugdatabase/view_bug.do?bug_id=7071826 + // http://www.oracle.com/technetwork/java/javase/2col/6u34-bugfixes-1733379.html + // http://hg.openjdk.java.net/jdk6/jdk6/jdk/rev/563d392b3e5c + UUID.randomUUID(); + } + + /** + * Enforces singleton. + */ + private IgnitionEx() { + // No-op. + } + + /** + * Sets daemon flag. + * <p> + * If daemon flag is set then all grid instances created by the factory will be + * daemon, i.e. the local node for these instances will be a daemon node. Note that + * if daemon flag is set - it will override the same settings in {@link org.apache.ignite.configuration.IgniteConfiguration#isDaemon()}. + * Note that you can set on and off daemon flag at will. + * + * @param daemon Daemon flag to set. + */ + public static void setDaemon(boolean daemon) { + IgnitionEx.daemon = daemon; + } + + /** + * Gets daemon flag. + * <p> + * If daemon flag it set then all grid instances created by the factory will be + * daemon, i.e. the local node for these instances will be a daemon node. Note that + * if daemon flag is set - it will override the same settings in {@link org.apache.ignite.configuration.IgniteConfiguration#isDaemon()}. + * Note that you can set on and off daemon flag at will. + * + * @return Daemon flag. + */ + public static boolean isDaemon() { + return daemon; + } + + /** + * Gets state of grid default grid. + * + * @return Default grid state. + */ + public static IgniteState state() { + return state(null); + } + + /** + * Gets states of named grid. If name is {@code null}, then state of + * default no-name grid is returned. + * + * @param name Grid name. If name is {@code null}, then state of + * default no-name grid is returned. + * @return Grid state. + */ + public static IgniteState state(@Nullable String name) { + IgniteNamedInstance grid = name != null ? grids.get(name) : dfltGrid; + + if (grid == null) { + IgniteState state = name != null ? gridStates.get(name) : dfltGridState; + + return state != null ? state : STOPPED; + } + + return grid.state(); + } + + /** + * Stops default grid. This method is identical to {@code G.stop(null, cancel)} apply. + * Note that method does not wait for all tasks to be completed. + * + * @param cancel If {@code true} then all jobs currently executing on + * default grid will be cancelled by calling {@link org.apache.ignite.compute.ComputeJob#cancel()} + * method. Note that just like with {@link Thread#interrupt()}, it is + * up to the actual job to exit from execution + * @return {@code true} if default grid instance was indeed stopped, + * {@code false} otherwise (if it was not started). + */ + public static boolean stop(boolean cancel) { + return stop(null, cancel); + } + + /** + * Stops named grid. If {@code cancel} flag is set to {@code true} then + * all jobs currently executing on local node will be interrupted. If + * grid name is {@code null}, then default no-name grid will be stopped. + * If wait parameter is set to {@code true} then grid will wait for all + * tasks to be finished. + * + * @param name Grid name. If {@code null}, then default no-name grid will + * be stopped. + * @param cancel If {@code true} then all jobs currently will be cancelled + * by calling {@link org.apache.ignite.compute.ComputeJob#cancel()} method. Note that just like with + * {@link Thread#interrupt()}, it is up to the actual job to exit from + * execution. If {@code false}, then jobs currently running will not be + * canceled. In either case, grid node will wait for completion of all + * jobs running on it before stopping. + * @return {@code true} if named grid instance was indeed found and stopped, + * {@code false} otherwise (the instance with given {@code name} was + * not found). + */ + public static boolean stop(@Nullable String name, boolean cancel) { + IgniteNamedInstance grid = name != null ? grids.get(name) : dfltGrid; + + if (grid != null && grid.state() == STARTED) { + grid.stop(cancel); + + boolean fireEvt; + + if (name != null) + fireEvt = grids.remove(name, grid); + else { + synchronized (dfltGridMux) { + fireEvt = dfltGrid == grid; + + if (fireEvt) + dfltGrid = null; + } + } + + if (fireEvt) + notifyStateChange(grid.getName(), grid.state()); + + return true; + } + + // We don't have log at this point... + U.warn(null, "Ignoring stopping grid instance that was already stopped or never started: " + name); + + return false; + } + + /** + * Stops <b>all</b> started grids. If {@code cancel} flag is set to {@code true} then + * all jobs currently executing on local node will be interrupted. + * If wait parameter is set to {@code true} then grid will wait for all + * tasks to be finished. + * <p> + * <b>Note:</b> it is usually safer and more appropriate to stop grid instances individually + * instead of blanket operation. In most cases, the party that started the grid instance + * should be responsible for stopping it. + * + * @param cancel If {@code true} then all jobs currently executing on + * all grids will be cancelled by calling {@link org.apache.ignite.compute.ComputeJob#cancel()} + * method. Note that just like with {@link Thread#interrupt()}, it is + * up to the actual job to exit from execution + */ + public static void stopAll(boolean cancel) { + IgniteNamedInstance dfltGrid0 = dfltGrid; + + if (dfltGrid0 != null) { + dfltGrid0.stop(cancel); + + boolean fireEvt; + + synchronized (dfltGridMux) { + fireEvt = dfltGrid == dfltGrid0; + + if (fireEvt) + dfltGrid = null; + } + + if (fireEvt) + notifyStateChange(dfltGrid0.getName(), dfltGrid0.state()); + } + + // Stop the rest and clear grids map. + for (IgniteNamedInstance grid : grids.values()) { + grid.stop(cancel); + + boolean fireEvt = grids.remove(grid.getName(), grid); + + if (fireEvt) + notifyStateChange(grid.getName(), grid.state()); + } + } + + /** + * Restarts <b>all</b> started grids. If {@code cancel} flag is set to {@code true} then + * all jobs currently executing on the local node will be interrupted. + * If {@code wait} parameter is set to {@code true} then grid will wait for all + * tasks to be finished. + * <p> + * <b>Note:</b> it is usually safer and more appropriate to stop grid instances individually + * instead of blanket operation. In most cases, the party that started the grid instance + * should be responsible for stopping it. + * <p> + * Note also that restarting functionality only works with the tools that specifically + * support GridGain's protocol for restarting. Currently only standard <tt>ggstart.{sh|bat}</tt> + * scripts support restarting of JVM GridGain's process. + * + * @param cancel If {@code true} then all jobs currently executing on + * all grids will be cancelled by calling {@link org.apache.ignite.compute.ComputeJob#cancel()} + * method. Note that just like with {@link Thread#interrupt()}, it is + * up to the actual job to exit from execution. + * @see org.apache.ignite.Ignition#RESTART_EXIT_CODE + */ + public static void restart(boolean cancel) { + String file = System.getProperty(GG_SUCCESS_FILE); + + if (file == null) + U.warn(null, "Cannot restart node when restart not enabled."); + else { + try { + new File(file).createNewFile(); + } + catch (IOException e) { + U.error(null, "Failed to create restart marker file (restart aborted): " + e.getMessage()); + + return; + } + + U.log(null, "Restarting node. Will exit (" + Ignition.RESTART_EXIT_CODE + ")."); + + // Set the exit code so that shell process can recognize it and loop + // the start up sequence again. + System.setProperty(GG_RESTART_CODE, Integer.toString(Ignition.RESTART_EXIT_CODE)); + + stopAll(cancel); + + // This basically leaves loaders hang - we accept it. + System.exit(Ignition.RESTART_EXIT_CODE); + } + } + + /** + * Stops <b>all</b> started grids. If {@code cancel} flag is set to {@code true} then + * all jobs currently executing on the local node will be interrupted. + * If {@code wait} parameter is set to {@code true} then grid will wait for all + * tasks to be finished. + * <p> + * <b>Note:</b> it is usually safer and more appropriate to stop grid instances individually + * instead of blanket operation. In most cases, the party that started the grid instance + * should be responsible for stopping it. + * <p> + * Note that upon completion of this method, the JVM with forcefully exist with + * exit code {@link org.apache.ignite.Ignition#KILL_EXIT_CODE}. + * + * @param cancel If {@code true} then all jobs currently executing on + * all grids will be cancelled by calling {@link org.apache.ignite.compute.ComputeJob#cancel()} + * method. Note that just like with {@link Thread#interrupt()}, it is + * up to the actual job to exit from execution. + * @see org.apache.ignite.Ignition#KILL_EXIT_CODE + */ + public static void kill(boolean cancel) { + stopAll(cancel); + + // This basically leaves loaders hang - we accept it. + System.exit(Ignition.KILL_EXIT_CODE); + } + + /** + * Starts grid with default configuration. By default this method will + * use grid configuration defined in {@code GRIDGAIN_HOME/config/default-config.xml} + * configuration file. If such file is not found, then all system defaults will be used. + * + * @return Started grid. + * @throws IgniteCheckedException If default grid could not be started. This exception will be thrown + * also if default grid has already been started. + */ + public static Ignite start() throws IgniteCheckedException { + return start((GridSpringResourceContext)null); + } + + /** + * Starts grid with default configuration. By default this method will + * use grid configuration defined in {@code GRIDGAIN_HOME/config/default-config.xml} + * configuration file. If such file is not found, then all system defaults will be used. + * + * @param springCtx Optional Spring application context, possibly {@code null}. + * Spring bean definitions for bean injection are taken from this context. + * If provided, this context can be injected into grid tasks and grid jobs using + * {@link org.apache.ignite.resources.IgniteSpringApplicationContextResource @IgniteSpringApplicationContextResource} annotation. + * @return Started grid. + * @throws IgniteCheckedException If default grid could not be started. This exception will be thrown + * also if default grid has already been started. + */ + public static Ignite start(@Nullable GridSpringResourceContext springCtx) throws IgniteCheckedException { + URL url = U.resolveGridGainUrl(DFLT_CFG); + + if (url != null) + return start(DFLT_CFG, null, springCtx); + + U.warn(null, "Default Spring XML file not found (is GRIDGAIN_HOME set?): " + DFLT_CFG); + + return start0(new GridStartContext(new IgniteConfiguration(), null, springCtx)).grid(); + } + + /** + * Starts grid with given configuration. Note that this method is no-op if grid with the name + * provided in given configuration is already started. + * + * @param cfg Grid configuration. This cannot be {@code null}. + * @return Started grid. + * @throws IgniteCheckedException If grid could not be started. This exception will be thrown + * also if named grid has already been started. + */ + public static Ignite start(IgniteConfiguration cfg) throws IgniteCheckedException { + return start(cfg, null); + } + + /** + * Starts grid with given configuration. Note that this method is no-op if grid with the name + * provided in given configuration is already started. + * + * @param cfg Grid configuration. This cannot be {@code null}. + * @param springCtx Optional Spring application context, possibly {@code null}. + * Spring bean definitions for bean injection are taken from this context. + * If provided, this context can be injected into grid tasks and grid jobs using + * {@link org.apache.ignite.resources.IgniteSpringApplicationContextResource @IgniteSpringApplicationContextResource} annotation. + * @return Started grid. + * @throws IgniteCheckedException If grid could not be started. This exception will be thrown + * also if named grid has already been started. + */ + public static Ignite start(IgniteConfiguration cfg, @Nullable GridSpringResourceContext springCtx) throws IgniteCheckedException { + A.notNull(cfg, "cfg"); + + return start0(new GridStartContext(cfg, null, springCtx)).grid(); + } + + /** + * Starts all grids specified within given Spring XML configuration file. If grid with given name + * is already started, then exception is thrown. In this case all instances that may + * have been started so far will be stopped too. + * <p> + * Usually Spring XML configuration file will contain only one Grid definition. Note that + * Grid configuration bean(s) is retrieved form configuration file by type, so the name of + * the Grid configuration bean is ignored. + * + * @param springCfgPath Spring XML configuration file path or URL. + * @return Started grid. If Spring configuration contains multiple grid instances, + * then the 1st found instance is returned. + * @throws IgniteCheckedException If grid could not be started or configuration + * read. This exception will be thrown also if grid with given name has already + * been started or Spring XML configuration file is invalid. + */ + public static Ignite start(@Nullable String springCfgPath) throws IgniteCheckedException { + return springCfgPath == null ? start() : start(springCfgPath, null); + } + + /** + * Starts all grids specified within given Spring XML configuration file. If grid with given name + * is already started, then exception is thrown. In this case all instances that may + * have been started so far will be stopped too. + * <p> + * Usually Spring XML configuration file will contain only one Grid definition. Note that + * Grid configuration bean(s) is retrieved form configuration file by type, so the name of + * the Grid configuration bean is ignored. + * + * @param springCfgPath Spring XML configuration file path or URL. + * @param gridName Grid name that will override default. + * @return Started grid. If Spring configuration contains multiple grid instances, + * then the 1st found instance is returned. + * @throws IgniteCheckedException If grid could not be started or configuration + * read. This exception will be thrown also if grid with given name has already + * been started or Spring XML configuration file is invalid. + */ + public static Ignite start(@Nullable String springCfgPath, @Nullable String gridName) throws IgniteCheckedException { + if (springCfgPath == null) { + IgniteConfiguration cfg = new IgniteConfiguration(); + + if (cfg.getGridName() == null && !F.isEmpty(gridName)) + cfg.setGridName(gridName); + + return start(cfg); + } + else + return start(springCfgPath, gridName, null); + } + + /** + * Start Grid for interop scenario. + * + * @param springCfgPath Spring config path. + * @param gridName Grid name. + * @param cfgClo Configuration closure. + * @return Started Grid. + * @throws IgniteCheckedException If failed. + */ + public static Ignite startInterop(@Nullable String springCfgPath, @Nullable String gridName, + IgniteClosure<IgniteConfiguration, IgniteConfiguration> cfgClo) throws IgniteCheckedException { + URL url = resolveSpringUrl(springCfgPath); + + return start(url, gridName, null, cfgClo); + } + + /** + * Loads all grid configurations specified within given Spring XML configuration file. + * <p> + * Usually Spring XML configuration file will contain only one Grid definition. Note that + * Grid configuration bean(s) is retrieved form configuration file by type, so the name of + * the Grid configuration bean is ignored. + * + * @param springCfgUrl Spring XML configuration file path or URL. This cannot be {@code null}. + * @return Tuple containing all loaded configurations and Spring context used to load them. + * @throws IgniteCheckedException If grid could not be started or configuration + * read. This exception will be thrown also if grid with given name has already + * been started or Spring XML configuration file is invalid. + */ + public static IgniteBiTuple<Collection<IgniteConfiguration>, ? extends GridSpringResourceContext> loadConfigurations( + URL springCfgUrl) throws IgniteCheckedException { + IgniteSpringProcessor spring = SPRING.create(false); + + return spring.loadConfigurations(springCfgUrl); + } + + /** + * Loads all grid configurations specified within given Spring XML configuration file. + * <p> + * Usually Spring XML configuration file will contain only one Grid definition. Note that + * Grid configuration bean(s) is retrieved form configuration file by type, so the name of + * the Grid configuration bean is ignored. + * + * @param springCfgPath Spring XML configuration file path. This cannot be {@code null}. + * @return Tuple containing all loaded configurations and Spring context used to load them. + * @throws IgniteCheckedException If grid could not be started or configuration + * read. This exception will be thrown also if grid with given name has already + * been started or Spring XML configuration file is invalid. + */ + public static IgniteBiTuple<Collection<IgniteConfiguration>, ? extends GridSpringResourceContext> loadConfigurations( + String springCfgPath) throws IgniteCheckedException { + A.notNull(springCfgPath, "springCfgPath"); + + URL url; + + try { + url = new URL(springCfgPath); + } + catch (MalformedURLException e) { + url = U.resolveGridGainUrl(springCfgPath); + + if (url == null) + throw new IgniteCheckedException("Spring XML configuration path is invalid: " + springCfgPath + + ". Note that this path should be either absolute or a relative local file system path, " + + "relative to META-INF in classpath or valid URL to GRIDGAIN_HOME.", e); + } + + return loadConfigurations(url); + } + + /** + * Loads first found grid configuration specified within given Spring XML configuration file. + * <p> + * Usually Spring XML configuration file will contain only one Grid definition. Note that + * Grid configuration bean(s) is retrieved form configuration file by type, so the name of + * the Grid configuration bean is ignored. + * + * @param springCfgUrl Spring XML configuration file path or URL. This cannot be {@code null}. + * @return First found configuration and Spring context used to load it. + * @throws IgniteCheckedException If grid could not be started or configuration + * read. This exception will be thrown also if grid with given name has already + * been started or Spring XML configuration file is invalid. + */ + public static IgniteBiTuple<IgniteConfiguration, GridSpringResourceContext> loadConfiguration(URL springCfgUrl) + throws IgniteCheckedException { + IgniteBiTuple<Collection<IgniteConfiguration>, ? extends GridSpringResourceContext> t = loadConfigurations(springCfgUrl); + + return F.t(F.first(t.get1()), t.get2()); + } + + /** + * Loads first found grid configuration specified within given Spring XML configuration file. + * <p> + * Usually Spring XML configuration file will contain only one Grid definition. Note that + * Grid configuration bean(s) is retrieved form configuration file by type, so the name of + * the Grid configuration bean is ignored. + * + * @param springCfgPath Spring XML configuration file path. This cannot be {@code null}. + * @return First found configuration and Spring context used to load it. + * @throws IgniteCheckedException If grid could not be started or configuration + * read. This exception will be thrown also if grid with given name has already + * been started or Spring XML configuration file is invalid. + */ + public static IgniteBiTuple<IgniteConfiguration, GridSpringResourceContext> loadConfiguration(String springCfgPath) + throws IgniteCheckedException { + IgniteBiTuple<Collection<IgniteConfiguration>, ? extends GridSpringResourceContext> t = + loadConfigurations(springCfgPath); + + return F.t(F.first(t.get1()), t.get2()); + } + + /** + * Starts all grids specified within given Spring XML configuration file. If grid with given name + * is already started, then exception is thrown. In this case all instances that may + * have been started so far will be stopped too. + * <p> + * Usually Spring XML configuration file will contain only one Grid definition. Note that + * Grid configuration bean(s) is retrieved form configuration file by type, so the name of + * the Grid configuration bean is ignored. + * + * @param springCfgPath Spring XML configuration file path or URL. This cannot be {@code null}. + * @param gridName Grid name that will override default. + * @param springCtx Optional Spring application context, possibly {@code null}. + * Spring bean definitions for bean injection are taken from this context. + * If provided, this context can be injected into grid tasks and grid jobs using + * {@link org.apache.ignite.resources.IgniteSpringApplicationContextResource @IgniteSpringApplicationContextResource} annotation. + * @return Started grid. If Spring configuration contains multiple grid instances, + * then the 1st found instance is returned. + * @throws IgniteCheckedException If grid could not be started or configuration + * read. This exception will be thrown also if grid with given name has already + * been started or Spring XML configuration file is invalid. + */ + public static Ignite start(String springCfgPath, @Nullable String gridName, + @Nullable GridSpringResourceContext springCtx) throws IgniteCheckedException { + URL url = resolveSpringUrl(springCfgPath); + + return start(url, gridName, springCtx); + } + + /** + * Starts all grids specified within given Spring XML configuration file URL. If grid with given name + * is already started, then exception is thrown. In this case all instances that may + * have been started so far will be stopped too. + * <p> + * Usually Spring XML configuration file will contain only one Grid definition. Note that + * Grid configuration bean(s) is retrieved form configuration file by type, so the name of + * the Grid configuration bean is ignored. + * + * @param springCfgUrl Spring XML configuration file URL. This cannot be {@code null}. + * @return Started grid. If Spring configuration contains multiple grid instances, + * then the 1st found instance is returned. + * @throws IgniteCheckedException If grid could not be started or configuration + * read. This exception will be thrown also if grid with given name has already + * been started or Spring XML configuration file is invalid. + */ + public static Ignite start(URL springCfgUrl) throws IgniteCheckedException { + return start(springCfgUrl, null, null); + } + + /** + * Starts all grids specified within given Spring XML configuration file URL. If grid with given name + * is already started, then exception is thrown. In this case all instances that may + * have been started so far will be stopped too. + * <p> + * Usually Spring XML configuration file will contain only one Grid definition. Note that + * Grid configuration bean(s) is retrieved form configuration file by type, so the name of + * the Grid configuration bean is ignored. + * + * @param springCfgUrl Spring XML configuration file URL. This cannot be {@code null}. + * @param gridName Grid name that will override default. + * @param springCtx Optional Spring application context, possibly {@code null}. + * Spring bean definitions for bean injection are taken from this context. + * If provided, this context can be injected into grid tasks and grid jobs using + * {@link org.apache.ignite.resources.IgniteSpringApplicationContextResource @IgniteSpringApplicationContextResource} annotation. + * @return Started grid. If Spring configuration contains multiple grid instances, + * then the 1st found instance is returned. + * @throws IgniteCheckedException If grid could not be started or configuration + * read. This exception will be thrown also if grid with given name has already + * been started or Spring XML configuration file is invalid. + */ + public static Ignite start(URL springCfgUrl, @Nullable String gridName, + @Nullable GridSpringResourceContext springCtx) throws IgniteCheckedException { + return start(springCfgUrl, gridName, springCtx, null); + } + + /** + * Internal Spring-based start routine. + * + * @param springCfgUrl Spring XML configuration file URL. This cannot be {@code null}. + * @param gridName Grid name that will override default. + * @param springCtx Optional Spring application context. + * @param cfgClo Optional closure to change configuration before it is used to start the grid. + * @return Started grid. + * @throws IgniteCheckedException If failed. + */ + private static Ignite start(URL springCfgUrl, @Nullable String gridName, + @Nullable GridSpringResourceContext springCtx, + @Nullable IgniteClosure<IgniteConfiguration, IgniteConfiguration> cfgClo) + throws IgniteCheckedException { + A.notNull(springCfgUrl, "springCfgUrl"); + + boolean isLog4jUsed = U.gridClassLoader().getResource("org/apache/log4j/Appender.class") != null; + + IgniteBiTuple<Object, Object> t = null; + + Collection<Handler> savedHnds = null; + + if (isLog4jUsed) + t = U.addLog4jNoOpLogger(); + else + savedHnds = U.addJavaNoOpLogger(); + + IgniteBiTuple<Collection<IgniteConfiguration>, ? extends GridSpringResourceContext> cfgMap; + + try { + cfgMap = loadConfigurations(springCfgUrl); + } + finally { + if (isLog4jUsed && t != null) + U.removeLog4jNoOpLogger(t); + + if (!isLog4jUsed) + U.removeJavaNoOpLogger(savedHnds); + } + + List<IgniteNamedInstance> grids = new ArrayList<>(cfgMap.size()); + + try { + for (IgniteConfiguration cfg : cfgMap.get1()) { + assert cfg != null; + + if (cfg.getGridName() == null && !F.isEmpty(gridName)) + cfg.setGridName(gridName); + + if (cfgClo != null) { + cfg = cfgClo.apply(cfg); + + assert cfg != null; + } + + // Use either user defined context or our one. + IgniteNamedInstance grid = start0( + new GridStartContext(cfg, springCfgUrl, springCtx == null ? cfgMap.get2() : springCtx)); + + // Add it if it was not stopped during startup. + if (grid != null) + grids.add(grid); + } + } + catch (IgniteCheckedException e) { + // Stop all instances started so far. + for (IgniteNamedInstance grid : grids) { + try { + grid.stop(true); + } + catch (Exception e1) { + U.error(grid.log, "Error when stopping grid: " + grid, e1); + } + } + + throw e; + } + + // Return the first grid started. + IgniteNamedInstance res = !grids.isEmpty() ? grids.get(0) : null; + + return res != null ? res.grid() : null; + } + + /** + * Resolve Spring configuration URL. + * + * @param springCfgPath Spring XML configuration file path or URL. This cannot be {@code null}. + * @return URL. + * @throws IgniteCheckedException If failed. + */ + private static URL resolveSpringUrl(String springCfgPath) throws IgniteCheckedException { + A.notNull(springCfgPath, "springCfgPath"); + + URL url; + + try { + url = new URL(springCfgPath); + } + catch (MalformedURLException e) { + url = U.resolveGridGainUrl(springCfgPath); + + if (url == null) + throw new IgniteCheckedException("Spring XML configuration path is invalid: " + springCfgPath + + ". Note that this path should be either absolute or a relative local file system path, " + + "relative to META-INF in classpath or valid URL to GRIDGAIN_HOME.", e); + } + + return url; + } + + /** + * Starts grid with given configuration. + * + * @param startCtx Start context. + * @return Started grid. + * @throws IgniteCheckedException If grid could not be started. + */ + private static IgniteNamedInstance start0(GridStartContext startCtx) throws IgniteCheckedException { + assert startCtx != null; + + String name = startCtx.config().getGridName(); + + if (name != null && name.isEmpty()) + throw new IgniteCheckedException("Non default grid instances cannot have empty string name."); + + IgniteNamedInstance grid = new IgniteNamedInstance(name); + + IgniteNamedInstance old; + + if (name != null) + old = grids.putIfAbsent(name, grid); + else { + synchronized (dfltGridMux) { + old = dfltGrid; + + if (old == null) + dfltGrid = grid; + } + } + + if (old != null) { + if (name == null) + throw new IgniteCheckedException("Default grid instance has already been started."); + else + throw new IgniteCheckedException("Grid instance with this name has already been started: " + name); + } + + if (startCtx.config().getWarmupClosure() != null) + startCtx.config().getWarmupClosure().apply(startCtx.config()); + + startCtx.single(grids.size() == 1); + + boolean success = false; + + try { + grid.start(startCtx); + + notifyStateChange(name, STARTED); + + success = true; + } + finally { + if (!success) { + if (name != null) + grids.remove(name, grid); + else { + synchronized (dfltGridMux) { + if (dfltGrid == grid) + dfltGrid = null; + } + } + + grid = null; + } + } + + if (grid == null) + throw new IgniteCheckedException("Failed to start grid with provided configuration."); + + return grid; + } + + /** + * Gets an instance of default no-name grid. Note that + * caller of this method should not assume that it will return the same + * instance every time. + * <p> + * This method is identical to {@code G.grid(null)} apply. + * + * @return An instance of default no-name grid. This method never returns + * {@code null}. + * @throws org.apache.ignite.IgniteIllegalStateException Thrown if default grid was not properly + * initialized or grid instance was stopped or was not started. + */ + public static Ignite grid() throws IgniteIllegalStateException { + return grid((String)null); + } + + /** + * Gets a list of all grids started so far. + * + * @return List of all grids started so far. + */ + public static List<Ignite> allGrids() { + List<Ignite> allIgnites = new ArrayList<>(grids.size() + 1); + + for (IgniteNamedInstance grid : grids.values()) { + Ignite g = grid.grid(); + + if (g != null) + allIgnites.add(g); + } + + IgniteNamedInstance dfltGrid0 = dfltGrid; + + if (dfltGrid0 != null) { + IgniteKernal g = dfltGrid0.grid(); + + if (g != null) + allIgnites.add(g); + } + + return allIgnites; + } + + /** + * Gets a grid instance for given local node ID. Note that grid instance and local node have + * one-to-one relationship where node has ID and instance has name of the grid to which + * both grid instance and its node belong. Note also that caller of this method + * should not assume that it will return the same instance every time. + * + * @param locNodeId ID of local node the requested grid instance is managing. + * @return An instance of named grid. This method never returns + * {@code null}. + * @throws org.apache.ignite.IgniteIllegalStateException Thrown if grid was not properly + * initialized or grid instance was stopped or was not started. + */ + public static Ignite grid(UUID locNodeId) throws IgniteIllegalStateException { + A.notNull(locNodeId, "locNodeId"); + + IgniteNamedInstance dfltGrid0 = dfltGrid; + + if (dfltGrid0 != null) { + IgniteKernal g = dfltGrid0.grid(); + + if (g != null && g.getLocalNodeId().equals(locNodeId)) + return g; + } + + for (IgniteNamedInstance grid : grids.values()) { + IgniteKernal g = grid.grid(); + + if (g != null && g.getLocalNodeId().equals(locNodeId)) + return g; + } + + throw new IgniteIllegalStateException("Grid instance with given local node ID was not properly " + + "started or was stopped: " + locNodeId); + } + + /** + * Gets an named grid instance. If grid name is {@code null} or empty string, + * then default no-name grid will be returned. Note that caller of this method + * should not assume that it will return the same instance every time. + * <p> + * Note that Java VM can run multiple grid instances and every grid instance (and its + * node) can belong to a different grid. Grid name defines what grid a particular grid + * instance (and correspondingly its node) belongs to. + * + * @param name Grid name to which requested grid instance belongs to. If {@code null}, + * then grid instance belonging to a default no-name grid will be returned. + * @return An instance of named grid. This method never returns + * {@code null}. + * @throws org.apache.ignite.IgniteIllegalStateException Thrown if default grid was not properly + * initialized or grid instance was stopped or was not started. + */ + public static Ignite grid(@Nullable String name) throws IgniteIllegalStateException { + IgniteNamedInstance grid = name != null ? grids.get(name) : dfltGrid; + + Ignite res; + + if (grid == null || (res = grid.grid()) == null) + throw new IgniteIllegalStateException("Grid instance was not properly started " + + "or was already stopped: " + name); + + return res; + } + + /** + * Gets grid instance without waiting its initialization. + * + * @param name Grid name. + * @return Grid instance. + */ + public static IgniteKernal gridx(@Nullable String name) { + IgniteNamedInstance grid = name != null ? grids.get(name) : dfltGrid; + + IgniteKernal res; + + if (grid == null || (res = grid.gridx()) == null) + throw new IllegalStateException("Grid instance was not properly started or was already stopped: " + name); + + return res; + } + + /** + * Adds a lsnr for grid life cycle events. + * <p> + * Note that unlike other listeners in GridGain this listener will be + * notified from the same thread that triggers the state change. Because of + * that it is the responsibility of the user to make sure that listener logic + * is light-weight and properly handles (catches) any runtime exceptions, if any + * are expected. + * + * @param lsnr Listener for grid life cycle events. If this listener was already added + * this method is no-op. + */ + public static void addListener(IgniteListener lsnr) { + A.notNull(lsnr, "lsnr"); + + lsnrs.add(lsnr); + } + + /** + * Removes lsnr added by {@link #addListener(org.apache.ignite.lifecycle.IgniteListener)} method. + * + * @param lsnr Listener to remove. + * @return {@code true} if lsnr was added before, {@code false} otherwise. + */ + public static boolean removeListener(IgniteListener lsnr) { + A.notNull(lsnr, "lsnr"); + + return lsnrs.remove(lsnr); + } + + /** + * @param gridName Grid instance name. + * @param state Factory state. + */ + private static void notifyStateChange(@Nullable String gridName, IgniteState state) { + if (gridName != null) + gridStates.put(gridName, state); + else + dfltGridState = state; + + for (IgniteListener lsnr : lsnrs) + lsnr.onStateChange(gridName, state); + } + + /** + * Start context encapsulates all starting parameters. + */ + private static final class GridStartContext { + /** User-defined configuration. */ + private IgniteConfiguration cfg; + + /** Optional configuration path. */ + private URL cfgUrl; + + /** Optional Spring application context. */ + private GridSpringResourceContext springCtx; + + /** Whether or not this is a single grid instance in current VM. */ + private boolean single; + + /** + * + * @param cfg User-defined configuration. + * @param cfgUrl Optional configuration path. + * @param springCtx Optional Spring application context. + */ + GridStartContext(IgniteConfiguration cfg, @Nullable URL cfgUrl, @Nullable GridSpringResourceContext springCtx) { + assert(cfg != null); + + this.cfg = cfg; + this.cfgUrl = cfgUrl; + this.springCtx = springCtx; + } + + /** + * @return Whether or not this is a single grid instance in current VM. + */ + public boolean single() { + return single; + } + + /** + * @param single Whether or not this is a single grid instance in current VM. + */ + public void single(boolean single) { + this.single = single; + } + + /** + * @return User-defined configuration. + */ + IgniteConfiguration config() { + return cfg; + } + + /** + * @param cfg User-defined configuration. + */ + void config(IgniteConfiguration cfg) { + this.cfg = cfg; + } + + /** + * @return Optional configuration path. + */ + URL configUrl() { + return cfgUrl; + } + + /** + * @param cfgUrl Optional configuration path. + */ + void configUrl(URL cfgUrl) { + this.cfgUrl = cfgUrl; + } + + /** + * @return Optional Spring application context. + */ + public GridSpringResourceContext springContext() { + return springCtx; + } + } + + /** + * Grid data container. + */ + private static final class IgniteNamedInstance { + /** Map of registered MBeans. */ + private static final Map<MBeanServer, GridMBeanServerData> mbeans = + new HashMap<>(); + + /** */ + private static final String[] EMPTY_STR_ARR = new String[0]; + + /** Empty array of caches. */ + private static final CacheConfiguration[] EMPTY_CACHE_CONFIGS = new CacheConfiguration[0]; + + /** Grid name. */ + private final String name; + + /** Grid instance. */ + private volatile IgniteKernal grid; + + /** Executor service. */ + private ExecutorService execSvc; + + /** Auto executor service flag. */ + private boolean isAutoExecSvc; + + /** Executor service shutdown flag. */ + private boolean execSvcShutdown; + + /** System executor service. */ + private ExecutorService sysExecSvc; + + /** Auto system service flag. */ + private boolean isAutoSysSvc; + + /** System executor service shutdown flag. */ + private boolean sysSvcShutdown; + + /** Management executor service. */ + private ExecutorService mgmtExecSvc; + + /** Auto management service flag. */ + private boolean isAutoMgmtSvc; + + /** Management executor service shutdown flag. */ + private boolean mgmtSvcShutdown; + + /** P2P executor service. */ + private ExecutorService p2pExecSvc; + + /** Auto P2P service flag. */ + private boolean isAutoP2PSvc; + + /** P2P executor service shutdown flag. */ + private boolean p2pSvcShutdown; + + /** GGFS executor service. */ + private ExecutorService ggfsExecSvc; + + /** Auto GGFS service flag. */ + private boolean isAutoGgfsSvc; + + /** GGFS executor service shutdown flag. */ + private boolean ggfsSvcShutdown; + + /** REST requests executor service. */ + private ExecutorService restExecSvc; + + /** Auto REST service flag. */ + private boolean isAutoRestSvc; + + /** REST executor service shutdown flag. */ + private boolean restSvcShutdown; + + /** Utility cache executor service. */ + private ExecutorService utilityCacheExecSvc; + + /** Grid state. */ + private volatile IgniteState state = STOPPED; + + /** Shutdown hook. */ + private Thread shutdownHook; + + /** Grid log. */ + private IgniteLogger log; + + /** Start guard. */ + private final AtomicBoolean startGuard = new AtomicBoolean(); + + /** Start latch. */ + private final CountDownLatch startLatch = new CountDownLatch(1); + + /** + * Thread that starts this named instance. This field can be non-volatile since + * it makes sense only for thread where it was originally initialized. + */ + @SuppressWarnings("FieldAccessedSynchronizedAndUnsynchronized") + private Thread starterThread; + + /** + * Creates un-started named instance. + * + * @param name Grid name (possibly {@code null} for default grid). + */ + IgniteNamedInstance(@Nullable String name) { + this.name = name; + } + + /** + * Gets grid name. + * + * @return Grid name. + */ + String getName() { + return name; + } + + /** + * Gets grid instance. + * + * @return Grid instance. + */ + IgniteKernal grid() { + if (starterThread != Thread.currentThread()) + U.awaitQuiet(startLatch); + + return grid; + } + + /** + * Gets grid instance without waiting for its initialization. + * + * @return Grid instance. + */ + public IgniteKernal gridx() { + return grid; + } + + /** + * Gets grid state. + * + * @return Grid state. + */ + IgniteState state() { + if (starterThread != Thread.currentThread()) + U.awaitQuiet(startLatch); + + return state; + } + + /** + * @param spi SPI implementation. + * @throws IgniteCheckedException Thrown in case if multi-instance is not supported. + */ + private void ensureMultiInstanceSupport(IgniteSpi spi) throws IgniteCheckedException { + IgniteSpiMultipleInstancesSupport ann = U.getAnnotation(spi.getClass(), + IgniteSpiMultipleInstancesSupport.class); + + if (ann == null || !ann.value()) + throw new IgniteCheckedException("SPI implementation doesn't support multiple grid instances in " + + "the same VM: " + spi); + } + + /** + * @param spis SPI implementations. + * @throws IgniteCheckedException Thrown in case if multi-instance is not supported. + */ + private void ensureMultiInstanceSupport(IgniteSpi[] spis) throws IgniteCheckedException { + for (IgniteSpi spi : spis) + ensureMultiInstanceSupport(spi); + } + + /** + * Starts grid with given configuration. + * + * @param startCtx Starting context. + * @throws IgniteCheckedException If start failed. + */ + synchronized void start(GridStartContext startCtx) throws IgniteCheckedException { + if (startGuard.compareAndSet(false, true)) { + try { + starterThread = Thread.currentThread(); + + start0(startCtx); + } + catch (Exception e) { + if (log != null) + stopExecutors(log); + + throw e; + } + finally { + startLatch.countDown(); + } + } + else + U.awaitQuiet(startLatch); + } + + /** + * @param startCtx Starting context. + * @throws IgniteCheckedException If start failed. + */ + @SuppressWarnings({"unchecked", "TooBroadScope"}) + private void start0(GridStartContext startCtx) throws IgniteCheckedException { + assert grid == null : "Grid is already started: " + name; + + IgniteConfiguration cfg = startCtx.config(); + + if (cfg == null) + cfg = new IgniteConfiguration(); + + IgniteConfiguration myCfg = new IgniteConfiguration(); + + String ggHome = cfg.getGridGainHome(); + + // Set GridGain home. + if (ggHome == null) + ggHome = U.getGridGainHome(); + else + // If user provided GRIDGAIN_HOME - set it as a system property. + U.setGridGainHome(ggHome); + + U.setWorkDirectory(cfg.getWorkDirectory(), ggHome); + + /* + * Set up all defaults and perform all checks. + */ + + // Ensure invariant. + // It's a bit dirty - but this is a result of late refactoring + // and I don't want to reshuffle a lot of code. + assert F.eq(name, cfg.getGridName()); + + // Set configuration URL, if any, into system property. + if (startCtx.configUrl() != null) + System.setProperty(GG_CONFIG_URL, startCtx.configUrl().toString()); + + myCfg.setGridName(cfg.getGridName()); + + UUID nodeId = cfg.getNodeId(); + + if (nodeId == null) + nodeId = UUID.randomUUID(); + + IgniteLogger cfgLog = initLogger(cfg.getGridLogger(), nodeId); + + assert cfgLog != null; + + cfgLog = new GridLoggerProxy(cfgLog, null, name, U.id8(nodeId)); + + // Initialize factory's log. + log = cfgLog.getLogger(G.class); + + // Check GridGain home folder (after log is available). + if (ggHome != null) { + File ggHomeFile = new File(ggHome); + + if (!ggHomeFile.exists() || !ggHomeFile.isDirectory()) + throw new IgniteCheckedException("Invalid GridGain installation home folder: " + ggHome); + } + + myCfg.setGridGainHome(ggHome); + + // Copy values that don't need extra processing. + myCfg.setLicenseUrl(cfg.getLicenseUrl()); + myCfg.setPeerClassLoadingEnabled(cfg.isPeerClassLoadingEnabled()); + myCfg.setDeploymentMode(cfg.getDeploymentMode()); + myCfg.setNetworkTimeout(cfg.getNetworkTimeout()); + myCfg.setClockSyncSamples(cfg.getClockSyncSamples()); + myCfg.setClockSyncFrequency(cfg.getClockSyncFrequency()); + myCfg.setDiscoveryStartupDelay(cfg.getDiscoveryStartupDelay()); + myCfg.setMetricsHistorySize(cfg.getMetricsHistorySize()); + myCfg.setMetricsExpireTime(cfg.getMetricsExpireTime()); + myCfg.setMetricsUpdateFrequency(cfg.getMetricsUpdateFrequency()); + myCfg.setLifecycleBeans(cfg.getLifecycleBeans()); + myCfg.setLocalEventListeners(cfg.getLocalEventListeners()); + myCfg.setPeerClassLoadingMissedResourcesCacheSize(cfg.getPeerClassLoadingMissedResourcesCacheSize()); + myCfg.setIncludeEventTypes(cfg.getIncludeEventTypes()); + myCfg.setDaemon(cfg.isDaemon()); + myCfg.setIncludeProperties(cfg.getIncludeProperties()); + myCfg.setLifeCycleEmailNotification(cfg.isLifeCycleEmailNotification()); + myCfg.setMetricsLogFrequency(cfg.getMetricsLogFrequency()); + myCfg.setNetworkSendRetryDelay(cfg.getNetworkSendRetryDelay()); + myCfg.setNetworkSendRetryCount(cfg.getNetworkSendRetryCount()); + myCfg.setSecurityCredentialsProvider(cfg.getSecurityCredentialsProvider()); + myCfg.setServiceConfiguration(cfg.getServiceConfiguration()); + myCfg.setWarmupClosure(cfg.getWarmupClosure()); + myCfg.setInteropConfiguration(cfg.getInteropConfiguration()); + myCfg.setPluginConfigurations(cfg.getPluginConfigurations()); + myCfg.setTransactionsConfiguration(new TransactionsConfiguration(cfg.getTransactionsConfiguration())); + myCfg.setQueryConfiguration(cfg.getQueryConfiguration()); + + ClientConnectionConfiguration clientCfg = cfg.getClientConnectionConfiguration(); + + if (clientCfg == null) { + // If client config is not provided then create config copying values from GridConfiguration. + if (cfg.isRestEnabled()) { + clientCfg = new ClientConnectionConfiguration(); + + clientCfg.setClientMessageInterceptor(cfg.getClientMessageInterceptor()); + clientCfg.setRestAccessibleFolders(cfg.getRestAccessibleFolders()); + clientCfg.setRestExecutorService(cfg.getRestExecutorService()); + clientCfg.setRestExecutorServiceShutdown(cfg.getRestExecutorServiceShutdown()); + clientCfg.setRestIdleTimeout(cfg.getRestIdleTimeout()); + clientCfg.setRestJettyPath(cfg.getRestJettyPath()); + clientCfg.setRestPortRange(cfg.getRestPortRange()); + clientCfg.setRestSecretKey(cfg.getRestSecretKey()); + clientCfg.setRestTcpDirectBuffer(cfg.isRestTcpDirectBuffer()); + clientCfg.setRestTcpHost(cfg.getRestTcpHost()); + clientCfg.setRestTcpNoDelay(cfg.isRestTcpNoDelay()); + clientCfg.setRestTcpPort(cfg.getRestTcpPort()); + clientCfg.setRestTcpReceiveBufferSize(cfg.getRestTcpReceiveBufferSize()); + clientCfg.setRestTcpSelectorCount(cfg.getRestTcpSelectorCount()); + clientCfg.setRestTcpSendBufferSize(cfg.getRestTcpSendBufferSize()); + clientCfg.setRestTcpSendQueueLimit(cfg.getRestTcpSendQueueLimit()); + clientCfg.setRestTcpSslClientAuth(cfg.isRestTcpSslClientAuth()); + clientCfg.setRestTcpSslContextFactory(cfg.getRestTcpSslContextFactory()); + clientCfg.setRestTcpSslEnabled(cfg.isRestTcpSslEnabled()); + } + } + else + clientCfg = new ClientConnectionConfiguration(clientCfg); + + + String ntfStr = IgniteSystemProperties.getString(GG_LIFECYCLE_EMAIL_NOTIFY); + + if (ntfStr != null) + myCfg.setLifeCycleEmailNotification(Boolean.parseBoolean(ntfStr)); + + // Local host. + String locHost = IgniteSystemProperties.getString(GG_LOCAL_HOST); + + myCfg.setLocalHost(F.isEmpty(locHost) ? cfg.getLocalHost() : locHost); + + // Override daemon flag if it was set on the factory. + if (daemon) + myCfg.setDaemon(true); + + // Check for deployment mode override. + String depModeName = IgniteSystemProperties.getString(GG_DEP_MODE_OVERRIDE); + + if (!F.isEmpty(depModeName)) { + if (!F.isEmpty(cfg.getCacheConfiguration())) { + U.quietAndInfo(log, "Skipping deployment mode override for caches (custom closure " + + "execution may not work for console Visor)"); + } + else { + try { + IgniteDeploymentMode depMode = IgniteDeploymentMode.valueOf(depModeName); + + if (myCfg.getDeploymentMode() != depMode) + myCfg.setDeploymentMode(depMode); + } + catch (IllegalArgumentException e) { + throw new IgniteCheckedException("Failed to override deployment mode using system property " + + "(are there any misspellings?)" + + "[name=" + GG_DEP_MODE_OVERRIDE + ", value=" + depModeName + ']', e); + } + } + } + + Map<String, ?> attrs = cfg.getUserAttributes(); + + if (attrs == null) + attrs = Collections.emptyMap(); + + MBeanServer mbSrv = cfg.getMBeanServer(); + + IgniteMarshaller marsh = cfg.getMarshaller(); + + String[] p2pExclude = cfg.getPeerClassLoadingLocalClassPathExclude(); + + CommunicationSpi commSpi = cfg.getCommunicationSpi(); + DiscoverySpi discoSpi = cfg.getDiscoverySpi(); + EventStorageSpi evtSpi = cfg.getEventStorageSpi(); + CollisionSpi colSpi = cfg.getCollisionSpi(); + AuthenticationSpi authSpi = cfg.getAuthenticationSpi(); + SecureSessionSpi sesSpi = cfg.getSecureSessionSpi(); + DeploymentSpi deploySpi = cfg.getDeploymentSpi(); + CheckpointSpi[] cpSpi = cfg.getCheckpointSpi(); + FailoverSpi[] failSpi = cfg.getFailoverSpi(); + LoadBalancingSpi[] loadBalancingSpi = cfg.getLoadBalancingSpi(); + SwapSpaceSpi swapspaceSpi = cfg.getSwapSpaceSpi(); + GridIndexingSpi indexingSpi = cfg.getIndexingSpi(); + + execSvc = cfg.getExecutorService(); + sysExecSvc = cfg.getSystemExecutorService(); + p2pExecSvc = cfg.getPeerClassLoadingExecutorService(); + mgmtExecSvc = cfg.getManagementExecutorService(); + ggfsExecSvc = cfg.getGgfsExecutorService(); + + if (execSvc == null) { + isAutoExecSvc = true; + + execSvc = new IgniteThreadPoolExecutor( + "pub-" + cfg.getGridName(), + DFLT_PUBLIC_CORE_THREAD_CNT, + DFLT_PUBLIC_MAX_THREAD_CNT, + DFLT_PUBLIC_KEEP_ALIVE_TIME, + new LinkedBlockingQueue<Runnable>(DFLT_PUBLIC_THREADPOOL_QUEUE_CAP)); + + // Pre-start all threads as they are guaranteed to be needed. + ((ThreadPoolExecutor)execSvc).prestartAllCoreThreads(); + } + + if (sysExecSvc == null) { + isAutoSysSvc = true; + + // Note that since we use 'LinkedBlockingQueue', number of + // maximum threads has no effect. + sysExecSvc = new IgniteThreadPoolExecutor( + "sys-" + cfg.getGridName(), + DFLT_SYSTEM_CORE_THREAD_CNT, + DFLT_SYSTEM_MAX_THREAD_CNT, + DFLT_SYSTEM_KEEP_ALIVE_TIME, + new LinkedBlockingQueue<Runnable>(DFLT_SYSTEM_THREADPOOL_QUEUE_CAP)); + + // Pre-start all threads as they are guaranteed to be needed. + ((ThreadPoolExecutor)sysExecSvc).prestartAllCoreThreads(); + } + + if (mgmtExecSvc == null) { + isAutoMgmtSvc = true; + + // Note that since we use 'LinkedBlockingQueue', number of + // maximum threads has no effect. + // Note, that we do not pre-start threads here as management pool may + // not be needed. + mgmtExecSvc = new IgniteThreadPoolExecutor( + "mgmt-" + cfg.getGridName(), + DFLT_MGMT_THREAD_CNT, + DFLT_MGMT_THREAD_CNT, + 0, + new LinkedBlockingQueue<Runnable>()); + } + + if (p2pExecSvc == null) { + isAutoP2PSvc = true; + + // Note that since we use 'LinkedBlockingQueue', number of + // maximum threads has no effect. + // Note, that we do not pre-start threads here as class loading pool may + // not be needed. + p2pExecSvc = new IgniteThreadPoolExecutor( + "p2p-" + cfg.getGridName(), + DFLT_P2P_THREAD_CNT, + DFLT_P2P_THREAD_CNT, + 0, + new LinkedBlockingQueue<Runnable>()); + } + + if (ggfsExecSvc == null) { + isAutoGgfsSvc = true; + + int procCnt = Runtime.getRuntime().availableProcessors(); + + // Note that we do not pre-start threads here as ggfs pool may not be needed. + ggfsExecSvc = new IgniteThreadPoolExecutor( + "ggfs-" + cfg.getGridName(), + procCnt, + procCnt, + 0, + new LinkedBlockingQueue<Runnable>()); + } + + restExecSvc = clientCfg != null ? clientCfg.getRestExecutorService() : null; + + if (restExecSvc != null && !cfg.isRestEnabled()) { + U.warn(log, "REST executor service is configured, but REST is disabled in configuration " + + "(safely ignoring)."); + } + else if (restExecSvc == null && clientCfg != null) { + isAutoRestSvc = true; + + restExecSvc = new IgniteThreadPoolExecutor( + "rest-" + cfg.getGridName(), + DFLT_REST_CORE_THREAD_CNT, + DFLT_REST_MAX_THREAD_CNT, + DFLT_REST_KEEP_ALIVE_TIME, + new LinkedBlockingQueue<Runnable>(DFLT_REST_THREADPOOL_QUEUE_CAP) + ); + + clientCfg.setRestExecutorService(restExecSvc); + } + + utilityCacheExecSvc = new IgniteThreadPoolExecutor( + "utility-" + cfg.getGridName(), + DFLT_SYSTEM_CORE_THREAD_CNT, + DFLT_SYSTEM_MAX_THREAD_CNT, + DFLT_SYSTEM_KEEP_ALIVE_TIME, + new LinkedBlockingQueue<Runnable>(DFLT_SYSTEM_THREADPOOL_QUEUE_CAP)); + + execSvcShutdown = cfg.getExecutorServiceShutdown(); + sysSvcShutdown = cfg.getSystemExecutorServiceShutdown(); + mgmtSvcShutdown = cfg.getManagementExecutorServiceShutdown(); + p2pSvcShutdown = cfg.getPeerClassLoadingExecutorServiceShutdown(); + ggfsSvcShutdown = cfg.getGgfsExecutorServiceShutdown(); + restSvcShutdown = clientCfg != null && clientCfg.isRestExecutorServiceShutdown(); + + if (marsh == null) { + if (!U.isHotSpot()) { + U.warn(log, "GridOptimizedMarshaller is not supported on this JVM " + + "(only Java HotSpot VMs are supported). Switching to standard JDK marshalling - " + + "object serialization performance will be significantly slower.", + "To enable fast marshalling upgrade to recent 1.6 or 1.7 HotSpot VM release."); + + marsh = new IgniteJdkMarshaller(); + } + else if (!IgniteOptimizedMarshaller.available()) { + U.warn(log, "GridOptimizedMarshaller is not supported on this JVM " + + "(only recent 1.6 and 1.7 versions HotSpot VMs are supported). " + + "To enable fast marshalling upgrade to recent 1.6 or 1.7 HotSpot VM release. " + + "Switching to standard JDK marshalling - " + + "object serialization performance will be significantly slower.", + "To enable fast marshalling upgrade to recent 1.6 or 1.7 HotSpot VM release."); + + marsh = new IgniteJdkMarshaller(); + } + else + marsh = new IgniteOptimizedMarshaller(); + } + else if (marsh instanceof IgniteOptimizedMarshaller && !U.isHotSpot()) { + U.warn(log, "Using GridOptimizedMarshaller on untested JVM (only Java HotSpot VMs were tested) - " + + "object serialization behavior could yield unexpected results.", + "Using GridOptimizedMarshaller on untested JVM."); + } + + myCfg.setUserAttributes(attrs); + myCfg.setMBeanServer(mbSrv == null ? ManagementFactory.getPlatformMBeanServer() : mbSrv); + myCfg.setGridLogger(cfgLog); + myCfg.setMarshaller(marsh); + myCfg.setMarshalLocalJobs(cfg.isMarshalLocalJobs()); + myCfg.setExecutorService(execSvc); + myCfg.setSystemExecutorService(sysExecSvc); + myCfg.setManagementExecutorService(mgmtExecSvc); + myCfg.setPeerClassLoadingExecutorService(p2pExecSvc); + myCfg.setGgfsExecutorService(ggfsExecSvc); + myCfg.setExecutorServiceShutdown(execSvcShutdown); + myCfg.setSystemExecutorServiceShutdown(sysSvcShutdown); + myCfg.setManagementExecutorServiceShutdown(mgmtSvcShutdown); + myCfg.setPeerClassLoadingExecutorServiceShutdown(p2pSvcShutdown); + myCfg.setGgfsExecutorServiceShutdown(ggfsSvcShutdown); + myCfg.setNodeId(nodeId); + + IgniteFsConfiguration[] ggfsCfgs = cfg.getGgfsConfiguration(); + + if (ggfsCfgs != null) { + IgniteFsConfiguration[] clone = ggfsCfgs.clone(); + + for (int i = 0; i < ggfsCfgs.length; i++) + clone[i] = new IgniteFsConfiguration(ggfsCfgs[i]); + + myCfg.setGgfsConfiguration(clone); + } + + StreamerConfiguration[] streamerCfgs = cfg.getStreamerConfiguration(); + + if (streamerCfgs != null) { + StreamerConfiguration[] clone = streamerCfgs.clone(); + + for (int i = 0; i < streamerCfgs.length; i++) + clone[i] = new StreamerConfiguration(streamerCfgs[i]); + + myCfg.setStreamerConfiguration(clone); + } + + if (p2pExclude == null) + p2pExclude = EMPTY_STR_ARR; + + myCfg.setPeerClassLoadingLocalClassPathExclude(p2pExclude); + + /* + * Initialize default SPI implementations. + */ + + if (commSpi == null) + commSpi = new TcpCommunicationSpi(); + + if (discoSpi == null) + discoSpi = new TcpDiscoverySpi(); + + if (discoSpi instanceof TcpDiscoverySpi) { + TcpDiscoverySpi tcpDisco = (TcpDiscoverySpi)discoSpi; + + if (tcpDisco.getIpFinder() == null) + tcpDisco.setIpFinder(new TcpDiscoveryMulticastIpFinder()); + } + + if (evtSpi == null) + evtSpi = new MemoryEventStorageSpi(); + + if (colSpi == null) + colSpi = new NoopCollisionSpi(); + + if (authSpi == null) + authSpi = new NoopAuthenticationSpi(); + + if (sesSpi == null) + sesSpi = new NoopSecureSessionSpi(); + + if (deploySpi == null) + deploySpi = new LocalDeploymentSpi(); + + if (cpSpi == null) + cpSpi = new CheckpointSpi[] {new NoopCheckpointSpi()}; + + if (failSpi == null) + failSpi = new FailoverSpi[] {new AlwaysFailoverSpi()}; + + if (loadBalancingSpi == null) + loadBalancingSpi = new LoadBalancingSpi[] {new RoundRobinLoadBalancingSpi()}; + + if (swapspaceSpi == null) { + boolean needSwap = false; + + CacheConfiguration[] caches = cfg.getCacheConfiguration(); + + if (caches != null) { + for (CacheConfiguration c : caches) { + if (c.isSwapEnabled()) { + needSwap = true; + + break; + } + } + } + + swapspaceSpi = needSwap ? new FileSwapSpaceSpi() : new NoopSwapSpaceSpi(); + } + + if (indexingSpi == null) + indexingSpi = new GridNoopIndexingSpi(); + + myCfg.setCommunicationSpi(commSpi); + myCfg.setDiscoverySpi(discoSpi); + myCfg.setCheckpointSpi(cpSpi); + myCfg.setEventStorageSpi(evtSpi); + myCfg.setAuthenticationSpi(authSpi); + myCfg.setSecureSessionSpi(sesSpi); + myCfg.setDeploymentSpi(deploySpi); + myCfg.setFailoverSpi(failSpi); + myCfg.setCollisionSpi(colSpi); + myCfg.setLoadBalancingSpi(loadBalancingSpi); + myCfg.setSwapSpaceSpi(swapspaceSpi); + myCfg.setIndexingSpi(indexingSpi); + + myCfg.setAddressResolver(cfg.getAddressResolver()); + + // Set SMTP configuration. + myCfg.setSmtpFromEmail(cfg.getSmtpFromEmail()); + myCfg.setSmtpHost(cfg.getSmtpHost()); + myCfg.setSmtpPort(cfg.getSmtpPort()); + myCfg.setSmtpSsl(cfg.isSmtpSsl()); + myCfg.setSmtpUsername(cfg.getSmtpUsername()); + myCfg.setSmtpPassword(cfg.getSmtpPassword()); + myCfg.setAdminEmails(cfg.getAdminEmails()); + + // REST configuration. + myCfg.setClientConnectionConfiguration(clientCfg); + + // Portable configuration. + myCfg.setPortableConfiguration(cfg.getPortableConfiguration()); + + // Hadoop configuration. + myCfg.setHadoopConfiguration(cfg.getHadoopConfiguration()); + + // Validate segmentation configuration. + GridSegmentationPolicy segPlc = cfg.getSegmentationPolicy(); + + // 1. Warn on potential configuration problem: grid is not configured to wait + // for correct segment after segmentation happens. + if (!F.isEmpty(cfg.getSegmentationResolvers()) && segPlc == RESTART_JVM && !cfg.isWaitForSegmentOnStart()) { + U.warn(log, "Found potential configuration problem (forgot to enable waiting for segment" + + "on start?) [segPlc=" + segPlc + ", wait=false]"); + } + + myCfg.setSegmentationResolvers(cfg.getSegmentationResolvers()); + myCfg.setSegmentationPolicy(segPlc); + myCfg.setSegmentCheckFrequency(cfg.getSegmentCheckFrequency()); + myCfg.setWaitForSegmentOnStart(cfg.isWaitForSegmentOnStart()); + myCfg.setAllSegmentationResolversPassRequired(cfg.isAllSegmentationResolversPassRequired()); + + // Override SMTP configuration from system properties + // and environment variables, if specified. + String fromEmail = IgniteSystemProperties.getString(GG_SMTP_FROM); + + if (fromEmail != null) + myCfg.setSmtpFromEmail(fromEmail); + + String smtpHost = IgniteSystemProperties.getString(GG_SMTP_HOST); + + if (smtpHost != null) + myCfg.setSmtpHost(smtpHost); + + String smtpUsername = IgniteSystemProperties.getString(GG_SMTP_USERNAME); + + if (smtpUsername != null) + myCfg.setSmtpUsername(smtpUsername); + + String smtpPwd = IgniteSystemProperties.getString(GG_SMTP_PWD); + + if (smtpPwd != null) + myCfg.setSmtpPassword(smtpPwd); + + int smtpPort = IgniteSystemProperties.getInteger(GG_SMTP_PORT, -1); + + if(smtpPort != -1) + myCfg.setSmtpPort(smtpPort); + + myCfg.setSmtpSsl(IgniteSystemProperties.getBoolean(GG_SMTP_SSL)); + + String adminEmails = IgniteSystemProperties.getString(GG_ADMIN_EMAILS); + + if (adminEmails != null) + myCfg.setAdminEmails(adminEmails.split(",")); + + CacheConfiguration[] cacheCfgs = cfg.getCacheConfiguration(); + + boolean hasHadoop = IgniteComponentType.HADOOP.inClassPath(); + + CacheConfiguration[] copies; + + if (cacheCfgs != null && cacheCfgs.length > 0) { + if (!U.discoOrdered(discoSpi) && !U.relaxDiscoveryOrdered()) + throw new IgniteCheckedException("Discovery SPI implementation does not support node ordering and " + + "cannot be used with cache (use SPI with @GridDiscoverySpiOrderSupport annotation, " + + "like GridTcpDiscoverySpi)"); + + for (CacheConfiguration ccfg : cacheCfgs) { + if (CU.isHadoopSystemCache(ccfg.getName())) + throw new IgniteCheckedException("Cache name cannot be \"" + CU.SYS_CACHE_HADOOP_MR + + "\" because it is reserved for internal purposes."); + + if (CU.isUtilityCache(ccfg.getName())) + throw new IgniteCheckedException("Cache name cannot start with \"" + CU.UTILITY_CACHE_NAME + + "\" because this prefix is reserved for internal purposes."); + } + + copies = new CacheConfiguration[cacheCfgs.length + (hasHadoop ? 2 : 1)]; + + int cloneIdx = 1; + + if (hasHadoop) + copies[cloneIdx++] = CU.hadoopSystemCache(); + + for (CacheConfiguration ccfg : cacheCfgs) + copies[cloneIdx++] = new CacheConfiguration(ccfg); + } + else if (hasHadoop) { + // Populate system caches + copies = new CacheConfiguration[hasHadoop ? 2 : 1]; + + copies[1] = CU.hadoopSystemCache(); + } + else + copies = new CacheConfiguration[1]; + + // Always add utility cache. + copies[0] = utilitySystemCache(discoSpi instanceof TcpClientDiscoverySpi); + + myCfg.setCacheConfiguration(copies); + + myCfg.setCacheSanityCheckEnabled(cfg.isCacheSanityCheckEnabled()); + + try { + // Use reflection to avoid loading undesired classes. + Class helperCls = Class.forName("org.gridgain.grid.util.GridConfigurationHelper"); + + helperCls.getMethod("overrideConfiguration", IgniteConfiguration.class, Properties.class, + String.class, IgniteLogger.class).invoke(helperCls, myCfg, System.getProperties(), name, log); + } + catch (Exception ignored) { + // No-op. + } + + // Ensure that SPIs support multiple grid instances, if required. + if (!startCtx.single()) { + ensureMultiInstanceSupport(deploySpi); + ensureMultiInstanceSupport(commSpi); + ensureMultiInstanceSupport(discoSpi); + ensureMultiInstanceSupport(cpSpi); + ensureMultiInstanceSupport(evtSpi); + ensureMultiInstanceSupport(colSpi); + ensureMultiInstanceSupport(failSpi); + ensureMultiInstanceSupport(authSpi); + ensureMultiInstanceSupport(sesSpi); + ensureMultiInstanceSupport(loadBalancingSpi); + ensureMultiInstanceSupport(swapspaceSpi); + } + + // Register GridGain MBean for current grid instance. + registerFactoryMbean(myCfg.getMBeanServer()); + + boolean started = false; + + try { + IgniteKernal grid0 = new IgniteKernal(startCtx.springContext()); + + // Init here to make grid available to lifecycle listeners. + grid = grid0; + + grid0.start(myCfg, utilityCacheExecSvc, new CA() { + @Override public void apply() { + startLatch.countDown(); + } + }); + + state = STARTED; + + if (log.isDebugEnabled()) + log.debug("Grid factory started ok: " + name); + + started = true; + } + catch (IgniteCheckedException e) { + unregisterFactoryMBean(); + + throw e; + } + // Catch Throwable to protect against any possible failure. + catch (Throwable e) { + unregisterFactoryMBean(); + + throw new IgniteCheckedException("Unexpected exception when starting grid.", e); + } + finally { + if (!started) + // Grid was not started. + grid = null; + } + + // Do NOT set it up only if GRIDGAIN_NO_SHUTDOWN_HOOK=TRUE is provided. + if (!IgniteSystemProperties.getBoolean(GG_NO_SHUTDOWN_HOOK, false)) { + try { + Runtime.getRuntime().addShutdownHook(shutdownHook = new Thread() { + @Override public void run() { + if (log.isInfoEnabled()) + log.info("Invoking shutdown hook..."); + + IgniteNamedInstance.this.stop(true); + } + }); + + if (log.isDebugEnabled()) + log.debug("Shutdown hook is installed."); + } + catch (IllegalStateException e) { + stop(true); + + throw new IgniteCheckedException("Failed to install shutdown hook.", e); + } + } + else { + if (log.isDebugEnabled()) + log.debug("Shutdown hook has not been installed because environment " + + "or system property " + GG_NO_SHUTDOWN_HOOK + " is set."); + } + } + + /** + * @param cfgLog Configured logger. + * @param nodeId Local node ID. + * @return Initialized logger. + * @throws IgniteCheckedException If failed. + */ + private IgniteLogger initLogger(@Nullable IgniteLogger cfgLog, UUID nodeId) throws IgniteCheckedException { + try { + if (cfgLog == null) { + Class<?> log4jCls; + + try { + log4jCls = Class.forName("org.gridgain.grid.logger.log4j.GridLog4jLogger"); + } + catch (ClassNotFoundException | NoClassDefFoundError ignored) { + log4jCls = null; + } + + if (log4jCls != null) { + URL url = U.resolveGridGainUrl("config/gridgain-log4j.xml"); + + if (url == null) { + File cfgFile = new File("config/gridgain-log4j.xml"); + + if (!cfgFile.exists()) + cfgFile = new File("../config/gridgain-log4j.xml"); + + if (cfgFile.exists()) { + try { + url = cfgFile.toURI().toURL(); + } + catch (MalformedURLException ignore) { + // No-op. + } + } + } + + if (url != null) { + boolean configured = (Boolean)log4jCls.getMethod("isConfigured").invoke(null); + + if (configured) + url = null; + } + + if (url != null) { + Constructor<?> ctor = log4jCls.getConstructor(URL.class); + + cfgLog = (IgniteLogger)ctor.newInstance(url); + } + else + cfgLog = (IgniteLogger)log4jCls.newInstance(); + } + else + cfgLog = new IgniteJavaLogger(); + } + + // Set node IDs for all file appenders. + if (cfgLog instanceof IgniteLoggerNodeIdAware) + ((IgniteLoggerNodeIdAware)cfgLog).setNodeId(nodeId); + + return cfgLog; + } + catch (Exception e) { + throw new IgniteCheckedException("Failed to create logger.", e); + } + } + + /** + * Creates utility system cache configuration. + * + * @param client If {@code true} creates client-only cache configuration. + * @return Utility system cache configuration. + */ + private CacheConfiguration utilitySystemCache(boolean client) { + CacheConfiguration cache = new CacheConfiguration(); + + cache.setName(CU.UTILITY_CACHE_NAME); + cache.setCacheMode(REPLICATED); + cache.setAtomicityMode(TRANSACTIONAL); + cache.setSwapEnabled(false); + cache.setQueryIndexEnabled(false); + cache.setPreloadMode(SYNC); + cache.setWriteSynchronizationMode(FULL_SYNC); + cache.setAffinity(new CacheRendezvousAffinityFunction(false, 100)); + + if (client) + cache.setDistributionMode(CLIENT_ONLY); + + return cache; + } + + /** + * Stops grid. + * + * @param cancel Flag indicating whether all currently running jobs + * should be cancelled. + */ + void stop(boolean cancel) { + // Stop cannot be called prior to start from public API, + // since it checks for STARTED state. So, we can assert here. + assert startGuard.get(); + + stop0(cancel); + } + + /** + * @param cancel Flag indicating whether all currently running jobs + * should be cancelled. + */ + private synchronized void stop0(boolean cancel) { + IgniteKernal grid0 = grid; + + // Double check. + if (grid0 == null) { + if (log != null) + U.warn(log, "Attempting to stop an already stopped grid instance (ignore): " + name); + + return; + } + + if (shutdownHook != null) + try { + Runtime.getRuntime().removeShutdownHook(shutdownHook); + + shutdownHook = null; + + if (log.isDebugEnabled()) + log.debug("Shutdown hook is removed."); + } + catch (IllegalStateException e) { + // Shutdown is in progress... + if (log.isDebugEnabled()) + log.debug("Shutdown is in progress (ignoring): " + e.getMessage()); + } + + // Unregister GridGain MBean. + unregisterFactoryMBean(); + + try { + grid0.stop(cancel); + + if (log.isDebugEnabled()) +
<TRUNCATED>
