Java ConsistencyLevel类代码示例

import org.apache.cassandra.db.ConsistencyLevel; //导入依赖的package包/类
private EnumSet<Flag> gatherFlags(QueryOptions options)
{
    EnumSet<Flag> flags = EnumSet.noneOf(Flag.class);
    if (options.getValues().size() > 0)
        flags.add(Flag.VALUES);
    if (options.skipMetadata())
        flags.add(Flag.SKIP_METADATA);
    if (options.getPageSize() >= 0)
        flags.add(Flag.PAGE_SIZE);
    if (options.getPagingState() != null)
        flags.add(Flag.PAGING_STATE);
    if (options.getSerialConsistency() != ConsistencyLevel.SERIAL)
        flags.add(Flag.SERIAL_CONSISTENCY);
    if (options.getSpecificOptions().timestamp != Long.MIN_VALUE)
        flags.add(Flag.TIMESTAMP);
    return flags;
}
 

import org.apache.cassandra.db.ConsistencyLevel; //导入依赖的package包/类
private void mutate(List<org.apache.cassandra.db.Mutation> cmds, org.apache.cassandra.db.ConsistencyLevel clvl) throws BackendException {
    try {
        schedule(DatabaseDescriptor.getRpcTimeout());
        try {
            if (atomicBatch) {
                StorageProxy.mutateAtomically(cmds, clvl);
            } else {
                StorageProxy.mutate(cmds, clvl);
            }
        } catch (RequestExecutionException e) {
            throw new TemporaryBackendException(e);
        } finally {
            release();
        }
    } catch (TimeoutException ex) {
        log.debug("Cassandra TimeoutException", ex);
        throw new TemporaryBackendException(ex);
    }
}
 

import org.apache.cassandra.db.ConsistencyLevel; //导入依赖的package包/类
private static void setupDefaultSuperuser()
{
    try
    {
        // insert a default superuser if AUTH_KS.USERS_CF is empty.
        if (!hasExistingUsers())
        {
            QueryProcessor.process(String.format("INSERT INTO %s.%s (name, super) VALUES ('%s', %s) USING TIMESTAMP 0",
                                                 AUTH_KS,
                                                 USERS_CF,
                                                 DEFAULT_SUPERUSER_NAME,
                                                 true),
                                   ConsistencyLevel.ONE);
            logger.info("Created default superuser '{}'", DEFAULT_SUPERUSER_NAME);
        }
    }
    catch (RequestExecutionException e)
    {
        logger.warn("Skipped default superuser setup: some nodes were not ready");
    }
}
 

import org.apache.cassandra.db.ConsistencyLevel; //导入依赖的package包/类
private void setupDefaultUser()
{
    try
    {
        // insert the default superuser if AUTH_KS.CREDENTIALS_CF is empty.
        if (!hasExistingUsers())
        {
            process(String.format("INSERT INTO %s.%s (username, salted_hash) VALUES ('%s', '%s') USING TIMESTAMP 0",
                                  Auth.AUTH_KS,
                                  CREDENTIALS_CF,
                                  DEFAULT_USER_NAME,
                                  escape(hashpw(DEFAULT_USER_PASSWORD))),
                    ConsistencyLevel.ONE);
            logger.info("PasswordAuthenticator created default user '{}'", DEFAULT_USER_NAME);
        }
    }
    catch (RequestExecutionException e)
    {
        logger.warn("PasswordAuthenticator skipped default user setup: some nodes were not ready");
    }
}
 

import org.apache.cassandra.db.ConsistencyLevel; //导入依赖的package包/类
public DatacenterSyncWriteResponseHandler(Collection<InetAddress> naturalEndpoints,
                                          Collection<InetAddress> pendingEndpoints,
                                          ConsistencyLevel consistencyLevel,
                                          Keyspace keyspace,
                                          Runnable callback,
                                          WriteType writeType)
{
    // Response is been managed by the map so make it 1 for the superclass.
    super(keyspace, naturalEndpoints, pendingEndpoints, consistencyLevel, callback, writeType);
    assert consistencyLevel == ConsistencyLevel.EACH_QUORUM;

    strategy = (NetworkTopologyStrategy) keyspace.getReplicationStrategy();

    for (String dc : strategy.getDatacenters())
    {
        int rf = strategy.getReplicationFactor(dc);
        responses.put(dc, new AtomicInteger((rf / 2) + 1));
    }

    // During bootstrap, we have to include the pending endpoints or we may fail the consistency level
    // guarantees (see #833)
    for (InetAddress pending : pendingEndpoints)
    {
        responses.get(snitch.getDatacenter(pending)).incrementAndGet();
    }
}
 

