/** * Deserialize from a byte array * @param path path the data came from * @param bytes byte array * @throws IOException all problems * @throws EOFException not enough data * @throws InvalidRecordException if the parsing failed -the record is invalid * @throws NoRecordException if the data is not considered a record: either * it is too short or it did not contain the marker string. */ public T fromBytes(String path, byte[] bytes) throws IOException { return fromBytes(path, bytes, ""); }
/** * clone by converting to JSON and back again. * This is much less efficient than any Java clone process. * @param instance instance to duplicate * @return a new instance * @throws IOException problems. */ public T fromInstance(T instance) throws IOException { return fromJson(toJson(instance)); }
@Override public String toString() { JsonSerDeser<ContainerInformation> serDeser = new JsonSerDeser<>( ContainerInformation.class); return serDeser.toString(this); }
return fromJson(json); } catch (JsonProcessingException e) { throw new InvalidRecordException(path, e.toString(), e);
/** * Convert JSON To bytes * @param instance instance to convert * @return a byte array * @throws IOException */ public byte[] toBytes(T instance) throws IOException { String json = toJson(instance); return json.getBytes(UTF_8); }
/** * Save a cluster description to a hadoop filesystem * @param fs filesystem * @param path path * @param overwrite should any existing file be overwritten * @throws IOException IO exception */ public void save(FileSystem fs, Path path, T instance, boolean overwrite) throws IOException { FSDataOutputStream dataOutputStream = fs.create(path, overwrite); writeJsonAsBytes(instance, dataOutputStream); }
/** * Write the json as bytes -then close the file * @param dataOutputStream an outout stream that will always be closed * @throws IOException on any failure */ private void writeJsonAsBytes(T instance, DataOutputStream dataOutputStream) throws IOException { try { byte[] b = toBytes(instance); dataOutputStream.write(b); } finally { dataOutputStream.close(); } }
return fromJson(json); } catch (JsonProcessingException e) { throw new InvalidRecordException(path, e.toString(), e);
/** * Convert an instance to a string form for output. This is a robust * operation which will convert any JSON-generating exceptions into * error text. * @param instance non-null instance * @return a JSON string */ public String toString(T instance) { Preconditions.checkArgument(instance != null, "Null instance argument"); try { return toJson(instance); } catch (IOException e) { return "Failed to convert to a string: " + e; } } }
/** * Deserialize from a byte array * @param path path the data came from * @param bytes byte array * @throws IOException all problems * @throws EOFException not enough data * @throws InvalidRecordException if the parsing failed -the record is invalid */ public T fromBytes(String path, byte[] bytes) throws IOException, InvalidRecordException { return fromBytes(path, bytes, ""); }
@Override public String toString() { JsonSerDeser<ContainerInformation> serDeser = new JsonSerDeser<>( ContainerInformation.class); return serDeser.toString(this); }
/** * Load from a Hadoop filesystem * @param fs filesystem * @param path path * @return a loaded CD * @throws IOException IO problems * @throws EOFException if not enough bytes were read in * @throws JsonParseException parse problems * @throws JsonMappingException O/J mapping problems */ public T load(FileSystem fs, Path path) throws IOException, JsonParseException, JsonMappingException { FileStatus status = fs.getFileStatus(path); long len = status.getLen(); byte[] b = new byte[(int) len]; FSDataInputStream dataInputStream = fs.open(path); int count = dataInputStream.read(b); if (count != len) { throw new EOFException(path.toString() + ": read finished prematurely"); } return fromBytes(path.toString(), b); }