@Override public Collection<SchemaVersionInfo> getAllVersions(String schemaBranchName, String schemaName, List<Byte> stateIds) throws SchemaNotFoundException, SchemaBranchNotFoundException { if(stateIds == null || stateIds.isEmpty()) return getAllVersions(schemaBranchName, schemaName); else return schemaVersionLifecycleManager.getAllVersions(schemaBranchName, schemaName, stateIds); }
private List<SerDesInfo> getSerDesInfos(String schemaName) { Collection<SchemaSerDesMapping> schemaSerDesMappings = getSchemaSerDesMappings(getSchemaMetadataInfo(schemaName) .getId()); List<SerDesInfo> serDesInfos; if (schemaSerDesMappings == null || schemaSerDesMappings.isEmpty()) { serDesInfos = Collections.emptyList(); } else { serDesInfos = new ArrayList<>(); for (SchemaSerDesMapping schemaSerDesMapping : schemaSerDesMappings) { SerDesInfo serDesInfo = getSerDes(schemaSerDesMapping.getSerDesId()); serDesInfos.add(serDesInfo); } } return serDesInfos; }
public SchemaIdVersion addSchemaVersion(String schemaBranchName, SchemaMetadata schemaMetadata, SchemaVersion schemaVersion) throws IncompatibleSchemaException, InvalidSchemaException, SchemaNotFoundException, SchemaBranchNotFoundException { lockSchemaMetadata(schemaMetadata.getName()); return schemaVersionLifecycleManager.addSchemaVersion(schemaBranchName, schemaMetadata, schemaVersion, x -> registerSchemaMetadata(x)); }
public AggregatedSchemaMetadataInfo getAggregatedSchemaMetadataInfo(String schemaName) throws SchemaNotFoundException, SchemaBranchNotFoundException { SchemaMetadataInfo schemaMetadataInfo = getSchemaMetadataInfo(schemaName); return buildAggregatedSchemaMetadataInfo(schemaMetadataInfo); }
public Collection<AggregatedSchemaMetadataInfo> findAggregatedSchemaMetadata(Map<String, String> props) throws SchemaBranchNotFoundException, SchemaNotFoundException { return findSchemaMetadata(props) .stream() .map(schemaMetadataInfo -> { try { return buildAggregatedSchemaMetadataInfo(schemaMetadataInfo); } catch (SchemaNotFoundException | SchemaBranchNotFoundException e) { throw new RuntimeException(e); } }) .collect(Collectors.toList()); }
Long schemaMetadataId = schemaRegistry.registerSchemaMetadata(schemaMetadata); SchemaMetadata schemaMetadataReturned = schemaRegistry.getSchemaMetadataInfo(schemaMetadataId).getSchemaMetadata(); Assert.assertEquals(schemaMetadata, schemaMetadataReturned); Integer v1 = schemaRegistry.addSchemaVersion(schemaMetadata, new SchemaVersion(schema1, "initial version of the schema")) .getVersion(); Integer v2 = schemaRegistry.addSchemaVersion(schemaName, new SchemaVersion(schema2, "second version of the the schema")) .getVersion(); Assert.assertTrue(v2 == v1 + 1); Collection<SchemaVersionInfo> allSchemaVersions = schemaRegistry.getAllVersions(schemaName); Assert.assertTrue(allSchemaVersions.size() == 2); SchemaMetadataInfo schemaMetadataInfo = schemaRegistry.getSchemaMetadataInfo(schemaName); Assert.assertEquals(schemaMetadata, schemaMetadataInfo.getSchemaMetadata()); Integer schemaVersion = schemaRegistry.getSchemaVersionInfo(schemaName, schema1).getVersion(); Assert.assertEquals(v1, schemaVersion); SchemaVersionInfo schemaVersionInfo1 = schemaRegistry.getSchemaVersionInfo(new SchemaVersionKey(schemaName, v1)); Assert.assertEquals(schemaVersionInfo1.getSchemaText(), schema1); SchemaVersionInfo schemaVersionInfo2 = schemaRegistry.getSchemaVersionInfo(new SchemaVersionKey(schemaName, v2)); Assert.assertEquals(schemaVersionInfo2.getSchemaText(), schema2); Integer version = schemaRegistry.addSchemaVersion(schemaMetadata, new SchemaVersion(schema1, "already added schema"))
@Override public List<Object> getResources() { Collection<Map<String, Object>> schemaProviders = (Collection<Map<String, Object>>) config.get(SCHEMA_PROVIDERS); DefaultSchemaRegistry schemaRegistry = new DefaultSchemaRegistry(storageManager, fileStorage, schemaProviders, haServerNotificationManager); schemaRegistry.init(config); SchemaRegistryVersion schemaRegistryVersion = SchemaRegistryServiceInfo.get().version(); LOG.info("SchemaRegistry is starting with {}", schemaRegistryVersion); SchemaRegistryResource schemaRegistryResource = new SchemaRegistryResource(schemaRegistry, leadershipParticipant, schemaRegistryVersion); ConfluentSchemaRegistryCompatibleResource confluentSchemaRegistryResource = new ConfluentSchemaRegistryCompatibleResource(schemaRegistry, leadershipParticipant); return Arrays.asList(schemaRegistryResource, confluentSchemaRegistryResource); }
@Test public void testSchemaMetadataOps() throws Exception { for (SchemaCompatibility schemaCompatibility : SchemaCompatibility.values()) { SchemaMetadata schemaMetadata = new SchemaMetadata.Builder("compatibility-" + schemaCompatibility) .type(AvroSchemaProvider.TYPE) .description("devices schema") .compatibility(schemaCompatibility) .schemaGroup(SCHEMA_GROUP).build(); Long schemaMetadataId = schemaRegistry.registerSchemaMetadata(schemaMetadata); SchemaMetadata schemaMetadataReturned = schemaRegistry.getSchemaMetadataInfo(schemaMetadataId).getSchemaMetadata(); Assert.assertEquals(schemaMetadata, schemaMetadataReturned); } }
@Override public void mapSchemaWithSerDes(String schemaName, Long serDesId) { SerDesInfo serDesInfo = getSerDes(serDesId); if (serDesInfo == null) { throw new SerDesException("Serializer with given ID " + serDesId + " does not exist"); } SchemaMetadataInfo schemaMetadataInfo = getSchemaMetadataInfo(schemaName); SchemaSerDesMapping schemaSerDesMapping = new SchemaSerDesMapping(schemaMetadataInfo.getId(), serDesId); storageManager.add(schemaSerDesMapping); }
@Override public SchemaMetadataInfo getSchemaMetadataInfo( String schemaName) { return DefaultSchemaRegistry.this.getSchemaMetadataInfo(schemaName); }
schemaBranchCache = new SchemaBranchCache(options.getMaxSchemaCacheSize(), options.getSchemaExpiryInSecs(), createSchemaBranchFetcher()); SchemaMetadataFetcher schemaMetadataFetcher = createSchemaMetadataFetcher(); schemaVersionLifecycleManager = new SchemaVersionLifecycleManager(storageManager, props, haServerNotificationManager); Collection<? extends SchemaProvider> schemaProviders = initSchemaProviders(schemaProvidersConfig, schemaVersionLifecycleManager.getSchemaVersionRetriever());
@Override public Collection<AggregatedSchemaBranch> getAggregatedSchemaBranch(String schemaName) throws SchemaNotFoundException, SchemaBranchNotFoundException { Collection<AggregatedSchemaBranch> aggregatedSchemaBranches = new ArrayList<>(); for (SchemaBranch schemaBranch : getSchemaBranches(schemaName)) { Long rootVersion = schemaBranch.getName().equals(SchemaBranch.MASTER_BRANCH) ? null: schemaVersionLifecycleManager.getRootVersion(schemaBranch).getId(); Collection<SchemaVersionInfo> schemaVersionInfos = getAllVersions(schemaBranch.getName(), schemaName); schemaVersionInfos.stream().forEach(schemaVersionInfo -> { SchemaVersionLifecycleContext context = null;
@Override public Collection<SchemaVersionKey> findSchemasByFields(SchemaFieldQuery schemaFieldQuery) { List<QueryParam> queryParams = buildQueryParam(schemaFieldQuery); Collection<SchemaFieldInfoStorable> fieldInfos = storageManager.find(SchemaFieldInfoStorable.STORABLE_NAME_SPACE, queryParams); Collection<SchemaVersionKey> schemaVersionKeys; if (fieldInfos != null && !fieldInfos.isEmpty()) { List<Long> schemaIds = new ArrayList<>(); for (SchemaFieldInfoStorable fieldInfo : fieldInfos) { schemaIds.add(fieldInfo.getSchemaInstanceId()); } // todo get only few selected columns instead of getting the whole row. // add OR query to find items from store schemaVersionKeys = new ArrayList<>(); for (Long schemaId : schemaIds) { SchemaVersionKey schemaVersionKey = getSchemaKey(schemaId); if (schemaVersionKey != null) { schemaVersionKeys.add(schemaVersionKey); } } } else { schemaVersionKeys = Collections.emptyList(); } return schemaVersionKeys; }
@Test(expected = SchemaNotFoundException.class) public void testAddVersionToNonExistingSchema() throws SchemaNotFoundException, IncompatibleSchemaException, InvalidSchemaException, SchemaBranchNotFoundException { schemaRegistry.addSchemaVersion(INVALID_SCHEMA_METADATA_KEY, new SchemaVersion("foo", "dummy")); }
public MockSchemaRegistryClient() { StorageManager storageManager = new InMemoryStorageManager(); Collection<Map<String, Object>> schemaProvidersConfig = Collections.singleton(Collections.singletonMap("providerClass", AvroSchemaProvider.class.getName())); this.schemaRegistry = new DefaultSchemaRegistry(storageManager, null, schemaProvidersConfig, new HAServerNotificationManager(), new SchemaLockManager(new NOOPTransactionManager())); this.schemaRegistry.init(Collections.<String, Object>emptyMap()); }
public Long addSchemaMetadata(SchemaMetadata schemaMetadata) throws UnsupportedSchemaTypeException { return addSchemaMetadata(schemaMetadata, false); }
@Override public List<Object> getResources() { Collection<Map<String, Object>> schemaProviders = (Collection<Map<String, Object>>) config.get(SCHEMA_PROVIDERS); DefaultSchemaRegistry schemaRegistry = new DefaultSchemaRegistry(storageManager, fileStorage, schemaProviders, haServerNotificationManager, new SchemaLockManager(transactionManager)); schemaRegistry.init(config); SchemaRegistryVersion schemaRegistryVersion = SchemaRegistryServiceInfo.get().version(); LOG.info("SchemaRegistry is starting with {}", schemaRegistryVersion); SchemaRegistryResource schemaRegistryResource = new SchemaRegistryResource(schemaRegistry, leadershipParticipant, schemaRegistryVersion); ConfluentSchemaRegistryCompatibleResource confluentSchemaRegistryResource = new ConfluentSchemaRegistryCompatibleResource(schemaRegistry, leadershipParticipant); return Arrays.asList(schemaRegistryResource, confluentSchemaRegistryResource); }
@Override public SchemaMetadataInfo getSchemaMetadataInfo( Long schemaMetadataId) { return DefaultSchemaRegistry.this.getSchemaMetadataInfo(schemaMetadataId); }
@Test(expected = InvalidSchemaException.class) public void testInvalidSchema() throws Exception { String schema = "--- random invalid schema ---" + new Date(); SchemaMetadata schemaMetadataInfo = createSchemaInfo(TEST_NAME_RULE.getMethodName(), SchemaCompatibility.BACKWARD); // registering a new schema Integer v1 = schemaRegistry.addSchemaVersion(schemaMetadataInfo, new SchemaVersion(schema, "Initial version of the schema")) .getVersion(); }
@Override public Long registerSchemaMetadata(SchemaMetadata schemaMetadata) throws UnsupportedSchemaTypeException { return addSchemaMetadata(schemaMetadata); }