Java Descriptor类代码示例

import org.apache.cassandra.io.sstable.Descriptor; //导入依赖的package包/类
public Map<MetadataType, MetadataComponent> deserialize(Descriptor descriptor, EnumSet<MetadataType> types) throws IOException
{
    Map<MetadataType, MetadataComponent> components;
    logger.trace("Load metadata for {}", descriptor);
    String statsFile = descriptor.filenameFor(Component.STATS);

    if (!HadoopFileUtils.exists(statsFile, descriptor.getConfiguration()))
    {
        logger.trace("No sstable stats for {}", descriptor);
        components = Maps.newHashMap();
        components.put(MetadataType.STATS, MetadataCollector.defaultStatsMetadata());
    }
    else
    {
        try (RandomAccessReader r = RandomAccessReader.open(statsFile, descriptor.getConfiguration()))
        {
            components = deserialize(descriptor, r, types);
        }
    }

    return components;
}
 

import org.apache.cassandra.io.sstable.Descriptor; //导入依赖的package包/类
/**
 * Open a RowIndexedReader which already has its state initialized (by SSTableWriter).
 */
public static SSTableReader internalOpen(Descriptor desc,
                                  Set<Component> components,
                                  CFMetaData metadata,
                                  FileHandle ifile,
                                  FileHandle dfile,
                                  IndexSummary isummary,
                                  IFilter bf,
                                  long maxDataAge,
                                  StatsMetadata sstableMetadata,
                                  OpenReason openReason,
                                  SerializationHeader header)
{
    assert desc != null && ifile != null && dfile != null && isummary != null && bf != null && sstableMetadata != null;

    SSTableReader reader = internalOpen(desc, components, metadata, maxDataAge, sstableMetadata, openReason, header);

    reader.bf = bf;
    reader.ifile = ifile;
    reader.dfile = dfile;
    reader.indexSummary = isummary;
    reader.setup(true);

    return reader;
}
 

import org.apache.cassandra.io.sstable.Descriptor; //导入依赖的package包/类
@SuppressWarnings("resource")
public static Ref<GlobalTidy> get(SSTableReader sstable)
{
    Descriptor descriptor = sstable.descriptor;
    Ref<GlobalTidy> refc = lookup.get(descriptor);
    if (refc != null)
        return refc.ref();
    final GlobalTidy tidy = new GlobalTidy(sstable);
    refc = new Ref<>(tidy, tidy);
    Ref<?> ex = lookup.putIfAbsent(descriptor, refc);
    if (ex != null)
    {
        refc.close();
        //throw new AssertionError();
    }
    return refc;
}
 

import org.apache.cassandra.io.sstable.Descriptor; //导入依赖的package包/类
public static Iterator<OnDiskAtom> onDiskIterator(final DataInput in,
                                                  final ColumnSerializer.Flag flag,
                                                  final int expireBefore,
                                                  final Descriptor.Version version,
                                                  final CellNameType type)
{
    return new AbstractIterator<OnDiskAtom>()
    {
        protected OnDiskAtom computeNext()
        {
            OnDiskAtom atom;
            try
            {
                atom = type.onDiskAtomSerializer().deserializeFromSSTable(in, flag, expireBefore, version);
            }
            catch (IOException e)
            {
                throw new IOError(e);
            }
            if (atom == null)
                return endOfData();

            return atom;
        }
    };
}
 

import org.apache.cassandra.io.sstable.Descriptor; //导入依赖的package包/类
@VisibleForTesting
protected synchronized void compact()
{
    ArrayList<Descriptor> descriptors = new ArrayList<>();
    for (SSTable sstable : hintStore.getDataTracker().getUncompactingSSTables())
        descriptors.add(sstable.descriptor);

    if (descriptors.isEmpty())
        return;

    try
    {
        CompactionManager.instance.submitUserDefined(hintStore, descriptors, (int) (System.currentTimeMillis() / 1000)).get();
    }
    catch (InterruptedException | ExecutionException e)
    {
        throw new RuntimeException(e);
    }
}
 

import org.apache.cassandra.io.sstable.Descriptor; //导入依赖的package包/类
@Test
public void testMTSnapshots() throws Exception
{
    for (final CFMetaData cfm : CFM)
    {
        final Directories directories = new Directories(cfm);
        assertEquals(cfDir(cfm), directories.getDirectoryForNewSSTables());
        final String n = Long.toString(System.nanoTime());
        Callable<File> directoryGetter = new Callable<File>() {
            public File call() throws Exception {
                Descriptor desc = new Descriptor(cfDir(cfm), KS, cfm.cfName, 1);
                return Directories.getSnapshotDirectory(desc, n);
            }
        };
        List<Future<File>> invoked = Executors.newFixedThreadPool(2).invokeAll(Arrays.asList(directoryGetter, directoryGetter));
        for(Future<File> fut:invoked) {
            assertTrue(fut.get().exists());
        }
    }
}
 

