示例#1
0
  private File findTempFile(String s) {
    String os = System.getProperty("os.name").toLowerCase();
    File f;

    if (os.indexOf("linux") >= 0) {
      // DEBUG System.out.println("LINUX");
      f = new File("/tmp/Cryptography/");
      if (!f.exists()) f.mkdirs();
      f = new File(f.toPath() + "/" + s);
      if (f.exists()) if (!f.delete()) System.err.println("No writing access to temp files");
    } else if (os.indexOf("win") >= 0) {
      // DEBUG System.out.println("WINDOWS");
      f =
          new File(
              "C:\\Users\\"
                  + System.getProperty("user.name")
                  + "\\AppData\\Local\\Temp\\Cryptography\\");
      if (!f.exists()) f.mkdirs();
      f = new File(f.toPath() + "\\" + s);
      if (f.exists()) if (!f.delete()) System.err.println("No writing access to temp files");
    } else {
      System.err.println("Unbekanntes Betriebssystem!");
      return null;
    }
    return f;
  }
  public void cp(String source, String destination, boolean recursive)
      throws NoSuchFileException, IOException {
    File srcFile = getPath(source).toFile();
    File destFile = getPath(destination).toFile();

    if (!srcFile.exists()) {
      throw new FileNotFoundException(source);
    }

    if (srcFile.isDirectory() && !recursive) {
      String exMsg = "'%s' is Directory";
      throw new IOException(String.format(exMsg, source));
    }

    if (srcFile.equals(destFile)) {
      String exMsg = "'%s' and '%s' are the same";
      throw new IOException(String.format(exMsg, source, destination));
    }

    if (srcFile.isFile()) {
      if (destFile.isDirectory()) {
        destFile = new File(destFile, source);
      }
      Files.copy(srcFile.toPath(), destFile.toPath(), StandardCopyOption.REPLACE_EXISTING);
    } else {
      Files.walkFileTree(srcFile.toPath(), new FileVisitorImpl(srcFile, destFile));
    }
  }
  /**
   * Uploads the dsl file of a user to an auxiliar folder, if it's not upload returns an error
   *
   * @param file
   * @param idUser
   */
  @RequestMapping(method = RequestMethod.POST, value = "/uploadDSL")
  public ResponseEntity<String> handleFileUploadDSL(
      @RequestParam("dsl") MultipartFile file, @RequestParam("idUser") String idUser) {

    // target DSL name
    String name = "dsl.yml";
    if (!file.isEmpty()) {
      try {
        // User folder
        File userFolder = new File(idUser);
        if (!userFolder.exists()) Files.createDirectory(userFolder.toPath());
        // Auxiliar folder where the temporal configuration files are
        // copy
        String folderAux = idUser + "/aux";
        File folder = new File(folderAux);
        if (!folder.exists()) Files.createDirectory(folder.toPath());
        // Copy DSL file
        BufferedOutputStream stream =
            new BufferedOutputStream(new FileOutputStream(new File(folderAux + "/" + name)));
        FileCopyUtils.copy(file.getInputStream(), stream);
        stream.close();
        log.info("DSL copied: " + idUser);
      } catch (Exception e) {
        log.warn("DSL not copied:" + e.getMessage());
        throw new InternalError("Error copying: " + e.getMessage());
      }
    } else {
      log.warn("DSL not copied, empty file: " + idUser);
      throw new BadRequestError("Empty file");
    }
    return new ResponseEntity<>("copied", HttpStatus.OK);
  }
