* 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(Runtime.getRuntime().availableProcessors(),

                                               StageManager.KEEPALIVE,

                                               TimeUnit.SECONDS,

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

                                               new NamedThreadFactory("FlushSorter"),

                                               "internal");

    private static final ExecutorService flushWriter

            = new JMXEnabledThreadPoolExecutor(DatabaseDescriptor.getFlushWriters(),

                                               StageManager.KEEPALIVE,

                                               TimeUnit.SECONDS,

                                               new LinkedBlockingQueue<Runnable>(DatabaseDescriptor.getFlushQueueSize()),

                                               new NamedThreadFactory("FlushWriter"),

                                               "internal");

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

    static

    {

        if (DatabaseDescriptor.estimatesRealMemtableSize())

        {

            logger.info("Global memtable threshold is enabled at {}MB", DatabaseDescriptor.getTotalMemtableSpaceInMB());

            // (can block if flush queue fills up, so don't put on scheduledTasks)

            StorageService.tasks.scheduleWithFixedDelay(new MeteredFlusher(), 1000, 1000, TimeUnit.MILLISECONDS);

        }

        else

        {

            logger.info("Global memtable threshold is disabled");

        }

    }

    public final Table table;

    public final String columnFamily;

    public final CFMetaData metadata;

    public final IPartitioner partitioner;

    private final String mbeanName;

    private boolean invalid = false;

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

    private final DataTracker data;

    private volatile int memtableSwitchCount = 0;

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

    private AtomicInteger fileIndexGenerator = new AtomicInteger(0);

    private final ConcurrentSkipListMap<ByteBuffer, ColumnFamilyStore> indexedColumns;

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

    private AtomicReference<BinaryMemtable> binaryMemtable;

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

    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 DefaultInteger memtime;

    private volatile DefaultInteger memsize;

    private volatile DefaultDouble memops;

    private volatile DefaultInteger rowCacheSaveInSeconds;

    private volatile DefaultInteger keyCacheSaveInSeconds;

    /** Lock to allow migrations to block all flushing, so we can be sure not to write orphaned data files */

    public final Lock flushLock = new ReentrantLock();

    public static enum CacheType

    {

        KEY_CACHE_TYPE("KeyCache"),

        ROW_CACHE_TYPE("RowCache");

        public final String name;

        private CacheType(String name)

        {

            this.name = name;

        }

        @Override

        public String toString()

        {

            return name;

        }

    }

    public final AutoSavingCache<Pair<Descriptor,DecoratedKey>, Long> keyCache;

    public final AutoSavingCache<DecoratedKey, ColumnFamily> rowCache;

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

    volatile double liveRatio = 1.0;

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

    private final AtomicLong liveRatioComputedAt = new AtomicLong(32);

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

        if (!memtime.isModified())

            for (ColumnFamilyStore cfs : concatWithIndexes())

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

        if (!memsize.isModified())

            for (ColumnFamilyStore cfs : concatWithIndexes())

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

        if (!memops.isModified())

            for (ColumnFamilyStore cfs : concatWithIndexes())

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

        if (!rowCacheSaveInSeconds.isModified())

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

        if (!keyCacheSaveInSeconds.isModified())

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

       

        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 indexedColumn : indexedColumns.keySet())

        {

            ColumnDefinition def = metadata.getColumn_metadata().get(indexedColumn);

            if (def == null || def.getIndexType() == null)

                removeIndex(indexedColumn);

        }

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

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

                addIndex(cdef);

    }

    void removeIndex(ByteBuffer indexedColumn)

    {

        ColumnFamilyStore indexCfs = indexedColumns.remove(indexedColumn);

        if (indexCfs == null)

        {

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

            return;

        }

        indexCfs.unregisterMBean();

        SystemTable.setIndexRemoved(metadata.ksName, indexCfs.columnFamily);

        indexCfs.removeAllSSTables();

    }

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

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

        if (logger.isDebugEnabled())

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

        ICache<Pair<Descriptor, DecoratedKey>, Long> kc = ConcurrentLinkedHashCache.create(0, table.name, columnFamilyName);

        keyCache = new AutoSavingKeyCache<Pair<Descriptor, DecoratedKey>, Long>(kc, table.name, columnFamilyName);

        ICache<DecoratedKey, ColumnFamily> rc = metadata.getRowCacheProvider().create(0, table.name, columnFamilyName);

        rowCache = new AutoSavingRowCache<DecoratedKey, ColumnFamily>(rc, table.name, columnFamilyName);

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

        data = new DataTracker(this);

        Set<DecoratedKey> savedKeys = keyCache.readSaved();

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

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

        {

           SSTableReader reader = openSSTableReader(sstableFiles, savedKeys, data, metadata, partitioner);

            if (reader != null) // if == null, logger errors where already fired

                sstables.add(reader);

        }

        data.addSSTables(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);

        }

    }

    public Future<?> addIndex(final ColumnDefinition info)

    {

        assert info.getIndexType() != null;

        // create the index CFS

        final CFMetaData indexedCfMetadata = CFMetaData.newIndexMetadata(metadata, info, indexComparator());

        ColumnFamilyStore indexedCfs = ColumnFamilyStore.createColumnFamilyStore(table,

                                                                                 indexedCfMetadata.cfName,

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

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

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

        if (indexedCfs.isIndexBuilt())

            return null;

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

            {

                try

                {

                    forceBlockingFlush();

                }

                catch (ExecutionException e)

                {

                    throw new RuntimeException(e);

                }

                catch (InterruptedException e)

                {

                    throw new AssertionError(e);

                }

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

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

            }

        };

        FutureTask<?> f = new FutureTask<Object>(runnable, null);

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

        return f;

    }

    public static AbstractType indexComparator()

    {

        IPartitioner rowPartitioner = StorageService.getPartitioner();

        return (rowPartitioner instanceof OrderPreservingPartitioner || rowPartitioner instanceof ByteOrderedPartitioner)

                                        ? BytesType.instance

                                        : new LocalByPartionerType(StorageService.getPartitioner());

    }

    /**

     * Build secondary indexes for the provided {@code columns}.

     * This does nothing if {@code columns} is empty.

     */

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

    {

        if (columns.isEmpty())

            return;

        logger.info(String.format("Submitting index build of %s for data in %s",

                                  metadata.comparator.getString(columns), StringUtils.join(sstables, ", ")));

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

        }

        logger.info("Index build of " + metadata.comparator.getString(columns) + " complete");

    }

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

    {

        return data.getMinRowSize();

    }

    public long getMaxRowSize()

    {

        return data.getMaxRowSize();

    }

    public long getMeanRowSize()

    {

        return data.getMeanRowSize();

    }

    public int getMeanColumns()

    {

        return data.getMeanColumns();

    }

    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 (String path : DatabaseDescriptor.getAllDataFileLocationsForTable(table.name))

        {

            Iterable<Pair<Descriptor, Component>> pairs = files(new File(path));

            File incrementalsPath = new File(path, "backups");

            if (incrementalsPath.exists())

                pairs = Iterables.concat(pairs, files(incrementalsPath));

            for (Pair<Descriptor, Component> pair : pairs)

            {

                Descriptor desc = pair.left;

                if (!desc.cfname.equals(columnFamily))

                    continue;

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

    }

    /**

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

        Table table = Table.open(ksName);

        table.getColumnFamilyStore(cfName).loadNewSSTables();

    }

    /**

     * #{@inheritDoc}

     */

    public synchronized void loadNewSSTables()

    {

        logger.info("Loading new SSTables for " + table.name + "/" + columnFamily + "...");

        // current view over ColumnFamilyStore

        DataTracker.View view = data.getView();

        // descriptors of currently registered SSTables

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

        // going to hold new SSTable view of the CFS containing old and new SSTables

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

        Set<DecoratedKey> savedKeys = keyCache.readSaved();

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

        int generation = 0;

        for (SSTableReader reader : view.sstables)

        {

            sstables.add(reader); // first of all, add old SSTables

            currentDescriptors.add(reader.descriptor);

            if (reader.descriptor.generation > generation)

                generation = reader.descriptor.generation;

        }

        SSTableReader reader;

        // set to true if we have at least one new SSTable to load

        boolean atLeastOneNew = false;

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

        {

            Descriptor descriptor = rawSSTable.getKey();

            if (currentDescriptors.contains(descriptor))

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

            if (!descriptor.cfname.equals(columnFamily))

                continue;

            if (descriptor.isFromTheFuture())

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

                                                         Descriptor.CURRENT_VERSION,

                                                         descriptor));

            logger.info("Initializing new SSTable {}", rawSSTable);

            reader = openSSTableReader(rawSSTable, savedKeys, data, metadata, partitioner);

            if (reader == null)

                continue; // something wrong with SSTable, skipping

            sstables.add(reader);

            if (descriptor.generation > generation)

                generation = descriptor.generation;

            if (!atLeastOneNew) // set flag only once

                atLeastOneNew = true;

        }

        if (!atLeastOneNew)

        {

            logger.info("No new SSTables where found for " + table.name + "/" + columnFamily);

            return;

        }

        logger.info("Loading new SSTable Set for " + table.name + "/" + columnFamily + ": " + sstables);

        data.addSSTables(sstables); // this will call updateCacheSizes() for us

        logger.info("Requesting a full secondary index re-build for " + table.name + "/" + columnFamily);

        maybeBuildSecondaryIndexes(sstables, getIndexedColumns());

        logger.info("Setting up new generation: " + generation);

        fileIndexGenerator.set(generation);

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

    }

    /**

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

    {

        logger.info("Removing compacted SSTable files (see http://wiki.apache.org/cassandra/MemtableSSTable)");

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

        }

    }

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

    public void initCaches()

    {

        long start = System.currentTimeMillis();

        // results are sorted on read (via treeset) because there are few reads and many writes and reads only happen at startup

        for (DecoratedKey key : rowCache.readSaved())

            cacheRow(key);

        if (rowCache.size() > 0)

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

                                      System.currentTimeMillis()-start,

                                      rowCache.size(),

                                      table.name,

                                      columnFamily));

        scheduleCacheSaving(metadata.getRowCacheSavePeriodInSeconds(), metadata.getKeyCacheSavePeriodInSeconds());

    }

    public void scheduleCacheSaving(int rowCacheSavePeriodInSeconds, int keyCacheSavePeriodInSeconds)

    {

        keyCache.scheduleSaving(keyCacheSavePeriodInSeconds);

        rowCache.scheduleSaving(rowCacheSavePeriodInSeconds);

    }

    public AutoSavingCache<Pair<Descriptor,DecoratedKey>, Long> getKeyCache()

    {

        return keyCache;

    }

    /**

     * Collects a map of sstable components.

     */

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

    {

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

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

        {

            for (Pair<Descriptor, Component> component : files(new File(directory)))

            {

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

                {

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

                     && (includeTemporary || !component.left.temporary))

                    {

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

    }

    private static List<Pair<Descriptor, Component>> files(File path)

    {

        final List<Pair<Descriptor, Component>> sstables = new ArrayList<Pair<Descriptor, Component>>();

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

        path.list(new FilenameFilter()

        {

            public boolean accept(File dir, String name)

            {

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

                if (pair != null)

                    sstables.add(pair);

                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 estimatedSize, String version)

    {

        String location = table.getDataFileLocation(estimatedSize);

        if (location == null)

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

        return getTempSSTablePath(location, version);

    }

    public String getTempSSTablePath(String directory, String version)

    {

        Descriptor desc = new Descriptor(version,

                                         new File(directory),

                                         table.name,

                                         columnFamily,

                                         fileIndexGenerator.incrementAndGet(),

                                         true);

        return desc.filenameFor(Component.DATA);

    }

    public String getTempSSTablePath(String directory)

    {

        return getTempSSTablePath(directory, Descriptor.CURRENT_VERSION);

    }

    /** 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 (oldMemtable.isFrozen())

        {

            logger.debug("memtable is already frozen; another thread must be flushing it");

            return null;

        }

        /*

         * 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.switchLock.writeLock().lock();

        try

        {

            if (oldMemtable.isFrozen())

            {

                logger.debug("memtable is already frozen; another thread must be flushing it");

                return null;

            }

            assert getMemtableThreadSafe() == oldMemtable;

            oldMemtable.freeze();

            final ReplayPosition ctx = writeCommitLog ? CommitLog.instance.getContext() : ReplayPosition.NONE;

            logger.debug("flush position is {}", ctx);

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

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

            // 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 (!cfs.getMemtableThreadSafe().isClean())

                    icc.add(cfs);

            }

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

            for (ColumnFamilyStore cfs : icc)

                submitFlush(cfs.data.switchMemtable(), latch, ctx);

            // we marked our memtable as frozen as part of the concurrency control,

            // so even if there was nothing to flush we need to switch it out

            if (!icc.contains(this))

                data.renewMemtable();

            if (memtableSwitchCount == Integer.MAX_VALUE)

                memtableSwitchCount = 0;

            memtableSwitchCount++;

            // 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.switchLock.writeLock().unlock();

        }

    }

    public boolean isDropped()

    {

        return isIndex()

               ? DatabaseDescriptor.getCFMetaData(table.name, getParentColumnfamily()) == null

               : DatabaseDescriptor.getCFMetaData(metadata.cfId) == null;

    }

    void switchBinaryMemtable(DecoratedKey key, ByteBuffer buffer)

    {

        binaryMemtable.set(new BinaryMemtable(this));

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

    }

    public void forceFlushIfExpired()

    {

        if (getMemtableThreadSafe().isExpired())

            forceFlush();

    }

    public Future<?> forceFlush()

    {

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

        boolean clean = true;

        for (ColumnFamilyStore cfs : concatWithIndexes())

            clean &= cfs.getMemtableThreadSafe().isClean();

        if (clean)

        {

            logger.debug("forceFlush requested but everything is clean");

            return null;

        }

        return maybeSwitchMemtable(getMemtableThreadSafe(), 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), null);

    }

    public void updateRowCache(DecoratedKey key, ColumnFamily columnFamily)

    {

        if (rowCache.isPutCopying())

        {

            invalidateCachedRow(key);

        }

        else

        {

            ColumnFamily cachedRow = getRawCachedRow(key);

            if (cachedRow != null)

                cachedRow.addAll(columnFamily);

        }

    }

    /**

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

        Memtable mt = getMemtableThreadSafe();

        boolean flushRequested = mt.isThresholdViolated();

        mt.put(key, columnFamily);

        updateRowCache(key, columnFamily);

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