Refine search
/** * Instantiate an object of this class from its JSON representation */ public static FsWriterMetrics fromJson(String in) throws IOException { return new ObjectMapper().readValue(in, FsWriterMetrics.class); } }
/** * Call executor and parse the JSON response as an instance of the class given as an argument. */ <T> T callForJsonType(final String host, final int port, final String path, final List<Pair<String, String>> paramList, final Class<T> valueType) throws IOException { final String responseString = callForJsonString(host, port, path, paramList); if (null == responseString || responseString.length() == 0) { return null; } return new ObjectMapper().readValue(responseString, valueType); }
/** * Convert a json string to a Map. */ public static Map jsonToMap(String json) throws IOException { if (!TempletonUtils.isset(json)) return new HashMap<String, Object>(); else { ObjectMapper mapper = new ObjectMapper(); return mapper.readValue(json, Map.class); } }
private Map<String, Object> map(final Response response) throws IOException { try (InputStream is = response.getEntity().getContent()) { final ObjectMapper mapper = new ObjectMapper(); @SuppressWarnings("unchecked") final Map<String, Object> map = mapper.readValue(is, Map.class); return map; } }
Map<String, String> metaData = new ObjectMapper().readValue(strm, Map.class); if(!CURRENT_VERSION.equalsIgnoreCase(metaData.get(Field.VERSION))) { throw new IllegalStateException("Unexpected Meta Data version: "
@Override public RecordSchema getSchema(Map<String, String> variables, InputStream contentStream, RecordSchema readSchema) throws SchemaNotFoundException, IOException { byte[] bytes = IOUtils.readFully(contentStream, -1, true); ObjectMapper mapper = new ObjectMapper(); return convertSchema(mapper.readValue(bytes, Map.class)); }
private boolean npmIsAlreadyInstalled() { try { final File npmPackageJson = new File( this.config.getInstallDirectory() + Utils.normalize("/node/node_modules/npm/package.json")); if (npmPackageJson.exists()) { HashMap<String, Object> data = new ObjectMapper().readValue(npmPackageJson, HashMap.class); if (data.containsKey(VERSION)) { final String foundNpmVersion = data.get(VERSION).toString(); if (foundNpmVersion.equals(this.npmVersion)) { this.logger.info("NPM {} is already installed.", foundNpmVersion); return true; } else { this.logger.info("NPM {} was installed, but we need version {}", foundNpmVersion, this.npmVersion); return false; } } else { this.logger.info("Could not read NPM version from package.json"); return false; } } else { return false; } } catch (IOException ex) { throw new RuntimeException("Could not read package.json", ex); } }
@Override protected void doPost(final HttpServletRequest request, final HttpServletResponse response) throws ServletException, IOException { if (!HttpServer.isInstrumentationAccessAllowed(getServletContext(), request, response)) { response.setStatus(HttpServletResponse.SC_UNAUTHORIZED); return; } setResponseHeader(response); String dataJson = request.getReader().lines().collect(Collectors.joining()); ObjectMapper objectMapper = new ObjectMapper(); try { ConfLoggers confLoggers = objectMapper.readValue(dataJson, ConfLoggers.class); configureLogger(confLoggers); } catch (IOException e) { response.setStatus(HttpServletResponse.SC_BAD_REQUEST); LOG.error("Error configuring log4j2 via /conflog endpoint.", e); return; } response.setStatus(HttpServletResponse.SC_OK); }
if (httpResponse.getStatusLine().getStatusCode() == HttpStatus.SC_OK && entity != null) { String content = EntityUtils.toString(entity); ObjectMapper mapper = new ObjectMapper(); LogSchemaDto logSchemaDto = mapper.readValue(content, LogSchemaDto.class); HttpGet getCtlRequest = new HttpGet(KAA_ADMIN_REST_API_CTL_SCHEMA + logSchemaDto.getCtlSchemaId()); && ctlEntity != null) { String ctlContent = EntityUtils.toString(entity); ObjectMapper ctlMapper = new ObjectMapper(); logSchema = ctlMapper.readValue(ctlContent, String.class);
@SuppressWarnings("unchecked") public static Map<String, Object> mapFromJson(String location) throws Exception { ObjectMapper mapper = new ObjectMapper(); InputStream jsonStream = JsonUtils.class.getResourceAsStream(location); assertNotNull("no resource found at " + location, jsonStream); return mapper.readValue(jsonStream, Map.class); } }
private MappingSet getMappingsForResource(String resource) throws IOException { Map value = new ObjectMapper().readValue(getClass().getResourceAsStream(mappingDirectory + "/" + resource), Map.class); return FieldParser.parseMappings(value, !typeless); }
@Test public void testRecord() throws DataConversionException, IOException { Iterable<String> records = converter.convertRecord(null, sampleRecord, state); Iterator<String> recordIt = records.iterator(); ObjectMapper objectMapper = new ObjectMapper(); String record = recordIt.next(); Assert.assertFalse(recordIt.hasNext()); JsonNode parsedRecord = objectMapper.readValue(record, JsonNode.class); Assert.assertEquals(parsedRecord.get("field1").getTextValue(), sampleRecord.get("field1").toString()); } }
private Schema parseDependencies(CTLSchemaDto schema, final Schema.Parser parser) throws Exception { if (schema.getDependencySet() != null) { for (CTLSchemaDto dependency : schema.getDependencySet()) { this.parseDependencies(dependency, parser); } } ObjectNode object = new ObjectMapper().readValue(schema.getBody(), ObjectNode.class); object.remove(DEPENDENCIES); String body = new ObjectMapper().writerWithDefaultPrettyPrinter().writeValueAsString(object); return parser.parse(body); }
private Mapping mapping(String resource) throws Exception { InputStream stream = getClass().getResourceAsStream(resource); return FieldParser.parseTypelessMappings(new ObjectMapper().readValue(stream, Map.class)).getResolvedView(); } }
if (objectProperties != null) { try { objectNode.put("properties", new ObjectMapper().readValue(objectProperties, JsonNode.class)); } catch (IOException e) { throw new IllegalStateException(e); objectNode.put("items", new ObjectMapper().readValue(itemDefinition, JsonNode.class)); } catch (IOException e) { throw new IllegalStateException(e);
if (objectProperties != null) { try { objectNode.put("properties", new ObjectMapper().readValue(objectProperties, JsonNode.class)); } catch (IOException e) { throw new IllegalStateException(e); objectNode.put("items", new ObjectMapper().readValue(itemDefinition, JsonNode.class)); } catch (IOException e) { throw new IllegalStateException(e);
ObjectMapper mapper = new ObjectMapper(); try { VectorClockWrapper vcWrapper = mapper.readValue(vectorClockHeader, VectorClockWrapper.class); this.parsedVectorClock = new VectorClock(vcWrapper.getVersions(),
private Mapping getTestMapping() throws IOException { ObjectMapper mapper = new ObjectMapper(); JsonParser jsonParser = mapper.getJsonFactory() .createJsonParser(getClass().getResourceAsStream("/org/elasticsearch/hadoop/serialization/dto/mapping/typeless/basic.json")); Map<String, Object> map = (Map<String, Object>) mapper.readValue(jsonParser, Map.class); return FieldParser.parseTypelessMappings(map).getResolvedView(); }
private List<FileData> recursiveShallowExport(List<FileData> files, CTLSchemaDto parent) throws Exception { files.add(this.shallowExport(parent)); ObjectNode object = new ObjectMapper().readValue(parent.getBody(), ObjectNode.class); ArrayNode dependencies = (ArrayNode) object.get(DEPENDENCIES); if (dependencies != null) { for (JsonNode node : dependencies) { ObjectNode dependency = (ObjectNode) node; String fqn = dependency.get(FQN).getTextValue(); Integer version = dependency.get(VERSION).getIntValue(); CTLSchemaDto child = this.findAnyCtlSchemaByFqnAndVerAndTenantIdAndApplicationId( fqn, version, parent.getMetaInfo().getTenantId(), parent.getMetaInfo().getApplicationId()); Validate.notNull(child, MessageFormat.format("The dependency [{0}] was not found!", fqn)); this.recursiveShallowExport(files, child); } } return files; } }
@Test public void testSuccessWithBinary() throws DataConversionException, IOException { ObjectMapper objectMapper = new ObjectMapper(); byte[] record = "aaaa".getBytes(StandardCharsets.UTF_8); Metadata md = new Metadata(); md.getGlobalMetadata().setContentType("application/binary"); RecordWithMetadataToEnvelopedRecordWithMetadata converter = new RecordWithMetadataToEnvelopedRecordWithMetadata(); Iterator<RecordWithMetadata<byte[]>> recordWithMetadataIterator = converter.convertRecord("", new RecordWithMetadata<>(record, md), null).iterator(); RecordWithMetadata recordWithMetadata = recordWithMetadataIterator.next(); JsonNode parsedElement = objectMapper.readValue((byte[]) recordWithMetadata.getRecord(), JsonNode.class); Assert.assertEquals(parsedElement.get("r").getTextValue(), "YWFhYQ=="); } }