示例#4
0
 private int cpRecursive(String[] args, String directory, Status status) throws IOException {
   if (args.length < 2) {
     return 1;
   }
   File source = new File(directory + File.separator + args[2]);
   if (!source.exists()) {
     return 1;
   }
   File destination = new File(args[3] + File.separator + args[2]);
   if (destination.exists()) {
     String[] rmArgs = {"rm", "-r", destination.getName()};
     new RmCommand().execute(rmArgs, status);
   }
   if (!source.isDirectory()) {
     Files.copy(source.toPath(), destination.toPath());
     return 0;
   }
   Files.copy(source.toPath(), destination.toPath());
   File[] listFiles = source.listFiles();
   if (listFiles.length == 0) {
     return 0;
   }
   for (File f : listFiles) {
     String[] newArgs = {"cp", "-r", f.getName(), destination.getAbsolutePath()};
     cpRecursive(newArgs, source.getAbsolutePath(), status);
   }
   return 0;
 }
示例#5
0
  public void testMultipleListeners() throws Exception {
    File rootDirectory = Files.createTempDir();
    File subDirectory = createDirectoryIn("subdir", rootDirectory);

    ResourceAccumulator resourceAccumulator1 =
        new ResourceAccumulator(rootDirectory.toPath(), createInclusivePathPrefixSet());
    ResourceAccumulator resourceAccumulator2 =
        new ResourceAccumulator(rootDirectory.toPath(), createInclusivePathPrefixSet());

    assertTrue(getResources(resourceAccumulator1).isEmpty());
    assertTrue(getResources(resourceAccumulator2).isEmpty());

    createFileIn("New.java", subDirectory);
    waitForFileEvents();

    List<AbstractResource> resources1 = getResources(resourceAccumulator1);
    assertEquals(1, resources1.size());
    assertTrue(resources1.get(0).getPath().endsWith("New.java"));

    List<AbstractResource> resources2 = getResources(resourceAccumulator2);
    assertEquals(1, resources2.size());
    assertTrue(resources2.get(0).getPath().endsWith("New.java"));

    resourceAccumulator1.shutdown();
    resourceAccumulator2.shutdown();
  }
示例#6
0
  public void testSymlinks() throws Exception {
    File scratchDirectory = Files.createTempDir();
    File newFile = createFileIn("New.java", scratchDirectory);
    File rootDirectory = Files.createTempDir();
    File subDirectory = Files.createTempDir();

    ResourceAccumulator resourceAccumulator =
        new ResourceAccumulator(rootDirectory.toPath(), createInclusivePathPrefixSet());

    assertTrue(getResources(resourceAccumulator).isEmpty());

    // Symlink in a subdirectory and then symlink in a contained file.
    java.nio.file.Files.createSymbolicLink(
            new File(rootDirectory, "sublink").toPath(), subDirectory.toPath())
        .toFile();
    java.nio.file.Files.createSymbolicLink(
            new File(subDirectory, "New.java").toPath(), newFile.toPath())
        .toFile();
    waitForFileEvents();

    List<AbstractResource> resources = getResources(resourceAccumulator);
    assertEquals(1, resources.size());
    assertTrue(resources.get(0).getPath().endsWith("sublink/New.java"));

    resourceAccumulator.shutdown();
  }
  @Test
  public void should_create_given_directory() throws Exception {

    visitor.preVisitDirectory(source.toPath().resolve("widgets"), null);

    assertThat(exists(destination.toPath().resolve("widgets"))).isTrue();
  }
示例#8
0
 private synchronized File unpackFromFileURL(URL url, String fileName, ClassLoader cl) {
   File resource;
   try {
     resource = new File(URLDecoder.decode(url.getPath(), "UTF-8"));
   } catch (UnsupportedEncodingException e) {
     throw new VertxException(e);
   }
   boolean isDirectory = resource.isDirectory();
   File cacheFile = new File(cacheDir, fileName);
   if (!isDirectory) {
     cacheFile.getParentFile().mkdirs();
     try {
       if (ENABLE_CACHING) {
         Files.copy(resource.toPath(), cacheFile.toPath());
       } else {
         Files.copy(resource.toPath(), cacheFile.toPath(), StandardCopyOption.REPLACE_EXISTING);
       }
     } catch (FileAlreadyExistsException ignore) {
     } catch (IOException e) {
       throw new VertxException(e);
     }
   } else {
     cacheFile.mkdirs();
     String[] listing = resource.list();
     for (String file : listing) {
       String subResource = fileName + "/" + file;
       URL url2 = cl.getResource(subResource);
       unpackFromFileURL(url2, subResource, cl);
     }
   }
   return cacheFile;
 }
