Exemple #1
1
  /**
   * Return the value for a given name from the System Properties or the Environmental Variables.
   * The former overrides the latter.
   *
   * @param name - the name of the System Property or Environmental Variable
   * @return the value of the variable or null if it was not found
   */
  public static String getEnvOrProp(String name) {
    // System properties override env. variables
    String envVal = System.getenv(name);
    String sysPropVal = System.getProperty(name);

    if (sysPropVal != null) return sysPropVal;

    return envVal;
  }
Exemple #2
0
  public LocalFileSpy() {
    username = System.getenv("USER");
    if (username == null) username = System.getenv("USERNAME");
    if (username == null) username = "******";

    // init path of the logfile
    String jlmDirPath = getJLMPropertiesDir();
    if (jlmDirPath != null) filePath = jlmDirPath + "/progress.spy";
  }
 private String getEditor() {
   // if we have editor in the system properties, it should
   // override the env so we check that first
   String editor = System.getProperty("EDITOR");
   if (org.apache.commons.lang3.StringUtils.isEmpty(editor)) {
     editor = System.getenv().get("EDITOR");
   }
   if (org.apache.commons.lang3.StringUtils.isEmpty(editor)) {
     editor = System.getenv("VISUAL");
   }
   if (org.apache.commons.lang3.StringUtils.isEmpty(editor)) {
     editor = "/bin/vi";
   }
   return editor;
 }
  @BeforeMethod
  protected void setUp(final Method testMethod) throws Exception {
    // setting hg executable
    String exec = System.getenv(HG_EXECUTABLE_PATH);
    if (exec != null) {
      myClientBinaryPath = new File(exec);
    }
    if (exec == null || !myClientBinaryPath.exists()) {
      final File pluginRoot = new File(PluginPathManager.getPluginHomePath(HgVcs.VCS_NAME));
      myClientBinaryPath = new File(pluginRoot, "testData/bin");
    }
    HgVcs.setTestHgExecutablePath(myClientBinaryPath.getPath());

    myMainRepo = initRepositories();
    myProjectDir = new File(myMainRepo.getDirFixture().getTempDirPath());

    UIUtil.invokeAndWaitIfNeeded(
        new Runnable() {
          @Override
          public void run() {
            try {
              initProject(myProjectDir, testMethod.getName());
              activateVCS(HgVcs.VCS_NAME);
            } catch (Exception e) {
              e.printStackTrace();
            }
          }
        });

    myChangeListManager = new HgTestChangeListManager(myProject);
    myTraceClient = true;
    doActionSilently(VcsConfiguration.StandardConfirmation.ADD);
    doActionSilently(VcsConfiguration.StandardConfirmation.REMOVE);
  }
  private static File getHumanMediaTypeMappingsFile() throws RegistryException {

    String carbonHome = System.getProperty("carbon.home");

    if (carbonHome == null) {
      carbonHome = System.getenv("CARBON_HOME");
    }

    if (carbonHome != null) {

      File mediaTypesFile =
          new File(
              CarbonUtils.getEtcCarbonConfigDirPath(), HUMAN_READABLE_MEDIA_TYPE_MAPPINGS_FILE);
      if (!mediaTypesFile.exists()) {
        String msg =
            "Resource human readable media type mappings file (mime.mappings) file does "
                + "not exist in the path "
                + CarbonUtils.getEtcCarbonConfigDirPath();
        log.error(msg);
        throw new RegistryException(msg);
      }

      return mediaTypesFile;

    } else {
      String msg =
          "carbon.home system property is not set. It is required to to derive "
              + "the path of the media type definitions file (mime.types).";
      log.error(msg);
      throw new RegistryException(msg);
    }
  }
