/**
   * Because we're running with a security manager (most likely), we need to scan for Lingo3G
   * license in ES configuration directories.
   */
  private Path scanForLingo3GLicense(Environment environment, Path pluginConfigPath) {
    List<Path> licenses = new ArrayList<>();

    for (Path candidate :
        new Path[] {
          pluginConfigPath.resolve("license.xml"),
          pluginConfigPath.resolve(".license.xml"),
          environment.configFile().resolve("license.xml"),
          environment.configFile().resolve(".license.xml")
        }) {
      logger.debug(
          "Lingo3G license location scan: {} {}.",
          candidate.toAbsolutePath().normalize(),
          Files.isRegularFile(candidate) ? "(found)" : "(not found)");
      if (Files.isRegularFile(candidate)) {
        licenses.add(candidate);
      }
    }

    if (licenses.size() > 1) {
      throw new ElasticsearchException(
          "There should be exactly one Lingo3G license on scan paths: {}", licenses);
    }

    if (licenses.size() == 1) {
      return licenses.iterator().next();
    } else {
      return null;
    }
  }
 /**
  * Execute a single filesystem test against the given path.
  *
  * @param path The {@code Path} to test
  * @param test The character code of the test to perform.
  * @return {@code null} if the test passes, or a {@code FileSystemTestFailure} if it fails.
  */
 protected static FileSystemTestFailure testPath(final Path path, char test) {
   switch (test) {
     case 'e':
       return (Files.exists(path))
           ? null
           : new FileSystemTestFailure(path, test, "The path does not exist");
     case 'f':
       return (Files.isRegularFile(path))
           ? null
           : new FileSystemTestFailure(path, test, "The path is not a file");
     case 'd':
       return (Files.isDirectory(path))
           ? null
           : new FileSystemTestFailure(path, test, "The path is not a directory");
     case 'z':
       try {
         if (!Files.isRegularFile(path))
           return new FileSystemTestFailure(path, test, "The path is not a file");
         return (Files.size(path) < 1)
             ? null
             : new FileSystemTestFailure(path, test, "The path is not zero length");
       } catch (IOException ioe) {
         return new FileSystemTestFailure(path, test, "The path could not be read");
       }
     case 's':
       try {
         if (!Files.isRegularFile(path))
           return new FileSystemTestFailure(path, test, "The path is not a file");
         return (Files.size(path) > 0)
             ? null
             : new FileSystemTestFailure(path, test, "The path is a zero length file");
       } catch (IOException ioe) {
         return new FileSystemTestFailure(path, test, "The path could not be read");
       }
     case 'r':
       return (Files.isReadable(path))
           ? null
           : new FileSystemTestFailure(path, test, "The path is not readable");
     case 'w':
       return (Files.isWritable(path))
           ? null
           : new FileSystemTestFailure(path, test, "The path is not writable");
     case 'x':
       return (Files.isExecutable(path))
           ? null
           : new FileSystemTestFailure(path, test, "The path is not executable");
     default:
       throw new IllegalArgumentException("Unrecognized path test: " + test);
   }
 }
Beispiel #3
0
  private static Stream<String> apps() {
    if (cl instanceof URLClassLoader) {
      URLClassLoader ucl = (URLClassLoader) cl;

      return Stream.of(ucl.getURLs())
          .map(propagating(url -> Paths.get(url.toURI())))
          .flatMap(
              propagating(
                  path -> {
                    if (Files.isRegularFile(path)) {
                      return zipContents(path);
                    } else if (Files.isDirectory(path)) {
                      return Files.walk(path)
                          .map(subpath -> path.relativize(subpath))
                          .map(subpath -> subpath.toString())
                          .filter(subpath -> subpath.endsWith(".class"))
                          .map(Scanner::toClassName);
                    } else {
                      return Stream.empty();
                    }
                  }))
          .filter(x -> !x.startsWith("com.cakemanny.app."))
          .filter(implementsInterface(App.class));
    } else {
      return Stream.empty();
    }
  }
 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));
 }