import org.apache.cassandra.io.sstable.Descriptor; //导入依赖的package包/类
public void create(Collection<SSTableWriter> sstables)
{
    List<String> sstablePaths = new ArrayList<>(sstables.size());
    for (SSTableWriter writer : sstables)
    {
        /* write out the file names *without* the 'tmp-file' flag in the file name.
           this class will not need to clean up tmp files (on restart), CassandraDaemon does that already,
           just make sure we delete the fully-formed SSTRs. */
        sstablePaths.add(writer.descriptor.asType(Descriptor.Type.FINAL).baseFilename());
    }

    try
    {
        Files.write(lockfile.toPath(), sstablePaths, Charsets.UTF_8,
                StandardOpenOption.CREATE_NEW, StandardOpenOption.WRITE, StandardOpenOption.DSYNC);
    }
    catch (IOException e)
    {
        logger.warn(String.format("Could not create lockfile %s for stream session, nothing to worry too much about", lockfile), e);
    }
}
 

import org.apache.cassandra.io.sstable.Descriptor; //导入依赖的package包/类
@Test
public void testBackupAfterFlush() throws Throwable
{
    ColumnFamilyStore cfs = Keyspace.open(KEYSPACE2).getColumnFamilyStore(CF_STANDARD1);
    new RowUpdateBuilder(cfs.metadata, 0, ByteBufferUtil.bytes("key1")).clustering("Column1").add("val", "asdf").build().applyUnsafe();
    cfs.forceBlockingFlush();
    new RowUpdateBuilder(cfs.metadata, 0, ByteBufferUtil.bytes("key2")).clustering("Column1").add("val", "asdf").build().applyUnsafe();
    cfs.forceBlockingFlush();

    for (int version = 1; version <= 2; ++version)
    {
        Descriptor existing = new Descriptor(cfs.getDirectories().getDirectoryForNewSSTables(), KEYSPACE2, CF_STANDARD1, version);
        Descriptor desc = new Descriptor(Directories.getBackupsDirectory(existing), KEYSPACE2, CF_STANDARD1, version);
        for (Component c : new Component[]{ Component.DATA, Component.PRIMARY_INDEX, Component.FILTER, Component.STATS })
            assertTrue("Cannot find backed-up file:" + desc.filenameFor(c), new File(desc.filenameFor(c)).exists());
    }
}
 

import org.apache.cassandra.io.sstable.Descriptor; //导入依赖的package包/类
public Map<MetadataType, MetadataComponent> deserialize(Descriptor descriptor, FileDataInput in, EnumSet<MetadataType> types) throws IOException
{
    Map<MetadataType, MetadataComponent> components = Maps.newHashMap();
    // read number of components
    int numComponents = in.readInt();
    // read toc
    Map<MetadataType, Integer> toc = new HashMap<>(numComponents);
    for (int i = 0; i < numComponents; i++)
    {
        toc.put(MetadataType.values()[in.readInt()], in.readInt());
    }
    for (MetadataType type : types)
    {
        MetadataComponent component = null;
        if (toc.containsKey(type))
        {
            in.seek(toc.get(type));
            component = type.serializer.deserialize(descriptor.version, in);
        }
        components.put(type, component);
    }
    return components;
}
 

import org.apache.cassandra.io.sstable.Descriptor; //导入依赖的package包/类
public static synchronized ColumnFamilyStore createColumnFamilyStore(Keyspace keyspace,
                                                                     String columnFamily,
                                                                     CFMetaData metadata,
                                                                     boolean loadSSTables)
{
    // get the max generation number, to prevent generation conflicts
    Directories directories = new Directories(metadata, initialDirectories);
    Directories.SSTableLister lister = directories.sstableLister(Directories.OnTxnErr.IGNORE).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("Incompatible SSTable found. Current version %s is unable to read file: %s. Please run upgradesstables.",
                    desc.getFormat().getLatestVersion(), desc));
    }
    Collections.sort(generations);
    int value = (generations.size() > 0) ? (generations.get(generations.size() - 1)) : 0;

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