Exemple #6
0
  private void setSvnCredential(CIJob job) throws JDOMException, IOException {
    S_LOGGER.debug("Entering Method CIManagerImpl.setSvnCredential");
    try {
      String jenkinsTemplateDir = Utility.getJenkinsTemplateDir();
      String credentialFilePath = jenkinsTemplateDir + job.getRepoType() + HYPHEN + CREDENTIAL_XML;
      if (debugEnabled) {
        S_LOGGER.debug("credentialFilePath ... " + credentialFilePath);
      }
      File credentialFile = new File(credentialFilePath);

      SvnProcessor processor = new SvnProcessor(credentialFile);

      //			DataInputStream in = new DataInputStream(new FileInputStream(credentialFile));
      //			while (in.available() != 0) {
      //				System.out.println(in.readLine());
      //			}
      //			in.close();

      processor.changeNodeValue("credentials/entry//userName", job.getUserName());
      processor.changeNodeValue("credentials/entry//password", job.getPassword());
      processor.writeStream(new File(Utility.getJenkinsHome() + File.separator + job.getName()));

      // jenkins home location
      String jenkinsJobHome = System.getenv(JENKINS_HOME);
      StringBuilder builder = new StringBuilder(jenkinsJobHome);
      builder.append(File.separator);

      processor.writeStream(new File(builder.toString() + CI_CREDENTIAL_XML));
    } catch (Exception e) {
      S_LOGGER.error(
          "Entered into the catch block of CIManagerImpl.setSvnCredential "
              + e.getLocalizedMessage());
    }
  }
 void setConfig(Configuration config) {
   log.debug("config: " + config);
   proxyHost = config.get(PARAM_PROXY_HOST);
   proxyPort = config.getInt(PARAM_PROXY_PORT, DEFAULT_PROXY_PORT);
   if (StringUtil.isNullString(proxyHost) || proxyPort <= 0) {
     String http_proxy = System.getenv("http_proxy");
     if (!StringUtil.isNullString(http_proxy)) {
       try {
         HostPortParser hpp = new HostPortParser(http_proxy);
         proxyHost = hpp.getHost();
         proxyPort = hpp.getPort();
       } catch (HostPortParser.InvalidSpec e) {
         log.warning("Can't parse http_proxy environment var, ignoring: " + http_proxy + ": " + e);
       }
     }
   }
   if (StringUtil.isNullString(proxyHost) || proxyPort <= 0) {
     proxyHost = null;
   } else {
     log.info("Proxying through " + proxyHost + ":" + proxyPort);
   }
   userAgent = config.get(PARAM_USER_AGENT);
   if (StringUtil.isNullString(userAgent)) {
     userAgent = null;
   } else {
     log.debug("Setting User-Agent to " + userAgent);
   }
 }
 static {
   dict = null;
   String wnhome = System.getenv("WNHOME");
   String path =
       (new StringBuilder(String.valueOf(wnhome)))
           .append(File.separator)
           .append("dict")
           .toString();
   System.out.println(
       (new StringBuilder("Path to dictionary:")).append(getWNLocation()).toString());
   URL url = null;
   try {
     File f =
         new File(
             (new StringBuilder(String.valueOf(getWNLocation())))
                 .append(File.separator)
                 .append("dict")
                 .toString());
     URI uri = f.toURI();
     url = uri.toURL();
   } catch (MalformedURLException e) {
     e.printStackTrace();
   }
   dict = new Dictionary(url);
   dict.open();
 }
Exemple #9
0
  private static String expandEnvironment(Pattern pattern, String string) {

    if (string == null || pattern == null) {
      return string;
    }

    Matcher matcher = pattern.matcher(string);
    Map<String, String> envMap = null;

    while (matcher.find()) {

      // Retrieve environment variables
      if (envMap == null) {
        envMap = System.getenv();
      }

      String envNameOnly = matcher.group(1);

      if (envMap.containsKey(envNameOnly)) {
        String envValue = envMap.get(envNameOnly);

        if (envValue != null) {
          String escapeStrings[] = {"\\", "$", "{", "}"};
          for (String escapeString : escapeStrings) {
            envValue = envValue.replace(escapeString, "\\" + escapeString);
          }

          Pattern envNameClausePattern = Pattern.compile(Pattern.quote(matcher.group(0)));
          string = envNameClausePattern.matcher(string).replaceAll(envValue);
        }
      }
    }

    return string;
  }
