@BeforeClass(groups = "AllEnv")
  public void makeTestDirectories() throws IOException {
    if (Files.exists(Cテスト用ルートディレクトリ)) DirectoryDeleter.delete(Cテスト用ルートディレクトリ);

    Files.createDirectories(C読み込みテスト用ディレクトリ);
    Files.createDirectories(C書き込みテスト用ディレクトリ);
    Files.createDirectories(C読み込める設定ファイルかと思ったらディレクトリだった);
    Files.createDirectories(C書き込める設定ファイルかと思ったらディレクトリだった);

    Files.createFile(C存在するけど形式がおかしい設定ファイル);
    Files.write(
        C存在して読み込み可能な設定ファイル,
        Arrays.asList(
            "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"no\"?>",
            "<!DOCTYPE properties SYSTEM \"http://java.sun.com/dtd/properties.dtd\">",
            "<properties>",
            "<comment>Properties File for Boardgame Server</comment>",
            "<entry key=\"WINDOW_H\">252</entry>",
            "<entry key=\"WINDOW_Y\">2</entry>",
            "<entry key=\"WINDOW_X\">1</entry>",
            "<entry key=\"WINDOW_W\">251</entry>",
            "</properties>"),
        Charset.forName("UTF-8"));
    Files.createFile(C設定ファイルが書き込み不能だった);
    C設定ファイルが書き込み不能だった.toFile().setWritable(false);
  }
  /**
   * Test method for {@link SubtitleProvider#loadSubtitles(Path)}. Check that multiple subtitles are
   * loaded.
   *
   * @throws IOException if there was an I/O error.
   */
  @Test
  public void testLoadSubtitles() throws IOException {
    final SubtitleFormat subtitleFormat = mock(SubtitleFormat.class);
    final SubtitleReader subtitleReader = mock(SubtitleReader.class);
    final SubtitleFile subtitleFile = mock(SubtitleFile.class);
    final SubtitleFile secondSubtitle = mock(SubtitleFile.class);
    final Path folder = subtitleFolder.newFolder().toPath();
    final Path file = folder.resolve("single.srt");
    final Path second = folder.resolve("other.srt");
    Files.createFile(file);
    Files.createFile(second);
    Files.createFile(folder.resolve("test.sub"));

    when(subtitleFormatManager.getFormatByPath(file))
        .thenReturn(new HashSet<>(Arrays.asList(subtitleFormat)));
    when(subtitleFormatManager.getFormatByPath(second))
        .thenReturn(new HashSet<>(Arrays.asList(subtitleFormat)));
    when(subtitleFormat.getReader()).thenReturn(subtitleReader);
    when(subtitleReader.readFile(file)).thenReturn(subtitleFile);
    when(subtitleReader.readFile(second)).thenReturn(secondSubtitle);
    final Map<SubtitleFile, SubtitleFormat> subtitles = subtitleProvider.loadSubtitles(folder);
    assertEquals(2, subtitles.size());
    //		final Entry<SubtitleFile, SubtitleFormat> loaded = subtitles.entrySet().iterator().next();
    //		assertEquals(subtitleFile, loaded.getKey());
    //		assertEquals(subtitleFormat, loaded.getValue());
  }