Beispiel #5
0
 public long getFileSize(Path pathRelativeToProjectRoot) throws IOException {
   Path path = getPathForRelativePath(pathRelativeToProjectRoot);
   if (!Files.isRegularFile(path)) {
     throw new IOException("Cannot get size of " + path + " because it is not an ordinary file.");
   }
   return Files.size(path);
 }
  @Test
  public void testScanOSGiLog() throws IOException {
    StringBundler sb = new StringBundler();

    try (DirectoryStream<Path> directoryStream =
        Files.newDirectoryStream(Paths.get(System.getProperty("osgi.state.dir")), "*.log")) {

      for (Path path : directoryStream) {
        if (!Files.isRegularFile(path)) {
          continue;
        }

        sb.append("\nPortal log assert failure, OSGi log found: ");
        sb.append(path);
        sb.append(StringPool.COLON);
        sb.append(StringPool.NEW_LINE);
        sb.append(new String(Files.readAllBytes(path), Charset.defaultCharset()));
        sb.append(StringPool.NEW_LINE);
      }
    }

    if (sb.index() != 0) {
      Assert.fail(sb.toString());
    }
  }
 /**
  * Berechnet initial einen Hashwert über alle Dateien innerhalb des überwachten Ordners und
  * speichert diesen in der Datenbank. Ist der Eintrag vorhanden, so wird nur der Hashwert und das
  * Datum geupdated, ansonsten ein neuer Eintrag angelegt
  *
  * @param path
  * @param importance
  */
 public Folder(Path path, Controller.Importance importance) {
   this.path = path;
   this.importance = importance;
   fileList(path.toString());
   for (Path p : files) {
     try {
       // Hashwert berechnen und überprüfen ob Datei bereits
       // in Datenbank ist
       pstmt = connect.prepareStatement("SELECT * FROM hashwerte WHERE File LIKE '" + p + "';");
       rs = pstmt.executeQuery();
       if (Files.isRegularFile(p) == true) {
         if (!rs.next()) {
           insertInto(p, importance);
         } else {
           update(p, importance);
         }
       }
     } catch (Exception ex) {
       Logger.getLogger(Folder.class.getName()).log(Level.SEVERE, null, ex);
     }
     try {
       rs.close();
       pstmt.close();
     } catch (SQLException ex) {
       Logger.getLogger(Folder.class.getName()).log(Level.SEVERE, null, ex);
     }
   }
 }