Exemple #10
0
	public static String[] ginit(String[] args) {
		if (System.getenv("KONOHA_DEBUG") != null) {
			verboseDebug = true;
			verboseGc = true;
			verboseSugar = true;
			verboseCode = true;
		}
		
		CommandLineParser parser = new BasicParser();
		CommandLine commandLine = null;
		try {
			commandLine = parser.parse(longOptions, args);
		} catch (ParseException e) {
			// TODO
		}
		
		if(commandLine.hasOption("verbose")) {
			verboseDebug = true;
			System.out.println("option vervose");
		}
		if(commandLine.hasOption("verbose:gc")) {
			verboseGc = true;
			System.out.println("option vervose:gc");
		}
		if(commandLine.hasOption("verbose:sugar")) {
			verboseSugar = true;
			System.out.println("option vervose:sugar");
		}
		if(commandLine.hasOption("verbose:code")) {
			verboseCode = true;
			System.out.println("option vervose:code");
		}
		if(commandLine.hasOption("interactive")) {
			interactiveFlag = true;
			System.out.println("option interactive");
		}
		if(commandLine.hasOption("typecheck")) {
			compileonlyFlag = true;
			System.out.println("option typecheck");
		}
		if(commandLine.hasOption("start-with")) {
			startupScript = commandLine.getOptionValue("start-with");
			System.out.println("option start-with");
			System.out.println(" with arg " + startupScript);
		}
		if(commandLine.hasOption("test")) {
			testScript = commandLine.getOptionValue("test");
			System.out.println(" with arg " + testScript);
		}
		if(commandLine.hasOption("test-with")) {
			testScript = commandLine.getOptionValue("test");
			System.out.println(" with arg " + testScript);
		}
		if(commandLine.hasOption("builtin-test")) {
			builtinTest = commandLine.getOptionValue("builtin-test");
			System.out.println(" with arg " + builtinTest);
		}
		return commandLine.getArgs();
	}
  /* uses badsource and badsink */
  public void bad() throws Throwable {
    String data;

    /* get environment variable ADD */
    /* POTENTIAL FLAW: Read data from an environment variable */
    data = System.getenv("ADD");

    String root;
    if (System.getProperty("os.name").toLowerCase().indexOf("win") >= 0) {
      /* running on Windows */
      root = "C:\\uploads\\";
    } else {
      /* running on non-Windows */
      root = "/home/user/uploads/";
    }

    if (data != null) {
      /* POTENTIAL FLAW: no validation of concatenated value */
      File file = new File(root + data);
      FileInputStream streamFileInputSink = null;
      InputStreamReader readerInputStreamSink = null;
      BufferedReader readerBufferdSink = null;
      if (file.exists() && file.isFile()) {
        try {
          streamFileInputSink = new FileInputStream(file);
          readerInputStreamSink = new InputStreamReader(streamFileInputSink, "UTF-8");
          readerBufferdSink = new BufferedReader(readerInputStreamSink);
          IO.writeLine(readerBufferdSink.readLine());
        } catch (IOException exceptIO) {
          IO.logger.log(Level.WARNING, "Error with stream reading", exceptIO);
        } finally {
          /* Close stream reading objects */
          try {
            if (readerBufferdSink != null) {
              readerBufferdSink.close();
            }
          } catch (IOException exceptIO) {
            IO.logger.log(Level.WARNING, "Error closing BufferedReader", exceptIO);
          }

          try {
            if (readerInputStreamSink != null) {
              readerInputStreamSink.close();
            }
          } catch (IOException exceptIO) {
            IO.logger.log(Level.WARNING, "Error closing InputStreamReader", exceptIO);
          }

          try {
            if (streamFileInputSink != null) {
              streamFileInputSink.close();
            }
          } catch (IOException exceptIO) {
            IO.logger.log(Level.WARNING, "Error closing FileInputStream", exceptIO);
          }
        }
      }
    }
  }
 // For war agent needs to be switched on
 private boolean listenForDiscoveryMcRequests(Configuration pConfig) {
   // Check for system props, system env and agent config
   boolean sysProp =
       System.getProperty("jolokia." + ConfigKey.DISCOVERY_ENABLED.getKeyValue()) != null;
   boolean env = System.getenv("JOLOKIA_DISCOVERY") != null;
   boolean config = pConfig.getAsBoolean(ConfigKey.DISCOVERY_ENABLED);
   return sysProp || env || config;
 }
