* 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 Logger logger = LoggerFactory.getLogger(ColumnFamilyStore.class);

    /*

     * submitFlush first puts [Binary]Memtable.getSortedContents on the flushSorter executor,

     * which then puts the sorted results on the writer executor.  This is because sorting is CPU-bound,

     * and writing is disk-bound; we want to be able to do both at once.  When the write is complete,

     * we turn the writer into an SSTableReader and add it to ssTables_ where it is available for reads.

     *

     * For BinaryMemtable that's about all that happens.  For live Memtables there are two other things

     * that switchMemtable does (which should be the only caller of submitFlush in this case).

     * First, it puts the Memtable into memtablesPendingFlush, where it stays until the flush is complete

     * and it's been added as an SSTableReader to ssTables_.  Second, it adds an entry to commitLogUpdater

     * that waits for the flush to complete, then calls onMemtableFlush.  This allows multiple flushes

     * to happen simultaneously on multicore systems, while still calling onMF in the correct order,

     * which is necessary for replay in case of a restart since CommitLog assumes that when onMF is

     * called, all data up to the given context has been persisted to SSTables.

     */

    private static final ExecutorService flushSorter

            = new JMXEnabledThreadPoolExecutor(1,

                                               Runtime.getRuntime().availableProcessors(),

                                               StageManager.KEEPALIVE,

                                               TimeUnit.SECONDS,

                                               new LinkedBlockingQueue<Runnable>(Runtime.getRuntime().availableProcessors()),

                                               new NamedThreadFactory("FlushSorter"),

                                               "internal");

    private static final ExecutorService flushWriter

            = new JMXEnabledThreadPoolExecutor(1,

                                               DatabaseDescriptor.getFlushWriters(),

                                               StageManager.KEEPALIVE,

                                               TimeUnit.SECONDS,

                                               new SynchronousQueue<Runnable>(),

                                               new NamedThreadFactory("FlushWriter"),

                                               "internal");

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

   

    private Set<Memtable> memtablesPendingFlush = new ConcurrentSkipListSet<Memtable>();

    public final Table table;

    public final String columnFamily;

    public final IPartitioner partitioner;

    private final String mbeanName;

    private boolean invalid = false;

    private volatile int memtableSwitchCount = 0;

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

    private AtomicInteger fileIndexGenerator = new AtomicInteger(0);

    /* active memtable associated with this ColumnFamilyStore. */

    private Memtable memtable;

    private final ConcurrentSkipListMap<ByteBuffer, ColumnFamilyStore> indexedColumns;

    // TODO binarymemtable ops are not threadsafe (do they need to be?)

    private AtomicReference<BinaryMemtable> binaryMemtable;

    /* SSTables on disk for this column family */

    private SSTableTracker ssTables;

    private LatencyTracker readStats = new LatencyTracker();

    private LatencyTracker writeStats = new LatencyTracker();

    // counts of sstables accessed by reads

    private final EstimatedHistogram recentSSTablesPerRead = new EstimatedHistogram(35);

    private final EstimatedHistogram sstablesPerRead = new EstimatedHistogram(35);

    public final CFMetaData metadata;

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

    private volatile DefaultInteger minCompactionThreshold;

    private volatile DefaultInteger maxCompactionThreshold;

    private volatile DefaultInteger memtime;

    private volatile DefaultInteger memsize;

    private volatile DefaultDouble memops;

    private volatile DefaultInteger rowCacheSaveInSeconds;

    private volatile DefaultInteger keyCacheSaveInSeconds;

    // Locally held row/key cache scheduled tasks

    private volatile ScheduledFuture<?> saveRowCacheTask;

    private volatile ScheduledFuture<?> saveKeyCacheTask;

    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())

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

        if (!maxCompactionThreshold.isModified())

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

        if (!memtime.isModified())

            memtime = new DefaultInteger(metadata.getMemtableFlushAfterMins());

        if (!memsize.isModified())

            memsize = new DefaultInteger(metadata.getMemtableThroughputInMb());

        if (!memops.isModified())

            memops = new DefaultDouble(metadata.getMemtableOperationsInMillions());

        if (!rowCacheSaveInSeconds.isModified())

            rowCacheSaveInSeconds = new DefaultInteger(metadata.getRowCacheSavePeriodInSeconds());

        if (!keyCacheSaveInSeconds.isModified())

            keyCacheSaveInSeconds = new DefaultInteger(metadata.getKeyCacheSavePeriodInSeconds());

       

        ssTables.updateCacheSizes();

        scheduleCacheSaving(rowCacheSaveInSeconds.value(), keyCacheSaveInSeconds.value());

       

        // figure out what needs to be added and dropped.

        // future: if/when we have modifiable settings for secondary indexes, they'll need to be handled here.

        for (ByteBuffer indexName : indexedColumns.keySet())

        {

            if (!metadata.getColumn_metadata().containsKey(indexName))

            {

                ColumnFamilyStore indexCfs = indexedColumns.remove(indexName);

                if (indexCfs == null)

                {

                    logger.debug("index {} already removed; ignoring", ByteBufferUtil.bytesToHex(indexName));

                    continue;

                }

                indexCfs.unregisterMBean();

                SystemTable.setIndexRemoved(metadata.tableName, metadata.cfName);

                indexCfs.removeAllSSTables();

            }

        }

        for (ColumnDefinition cdef : metadata.getColumn_metadata().values())

            if (cdef.getIndexType() != null && !indexedColumns.containsKey(cdef.name))

                addIndex(cdef);

    }

    private ColumnFamilyStore(Table table, String columnFamilyName, IPartitioner partitioner, int generation, CFMetaData metadata)

    {

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

        this.table = table;

        columnFamily = columnFamilyName;

        this.metadata = metadata;

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

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

        this.memtime = new DefaultInteger(metadata.getMemtableFlushAfterMins());

        this.memsize = new DefaultInteger(metadata.getMemtableThroughputInMb());

        this.memops = new DefaultDouble(metadata.getMemtableOperationsInMillions());

        this.rowCacheSaveInSeconds = new DefaultInteger(metadata.getRowCacheSavePeriodInSeconds());

        this.keyCacheSaveInSeconds = new DefaultInteger(metadata.getKeyCacheSavePeriodInSeconds());

        this.partitioner = partitioner;

        fileIndexGenerator.set(generation);

        memtable = new Memtable(this);

        binaryMemtable = new AtomicReference<BinaryMemtable>(new BinaryMemtable(this));

        if (logger.isDebugEnabled())

            logger.debug("Starting CFS {}", columnFamily);

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

        ssTables = new SSTableTracker(table.name, columnFamilyName);

        Set<DecoratedKey> savedKeys = readSavedCache(DatabaseDescriptor.getSerializedKeyCachePath(table.name, columnFamilyName));

        List<SSTableReader> sstables = new ArrayList<SSTableReader>();

        for (Map.Entry<Descriptor,Set<Component>> sstableFiles : files(table.name, columnFamilyName, false).entrySet())

        {

            SSTableReader sstable;

            try

            {

                sstable = SSTableReader.open(sstableFiles.getKey(), sstableFiles.getValue(), savedKeys, ssTables, metadata, this.partitioner);

            }

            catch (FileNotFoundException ex)

            {

                logger.error("Missing sstable component in " + sstableFiles + "; skipped because of " + ex.getMessage());

                continue;

            }

            catch (IOException ex)

            {

                logger.error("Corrupt sstable " + sstableFiles + "; skipped", ex);

                continue;

            }

            sstables.add(sstable);

        }

        ssTables.add(sstables);

        // create the private ColumnFamilyStores for the secondary column indexes

        indexedColumns = new ConcurrentSkipListMap<ByteBuffer, ColumnFamilyStore>(getComparator());

        for (ColumnDefinition info : metadata.getColumn_metadata().values())

        {

            if (info.getIndexType() != null)

                addIndex(info);

        }

        // register the mbean

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

        mbeanName = "org.apache.cassandra.db:type=" + type + ",keyspace=" + this.table.name + ",columnfamily=" + columnFamily;

        try

        {

            MBeanServer mbs = ManagementFactory.getPlatformMBeanServer();

            ObjectName nameObj = new ObjectName(mbeanName);

            mbs.registerMBean(this, nameObj);

        }

        catch (Exception e)

        {

            throw new RuntimeException(e);

        }

    }

    protected Set<DecoratedKey> readSavedCache(File path)

    {

        Set<DecoratedKey> keys = new TreeSet<DecoratedKey>();

        if (path.exists())

        {

            DataInputStream in = null;

            try

            {

                long start = System.currentTimeMillis();

                logger.info(String.format("reading saved cache %s", path));

                in = new DataInputStream(new BufferedInputStream(new FileInputStream(path)));

                while (in.available() > 0)

                {

                    int size = in.readInt();

                    byte[] bytes = new byte[size];

                    in.readFully(bytes);

                    ByteBuffer buffer = ByteBuffer.wrap(bytes);

                    DecoratedKey key;

                    try

                    {

                        key = StorageService.getPartitioner().decorateKey(buffer);

                    }

                    catch (Exception e)

                    {

                        logger.info(String.format("unable to read entry #%s from saved cache %s; skipping remaining entries",

                                                  keys.size(), path.getAbsolutePath()), e);

                        break;

                    }

                    keys.add(key);

                }

                if (logger.isDebugEnabled())

                    logger.debug(String.format("completed reading (%d ms; %d keys) saved cache %s",

                                               System.currentTimeMillis() - start, keys.size(), path));

            }

            catch (IOException ioe)

            {

                logger.warn(String.format("error reading saved cache %s", path.getAbsolutePath()), ioe);

            }

            finally

            {

                FileUtils.closeQuietly(in);

            }

        }

        return keys;

    }

    public void addIndex(final ColumnDefinition info)

    {

        assert info.getIndexType() != null;

        // create the index CFS

        IPartitioner rowPartitioner = StorageService.getPartitioner();

        AbstractType columnComparator = (rowPartitioner instanceof OrderPreservingPartitioner || rowPartitioner instanceof ByteOrderedPartitioner)

                                        ? BytesType.instance

                                        : new LocalByPartionerType(StorageService.getPartitioner());

        final CFMetaData indexedCfMetadata = CFMetaData.newIndexMetadata(table.name, columnFamily, info, columnComparator);

        ColumnFamilyStore indexedCfs = ColumnFamilyStore.createColumnFamilyStore(table,

                                                                                 indexedCfMetadata.cfName,

                                                                                 new LocalPartitioner(metadata.getColumn_metadata().get(info.name).validator),

                                                                                 indexedCfMetadata);

        // link in indexedColumns.  this means that writes will add new data to the index immediately,

        // so we don't have to lock everything while we do the build.  it's up to the operator to wait

        // until the index is actually built before using in queries.

        if (indexedColumns.putIfAbsent(info.name, indexedCfs) != null)

            return;

        // if we're just linking in the index to indexedColumns on an already-built index post-restart, we're done

        if (indexedCfs.isIndexBuilt())

            return;

        // build it asynchronously; addIndex gets called by CFS open and schema update, neither of which

        // we want to block for a long period.  (actual build is serialized on CompactionManager.)

        Runnable runnable = new Runnable()

        {

            public void run()

            {

                logger.info("Creating index {}.{}", table, indexedCfMetadata.cfName);

                try

                {

                    forceBlockingFlush();

                }

                catch (ExecutionException e)

                {

                    throw new RuntimeException(e);

                }

                catch (InterruptedException e)

                {

                    throw new AssertionError(e);

                }

                buildSecondaryIndexes(getSSTables(), FBUtilities.singleton(info.name));

                logger.info("Index {} complete", indexedCfMetadata.cfName);

                SystemTable.setIndexBuilt(table.name, indexedCfMetadata.cfName);

            }

        };

        new Thread(runnable, "Create index " + indexedCfMetadata.cfName).start();

    }

    public void buildSecondaryIndexes(Collection<SSTableReader> sstables, SortedSet<ByteBuffer> columns)

    {

        logger.debug("Submitting index build to compactionmanager");

        Table.IndexBuilder builder = table.createIndexBuilder(this, columns, new ReducingKeyIterator(sstables));

        Future future = CompactionManager.instance.submitIndexBuild(this, builder);

        try

        {

            future.get();

            for (ByteBuffer column : columns)

                getIndexedColumnFamilyStore(column).forceBlockingFlush();

        }

        catch (InterruptedException e)

        {

            throw new AssertionError(e);

        }

        catch (ExecutionException e)

        {

            throw new RuntimeException(e);

        }

    }

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

    void unregisterMBean()

    {

        try

        {

            invalid = true;  

            MBeanServer mbs = ManagementFactory.getPlatformMBeanServer();

            ObjectName nameObj = new ObjectName(mbeanName);

            if (mbs.isRegistered(nameObj))

                mbs.unregisterMBean(nameObj);

            for (ColumnFamilyStore index : indexedColumns.values())

                index.unregisterMBean();

        }

        catch (Exception e)

        {

            // this shouldn't block anything.

            logger.warn(e.getMessage(), e);

        }

    }

    public long getMinRowSize()

    {

        long min = 0;

        for (SSTableReader sstable : ssTables)

        {

            if (min == 0 || sstable.getEstimatedRowSize().min() < min)

                min = sstable.getEstimatedRowSize().min();

        }

        return min;

    }

    public long getMaxRowSize()

    {

        long max = 0;

        for (SSTableReader sstable : ssTables)

        {

            if (sstable.getEstimatedRowSize().max() > max)

                max = sstable.getEstimatedRowSize().max();

        }

        return max;

    }

    public long getMeanRowSize()

    {

        long sum = 0;

        long count = 0;

        for (SSTableReader sstable : ssTables)

        {

            sum += sstable.getEstimatedRowSize().mean();

            count++;

        }

        return count > 0 ? sum / count : 0;

    }

    public int getMeanColumns()

    {

        long sum = 0;

        int count = 0;

        for (SSTableReader sstable : ssTables)

        {

            sum += sstable.getEstimatedColumnCount().mean();

            count++;

        }

        return count > 0 ? (int) (sum / count) : 0;

    }

    public static ColumnFamilyStore createColumnFamilyStore(Table table, String columnFamily)

    {

        return createColumnFamilyStore(table, columnFamily, StorageService.getPartitioner(), DatabaseDescriptor.getCFMetaData(table.name, columnFamily));

    }

    public static synchronized ColumnFamilyStore createColumnFamilyStore(Table table, String columnFamily, IPartitioner partitioner, CFMetaData metadata)

    {

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

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

        for (Descriptor desc : files(table.name, columnFamily, true).keySet())

        {

            generations.add(desc.generation);

            if (desc.isFromTheFuture())

            {

                throw new RuntimeException(String.format("Can't open sstables from the future! Current version %s, found file: %s",

                                                         Descriptor.CURRENT_VERSION, desc));

            }

        }

        Collections.sort(generations);

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

        return new ColumnFamilyStore(table, columnFamily, partitioner, value, metadata);

    }

   

    /**

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

     * @return A list of Descriptors that were removed.

     */

    public static void scrubDataDirectories(String table, String columnFamily)

    {

        for (Map.Entry<Descriptor,Set<Component>> sstableFiles : files(table, columnFamily, true).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)

            {

                try

                {

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

                }

                catch (IOException e)

                {

                    throw new IOError(e);

                }

            }

        }

        // cleanup incomplete saved caches

        Pattern tmpCacheFilePattern = Pattern.compile(table + "-" + 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 = DatabaseDescriptor.getCFMetaData(table, columnFamily);

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

        {

            for (ColumnDefinition def : cfm.getColumn_metadata().values())

                scrubDataDirectories(table, CFMetaData.indexName(cfm.cfName, def));

        }

    }

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

    public void initRowCache()

    {

        int rowCacheSavePeriodInSeconds = DatabaseDescriptor.getTableMetaData(table.name).get(columnFamily).getRowCacheSavePeriodInSeconds();

        int keyCacheSavePeriodInSeconds = DatabaseDescriptor.getTableMetaData(table.name).get(columnFamily).getKeyCacheSavePeriodInSeconds();

        long start = System.currentTimeMillis();

        // sort the results on read because there are few reads and many writes and reads only happen at startup

        Set<DecoratedKey> savedKeys = readSavedCache(DatabaseDescriptor.getSerializedRowCachePath(table.name, columnFamily));

        for (DecoratedKey key : savedKeys)

            cacheRow(key);

        if (ssTables.getRowCache().getSize() > 0)

            logger.info(String.format("completed loading (%d ms; %d keys) row cache for %s.%s",

                                      System.currentTimeMillis()-start,

                                      ssTables.getRowCache().getSize(),

                                      table.name,

                                      columnFamily));

        scheduleCacheSaving(rowCacheSavePeriodInSeconds, keyCacheSavePeriodInSeconds);

    }

    public void scheduleCacheSaving(int rowCacheSavePeriodInSeconds, int keyCacheSavePeriodInSeconds)

    {

        if (saveRowCacheTask != null)

        {

            saveRowCacheTask.cancel(false); // Do not interrupt an in-progress save

            saveRowCacheTask = null;

        }

        if (rowCacheSavePeriodInSeconds > 0)

        {

            Runnable runnable = new WrappedRunnable()

            {

                public void runMayThrow()

                {

                    submitRowCacheWrite();

                }

            };

            saveRowCacheTask = StorageService.scheduledTasks.scheduleWithFixedDelay(runnable,

                                                                                    rowCacheSavePeriodInSeconds,

                                                                                    rowCacheSavePeriodInSeconds,

                                                                                    TimeUnit.SECONDS);

        }

        if (saveKeyCacheTask != null)

        {

            saveKeyCacheTask.cancel(false); // Do not interrupt an in-progress save

            saveKeyCacheTask = null;

        }

        if (keyCacheSavePeriodInSeconds > 0)

        {

            Runnable runnable = new WrappedRunnable()

            {

                public void runMayThrow()

                {

                    submitKeyCacheWrite();

                }

            };

            saveKeyCacheTask = StorageService.scheduledTasks.scheduleWithFixedDelay(runnable,

                                                                                    keyCacheSavePeriodInSeconds,

                                                                                    keyCacheSavePeriodInSeconds,

                                                                                    TimeUnit.SECONDS);

        }

    }

    public Future<?> submitRowCacheWrite()

    {

        return CompactionManager.instance.submitCacheWrite(ssTables.getRowCacheWriter());

    }

    public Future<?> submitKeyCacheWrite()

    {

        return CompactionManager.instance.submitCacheWrite(ssTables.getKeyCacheWriter());

    }

    /**

     * Collects a map of sstable components.

     */

    private static Map<Descriptor,Set<Component>> files(String keyspace, final String columnFamily, final boolean includeCompacted)

    {

        final Map<Descriptor,Set<Component>> sstables = new HashMap<Descriptor,Set<Component>>();

        for (String directory : DatabaseDescriptor.getAllDataFileLocationsForTable(keyspace))

        {

            // NB: we never "accept" a file in the FilenameFilter sense: they are added to the sstable map

            new File(directory).list(new FilenameFilter()

            {

                public boolean accept(File dir, String name)

                {

                    Pair<Descriptor,Component> component = SSTable.tryComponentFromFilename(dir, name);

                    if (component != null && component.left.cfname.equals(columnFamily))

                    {

                        if (includeCompacted || !new File(component.left.filenameFor(Component.COMPACTED_MARKER)).exists())

                        {

                            Set<Component> components = sstables.get(component.left);

                            if (components == null)

                            {

                                components = new HashSet<Component>();

                                sstables.put(component.left, components);

                            }

                            components.add(component.right);

                        }

                        else

                            logger.debug("not including compacted sstable " + component.left.cfname + "-" + component.left.generation);

                    }

                    return false;

                }

            });

        }

        return sstables;

    }

    /**

     * @return the name of the column family

     */

    public String getColumnFamilyName()

    {

        return columnFamily;

    }

    /*

     * @return a temporary file name for an sstable.

     * When the sstable object is closed, it will be renamed to a non-temporary

     * format, so incomplete sstables can be recognized and removed on startup.

     */

    public String getFlushPath()

    {

        long guessedSize = 2L * memsize.value() * 1024*1024; // 2* adds room for keys, column indexes

        String location = DatabaseDescriptor.getDataFileLocationForTable(table.name, guessedSize);

        if (location == null)

            throw new RuntimeException("Insufficient disk space to flush");

        return getTempSSTablePath(location);

    }

    public String getTempSSTablePath(String directory)

    {

        Descriptor desc = new Descriptor(new File(directory),

                                         table.name,

                                         columnFamily,

                                         fileIndexGenerator.incrementAndGet(),

                                         true);

        return desc.filenameFor(Component.DATA);

    }

    /** flush the given memtable and swap in a new one for its CFS, if it hasn't been frozen already.  threadsafe. */

    Future<?> maybeSwitchMemtable(Memtable oldMemtable, final boolean writeCommitLog)

    {

        /*

         * 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 Table.flusherLock needs to be global instead of per-Table:

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

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

         * is multithreaded.

         */

        Table.flusherLock.writeLock().lock();

        try

        {

            if (oldMemtable.isFrozen())

                return null;

           

            if (DatabaseDescriptor.getCFMetaData(metadata.cfId) == null)

                return null; // column family was dropped. no point in flushing.

            assert memtable == oldMemtable;

            memtable.freeze();

            final CommitLogSegment.CommitLogContext ctx = writeCommitLog ? CommitLog.instance.getContext() : null;

            logger.info("switching in a fresh Memtable for " + columnFamily + " at " + ctx);

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

            List<ColumnFamilyStore> icc = new ArrayList<ColumnFamilyStore>(indexedColumns.size());

            icc.add(this);

            for (ColumnFamilyStore indexCfs : indexedColumns.values())

            {

                if (!indexCfs.memtable.isClean())

                    icc.add(indexCfs);

            }

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

            for (ColumnFamilyStore cfs : icc)

            {

                submitFlush(cfs.memtable, latch);

                cfs.memtable = new Memtable(cfs);

            }

            // 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, IOException

                {

                    latch.await();

                    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);

                    }

                }

            });

        }

        finally

        {

            Table.flusherLock.writeLock().unlock();

            if (memtableSwitchCount == Integer.MAX_VALUE)

            {

                memtableSwitchCount = 0;

            }

            memtableSwitchCount++;

        }

    }

    void switchBinaryMemtable(DecoratedKey key, ByteBuffer buffer)

    {

        binaryMemtable.set(new BinaryMemtable(this));

        binaryMemtable.get().put(key, buffer);

    }

    public void forceFlushIfExpired()

    {

        if (memtable.isExpired())

            forceFlush();

    }

    public Future<?> forceFlush()

    {

        if (memtable.isClean())

            return null;

        return maybeSwitchMemtable(memtable, true);

    }

    public void forceBlockingFlush() throws ExecutionException, InterruptedException

    {

        Future<?> future = forceFlush();

        if (future != null)

            future.get();

    }

    public void forceFlushBinary()

    {

        if (binaryMemtable.get().isClean())

            return;

        submitFlush(binaryMemtable.get(), new CountDownLatch(1));

    }

    /**

     * Insert/Update the column family for this key.

     * Caller is responsible for acquiring Table.flusherLock!

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

     * param @ key - key for update/insert

     * param @ columnFamily - columnFamily changes

     */

    Memtable apply(DecoratedKey key, ColumnFamily columnFamily)

    {

        long start = System.nanoTime();

        boolean flushRequested = memtable.isThresholdViolated();

        memtable.put(key, columnFamily);

        ColumnFamily cachedRow = getRawCachedRow(key);

        if (cachedRow != null)

            cachedRow.addAll(columnFamily);

        writeStats.addNano(System.nanoTime() - start);

       

        return flushRequested ? memtable : null;

    }

    /*

     * Insert/Update the column family for this key. param @ lock - lock that

     * needs to be used. param @ key - key for update/insert param @

     * columnFamily - columnFamily changes

     */

    void applyBinary(DecoratedKey key, ByteBuffer buffer)

    {

        long start = System.nanoTime();

        binaryMemtable.get().put(key, buffer);

        writeStats.addNano(System.nanoTime() - start);

    }

    public static ColumnFamily removeDeletedCF(ColumnFamily cf, int gcBefore)

    {

        // in case of a timestamp tie, tombstones get priority over non-tombstones.

        // (we want this to be deterministic to avoid confusion.)

        if (cf.getColumnCount() == 0 && cf.getLocalDeletionTime() <= gcBefore)

            return null;

        return cf;

    }

    /*

     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)

    {

        if (cf == null)

        {

            return null;

        }

        removeDeletedColumnsOnly(cf, gcBefore);

        return removeDeletedCF(cf, gcBefore);

    }

    private static void removeDeletedColumnsOnly(ColumnFamily cf, int gcBefore)

    {

        if (cf.isSuper())

            removeDeletedSuper(cf, gcBefore);

        else

            removeDeletedStandard(cf, gcBefore);

    }

    private static void removeDeletedStandard(ColumnFamily cf, int gcBefore)

    {

        for (Map.Entry<ByteBuffer, IColumn> entry : cf.getColumnsMap().entrySet())

        {

            ByteBuffer cname = entry.getKey();

            IColumn c = entry.getValue();

            // remove columns if

            // (a) the column itself is tombstoned or

            // (b) the CF is tombstoned and the column is not newer than it

            // (we split the test to avoid computing ClockRelationship if not necessary)

            if ((c.isMarkedForDelete() && c.getLocalDeletionTime() <= gcBefore)

                || c.timestamp() <= cf.getMarkedForDeleteAt())

            {

                cf.remove(cname);

            }

        }

    }

    private static void removeDeletedSuper(ColumnFamily cf, int gcBefore)

    {

        // TODO assume deletion means "most are deleted?" and add to clone, instead of remove from original?

        // this could be improved by having compaction, or possibly even removeDeleted, r/m the tombstone

        // once gcBefore has passed, so if new stuff is added in it doesn't used the wrong algorithm forever

        for (Map.Entry<ByteBuffer, IColumn> entry : cf.getColumnsMap().entrySet())

        {

            SuperColumn c = (SuperColumn) entry.getValue();

            long minTimestamp = Math.max(c.getMarkedForDeleteAt(), cf.getMarkedForDeleteAt());

            for (IColumn subColumn : c.getSubColumns())

            {

                // remove subcolumns if

                // (a) the subcolumn itself is tombstoned or

                // (b) the supercolumn is tombstoned and the subcolumn is not newer than it

                if (subColumn.timestamp() <= minTimestamp

                    || (subColumn.isMarkedForDelete() && subColumn.getLocalDeletionTime() <= gcBefore))

                {

                    c.remove(subColumn.name());

                }

            }

            if (c.getSubColumns().isEmpty() && c.getLocalDeletionTime() <= gcBefore)

            {

                cf.remove(c.name());

            }

        }

    }

    /**

     * Uses bloom filters to check if key may be present in any sstable in this

     * ColumnFamilyStore, minus a set of provided ones.

     *

     * Because BFs are checked, negative returns ensure that the key is not

     * present in the checked SSTables, but positive ones doesn't ensure key

     * presence.

     */

    public boolean isKeyInRemainingSSTables(DecoratedKey key, Set<SSTable> sstablesToIgnore)

    {

        for (SSTableReader sstable : ssTables)

        {

            if (!sstablesToIgnore.contains(sstable) && sstable.getBloomFilter().isPresent(key.key))

                return true;

        }

        return false;

    }

    /*

     * Called after the Memtable flushes its in-memory data, or we add a file

     * via bootstrap. This information is

     * cached in the ColumnFamilyStore. This is useful for reads because the

     * ColumnFamilyStore first looks in the in-memory store and the into the

     * disk to find the key. If invoked during recoveryMode the

     * onMemtableFlush() need not be invoked.

     *

     * param @ filename - filename just flushed to disk

     */

    public void addSSTable(SSTableReader sstable)

    {

        assert sstable.getColumnFamilyName().equals(columnFamily);

        ssTables.add(Arrays.asList(sstable));

        CompactionManager.instance.submitMinorIfNeeded(this);

    }

    /*

     * Add up all the files sizes this is the worst case file

     * size for compaction of all the list of files given.

     */

    long getExpectedCompactedFileSize(Iterable<SSTableReader> sstables)

    {

        long expectedFileSize = 0;

        for (SSTableReader sstable : sstables)

        {

            long size = sstable.length();

            expectedFileSize = expectedFileSize + size;

        }

        return expectedFileSize;

    }

    /*

     *  Find the maximum size file in the list .

     */

    SSTableReader getMaxSizeFile(Iterable<SSTableReader> sstables)

    {

        long maxSize = 0L;

        SSTableReader maxFile = null;

        for (SSTableReader sstable : sstables)

        {

            if (sstable.length() > maxSize)

            {

                maxSize = sstable.length();

                maxFile = sstable;

            }

        }

        return maxFile;

    }

    public void forceCleanup() throws ExecutionException, InterruptedException

    {

        CompactionManager.instance.performCleanup(ColumnFamilyStore.this);

    }

    public void scrub() throws ExecutionException, InterruptedException

    {

        snapshotWithoutFlush("pre-scrub-" + System.currentTimeMillis());

        CompactionManager.instance.performScrub(ColumnFamilyStore.this);

    }

    void markCompacted(Collection<SSTableReader> sstables)

    {

        ssTables.markCompacted(sstables);

    }

    boolean isCompleteSSTables(Collection<SSTableReader> sstables)

    {

        return ssTables.getSSTables().equals(new HashSet<SSTableReader>(sstables));

    }

    void replaceCompactedSSTables(Collection<SSTableReader> sstables, Iterable<SSTableReader> replacements)

    {

        ssTables.replace(sstables, replacements);

    }

   

    public boolean isInvalid()

    {

        return invalid;

    }

    public void removeAllSSTables()

    {

        ssTables.replace(ssTables.getSSTables(), Collections.<SSTableReader>emptyList());

        for (ColumnFamilyStore indexedCfs : indexedColumns.values())

        {

            indexedCfs.removeAllSSTables();

        }

    }

    /**

     * submits flush sort on the flushSorter executor, which will in turn submit to flushWriter when sorted.

     * TODO because our executors use CallerRunsPolicy, when flushSorter fills up, no writes will proceed

     * because the next flush will start executing on the caller, mutation-stage thread that has the

     * flush write lock held.  (writes aquire this as a read lock before proceeding.)

     * This is good, because it backpressures flushes, but bad, because we can't write until that last

     * flushing thread finishes sorting, which will almost always be longer than any of the flushSorter threads proper

     * (since, by definition, it started last).

     */

    void submitFlush(IFlushable flushable, CountDownLatch latch)

    {

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

        flushable.flushAndSignal(latch, flushSorter, flushWriter);

    }

    public long getMemtableColumnsCount()

    {

        return getMemtableThreadSafe().getCurrentOperations();

    }

    public long getMemtableDataSize()

    {

        return getMemtableThreadSafe().getCurrentThroughput();

    }

    public int getMemtableSwitchCount()

    {

        return memtableSwitchCount;

    }

    /**

     * get the current memtable in a threadsafe fashion.  note that simply "return memtable_" is

     * incorrect; you need to lock to introduce a thread safe happens-before ordering.

     *

     * do NOT use this method to do either a put or get on the memtable object, since it could be

     * flushed in the meantime (and its executor terminated).

     *

     * also do NOT make this method public or it will really get impossible to reason about these things.

     * @return

     */

    private Memtable getMemtableThreadSafe()