Пример #3
0
  @BeforeClass
  void setupTestFolder() throws IOException {
    testFolder = TestUtil.createTemporaryDirectory();
    supportsLinks = TestUtil.supportsLinks(testFolder);
    TreeSet<Path> set = new TreeSet<>();

    // Level 1
    Path empty = testFolder.resolve("empty");
    Path file = testFolder.resolve("file");
    Path dir = testFolder.resolve("dir");
    Path dir2 = testFolder.resolve("dir2");
    Files.createDirectory(empty);
    Files.createFile(file);
    Files.createDirectory(dir);
    Files.createDirectory(dir2);
    set.add(empty);
    set.add(file);
    set.add(dir);
    set.add(dir2);
    if (supportsLinks) {
      Path tmp = testFolder.resolve("linkDir");
      Files.createSymbolicLink(tmp, dir);
      set.add(tmp);
      tmp = testFolder.resolve("linkFile");
      Files.createSymbolicLink(tmp, file);
      set.add(tmp);
    }
    level1 = set.toArray(new Path[0]);

    // Level 2
    Path tmp = dir.resolve("d1");
    Files.createDirectory(tmp);
    set.add(tmp);
    tmp = dir.resolve("f1");
    Files.createFile(tmp);
    set.add(tmp);
    if (supportsLinks) {
      tmp = dir.resolve("lnDir2");
      Files.createSymbolicLink(tmp, dir2);
      set.add(tmp);
    }
    // walk include starting folder
    set.add(testFolder);
    all = set.toArray(new Path[0]);

    // Follow links
    if (supportsLinks) {
      tmp = testFolder.resolve("linkDir");
      set.add(tmp.resolve("d1"));
      set.add(tmp.resolve("f1"));
      tmp = tmp.resolve("lnDir2");
      set.add(tmp);
    }
    all_folowLinks = set.toArray(new Path[0]);
  }
Пример #4
0
  public void testUncheckedIOException() throws IOException {
    Path triggerFile = testFolder.resolve(Paths.get("dir2", "IOException"));
    Files.createFile(triggerFile);
    Path triggerDir = testFolder.resolve(Paths.get("empty", "IOException"));
    Files.createDirectories(triggerDir);
    Files.createFile(triggerDir.resolve("file"));
    FaultyFileSystem.FaultyFSProvider fsp = FaultyFileSystem.FaultyFSProvider.getInstance();
    FaultyFileSystem fs = (FaultyFileSystem) fsp.newFileSystem(testFolder, null);

    try {
      fsp.setFaultyMode(false);
      Path fakeRoot = fs.getRoot();
      try (Stream<Path> s = Files.list(fakeRoot.resolve("dir2"))) {
        // only one file
        s.forEach(path -> assertEquals(path.getFileName().toString(), "IOException"));
      }

      try (Stream<Path> s = Files.walk(fakeRoot.resolve("empty"))) {
        String[] result = s.map(path -> path.getFileName().toString()).toArray(String[]::new);
        // ordered as depth-first
        assertEquals(result, new String[] {"empty", "IOException", "file"});
      }

      fsp.setFaultyMode(true);
      try (Stream<Path> s = Files.list(fakeRoot.resolve("dir2"))) {
        s.forEach(path -> fail("should have caused exception"));
      } catch (UncheckedIOException uioe) {
        assertTrue(uioe.getCause() instanceof FaultyFileSystem.FaultyException);
      }

      try (Stream<Path> s = Files.walk(fakeRoot.resolve("empty"))) {
        String[] result = s.map(path -> path.getFileName().toString()).toArray(String[]::new);
        fail("should not reach here due to IOException");
      } catch (UncheckedIOException uioe) {
        assertTrue(uioe.getCause() instanceof FaultyFileSystem.FaultyException);
      }

      try (Stream<Path> s = Files.walk(fakeRoot.resolve("empty").resolve("IOException"))) {
        String[] result = s.map(path -> path.getFileName().toString()).toArray(String[]::new);
        fail("should not reach here due to IOException");
      } catch (IOException ioe) {
        assertTrue(ioe instanceof FaultyFileSystem.FaultyException);
      } catch (UncheckedIOException ex) {
        fail("Top level should be repored as is");
      }
    } finally {
      // Cleanup
      if (fs != null) {
        fs.close();
      }
      Files.delete(triggerFile);
      TestUtil.removeAll(triggerDir);
    }
  }
  @Override
  protected void setUp() throws Exception {
    deleteDirectory(ROOT);

    super.setUp();

    Files.createFile(Paths.get(ROOT, "basic", FILE));
    Files.createFile(Paths.get(ROOT, "basic-as-default", FILE));
    Files.createFile(Paths.get(ROOT, "basic-as-default-with-filter", FILE));
    Files.createFile(Paths.get(ROOT, "posix", FILE));
  }
 /** Creates a test environment with bin, config and plugins directories. */
 static Tuple<Path, Environment> createEnv(FileSystem fs, Function<String, Path> temp)
     throws IOException {
   Path home = temp.apply("install-plugin-command-tests");
   Files.createDirectories(home.resolve("bin"));
   Files.createFile(home.resolve("bin").resolve("elasticsearch"));
   Files.createDirectories(home.resolve("config"));
   Files.createFile(home.resolve("config").resolve("elasticsearch.yml"));
   Path plugins = Files.createDirectories(home.resolve("plugins"));
   assertTrue(Files.exists(plugins));
   Settings settings = Settings.builder().put("path.home", home).build();
   return Tuple.tuple(home, new Environment(settings));
 }
 public void testPlatformBinPermissions() throws Exception {
   assumeTrue("posix filesystem", isPosix);
   Tuple<Path, Environment> env = createEnv(fs, temp);
   Path pluginDir = createPluginDir(temp);
   Path platformDir = pluginDir.resolve("platform");
   Path platformNameDir = platformDir.resolve("linux-x86_64");
   Path platformBinDir = platformNameDir.resolve("bin");
   Files.createDirectories(platformBinDir);
   Path programFile = Files.createFile(platformBinDir.resolve("someprogram"));
   // a file created with Files.createFile() should not have execute permissions
   Set<PosixFilePermission> sourcePerms = Files.getPosixFilePermissions(programFile);
   assertFalse(sourcePerms.contains(PosixFilePermission.OWNER_EXECUTE));
   assertFalse(sourcePerms.contains(PosixFilePermission.GROUP_EXECUTE));
   assertFalse(sourcePerms.contains(PosixFilePermission.OTHERS_EXECUTE));
   String pluginZip = createPlugin("fake", pluginDir);
   installPlugin(pluginZip, env.v1());
   assertPlugin("fake", pluginDir, env.v2());
   // check that the installed program has execute permissions, even though the one added to the
   // plugin didn't
   Path installedPlatformBinDir =
       env.v2()
           .pluginsFile()
           .resolve("fake")
           .resolve("platform")
           .resolve("linux-x86_64")
           .resolve("bin");
   assertTrue(Files.isDirectory(installedPlatformBinDir));
   Path installedProgramFile = installedPlatformBinDir.resolve("someprogram");
   assertTrue(Files.isRegularFile(installedProgramFile));
   Set<PosixFilePermission> installedPerms = Files.getPosixFilePermissions(installedProgramFile);
   assertTrue(installedPerms.contains(PosixFilePermission.OWNER_EXECUTE));
   assertTrue(installedPerms.contains(PosixFilePermission.GROUP_EXECUTE));
   assertTrue(installedPerms.contains(PosixFilePermission.OTHERS_EXECUTE));
 }