Beispiel #8
0
  private void initConfig() {
    if (Files.isRegularFile(Config.getConfigFile())) {
      try {
        config = Config.load(Config.getConfigFile());
      } catch (IOException e) {
        logger.error("Failed to load config", e);
        config = new Config();
      }
    } else {
      config = new Config();
    }
    if (!config.getDefaultModSelection().hasModule(TerasologyConstants.CORE_GAMEPLAY_MODULE)) {
      config.getDefaultModSelection().addModule(TerasologyConstants.CORE_GAMEPLAY_MODULE);
    }

    if (!validateServerIdentity()) {
      CertificateGenerator generator = new CertificateGenerator();
      CertificatePair serverIdentity = generator.generateSelfSigned();
      config
          .getSecurity()
          .setServerCredentials(serverIdentity.getPublicCert(), serverIdentity.getPrivateCert());
      config.save();
    }

    renderingConfig = config.getRendering();
    logger.info("Video Settings: " + renderingConfig.toString());
    CoreRegistry.putPermanently(Config.class, config);
  }
  public static Collection<ProfileDef> getAvailableProfiles(Path rootDir) {
    Path profileDir = getProfileDirectory(rootDir);
    if (!Files.isDirectory(profileDir)) {
      return Collections.emptySet();
    }

    List<ProfileDef> result = new LinkedList<>();
    try (DirectoryStream<Path> profileDirContent = Files.newDirectoryStream(profileDir)) {
      int suffixLength = PROFILE_FILE_NAME_SUFFIX.length();
      for (Path file : profileDirContent) {
        if (!Files.isRegularFile(file)) {
          continue;
        }

        String fileName = file.getFileName().toString();
        String normFileName = fileName.toLowerCase(Locale.ROOT);
        if (!normFileName.endsWith(PROFILE_FILE_NAME_SUFFIX)) {
          continue;
        }

        // This should hold, but check it just in case I don't know
        // something about weird case issues.
        if (fileName.length() >= suffixLength) {
          String profileName = fileName.substring(0, fileName.length() - suffixLength);
          result.add(new ProfileDef(null, fileName, profileName));
        }
      }
    } catch (IOException ex) {
      LOGGER.log(Level.INFO, "Cannot list profile directory: " + profileDir, ex);
    }
    return result;
  }
 public PathContentProvider(Path filePath, int bufferSize) throws IOException {
   if (!Files.isRegularFile(filePath)) throw new NoSuchFileException(filePath.toString());
   if (!Files.isReadable(filePath)) throw new AccessDeniedException(filePath.toString());
   this.filePath = filePath;
   this.fileSize = Files.size(filePath);
   this.bufferSize = bufferSize;
 }
  /** Must be called or paths will not generate */
  public static void initialize() {
    // By default, the path should be the code location (where JVE.jar is)
    getInstance();
    try {
      URL urlToSource = PathManager.class.getProtectionDomain().getCodeSource().getLocation();

      codeLocation = Paths.get(urlToSource.toURI());
      //            System.out.println("codeLocation: " + codeLocation);
      if (Files.isRegularFile(codeLocation)) {
        location = codeLocation.getParent().getParent();
        //                System.out.println("Running from a file (jar). Setting installPath to: " +
        // installPath);
      }
    } catch (URISyntaxException e) {
      // Can't use logger, because logger not set up when PathManager is used.
      //            System.out.println("Failed to convert code location to uri");
    }
    // If terasology.jar's location could not be resolved (maybe running from an IDE) then fallback
    // on working path
    if (location == null) {
      location = Paths.get("").toAbsolutePath();
      //            System.out.println("installPath was null, running from IDE. Setting it to: " +
      // installPath);
    }

    logger = LoggerFactory.getLogger(PathManager.class);

    logger.info("Location: " + getLocationPath() + "/");
  }
  public static void main(String[] args) {
    try {
      File[] files =
          new File(Paths.get("/Users/AriApar/Dropbox", "results").toString())
              .listFiles(
                  new FilenameFilter() {
                    @Override
                    public boolean accept(File dir, String name) {
                      return (name.contains("2x")
                          || name.contains("3x")
                          || name.contains("4x")
                          || name.contains("5x")
                          || name.contains("6x")
                          || name.contains("7x")
                          || name.contains("8x"));
                    }
                  });

      for (File f : files) {
        Path filePath = f.toPath();
        File resFile =
            new File(
                Paths.get("/Users/AriApar/Documents", "lazy_wo_cost", "results", f.getName())
                    .toString());
        if (Files.isRegularFile(filePath) && resFile.exists() && !resFile.isDirectory()) {
          if (!matchesWinners(f, resFile))
            System.out.println("Winners for " + f.getName() + " doesn't match");
        }
      }
    } catch (Exception e) {
      e.printStackTrace();
    }
  }
Beispiel #13
0
 public int run() throws IOException {
   try {
     int b = in.read();
     if (b != -1) {
       dOut.write(b);
       size++;
       return 1;
     } else {
       dOut.close();
       tmpOut.close();
       LongObjectId loid = LongObjectId.fromRaw(dOut.getMessageDigest().digest());
       Path mediaFile = lfsUtil.getMediaFile(loid);
       if (Files.isRegularFile(mediaFile)) {
         long fsSize = Files.size(mediaFile);
         if (fsSize != size) {
           throw new CorruptMediaFile(mediaFile, size, fsSize);
         }
       } else {
         FileUtils.mkdirs(mediaFile.getParent().toFile(), true);
         FileUtils.rename(tmpFile.toFile(), mediaFile.toFile());
       }
       LfsPointer lfsPointer = new LfsPointer(loid, size);
       lfsPointer.encode(out);
       out.close();
       return -1;
     }
   } catch (IOException e) {
     out.close();
     dOut.close();
     tmpOut.close();
     throw e;
   }
 }
