import com.netflix.astyanax.connectionpool.exceptions.BadRequestException; //导入依赖的package包/类
private void createSchema() throws ConnectionException {
    boolean keyspaceExists = false;
    try {
        if (keyspace.describeKeyspace() != null) {
            keyspaceExists = true;
        }
    } catch(BadRequestException e) {
        // do nothing, keyspace does not exist
    }

    if(!keyspaceExists) {
        keyspace.createKeyspace(ImmutableMap.<String, Object> builder()
                .put("strategy_options", ImmutableMap.<String, Object> builder().put("replication_factor", "1").build())
                .put("strategy_class", "SimpleStrategy").build());
    }

    if (keyspace.describeKeyspace().getColumnFamily(blobCFName) == null) {
        keyspace.createColumnFamily(blobCF,
                ImmutableMap.<String, Object> builder().put("key_validation_class", "UTF8Type").put("comparator_type", "UTF8Type").build());
    }
}
 

import com.netflix.astyanax.connectionpool.exceptions.BadRequestException; //导入依赖的package包/类
public static void deleteCassandraKeySpace(String cassandraConnString, String keySpace) throws Exception {

        try {
            AstyanaxContext<Keyspace> context = new AstyanaxContext.Builder()
                    .forCluster("ClusterName")
                    .forKeyspace(keySpace)
                    .withAstyanaxConfiguration(new AstyanaxConfigurationImpl()
                                    .setDiscoveryType(NodeDiscoveryType.RING_DESCRIBE)
                    )
                    .withConnectionPoolConfiguration(new ConnectionPoolConfigurationImpl("MyConnectionPool")
                                    .setMaxConnsPerHost(1)
                                    .setSeeds(cassandraConnString)
                    )
                    .withConnectionPoolMonitor(new CountingConnectionPoolMonitor())
                    .buildKeyspace(ThriftFamilyFactory.getInstance());

            context.start();
            Keyspace keyspace = context.getClient();
            keyspace.dropKeyspace();
            context.shutdown();
        } catch (BadRequestException e) {
            LOG.warn("Could not delete cassandra keyspace, assuming it does not exist.", e);
        }
    }
 

import com.netflix.astyanax.connectionpool.exceptions.BadRequestException; //导入依赖的package包/类
/**
 * Return true if the exception is an instance of a missing keysapce
 * @param rethrowMessage The message to add to the exception if rethrown
 * @param cassandraException The exception from cassandar
 * @return
 */
public static void isSchemaMissing(final String rethrowMessage, final Exception cassandraException ) {

    if ( cassandraException instanceof BadRequestException ) {

        //check if it's b/c the keyspace is missing, if so
        final String message = cassandraException.getMessage();

        //no op, just swallow
        if( (message.contains( "why:Keyspace" ) && message.contains( "does not exist" ))
            || message.contains("why:unconfigured columnfamily")){
            return;
        };
    }

   throw new RuntimeException( rethrowMessage, cassandraException );
}
 

import com.netflix.astyanax.connectionpool.exceptions.BadRequestException; //导入依赖的package包/类
public static void setupCassandraKeySpace(String cassandraConnectionString, String keySpaceName,
                                          String columnFamily) throws ConnectionException {

    try {
        AstyanaxContext<Keyspace> context = new AstyanaxContext.Builder()
                .forCluster("ClusterName")
                .forKeyspace(keySpaceName)
                .withAstyanaxConfiguration(new AstyanaxConfigurationImpl()
                                .setDiscoveryType(NodeDiscoveryType.RING_DESCRIBE)
                )
                .withConnectionPoolConfiguration(new ConnectionPoolConfigurationImpl("MyConnectionPool")
                                .setMaxConnsPerHost(1)
                                .setSeeds(cassandraConnectionString)
                )
                .withConnectionPoolMonitor(new CountingConnectionPoolMonitor())
                .buildKeyspace(ThriftFamilyFactory.getInstance());

        context.start();
        Keyspace keyspace = context.getClient();

        // Using simple strategy
        keyspace.createKeyspace(ImmutableMap.<String, Object>builder()
                        .put("strategy_options", ImmutableMap.<String, Object>builder()
                                .put("replication_factor", "1")
                                .build())
                        .put("strategy_class", "SimpleStrategy")
                        .build()
        );

        ColumnFamily<String, String> CF_STANDARD1 = ColumnFamily.newColumnFamily(columnFamily,
                StringSerializer.get(), StringSerializer.get());

        keyspace.createColumnFamily(CF_STANDARD1, null);
        context.shutdown();
    } catch(BadRequestException e) {
        LOG.warn("could not setup cassandra keyspace , assuming keyspace already exists.", e);
    }
}
 

import com.netflix.astyanax.connectionpool.exceptions.BadRequestException; //导入依赖的package包/类
private static void verifyMagic(Keyspace keyspace) throws ConnectionException {
  OperationResult<ColumnList<String>> result;
  try {
    result = keyspace.prepareQuery(CF_CONFIG)
        .getKey(CONFIGURATION_MAGIC_KEY)
        .execute();
  } catch (BadRequestException e) {
    throw new HumanReadableException("Artifact cache error during schema verification: %s",
        e.getMessage());
  }
  Column<String> column = result.getResult().getColumnByName(CONFIGURATION_COLUMN_NAME);
  if (column == null || !column.getStringValue().equals(CONFIGURATION_MAGIC_VALUE)) {
    throw new HumanReadableException("Artifact cache schema mismatch");
  }
}
 

import com.netflix.astyanax.connectionpool.exceptions.BadRequestException; //导入依赖的package包/类
public boolean isBootstrapping() {
    if ( getCause() instanceof BadRequestException ) {
        BadRequestException bre = (BadRequestException)getCause();
        String msg = bre.getMessage();
        if ( (msg.contains("Keyspace") && msg.contains( "does not exist" )) || msg.contains("unconfigured columnfamily")) {
            return true;
        }
    }
    return false;
}