How to use

OutputStreamAndPath

in

org.apache.flink.core.fs

@Test
public void testCreateEntropyAwarePlainFs() throws Exception {
  File folder = TMP_FOLDER.newFolder();
  Path path = new Path(Path.fromLocalFile(folder), "_entropy_/file");
  OutputStreamAndPath out = EntropyInjector.createEntropyAware(
      LocalFileSystem.getSharedInstance(), path, WriteMode.NO_OVERWRITE);
  out.stream().close();
  assertEquals(path, out.path());
  assertTrue(new File (new File(folder, "_entropy_"), "file").exists());
}

/**
 * Handles entropy injection across regular and entropy-aware file systems.
 *
 * <p>If the given file system is entropy-aware (a implements {@link EntropyInjectingFileSystem}),
 * then this method replaces the entropy marker in the path with random characters.
 * The entropy marker is defined by {@link EntropyInjectingFileSystem#getEntropyInjectionKey()}.
 *
 * <p>If the given file system does not implement {@code EntropyInjectingFileSystem},
 * then this method delegates to {@link FileSystem#create(Path, WriteMode)} and
 * returns the same path in the resulting {@code OutputStreamAndPath}.
 */
public static OutputStreamAndPath createEntropyAware(
    FileSystem fs,
    Path path,
    WriteMode writeMode) throws IOException {
  // check and possibly inject entropy into the path
  final EntropyInjectingFileSystem efs = getEntropyFs(fs);
  final Path processedPath = efs == null ? path : resolveEntropy(path, efs, true);
  // create the stream on the original file system to let the safety net
  // take its effect
  final FSDataOutputStream out = fs.create(processedPath, writeMode);
  return new OutputStreamAndPath(out, processedPath);
}

@Test
public void testCreateEntropyAwareEntropyFs() throws Exception {
  File folder = TMP_FOLDER.newFolder();
  Path path = new Path(Path.fromLocalFile(folder), "_entropy_/file");
  Path pathWithEntropy = new Path(Path.fromLocalFile(folder), "test-entropy/file");
  FileSystem fs = new TestEntropyInjectingFs("_entropy_", "test-entropy");
  OutputStreamAndPath out = EntropyInjector.createEntropyAware(fs, path, WriteMode.NO_OVERWRITE);
  out.stream().close();
  assertEquals(new Path(Path.fromLocalFile(folder), "test-entropy/file"), out.path());
  assertTrue(new File (new File(folder, "test-entropy"), "file").exists());
}

/**
 * Handles entropy injection across regular and entropy-aware file systems.
 *
 * <p>If the given file system is entropy-aware (a implements {@link EntropyInjectingFileSystem}),
 * then this method replaces the entropy marker in the path with random characters.
 * The entropy marker is defined by {@link EntropyInjectingFileSystem#getEntropyInjectionKey()}.
 *
 * <p>If the given file system does not implement {@code EntropyInjectingFileSystem},
 * then this method delegates to {@link FileSystem#create(Path, WriteMode)} and
 * returns the same path in the resulting {@code OutputStreamAndPath}.
 */
public static OutputStreamAndPath createEntropyAware(
    FileSystem fs,
    Path path,
    WriteMode writeMode) throws IOException {
  // check and possibly inject entropy into the path
  final EntropyInjectingFileSystem efs = getEntropyFs(fs);
  final Path processedPath = efs == null ? path : resolveEntropy(path, efs, true);
  // create the stream on the original file system to let the safety net
  // take its effect
  final FSDataOutputStream out = fs.create(processedPath, writeMode);
  return new OutputStreamAndPath(out, processedPath);
}

@Test
public void testWithSafetyNet() throws Exception {
  final String entropyKey = "__ekey__";
  final String entropyValue = "abc";
  final File folder = TMP_FOLDER.newFolder();
  final Path path = new Path(Path.fromLocalFile(folder), entropyKey + "/path/");
  final Path pathWithEntropy = new Path(Path.fromLocalFile(folder), entropyValue + "/path/");
  TestEntropyInjectingFs efs = new TestEntropyInjectingFs(entropyKey, entropyValue);
  FSDataOutputStream out;
  FileSystemSafetyNet.initializeSafetyNetForThread();
  FileSystem fs = FileSystemSafetyNet.wrapWithSafetyNetWhenActivated(efs);
  try  {
    OutputStreamAndPath streamAndPath = EntropyInjector.createEntropyAware(
        fs, path, WriteMode.NO_OVERWRITE);
    out = streamAndPath.stream();
    assertEquals(pathWithEntropy, streamAndPath.path());
  }
  finally {
    FileSystemSafetyNet.closeSafetyNetAndGuardedResourcesForThread();
  }
  // check that the safety net closed the stream
  try {
    out.write(42);
    out.flush();
    fail("stream should be already close and hence fail with an exception");
  } catch (IOException ignored) {}
}

  private void createStream() throws IOException {
    Exception latestException = null;
    for (int attempt = 0; attempt < 10; attempt++) {
      try {
        OutputStreamAndPath streamAndPath = EntropyInjector.createEntropyAware(
            fs, createStatePath(), WriteMode.NO_OVERWRITE);
        this.outStream = streamAndPath.stream();
        this.statePath = streamAndPath.path();
        return;
      }
      catch (Exception e) {
        latestException = e;
      }
    }
    throw new IOException("Could not open output stream for state backend", latestException);
  }
}

  private void createStream() throws IOException {
    Exception latestException = null;
    for (int attempt = 0; attempt < 10; attempt++) {
      try {
        OutputStreamAndPath streamAndPath = EntropyInjector.createEntropyAware(
            fs, createStatePath(), WriteMode.NO_OVERWRITE);
        this.outStream = streamAndPath.stream();
        this.statePath = streamAndPath.path();
        return;
      }
      catch (Exception e) {
        latestException = e;
      }
    }
    throw new IOException("Could not open output stream for state backend", latestException);
  }
}