示例#9
0
 public void drop() throws Exception {
   for (int i = 0; i < 16; i++) {
     File subDir = new File(mainDir, String.valueOf(i) + ".dir");
     for (int j = 0; j < 16; j++) {
       if (databases[i][j] != null) {
         File dbFile = new File(subDir, String.valueOf(j) + ".dat");
         if (dbFile.exists()) {
           try {
             Files.delete(dbFile.toPath());
           } catch (SecurityException | IOException e) {
             throw new Exception("Access violation: cannon delete database file");
           }
         }
       }
     }
     if (subDir.exists()) {
       try {
         Files.delete(subDir.toPath());
       } catch (DirectoryNotEmptyException e) {
         throw new Exception("Cannot remove table subdirectory. Redundant files");
       } catch (SecurityException | IOException e) {
         throw new Exception("Access violation: cannot delete database subdirectory");
       }
     }
   }
   try {
     Files.delete(mainDir.toPath());
   } catch (DirectoryNotEmptyException e) {
     throw new Exception("Cannot remove main table directory. Redundant files");
   } catch (SecurityException | IOException e) {
     throw new Exception("Access violation: cannot delete main database directory");
   }
 }
  @Test
  public void testTerminateQueueCannotDeleteDirectory() throws IOException {
    String queueName = "queueCannotDelete";
    File queueDir = new File("target", queueName);
    ReportExporter exporter = mock(ReportExporter.class);
    BatchProcessorConfig config = mock(BatchProcessorConfig.class);
    when(config.getDataDirectory()).thenReturn("target");
    when(config.getQueueSize()).thenReturn(5);
    FileUtil.deleteDirectory(queueDir);

    queueFactory = new QueueFactory(config, exporter);

    Set<PosixFilePermission> permissions = new HashSet<>();
    permissions.add(PosixFilePermission.OWNER_READ);

    queueFactory.create(queueName);
    assertTrue(queueDir.exists());
    Files.setPosixFilePermissions(queueDir.toPath(), permissions);

    try {
      queueFactory.terminate(queueName);
      fail("Expected IllegalStateException");
    } catch (IllegalStateException e) {
      assertTrue(true);
    }

    permissions = new HashSet<>();
    permissions.add(PosixFilePermission.OWNER_WRITE);
    permissions.add(PosixFilePermission.OWNER_READ);
    permissions.add(PosixFilePermission.OWNER_EXECUTE);
    Files.setPosixFilePermissions(queueDir.toPath(), permissions);
    FileUtil.deleteDirectory(queueDir);
  }