Пример #8
0
  /** Check that a cancelled key will never be queued */
  static void testCancel(Path dir) throws IOException {
    System.out.println("-- Cancel --");

    try (WatchService watcher = FileSystems.getDefault().newWatchService()) {

      System.out.format("register %s for events\n", dir);
      WatchKey myKey = dir.register(watcher, new WatchEvent.Kind<?>[] {ENTRY_CREATE});
      checkKey(myKey, dir);

      System.out.println("cancel key");
      myKey.cancel();

      // create a file in the directory
      Path file = dir.resolve("mars");
      System.out.format("create: %s\n", file);
      Files.createFile(file);

      // poll for keys - there will be none
      System.out.println("poll...");
      try {
        WatchKey key = watcher.poll(3000, TimeUnit.MILLISECONDS);
        if (key != null) throw new RuntimeException("key should not be queued");
      } catch (InterruptedException x) {
        throw new RuntimeException(x);
      }

      // done
      Files.delete(file);

      System.out.println("OKAY");
    }
  }
  /**
   * 修改渠道号
   *
   * <p>demo: <code>changeChannel("xxx../../my.apk", "hiapk");</code>
   *
   * @param zipFilename apk文件
   * @param channel 新渠道号
   * @return true or false
   */
  public static boolean buildChannel(String zipFilename, String channelPrefix, String channel) {
    try (FileSystem zipfs = createZipFileSystem(zipFilename, false)) {
      String channelBegin = "/META-INF/" + channelPrefix;
      String channelFlagName = channelBegin + channel;

      final Path root = zipfs.getPath("/META-INF/");
      ChannelFileVisitor visitor = new ChannelFileVisitor(channelBegin);
      Files.walkFileTree(root, visitor);

      Path existChannel = visitor.getChannelFile();
      Path newChannel = zipfs.getPath(channelFlagName);
      if (existChannel != null) {
        Files.move(existChannel, newChannel, StandardCopyOption.ATOMIC_MOVE);
      } else {
        Files.createFile(newChannel);
      }

      return true;

    } catch (IOException e) {
      e.printStackTrace();
    }

    return false;
  }