Exemple #13
0
  /** Must be called from the Generator implementation */
  void compileCode() throws Exception {
    System.out.println("Compiling code...\n");
    Set<Map.Entry<String, String>> set = mCodeFiles.entrySet();
    Iterator<Map.Entry<String, String>> itr = set.iterator();
    while (itr.hasNext()) {
      Map.Entry<String, String> entry = itr.next();
      File file = new File(entry.getKey());
      String source = entry.getValue();

      // dump file
      {
        FileOutputStream fos = new FileOutputStream(file);
        fos.write(source.getBytes());
        fos.close();
      }
    }

    itr = set.iterator();
    while (itr.hasNext()) {
      Map.Entry<String, String> entry = itr.next();
      File file = new File(entry.getKey());
      if (!file.getName().endsWith(".h")) {
        // compile file, standard MoSync settings
        String mosyncdir = System.getenv("FULLPATH_MOSYNCDIR");

        if (mosyncdir == null) mosyncdir = System.getenv("MOSYNCDIR");

        String cmd =
            mosyncdir
                + "/bin/xgcc -g -S \""
                + file.getAbsolutePath()
                + "\" -I"
                + mosyncdir
                + "/include";
        if (exec(cmd, true, null) != 0)
          throw new Exception("Compilation failed: " + file.getName());
      }
    }

    itr = set.iterator();
    while (itr.hasNext()) {
      Map.Entry<String, String> entry = itr.next();
      File file = new File(entry.getKey());
      if (!file.delete()) throw new Exception("Could not delete file " + file.getName());
    }
  }
Exemple #14
0
 public static String dataDirectory() {
   String OS = System.getProperty("os.name").toUpperCase();
   if (OS.contains("WIN")) return System.getenv("APPDATA");
   else if (OS.contains("MAC"))
     return System.getProperty("user.home") + "/Library/Application " + "Support";
   else if (OS.contains("NUX")) return System.getProperty("user.home");
   return System.getProperty("user.dir");
 }
  public static void addVMParameters(
      ParametersList parametersList, String mavenHome, MavenRunnerSettings runnerSettings) {
    parametersList.addParametersString(System.getenv(MAVEN_OPTS));

    parametersList.addParametersString(runnerSettings.getVmOptions());

    parametersList.addProperty("maven.home", mavenHome);
  }
Exemple #16
0
 /**
  * A constructor
  *
  * @param xmlRpcPort a xml RPC port
  * @param host a host
  * @param username a name of user (from URL)
  * @param port a port
  * @param command a command
  * @throws IOException if config file could not be loaded
  */
 private SSHMain(final int xmlRpcPort, String host, String username, Integer port, String command)
     throws IOException {
   SSHConfig config = SSHConfig.load();
   myHost = config.lookup(username, host, port);
   myXmlRpcClient = new GitSSHIdeaClient(xmlRpcPort, myHost.isBatchMode());
   myHandlerNo = Integer.parseInt(System.getenv(GitSSHService.SSH_HANDLER_ENV));
   myCommand = command;
 }
Exemple #17
0
	public static void startup(CTX konoha, String startup_script) {
		String[] buf = new String[256];
		String path = System.getenv("KONOHA_SCRIPTPATH");
		String local = "";
		if (path == null) {
			path = System.getenv("KONOHA_HOME");
			local = "/script";
		}	
		if (path == null) {
			path = System.getenv("HOME");
			local = "/.konoha/script";
		}
		//TODO snprintf(buf, sizeof(buf), "%s%s%s.k", path, local, startup_script);
		if (true /*TODO load(konoha, (const char*)buf)*/ ) {
			System.exit(1);
		}
	}
Exemple #18
0
  /**
   * Creates a github repository and pushes the files in the working folder into it (respecting
   * -with some restrictions- the .gitignore file)
   *
   * <p>If a repository already exists with the desired name, creates a new commit, maintaining
   * push/commit history.
   */
  private void pushToGitHub() throws RuntimeException {
    // only GitHub implemented in this application
    IRepositoryManager rpm = new GitHubRepositoryManager(repositoryName);
    rpm.setUser(System.getenv("GH_USER"));
    rpm.setPass(System.getenv("GH_PASS"));
    try {
      // create a git repo on github or bitbucket...
      rpm.createRepository();

      // add folder to track
      rpm.setLocalFolder(this.workingFolder);

      // push the files to the repo...
      rpm.push();
    } catch (Exception e) {
      throw new RuntimeException(e);
    }
  }
 public static String getAccountsFile() {
   final String path;
   if (Configuration.getCurrentOperatingSystem() == OperatingSystem.WINDOWS) {
     path = System.getenv("APPDATA") + File.separator + Configuration.NAME + "_Accounts.ini";
   } else {
     path = Paths.getUnixHome() + File.separator + "." + Configuration.NAME_LOWERCASE + "acct";
   }
   return path;
 }
