log.trace("Created transport {}", transport); TBinaryProtocol protocol = new TBinaryProtocol(transport); Cassandra.Client client = new Cassandra.Client(protocol); if (!transport.isOpen()) { transport.open(); client.login(new AuthenticationRequest(credentials)); } catch (Exception e) { // TTransportException will propagate authentication/authorization failure throw new TTransportException(e);
client.set_keyspace(keyspaceName); // Don't remove client.set_keyspace(SYSTEM_KS); log.debug("Found existing keyspace {}", keyspaceName); } catch (InvalidRequestException e) { KsDef ksdef = new KsDef().setName(keyspaceName) .setCf_defs(new LinkedList<CfDef>()) // cannot be null but can be empty .setStrategy_class(storageConfig.get(REPLICATION_STRATEGY)) .setStrategy_options(strategyOptions); client.set_keyspace(SYSTEM_KS); try { client.system_add_keyspace(ksdef); retrySetKeyspace(keyspaceName, client); log.debug("Created keyspace {}", keyspaceName); return client.describe_keyspace(keyspaceName); } catch (Exception e) { throw new TemporaryBackendException(e);
Cassandra.Client client = conn.getClient(); if (atomicBatch) { client.atomic_batch_mutate(batch, consistency); } else { client.batch_mutate(batch, consistency);
CfDef professionalCfDef = new CfDef(); professionalCfDef.name = COLUMN_FAMILY_PROFESSIONAL; professionalCfDef.keyspace = _KEYSPACE; professionalCfDef.setComparator_type("UTF8Type"); professionalCfDef.setKey_validation_class("UTF8Type"); ksDef = CassandraCli.client.describe_keyspace(_KEYSPACE); CassandraCli.client.set_keyspace(_KEYSPACE); List<CfDef> cfDefn = ksDef.getCf_defs(); if (cfDef1.getName().equalsIgnoreCase(COLUMN_FAMILY_PROFESSIONAL)) CassandraCli.client.system_drop_column_family(COLUMN_FAMILY_PROFESSIONAL); CassandraCli.client.system_add_column_family(professionalCfDef); ksDef = new KsDef(_KEYSPACE, "org.apache.cassandra.locator.SimpleStrategy", cfDefs); Map<String, String> strategy_options = new HashMap<String, String>(); strategy_options.put("replication_factor", "1"); ksDef.setStrategy_options(strategy_options); CassandraCli.client.system_add_keyspace(ksDef); CassandraCli.client.set_keyspace(_KEYSPACE);
CfDef user_Def = new CfDef(); user_Def.name = "users"; user_Def.keyspace = "KunderaExamples"; user_Def.setComparator_type("UTF8Type"); user_Def.setDefault_validation_class("UTF8Type"); user_Def.setKey_validation_class("UTF8Type"); ColumnDef columnDef = new ColumnDef(ByteBuffer.wrap("birth_date".getBytes()), "Int32Type"); columnDef.index_type = IndexType.KEYS; user_Def.addToColumn_metadata(columnDef); ColumnDef columnDef1 = new ColumnDef(ByteBuffer.wrap("state".getBytes()), "UTF8Type"); columnDef1.index_type = IndexType.KEYS; user_Def.addToColumn_metadata(columnDef1); ColumnDef columnDef2 = new ColumnDef(ByteBuffer.wrap("full_name".getBytes()), "UTF8Type"); columnDef2.index_type = IndexType.KEYS; user_Def.addToColumn_metadata(columnDef2); cfDefs.add(user_Def); ksDef = new KsDef("KunderaExamples", "org.apache.cassandra.locator.SimpleStrategy", cfDefs); CassandraCli.client.system_add_keyspace(ksDef);
private void createColumnFamily(Cassandra.Client client, String ksName, String cfName, String comparator) throws BackendException { CfDef createColumnFamily = new CfDef(); createColumnFamily.setName(cfName); createColumnFamily.setKeyspace(ksName); createColumnFamily.setComparator_type(comparator); ImmutableMap.Builder<String, String> compressionOptions = new ImmutableMap.Builder<String, String>(); if (compressionEnabled) { compressionOptions.put("sstable_compression", compressionClass) .put("chunk_length_kb", Integer.toString(compressionChunkSizeKB)); } createColumnFamily.setCompression_options(compressionOptions.build()); // Hard-coded caching settings if (cfName.startsWith(Backend.EDGESTORE_NAME)) { createColumnFamily.setCaching("keys_only"); } else if (cfName.startsWith(Backend.INDEXSTORE_NAME)) { createColumnFamily.setCaching("rows_only"); } log.debug("Adding column family {} to keyspace {}...", cfName, ksName); try { client.system_add_column_family(createColumnFamily); } catch (SchemaDisagreementException e) { throw new TemporaryBackendException("Error in setting up column family", e); } catch (Exception e) { throw new PermanentBackendException(e); } log.debug("Added column family {} to keyspace {}.", cfName, ksName); }
Assert.assertTrue(CassandraCli.keyspaceExist("KunderaCoreExmples")); Assert.assertTrue(CassandraCli.columnFamilyExist("CassandraEntitySimple", "KunderaCoreExmples")); org.apache.cassandra.thrift.KsDef ksDef = new KsDef(); ksDef = client.describe_keyspace("KunderaCoreExmples"); Assert.assertEquals(1, ksDef.getCf_defs().size()); for (org.apache.cassandra.thrift.CfDef cfDef : ksDef.getCf_defs()) if ("CassandraEntitySimple".equals(cfDef.getName())) Assert.assertEquals("CassandraEntitySimple", cfDef.getName()); Assert.assertEquals(2, cfDef.getColumn_metadata().size()); List<String> columns = new ArrayList<String>(); columns.add("AGE"); for (ColumnDef columnDef : cfDef.getColumn_metadata()) if (new String(columnDef.getName(), Constants.ENCODING).equals("AGE")) Assert.assertTrue(columnDef.isSetIndex_type()); Assert.assertTrue(columns.contains(new String(columnDef.getName(), Constants.ENCODING))); Assert.assertEquals(IndexType.KEYS, columnDef.index_type);
/** * Sets the up. * * @throws Exception * the exception */ @Before public void setUp() throws Exception { CassandraCli.cassandraSetUp(); CassandraCli.createKeySpace("KunderaExamples"); Cassandra.Client client = CassandraCli.getClient(); client.set_keyspace("KunderaExamples"); CfDef cf_def = new CfDef(); cf_def.keyspace = "KunderaExamples"; cf_def.name = "users"; cf_def.setKey_validation_class("UTF8Type"); ColumnDef columnDef2 = new ColumnDef(ByteBuffer.wrap("full_name".getBytes()), "UTF8Type"); columnDef2.index_type = IndexType.KEYS; cf_def.addToColumn_metadata(columnDef2); ColumnDef columnDef3 = new ColumnDef(ByteBuffer.wrap("birth_date".getBytes()), "Int32Type"); columnDef3.index_type = IndexType.KEYS; cf_def.addToColumn_metadata(columnDef3); ColumnDef columnDef4 = new ColumnDef(ByteBuffer.wrap("state".getBytes()), "UTF8Type"); columnDef4.index_type = IndexType.KEYS; cf_def.addToColumn_metadata(columnDef4); client.system_add_column_family(cf_def); }
@Test public void test() throws NotFoundException, InvalidRequestException, TException, UnsupportedEncodingException { getEntityManagerFactory("create"); Assert.assertTrue(CassandraCli.keyspaceExist("KunderaCoreExmples")); Assert.assertTrue(CassandraCli.columnFamilyExist("Actor", "KunderaCoreExmples")); org.apache.cassandra.thrift.KsDef ksDef = new KsDef(); ksDef = client.describe_keyspace("KunderaCoreExmples"); Assert.assertEquals(2, ksDef.getCf_defs().size()); for (org.apache.cassandra.thrift.CfDef cfDef : ksDef.getCf_defs()) { if ("Actor".equals(cfDef.getName())) { Assert.assertEquals("Standard", cfDef.column_type); } } }
@Override public Map<String, String> getCompressionOptions(String cf) throws BackendException { CTConnection conn = null; Map<String, String> result = null; try { conn = pool.borrowObject(keySpaceName); Cassandra.Client client = conn.getClient(); KsDef ksDef = client.describe_keyspace(keySpaceName); for (CfDef cfDef : ksDef.getCf_defs()) { if (null != cfDef && cfDef.getName().equals(cf)) { result = cfDef.getCompression_options(); break; } } return result; } catch (InvalidRequestException e) { log.debug("Keyspace {} does not exist", keySpaceName); return null; } catch (Exception e) { throw new TemporaryBackendException(e); } finally { pool.returnObjectUnsafe(keySpaceName, conn); } }
/** * Creates keyspace. * * @throws Exception * the exception */ private void createKeyspace() throws Exception { if (cql_version != null && cql_version.equals(CassandraConstants.CQL_VERSION_3_0)) { onCql3CreateKeyspace(); } else { Map<String, String> strategy_options = new HashMap<String, String>(); List<CfDef> cfDefs = new ArrayList<CfDef>(); KsDef ksDef = new KsDef(databaseName, csmd.getPlacement_strategy(databaseName), cfDefs); setProperties(ksDef, strategy_options); ksDef.setStrategy_options(strategy_options); cassandra_client.system_add_keyspace(ksDef); } }
private void createSchema() throws InvalidRequestException, TException, SchemaDisagreementException { Client client = CassandraCli.getClient(); CassandraCli.createKeySpace(keyspace); client.set_keyspace(keyspace); CfDef cfDef = new CfDef(); cfDef.keyspace = keyspace; cfDef.name = "counters"; cfDef.default_validation_class = "CounterColumnType"; cfDef.key_validation_class = "UTF8Type"; ColumnDef columnDef = new ColumnDef(ByteBuffer.wrap("counter".getBytes()), "CounterColumnType"); columnDef.index_type = IndexType.KEYS; cfDef.addToColumn_metadata(columnDef); cfDef.comparator_type = "UTF8Type"; client.system_add_column_family(cfDef); }
public static boolean columnFamilyExist(String columnfamilyName, String keyspaceName) { try { client.set_keyspace(keyspaceName); client.system_add_column_family(new CfDef(keyspaceName, columnfamilyName)); } catch (InvalidRequestException irex) { StringBuilder builder = new StringBuilder("Cannot add already existing column family "); if (irex.getWhy() != null && irex.getWhy().contains(builder.toString())) { return true; } return false; } catch (SchemaDisagreementException e) { return false; } catch (TException e) { return false; } return true; }
client.set_keyspace(keySpaceName); ksDef = client.describe_keyspace(keySpaceName); } catch (NotFoundException e) { log.debug(lp + "Keyspace {} does not exist, not attempting to truncate.", keySpaceName); List<CfDef> cfDefs = ksDef.getCf_defs(); for (CfDef cfDef : ksDef.getCf_defs()) { client.truncate(cfDef.name); log.info(lp + "Truncated CF {} in keyspace {}", cfDef.name, keySpaceName); if (conn != null && conn.getClient() != null) { try { conn.getClient().set_keyspace(SYSTEM_KS); } catch (InvalidRequestException e) { log.warn("Failed to reset keyspace", e);
@Override public CTConnection makeObject(String key) throws Exception { CTConnection conn = makeRawConnection(); Cassandra.Client client = conn.getClient(); client.set_keyspace(key); return conn; }
private void retrySetKeyspace(String ksName, Cassandra.Client client) throws BackendException { final long end = System.currentTimeMillis() + (60L * 1000L); while (System.currentTimeMillis() <= end) { try { client.set_keyspace(ksName); return; } catch (Exception e) { log.warn("Exception when changing to keyspace {} after creating it", ksName, e); try { Thread.sleep(1000L); } catch (InterruptedException ie) { throw new PermanentBackendException("Unexpected interrupt (shutting down?)", ie); } } } throw new PermanentBackendException("Could change to keyspace " + ksName + " after creating it"); }
connection.getClient().get_range_slices(new ColumnParent(columnFamily), new SlicePredicate() .setSlice_range(sliceRange),
/** * {@inheritDoc} */ public Cassandra.Client getCassandra() { if ( !isOpen() ) { throw new IllegalStateException("getCassandra called on client that was not open. You should not have gotten here."); } if ( cassandraClient == null ) { cassandraClient = new Cassandra.Client(new TBinaryProtocol(transport)); } return cassandraClient; }
@Override public void batch_mutate(String kvsMethodName, Map<ByteBuffer, Map<String, List<Mutation>>> mutation_map, ConsistencyLevel consistency_level) throws InvalidRequestException, UnavailableException, TimedOutException, TException { executeHandlingExceptions(() -> client.batch_mutate(mutation_map, consistency_level)); }
@Override public String system_drop_column_family(String column_family) throws InvalidRequestException, SchemaDisagreementException, TException { return executeHandlingExceptions(() -> client.system_drop_column_family(column_family)); }