Beispiel #14
0
  @GET
  @javax.ws.rs.Path("/overview")
  @NoCache
  public Response getAtonOverviewIcon(@Context HttpServletRequest request) throws Exception {

    long t0 = System.currentTimeMillis();

    String type = request.getParameter("seamark:type");
    if (StringUtils.isBlank(type)) {
      return Response.temporaryRedirect(new URI("/img/aton/aton.png")).build();
    }

    // Prepare an AtoN to use as a template for icon construction
    AtonNode aton = new AtonNode();

    // Construct a repository path to the icon
    Path path = repositoryService.getRepoRoot().resolve(OVERVIEW_ICON_REPO);

    path = addParam(aton, path, request, "seamark:type");
    path = addParam(aton, path, request, "seamark:" + type + ":category");
    path = addParam(aton, path, request, "seamark:" + type + ":shape");
    path = addParam(aton, path, request, "seamark:" + type + ":colour");
    path = addParam(aton, path, request, "seamark:" + type + ":colour_pattern");
    path = addParam(aton, path, request, "seamark:topmark:shape");
    path = addParam(aton, path, request, "seamark:topmark:colour");
    path = addParam(aton, path, request, "seamark:light:character");
    path = addParam(aton, path, request, "seamark:light:colour");

    // And the actual icon file
    path = path.resolve("aton_icon_" + OVERVIEW_ICON_WIDTH + "x" + OVERVIEW_ICON_HEIGHT + ".png");

    if (!Files.isRegularFile(path)) {
      checkCreateParentDirs(path);

      try (FileOutputStream out = new FileOutputStream(path.toFile())) {
        AtonIconRenderer.renderIcon(
            aton.toVo(),
            "png",
            out,
            OVERVIEW_ICON_WIDTH, // width
            OVERVIEW_ICON_HEIGHT, // height
            OVERVIEW_ICON_WIDTH / 3, // x
            2 * OVERVIEW_ICON_HEIGHT / 3, // y
            OVERVIEW_ICON_SCALE // scale
            );

        log.trace(
            "Generated AtoN PNG " + path + " in " + (System.currentTimeMillis() - t0) + " ms");
      }
    }

    // Redirect to the icon
    String iconUri = repositoryService.getRepoUri(path);
    return Response.temporaryRedirect(new URI("../" + iconUri)).build();
  }