示例#11
0
  /**
   * @param srcFilename
   * @param dstFilename
   */
  public static void copyOrDie(String srcFilename, String dstFilename) {
    File src = new File(srcFilename);
    File dst = new File(dstFilename);

    System.out.printf("Copy or die: %s, %s\n", srcFilename, dstFilename);
    if (!src.exists()) {
      return;
    }

    // Ensure target file is non-existent.
    deleteOrDie(dstFilename);

    // Copy file.
    try {
      if (src.isDirectory()) {
        org.apache.commons.io.FileUtils.copyDirectory(src, dst);
      } else {
        Files.copy(src.toPath(), dst.toPath());
      }
    } catch (IOException ex) {
      throw new FatalError(
          "copyOrDie failed for '" + srcFilename + "' -> '" + dstFilename + "'", ex);
    }

    // Check if target exists.
    existsOrDie(dst);
  }
  /** Generate evolutions. */
  @Override
  public void create() {
    if (!environment.isProd()) {
      config
          .serverConfigs()
          .forEach(
              (key, serverConfig) -> {
                String evolutionScript = generateEvolutionScript(servers.get(key));
                if (evolutionScript != null) {
                  File evolutions = environment.getFile("conf/evolutions/" + key + "/1.sql");
                  try {
                    String content = "";
                    if (evolutions.exists()) {
                      content = new String(Files.readAllBytes(evolutions.toPath()), "utf-8");
                    }

                    if (content.isEmpty() || content.startsWith("# --- Created by Ebean DDL")) {
                      environment.getFile("conf/evolutions/" + key).mkdirs();
                      if (!content.equals(evolutionScript)) {
                        Files.write(evolutions.toPath(), evolutionScript.getBytes("utf-8"));
                      }
                    }
                  } catch (IOException e) {
                    throw new RuntimeException(e);
                  }
                }
              });
    }
  }
  static void setupCleanDirectories(File jbossHomeDir, Properties props) {
    File tempRoot = getTempRoot(props);
    if (tempRoot == null) {
      return;
    }

    File originalConfigDir =
        getFileUnderAsRoot(
            jbossHomeDir, props, ServerEnvironment.SERVER_CONFIG_DIR, "configuration", true);
    File originalDataDir =
        getFileUnderAsRoot(jbossHomeDir, props, ServerEnvironment.SERVER_DATA_DIR, "data", false);

    try {
      File configDir = new File(tempRoot, "config");
      Files.createDirectory(configDir.toPath());
      File dataDir = new File(tempRoot, "data");
      Files.createDirectory(dataDir.toPath());
      // For jboss.server.deployment.scanner.default
      File deploymentsDir = new File(tempRoot, "deployments");
      Files.createDirectory(deploymentsDir.toPath());

      copyDirectory(originalConfigDir, configDir);
      if (originalDataDir.exists()) {
        copyDirectory(originalDataDir, dataDir);
      }

      props.put(ServerEnvironment.SERVER_BASE_DIR, tempRoot.getAbsolutePath());
      props.put(ServerEnvironment.SERVER_CONFIG_DIR, configDir.getAbsolutePath());
      props.put(ServerEnvironment.SERVER_DATA_DIR, dataDir.getAbsolutePath());
    } catch (IOException e) {
      throw EmbeddedLogger.ROOT_LOGGER.cannotSetupEmbeddedServer(e);
    }
  }
示例#14
0
  public void testSymlinkInfiniteLoop() throws Exception {
    File rootDirectory = Files.createTempDir();
    File subDirectory = Files.createTempDir();

    ResourceAccumulator resourceAccumulator =
        new ResourceAccumulator(rootDirectory.toPath(), createInclusivePathPrefixSet());

    assertTrue(getResources(resourceAccumulator).isEmpty());

    // Symlink in a loop
    java.nio.file.Files.createSymbolicLink(
            new File(rootDirectory, "sublink").toPath(), subDirectory.toPath())
        .toFile();
    java.nio.file.Files.createSymbolicLink(
            new File(subDirectory, "sublink").toPath(), rootDirectory.toPath())
        .toFile();
    createFileIn("New.java", subDirectory);
    waitForFileEvents();

    try {
      // Should throw an error if resourceAccumulator got stuck in an infinite directory scan loop.
      getResources(resourceAccumulator);
      fail();
    } catch (FileSystemException expected) {
      // Expected
    }

    resourceAccumulator.shutdown();
  }
