예제 #1
1
  public static void main(String[] args) {

    // create new file
    try {
      File file = new File("src/IOTasks/output/test.txt");
      if (file.createNewFile()) {
        System.out.println("File is created");
      } else {
        System.out.println("File already exisits");
      }
    } catch (IOException e) {
      e.printStackTrace();
    }

    // construct filepath
    try {
      String filename = "file.txt";
      String workingDirectory = System.getProperty("user.dir");

      // String absoluteFilePath = workingDirectory + File.separator + filename;
      // File file1 = new File(absoluteFilePath);

      File file1 = new File(workingDirectory, filename);
      file1.createNewFile();

      System.out.println("Final pathname : " + file1.getAbsolutePath());

      file1.setExecutable(false);
      file1.setReadOnly();

      if (file1.exists()) {
        System.out.println("executable : " + file1.canExecute());
        System.out.println("writable : " + file1.canWrite());
      }

      file1.setWritable(true);

      File file2 = new File("src/IOTasks/input/file.jpg");

      long lastModifiedTime = file2.lastModified();
      SimpleDateFormat sdf = new SimpleDateFormat("dd/MM/YYYY hh:mm:ss");
      System.out.println("Last modified : " + sdf.format(lastModifiedTime));

      String newLastModified = "31/01/2015 10:15:21";
      // convert to miliseconds in long
      Date newDate = sdf.parse(newLastModified);
      file2.setLastModified(newDate.getTime());

      long size = file2.length();
      System.out.println(size / 1024 + " kB");

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

    // get file size

  }
  @Override
  protected Boolean doInBackground(Void... params) {
    File ffmpegFile = new File(FileUtils.getFFmpeg(context));
    if (ffmpegFile.exists() && isDeviceFFmpegVersionOld() && !ffmpegFile.delete()) {
      return false;
    }
    if (!ffmpegFile.exists()) {
      boolean isFileCopied =
          FileUtils.copyBinaryFromAssetsToData(
              context,
              cpuArchNameFromAssets + File.separator + FileUtils.ffmpegFileName,
              FileUtils.ffmpegFileName);

      // make file executable
      if (isFileCopied) {
        if (!ffmpegFile.canExecute()) {
          Log.d("FFmpeg is not executable, trying to make it executable ...");
          if (ffmpegFile.setExecutable(true)) {
            return true;
          }
        } else {
          Log.d("FFmpeg is executable");
          return true;
        }
      }
    }
    return ffmpegFile.exists() && ffmpegFile.canExecute();
  }
예제 #3
0
  private void copyFile(String sourcePath, String absoluteTargetPath, ChannelSftp channelSftp)
      throws MachineException {
    try {
      channelSftp.put(sourcePath, absoluteTargetPath);

      // apply permissions
      File file = new File(sourcePath);
      // read
      int permissions = 256;
      // execute
      if (file.canExecute()) {
        permissions += 64;
      }
      // write
      if (file.canWrite()) {
        permissions += 128;
      }
      channelSftp.chmod(permissions, absoluteTargetPath);
    } catch (SftpException e) {
      throw new MachineException(
          format(
              "Sftp copying of file %s failed. Error: %s",
              absoluteTargetPath, e.getLocalizedMessage()));
    }
  }
예제 #4
0
  private void showFiles(File file) {
    TableItem tableItem = null;
    String fileName = null;
    String filePath = null;
    float fileSize = -1;
    String columns[] = new String[3];

    if (file.canRead() && file.canExecute() && file.isDirectory()) {
      File currentFile[] = file.listFiles();
      for (int i = 0; i < currentFile.length; i++) {
        if (currentFile[i].isFile()) {
          tableItem = new TableItem(table, SWT.NONE);
          fileName = currentFile[i].getName();
          filePath = currentFile[i].getPath();
          fileSize = currentFile[i].length();
          columns[0] = fileName;
          if (fileSize >= 512) {
            columns[1] = fileSize / 1024 + "KB";
          } else {
            columns[1] = fileSize + "Bytes";
          }
          columns[2] = filePath;
          tableItem.setText(columns);
          table.setLinesVisible(true);
        }
      }
    }
  }
  @Override
  public void initialize(
      @NotNull ManagingFS managingFS, @NotNull FileWatcherNotificationSink notificationSink) {
    myManagingFS = managingFS;
    myNotificationSink = notificationSink;

    boolean disabled = Boolean.parseBoolean(System.getProperty(PROPERTY_WATCHER_DISABLED));
    myExecutable = getExecutable();

    if (disabled) {
      LOG.info("Native file watcher is disabled");
    } else if (myExecutable == null) {
      LOG.info("Native file watcher is not supported on this platform");
    } else if (!myExecutable.exists()) {
      notifyOnFailure(ApplicationBundle.message("watcher.exe.not.found"), null);
    } else if (!myExecutable.canExecute()) {
      notifyOnFailure(
          ApplicationBundle.message("watcher.exe.not.exe", myExecutable),
          new NotificationListener() {
            @Override
            public void hyperlinkUpdate(
                @NotNull Notification notification, @NotNull HyperlinkEvent event) {
              ShowFilePathAction.openFile(myExecutable);
            }
          });
    } else {
      try {
        startupProcess(false);
        LOG.info("Native file watcher is operational.");
      } catch (IOException e) {
        LOG.warn(e.getMessage());
        notifyOnFailure(ApplicationBundle.message("watcher.failed.to.start"), null);
      }
    }
  }
 @Override
 public CommandRunner.CommandOutput runCommandAndWaitForExit(
     File workingDir, List<String> arguments) throws IOException, InterruptedException {
   File binary = new File(arguments.get(0));
   if (!binary.exists()) {
     logger.error("Binary {} does not exists, fix your configuration!", binary.getAbsolutePath());
     return createErrorCommandOutput();
   }
   if (!binary.canExecute()) {
     logger.error(
         "Binary {} can't be executed, fix your configuration!", binary.getAbsolutePath());
     return createErrorCommandOutput();
   }
   ProcessBuilder pb = new ProcessBuilder(arguments);
   pb.directory(workingDir);
   Process process = pb.start();
   ByteArrayOutputStream stderr = new ByteArrayOutputStream();
   ByteArrayOutputStream stdout = new ByteArrayOutputStream();
   CommandRunnerImpl.StreamGobbler sgerr =
       new CommandRunnerImpl.StreamGobbler(process.getErrorStream(), stderr);
   CommandRunnerImpl.StreamGobbler sgout =
       new CommandRunnerImpl.StreamGobbler(process.getInputStream(), stdout);
   sgerr.start();
   sgout.start();
   int exitCode = process.waitFor();
   sgerr.join();
   sgout.join();
   CommandRunner.CommandOutput result =
       new CommandRunner.CommandOutput(stdout.toByteArray(), stderr.toByteArray());
   result.setExitCode(exitCode);
   return result;
 }
예제 #7
0
 private boolean ffmpegIsCorrectlyInstalled() {
   File ffmpegTargetLocation = AndroidFFMPEGLocator.ffmpegTargetLocation();
   // assumed to be correct if existing and executable and larger than 1MB:
   return ffmpegTargetLocation.exists()
       && ffmpegTargetLocation.canExecute()
       && ffmpegTargetLocation.length() > 1000000;
 }
예제 #8
0
 @Override
 public String check() {
   LOGGER.info("Checking msmsEval worker");
   if (!msmsEvalExecutable.canExecute()) {
     return "msmsEval is not executable: " + msmsEvalExecutable.getAbsolutePath();
   }
   return null;
 }
예제 #9
0
 /**
  * Given a program name, lookup the fully qualified path. Throws an exception if the program is
  * missing or not authorized.
  *
  * @param path The path of the program.
  * @return The path of the validated program.
  */
 public String validateProgram(String path) throws NotAuthorizedException, IOException {
   File f = new File(path);
   if (f.canExecute()) {
     return f.getCanonicalPath();
   } else {
     throw new NotAuthorizedException("Unable to access program: " + path);
   }
 }
  /**
   * Ejecuta el script PowerShell para la generaci&oacute;n del almac&eacute;n de claves SSL.
   *
   * @param appConfigDir Directorio de configuraci&oacute;n de AutoFirma.
   * @param profilesDir Directorio de perfiles de Mozilla Firefox.
   * @throws IOException Cuando ocurre un error
   * @throws GeneralSecurityException Cuando ocurre un error en la inserci&oacute;n del certificado
   *     en el KeyStore.
   */
  private static void executeCertUtilToImport(final File appConfigDir, final File profilesDir)
      throws IOException, GeneralSecurityException {

    final File certutilFile = new File(appConfigDir, DIR_CERTUTIL + File.separator + CERTUTIL_EXE);

    if (!certutilFile.exists() || !certutilFile.isFile() || !certutilFile.canExecute()) {
      throw new IOException(
          "No se encuentra o no se puede leer el ejecutable para la instalacion en Firefox"); //$NON-NLS-1$
    }

    // Obtenemos todos los directorios de perfil de Firefox del usuario
    boolean error = false;
    for (final File profileDir : profilesDir.listFiles()) {
      if (!profileDir.isDirectory()) {
        continue;
      }

      final String[] certutilCommands =
          new String[] {
            certutilFile.getAbsolutePath(),
            "-A", //$NON-NLS-1$
            "-d", //$NON-NLS-1$
            profileDir.getAbsolutePath(),
            "-i", //$NON-NLS-1$
            new File(appConfigDir, FILE_AUTOFIRMA_CERTIFICATE).getAbsolutePath(),
            "-n", //$NON-NLS-1$
            "\"" + CERT_ALIAS + "\"", // $NON-NLS-1$ //$NON-NLS-2$
            "-t", //$NON-NLS-1$
            "\"C,,\"" //$NON-NLS-1$
          };

      final Process process = new ProcessBuilder(certutilCommands).start();

      // Cuando se instala correctamente no hay salida de ningun tipo, asi que se interpreta
      // cualquier salida como un error
      String line;
      try (final InputStream resIs = process.getInputStream();
          final BufferedReader resReader = new BufferedReader(new InputStreamReader(resIs)); ) {
        while ((line = resReader.readLine()) != null) {
          error = true;
          LOGGER.severe(line);
        }
      }

      try (final InputStream errIs = process.getErrorStream();
          final BufferedReader errReader = new BufferedReader(new InputStreamReader(errIs)); ) {
        while ((line = errReader.readLine()) != null) {
          error = true;
          LOGGER.severe(line);
        }
      }
    }

    if (error) {
      throw new KeyStoreException(
          "Error la instalacion del certificado de CA en alguno de los perfiles de usuario de Firefox"); //$NON-NLS-1$
    }
  }
예제 #11
0
 /**
  * Ensures that the File associated with this stub (if any) is in a writable location
  *
  * @param stub
  */
 protected <T> void validateOutputPath(final Stub<T> stub) {
   if (stub.getOutputFile() != null && !(IOUtils.isSpecialFile(stub.getOutputFile()))) {
     final File parentDir = stub.getOutputFile().getAbsoluteFile().getParentFile();
     if (!(parentDir.canWrite() && parentDir.canExecute()))
       throw new UserException.CouldNotCreateOutputFile(
           stub.getOutputFile(),
           "either the containing directory doesn't exist or it isn't writable");
   }
 }
 static boolean validatePath(String path) {
   if (path == null || path.isEmpty()) return true;
   try {
     File s = new File(path.trim());
     return s.isFile() && s.canExecute();
   } catch (Exception e) {
     return false;
   }
 }
예제 #13
0
 private static void checkBatFile() throws Exception {
   File batFile = new File(mainFrame.getBatFilePath());
   if (!batFile.exists())
     throw new Exception("Bat file does not exist (" + batFile.getAbsolutePath() + ")");
   if (!batFile.canExecute())
     throw new Exception(
         "[Linux] Bat file can not be executed - set it as application ("
             + batFile.getAbsolutePath()
             + ")");
 }
예제 #14
0
 /**
  * Constructor.
  *
  * @param needleApp String holding the path to the NEEDLE application.
  * @throws FileNotFoundException if NEEDLE application can not be found at given path or is not
  *     executable.
  */
 public Needle(final File needleApp) throws FileNotFoundException {
   if (!needleApp.exists()) {
     throw new FileNotFoundException(
         "ERROR: NEEDLE application does " + "not reside at " + needleApp.getAbsolutePath());
   } else if (!needleApp.canExecute()) {
     throw new FileNotFoundException("ERROR: NEEDLE application is " + "not executable!");
   } else {
     this.needle = needleApp;
   }
 }
예제 #15
0
  static String getAjavaCmd(String cmdStr) {
    File binDir = new File(JavaHome, "bin");
    File unpack200File = IsWindows ? new File(binDir, cmdStr + ".exe") : new File(binDir, cmdStr);

    String cmd = unpack200File.getAbsolutePath();
    if (!unpack200File.canExecute()) {
      throw new RuntimeException("please check" + cmd + " exists and is executable");
    }
    return cmd;
  }
예제 #16
0
 /**
  * Ensure that the dart VM is executable. If it is not, make it executable and log that it was
  * necessary for us to do so.
  */
 @DartBlockBody({})
 private void ensureVmIsExecutable() {
   File dartVm = getVmExecutable();
   if (dartVm != null) {
     if (!dartVm.canExecute()) {
       FileUtilities.makeExecutable(dartVm);
       AnalysisEngine.getInstance().getLogger().logError(dartVm.getPath() + " was not executable");
     }
   }
 }
 public void setGitBinaryPath(File gitBinaryPath) {
   if (!gitBinaryPath.exists()) {
     logger.warn("Path '" + gitBinaryPath + "' for GIT binary does not exist.");
   } else if (!gitBinaryPath.isFile()) {
     logger.warn("Path '" + gitBinaryPath + "' for GIT binary is not a file.");
   } else if (!gitBinaryPath.canExecute()) {
     logger.warn("Path '" + gitBinaryPath + "' for GIT binary is not executable.");
   } else {
     this.gitBinaryPath = gitBinaryPath;
   }
 }
 public static void checkReadableDirectory(File dir) throws IOException {
   if (dir == null) {
     Throw.ioe(TAG, "Directory object File is null.");
   } else {
     if (!dir.exists()) Throw.ioe(TAG, "Directory does not exist: " + dir.getAbsolutePath());
     if (!dir.isDirectory()) Throw.ioe(TAG, "Not a directory: " + dir.getAbsolutePath());
     if (!dir.canRead()) Throw.ioe(TAG, "No read permission: " + dir.getAbsolutePath());
     if (!dir.canExecute())
       Throw.ioe(TAG, "No execute (access files) permission: " + dir.getAbsolutePath());
   }
 }
 private void doDeleteJarFileTest(File file) {
   boolean b = file.delete();
   if (!b) {
     throw new SpagoBIPluginException(
         "Can't delete the file "
             + file.getAbsolutePath()
             + " the file is writtable? "
             + file.canWrite()
             + " "
             + file.canExecute());
   }
 }
예제 #20
0
 public JavaTask(String fullyQualifiedClassName, File startDir) throws RuntimeException {
   _className = fullyQualifiedClassName;
   _classpath = System.getProperty("java.class.path");
   _startDir = startDir;
   String javaHome = System.getProperty("java.home");
   File jvm = new File(javaHome, "bin/javaw.exe");
   if (jvm.canExecute()) {
     _jvm = jvm;
   } else {
     jvm = new File(javaHome, "bin/java.exe");
     if (jvm.canExecute()) {
       _jvm = jvm;
     } else {
       jvm = new File(javaHome, "bin/java");
       if (jvm.canExecute()) {
         _jvm = jvm;
       } else {
         throw new RuntimeException("Cannot find JVM");
       }
     }
   }
 }
  public OperaLauncherRunner(OperaSettings s) {
    super(s);

    // Locate the bundled launcher from OperaLaunchers project and copy it to its default location
    // on users system if it's not there or outdated
    URL bundledLauncher =
        OperaLaunchers.class.getClassLoader().getResource("launchers/" + LAUNCHER_NAME);

    if (bundledLauncher == null) {
      throw new OperaRunnerException("Not able to locate bundled launcher: " + bundledLauncher);
    }

    File launcher = settings.getLauncher();
    try {
      if (launcher.getCanonicalPath().equals(LAUNCHER_DEFAULT_LOCATION.getCanonicalPath())
          && (!launcher.exists() || isLauncherOutdated(launcher))) {
        extractLauncher(bundledLauncher, launcher);
      }
    } catch (IOException e) {
      throw new OperaRunnerException(e);
    }

    if (!launcher.canExecute()) {
      if (!launcher.setExecutable(true)) {
        throw new OperaRunnerException("Unable to make launcher executable: " + launcher.getPath());
      }
    }

    // Find a suitable Opera executable based on requested product if no binary has already been
    // specified
    if (settings.getBinary() == null) {
      // Do check for null here since OperaBinary's sanitization throws a cryptic null pointer
      File binary = OperaBinary.find(settings.getProduct());
      if (binary == null) {
        throw new OperaRunnerException(
            String.format("Unable to find executable for product %s", settings.getProduct()));
      }

      // Calls new OperaBinary(b) which will check that the binary is executable and that it's not a
      // directory
      settings.setBinary(binary);
    }

    // Create list of arguments for launcher binary
    arguments = buildArguments();
    logger.config("launcher arguments: " + arguments);

    init();
  }
예제 #22
0
  /**
   * @param binName the binary to look for (eg 'kudu-tserver')
   * @return the absolute path of that binary
   * @throws FileNotFoundException if no such binary is found
   */
  public static String findBinary(String binName) throws FileNotFoundException {
    String binDir = System.getProperty(BIN_DIR_PROP);
    if (binDir != null) {
      LOG.info("Using binary directory specified by property: {}", binDir);
    } else {
      binDir = findBuildDir();
    }

    File candidate = new File(binDir, binName);
    if (candidate.canExecute()) {
      return candidate.getAbsolutePath();
    }
    throw new FileNotFoundException(
        "Cannot find binary " + binName + " in binary directory " + binDir);
  }
예제 #23
0
  public static void createTree(TreeItem rootNode, File parent) {

    if (parent.isDirectory() && parent.canRead() && parent.canExecute()) {
      for (File file : parent.listFiles()) {
        if (file.isDirectory()) {
          TreeItem treeNode = new TreeItem(rootNode, SWT.CHECK);
          treeNode.setData(file);
          treeNode.setText(file.getName());

          System.out.println(file.getPath());
          createTree(treeNode, file);
        }
      }
    }
  }
예제 #24
0
파일: main.java 프로젝트: xearax/alue
  private static int dependencies() {
    String dependencies[] = {"trid", "7z", "unrtf"};
    int result = 0;

    for (int count = 0; count < dependencies.length; count++) {
      File test = new File(dependencies[count]);

      if (!(test.exists() && test.isFile() && test.canExecute())) {
        System.err.println(" Dependency check failed for: " + dependencies[count]);
        result = 2;
      }
    }

    return result;
  }
예제 #25
0
    protected TestSuite buildSuite() {
      TestSuite suite = new TestSuite("Shared Dart tests");

      if (!V8Launcher.isConfigured()) {
        return configurationProblem(
            suite, "Please set the system property com.google.dart.runner.d8");
      }

      File file = new File(listTests[0]);
      if (!file.canExecute()) {
        return configurationProblem(suite, file.getPath() + " is not executable");
      }
      ProcessBuilder builder = new ProcessBuilder(listTests);
      try {
        Process process = builder.start();
        InputStream inputStream = process.getInputStream();
        StringBuilder sb = new StringBuilder();
        try {
          InputStreamReader inputStreamReader = new InputStreamReader(inputStream);
          LineReader lineReader = new LineReader(inputStreamReader);
          String line;
          while ((line = lineReader.readLine()) != null) {
            if (!line.startsWith("dartc/")) {
              suite.addTest(SharedTestCase.getInstance(line, false));
            } else if (line.startsWith("dartc/client/")) {
              suite.addTest(SharedTestCase.getInstance(line, true));
            }
          }
        } finally {
          inputStream.close();
          process.getOutputStream().close();
          InputStreamReader inputStreamReader = new InputStreamReader(process.getErrorStream());
          CharStreams.copy(inputStreamReader, sb);
          process.getErrorStream().close();
        }
        process.waitFor();
        if (process.exitValue() != 0) {
          sb.insert(0, file.getPath());
          sb.insert(0, " returned non-zero exit code.\n");
          return configurationProblem(suite, sb.toString());
        }
      } catch (IOException e) {
        throw new AssertionError(e);
      } catch (InterruptedException e) {
        throw new AssertionError(e);
      }
      return suite;
    }
예제 #26
0
 public static void initializeCacheRoot(File cacheRoot) {
   if (CACHE_ROOT.compareAndSet(null, checkNotNull(cacheRoot))) {
     if (!cacheRoot.exists() && !cacheRoot.mkdirs()) {
       throw new SetUpException(
           "Failed to create required OSGI cache directory: " + cacheRoot.getAbsolutePath());
     }
     if (!cacheRoot.isDirectory()
         || !cacheRoot.canRead()
         || !cacheRoot.canWrite()
         || !cacheRoot.canExecute()) {
       throw new SetUpException(
           "Cannot access OSGI cache directory: " + cacheRoot.getAbsolutePath());
     }
     m_self = new ModuleManager(cacheRoot);
   }
 }
예제 #27
0
 /**
  * Computes the default Hadoop command path.
  *
  * @param environmentVariables the current environment variables
  * @return the detected command path, or {@code null} if the command path is not found
  * @since 0.6.0
  */
 public static File findHadoopCommand(Map<String, String> environmentVariables) {
   assert environmentVariables != null;
   File command = getExplicitHadoopCommand(environmentVariables);
   if (command != null) {
     return command;
   }
   File home = getExplicitHadoopDirectory(environmentVariables);
   if (home != null && home.isDirectory()) {
     command = new File(home, PATH_HADOOP_COMMAND);
   } else {
     command = findHadoopCommandFromPath(environmentVariables);
   }
   if (command == null || command.canExecute() == false) {
     return null;
   }
   return command;
 }
예제 #28
0
 public static String getBuildDirectoryPath() {
   String envPath = System.getenv("TEST_DIR");
   if (envPath != null) {
     File path = new File(envPath);
     path.mkdirs();
     if (!path.exists()
         || !path.isDirectory()
         || !path.canRead()
         || !path.canWrite()
         || !path.canExecute()) {
       throw new RuntimeException("Could not create test directory");
     }
     return envPath;
   } else {
     return ".";
   }
 }
 public void checkExecutePermissionForIOSDebugProxyLauncher() throws IOException {
   input = new FileInputStream("config.properties");
   prop.load(input);
   String serverPath = prop.getProperty("APPIUM_JS_PATH");
   File file = new File(serverPath);
   File curentPath = new File(file.getParent());
   System.out.println(curentPath);
   file = new File(curentPath + "/.." + "/..");
   File executePermission =
       new File(file.getCanonicalPath() + "/bin/ios-webkit-debug-proxy-launcher.js");
   if (executePermission.exists()) {
     if (executePermission.canExecute() == false) {
       executePermission.setExecutable(true);
       System.out.println("Access Granted for iOSWebKitProxyLauncher");
     } else {
       System.out.println("iOSWebKitProxyLauncher File already has access to execute");
     }
   }
 }
예제 #30
0
  /**
   * Return an empty string if short circuit read is properly enabled. If not, return an error
   * string describing the issues.
   */
  private String checkShortCircuitRead(Configuration conf) {
    StringBuilder output = new StringBuilder();
    String errorMessage = "ERROR: short-circuit local reads is disabled because\n";
    String prefix = "  - ";
    StringBuilder errorCause = new StringBuilder();

    // dfs.domain.socket.path must be set properly
    String domainSocketPath =
        conf.getTrimmed(
            DFSConfigKeys.DFS_DOMAIN_SOCKET_PATH_KEY, DFSConfigKeys.DFS_DOMAIN_SOCKET_PATH_DEFAULT);
    if (domainSocketPath.isEmpty()) {
      errorCause.append(prefix);
      errorCause.append(DFSConfigKeys.DFS_DOMAIN_SOCKET_PATH_KEY);
      errorCause.append(" is not configured.\n");
    } else {
      // The socket path parent directory must be readable and executable.
      File socketFile = new File(domainSocketPath);
      File socketDir = socketFile.getParentFile();
      if (socketDir == null || !socketDir.canRead() || !socketDir.canExecute()) {
        errorCause.append(prefix);
        errorCause.append("Impala cannot read or execute the parent directory of ");
        errorCause.append(DFSConfigKeys.DFS_DOMAIN_SOCKET_PATH_KEY);
        errorCause.append("\n");
      }
    }

    // dfs.client.read.shortcircuit must be set to true.
    if (!conf.getBoolean(
        DFSConfigKeys.DFS_CLIENT_READ_SHORTCIRCUIT_KEY,
        DFSConfigKeys.DFS_CLIENT_READ_SHORTCIRCUIT_DEFAULT)) {
      errorCause.append(prefix);
      errorCause.append(DFSConfigKeys.DFS_CLIENT_READ_SHORTCIRCUIT_KEY);
      errorCause.append(" is not enabled.\n");
    }

    if (errorCause.length() > 0) {
      output.append(errorMessage);
      output.append(errorCause);
    }

    return output.toString();
  }