Beispiel #15
0
  public static Config createDefaultConfig(
      Path root, ImmutableMap<String, ImmutableMap<String, String>> configOverrides)
      throws IOException {
    ImmutableList.Builder<Path> configFileBuilder = ImmutableList.builder();

    configFileBuilder.addAll(listFiles(GLOBAL_BUCK_CONFIG_DIRECTORY_PATH));
    if (Files.isRegularFile(GLOBAL_BUCK_CONFIG_FILE_PATH)) {
      configFileBuilder.add(GLOBAL_BUCK_CONFIG_FILE_PATH);
    }

    Path homeDirectory = Paths.get(System.getProperty("user.home"));
    Path userConfigDir = homeDirectory.resolve(DEFAULT_BUCK_CONFIG_DIRECTORY_NAME);
    configFileBuilder.addAll(listFiles(userConfigDir));
    Path userConfigFile = homeDirectory.resolve(DEFAULT_BUCK_CONFIG_FILE_NAME);
    if (Files.isRegularFile(userConfigFile)) {
      configFileBuilder.add(userConfigFile);
    }

    Path configFile = root.resolve(DEFAULT_BUCK_CONFIG_FILE_NAME);
    if (Files.isRegularFile(configFile)) {
      configFileBuilder.add(configFile);
    }
    Path overrideConfigFile = root.resolve(DEFAULT_BUCK_CONFIG_OVERRIDE_FILE_NAME);
    if (Files.isRegularFile(overrideConfigFile)) {
      configFileBuilder.add(overrideConfigFile);
    }

    ImmutableList<Path> configFiles = configFileBuilder.build();

    ImmutableList.Builder<ImmutableMap<String, ImmutableMap<String, String>>> builder =
        ImmutableList.builder();
    for (Path file : configFiles) {
      try (Reader reader = Files.newBufferedReader(file, StandardCharsets.UTF_8)) {
        ImmutableMap<String, ImmutableMap<String, String>> parsedConfiguration = Inis.read(reader);
        LOG.debug("Loaded a configuration file %s: %s", file, parsedConfiguration);
        builder.add(parsedConfiguration);
      }
    }
    LOG.debug("Adding configuration overrides: %s", configOverrides);
    builder.add(configOverrides);
    return new Config(builder.build());
  }
  /** Validate that the report pages were generated correctly */
  private void validateReports(GraphContext context) {
    ReportService reportService = new ReportService(context);
    ReportModel reportModel = getMainApplicationReport(context);
    Path appReportPath =
        Paths.get(reportService.getReportDirectory(), reportModel.getReportFilename());

    TestJavaApplicationOverviewUtil util = new TestJavaApplicationOverviewUtil();
    util.loadPage(appReportPath);
    util.checkFilePathAndTag("src_example", "src/main/resources/test.properties", "Properties");
    util.checkFilePathAndTag("src_example", "src/main/resources/WEB-INF/web.xml", "Web XML 3.0");
    util.checkFilePathAndTag(
        "src_example", "src/main/resources/WEB-INF/web.xml", "TestTag2"); // WINDUP-679
    util.checkFilePathAndIssues(
        "src_example",
        "org.windup.examples.servlet.SampleServlet",
        "References annotation 'javax.servlet.annotation.WebServlet'");
    util.checkFilePathAndIssues("src_example", "src/main/resources/WEB-INF/web.xml", "Container");
    util.checkFilePathAndIssues(
        "src_example", "src/main/resources/WEB-INF/web.xml", "Title for Hint from XML");
    util.checkFilePathAndIssues(
        "src_example", "src/main/resources/WEB-INF/web.xml", "title from user script");

    util.checkFilePathAndIssues(
        "src_example",
        "org.windup.examples.servlet.SampleServlet",
        "javax.servlet.http.HttpServletRequest usage");

    XsltTransformationService xsltService = new XsltTransformationService(context);
    Assert.assertTrue(
        Files.isRegularFile(
            xsltService.getTransformedXSLTPath().resolve("web-xml-converted-example.xml")));
    Assert.assertTrue(
        Files.isRegularFile(
            xsltService
                .getTransformedXSLTPath()
                .resolve("web-xmluserscript-converted-example.xml")));

    validateSpringBeanReport(context);
    validateEJBReport(context);
    validateJPAReport(context);
    validateMigrationIssuesReport(context);
  }
Beispiel #17
0
  private void onNewPath(Path path) throws IOException {
    if (Files.isHidden(path)) {
      return;
    }

    if (Files.isRegularFile(path)) {
      onNewFile(path);
    } else {
      onNewDirectory(path);
    }
  }
  @Test
  public void whenBuckBuiltTwiceLogIsPresent() throws IOException, InterruptedException {
    AssumeAndroidPlatform.assumeSdkIsAvailable();
    final ProjectWorkspace workspace =
        TestDataHelper.createProjectWorkspaceForScenario(this, "file_watching", tmp);
    workspace.setUp();

    workspace.runBuckdCommand("build", "//java/com/example/activity:activity").assertSuccess();

    Path buildLogFile = workspace.getPath("buck-out/bin/build.log");

    assertTrue(Files.isRegularFile(buildLogFile));
    Files.delete(buildLogFile);

    ProcessResult rebuild =
        workspace.runBuckdCommand("build", "//java/com/example/activity:activity");
    rebuild.assertSuccess();

    buildLogFile = workspace.getPath("buck-out/bin/build.log");
    assertTrue(Files.isRegularFile(buildLogFile));
  }