示例#15
0
  public String call() throws IOException, IllegalArgumentException {
    if (urlToFetch == null) {
      throw new IllegalArgumentException("Need a URL to fetch");
    }

    log.info("urlToFetch: " + urlToFetch);
    String[] filenameParts = urlToFetch.split("/");
    String basename = filenameParts[filenameParts.length - 1];
    String absoluteFilePath = outputDir + File.separator + basename;
    File finalMP3 = new File(absoluteFilePath);
    Path pathFinalMP3 = finalMP3.toPath();

    if (finalMP3.exists()) {
      log.info("Looks like " + basename + " is already there.. Skipping");
    } else {
      GenericUrl url = new GenericUrl(urlToFetch);

      HttpRequest request = requestFactory.buildGetRequest(url);
      File f = downloadToTempFile(request);
      Path pathTempMP3 = f.toPath();
      moveToFile(pathTempMP3, pathFinalMP3);
    }

    return pathFinalMP3.toString();
  }
 @Override
 public <T> T run(Callable<T> r) {
   T result = null;
   try {
     synchronized (store) {
       result = r.call();
       File temp = new File(store.getParentFile(), "temp_" + store.getName());
       FileOutputStream file = new FileOutputStream(temp);
       ObjectOutputStream out = new ObjectOutputStream(file);
       out.writeObject(properties);
       out.writeObject(maps);
       out.flush();
       out.close();
       file.flush();
       file.close();
       Files.move(
           temp.toPath(),
           store.toPath(),
           StandardCopyOption.ATOMIC_MOVE,
           StandardCopyOption.REPLACE_EXISTING);
     }
   } catch (Exception e) {
     // If something happened here, that is a serious bug so we need to assert.
     throw Assert.failure("Failure flushing FlatFileKeyValueStorage", e);
   }
   return result;
 }
示例#17
0
  private static void copyFiles(String str) throws IOException {

    File destFile =
        new File(
            "/home/vinay/work/finovera/web/static/src/main/webapp/resources/images/logos/" + str);

    File[] fiportFiles = readFilesName("fiport/webapps", str);
    File[] finoveraFiles = readFilesName("finovera/web", str);

    boolean found = false;

    for (File fp : fiportFiles) {

      found = false;

      for (File fn : finoveraFiles) {

        if (fp.getName().trim().equalsIgnoreCase(fn.getName().trim())) {
          found = true;
        }
      }

      if (found == false) {
        Path sourcePath = fp.toPath();
        Path destPath = destFile.toPath();
        Files.copy(sourcePath, destPath.resolve(sourcePath.getFileName()));

        System.out.println(fp.getName() + ": Image copied to Finovera.");
      }
    }
  }