Пример #10
0
  void storeXml(ParseIndexContext ctx, Path xml) throws IOException {
    Files.createFile(xml);
    PrintWriter p = new PrintWriter(Files.newBufferedWriter(xml, utf8));
    p.print("<?xml version='1.1' encoding='" + NotesRetriever.utf8.name() + "'?><snotes>");

    ctx.list.sort(Comparator.comparing(o1 -> o1.number));
    for (NoteListItem i : ctx.list) {
      p.print("\n<n");
      p.print(" n='" + i.number + "'");
      if (i.mark != null) p.print(" m='" + i.mark + "'");
      p.print(" a='" + i.apparea + "'");
      p.print(" l='" + i.asklangu + "'");
      p.print(" d='" + DateTimeFormatter.ISO_LOCAL_DATE.format(i.date) + "'");
      p.print(" c='" + i.category + "'");
      p.print(" p='" + i.priority + "'");
      if (i.objid != null) p.print(" o='" + i.objid + "'");
      p.print(">" + StringEscapeUtils.escapeXml11(i.title) + "</n>");
    }
    p.flush();
    for (Pair<String, String> a : ctx.lareas) {
      p.print("\n<area rcode='" + a.getKey() + "' value='" + a.getValue() + "'/>");
    }
    p.flush();
    //		p.print("\n<!-- [Statistics]");
    //		if (dsd==0 && dod==0) {
    //			p.print("\tNotes collected: " + q + ", no duplicates found");
    //		} else {
    //			p.print("\nUnique notes collected: " + q);
    //			p.print("\nDuplicate notes with the same date: " + dsd);
    //			p.print("\nDuplocate notes with the other date: " + dod);
    //		}
    //		p.println("\t-->");
    p.print("\n</snotes>");
    p.close();
  }
Пример #11
0
  /** Start the logging system. We must define a new log to store everything. */
  public synchronized void createLog() {
    if (logPath == null) {
      String id = String.format("log_%d", System.currentTimeMillis());
      try {
        // Try to close the old channel.
        if (logChannel != null) {
          logChannel.close();
        }

        logPath =
            Paths.get(db.getLogPath() + System.getProperty("file.separator") + id).toAbsolutePath();
        if (!Files.exists(logPath)) {
          // Create the necessary parent directories.
          Files.createDirectories(Paths.get(db.getLogPath()).toAbsolutePath());

          // Make sure that our WAL is created before we return.
          logPath = Files.createFile(logPath);

          // Open up the line of communication.
          String flag = "rw";
          if (flushPolicy == Flush.SAFE) {
            flag += "d";
          }
          logChannel = new RandomAccessFile(logPath.toString(), flag).getChannel();

          // Map the file.
          logBuffer = mapWAL();
        }
      } catch (IOException e) {
        e.printStackTrace();
      } catch (Exception e) {
        e.printStackTrace();
      }
    }
  }
  /**
   * Create new encrypt/decrypt instance with required parameters.
   *
   * @param sourceFileName File you want to encrypt/decrypt.
   * @param destinationFileName File which will be the result of encryption/decryption.
   * @param encryptionKey Encryption key which will be used in process of encryption/decryption.
   * @param initializationVector Initialization vector which will be used in process of
   *     encryption/decryption.
   * @param mode {@link FileEncryption} ENCRYPT_MODE/DECRYPT_MODE.
   */
  public FileEncryption(
      String sourceFileName,
      String destinationFileName,
      String encryptionKey,
      String initializationVector,
      int mode) {
    SecretKeySpec keySpec = new SecretKeySpec(hexToByte(encryptionKey), "AES");
    AlgorithmParameterSpec paramSpec = new IvParameterSpec(hexToByte(initializationVector));
    try {
      cipher = Cipher.getInstance("AES/CBC/PKCS5Padding");
      cipher.init(mode, keySpec, paramSpec);

      inputPath = Paths.get(sourceFileName);
      File outputFile = new File(destinationFileName);
      outputPath = outputFile.toPath();
      if (!outputFile.exists()) {
        Files.createFile(outputPath);
      }
    } catch (NoSuchAlgorithmException e) {
      System.out.println("No AES/CBC/PKCS5Padding algorithm available.");
    } catch (NoSuchPaddingException e) {
      System.out.println("No such padding.");
    } catch (InvalidKeyException e) {
      System.out.println("Invalid key.");
    } catch (InvalidAlgorithmParameterException e) {
      System.out.println("Invalid algorithm parameters.");
    } catch (IOException e) {
      System.out.println("Could not read a file.");
    }
  }