Beispiel #19
0
  static boolean isZip(Path path) {
    if (!Files.isRegularFile(path)) {
      return false;
    }

    try (ZipFile ignored = new ZipFile(path.toFile())) {
      return true;
    } catch (IOException ignored) {
      // Probably not a JAR file.
      return false;
    }
  }
 // Set type of file as name of the element
 private void setType(Element element, Path path) {
   if (Files.isDirectory(path)) {
     element.setLocalName(FileType.DIR.getName());
     return;
   } else if (Files.isRegularFile(path)) {
     element.setLocalName(FileType.FILE.getName());
     return;
   } else if (Files.isSymbolicLink(path)) {
     element.setLocalName(FileType.SYMLINK.getName());
     return;
   } else element.setLocalName(FileType.OTHER.getName());
 }
  @Test
  public void testFullClass() throws IOException {
    Path path =
        Paths.get("src/test/java/com/carrotsearch/hppc/generator/parser/KTypeVTypeClass.java");
    // Path path =
    // Paths.get("c:\\carrot2\\gh.carrotsearch\\hppc\\hppc\\src\\main\\templates\\com\\carrotsearch\\hppc\\KTypeArrayDeque.java");

    Assume.assumeTrue(Files.isRegularFile(path));
    SignatureProcessor sp =
        new SignatureProcessor(new String(Files.readAllBytes(path), StandardCharsets.UTF_8));
    System.out.println(sp.process(new TemplateOptions(Type.LONG, Type.GENERIC)));
  }
 private String loadApplicationKey() throws IOException {
   final Path configFile = Paths.get("settings.properties"); // NOI18N.
   assertTrue(Files.exists(configFile));
   assertTrue(Files.isRegularFile(configFile));
   assertTrue(Files.isReadable(configFile));
   final Properties settings = new Properties();
   try (final InputStream input = Files.newInputStream(configFile)) {
     settings.load(input);
   }
   final String appKey = settings.getProperty("app.key"); // NOI18N.
   assertNotNull(appKey);
   return appKey;
 }
Beispiel #23
0
  Cache(String d) throws IOException {
    root = fs.getPath(d);
    assert Files.isDirectory(root);

    notesdb = root.resolve("notes.db");
    assert Files.isRegularFile(notesdb) : "notes.db isn't exist";

    supportSapComNotes = root.resolve("support-sap-com-notes");
    if (!Files.exists(supportSapComNotes)) Files.createDirectory(supportSapComNotes);

    launchpad = root.resolve("launchpad");
    if (!Files.exists(launchpad)) Files.createDirectory(launchpad);
  }
Beispiel #24
0
 /**
  * Attempts to read or write data from or to a file.
  *
  * <p>If the file is found to be missing or the reset parameter is set to true, the file will be
  * written with the default data, and the default data will be returned.
  *
  * <p>If the file is found to be a regular, readable file, the file is read in, and its contents
  * returned.
  *
  * <p>If the method runs into an error while attempting any of this, a message is printed to the
  * log, and the default data is returned.
  *
  * @param directory the directory the file is in.
  * @param fileName the name of the file, without the .txt ending.
  * @param defaultData the data to write to the file, or default to.
  * @param reset if the file should be overwritten with the default data.
  * @return the data contained in the file, or the default data.
  */
 public static String readOrWrite(
     String directory, String fileName, String defaultData, boolean reset) {
   Path path = Paths.get(directory, fileName + ".txt");
   try {
     if (Files.isRegularFile(path) && !reset) {
       return new String(Files.readAllBytes(path));
     } else {
       Files.write(path, defaultData.getBytes());
     }
   } catch (IOException e) {
     LogHelper.info("Caught IOException when reading " + path.getFileName());
   }
   return defaultData;
 }