示例#18
0
 /**
  * @param templateDir The directory that contains the template version of the project.
  * @param temporaryFolder The directory where the clone of the template directory should be
  *     written. By requiring a {@link TemporaryFolder} rather than a {@link File}, we can ensure
  *     that JUnit will clean up the test correctly.
  */
 public ProjectWorkspace(File templateDir, DebuggableTemporaryFolder temporaryFolder) {
   Preconditions.checkNotNull(templateDir);
   Preconditions.checkNotNull(temporaryFolder);
   this.templatePath = templateDir.toPath();
   this.destDir = temporaryFolder.getRoot();
   this.destPath = destDir.toPath();
 }
  /** Create a jar file from the classes directory, creating it directly in the toolkit. */
  private static String createJarFile(File toolkitLib, final File classesDir) throws IOException {

    final Path classesPath = classesDir.toPath();
    Path jarPath = Files.createTempFile(toolkitLib.toPath(), "classes", ".jar");
    try (final JarOutputStream jarOut =
        new JarOutputStream(
            new BufferedOutputStream(new FileOutputStream(jarPath.toFile()), 128 * 1024))) {

      Files.walkFileTree(
          classesDir.toPath(),
          new FileVisitor<Path>() {

            @Override
            public FileVisitResult preVisitDirectory(Path dir, BasicFileAttributes attrs)
                throws IOException {
              return FileVisitResult.CONTINUE;
            }

            @Override
            public FileVisitResult visitFile(Path file, BasicFileAttributes attrs)
                throws IOException {
              File classFile = file.toFile();
              if (classFile.isFile()) {
                //  Write the entry followed by the data.
                Path relativePath = classesPath.relativize(file);
                JarEntry je = new JarEntry(relativePath.toString());
                je.setTime(classFile.lastModified());
                jarOut.putNextEntry(je);

                final byte[] data = new byte[32 * 1024];
                try (final BufferedInputStream classIn =
                    new BufferedInputStream(new FileInputStream(classFile), data.length)) {

                  for (; ; ) {
                    int count = classIn.read(data);
                    if (count == -1) break;
                    jarOut.write(data, 0, count);
                  }
                }
                jarOut.closeEntry();
              }
              return FileVisitResult.CONTINUE;
            }

            @Override
            public FileVisitResult visitFileFailed(Path file, IOException exc) throws IOException {
              return FileVisitResult.CONTINUE;
            }

            @Override
            public FileVisitResult postVisitDirectory(Path dir, IOException exc)
                throws IOException {
              dir.toFile().delete();
              return FileVisitResult.CONTINUE;
            }
          });
    }

    return jarPath.getFileName().toString();
  }
  public static void reconstructTurtle(File partFolder, File reconstructed) throws IOException {
    Path tmpOut = Files.createTempFile(partFolder.toPath(), "reconstr", ".tmp");
    FileOutputStream dstOut = new FileOutputStream(tmpOut.toFile());
    FileChannel dstOutChannel = dstOut.getChannel();
    try {
      if (!Files.isDirectory(partFolder.toPath()))
        throw new IOException("Not a directory: " + partFolder);
      File[] fileList =
          FileUtils.listFiles(partFolder, new PrefixFileFilter("part"), TrueFileFilter.TRUE)
              .toArray(new File[0]);
      Arrays.sort(fileList);
      RandomAccessFile inputFile;

      inputFile = new RandomAccessFile(fileList[0], "r");
      inputFile.getChannel().transferTo(0, inputFile.length(), dstOutChannel);
      inputFile.close();
      for (int i = 1; i < fileList.length; i++) {
        inputFile = new RandomAccessFile(fileList[i], "r");
        long lastPrefix = findTurtlePrefixEnd(inputFile);
        inputFile
            .getChannel()
            .transferTo(lastPrefix, inputFile.length() - lastPrefix, dstOutChannel);
        inputFile.close();
      }
    } finally {
      dstOut.close();
    }
    Files.move(
        tmpOut,
        reconstructed.toPath(),
        StandardCopyOption.ATOMIC_MOVE,
        StandardCopyOption.REPLACE_EXISTING);
    FileUtils.deleteQuietly(tmpOut.toFile());
    FileUtils.deleteQuietly(partFolder);
  }
  /* Function Name: decryptSplitFileHandler
  // Description: Handles the decryption of split files
  // Calling Function: decryptFileHandler
  // Parameters: File parent - file to be decrypted
  //             String indent - indentation for log file
  */
  private void decryptSplitFileHandler(File parent, String indent) {

    try {

      log.write(indent.concat(parent.getName()).concat("\n"));

      String dePath = fileOne.getAbsolutePath();
      String deName = fileOne.getName().substring(2, (fileOne.getName().length() - 1));

      dePath = dePath.substring(0, (dePath.length() - fileOne.getName().length()));
      dePath = dePath.concat(deName);

      StatusGuiBuilder.updateStatusGui(fname);

      crypto.doSplitDecrypt(fileOne, fileTwo, new File(dePath));

      decryptSplitFileHandlerHelper(dePath);

      Files.delete(fileOne.toPath());
      Files.delete(fileTwo.toPath());

    } catch (IOException ex) {
      Logger.getLogger(DirectoryStructureDecryptionHandler.class.getName())
          .log(Level.SEVERE, null, ex);
    }
  }