import org.apache.cassandra.io.sstable.Descriptor; //导入依赖的package包/类
private static int numLegacyFiles()
{
    int ret = 0;
    Iterable<String> dirs = Arrays.asList(DatabaseDescriptor.getAllDataFileLocations());
    for (String dataDir : dirs)
    {
        File dir = new File(dataDir);
        for (File ksdir : dir.listFiles((d, n) -> new File(d, n).isDirectory()))
        {
            for (File cfdir : ksdir.listFiles((d, n) -> new File(d, n).isDirectory()))
            {
                if (Descriptor.isLegacyFile(cfdir))
                {
                    ret++;
                }
                else
                {
                    File[] legacyFiles = cfdir.listFiles((d, n) -> Descriptor.isLegacyFile(new File(d, n)));
                    ret += legacyFiles.length;
                }
            }
        }
    }
    return ret;
}
 

import org.apache.cassandra.io.sstable.Descriptor; //导入依赖的package包/类
@Test
public void testMTSnapshots() throws Exception
{
    for (final CFMetaData cfm : CFM)
    {
        final Directories directories = new Directories(cfm);
        assertEquals(cfDir(cfm), directories.getDirectoryForNewSSTables());
        final String n = Long.toString(System.nanoTime());
        Callable<File> directoryGetter = new Callable<File>() {
            public File call() throws Exception {
                Descriptor desc = new Descriptor(cfDir(cfm), KS, cfm.cfName, 1, Descriptor.Type.FINAL);
                return Directories.getSnapshotDirectory(desc, n);
            }
        };
        List<Future<File>> invoked = Executors.newFixedThreadPool(2).invokeAll(Arrays.asList(directoryGetter, directoryGetter));
        for(Future<File> fut:invoked) {
            assertTrue(fut.get().exists());
        }
    }
}
 

import org.apache.cassandra.io.sstable.Descriptor; //导入依赖的package包/类
@Test
/* 
 *  The schema is 
 *      CREATE TABLE cql_keyspace.table1 (k int PRIMARY KEY, v1 text, v2 int)
 * */
public void shouldImportCqlTable() throws IOException, URISyntaxException
{
    String cql_keyspace = "cql_keyspace";
    String cql_table = "table1";
    String jsonUrl = resourcePath("CQLTable.json");
    File tempSS = tempSSTableFile(cql_keyspace, cql_table);
    new SSTableImport(true).importJson(jsonUrl, cql_keyspace, cql_table, tempSS.getPath());
    SSTableReader reader = SSTableReader.open(Descriptor.fromFilename(tempSS.getPath()));
    Keyspace.open(cql_keyspace).getColumnFamilyStore(cql_table).addSSTable(reader);
    
    UntypedResultSet result = QueryProcessor.executeOnceInternal(String.format("SELECT * FROM %s.%s", cql_keyspace, cql_table));
    assertThat(result.size(), is(2));
    assertThat(result, hasItem(withElements(1, "NY", 1980)));
    assertThat(result, hasItem(withElements(2, "CA", 2014)));
    reader.selfRef().release();
}
 

import org.apache.cassandra.io.sstable.Descriptor; //导入依赖的package包/类
@Test
public void testSerialization() throws IOException
{
    Map<MetadataType, MetadataComponent> originalMetadata = constructMetadata();

    MetadataSerializer serializer = new MetadataSerializer();
    File statsFile = serialize(originalMetadata, serializer, BigFormat.latestVersion);

    Descriptor desc = new Descriptor( statsFile.getParentFile(), "", "", 0);
    try (RandomAccessReader in = RandomAccessReader.open(statsFile))
    {
        Map<MetadataType, MetadataComponent> deserialized = serializer.deserialize(desc, in, EnumSet.allOf(MetadataType.class));

        for (MetadataType type : MetadataType.values())
        {
            assertEquals(originalMetadata.get(type), deserialized.get(type));
        }
    }
}
 

import org.apache.cassandra.io.sstable.Descriptor; //导入依赖的package包/类
public RowIndexEntry deserialize(DataInput in, Descriptor.Version version) throws IOException
{
    long position = in.readLong();

    int size = in.readInt();
    if (size > 0)
    {
        DeletionTime deletionTime = DeletionTime.serializer.deserialize(in);

        int entries = in.readInt();
        List<IndexHelper.IndexInfo> columnsIndex = new ArrayList<IndexHelper.IndexInfo>(entries);
        for (int i = 0; i < entries; i++)
            columnsIndex.add(IndexHelper.IndexInfo.deserialize(in));

        return new IndexedEntry(position, deletionTime, columnsIndex);
    }
    else
    {
        return new RowIndexEntry(position);
    }
}