Beispiel #25
0
  @Test
  public void testUploadFile() throws FileNotFoundException {
    InputStream stream = new FileInputStream("/opt/digiverso/junit/data/metadata.xml");
    Part file = new MockUploadedFile(stream, "./some/path\\junit.xml");
    MassImportForm massImportForm = new MassImportForm();
    assertNotNull(massImportForm);
    massImportForm.setTemplate(template);

    massImportForm.setUploadedFile(file);
    massImportForm.uploadFile();

    Path dest = Paths.get(ConfigurationHelper.getInstance().getTemporaryFolder(), "junit.xml");
    assertTrue(Files.exists(dest) && Files.isRegularFile(dest));
  }
 // Returns the backup file of the specified resource entry if available or null.
 // A backup file is either a *.bak file or a biffed file which has been overridden.
 private static Path getBackupFile(ResourceEntry entry) {
   Path file = getCurrentFile(entry);
   if (entry instanceof FileResourceEntry
       || (entry instanceof BIFFResourceEntry && entry.hasOverride())) {
     if (file != null) {
       Path bakFile = file.getParent().resolve(file.getFileName().toString() + ".bak");
       if (Files.isRegularFile(bakFile)) {
         return bakFile;
       }
     }
   } else if (entry instanceof BIFFResourceEntry) {
     return file;
   }
   return null;
 }
Beispiel #27
0
 private Optional<String> readFileIfItExists(Path fileToRead, String pathRelativeToProjectRoot) {
   if (Files.isRegularFile(fileToRead)) {
     String contents;
     try {
       contents = new String(Files.readAllBytes(fileToRead), Charsets.UTF_8);
     } catch (IOException e) {
       // Alternatively, we could return Optional.absent(), though something seems suspicious if we
       // have already verified that fileToRead is a file and then we cannot read it.
       throw new RuntimeException("Error reading " + pathRelativeToProjectRoot, e);
     }
     return Optional.of(contents);
   } else {
     return Optional.absent();
   }
 }
Beispiel #28
0
 /**
  * Attempts to open the file for future read access. Returns {@link Optional#absent()} if the file
  * does not exist.
  */
 public Optional<Reader> getReaderIfFileExists(Path pathRelativeToProjectRoot) {
   Path fileToRead = getPathForRelativePath(pathRelativeToProjectRoot);
   if (Files.isRegularFile(fileToRead)) {
     try {
       return Optional.of(
           (Reader)
               new BufferedReader(
                   new InputStreamReader(newFileInputStream(pathRelativeToProjectRoot))));
     } catch (Exception e) {
       throw new RuntimeException("Error reading " + pathRelativeToProjectRoot, e);
     }
   } else {
     return Optional.absent();
   }
 }
 // Returns an unoccupied filename based on 'file'.
 private static Path getTempFile(Path file) {
   Path retVal = null;
   if (file != null && Files.isRegularFile(file)) {
     final String fmt = ".%03d";
     Path filePath = file.getParent();
     String fileName = file.getFileName().toString();
     for (int i = 0; i < 1000; i++) {
       Path tmp = filePath.resolve(fileName + String.format(fmt, i));
       if (!Files.exists(tmp) && Files.notExists(tmp)) {
         retVal = tmp;
         break;
       }
     }
   }
   return retVal;
 }
Beispiel #30
0
 /**
  * @param root
  * @param visitor
  * @param maxDepth
  */
 public void browse(File root, Visitor visitor, int maxDepth) {
   try {
     Files.walk(root.toPath(), maxDepth)
         .forEach(
             path -> {
               if (Files.isDirectory(path)) {
                 visitor.doFolder();
               } else if (Files.isRegularFile(path)) {
                 visitor.doFile();
               } else {
                 visitor.doOther();
               }
             });
   } catch (Exception e) {
     e.printStackTrace();
   }
 }