Пример #13
0
  private static void pathesAndFileCreation() throws IOException {
    System.out.println("yes\\no");
    System.out.println("c:\\program files\\myProgram");
    System.out.println("c:/program files/myProgram");
    String win = "c:\\HaxLogs.txt";
    String unix = "c:/HaxLogs.txt";

    File winFile = new File(win);
    System.out.println("win file exists: " + winFile.exists());

    File unixFile = new File(unix);
    System.out.println("unix file exists: " + unixFile.exists());

    Path path = Paths.get("myFile.txt");
    System.out.println(path);
    System.out.println(path.toAbsolutePath());

    Path absolutePath = Paths.get("d:/myFile.txt");
    System.out.println(absolutePath);
    System.out.println(absolutePath.toAbsolutePath());

    if (!Files.exists(absolutePath)) {
      Files.createFile(absolutePath);
      System.out.println("file created");
    } else {
      System.out.println("file already exists");
    }
  }
  /*
   * Windowsでは読み込み可否設定はできないっぽい
   */
  @Test(groups = "LinuxOnly", expectedExceptions = IllegalArgumentException.class)
  public void loadが呼び出されたけど設定ファイルが読み込み不能な時はIllegalArgumentExceptionをスローするよ() throws IOException {
    Files.createFile(C設定ファイルが読み込み不能だった);
    C設定ファイルが読み込み不能だった.toFile().setReadable(false);

    ServerProperties.INSTANCE.load(C設定ファイルが読み込み不能だった.toString());
  }
Пример #15
0
 /** 读写文件的优化 */
 @Test
 public void testReadAndWriter() {
   // StandardCharsets.UTF_8
   Path path2 = Paths.get(PATH);
   String string = ParentPath + "\\writer.txt";
   Path path3 = Paths.get(string);
   try {
     Files.createFile(path3);
   } catch (IOException e1) {
     // TODO Auto-generated catch block
     e1.printStackTrace();
   }
   try (BufferedReader reader = Files.newBufferedReader(path2, Charset.forName("GBK"));
       BufferedWriter bw =
           Files.newBufferedWriter(path3, Charset.forName("UTF-8"), StandardOpenOption.WRITE)) {
     String line;
     while ((line = reader.readLine()) != null) {
       System.out.println(line);
       bw.write(line);
     }
   } catch (IOException e) {
     // TODO Auto-generated catch block
     e.printStackTrace();
   }
 }
  private void LoadFile() {
    try {
      if (!Files.exists(_path)) {
        Files.createFile(_path);
        return;
      }

      Files.readAllLines(_path, StandardCharsets.UTF_8);

      try {
        String playerName = "";
        String timeStamp = "";

        for (String line : Files.readAllLines(_path, StandardCharsets.UTF_8)) {
          if (line.equals("")) continue;

          if (playerName.equals("")) {
            playerName = line;
            continue;
          }

          if (timeStamp.equals("")) {
            timeStamp = line;
            _whiteListed.Add(new PlayerWhitelistRecord(playerName, timeStamp));
            continue;
          }
        }
      } catch (Exception e) {
        e.printStackTrace();
      }

    } catch (Exception e) {
      e.printStackTrace();
    }
  }