import org.apache.cassandra.db.ConsistencyLevel; //导入依赖的package包/类
private static void setupDefaultSuperuser()
{
    try
    {
        // insert a default superuser if AUTH_KS.USERS_CF is empty.
        if (QueryProcessor.process(String.format("SELECT * FROM %s.%s", AUTH_KS, USERS_CF), ConsistencyLevel.QUORUM).isEmpty())
        {
            QueryProcessor.process(String.format("INSERT INTO %s.%s (name, super) VALUES ('%s', %s) USING TIMESTAMP 0",
                                                 AUTH_KS,
                                                 USERS_CF,
                                                 DEFAULT_SUPERUSER_NAME,
                                                 true),
                                   ConsistencyLevel.QUORUM);
            logger.info("Created default superuser '{}'", DEFAULT_SUPERUSER_NAME);
        }
    }
    catch (RequestExecutionException e)
    {
        logger.warn("Skipped default superuser setup: some nodes were not ready");
    }
}
 

import org.apache.cassandra.db.ConsistencyLevel; //导入依赖的package包/类
@Test
public void executeTriggerOnThriftBatchUpdate() throws Exception
{
    Cassandra.Client client = new Cassandra.Client(
                                new TBinaryProtocol(
                                    new TFramedTransportFactory().openTransport(
                                        InetAddress.getLocalHost().getHostName(), 9170)));
    client.set_keyspace(ksName);
    org.apache.cassandra.thrift.Mutation mutation = new org.apache.cassandra.thrift.Mutation();
    ColumnOrSuperColumn cosc = new ColumnOrSuperColumn();
    cosc.setColumn(getColumnForInsert("v1", 3));
    mutation.setColumn_or_supercolumn(cosc);
    client.batch_mutate(
        Collections.singletonMap(bytes(3),
                                 Collections.singletonMap(cfName,
                                                          Collections.singletonList(mutation))),
        org.apache.cassandra.thrift.ConsistencyLevel.ONE);

    assertUpdateIsAugmented(3);
}
 

import org.apache.cassandra.db.ConsistencyLevel; //导入依赖的package包/类
@Test(expected=InvalidRequestException.class)
public void onThriftCASRejectGeneratedUpdatesForDifferentCF() throws Exception
{
    String cf = "cf" + System.nanoTime();
    try
    {
        setupTableWithTrigger(cf, CrossTableTrigger.class);
        Cassandra.Client client = new Cassandra.Client(
                new TBinaryProtocol(
                        new TFramedTransportFactory().openTransport(
                                InetAddress.getLocalHost().getHostName(), 9170)));
        client.set_keyspace(ksName);
        client.cas(bytes(10),
                   cf,
                   Collections.<Column>emptyList(),
                   Collections.singletonList(getColumnForInsert("v1", 10)),
                   org.apache.cassandra.thrift.ConsistencyLevel.LOCAL_SERIAL,
                   org.apache.cassandra.thrift.ConsistencyLevel.ONE);
    }
    finally
    {
        assertUpdateNotExecuted(cf, 10);
    }
}
 

import org.apache.cassandra.db.ConsistencyLevel; //导入依赖的package包/类
@Test(expected=InvalidRequestException.class)
public void onThriftCASRejectGeneratedUpdatesForDifferentPartition() throws Exception
{
    String cf = "cf" + System.nanoTime();
    try
    {
        setupTableWithTrigger(cf, CrossPartitionTrigger.class);
        Cassandra.Client client = new Cassandra.Client(
                new TBinaryProtocol(
                        new TFramedTransportFactory().openTransport(
                                InetAddress.getLocalHost().getHostName(), 9170)));
        client.set_keyspace(ksName);
        client.cas(bytes(9),
                   cf,
                   Collections.<Column>emptyList(),
                   Collections.singletonList(getColumnForInsert("v1", 9)),
                   org.apache.cassandra.thrift.ConsistencyLevel.LOCAL_SERIAL,
                   org.apache.cassandra.thrift.ConsistencyLevel.ONE);
    }
    finally
    {
        assertUpdateNotExecuted(cf, 9);
    }
}
 

