/**
* MVEL 2.0
* Copyright (C) 2007 The Codehaus
* Mike Brock, Dhanji Prasanna, John Graham, Mark Proctor
*
* Licensed 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.mvel2.sh;
import org.mvel2.MVELInterpretedRuntime;
import org.mvel2.ParserContext;
import org.mvel2.integration.VariableResolverFactory;
import org.mvel2.integration.impl.MapVariableResolverFactory;
import org.mvel2.sh.command.basic.BasicCommandSet;
import org.mvel2.sh.command.file.FileCommandSet;
import org.mvel2.templates.TemplateRuntime;
import org.mvel2.util.StringAppender;
import org.mvel2.util.PropertyTools;
import java.io.*;
import java.util.*;
import static java.lang.Boolean.parseBoolean;
import static java.lang.Runtime.getRuntime;
import static java.lang.System.arraycopy;
import static java.lang.System.getProperty;
import static java.util.ResourceBundle.getBundle;
import static org.mvel2.MVEL.compileExpression;
import static org.mvel2.MVEL.executeExpression;
import static org.mvel2.util.PropertyTools.contains;
/**
* A shell session.
*/
public class ShellSession {
public static final String PROMPT_VAR = "$PROMPT";
private static final String[] EMPTY = new String[0];
private final Map<String, Command> commands = new HashMap<String, Command>();
private Map<String, Object> variables;
private Map<String, String> env;
private Object ctxObject;
ParserContext pCtx = new ParserContext();
VariableResolverFactory lvrf;
private int depth;
private int cdepth;
private boolean multi = false;
private int multiIndentSize = 0;
private PrintStream out = System.out;
private String prompt;
private String commandBuffer;
StringAppender inBuffer = new StringAppender();
final BufferedReader readBuffer = new BufferedReader(new InputStreamReader(System.in));
public ShellSession() {
System.out.println("Starting session...");
variables = new HashMap<String, Object>();
env = new HashMap<String, String>();
commands.putAll(new BasicCommandSet().load());
commands.putAll(new FileCommandSet().load());
env.put(PROMPT_VAR, DefaultEnvironment.PROMPT);
env.put("$OS_NAME", getProperty("os.name"));
env.put("$OS_VERSION", getProperty("os.version"));
env.put("$JAVA_VERSION", PropertyTools.getJavaVersion());
env.put("$CWD", new File(".").getAbsolutePath());
env.put("$COMMAND_PASSTRU", "false");
env.put("$PRINTOUTPUT", "true");
env.put("$ECHO", "false");
env.put("$SHOW_TRACES", "true");
env.put("$USE_OPTIMIZER_ALWAYS", "false");
env.put("$PATH", "");
try {
ResourceBundle bundle = getBundle(".mvelsh.properties");
Enumeration<String> enumer = bundle.getKeys();
String key;
while (enumer.hasMoreElements()) {
env.put(key = enumer.nextElement(), bundle.getString(key));
}
}
catch (MissingResourceException e) {
System.out.println("No config file found. Loading default config.");
if (!contains(getProperty("os.name").toLowerCase(), "windows")) {
env.put("$PATH", "/bin:/usr/bin:/sbin:/usr/sbin");
}
}
lvrf = new MapVariableResolverFactory(variables, new MapVariableResolverFactory(env));
}
public ShellSession(String init) {
this();
exec(init);
}
private void _exec() {
String[] inTokens;
Object outputBuffer;
final PrintStream sysPrintStream = System.out;
final PrintStream sysErrorStream = System.err;
final InputStream sysInputStream = System.in;
File execFile;
if ("true".equals(env.get("$ECHO"))) {
out.println(">" + commandBuffer);
out.flush();
}
inTokens = inBuffer.append(commandBuffer).toString().split("\\s");
if (inTokens.length != 0 && commands.containsKey(inTokens[0])) {
commandBuffer = null;
String[] passParameters;
if (inTokens.length > 1) {
arraycopy(inTokens, 1, passParameters = new String[inTokens.length - 1], 0, passParameters.length);
}
else {
passParameters = EMPTY;
}
try {
commands.get(inTokens[0]).execute(this, passParameters);
}
catch (CommandException e) {
out.append("Error: ").append(e.getMessage()).append("\n");
}
}
else {
commandBuffer = null;
try {
if (shouldDefer(inBuffer)) {
multi = true;
return;
}
else {
multi = false;
}
if (parseBoolean(env.get("$USE_OPTIMIZER_ALWAYS"))) {
outputBuffer = executeExpression(compileExpression(inBuffer.toString()), ctxObject, lvrf);
}
else {
MVELInterpretedRuntime runtime = new MVELInterpretedRuntime(inBuffer.toString(), ctxObject, lvrf, pCtx);
outputBuffer = runtime.parse();
}
}
catch (Exception e) {
if ("true".equals(env.get("$COMMAND_PASSTHRU"))) {
String[] paths;
String s;
if ((s = inTokens[0]).startsWith("./")) {
s = new File(env.get("$CWD")).getAbsolutePath() + s.substring(s.indexOf('/'));
paths = new String[]{s};
}
else {
paths = env.get("$PATH").split("(:|;)");
}
boolean successfulExec = false;
for (String execPath : paths) {
if ((execFile = new File(execPath + "/" + s)).exists() && execFile.isFile()) {
successfulExec = true;
String[] execString = new String[inTokens.length];
execString[0] = execFile.getAbsolutePath();
System.arraycopy(inTokens, 1, execString, 1, inTokens.length - 1);
try {
final Process p = getRuntime().exec(execString);
final OutputStream outStream = p.getOutputStream();
final InputStream inStream = p.getInputStream();
final InputStream errStream = p.getErrorStream();
final RunState runState = new RunState(this);
final Thread pollingThread = new Thread(new Runnable() {
public void run() {
byte[] buf = new byte[25];
int read;
while (true) {
try {
while ((read = inStream.read(buf)) > 0) {
for (int i = 0; i < read; i++) {
sysPrintStream.print((char) buf[i]);
}
sysPrintStream.flush();
}
if (!runState.isRunning()) break;
}
catch (Exception e) {
break;
}
}
sysPrintStream.flush();
if (!multi) {
multiIndentSize = (prompt = String.valueOf(TemplateRuntime.eval(env.get("$PROMPT"), variables))).length();
out.append(prompt);
}
else {
out.append(">").append(indent((multiIndentSize - 1) + (depth * 4)));
}
}
});
final Thread watchThread = new Thread(new Runnable() {
public void run() {
Thread runningThread = new Thread(new Runnable() {
public void run() {
try {
String read;
while (runState.isRunning()) {
while ((read = readBuffer.readLine()) != null) {
if (runState.isRunning()) {
for (char c : read.toCharArray()) {
outStream.write((byte) c);
}
}
else {
runState.getSession().setCommandBuffer(read);
break;
}
}
}
outStream.write((byte) '\n');
outStream.flush();
}
catch (Exception e2) {
}
}
});
runningThread.setPriority(Thread.MIN_PRIORITY);
runningThread.start();
try {
p.waitFor();
}
catch (InterruptedException e) {
// nothing;
}
sysPrintStream.flush();
runState.setRunning(false);
try {
runningThread.join();
}
catch (InterruptedException e) {
// nothing;�
}
}
});
pollingThread.setPriority(Thread.MIN_PRIORITY);
pollingThread.start();
watchThread.setPriority(Thread.MIN_PRIORITY);
watchThread.start();
watchThread.join();
try {
pollingThread.notify();
}
catch (Exception ne) {
}
}
catch (Exception e2) {
// fall through;
}
}
}
if (successfulExec) {
inBuffer.reset();
return;
}
}
ByteArrayOutputStream stackTraceCap = new ByteArrayOutputStream();
PrintStream capture = new PrintStream(stackTraceCap);
e.printStackTrace(capture);
capture.flush();
env.put("$LAST_STACK_TRACE", new String(stackTraceCap.toByteArray()));
if (parseBoolean(env.get("$SHOW_TRACE"))) {
out.println(env.get("$LAST_STACK_TRACE"));
}
else {
out.println(e.toString());
}
inBuffer.reset();
return;
}
if (outputBuffer != null && "true".equals(env.get("$PRINTOUTPUT"))) {
if (outputBuffer.getClass().isArray()) {
out.println(Arrays.toString((Object[]) outputBuffer));
}
else {
out.println(String.valueOf(outputBuffer));
}
}
}
inBuffer.reset();
}
//todo: fix this
public void run() {
final BufferedReader readBuffer = new BufferedReader(new InputStreamReader(System.in));
try {
//noinspection InfiniteLoopStatement
while (true) {
printPrompt();
if (commandBuffer == null) {
commandBuffer = readBuffer.readLine();
}
_exec();
}
}
catch (Exception e) {
e.printStackTrace();
System.out.println("unexpected exception. exiting.");
}
}
public void printPrompt() {
if (!multi) {
multiIndentSize = (prompt = String.valueOf(TemplateRuntime.eval(env.get("$PROMPT"), variables))).length();
out.append(prompt);
}
else {
out.append(">").append(indent((multiIndentSize - 1) + (depth * 4)));
}
}
public boolean shouldDefer(StringAppender inBuf) {
char[] buffer = new char[inBuf.length()];
inBuf.getChars(0, inBuf.length(), buffer, 0);
depth = cdepth = 0;
for (int i = 0; i < buffer.length; i++) {
switch (buffer[i]) {
case '/':
if (i + 1 < buffer.length && buffer[i + 1] == '*') {
cdepth++;
}
break;
case '*':
if (i + 1 < buffer.length && buffer[i + 1] == '/') {
cdepth--;
}
break;
case '{':
depth++;
break;
case '}':
depth--;
break;
}
}
return depth + cdepth > 0;
}
public String indent(int size) {
StringBuffer sbuf = new StringBuffer();
for (int i = 0; i < size; i++) sbuf.append(" ");
return sbuf.toString();
}
public Map<String, Command> getCommands() {
return commands;
}
public Map<String, Object> getVariables() {
return variables;
}
public Map<String, String> getEnv() {
return env;
}
public Object getCtxObject() {
return ctxObject;
}
public void setCtxObject(Object ctxObject) {
this.ctxObject = ctxObject;
}
public String getCommandBuffer() {
return commandBuffer;
}
public void setCommandBuffer(String commandBuffer) {
this.commandBuffer = commandBuffer;
}
public void exec(String command) {
for (String c : command.split("\n")) {
inBuffer.append(c);
_exec();
}
}
public static final class RunState {
private boolean running = true;
private ShellSession session;
public RunState(ShellSession session) {
this.session = session;
}
public ShellSession getSession() {
return session;
}
public void setSession(ShellSession session) {
this.session = session;
}
public boolean isRunning() {
return running;
}
public void setRunning(boolean running) {
this.running = running;
}
}
}