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

*/

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

    public static final ExecutorService postFlushExecutor = new JMXEnabledThreadPoolExecutor("MemtablePostFlusher");

    public final Keyspace keyspace;

    public final String name;

    public final CFMetaData metadata;

    public final IPartitioner partitioner;

    private final String mbeanName;

    private volatile boolean valid = true;

    /* Memtables and SSTables on disk for this column family */

    private final DataTracker data;

    /* This is used to generate the next index for a SSTable */

    private final AtomicInteger fileIndexGenerator = new AtomicInteger(0);

    public final SecondaryIndexManager indexManager;

    private static final int INTERN_CUTOFF = 256;

    public final ConcurrentMap<ByteBuffer, ByteBuffer> internedNames = new NonBlockingHashMap<ByteBuffer, ByteBuffer>();

    /* These are locally held copies to be changed from the config during runtime */

    private volatile DefaultInteger minCompactionThreshold;

    private volatile DefaultInteger maxCompactionThreshold;

    private volatile AbstractCompactionStrategy compactionStrategy;

    public final Directories directories;

    /** ratio of in-memory memtable size, to serialized size */

    volatile double liveRatio = 10.0; // reasonable default until we compute what it is based on actual data

    /** ops count last time we computed liveRatio */

    private final AtomicLong liveRatioComputedAt = new AtomicLong(32);

    public final ColumnFamilyMetrics metric;

    public volatile long sampleLatencyNanos;

    public void reload()

    {

        // metadata object has been mutated directly. make all the members jibe with new settings.

        // only update these runtime-modifiable settings if they have not been modified.

        if (!minCompactionThreshold.isModified())

            for (ColumnFamilyStore cfs : concatWithIndexes())

                cfs.minCompactionThreshold = new DefaultInteger(metadata.getMinCompactionThreshold());

        if (!maxCompactionThreshold.isModified())

            for (ColumnFamilyStore cfs : concatWithIndexes())

                cfs.maxCompactionThreshold = new DefaultInteger(metadata.getMaxCompactionThreshold());

        maybeReloadCompactionStrategy();

        scheduleFlush();

        indexManager.reload();

        // If the CF comparator has changed, we need to change the memtable,

        // because the old one still aliases the previous comparator.

        if (getMemtableThreadSafe().initialComparator != metadata.comparator)

            switchMemtable(true, true);

    }

    private void maybeReloadCompactionStrategy()

    {

        // Check if there is a need for reloading

        if (metadata.compactionStrategyClass.equals(compactionStrategy.getClass()) && metadata.compactionStrategyOptions.equals(compactionStrategy.options))

            return;

        // synchronize vs runWithCompactionsDisabled calling pause/resume.  otherwise, letting old compactions

        // finish should be harmless and possibly useful.

        synchronized (this)

        {

            compactionStrategy.shutdown();

            compactionStrategy = metadata.createCompactionStrategyInstance(this);

        }

    }

    void scheduleFlush()

    {

        int period = metadata.getMemtableFlushPeriod();

        if (period > 0)

        {

            logger.debug("scheduling flush in {} ms", period);

            WrappedRunnable runnable = new WrappedRunnable()

            {

                protected void runMayThrow() throws Exception

                {

                    if (getMemtableThreadSafe().isExpired())

                    {

                        // if memtable is already expired but didn't flush because it's empty,

                        // then schedule another flush.

                        if (isClean())

                            scheduleFlush();

                        else

                            forceFlush(); // scheduleFlush() will be called by the constructor of the new memtable.

                    }

                }

            };

            StorageService.scheduledTasks.schedule(runnable, period, TimeUnit.MILLISECONDS);

        }

    }

    public void setCompactionStrategyClass(String compactionStrategyClass)

    {

        try

        {

            metadata.compactionStrategyClass = CFMetaData.createCompactionStrategy(compactionStrategyClass);

            maybeReloadCompactionStrategy();

        }

        catch (ConfigurationException e)

        {

            throw new IllegalArgumentException(e.getMessage());

        }

    }

    public String getCompactionStrategyClass()

    {

        return metadata.compactionStrategyClass.getName();

    }

    public Map<String,String> getCompressionParameters()

    {

        return metadata.compressionParameters().asThriftOptions();

    }

    public void setCompressionParameters(Map<String,String> opts)

    {

        try

        {

            metadata.compressionParameters = CompressionParameters.create(opts);

        }

        catch (ConfigurationException e)

        {

            throw new IllegalArgumentException(e.getMessage());

        }

    }

    public void setCrcCheckChance(double crcCheckChance)

    {

        try

        {

            for (SSTableReader sstable : keyspace.getAllSSTables())

                if (sstable.compression)

                    sstable.getCompressionMetadata().parameters.setCrcCheckChance(crcCheckChance);

        }

        catch (ConfigurationException e)

        {

            throw new IllegalArgumentException(e.getMessage());

        }

    }

    private ColumnFamilyStore(Keyspace keyspace,

                              String columnFamilyName,

                              IPartitioner partitioner,

                              int generation,

                              CFMetaData metadata,

                              Directories directories,

                              boolean loadSSTables)

    {

        assert metadata != null : "null metadata for " + keyspace + ":" + columnFamilyName;

        this.keyspace = keyspace;

        name = columnFamilyName;

        this.metadata = metadata;

        this.minCompactionThreshold = new DefaultInteger(metadata.getMinCompactionThreshold());

        this.maxCompactionThreshold = new DefaultInteger(metadata.getMaxCompactionThreshold());

        this.partitioner = partitioner;

        this.directories = directories;

        this.indexManager = new SecondaryIndexManager(this);

        this.metric = new ColumnFamilyMetrics(this);

        fileIndexGenerator.set(generation);

        sampleLatencyNanos = DatabaseDescriptor.getReadRpcTimeout() / 2;

        Caching caching = metadata.getCaching();

        logger.info("Initializing {}.{}", keyspace.getName(), name);

        // scan for sstables corresponding to this cf and load them

        data = new DataTracker(this);

        if (loadSSTables)

        {

            Directories.SSTableLister sstableFiles = directories.sstableLister().skipTemporary(true);

            Collection<SSTableReader> sstables = SSTableReader.openAll(sstableFiles.list().entrySet(), metadata, this.partitioner);

            data.addInitialSSTables(sstables);

        }

        if (caching == Caching.ALL || caching == Caching.KEYS_ONLY)

            CacheService.instance.keyCache.loadSaved(this);

        // compaction strategy should be created after the CFS has been prepared

        this.compactionStrategy = metadata.createCompactionStrategyInstance(this);

        if (maxCompactionThreshold.value() <= 0 || minCompactionThreshold.value() <=0)

        {

            logger.warn("Disabling compaction strategy by setting compaction thresholds to 0 is deprecated, set the compaction option 'enabled' to 'false' instead.");

            this.compactionStrategy.disable();

        }

        // create the private ColumnFamilyStores for the secondary column indexes

        for (ColumnDefinition info : metadata.allColumns())

        {

            if (info.getIndexType() != null)

                indexManager.addIndexedColumn(info);

        }

        // register the mbean

        String type = this.partitioner instanceof LocalPartitioner ? "IndexColumnFamilies" : "ColumnFamilies";

        mbeanName = "org.apache.cassandra.db:type=" + type + ",keyspace=" + this.keyspace.getName() + ",columnfamily=" + name;

        try

        {

            MBeanServer mbs = ManagementFactory.getPlatformMBeanServer();

            ObjectName nameObj = new ObjectName(mbeanName);

            mbs.registerMBean(this, nameObj);

        }

        catch (Exception e)

        {

            throw new RuntimeException(e);

        }

        StorageService.optionalTasks.scheduleWithFixedDelay(new Runnable()

        {

            public void run()

            {

                SpeculativeRetry retryPolicy = ColumnFamilyStore.this.metadata.getSpeculativeRetry();

                logger.debug("retryPolicy for {} is {}", name, retryPolicy.value);

                switch (retryPolicy.type)

                {

                    case PERCENTILE:

                        // get percentile in nanos

                        assert metric.coordinatorReadLatency.durationUnit() == TimeUnit.MICROSECONDS;

                        sampleLatencyNanos = (long) (metric.coordinatorReadLatency.getSnapshot().getValue(retryPolicy.value) * 1000d);

                        break;

                    case CUSTOM:

                        // convert to nanos, since configuration is in millisecond

                        sampleLatencyNanos = (long) (retryPolicy.value * 1000d * 1000d);

                        break;

                    default:

                        sampleLatencyNanos = Long.MAX_VALUE;

                        break;

                }

            }

        }, DatabaseDescriptor.getReadRpcTimeout(), DatabaseDescriptor.getReadRpcTimeout(), TimeUnit.MILLISECONDS);

    }

    /** call when dropping or renaming a CF. Performs mbean housekeeping and invalidates CFS to other operations */

    public void invalidate()

    {

        try

        {

            valid = false;

            unregisterMBean();

            SystemKeyspace.removeTruncationRecord(metadata.cfId);

            data.unreferenceSSTables();

            indexManager.invalidate();

            for (RowCacheKey key : CacheService.instance.rowCache.getKeySet())

            {

                if (key.cfId == metadata.cfId)

                    invalidateCachedRow(key);

            }

        }

        catch (Exception e)

        {

            // this shouldn't block anything.

            logger.warn("Failed unregistering mbean: " + mbeanName, e);

        }

    }

    /**

     * Removes every SSTable in the directory from the DataTracker's view.

     * @param directory the unreadable directory, possibly with SSTables in it, but not necessarily.

     */

    void maybeRemoveUnreadableSSTables(File directory)

    {

        data.removeUnreadableSSTables(directory);

    }

    void unregisterMBean() throws MalformedObjectNameException, InstanceNotFoundException, MBeanRegistrationException

    {

        MBeanServer mbs = ManagementFactory.getPlatformMBeanServer();

        ObjectName nameObj = new ObjectName(mbeanName);

        if (mbs.isRegistered(nameObj))

            mbs.unregisterMBean(nameObj);

        // unregister metrics

        metric.release();

    }

    public long getMinRowSize()

    {

        return metric.minRowSize.value();

    }

    public long getMaxRowSize()

    {

        return metric.maxRowSize.value();

    }

    public long getMeanRowSize()

    {

        return metric.meanRowSize.value();

    }

    public int getMeanColumns()

    {

        return data.getMeanColumns();

    }

    public static ColumnFamilyStore createColumnFamilyStore(Keyspace keyspace, String columnFamily, boolean loadSSTables)

    {

        return createColumnFamilyStore(keyspace, columnFamily, StorageService.getPartitioner(), Schema.instance.getCFMetaData(keyspace.getName(), columnFamily), loadSSTables);

    }

    public static ColumnFamilyStore createColumnFamilyStore(Keyspace keyspace, String columnFamily, IPartitioner partitioner, CFMetaData metadata)

    {

        return createColumnFamilyStore(keyspace, columnFamily, partitioner, metadata, true);

    }

    private static synchronized ColumnFamilyStore createColumnFamilyStore(Keyspace keyspace,

                                                                         String columnFamily,

                                                                         IPartitioner partitioner,

                                                                         CFMetaData metadata,

                                                                         boolean loadSSTables)

    {

        // get the max generation number, to prevent generation conflicts

        Directories directories = Directories.create(keyspace.getName(), columnFamily);

        Directories.SSTableLister lister = directories.sstableLister().includeBackups(true);

        List<Integer> generations = new ArrayList<Integer>();

        for (Map.Entry<Descriptor, Set<Component>> entry : lister.list().entrySet())

        {

            Descriptor desc = entry.getKey();

            generations.add(desc.generation);

            if (!desc.isCompatible())

                throw new RuntimeException(String.format("Can't open incompatible SSTable! Current version %s, found file: %s", Descriptor.Version.CURRENT, desc));

        }

        Collections.sort(generations);

        int value = (generations.size() > 0) ? (generations.get(generations.size() - 1)) : 0;

        return new ColumnFamilyStore(keyspace, columnFamily, partitioner, value, metadata, directories, loadSSTables);

    }

    /**

     * Removes unnecessary files from the cf directory at startup: these include temp files, orphans, zero-length files

     * and compacted sstables. Files that cannot be recognized will be ignored.

     */

    public static void scrubDataDirectories(String keyspaceName, String columnFamily)

    {

        logger.debug("Removing compacted SSTable files from {} (see http://wiki.apache.org/cassandra/MemtableSSTable)", columnFamily);

        Directories directories = Directories.create(keyspaceName, columnFamily);

        for (Map.Entry<Descriptor,Set<Component>> sstableFiles : directories.sstableLister().list().entrySet())

        {

            Descriptor desc = sstableFiles.getKey();

            Set<Component> components = sstableFiles.getValue();

            if (components.contains(Component.COMPACTED_MARKER) || desc.temporary)

            {

                SSTable.delete(desc, components);

                continue;

            }

            File dataFile = new File(desc.filenameFor(Component.DATA));

            if (components.contains(Component.DATA) && dataFile.length() > 0)

                // everything appears to be in order... moving on.

                continue;

            // missing the DATA file! all components are orphaned

            logger.warn("Removing orphans for {}: {}", desc, components);

            for (Component component : components)

            {

                FileUtils.deleteWithConfirm(desc.filenameFor(component));

            }

        }

        // cleanup incomplete saved caches

        Pattern tmpCacheFilePattern = Pattern.compile(keyspaceName + "-" + columnFamily + "-(Key|Row)Cache.*\\.tmp$");

        File dir = new File(DatabaseDescriptor.getSavedCachesLocation());

        if (dir.exists())

        {

            assert dir.isDirectory();

            for (File file : dir.listFiles())

                if (tmpCacheFilePattern.matcher(file.getName()).matches())

                    if (!file.delete())

                        logger.warn("could not delete " + file.getAbsolutePath());

        }

        // also clean out any index leftovers.

        CFMetaData cfm = Schema.instance.getCFMetaData(keyspaceName, columnFamily);

        if (cfm != null) // secondary indexes aren't stored in DD.

        {

            for (ColumnDefinition def : cfm.allColumns())

                scrubDataDirectories(keyspaceName, cfm.indexColumnFamilyName(def));

        }

    }

    /**

     * Replacing compacted sstables is atomic as far as observers of DataTracker are concerned, but not on the

     * filesystem: first the new sstables are renamed to "live" status (i.e., the tmp marker is removed), then

     * their ancestors are removed.

     *

     * If an unclean shutdown happens at the right time, we can thus end up with both the new ones and their

     * ancestors "live" in the system.  This is harmless for normal data, but for counters it can cause overcounts.

     *

     * To prevent this, we record sstables being compacted in the system keyspace.  If we find unfinished

     * compactions, we remove the new ones (since those may be incomplete -- under LCS, we may create multiple

     * sstables from any given ancestor).

     */

    public static void removeUnfinishedCompactionLeftovers(String keyspace, String columnfamily, Set<Integer> unfinishedGenerations)

    {

        Directories directories = Directories.create(keyspace, columnfamily);

        // sanity-check unfinishedGenerations

        Set<Integer> allGenerations = new HashSet<Integer>();

        for (Descriptor desc : directories.sstableLister().list().keySet())

            allGenerations.add(desc.generation);

        if (!allGenerations.containsAll(unfinishedGenerations))

        {

            throw new IllegalStateException("Unfinished compactions reference missing sstables."

                                            + " This should never happen since compactions are marked finished before we start removing the old sstables.");

        }

        // remove new sstables from compactions that didn't complete, and compute

        // set of ancestors that shouldn't exist anymore

        Set<Integer> completedAncestors = new HashSet<Integer>();

        for (Map.Entry<Descriptor, Set<Component>> sstableFiles : directories.sstableLister().list().entrySet())

        {

            Descriptor desc = sstableFiles.getKey();

            Set<Component> components = sstableFiles.getValue();

            Set<Integer> ancestors;

            try

            {

                ancestors = SSTableMetadata.serializer.deserialize(desc).right;

            }

            catch (IOException e)

            {

                throw new FSReadError(e, desc.filenameFor(Component.STATS));

            }

            if (!ancestors.isEmpty() && unfinishedGenerations.containsAll(ancestors))

            {

                SSTable.delete(desc, components);

            }

            else

            {

                completedAncestors.addAll(ancestors);

            }

        }

        // remove old sstables from compactions that did complete

        for (Map.Entry<Descriptor, Set<Component>> sstableFiles : directories.sstableLister().list().entrySet())

        {

            Descriptor desc = sstableFiles.getKey();

            Set<Component> components = sstableFiles.getValue();

            if (completedAncestors.contains(desc.generation))

                SSTable.delete(desc, components);

        }

    }

    // must be called after all sstables are loaded since row cache merges all row versions

    public void initRowCache()

    {

        if (!isRowCacheEnabled())

            return;

        long start = System.nanoTime();

        int cachedRowsRead = CacheService.instance.rowCache.loadSaved(this);

        if (cachedRowsRead > 0)

            logger.info("completed loading ({} ms; {} keys) row cache for {}.{}",

                        TimeUnit.NANOSECONDS.toMillis(System.nanoTime() - start),

                        cachedRowsRead,

                        keyspace.getName(),

                        name);

    }

    /**

     * See #{@code StorageService.loadNewSSTables(String, String)} for more info

     *

     * @param ksName The keyspace name

     * @param cfName The columnFamily name

     */

    public static synchronized void loadNewSSTables(String ksName, String cfName)

    {

        /** ks/cf existence checks will be done by open and getCFS methods for us */

        Keyspace keyspace = Keyspace.open(ksName);

        keyspace.getColumnFamilyStore(cfName).loadNewSSTables();

    }

    /**

     * #{@inheritDoc}

     */

    public synchronized void loadNewSSTables()

    {

        logger.info("Loading new SSTables for " + keyspace.getName() + "/" + name + "...");

        Set<Descriptor> currentDescriptors = new HashSet<Descriptor>();

        for (SSTableReader sstable : data.getView().sstables)

            currentDescriptors.add(sstable.descriptor);

        Set<SSTableReader> newSSTables = new HashSet<SSTableReader>();

        Directories.SSTableLister lister = directories.sstableLister().skipTemporary(true);

        for (Map.Entry<Descriptor, Set<Component>> entry : lister.list().entrySet())

        {

            Descriptor descriptor = entry.getKey();

            if (currentDescriptors.contains(descriptor))

                continue; // old (initialized) SSTable found, skipping

            if (descriptor.temporary) // in the process of being written

                continue;

            if (!descriptor.isCompatible())

                throw new RuntimeException(String.format("Can't open incompatible SSTable! Current version %s, found file: %s",

                                                         Descriptor.Version.CURRENT,

                                                         descriptor));

            // force foreign sstables to level 0

            try

            {

                if (new File(descriptor.filenameFor(Component.STATS)).exists())

                {

                    Pair<SSTableMetadata, Set<Integer>> oldMetadata = SSTableMetadata.serializer.deserialize(descriptor);

                    LeveledManifest.mutateLevel(oldMetadata, descriptor, descriptor.filenameFor(Component.STATS), 0);

                }

            }

            catch (IOException e)

            {

                SSTableReader.logOpenException(entry.getKey(), e);

                continue;

            }

            Descriptor newDescriptor = new Descriptor(descriptor.version,

                                                      descriptor.directory,

                                                      descriptor.ksname,

                                                      descriptor.cfname,

                                                      fileIndexGenerator.incrementAndGet(),

                                                      false);

            logger.info("Renaming new SSTable {} to {}", descriptor, newDescriptor);

            SSTableWriter.rename(descriptor, newDescriptor, entry.getValue());

            SSTableReader reader;

            try

            {

                reader = SSTableReader.open(newDescriptor, entry.getValue(), metadata, partitioner);

            }

            catch (IOException e)

            {

                SSTableReader.logOpenException(entry.getKey(), e);

                continue;

            }

            newSSTables.add(reader);

        }

        if (newSSTables.isEmpty())

        {

            logger.info("No new SSTables were found for " + keyspace.getName() + "/" + name);

            return;

        }

        logger.info("Loading new SSTables and building secondary indexes for " + keyspace.getName() + "/" + name + ": " + newSSTables);

        SSTableReader.acquireReferences(newSSTables);

        data.addSSTables(newSSTables);

        try

        {

            indexManager.maybeBuildSecondaryIndexes(newSSTables, indexManager.allIndexesNames());

        }

        finally

        {

            SSTableReader.releaseReferences(newSSTables);

        }

        logger.info("Done loading load new SSTables for " + keyspace.getName() + "/" + name);

    }

    public static void rebuildSecondaryIndex(String ksName, String cfName, String... idxNames)

    {

        ColumnFamilyStore cfs = Keyspace.open(ksName).getColumnFamilyStore(cfName);

        Set<String> indexes = new HashSet<String>(Arrays.asList(idxNames));

        Collection<SSTableReader> sstables = cfs.getSSTables();

        try

        {

            cfs.indexManager.setIndexRemoved(indexes);

            SSTableReader.acquireReferences(sstables);

            logger.info(String.format("User Requested secondary index re-build for %s/%s indexes", ksName, cfName));

            cfs.indexManager.maybeBuildSecondaryIndexes(sstables, indexes);

            cfs.indexManager.setIndexBuilt(indexes);

        }

        finally

        {

            SSTableReader.releaseReferences(sstables);

        }

    }

    public String getColumnFamilyName()

    {

        return name;

    }

    public String getTempSSTablePath(File directory)

    {

        return getTempSSTablePath(directory, Descriptor.Version.CURRENT);

    }

    private String getTempSSTablePath(File directory, Descriptor.Version version)

    {

        Descriptor desc = new Descriptor(version,

                                         directory,

                                         keyspace.getName(),

                                         name,

                                         fileIndexGenerator.incrementAndGet(),

                                         true);

        return desc.filenameFor(Component.DATA);

    }

    /**

     * Switch and flush the current memtable, if it was dirty. The forceSwitch

     * flag allow to force switching the memtable even if it is clean (though

     * in that case we don't flush, as there is no point).

     */

    public Future<?> switchMemtable(final boolean writeCommitLog, boolean forceSwitch)

    {

        /*

         * If we can get the writelock, that means no new updates can come in and

         * all ongoing updates to memtables have completed. We can get the tail

         * of the log and use it as the starting position for log replay on recovery.

         *

         * This is why we Keyspace.switchLock needs to be global instead of per-Keyspace:

         * we need to schedule discardCompletedSegments calls in the same order as their

         * contexts (commitlog position) were read, even though the flush executor

         * is multithreaded.

         */

        Keyspace.switchLock.writeLock().lock();

        try

        {

            final Future<ReplayPosition> ctx = writeCommitLog ? CommitLog.instance.getContext() : Futures.immediateFuture(ReplayPosition.NONE);

            // submit the memtable for any indexed sub-cfses, and our own.

            final List<ColumnFamilyStore> icc = new ArrayList<ColumnFamilyStore>();

            // don't assume that this.memtable is dirty; forceFlush can bring us here during index build even if it is not

            for (ColumnFamilyStore cfs : concatWithIndexes())

            {

                if (forceSwitch || !cfs.getMemtableThreadSafe().isClean())

                    icc.add(cfs);

            }

            final CountDownLatch latch = new CountDownLatch(icc.size());

            for (ColumnFamilyStore cfs : icc)

            {

                Memtable memtable = cfs.data.switchMemtable();

                // With forceSwitch it's possible to get a clean memtable here.

                // In that case, since we've switched it already, just remove

                // it from the memtable pending flush right away.

                if (memtable.isClean())

                {

                    cfs.replaceFlushed(memtable, null);

                    latch.countDown();

                }

                else

                {

                    logger.info("Enqueuing flush of {}", memtable);

                    memtable.flushAndSignal(latch, ctx);

                }

            }

            if (metric.memtableSwitchCount.count() == Long.MAX_VALUE)

                metric.memtableSwitchCount.clear();

            metric.memtableSwitchCount.inc();

            // when all the memtables have been written, including for indexes, mark the flush in the commitlog header.

            // a second executor makes sure the onMemtableFlushes get called in the right order,

            // while keeping the wait-for-flush (future.get) out of anything latency-sensitive.

            return postFlushExecutor.submit(new WrappedRunnable()

            {

                public void runMayThrow() throws InterruptedException, ExecutionException

                {

                    latch.await();

                    if (!icc.isEmpty())

                    {

                        //only valid when memtables exist

                        for (SecondaryIndex index : indexManager.getIndexesNotBackedByCfs())

                        {

                            // flush any non-cfs backed indexes

                            logger.info("Flushing SecondaryIndex {}", index);

                            index.forceBlockingFlush();

                        }

                    }

                    if (writeCommitLog)

                    {

                        // if we're not writing to the commit log, we are replaying the log, so marking

                        // the log header with "you can discard anything written before the context" is not valid

                        CommitLog.instance.discardCompletedSegments(metadata.cfId, ctx.get());

                    }

                }

            });

        }

        finally

        {

            Keyspace.switchLock.writeLock().unlock();

        }

    }

    private boolean isClean()

    {

        // during index build, 2ary index memtables can be dirty even if parent is not.  if so,

        // we want flushLargestMemtables to flush the 2ary index ones too.

        for (ColumnFamilyStore cfs : concatWithIndexes())

            if (!cfs.getMemtableThreadSafe().isClean())

                return false;

        return true;

    }

    /**

     * @return a future, with a guarantee that any data inserted prior to the forceFlush() call is fully flushed

     *         by the time future.get() returns. Never returns null.

     */

    public Future<?> forceFlush()

    {

        if (isClean())

        {

            // We could have a memtable for this column family that is being

            // flushed. Make sure the future returned wait for that so callers can

            // assume that any data inserted prior to the call are fully flushed

            // when the future returns (see #5241).

            return postFlushExecutor.submit(new Runnable()

            {

                public void run()

                {

                    logger.debug("forceFlush requested but everything is clean in {}", name);

                }

            });

        }

        return switchMemtable(true, false);

    }

    public void forceBlockingFlush()

    {

        FBUtilities.waitOnFuture(forceFlush());

    }

    public void maybeUpdateRowCache(DecoratedKey key)

    {

        if (!isRowCacheEnabled())

            return;

        RowCacheKey cacheKey = new RowCacheKey(metadata.cfId, key);

        invalidateCachedRow(cacheKey);

    }

    /**

     * Insert/Update the column family for this key.

     * Caller is responsible for acquiring Keyspace.switchLock

     * param @ lock - lock that needs to be used.

     * param @ key - key for update/insert

     * param @ columnFamily - columnFamily changes

     */

    public void apply(DecoratedKey key, ColumnFamily columnFamily, SecondaryIndexManager.Updater indexer)

    {

        long start = System.nanoTime();

        Memtable mt = getMemtableThreadSafe();

        mt.put(key, columnFamily, indexer);

        maybeUpdateRowCache(key);

        metric.writeLatency.addNano(System.nanoTime() - start);

        // recompute liveRatio, if we have doubled the number of ops since last calculated

        while (true)

        {

            long last = liveRatioComputedAt.get();

            long operations = metric.writeLatency.latency.count();

            if (operations < 2 * last)

                break;

            if (liveRatioComputedAt.compareAndSet(last, operations))

            {

                logger.debug("computing liveRatio of {} at {} ops", this, operations);

                mt.updateLiveRatio();

            }

        }

    }

    public static ColumnFamily removeDeletedCF(ColumnFamily cf, int gcBefore)

    {

        cf.maybeResetDeletionTimes(gcBefore);

        return cf.getColumnCount() == 0 && !cf.isMarkedForDelete() ? null : cf;

    }

    public static ColumnFamily removeDeleted(ColumnFamily cf, int gcBefore)

    {

        return removeDeleted(cf, gcBefore, SecondaryIndexManager.nullUpdater);

    }

    /*

     This is complicated because we need to preserve deleted columns, supercolumns, and columnfamilies

     until they have been deleted for at least GC_GRACE_IN_SECONDS.  But, we do not need to preserve

     their contents; just the object itself as a "tombstone" that can be used to repair other

     replicas that do not know about the deletion.

     */

    public static ColumnFamily removeDeleted(ColumnFamily cf, int gcBefore, SecondaryIndexManager.Updater indexer)

    {

        if (cf == null)

        {

            return null;

        }

        removeDeletedColumnsOnly(cf, gcBefore, indexer);

        return removeDeletedCF(cf, gcBefore);

    }

    private static long removeDeletedColumnsOnly(ColumnFamily cf, int gcBefore, SecondaryIndexManager.Updater indexer)

    {

        Iterator<Column> iter = cf.iterator();

        DeletionInfo.InOrderTester tester = cf.inOrderDeletionTester();

        boolean hasDroppedColumns = !cf.metadata.getDroppedColumns().isEmpty();

        long removedBytes = 0;

        while (iter.hasNext())

        {

            Column c = iter.next();

            // remove columns if

            // (a) the column itself is gcable or

            // (b) the column is shadowed by a CF tombstone

            // (c) the column has been dropped from the CF schema (CQL3 tables only)

            if (c.getLocalDeletionTime() < gcBefore || tester.isDeleted(c) || (hasDroppedColumns && isDroppedColumn(c, cf.metadata())))

            {

                iter.remove();

                indexer.remove(c);

                removedBytes += c.dataSize();

            }

        }

        return removedBytes;

    }

    public static long removeDeletedColumnsOnly(ColumnFamily cf, int gcBefore)

    {

        return removeDeletedColumnsOnly(cf, gcBefore, SecondaryIndexManager.nullUpdater);

    }

    // returns true if

    // 1. this column has been dropped from schema and

    // 2. if it has been re-added since then, this particular column was inserted before the last drop

    private static boolean isDroppedColumn(Column c, CFMetaData meta)

    {

        Long droppedAt = meta.getDroppedColumns().get(((CompositeType) meta.comparator).extractLastComponent(c.name()));

        return droppedAt != null && c.timestamp() <= droppedAt;

    }

    private void removeDroppedColumns(ColumnFamily cf)

    {

        if (cf == null || cf.metadata.getDroppedColumns().isEmpty())

            return;

        Iterator<Column> iter = cf.iterator();

        while (iter.hasNext())

            if (isDroppedColumn(iter.next(), metadata))

                iter.remove();

    }

    /**

     * @param sstables