Exemple #20
0
 /** sometimes call by sample application, at that time normally set some properties directly */
 private Configure() {
   Properties p = new Properties();
   Map args = new HashMap();
   args.putAll(System.getenv());
   args.putAll(System.getProperties());
   p.putAll(args);
   this.property = p;
   reload(false);
 }
Exemple #21
0
  public String _env(String args[]) {
    verifyCommand(args, "${env;<name>}, get the environmet variable", null, 2, 2);

    try {
      return System.getenv(args[1]);
    } catch (Throwable t) {
      return null;
    }
  }
 /**
  * Determines if the line numbers array should be added to the generated Groovy class.
  *
  * @return true if they should
  */
 private boolean shouldAddLineNumbers() {
   try {
     // for now, we support this through a system property.
     return Boolean.valueOf(System.getenv("GROOVY_PAGE_ADD_LINE_NUMBERS"));
   } catch (Exception e) {
     // something wild happened
     return false;
   }
 }
  private String bad_source() throws Throwable {
    String data;

    Logger log_bad = Logger.getLogger("local-logger");

    /* get environment variable ADD */
    data = System.getenv("ADD");

    return data;
  }
  public void bad() throws Throwable {
    String data;

    Logger log_bad = Logger.getLogger("local-logger");

    /* get environment variable ADD */
    data = System.getenv("ADD");

    (new CWE36_Absolute_Path_Traversal__Environment_53b()).bad_sink(data);
  }
  public static synchronized void init() {
    // 已经初始化,则直接返回
    if (CommonConfigProvider.prop != null && CommonConfigProvider.prop.size() > 0) {
      return;
    }

    logger.info("init CommonConfigProvider.prop.");
    Properties properties = ConfigProperties.getProperties();
    if (properties != null && properties.size() > 0) {
      CommonConfigProvider.prop = properties;
      logger.info("find properties from ConfigProperties");
    } else {
      String configPath = System.getProperty(Constants.CONFIG_PATH);

      if (configPath == null) {
        logger.info("can't load config from:System.getProperty(Constants.CONFIG_PATH)");
        configPath = System.getenv(Constants.CONFIG_PATH);
        logger.info("can't load config from:System.getenv(Constants.CONFIG_PATH)");
        if (configPath == null) {
          logger.error(
              "config.path is null,now we use default config.if the environment is not dev,please check you startup param: -Dconfig.path=xxx");
          configPath = DEFAULT_CONFIG_PATH;
        }
      }
      logger.info("config.path:{}", configPath);

      Properties configs = new Properties();
      FileInputStream fileInputStream = null;
      InputStream inputStream = null;
      try {
        if (configPath.startsWith(FILE_PREFIX)) {
          configPath = configPath.substring(FILE_PREFIX.length());
          fileInputStream = new FileInputStream(new File(configPath));
          configs.load(fileInputStream);
        } else if (configPath.startsWith(CLASSPATH_PREFIX)) {
          configPath = configPath.substring(CLASSPATH_PREFIX.length());
          inputStream = CommonConfigProvider.class.getResourceAsStream(configPath);
          configs.load(inputStream);
        }
        CommonConfigProvider.prop = configs;
      } catch (FileNotFoundException e) {
        logger.error("", e);
      } catch (IOException e) {
        logger.error("", e);
      } finally {
        IOUtils.closeQuietly(fileInputStream);
        IOUtils.closeQuietly(inputStream);
      }
    }

    logger.info(
        "CommonConfigProvider.prop ={},size:{}",
        CommonConfigProvider.prop,
        CommonConfigProvider.prop.size());
  }
 public void addEnvToIntent(Intent intent) {
   Map<String, String> envMap = System.getenv();
   Set<Map.Entry<String, String>> envSet = envMap.entrySet();
   Iterator<Map.Entry<String, String>> envIter = envSet.iterator();
   int c = 0;
   while (envIter.hasNext()) {
     Map.Entry<String, String> entry = envIter.next();
     intent.putExtra("env" + c, entry.getKey() + "=" + entry.getValue());
     c++;
   }
 }
Exemple #27
0
public class Context {

  private String targetIO = "";

  private Object extraContext = "";

  private int port = 0;

  private final String TMPFI = "/tmp/fi/";
  private final String HADOOP_USERNAME = "******" + System.getenv("USER");
  private final String HADOOP_STORAGE_DIR = TMPFI + HADOOP_USERNAME + "/";

  // ********************************************
  // rest
  // ********************************************

  public Context() {}

  public Context(String s) {
    targetIO = new String(s);
  }

