* Copyright (C) 2008-2014 VoltDB Inc.

*

* This program is free software: you can redistribute it and/or modify

* it under the terms of the GNU Affero General Public License as

* published by the Free Software Foundation, either version 3 of the

* License, or (at your option) any later version.

*

* This program is distributed in the hope that it will be useful,

* but WITHOUT ANY WARRANTY; without even the implied warranty of

* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

* GNU Affero General Public License for more details.

*

* You should have received a copy of the GNU Affero General Public License

* along with VoltDB.  If not, see <http://www.gnu.org/licenses/>.

*/

* RealVoltDB initializes global server components, like the messaging

* layer, ExecutionSite(s), and ClientInterface. It provides accessors

* or references to those global objects. It is basically the global

* namespace. A lot of the global namespace is described by VoltDBInterface

* to allow test mocking.

*/

    private static final boolean DISABLE_JMX;

    static {

        DISABLE_JMX = Boolean.valueOf(System.getProperty("DISABLE_JMX", "false"));

    }

    private static final VoltLogger hostLog = new VoltLogger("HOST");

    private static final VoltLogger consoleLog = new VoltLogger("CONSOLE");

    /** Default deployment file contents if path to deployment is null */

    private static final String[] defaultDeploymentXML = {

        "<?xml version=\"1.0\"?>",

        "<!-- IMPORTANT: This file is an auto-generated default deployment configuration.",

        "                Changes to this file will be overwritten. Copy it elsewhere if you",

        "                want to use it as a starting point for a custom configuration. -->",

        "<deployment>",

        "   <cluster hostcount=\"1\" />",

        "   <httpd enabled=\"true\">",

        "      <jsonapi enabled=\"true\" />",

        "   </httpd>",

        "</deployment>"

    };

    public VoltDB.Configuration m_config = new VoltDB.Configuration();

    int m_configuredNumberOfPartitions;

    int m_configuredReplicationFactor;

    // CatalogContext is immutable, just make sure that accessors see a consistent version

    volatile CatalogContext m_catalogContext;

    private String m_buildString;

    static final String m_defaultVersionString = "4.9";

    // by default set the version to only be compatible with itself

    static final String m_defaultHotfixableRegexPattern = "^\\Q4.9\\E\\z";

    // these next two are non-static because they can be overrriden on the CLI for test

    private String m_versionString = m_defaultVersionString;

    private String m_hotfixableRegexPattern = m_defaultHotfixableRegexPattern;

    HostMessenger m_messenger = null;

    private ClientInterface m_clientInterface = null;

    HTTPAdminListener m_adminListener;

    private OpsRegistrar m_opsRegistrar = new OpsRegistrar();

    private AsyncCompilerAgent m_asyncCompilerAgent = new AsyncCompilerAgent();

    public AsyncCompilerAgent getAsyncCompilerAgent() { return m_asyncCompilerAgent; }

    private PartitionCountStats m_partitionCountStats = null;

    private IOStats m_ioStats = null;

    private MemoryStats m_memoryStats = null;

    private CpuStats m_cpuStats = null;

    private StatsManager m_statsManager = null;

    private SnapshotCompletionMonitor m_snapshotCompletionMonitor;

    // These are unused locally, but they need to be registered with the StatsAgent so they're

    // globally available

    @SuppressWarnings("unused")

    private InitiatorStats m_initiatorStats;

    private LiveClientsStats m_liveClientsStats = null;

    int m_myHostId;

    String m_httpPortExtraLogMessage = null;

    boolean m_jsonEnabled;

    DeploymentType m_deployment;

    // IV2 things

    List<Initiator> m_iv2Initiators = new ArrayList<Initiator>();

    Cartographer m_cartographer = null;

    LeaderAppointer m_leaderAppointer = null;

    GlobalServiceElector m_globalServiceElector = null;

    MpInitiator m_MPI = null;

    Map<Integer, Long> m_iv2InitiatorStartingTxnIds = new HashMap<Integer, Long>();

    // Should the execution sites be started in recovery mode

    // (used for joining a node to an existing cluster)

    // If CL is enabled this will be set to true

    // by the CL when the truncation snapshot completes

    // and this node is viable for replay

    volatile boolean m_rejoining = false;

    // Need to separate the concepts of rejoin data transfer and rejoin

    // completion.  This boolean tracks whether or not the data transfer

    // process is done.  CL truncation snapshots will not flip the all-complete

    // boolean until no mode data is pending.

    // Yes, this is fragile having two booleans.  We could aggregate them into

    // some rejoining state enum at some point.

    volatile boolean m_rejoinDataPending = false;

    // Since m_rejoinDataPending is set asynchronously, sites could have inconsistent

    // view of what the value is during the execution of a sysproc. Use this and

    // m_safeMpTxnId to prevent the race. The m_safeMpTxnId is updated once in the

    // lifetime of the node to reflect the first MP txn that witnessed the flip of

    // m_rejoinDataPending.

    private final Object m_safeMpTxnIdLock = new Object();

    private long m_lastSeenMpTxnId = Long.MIN_VALUE;

    private long m_safeMpTxnId = Long.MAX_VALUE;

    String m_rejoinTruncationReqId = null;

    // Are we adding the node to the cluster instead of rejoining?

    volatile boolean m_joining = false;

    boolean m_replicationActive = false;

    private NodeDRGateway m_nodeDRGateway = null;

    //Only restrict recovery completion during test

    static Semaphore m_testBlockRecoveryCompletion = new Semaphore(Integer.MAX_VALUE);

    private long m_executionSiteRecoveryFinish;

    private long m_executionSiteRecoveryTransferred;

    // Rejoin coordinator

    private JoinCoordinator m_joinCoordinator = null;

    private ElasticJoinService m_elasticJoinService = null;

    // Snapshot IO agent

    private SnapshotIOAgent m_snapshotIOAgent = null;

    // id of the leader, or the host restore planner says has the catalog

    int m_hostIdWithStartupCatalog;

    String m_pathToStartupCatalog;

    // Synchronize initialize and shutdown

    private final Object m_startAndStopLock = new Object();

    // Synchronize updates of catalog contexts across the multiple sites on this host.

    // Ensure that the first site to reach catalogUpdate() does all the work and that no

    // others enter until that's finished.  CatalogContext is immutable and volatile, accessors

    // should be able to always get a valid context without needing this lock.

    private final Object m_catalogUpdateLock = new Object();

    // add a random number to the sampler output to make it likely to be unique for this process.

    private final VoltSampler m_sampler = new VoltSampler(10, "sample" + String.valueOf(new Random().nextInt() % 10000) + ".txt");

    private final AtomicBoolean m_hasStartedSampler = new AtomicBoolean(false);

    List<Integer> m_partitionsToSitesAtStartupForExportInit;

    RestoreAgent m_restoreAgent = null;

    private ListeningExecutorService m_es = CoreUtils.getCachedSingleThreadExecutor("StartAction ZK Watcher", 15000);

    private volatile boolean m_isRunning = false;

    @Override

    public boolean rejoining() { return m_rejoining; }

    @Override

    public boolean rejoinDataPending() { return m_rejoinDataPending; }

    @Override

    public boolean isMpSysprocSafeToExecute(long txnId)

    {

        synchronized (m_safeMpTxnIdLock) {

            if (txnId >= m_safeMpTxnId) {

                return true;

            }

            if (txnId > m_lastSeenMpTxnId) {

                m_lastSeenMpTxnId = txnId;

                if (!rejoinDataPending() && m_safeMpTxnId == Long.MAX_VALUE) {

                    m_safeMpTxnId = txnId;

                }

            }

            return txnId >= m_safeMpTxnId;

        }

    }

    private long m_recoveryStartTime;

    CommandLog m_commandLog;

    private volatile OperationMode m_mode = OperationMode.INITIALIZING;

    private OperationMode m_startMode = null;

    volatile String m_localMetadata = "";

    private ListeningExecutorService m_computationService;

    private Thread m_configLogger;

    // methods accessed via the singleton

    @Override

    public void startSampler() {

        if (m_hasStartedSampler.compareAndSet(false, true)) {

            m_sampler.start();

        }

    }

    private ScheduledThreadPoolExecutor m_periodicWorkThread;

    private ScheduledThreadPoolExecutor m_periodicPriorityWorkThread;

    // The configured license api: use to decide enterprise/community edition feature enablement

    LicenseApi m_licenseApi;

    @SuppressWarnings("unused")

    private LatencyStats m_latencyStats;

    private LatencyHistogramStats m_latencyHistogramStats;

    @Override

    public LicenseApi getLicenseApi() {

        return m_licenseApi;

    }

    /**

     * Initialize all the global components, then initialize all the m_sites.

     */

    @Override

    public void initialize(VoltDB.Configuration config) {

        ShutdownHooks.enableServerStopLogging();

        synchronized(m_startAndStopLock) {

            // check that this is a 64 bit VM

            if (System.getProperty("java.vm.name").contains("64") == false) {

                hostLog.fatal("You are running on an unsupported (probably 32 bit) JVM. Exiting.");

                System.exit(-1);

            }

            consoleLog.l7dlog( Level.INFO, LogKeys.host_VoltDB_StartupString.name(), null);

            // If there's no deployment provide a default and put it under voltdbroot.

            if (config.m_pathToDeployment == null) {

                try {

                    config.m_pathToDeployment = setupDefaultDeployment();

                    config.m_deploymentDefault = true;

                } catch (IOException e) {

                    VoltDB.crashLocalVoltDB("Failed to write default deployment.", false, null);

                }

            }

            // set the mode first thing

            m_mode = OperationMode.INITIALIZING;

            m_config = config;

            m_startMode = null;

            // set a bunch of things to null/empty/new for tests

            // which reusue the process

            m_safeMpTxnId = Long.MAX_VALUE;

            m_lastSeenMpTxnId = Long.MIN_VALUE;

            m_clientInterface = null;

            m_adminListener = null;

            m_commandLog = new DummyCommandLog();

            m_deployment = null;

            m_messenger = null;

            m_startMode = null;

            m_opsRegistrar = new OpsRegistrar();

            m_asyncCompilerAgent = new AsyncCompilerAgent();

            m_snapshotCompletionMonitor = null;

            m_catalogContext = null;

            m_partitionCountStats = null;

            m_ioStats = null;

            m_memoryStats = null;

            m_statsManager = null;

            m_restoreAgent = null;

            m_recoveryStartTime = System.currentTimeMillis();

            m_hostIdWithStartupCatalog = 0;

            m_pathToStartupCatalog = m_config.m_pathToCatalog;

            m_replicationActive = false;

            m_configLogger = null;

            ActivePlanRepository.clear();

            // set up site structure

            final int computationThreads = Math.max(2, CoreUtils.availableProcessors() / 4);

            m_computationService =

                    CoreUtils.getListeningExecutorService(

                            "Computation service thread",

                            computationThreads, m_config.m_computationCoreBindings);

            // determine if this is a rejoining node

            // (used for license check and later the actual rejoin)

            boolean isRejoin = false;

            if (config.m_startAction.doesRejoin()) {

                isRejoin = true;

            }

            m_rejoining = isRejoin;

            m_rejoinDataPending = isRejoin || config.m_startAction == StartAction.JOIN;

            m_joining = config.m_startAction == StartAction.JOIN;

            // Set std-out/err to use the UTF-8 encoding and fail if UTF-8 isn't supported

            try {

                System.setOut(new PrintStream(System.out, true, "UTF-8"));

                System.setErr(new PrintStream(System.err, true, "UTF-8"));

            } catch (UnsupportedEncodingException e) {

                hostLog.fatal("Support for the UTF-8 encoding is required for VoltDB. This means you are likely running an unsupported JVM. Exiting.");

                System.exit(-1);

            }

            m_snapshotCompletionMonitor = new SnapshotCompletionMonitor();

            readBuildInfo(config.m_isEnterprise ? "Enterprise Edition" : "Community Edition");

            // Replay command line args that we can see

            StringBuilder sb = new StringBuilder(2048).append("Command line arguments: ");

            sb.append(System.getProperty("sun.java.command", "[not available]"));

            hostLog.info(sb.toString());

            List<String> iargs = ManagementFactory.getRuntimeMXBean().getInputArguments();

            sb.delete(0, sb.length()).append("Command line JVM arguments:");

            for (String iarg : iargs)

                sb.append(" ").append(iarg);

            if (iargs.size() > 0) hostLog.info(sb.toString());

            else hostLog.info("No JVM command line args known.");

            sb.delete(0, sb.length()).append("Command line JVM classpath: ");

            sb.append(System.getProperty("java.class.path", "[not available]"));

            hostLog.info(sb.toString());

            // use CLI overrides for testing hotfix version compatibility

            if (m_config.m_versionStringOverrideForTest != null) {

                m_versionString = m_config.m_versionStringOverrideForTest;

            }

            if (m_config.m_versionCompatibilityRegexOverrideForTest != null) {

                m_hotfixableRegexPattern = m_config.m_versionCompatibilityRegexOverrideForTest;

            }

            buildClusterMesh(isRejoin || m_joining);

            //Register dummy agents immediately

            m_opsRegistrar.registerMailboxes(m_messenger);

            //Start validating the build string in the background

            final Future<?> buildStringValidation = validateBuildString(getBuildString(), m_messenger.getZK());

            // race to create start action nodes and then verify theirs compatibility.

            m_messenger.getZK().create(VoltZK.start_action, null, Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT, new ZKUtil.StringCallback(), null);

            VoltZK.createStartActionNode(m_messenger.getZK(), m_messenger.getHostId(), m_config.m_startAction);

            validateStartAction();

            final int numberOfNodes = readDeploymentAndCreateStarterCatalogContext();

            if (!isRejoin && !m_joining) {

                m_messenger.waitForGroupJoin(numberOfNodes);

            }

            // Create the thread pool here. It's needed by buildClusterMesh()

            m_periodicWorkThread =

                    CoreUtils.getScheduledThreadPoolExecutor("Periodic Work", 1, CoreUtils.SMALL_STACK_SIZE);

            m_periodicPriorityWorkThread =

                    CoreUtils.getScheduledThreadPoolExecutor("Periodic Priority Work", 1, CoreUtils.SMALL_STACK_SIZE);

            Class<?> snapshotIOAgentClass = MiscUtils.loadProClass("org.voltdb.SnapshotIOAgentImpl", "Snapshot", true);

            if (snapshotIOAgentClass != null) {

                try {

                    m_snapshotIOAgent = (SnapshotIOAgent) snapshotIOAgentClass.getConstructor(HostMessenger.class, long.class)

                            .newInstance(m_messenger, m_messenger.getHSIdForLocalSite(HostMessenger.SNAPSHOT_IO_AGENT_ID));

                    m_messenger.createMailbox(m_snapshotIOAgent.getHSId(), m_snapshotIOAgent);

                } catch (Exception e) {

                    VoltDB.crashLocalVoltDB("Failed to instantiate snapshot IO agent", true, e);

                }

            }

            if (m_config.m_pathToLicense == null) {

                m_licenseApi = MiscUtils.licenseApiFactory();

                if (m_licenseApi == null) {

                    hostLog.fatal("Unable to open license file in default directories");

                }

            }

            else {

                m_licenseApi = MiscUtils.licenseApiFactory(m_config.m_pathToLicense);

                if (m_licenseApi == null) {

                    hostLog.fatal("Unable to open license file in provided path: " + m_config.m_pathToLicense);

                }

            }

            if (m_licenseApi == null) {

                hostLog.fatal("Please contact sales@voltdb.com to request a license.");

                VoltDB.crashLocalVoltDB("Failed to initialize license verifier. " +

                        "See previous log message for details.", false, null);

            }

            // Create the GlobalServiceElector.  Do this here so we can register the MPI with it

            // when we construct it below

            m_globalServiceElector = new GlobalServiceElector(m_messenger.getZK(), m_messenger.getHostId());

            // Start the GlobalServiceElector.  Not sure where this will actually belong.

            try {

                m_globalServiceElector.start();

            } catch (Exception e) {

                VoltDB.crashLocalVoltDB("Unable to start GlobalServiceElector", true, e);

            }

            // Always create a mailbox for elastic join data transfer

            if (m_config.m_isEnterprise) {

                long elasticHSId = m_messenger.getHSIdForLocalSite(HostMessenger.REBALANCE_SITE_ID);

                m_messenger.createMailbox(elasticHSId, new SiteMailbox(m_messenger, elasticHSId));

            }

            if (m_joining) {

                Class<?> elasticJoinCoordClass =

                        MiscUtils.loadProClass("org.voltdb.join.ElasticJoinNodeCoordinator", "Elastic", false);

                try {

                    Constructor<?> constructor = elasticJoinCoordClass.getConstructor(HostMessenger.class, String.class);

                    m_joinCoordinator = (JoinCoordinator) constructor.newInstance(m_messenger, m_catalogContext.cluster.getVoltroot());

                    m_messenger.registerMailbox(m_joinCoordinator);

                    m_joinCoordinator.initialize(m_deployment.getCluster().getKfactor());

                } catch (Exception e) {

                    VoltDB.crashLocalVoltDB("Failed to instantiate join coordinator", true, e);

                }

            }

            /*

             * Construct all the mailboxes for things that need to be globally addressable so they can be published

             * in one atomic shot.

             *

             * The starting state for partition assignments are statically derived from the host id generated

             * by host messenger and the k-factor/host count/sites per host. This starting state

             * is published to ZK as the topology metadata node.

             *

             * On join and rejoin the node has to inspect the topology meta node to find out what is missing

             * and then update the topology listing itself as the replica for those partitions.

             * Then it does a compare and set of the topology.

             *

             * Ning: topology may not reflect the true partitions in the cluster during join. So if another node

             * is trying to rejoin, it should rely on the cartographer's view to pick the partitions to replace.

             */

            JSONObject topo = getTopology(config.m_startAction, m_joinCoordinator);

            m_partitionsToSitesAtStartupForExportInit = new ArrayList<Integer>();

            try {

                // IV2 mailbox stuff

                ClusterConfig clusterConfig = new ClusterConfig(topo);

                m_configuredReplicationFactor = clusterConfig.getReplicationFactor();

                m_cartographer = new Cartographer(m_messenger, m_configuredReplicationFactor,

                        m_catalogContext.cluster.getNetworkpartition());

                List<Integer> partitions = null;

                if (isRejoin) {

                    m_configuredNumberOfPartitions = m_cartographer.getPartitionCount();

                    partitions = m_cartographer.getIv2PartitionsToReplace(m_configuredReplicationFactor,

                                                                          clusterConfig.getSitesPerHost());

                    if (partitions.size() == 0) {

                        VoltDB.crashLocalVoltDB("The VoltDB cluster already has enough nodes to satisfy " +

                                "the requested k-safety factor of " +

                                m_configuredReplicationFactor + ".\n" +

                                "No more nodes can join.", false, null);

                    }

                }

                else {

                    m_configuredNumberOfPartitions = clusterConfig.getPartitionCount();

                    partitions = ClusterConfig.partitionsForHost(topo, m_messenger.getHostId());

                }

                for (int ii = 0; ii < partitions.size(); ii++) {

                    Integer partition = partitions.get(ii);

                    m_iv2InitiatorStartingTxnIds.put( partition, TxnEgo.makeZero(partition).getTxnId());

                }

                m_iv2Initiators = createIv2Initiators(

                        partitions,

                        m_config.m_startAction,

                        m_partitionsToSitesAtStartupForExportInit);

                m_iv2InitiatorStartingTxnIds.put(

                        MpInitiator.MP_INIT_PID,

                        TxnEgo.makeZero(MpInitiator.MP_INIT_PID).getTxnId());

                // Pass the local HSIds to the MPI so it can farm out buddy sites

                // to the RO MP site pool

                List<Long> localHSIds = new ArrayList<Long>();

                for (Initiator ii : m_iv2Initiators) {

                    localHSIds.add(ii.getInitiatorHSId());

                }

                m_MPI = new MpInitiator(m_messenger, localHSIds, getStatsAgent());

                m_iv2Initiators.add(m_MPI);

                // Make a list of HDIds to join

                Map<Integer, Long> partsToHSIdsToRejoin = new HashMap<Integer, Long>();

                for (Initiator init : m_iv2Initiators) {

                    if (init.isRejoinable()) {

                        partsToHSIdsToRejoin.put(init.getPartitionId(), init.getInitiatorHSId());

                    }

                }

                OnDemandBinaryLogger.path = m_catalogContext.cluster.getVoltroot();

                if (isRejoin) {

                    SnapshotSaveAPI.recoveringSiteCount.set(partsToHSIdsToRejoin.size());

                    hostLog.info("Set recovering site count to " + partsToHSIdsToRejoin.size());

                    m_joinCoordinator = new Iv2RejoinCoordinator(m_messenger,

                            partsToHSIdsToRejoin.values(),

                            m_catalogContext.cluster.getVoltroot(),

                            m_config.m_startAction == StartAction.LIVE_REJOIN);

                    m_messenger.registerMailbox(m_joinCoordinator);

                    if (m_config.m_startAction == StartAction.LIVE_REJOIN) {

                        hostLog.info("Using live rejoin.");

                    }

                    else {

                        hostLog.info("Using blocking rejoin.");

                    }

                } else if (m_joining) {

                    m_joinCoordinator.setPartitionsToHSIds(partsToHSIdsToRejoin);

                }

            } catch (Exception e) {

                VoltDB.crashLocalVoltDB(e.getMessage(), true, e);

            }

            // do the many init tasks in the Inits class

            Inits inits = new Inits(this, 1);

            inits.doInitializationWork();

            // Need the catalog so that we know how many tables so we can guess at the necessary heap size

            // This is done under Inits.doInitializationWork(), so need to wait until we get here.

            // Current calculation needs pro/community knowledge, number of tables, and the sites/host,

            // which is the number of initiators (minus the possibly idle MPI initiator)

            checkHeapSanity(MiscUtils.isPro(), m_catalogContext.tables.size(),

                    (m_iv2Initiators.size() - 1), m_configuredReplicationFactor);

            if (m_joining && m_config.m_replicationRole == ReplicationRole.REPLICA) {

                VoltDB.crashLocalVoltDB("Elastic join is prohibited on a replica cluster.", false, null);

            }

            collectLocalNetworkMetadata();

            /*

             * Construct an adhoc planner for the initial catalog

             */

            final CatalogSpecificPlanner csp = new CatalogSpecificPlanner(m_asyncCompilerAgent, m_catalogContext);

            // DR overflow directory

            File drOverflowDir = new File(m_catalogContext.cluster.getVoltroot(), "dr_overflow");

            if (m_config.m_isEnterprise) {

                try {

                    Class<?> ndrgwClass = null;

                    if (Boolean.getBoolean("USE_DR_V2")) {

                        ndrgwClass = Class.forName("org.voltdb.dr2.InvocationBufferServer");

                    } else {

                        ndrgwClass = Class.forName("org.voltdb.dr.InvocationBufferServer");

                    }

                    Constructor<?> ndrgwConstructor = ndrgwClass.getConstructor(File.class, boolean.class);

                    m_nodeDRGateway = (NodeDRGateway) ndrgwConstructor.newInstance(drOverflowDir,

                                                                                   m_replicationActive);

                } catch (Exception e) {

                    VoltDB.crashLocalVoltDB("Unable to load DR system", true, e);

                }

            }

            // Initialize stats

            m_ioStats = new IOStats();

            getStatsAgent().registerStatsSource(StatsSelector.IOSTATS,

                    0, m_ioStats);

            m_memoryStats = new MemoryStats();

            getStatsAgent().registerStatsSource(StatsSelector.MEMORY,

                    0, m_memoryStats);

            getStatsAgent().registerStatsSource(StatsSelector.TOPO, 0, m_cartographer);

            m_partitionCountStats = new PartitionCountStats(m_cartographer);

            getStatsAgent().registerStatsSource(StatsSelector.PARTITIONCOUNT,

                    0, m_partitionCountStats);

            m_initiatorStats = new InitiatorStats(m_myHostId);

            m_liveClientsStats = new LiveClientsStats();

            getStatsAgent().registerStatsSource(StatsSelector.LIVECLIENTS, 0, m_liveClientsStats);

            m_latencyStats = new LatencyStats(m_myHostId);

            getStatsAgent().registerStatsSource(StatsSelector.LATENCY, 0, m_latencyStats);

            m_latencyHistogramStats = new LatencyHistogramStats(m_myHostId);

            getStatsAgent().registerStatsSource(StatsSelector.LATENCY_HISTOGRAM,

                    0, m_latencyHistogramStats);

            BalancePartitionsStatistics rebalanceStats = new BalancePartitionsStatistics();

            getStatsAgent().registerStatsSource(StatsSelector.REBALANCE, 0, rebalanceStats);

            KSafetyStats kSafetyStats = new KSafetyStats();

            getStatsAgent().registerStatsSource(StatsSelector.KSAFETY, 0, kSafetyStats);