/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.exec.environment;
import java.io.BufferedReader;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.IOException;
import java.io.StringReader;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.Comparator;
import java.util.HashMap;
import java.util.Map;
import java.util.TreeMap;
import org.apache.commons.exec.CommandLine;
import org.apache.commons.exec.DefaultExecutor;
import org.apache.commons.exec.Executor;
import org.apache.commons.exec.OS;
import org.apache.commons.exec.PumpStreamHandler;
/**
* Helper class to determine the environment variable
* for the OS. Depending on the JDK the environment
* variables can be either retrieved directly from the
* JVM or requires starting a process to get them running
* an OS command line.
*/
public class DefaultProcessingEnvironment {
/** the line seperator of the system */
private static final String LINE_SEPARATOR = System.getProperty("line.separator");
/** the environment variables of the process */
protected Map procEnvironment;
/**
* Find the list of environment variables for this process.
*
* @return a map containing the environment variables
* @throws IOException obtaining the environment variables failed
*/
public synchronized Map getProcEnvironment() throws IOException {
if(procEnvironment == null) {
procEnvironment = this.createProcEnvironment();
}
// create a copy of the map just in case that
// anyone is going to modifiy it, e.g. removing
// or setting an evironment variable
Map copy = createEnvironmentMap();
copy.putAll(procEnvironment);
return copy;
}
/**
* Find the list of environment variables for this process.
*
* @return a amp containing the environment variables
* @throws IOException the operation failed
*/
protected Map createProcEnvironment() throws IOException {
if (procEnvironment == null) {
try {
Method getenvs = System.class.getMethod( "getenv", (java.lang.Class[]) null );
Map env = (Map) getenvs.invoke( null, (java.lang.Object[]) null );
procEnvironment = createEnvironmentMap();
procEnvironment.putAll(env);
} catch ( NoSuchMethodException e ) {
// ok, just not on JDK 1.5
} catch ( IllegalAccessException e ) {
// Unexpected error obtaining environment - using JDK 1.4 method
} catch ( InvocationTargetException e ) {
// Unexpected error obtaining environment - using JDK 1.4 method
}
}
if(procEnvironment == null) {
procEnvironment = createEnvironmentMap();
BufferedReader in = runProcEnvCommand();
String var = null;
String line;
while ((line = in.readLine()) != null) {
if (line.indexOf('=') == -1) {
// Chunk part of previous env var (UNIX env vars can
// contain embedded new lines).
if (var == null) {
var = LINE_SEPARATOR + line;
} else {
var += LINE_SEPARATOR + line;
}
} else {
// New env var...append the previous one if we have it.
if (var != null) {
EnvironmentUtils.addVariableToEnvironment(procEnvironment, var);
}
var = line;
}
}
// Since we "look ahead" before adding, there's one last env var.
if (var != null) {
EnvironmentUtils.addVariableToEnvironment(procEnvironment, var);
}
}
return procEnvironment;
}
/**
* Start a process to list the environment variables.
*
* @return a reader containing the output of the process
* @throws IOException starting the process failed
*/
protected BufferedReader runProcEnvCommand() throws IOException {
ByteArrayOutputStream out = new ByteArrayOutputStream();
Executor exe = new DefaultExecutor();
exe.setStreamHandler(new PumpStreamHandler(out));
// ignore the exit value - Just try to use what we got
exe.execute(getProcEnvCommand());
return new BufferedReader(new StringReader(toString(out)));
}
/**
* Determine the OS specific command line to get a list of environment
* variables.
*
* @return the command line
*/
protected CommandLine getProcEnvCommand() {
String executable;
String[] arguments = null;
if (OS.isFamilyOS2()) {
// OS/2 - use same mechanism as Windows 2000
executable = "cmd";
arguments = new String[] {"/c", "set"};
} else if (OS.isFamilyWindows()) {
// Determine if we're running under XP/2000/NT or 98/95
if (OS.isFamilyWin9x()) {
executable = "command.com";
// Windows 98/95
} else {
executable = "cmd";
// Windows XP/2000/NT/2003
}
arguments = new String[] {"/c", "set"};
} else if (OS.isFamilyZOS() || OS.isFamilyUnix()) {
// On most systems one could use: /bin/sh -c env
// Some systems have /bin/env, others /usr/bin/env, just try
if (new File("/bin/env").canRead()) {
executable = "/bin/env";
} else if (new File("/usr/bin/env").canRead()) {
executable = "/usr/bin/env";
} else {
// rely on PATH
executable = "env";
}
} else if (OS.isFamilyNetware() || OS.isFamilyOS400()) {
// rely on PATH
executable = "env";
} else {
// MAC OS 9 and previous
// TODO: I have no idea how to get it, someone must fix it
executable = null;
}
CommandLine commandLine = null;
if(executable != null) {
commandLine = new CommandLine(executable);
commandLine.addArguments(arguments);
}
return commandLine;
}
/**
* ByteArrayOutputStream#toString doesn't seem to work reliably on OS/390,
* at least not the way we use it in the execution context.
*
* @param bos
* the output stream that one wants to read
* @return the output stream as a string, read with special encodings in the
* case of z/os and os/400
*/
private String toString(final ByteArrayOutputStream bos) {
if (OS.isFamilyZOS()) {
try {
return bos.toString("Cp1047");
} catch (java.io.UnsupportedEncodingException e) {
// noop default encoding used
}
} else if (OS.isFamilyOS400()) {
try {
return bos.toString("Cp500");
} catch (java.io.UnsupportedEncodingException e) {
// noop default encoding used
}
}
return bos.toString();
}
/**
* Creates a map that obeys the casing rules of the current platform for key
* lookup. E.g. on a Windows platform, the map keys will be
* case-insensitive.
*
* @return The map for storage of environment variables, never
* <code>null</code>.
*/
private Map createEnvironmentMap() {
if (OS.isFamilyWindows()) {
return new TreeMap(new Comparator() {
public int compare(Object arg0, Object arg1) {
String key0 = (String) arg0;
String key1 = (String) arg1;
return key0.compareToIgnoreCase(key1);
}
});
} else {
return new HashMap();
}
}
}