public static CombinedConfig loadCombinedConfig(io.vavr.collection.Map<String, ?> config) { // Deserialize the combined config try { return Deserializer.deserialize(CombinedConfig.class, config, ""); } catch (Exception e) { e.printStackTrace(); return null; } }
@POST @Produces(MediaType.APPLICATION_JSON) @Path("/v2/tables") public Response createNewTable(String tableConfiguration) { CombinedConfig config = null; try { config = Deserializer.deserializeFromString(CombinedConfig.class, tableConfiguration); } catch (Exception e) { LOGGER.warn("Caught exception while deserializing the table configuration", e); return Response.serverError().entity(e.getMessage()).type(MediaType.TEXT_PLAIN_TYPE).build(); } if (config == null) { LOGGER.warn("Failed to deserialize the table configuration: {}", tableConfiguration); return Response.serverError().entity("Failed to deserialize the table configuration") .type(MediaType.TEXT_PLAIN_TYPE).build(); } if (config.getSchema() != null) { _resourceManager.addOrUpdateSchema(config.getSchema()); } if (config.getOfflineTableConfig() != null) { _resourceManager.addTable(config.getOfflineTableConfig()); } if (config.getRealtimeTableConfig() != null) { _resourceManager.addTable(config.getRealtimeTableConfig()); } return Response.ok().build(); }
config = subset(suffix, config); configPath = configPath + suffix; List<Field> declaredFields = getClassFields(clazz); coerceValueIntoField(rootObject, declaredField, dslValues.getOrElse(dslInfo.value(), null)); Object value = childKeyHandler.handleChildKeys(subset(keyName + ".", config), configPath + "." + keyName); valueInjected |= coerceValueIntoField(rootObject, declaredField, value); } else if (isSimpleType(declaredField.getType())) { valueInjected |= coerceValueIntoField(rootObject, declaredField, config.getOrElse(keyName, null)); } else { String newPath = configPath + suffix; LOGGER.debug("Recursively deserializing complex type"); valueInjected |= coerceValueIntoField(rootObject, declaredField, deserialize(declaredField.getType(), subset(suffix, config), newPath)); valueInjected |= coerceValueIntoField(rootObject, declaredField, value); } else { valueInjected |= coerceValueIntoField(rootObject, declaredField, deserialize(declaredField.getType(), config, configPath));
@Test public void testConfigRoundtrip() throws Exception { // Load the config and check it CombinedConfig combinedConfig = CombinedConfigLoader .loadCombinedConfig(new File(getClass().getClassLoader().getResource("test-table-config.conf").getFile())); TableConfig config = combinedConfig.getOfflineTableConfig(); validateLoadedConfig(config); // Shallow serialization (to a map of objects): serialize to a map of objects, deserialize and check config final Map<String, ?> serialize = Serializer.serialize(config); TableConfig newConfig = Deserializer.deserialize(TableConfig.class, serialize, ""); Assert.assertEquals(config, newConfig); validateLoadedConfig(newConfig); // Serialization to a string (which could be written to a file): serialize to a string, deserialize and check config String configAsString = Serializer.serializeToString(config); TableConfig newConfigFromString = Deserializer.deserializeFromString(TableConfig.class, configAsString); if (!config.equals(newConfigFromString)) { System.out.println("Serialized config is = " + configAsString); System.out.println("Expected a config that contains: " + config); } Assert.assertEquals(config, newConfigFromString); validateLoadedConfig(newConfigFromString); }
values = values.merge(serializedChildMap); } else if (Deserializer.isSimpleType(field.getType())) { values = storeSimpleFieldIntoMap(field.get(object), field.getType(), keyName, values); } else { SingleKeyDsl dslInstance = dslClass.newInstance(); Class<?> dslValueType = dslClass.getMethod("parse", String.class).getReturnType(); Object dslValueObject = Deserializer.deserialize(dslValueType, dslValueData, ""); if (dslValueObject != null) { String unparsedValue = dslInstance.unparse(dslValueObject);
@Override public java.util.Map<String, T> handleChildKeys(Map<String, ?> childKeys, String pathPrefix) { java.util.Map<String, T> returnedMap = new HashMap<>(); childKeys.groupBy(tuple2 -> tuple2._1.split("\\.", 2)[0]).map((key, values) -> { // Drop the prefix Map<String, ?> valuesWithoutPrefix = values.map((configKey, configValue) -> Tuple.of(configKey.substring(key.length() + 1), configValue)); T value; try { value = Deserializer.deserialize(_type, valuesWithoutPrefix, ""); } catch (Exception e) { value = null; e.printStackTrace(); } return Tuple.of(key, value); }).forEach(returnedMap::put); if (returnedMap.isEmpty()) { return null; } else { return returnedMap; } }
config = Deserializer.deserializeFromString(CombinedConfig.class, tableConfiguration); } catch (Exception e) { LOGGER.warn("Caught exception while deserializing the table configuration", e);
@Override public java.util.List<T> handleChildKeys(Map<String, ?> childKeys, String pathPrefix) { Seq<T> valueList = childKeys.groupBy(tuple2 -> tuple2._1.split("\\.", 2)[0]).flatMap(tuple2 -> { String key = tuple2._1; Map<String, ?> values = tuple2._2; // Drop the prefix Map<String, Object> valuesWithoutPrefix = values.map((configKey, configValue) -> Tuple.of(configKey.substring(key.length() + 1), configValue)); valuesWithoutPrefix = valuesWithoutPrefix.put("name", key); T value; try { value = Deserializer.deserialize(_type, valuesWithoutPrefix, ""); return Option.some(value); } catch (Exception e) { e.printStackTrace(); return Option.none(); } }); return valueList.asJava(); }
public static <T> T deserializeFromString(Class<T> clazz, String string) { Config config = ConfigFactory.parseString(string, ConfigParseOptions.defaults().prependIncluder(new ConfigIncluder() { private ConfigIncluder parent = null; public ConfigObject include(ConfigIncludeContext context, String what) { return ConfigFactory.parseFileAnySyntax(new File(what)).root(); } public ConfigIncluder withFallback(ConfigIncluder fallback) { parent = fallback; return this; } })); config = config.resolve(); try { return deserialize(clazz, io.vavr.collection.HashSet.ofAll(config.entrySet()) .toMap(entry -> Tuple.of(entry.getKey(), entry.getValue().unwrapped())), ""); } catch (Exception e) { Utils.rethrowException(e); return null; } }