Exemple #1
0
 @Override
 public Iterable<? extends LocalSourceFile> getChildren(LocalFileFilter filter)
     throws IOException {
   List<LocalSourceFile> files = newArrayList();
   for (OverthereFile each : f.listFiles()) {
     files.add(new OverthereFileLocalSourceFile(each));
   }
   return files;
 }
Exemple #2
0
  @Override
  protected void copyFrom(OverthereFile source) {
    logger.debug("Copying file or directory {} to {}", source, this);

    SCPUploadClient uploadClient =
        connection.getSshClient().newSCPFileTransfer().newSCPUploadClient();

    try {
      if (source.isDirectory() && this.exists()) {
        for (OverthereFile sourceFile : source.listFiles()) {
          uploadClient.copy(new OverthereFileLocalSourceFile(sourceFile), getPath());
        }
      } else {
        uploadClient.copy(new OverthereFileLocalSourceFile(source), getPath());
      }
    } catch (IOException e) {
      throw new RuntimeIOException("Cannot copy " + source + " to " + this, e);
    }
  }
 /**
  * Lists the files in the directory.
  *
  * @param directory in which to list files.
  * @return all the files in the directory as filtering.
  */
 protected List<OverthereFile> listFiles(OverthereFile directory) {
   return directory.listFiles();
 }
  @Test
  public void shouldCreatePopulateListAndRemoveTemporaryDirectory() {
    final String prefix = "prefix";
    final String suffix = "suffix";

    OverthereFile tempDir = connection.getTempFile(prefix, suffix);
    assertThat(
        "Expected a non-null return value from HostConnection.getTempFile()",
        tempDir,
        notNullValue());
    assertThat(
        "Expected name of temporary file to start with the prefix",
        tempDir.getName(),
        startsWith(prefix));
    assertThat(
        "Expected name of temporary file to end with the suffix",
        tempDir.getName(),
        endsWith(suffix));
    assertThat("Expected temporary file to not exist yet", tempDir.exists(), equalTo(false));

    tempDir.mkdir();
    assertThat(
        "Expected temporary directory to exist after creating it", tempDir.exists(), equalTo(true));
    assertThat(
        "Expected temporary directory to be a directory", tempDir.isDirectory(), equalTo(true));

    OverthereFile anotherTempDir = connection.getTempFile(prefix, suffix);
    assertThat(
        "Expected temporary directories created with identical prefix and suffix to still be different",
        tempDir.getPath(),
        not(equalTo(anotherTempDir.getPath())));

    OverthereFile nested1 = tempDir.getFile("nested1");
    OverthereFile nested2 = nested1.getFile("nested2");
    OverthereFile nested3 = nested2.getFile("nested3");
    assertThat("Expected deeply nested directory to not exist", nested3.exists(), equalTo(false));
    try {
      nested3.mkdir();
      fail("Expected not to be able to create a deeply nested directory in one go");
    } catch (RuntimeIOException expected1) {
    }
    assertThat(
        "Expected deeply nested directory to still not exist", nested3.exists(), equalTo(false));
    nested3.mkdirs();
    assertThat(
        "Expected deeply nested directory to exist after invoking mkdirs on it",
        nested3.exists(),
        equalTo(true));

    final byte[] contents =
        ("Contents of the temporary file created at "
                + System.currentTimeMillis()
                + "ms since the epoch")
            .getBytes();
    OverthereFile regularFile = tempDir.getFile("somefile.txt");
    OverthereUtils.write(contents, regularFile);

    List<OverthereFile> dirContents = tempDir.listFiles();
    assertThat("Expected directory to contain two entries", dirContents.size(), equalTo(2));
    assertThat(
        "Expected directory to contain parent of deeply nested directory",
        dirContents.contains(nested1),
        equalTo(true));
    assertThat(
        "Expected directory to contain regular file that was just created",
        dirContents.contains(regularFile),
        equalTo(true));

    try {
      nested1.delete();
    } catch (RuntimeIOException expected2) {
    }
    nested1.deleteRecursively();
    assertThat(
        "Expected parent of deeply nested directory to have been removed recursively",
        nested1.exists(),
        equalTo(false));

    regularFile.delete();
    tempDir.delete();
    assertThat(
        "Expected temporary directory to not exist after removing it when it was empty",
        tempDir.exists(),
        equalTo(false));
  }