示例#22
0
 static void copyFile(File src, File dst) throws IOException {
   Path parent = dst.toPath().getParent();
   if (parent != null) {
     Files.createDirectories(parent);
   }
   Files.copy(src.toPath(), dst.toPath(), COPY_ATTRIBUTES, REPLACE_EXISTING);
 }
  @Test
  public void testResourceBase() throws Exception {
    testdir.ensureEmpty();
    File resBase = testdir.getFile("docroot");
    FS.ensureDirExists(resBase);
    File foobar = new File(resBase, "foobar.txt");
    File link = new File(resBase, "link.txt");
    createFile(foobar, "Foo Bar");

    String resBasePath = resBase.getAbsolutePath();

    ServletHolder defholder = context.addServlet(DefaultServlet.class, "/");
    defholder.setInitParameter("resourceBase", resBasePath);
    defholder.setInitParameter("gzip", "false");

    String response;

    response = connector.getResponses("GET /context/foobar.txt HTTP/1.0\r\n\r\n");
    assertResponseContains("Foo Bar", response);

    if (!OS.IS_WINDOWS) {
      Files.createSymbolicLink(link.toPath(), foobar.toPath());
      response = connector.getResponses("GET /context/link.txt HTTP/1.0\r\n\r\n");
      assertResponseContains("404", response);

      context.addAliasCheck(new ContextHandler.ApproveAliases());

      response = connector.getResponses("GET /context/link.txt HTTP/1.0\r\n\r\n");
      assertResponseContains("Foo Bar", response);
    }
  }
示例#24
0
  private synchronized File unpackFromJarURL(URL url, String fileName, ClassLoader cl) {
    ZipFile zip = null;
    try {
      String path = url.getPath();
      int idx1 = path.lastIndexOf(".jar!");
      if (idx1 == -1) {
        idx1 = path.lastIndexOf(".zip!");
      }
      int idx2 = path.lastIndexOf(".jar!", idx1 - 1);
      if (idx2 == -1) {
        idx2 = path.lastIndexOf(".zip!", idx1 - 1);
      }
      if (idx2 == -1) {
        File file = new File(URLDecoder.decode(path.substring(5, idx1 + 4), "UTF-8"));
        zip = new ZipFile(file);
      } else {
        String s = path.substring(idx2 + 6, idx1 + 4);
        File file = resolveFile(s);
        zip = new ZipFile(file);
      }

      String inJarPath = path.substring(idx1 + 6);
      String[] parts = JAR_URL_SEP_PATTERN.split(inJarPath);
      StringBuilder prefixBuilder = new StringBuilder();
      for (int i = 0; i < parts.length - 1; i++) {
        prefixBuilder.append(parts[i]).append("/");
      }
      String prefix = prefixBuilder.toString();

      Enumeration<? extends ZipEntry> entries = zip.entries();
      while (entries.hasMoreElements()) {
        ZipEntry entry = entries.nextElement();
        String name = entry.getName();
        if (name.startsWith(prefix.isEmpty() ? fileName : prefix + fileName)) {
          File file = new File(cacheDir, prefix.isEmpty() ? name : name.substring(prefix.length()));
          if (name.endsWith("/")) {
            // Directory
            file.mkdirs();
          } else {
            file.getParentFile().mkdirs();
            try (InputStream is = zip.getInputStream(entry)) {
              if (ENABLE_CACHING) {
                Files.copy(is, file.toPath());
              } else {
                Files.copy(is, file.toPath(), StandardCopyOption.REPLACE_EXISTING);
              }
            } catch (FileAlreadyExistsException ignore) {
            }
          }
        }
      }
    } catch (IOException e) {
      throw new VertxException(e);
    } finally {
      closeQuietly(zip);
    }

    return new File(cacheDir, fileName);
  }