import org.apache.cassandra.db.ConsistencyLevel; //导入依赖的package包/类
private static void testWriting() throws Exception
{
    // do some writing.
    for (int i = 0; i < 100; i++)
    {
        QueryProcessor.process(String.format("INSERT INTO %s.%s (id, name, value) VALUES ( 'key%d', 'colb', 'value%d')",
                                             KEYSPACE,
                                             COLUMN_FAMILY,
                                             i,
                                             i),
                               ConsistencyLevel.QUORUM);

        System.out.println("wrote key" + i);
    }
    System.out.println("Done writing.");
}
 

import org.apache.cassandra.db.ConsistencyLevel; //导入依赖的package包/类
AbstractReadExecutor(Keyspace keyspace, ReadCommand command, ConsistencyLevel consistencyLevel, List<InetAddress> targetReplicas)
{
    this.command = command;
    this.targetReplicas = targetReplicas;
    this.handler = new ReadCallback(new DigestResolver(keyspace, command, consistencyLevel, targetReplicas.size()), consistencyLevel, command, targetReplicas);
    this.traceState = Tracing.instance.get();

    // Set the digest version (if we request some digests). This is the smallest version amongst all our target replicas since new nodes
    // knows how to produce older digest but the reverse is not true.
    // TODO: we need this when talking with pre-3.0 nodes. So if we preserve the digest format moving forward, we can get rid of this once
    // we stop being compatible with pre-3.0 nodes.
    int digestVersion = MessagingService.current_version;
    for (InetAddress replica : targetReplicas)
        digestVersion = Math.min(digestVersion, MessagingService.instance().getVersion(replica));
    command.setDigestVersion(digestVersion);
}
 

import org.apache.cassandra.db.ConsistencyLevel; //导入依赖的package包/类
public BatchMessage decode(ChannelBuffer body, int version)
{
    if (version == 1)
        throw new ProtocolException("BATCH messages are not support in version 1 of the protocol");

    byte type = body.readByte();
    int n = body.readUnsignedShort();
    List<Object> queryOrIds = new ArrayList<Object>(n);
    List<List<ByteBuffer>> variables = new ArrayList<List<ByteBuffer>>(n);
    for (int i = 0; i < n; i++)
    {
        byte kind = body.readByte();
        if (kind == 0)
            queryOrIds.add(CBUtil.readLongString(body));
        else if (kind == 1)
            queryOrIds.add(MD5Digest.wrap(CBUtil.readBytes(body)));
        else
            throw new ProtocolException("Invalid query kind in BATCH messages. Must be 0 or 1 but got " + kind);
        variables.add(CBUtil.readValueList(body));
    }
    ConsistencyLevel consistency = CBUtil.readConsistencyLevel(body);
    return new BatchMessage(toType(type), queryOrIds, variables, consistency);
}
 

import org.apache.cassandra.db.ConsistencyLevel; //导入依赖的package包/类
private void addStatementMutations(ModificationStatement statement,
                                   List<ByteBuffer> variables,
                                   boolean local,
                                   ConsistencyLevel cl,
                                   long now,
                                   Map<Pair<String, ByteBuffer>, IMutation> mutations)
throws RequestExecutionException, RequestValidationException
{
    // Group mutation together, otherwise they won't get applied atomically
    for (IMutation m : statement.getMutations(variables, local, cl, attrs.getTimestamp(now, variables), true))
    {
        Pair<String, ByteBuffer> key = Pair.create(m.getKeyspaceName(), m.key());
        IMutation existing = mutations.get(key);

        if (existing == null)
        {
            mutations.put(key, m);
        }
        else
        {
            existing.addAll(m);
        }
    }
}
 

import org.apache.cassandra.db.ConsistencyLevel; //导入依赖的package包/类
DefaultQueryOptions(ConsistencyLevel consistency, List<ByteBuffer> values, boolean skipMetadata, SpecificOptions options, ProtocolVersion protocolVersion)
{
    this.consistency = consistency;
    this.values = values;
    this.skipMetadata = skipMetadata;
    this.options = options;
    this.protocolVersion = protocolVersion;
}
 

import org.apache.cassandra.db.ConsistencyLevel; //导入依赖的package包/类
private SpecificOptions(int pageSize, PagingState state, ConsistencyLevel serialConsistency, long timestamp)
{
    this.pageSize = pageSize;
    this.state = state;
    this.serialConsistency = serialConsistency == null ? ConsistencyLevel.SERIAL : serialConsistency;
    this.timestamp = timestamp;
}