Пример #17
0
  public static void saveData(String file, EnumMap<PlayerStats, Float> map, boolean overwrite) {
    FileSystem fileSystem = FileSystems.getDefault();
    Path path = fileSystem.getPath(file);
    if (Files.isDirectory(path))
      throw new IllegalArgumentException("This method is not supposed to read a directory");

    if (Files.exists(path) && Files.isReadable(path)) {
      if (overwrite == false) return;
    } else
      try {
        Files.createFile(path);
      } catch (IOException e) {
        e
            .printStackTrace(); // To change body of catch statement use File | Settings | File
                                // Templates.
      }

    try (ObjectOutputStream objectOutputStream =
        new ObjectOutputStream(Files.newOutputStream(path))) {
      objectOutputStream.writeObject(map);
    } catch (IOException e) {
      e
          .printStackTrace(); // To change body of catch statement use File | Settings | File
                              // Templates.
    }
  }
Пример #18
0
  @Test
  public void test() {

    AntivirusPlugin antivirusPlugin = new AntivirusPlugin();
    Path testFile = null;
    FileOutputStream f = null;

    try {

      List<byte[]> bytesList = AntivirusProperties.getByteSequences();
      if (bytesList.size() == 0) {
        fail(
            "You should have at least one sequence in file antivirus.properties. Please write one");
      }

      // empty file can't be infected
      testFile = Files.createFile(Paths.get("testfile"));
      assertTrue(antivirusPlugin.canCopyFile(testFile));

      // adding infected sequence of bytes to file
      f = new FileOutputStream(testFile.toFile());
      f.write(bytesList.get(0));

      assertFalse(antivirusPlugin.canCopyFile(testFile));

    } catch (IOException e) {
      fail(e.getMessage());
    } finally {
      closeStream(f);
      deleteFile(testFile);
    }
  }
  @Test
  public void rewritesRequireStatementForDirectoryIndex2() throws IOException {
    createDirectories(path("foo"));
    createFile(path("foo/bar.js"));
    CompilerUtil compiler =
        createCompiler(path("foo/bar/index.js"), path("foo/bar.js"), path("foo/main.js"));

    compiler.compile(
        createSourceFile(path("foo/bar/index.js"), "exports.a = 123;"),
        createSourceFile(path("foo/bar.js"), "exports.b = 456;"),
        createSourceFile(
            path("foo/main.js"),
            "var bar1 = require('./bar');",
            "var bar2 = require('./bar/');",
            "exports.c = bar1.a * bar2.b;"));

    assertThat(compiler.toSource())
        .startsWith(
            lines(
                "var $jscomp = {};",
                "$jscomp.scope = {};",
                "var module$foo$bar$index = {};",
                "module$foo$bar$index.a = 123;",
                "var module$foo$bar = {};",
                "module$foo$bar.b = 456;",
                "var module$foo$main = {};",
                "module$foo$main.c = module$foo$bar.a * module$foo$bar$index.b;"));
  }
Пример #20
0
 public void open(Path path) {
   try {
     if (!Files.exists(path)) path = Files.createFile(path);
     writer = Files.newBufferedWriter(path, charset);
   } catch (IOException e) {
     e.printStackTrace();
   }
 }
Пример #21
0
 public FileResource create() {
   try {
     Files.createFile(file);
   } catch (IOException e) {
     throw New.unchecked(e);
   }
   return this;
 }
