@Override public OverrideSchema createOverrideSchema(String schema) { return new OverrideSchema(schema); }
@Override public DataSchema createDataSchema(String schema) { return new DataSchema(schema); }
@Override public ProtocolSchema createProtocolSchema(String schema) { return new ProtocolSchema(schema); }
private void generateSchemas(ConfigurationSchemaDto schema) throws SchemaCreationException { CTLSchemaDto ctlSchema = ctlService.findCtlSchemaById(schema.getCtlSchemaId()); String sch = ctlService.flatExportAsString(ctlSchema); DataSchema dataSchema = new DataSchema(sch); if (!dataSchema.isEmpty()) { SchemaGenerationAlgorithm schemaGenerator = schemaGeneratorFactory.createSchemaGenerator(dataSchema); ProtocolSchema protocol = schemaGenerator.getProtocolSchema(); BaseSchema base = schemaGenerator.getBaseSchema(); OverrideSchema override = schemaGenerator.getOverrideSchema(); if (!protocol.isEmpty() && !base.isEmpty() && !override.isEmpty()) { schema.setBaseSchema(base.getRawSchema()); schema.setProtocolSchema(protocol.getRawSchema()); schema.setOverrideSchema(override.getRawSchema()); } else { LOG.trace("One or more generated schemas are empty. base: {} protocol {} override {}", base, protocol, override); throw new IncorrectParameterException("Can't generate schemas. Check your data schema"); } } else { LOG.warn("Can't generate schemas because data schema is empty."); } }
@Test public void createSchemaTest() throws Exception { DataSchema schema = new DataSchema(readSchemaFileAsString("dao/schema/dataSchema.json")); SchemaGenerationAlgorithmFactory factory = new SchemaGenerationAlgorithmFactoryImpl(); SchemaGenerationAlgorithm generator = factory.createSchemaGenerator(schema); KaaSchema protocolSchema = generator.getProtocolSchema(); KaaSchema baseSchema = generator.getBaseSchema(); KaaSchema overrideSchema = generator.getOverrideSchema(); LOG.debug("Created Override schema JSON {} ", overrideSchema.getRawSchema()); LOG.debug("Created Base schema JSON {} ", baseSchema.getRawSchema()); LOG.debug("Created Protocol schema JSON {} ", protocolSchema.getRawSchema()); }
private Pair<BaseData, RawData> mergeConfiguration(String endpointId, String config, ConfigurationSchemaDto configSchema, Pair<BaseData, RawData> mergedConfiguration) throws GetDeltaException { OverrideAlgorithm configurationMerger = configurationOverrideFactory.createConfigurationOverrideAlgorithm(); OverrideSchema overrideSchema = new OverrideSchema(configSchema.getOverrideSchema()); try { LOG.trace("Merging group configuration with configuration: {}", config); BaseData baseData = configurationMerger.override(mergedConfiguration.getV1(), Collections.singletonList(new OverrideData(overrideSchema, config))); JsonNode json = new ObjectMapper().readTree(baseData.getRawData()); AvroUtils.removeUuids(json); RawData rawData = new RawData(new RawSchema(mergedConfiguration.getV2().getSchema().getRawSchema()), json.toString()); return new Pair<>(baseData, rawData); } catch (OverrideException | IOException oe) { LOG.error("[{}] Unexpected exception occurred while merging configuration: ", endpointId, oe); throw new GetDeltaException(oe); } finally { LOG.trace("[{}] getMergedConfiguration.compute end", endpointId); } }
@Override public BaseSchema createBaseSchema(String schema) { return new BaseSchema(schema); }
@Override public DeltaCalculationAlgorithm createDeltaCalculator( ProtocolSchema protocolSchemaBody, BaseSchema baseDataSchema) { Schema protocolSchema = new Schema.Parser().parse(protocolSchemaBody.getRawSchema()); Schema baseSchema = new Schema.Parser().parse(baseDataSchema.getRawSchema()); return new DefaultDeltaCalculationAlgorithm(protocolSchema, baseSchema); }
/** * Instantiates a new default configuration processor. * * @param kaaSchema the base schema * @throws ConfigurationGenerationException the configuration processing exception */ public DefaultRecordGenerationAlgorithmImpl(U kaaSchema, KaaDataFactory<U, T> factory) throws ConfigurationGenerationException { LOG.debug("Generating default configuration for configuration schema: " + kaaSchema.getRawSchema()); this.rootSchema = kaaSchema; this.dataFactory = factory; this.avroSchemaParser = new Schema.Parser(); this.avroBaseSchema = this.avroSchemaParser.parse(kaaSchema.getRawSchema()); }
void setSchema(AbstractSchemaDto schemaDto, byte[] data) throws KaaAdminServiceException { String schema = new String(data); validateRecordSchema(schema, false); schemaDto.setSchema(new KaaSchemaFactoryImpl().createDataSchema(schema).getRawSchema()); }
private String generateDefaultRecord() throws ConfigurationGenerationException, IOException { org.apache.avro.Schema schemaBody = new org.apache.avro.Schema.Parser().parse(body); String fqn = schemaBody.getFullName(); RawSchema rawSchema = new RawSchema(schemaBody.toString()); DefaultRecordGenerationAlgorithm<RawData> algorithm = new DefaultRecordGenerationAlgorithmImpl<>(rawSchema, new RawDataFactory()); return algorithm.getRootData().getRawData(); } }
@Override public T createSchema(DataSchema configSchema) throws SchemaCreationException { addressableRecords.clear(); processedRecords.clear(); Schema avroSchema = new Schema.Parser().parse(configSchema.getRawSchema()); rootSchemaName = avroSchema.getFullName(); Schema resultSchema = convert(avroSchema); return strategy.createSchema(strategy.onSchemaProcessed(resultSchema, addressableRecords)); } }
@Override public ProtocolSchema createSchema(Schema schema) { return getSchemaFactory().createProtocolSchema(schema.toString()); } }
@Override public OverrideSchema createSchema(Schema schema) { return getSchemaFactory().createOverrideSchema(schema.toString()); }
@Override public BaseSchema createSchema(Schema schema) { return getSchemaFactory().createBaseSchema(schema.toString()); }
@Test(expected = OverrideException.class) public void testResolveFailsWhenSchemaForParentIsNotFound() throws Exception { Path schemaUrl = Paths.get(Thread.currentThread().getContextClassLoader().getResource("override/schema.json").toURI()); DataSchema configurationSchema = new DataSchema(new String(Files.readAllBytes(schemaUrl))); SchemaGenerationAlgorithmFactory factory = new SchemaGenerationAlgorithmFactoryImpl(); SchemaGenerationAlgorithm generator = factory.createSchemaGenerator(configurationSchema); KaaSchema baseSchemaString = generator.getBaseSchema(); Schema.Parser baseParser = new Schema.Parser(); baseParser.parse(baseSchemaString.getRawSchema()); ArrayOverrideStrategyResolver arrayMergeStrategyResolver = new ArrayOverrideStrategyResolver(baseParser.getTypes()); arrayMergeStrategyResolver.resolve("wrong_parent_name", "org.kaa.config", "child_name"); }
@Override public T validateUuidFields(GenericRecord configurationToValidate, GenericRecord previousConfiguration) throws IOException { processedUuids.clear(); String config = null; GenericAvroConverter<GenericRecord> converter = new GenericAvroConverter<>( schema.getRawSchema()); validateRecord(configurationToValidate, previousConfiguration, previousConfiguration); if (configurationToValidate != null) { config = converter.encodeToJson(configurationToValidate); } LOG.trace("Generated uuid fields for records {}", configurationToValidate); return dataFactory.createData(schema, config); }
@Test public void testStrategyIsResolvedToOverrideWhenFieldsDefinitionIsEmpty() throws Exception { Path schemaUrl = Paths.get(Thread.currentThread().getContextClassLoader().getResource("override/schema_for_array_merge_strategy_resolver_with_empty_fields_definition.json").toURI()); DataSchema configurationSchema = new DataSchema(new String(Files.readAllBytes(schemaUrl))); SchemaGenerationAlgorithmFactory factory = new SchemaGenerationAlgorithmFactoryImpl(); SchemaGenerationAlgorithm generator = factory.createSchemaGenerator(configurationSchema); KaaSchema baseSchemaString = generator.getBaseSchema(); Schema.Parser baseParser = new Schema.Parser(); baseParser.parse(baseSchemaString.getRawSchema()); ArrayOverrideStrategyResolver arrayMergeStrategyResolver = new ArrayOverrideStrategyResolver(baseParser.getTypes()); ArrayOverrideStrategy actualArrayMergeStrategy = arrayMergeStrategyResolver.resolve("testT", "org.kaa.config", "child_name"); Assert.assertTrue(ArrayOverrideStrategy.REPLACE == actualArrayMergeStrategy); }
@Override public T validateUuidFields(T configurationToValidate, T previousConfiguration) throws IOException { processedUuids.clear(); String config = null; GenericAvroConverter<GenericRecord> converter = new GenericAvroConverter<>( schema.getRawSchema()); GenericRecord currentRecord = converter.decodeJson(configurationToValidate.getRawData()); GenericRecord previousRecord = null; if (previousConfiguration != null) { previousRecord = converter.decodeJson(previousConfiguration.getRawData()); } validateRecord(currentRecord, previousRecord, previousRecord); if (currentRecord != null) { config = converter.encodeToJson(currentRecord); } LOG.trace("Generated uuid fields for records {}", currentRecord); return dataFactory.createData(schema, config); }
@Test public void testResolveSuccessForUnionWithArrayType() throws Exception { Path schemaUrl = Paths.get(Thread.currentThread().getContextClassLoader().getResource("override/schema_for_array_merge_strategy_resolver_with_array_in_union_type.json").toURI()); DataSchema configurationSchema = new DataSchema(new String(Files.readAllBytes(schemaUrl))); SchemaGenerationAlgorithmFactory factory = new SchemaGenerationAlgorithmFactoryImpl(); SchemaGenerationAlgorithm generator = factory.createSchemaGenerator(configurationSchema); KaaSchema baseSchemaString = generator.getBaseSchema(); Schema.Parser baseParser = new Schema.Parser(); baseParser.parse(baseSchemaString.getRawSchema()); ArrayOverrideStrategyResolver arrayMergeStrategyResolver = new ArrayOverrideStrategyResolver(baseParser.getTypes()); ArrayOverrideStrategy actualArrayMergeStrategy = arrayMergeStrategyResolver.resolve("testT", "org.kaa.config", "field1"); Assert.assertTrue(ArrayOverrideStrategy.APPEND == actualArrayMergeStrategy); } }