  public Context(int port) {
    this.port = port;
  }

  public int getPort() {
    return port;
  }

  public String getTargetIO() {
    return targetIO;
  }

  public void setExtraContext(Object extra) {
    this.extraContext = extra;
  }

  public Object getExtraContext() {
    return extraContext;
  }

  public String toString() {
    String tmp = targetIO;
    if (targetIO.contains("/tmp/" + HADOOP_USERNAME))
      tmp = tmp.replaceFirst("/tmp/" + HADOOP_USERNAME, "/thh/");
    if (targetIO.contains(HADOOP_STORAGE_DIR)) tmp = tmp.replaceFirst(HADOOP_STORAGE_DIR, "/rhh/");
    return tmp;
  }

  public void setTargetIO(String f) {
    targetIO = new String(f);
  }
}
  public static void main(String args[]) throws InterruptedException, IOException {
    List<String> command = new ArrayList<String>();
    command.add(System.getenv("windir") + "\\system32\\" + "tree.com");
    command.add("/A");

    ProcessBuilder builder = new ProcessBuilder(command);
    Map<String, String> environ = builder.environment();
    builder.directory(new File(System.getenv("temp")));

    System.out.println("Directory : " + System.getenv("temp"));
    final Process process = builder.start();
    InputStream is = process.getInputStream();
    InputStreamReader isr = new InputStreamReader(is);
    BufferedReader br = new BufferedReader(isr);
    String line;
    while ((line = br.readLine()) != null) {
      System.out.println(line);
    }
    System.out.println("Program terminated!");
  }
 // Try to find an URL for system props or config
 private String findAgentUrl(Configuration pConfig) {
   // System property has precedence
   String url = System.getProperty("jolokia." + ConfigKey.DISCOVERY_AGENT_URL.getKeyValue());
   if (url == null) {
     url = System.getenv("JOLOKIA_DISCOVERY_AGENT_URL");
     if (url == null) {
       url = pConfig.get(ConfigKey.DISCOVERY_AGENT_URL);
     }
   }
   return NetworkUtil.replaceExpression(url);
 }
Exemple #30
0
  public static void checkOCSSW() {

    String ocsswLocation = RuntimeContext.getConfig().getContextProperty(OCSSW_LOCATION_PROPERTY);

    // ocssw installed local
    if (ocsswLocation == null || ocsswLocation.trim().equals(SEADAS_OCSSW_LOCATION_LOCAL)) {
      String dirPath =
          RuntimeContext.getConfig()
              .getContextProperty(OCSSWROOT_PROPERTY, System.getenv(OCSSWROOT_ENVVAR));

      if (dirPath == null) {
        dirPath =
            RuntimeContext.getConfig()
                .getContextProperty(
                    SEADASHOME_PROPERTY,
                    System.getProperty("user.home")
                        + System.getProperty("file.separator")
                        + "ocssw");
      }
      if (dirPath != null) {
        // Check if ${ocssw.root}/run/scripts directory exists in the system.
        // Precondition to detect the existing installation:
        // the user needs to provide "seadas.ocssw.root" value in seadas.config
        // or set OCSSWROOT in the system env.
        ocsswRoot = dirPath;
        final File dir =
            new File(
                dirPath
                    + System.getProperty("file.separator")
                    + "run"
                    + System.getProperty("file.separator")
                    + "scripts");
        if (dir.isDirectory()) {
          ocsswExist = true;
          return;
        }
      }
    } else {
      // ocssw installed in virtual box and needs be accessed through web services
      // need to access to two services: one for ocsswRoot, and the other for ocsswExist -this
      // doesn't work. Because ocsswrest package is not available to SeadasMain at this time
      //            OCSSWClient ocsswClient = new OCSSWClient();
      //            WebTarget target = ocsswClient.getOcsswWebTarget();
      //            ocsswRoot =
      // target.path("ocssw").path("installDir").request(MediaType.TEXT_PLAIN).get(String.class);
      //            ocsswExist =
      // target.path("ocssw").path("ocsswInfo").request(MediaType.APPLICATION_JSON).get(new
      // GenericType<HashMap<String, Boolean>>() {}).get("ocsswExists");
      // Assumption: ocssw is already installed on the virtual box and the location is
      // ${remoteuser.home}/ocssw
      ocsswRoot = "${remoteuser.home}/ocssw";
      ocsswExist = true;
    }
  }