Пример #22
0
 private FileBasedConfig getGerritConfigFile(SitePaths sitePath) throws IOException {
   FileBasedConfig cfg = new FileBasedConfig(sitePath.gerrit_config.toFile(), FS.DETECTED);
   if (!cfg.getFile().exists()) {
     Path etc_path = Files.createDirectories(sitePath.etc_dir);
     Files.createFile(etc_path.resolve("gerrit.config"));
   }
   return cfg;
 }
  @Test
  public void handlesReferencesToOtherModulesTypesEvenIfNotExplicitlyRequired() throws IOException {
    Path root = path("root.js");
    Path bar = path("foo/bar.js");
    Path baz = path("foo/baz.js");

    createFile(root);
    createDirectories(bar.getParent());
    createFile(bar);
    createFile(baz);

    CompilerUtil compiler = createCompiler(root, bar, baz);
    compiler.compile(
        createSourceFile(root, "/** @param {!./foo/bar.Person} p . */", "function inRoot(p) {}"),
        createSourceFile(bar, "/** @constructor */", "exports.Person = function(){};"),
        createSourceFile(baz, "/** @param {!./bar.Person} p . */", "function inBaz(p) {}"));
  }
 public void testConfig() throws Exception {
   Tuple<Path, Environment> env = createEnv(fs, temp);
   Path pluginDir = createPluginDir(temp);
   Path configDir = pluginDir.resolve("config");
   Files.createDirectory(configDir);
   Files.createFile(configDir.resolve("custom.yaml"));
   String pluginZip = createPlugin("fake", pluginDir);
   installPlugin(pluginZip, env.v1());
   assertPlugin("fake", pluginDir, env.v2());
 }
 public void testConfigNotDir() throws Exception {
   Tuple<Path, Environment> env = createEnv(fs, temp);
   Path pluginDir = createPluginDir(temp);
   Path configDir = pluginDir.resolve("config");
   Files.createFile(configDir);
   String pluginZip = createPlugin("fake", pluginDir);
   UserException e = expectThrows(UserException.class, () -> installPlugin(pluginZip, env.v1()));
   assertTrue(e.getMessage(), e.getMessage().contains("not a directory"));
   assertInstallCleaned(env.v2());
 }
 public void testBin() throws Exception {
   Tuple<Path, Environment> env = createEnv(fs, temp);
   Path pluginDir = createPluginDir(temp);
   Path binDir = pluginDir.resolve("bin");
   Files.createDirectory(binDir);
   Files.createFile(binDir.resolve("somescript"));
   String pluginZip = createPlugin("fake", pluginDir);
   installPlugin(pluginZip, env.v1());
   assertPlugin("fake", pluginDir, env.v2());
 }
Пример #27
0
 @Before
 private void setUp() throws IOException {
   final String[] fileNames = {
     "backup_CombinedData_2016-Jun-20_at_00-14-00", "backup_CombinedData_2016-Jul-19_at_00-20-00",
     // TODO other types
   };
   for (final String fileName : fileNames) {
     Files.createFile(testPath.resolve(fileName));
   }
 }
 public void testMissingDescriptor() throws Exception {
   Tuple<Path, Environment> env = createEnv(fs, temp);
   Path pluginDir = createPluginDir(temp);
   Files.createFile(pluginDir.resolve("fake.yml"));
   String pluginZip = writeZip(pluginDir, "elasticsearch");
   NoSuchFileException e =
       expectThrows(NoSuchFileException.class, () -> installPlugin(pluginZip, env.v1()));
   assertTrue(e.getMessage(), e.getMessage().contains("plugin-descriptor.properties"));
   assertInstallCleaned(env.v2());
 }
 private void ensureServiceOutExists() {
   try {
     if (!Files.exists(taskDefinition.getServiceLogOutPath())) {
       Files.createFile(taskDefinition.getServiceLogOutPath());
     }
   } catch (FileAlreadyExistsException faee) {
     log.debug("Executor out {} already existed", taskDefinition.getServiceLogOut());
   } catch (Throwable t) {
     log.error("Failed creating executor out {}", taskDefinition.getServiceLogOut(), t);
   }
 }
Пример #30
0
 @Test
 public void testCreate_NotDirectory() throws IOException {
   final Path root = random();
   try {
     Files.createFile(root);
     exception.expect(NotDirectoryException.class);
     new SitePaths(root);
   } finally {
     Files.delete(root);
   }
 }