示例#25
0
 public void replaceSnippets(File file, String encoding) throws IOException {
   final File temp = File.createTempFile("snippets", "txt");
   replace(file, temp, encoding, false);
   if (!file.delete()) {
     throw new IOException("Could not delete file " + file);
   }
   Files.move(temp.toPath(), file.toPath());
 }
 private void writeIntoFile(int numOfDir, int numOfFile) {
   String dirString = String.valueOf(numOfDir) + ".dir";
   String fileString = String.valueOf(numOfFile) + ".dat";
   File dbDir = tableDir.toPath().resolve(dirString).normalize().toFile();
   if (!dbDir.isDirectory()) {
     dbDir.mkdir();
   }
   File dbFile = dbDir.toPath().resolve(fileString).normalize().toFile();
   if (list[numOfDir][numOfFile].isEmpty()) {
     dbFile.delete();
     if (dbDir.list().length == 0) {
       dbDir.delete();
     }
     return;
   }
   RandomAccessFile db;
   try {
     db = new RandomAccessFile(dbFile, "rw");
     try {
       db.setLength(0);
       Iterator<Map.Entry<String, String>> it;
       it = list[numOfDir][numOfFile].entrySet().iterator();
       long[] pointers = new long[list[numOfDir][numOfFile].size()];
       int counter = 0;
       while (it.hasNext()) {
         Map.Entry<String, String> m = (Map.Entry<String, String>) it.next();
         String key = m.getKey();
         db.write(key.getBytes("UTF-8"));
         db.write("\0".getBytes("UTF-8"));
         pointers[counter] = db.getFilePointer();
         db.seek(pointers[counter] + 4);
         ++counter;
       }
       it = list[numOfDir][numOfFile].entrySet().iterator();
       counter = 0;
       while (it.hasNext()) {
         Map.Entry<String, String> m = (Map.Entry<String, String>) it.next();
         String value = m.getValue();
         int curPointer = (int) db.getFilePointer();
         db.seek(pointers[counter]);
         db.writeInt(curPointer);
         db.seek(curPointer);
         db.write(value.getBytes("UTF-8"));
         ++counter;
       }
     } catch (Exception e) {
       db.close();
       throw new Exception(e);
     }
     db.close();
     if (dbDir.list().length == 0) {
       dbDir.delete();
     }
   } catch (Exception e) {
     throw new IllegalArgumentException();
   }
 }
示例#27
0
 // This is a fail-safe wrapper around File.renameTo() since that can fail if the destination path
 // is on a
 // different file system or potentially for other causes which don't preclude other means of I/O.
 // renameTo() is the simplest and most efficient (and hopefully atomic) method, but we fall back
 // to the
 // more laborious byte-by-byte copy if it fails.
 public static void moveFile(java.io.File srcfile, java.io.File dstfile)
     throws java.io.IOException {
   if (srcfile.renameTo(dstfile)) {
     return;
   }
   java.nio.file.Path srcpath = srcfile.toPath();
   copyFile(srcpath, dstfile.toPath());
   deleteFile(srcpath);
 }
示例#28
0
 /**
  * Tries to move/rename a file from one path to another. Uses {@link java.nio.file.Files#move}
  * when available. Does not use {@link java.nio.file.StandardCopyOption#REPLACE_EXISTING} or any
  * other options. TODO candidate for moving to {@link Util}
  */
 static void move(File src, File dest) throws IOException {
   try {
     Files.move(src.toPath(), dest.toPath());
   } catch (IOException x) {
     throw x;
   } catch (Exception x) {
     throw new IOException(x);
   }
 }
  @Test
  public void should_copy_given_file_from_source_directory() throws Exception {
    write(source.toPath().resolve("pbButton.json"), "contents".getBytes());

    visitor.visitFile(source.toPath().resolve("pbButton.json"), null);

    assertThat(readAllBytes(destination.toPath().resolve("pbButton.json")))
        .isEqualTo("contents".getBytes());
  }
 public void addJarDependency(String location) throws IllegalArgumentException {
   File f = new File(location);
   if (!f.exists()) {
     throw new IllegalArgumentException(
         "File not found. Invalid "
             + "third party dependency location:"
             + f.toPath().toAbsolutePath().toString());
   }
   globalDependencies.add(f.toPath().toAbsolutePath());
 }