* 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.

*/

* This abstraction contains the token/identifier of this node

* on the identifier space. This token gets gossiped around.

* This class will also maintain histograms of the load information

* of other nodes in the cluster.

*/

    private static final Logger logger = LoggerFactory.getLogger(StorageService.class);

    public static final int RING_DELAY = getRingDelay(); // delay after which we assume ring has stablized

    /* JMX notification serial number counter */

    private final AtomicLong notificationSerialNumber = new AtomicLong();

    private final AtomicDouble severity = new AtomicDouble();

    private static int getRingDelay()

    {

        String newdelay = System.getProperty("cassandra.ring_delay_ms");

        if (newdelay != null)

        {

            logger.info("Overriding RING_DELAY to {}ms", newdelay);

            return Integer.parseInt(newdelay);

        }

        else

            return 30 * 1000;

    }

    /**

     * This pool is used for periodic short (sub-second) tasks.

     */

     public static final DebuggableScheduledThreadPoolExecutor scheduledTasks = new DebuggableScheduledThreadPoolExecutor("ScheduledTasks");

    /**

     * This pool is used by tasks that can have longer execution times, and usually are non periodic.

     */

    public static final DebuggableScheduledThreadPoolExecutor tasks = new DebuggableScheduledThreadPoolExecutor("NonPeriodicTasks");

    /**

     * tasks that do not need to be waited for on shutdown/drain

     */

    public static final DebuggableScheduledThreadPoolExecutor optionalTasks = new DebuggableScheduledThreadPoolExecutor("OptionalTasks");

    static

    {

        tasks.setExecuteExistingDelayedTasksAfterShutdownPolicy(false);

    }

    /* This abstraction maintains the token/endpoint metadata information */

    private TokenMetadata tokenMetadata = new TokenMetadata();

    public volatile VersionedValue.VersionedValueFactory valueFactory = new VersionedValue.VersionedValueFactory(getPartitioner());

    public static final StorageService instance = new StorageService();

    public static IPartitioner getPartitioner()

    {

        return DatabaseDescriptor.getPartitioner();

    }

    public Collection<Range<Token>> getLocalRanges(String keyspaceName)

    {

        return getRangesForEndpoint(keyspaceName, FBUtilities.getBroadcastAddress());

    }

    public Collection<Range<Token>> getLocalPrimaryRanges(String keyspace)

    {

        return getPrimaryRangesForEndpoint(keyspace, FBUtilities.getBroadcastAddress());

    }

    private final Set<InetAddress> replicatingNodes = Collections.synchronizedSet(new HashSet<InetAddress>());

    private CassandraDaemon daemon;

    private InetAddress removingNode;

    /* Are we starting this node in bootstrap mode? */

    private boolean isBootstrapMode;

    /* we bootstrap but do NOT join the ring unless told to do so */

    private boolean isSurveyMode= Boolean.parseBoolean(System.getProperty("cassandra.write_survey", "false"));

    /* when intialized as a client, we shouldn't write to the system keyspace. */

    private boolean isClientMode;

    private boolean initialized;

    private volatile boolean joined = false;

    /* the probability for tracing any particular request, 0 disables tracing and 1 enables for all */

    private double tracingProbability = 0.0;

    private static enum Mode { STARTING, NORMAL, CLIENT, JOINING, LEAVING, DECOMMISSIONED, MOVING, DRAINING, DRAINED, RELOCATING }

    private Mode operationMode = Mode.STARTING;

    private final MigrationManager migrationManager = MigrationManager.instance;

    /* Used for tracking drain progress */

    private volatile int totalCFs, remainingCFs;

    private static final AtomicInteger nextRepairCommand = new AtomicInteger();

    private static ScheduledRangeTransferExecutorService rangeXferExecutor = new ScheduledRangeTransferExecutorService();

    private final List<IEndpointLifecycleSubscriber> lifecycleSubscribers = new CopyOnWriteArrayList<IEndpointLifecycleSubscriber>();

    private static final BackgroundActivityMonitor bgMonitor = new BackgroundActivityMonitor();

    private final ObjectName jmxObjectName;

    public void finishBootstrapping()

    {

        isBootstrapMode = false;

    }

    /** This method updates the local token on disk  */

    public void setTokens(Collection<Token> tokens)

    {

        if (logger.isDebugEnabled())

            logger.debug("Setting tokens to {}", tokens);

        SystemKeyspace.updateTokens(tokens);

        tokenMetadata.updateNormalTokens(tokens, FBUtilities.getBroadcastAddress());

        // order is important here, the gossiper can fire in between adding these two states.  It's ok to send TOKENS without STATUS, but *not* vice versa.

        Gossiper.instance.addLocalApplicationState(ApplicationState.TOKENS, valueFactory.tokens(getLocalTokens()));

        Gossiper.instance.addLocalApplicationState(ApplicationState.STATUS, valueFactory.normal(getLocalTokens()));

        setMode(Mode.NORMAL, false);

    }

    public StorageService()

    {

        MBeanServer mbs = ManagementFactory.getPlatformMBeanServer();

        try

        {