@Override public void clearStorage() throws BackendException { openStores.clear(); try { KSMetaData ksMetaData = Schema.instance.getKSMetaData(keySpaceName); // Not a big deal if Keyspace doesn't not exist (dropped manually by user or tests). // This is called on per test setup basis to make sure that previous test cleaned // everything up, so first invocation would always fail as Keyspace doesn't yet exist. if (ksMetaData == null) return; for (String cfName : ksMetaData.cfMetaData().keySet()) StorageService.instance.truncate(keySpaceName, cfName); } catch (Exception e) { throw new PermanentBackendException(e); } }
private void ensureKeyspaceExists(String keyspaceName) throws BackendException { if (null != Schema.instance.getKeyspaceInstance(keyspaceName)) return; // Keyspace not found; create it String strategyName = storageConfig.get(REPLICATION_STRATEGY); KSMetaData ksm; try { ksm = KSMetaData.newKeyspace(keyspaceName, strategyName, strategyOptions, true); } catch (ConfigurationException e) { throw new PermanentBackendException("Failed to instantiate keyspace metadata for " + keyspaceName, e); } try { MigrationManager.announceNewKeyspace(ksm); log.info("Created keyspace {}", keyspaceName); } catch (ConfigurationException e) { throw new PermanentBackendException("Failed to create keyspace " + keyspaceName, e); } }
private static KSMetaData makeNewKeyspaceDefinition(KSMetaData ksm, CFMetaData toExclude) { // clone ksm but do not include the new def List<CFMetaData> newCfs = new ArrayList<>(ksm.cfMetaData().values()); newCfs.remove(toExclude); assert newCfs.size() == ksm.cfMetaData().size() - 1; return KSMetaData.cloneWith(ksm, newCfs); }
private static void updateKeyspace(String ksName) { KSMetaData oldKsm = Schema.instance.getKSMetaData(ksName); assert oldKsm != null; KSMetaData newKsm = KSMetaData.cloneWith(oldKsm.reloadAttributes(), oldKsm.cfMetaData().values()); Schema.instance.setKeyspaceDefinition(newKsm); if (!StorageService.instance.isClientMode()) { Keyspace.open(ksName).setMetadata(newKsm); MigrationManager.instance.notifyUpdateKeyspace(newKsm); } }
created.addAll(KSMetaData.deserializeColumnFamilies(new Row(entry.getKey(), entry.getValue())).values()); Maps.difference(Schema.instance.getKSMetaData(keyspaceName).cfMetaData(), KSMetaData.deserializeColumnFamilies(new Row(entry.getKey(), post))); dropped.addAll(Schema.instance.getKSMetaData(keyspaceName).cfMetaData().values()); created.addAll(KSMetaData.deserializeColumnFamilies(new Row(entry.getKey(), post)).values());
schema.add(KSMetaData.testMetadata( ks1, simple,
public static KSMetaData cloneWith(KSMetaData ksm, Iterable<CFMetaData> cfDefs) { return new KSMetaData(ksm.name, ksm.strategyClass, ksm.strategyOptions, ksm.durableWrites, cfDefs, ksm.userTypes); }
/** * Deserialize Keyspace with nested ColumnFamilies * * @param serializedKs Keyspace in serialized form * @param serializedCFs Collection of the serialized ColumnFamilies * * @return deserialized keyspace with cf_defs */ public static KSMetaData fromSchema(Row serializedKs, Row serializedCFs, Row serializedUserTypes) { Map<String, CFMetaData> cfs = deserializeColumnFamilies(serializedCFs); UTMetaData userTypes = new UTMetaData(UTMetaData.fromSchema(serializedUserTypes)); return fromSchema(serializedKs, cfs.values(), userTypes); }
public KSMetaData reloadAttributes() { Row ksDefRow = SystemKeyspace.readSchemaRow(SystemKeyspace.SCHEMA_KEYSPACES_CF, name); if (ksDefRow.cf == null) throw new RuntimeException(String.format("%s not found in the schema definitions keyspaceName (%s).", name, SystemKeyspace.SCHEMA_KEYSPACES_CF)); return fromSchema(ksDefRow, Collections.<CFMetaData>emptyList(), userTypes); }
/** update an existing keyspace, but do not allow column family modifications. * @throws SchemaDisagreementException */ public String system_update_keyspace(KsDef ks_def) throws InvalidRequestException, SchemaDisagreementException, TException { logger.debug("update_keyspace"); try { ThriftValidation.validateKeyspaceNotSystem(ks_def.name); state().hasKeyspaceAccess(ks_def.name, Permission.ALTER); ThriftValidation.validateKeyspace(ks_def.name); if (ks_def.getCf_defs() != null && ks_def.getCf_defs().size() > 0) throw new InvalidRequestException("Keyspace update must not contain any column family definitions."); MigrationManager.announceKeyspaceUpdate(KSMetaData.fromThrift(ks_def)); return Schema.instance.getVersion().toString(); } catch (RequestValidationException e) { throw ThriftConversion.toThrift(e); } }
public static void announceKeyspaceDrop(String ksName, boolean announceLocally) throws ConfigurationException { KSMetaData oldKsm = Schema.instance.getKSMetaData(ksName); if (oldKsm == null) throw new ConfigurationException(String.format("Cannot drop non existing keyspace '%s'.", ksName)); logger.info(String.format("Drop Keyspace '%s'", oldKsm.name)); announce(oldKsm.dropFromSchema(FBUtilities.timestampMicros()), announceLocally); }
/** * Adds the specified column family to the specified keyspace. * * @param ksm the keyspace meta data * @param cfm the column family meta data */ private static void addTableToKeyspace(KSMetaData ksm, CFMetaData cfm) { ksm = KSMetaData.cloneWith(ksm, Iterables.concat(ksm.cfMetaData().values(), Collections.singleton(cfm))); Schema.instance.load(cfm); Schema.instance.setKeyspaceDefinition(ksm); }
schema.add(KSMetaData.testMetadata( ks1, simple,
public static KSMetaData testMetadata(String name, Class<? extends AbstractReplicationStrategy> strategyClass, Map<String, String> strategyOptions, CFMetaData... cfDefs) { return new KSMetaData(name, strategyClass, strategyOptions, true, Arrays.asList(cfDefs)); }
/** * Load keyspace definitions for the system keyspace (system.SCHEMA_KEYSPACES_CF) * * @return Collection of found keyspace definitions */ public static Collection<KSMetaData> loadFromKeyspace() { List<Row> serializedSchema = SystemKeyspace.serializedSchema(SystemKeyspace.SCHEMA_KEYSPACES_CF); List<KSMetaData> keyspaces = new ArrayList<>(serializedSchema.size()); for (Row row : serializedSchema) { if (Schema.invalidSchemaRow(row) || Schema.ignoredSchemaRow(row)) continue; keyspaces.add(KSMetaData.fromSchema(row, serializedColumnFamilies(row.key), serializedUserTypes(row.key))); } return keyspaces; }
MigrationManager.announceNewKeyspace(KSMetaData.fromThrift(ks_def, cfDefs.toArray(new CFMetaData[cfDefs.size()]))); return Schema.instance.getVersion().toString();
/** * Get metadata about keyspace inner ColumnFamilies * * @param keyspaceName The name of the keyspace * * @return metadata about ColumnFamilies the belong to the given keyspace */ public Map<String, CFMetaData> getKeyspaceMetaData(String keyspaceName) { assert keyspaceName != null; KSMetaData ksm = keyspaces.get(keyspaceName); assert ksm != null; return ksm.cfMetaData(); }
public static KSMetaData newKeyspace(String name, String strategyName, Map<String, String> options, boolean durableWrites) throws ConfigurationException { Class<? extends AbstractReplicationStrategy> cls = AbstractReplicationStrategy.getClass(strategyName); if (cls.equals(LocalStrategy.class)) throw new ConfigurationException("Unable to use given strategy class: LocalStrategy is reserved for internal use."); return newKeyspace(name, cls, options, durableWrites, Collections.<CFMetaData>emptyList()); }
private static void addColumnFamily(CFMetaData cfm) { assert Schema.instance.getCFMetaData(cfm.ksName, cfm.cfName) == null; KSMetaData ksm = Schema.instance.getKSMetaData(cfm.ksName); ksm = KSMetaData.cloneWith(ksm, Iterables.concat(ksm.cfMetaData().values(), Collections.singleton(cfm))); logger.info("Loading {}", cfm); Schema.instance.load(cfm); // make sure it's init-ed w/ the old definitions first, // since we're going to call initCf on the new one manually Keyspace.open(cfm.ksName); Schema.instance.setKeyspaceDefinition(ksm); if (!StorageService.instance.isClientMode()) { Keyspace.open(ksm.name).initCf(cfm.cfId, cfm.cfName, true); MigrationManager.instance.notifyCreateColumnFamily(cfm); } }
schema.add(KSMetaData.testMetadata( ks1, simple,