/*
* 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.karaf.shell.impl.console;
import java.io.CharArrayWriter;
import java.io.Closeable;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.InterruptedIOException;
import java.io.PrintStream;
import java.io.Reader;
import java.lang.management.ManagementFactory;
import java.util.List;
import java.util.Map;
import java.util.Properties;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import jline.UnsupportedTerminal;
import jline.console.ConsoleReader;
import jline.console.history.MemoryHistory;
import jline.console.history.PersistentHistory;
import org.apache.felix.service.command.CommandProcessor;
import org.apache.felix.service.command.CommandSession;
import org.apache.felix.service.command.Converter;
import org.apache.felix.service.command.Function;
import org.apache.felix.service.threadio.ThreadIO;
import org.apache.karaf.shell.api.console.Command;
import org.apache.karaf.shell.api.console.Completer;
import org.apache.karaf.shell.api.console.History;
import org.apache.karaf.shell.api.console.Registry;
import org.apache.karaf.shell.api.console.Session;
import org.apache.karaf.shell.api.console.SessionFactory;
import org.apache.karaf.shell.api.console.Terminal;
import org.apache.karaf.shell.support.ShellUtil;
import org.apache.karaf.shell.support.completers.FileCompleter;
import org.apache.karaf.shell.support.completers.FileOrUriCompleter;
import org.apache.karaf.shell.support.completers.UriCompleter;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public class ConsoleSessionImpl implements Session {
public static final String SHELL_INIT_SCRIPT = "karaf.shell.init.script";
public static final String SHELL_HISTORY_MAXSIZE = "karaf.shell.history.maxSize";
public static final String PROMPT = "PROMPT";
public static final String DEFAULT_PROMPT = "\u001B[1m${USER}\u001B[0m@${APPLICATION}(${SUBSHELL})> ";
private static final Logger LOGGER = LoggerFactory.getLogger(ConsoleSessionImpl.class);
// Input stream
final BlockingQueue<Integer> queue = new ArrayBlockingQueue<Integer>(1024);
final ConsoleInputStream console = new ConsoleInputStream();
final Pipe pipe = new Pipe();
volatile boolean running;
volatile boolean eof;
final SessionFactory factory;
final ThreadIO threadIO;
final InputStream in;
final PrintStream out;
final PrintStream err;
private Runnable closeCallback;
final CommandSession session;
final Registry registry;
final Terminal terminal;
final History history;
final ConsoleReader reader;
private boolean interrupt;
private Thread thread;
public ConsoleSessionImpl(SessionFactory factory,
CommandProcessor processor,
ThreadIO threadIO,
InputStream in,
PrintStream out,
PrintStream err,
Terminal term,
String encoding,
Runnable closeCallback) {
// Arguments
this.factory = factory;
this.threadIO = threadIO;
this.in = in;
this.out = out;
this.err = err;
this.closeCallback = closeCallback;
// Terminal
terminal = term == null ? new JLineTerminal(new UnsupportedTerminal()) : term;
// Console reader
try {
reader = new ConsoleReader(null,
in != null ? console : null,
out,
terminal instanceof JLineTerminal ? ((JLineTerminal) terminal).getTerminal() : new KarafTerminal(terminal),
encoding);
} catch (IOException e) {
throw new RuntimeException("Error opening console reader", e);
}
// History
final File file = getHistoryFile();
try {
file.getParentFile().mkdirs();
reader.setHistory(new KarafFileHistory(file));
} catch (Exception e) {
LOGGER.error("Can not read history from file " + file + ". Using in memory history", e);
}
if (reader.getHistory() instanceof MemoryHistory) {
String maxSizeStr = System.getProperty(SHELL_HISTORY_MAXSIZE);
if (maxSizeStr != null) {
((MemoryHistory) this.reader.getHistory()).setMaxSize(Integer.parseInt(maxSizeStr));
}
}
history = new HistoryWrapper(reader.getHistory());
// Registry
registry = new RegistryImpl(factory.getRegistry());
registry.register(factory);
registry.register(this);
registry.register(registry);
registry.register(terminal);
registry.register(history);
// Completers
Completer completer = new CommandsCompleter(factory);
reader.addCompleter(new CompleterAsCompletor(this, completer));
registry.register(completer);
registry.register(new CommandNamesCompleter());
registry.register(new FileCompleter());
registry.register(new UriCompleter());
registry.register(new FileOrUriCompleter());
// Session
session = processor.createSession(in != null ? console : null, out, err);
Properties sysProps = System.getProperties();
for (Object key : sysProps.keySet()) {
session.put(key.toString(), sysProps.get(key));
}
session.put(".session", this);
session.put(".commandSession", session);
session.put(".jline.reader", reader);
session.put(".jline.terminal", reader.getTerminal());
session.put(".jline.history", reader.getHistory());
session.put(Session.SCOPE, "shell:bundle:*");
session.put(Session.SUBSHELL, "");
session.put(Session.COMPLETION_MODE, loadCompletionMode());
session.put("USER", ShellUtil.getCurrentUserName());
session.put("APPLICATION", System.getProperty("karaf.name", "root"));
session.put("#LINES", new Function() {
public Object execute(CommandSession session, List<Object> arguments) throws Exception {
return Integer.toString(terminal.getHeight());
}
});
session.put("#COLUMNS", new Function() {
public Object execute(CommandSession session, List<Object> arguments) throws Exception {
return Integer.toString(terminal.getWidth());
}
});
session.put("pid", getPid());
}
/**
* Subclasses can override to use a different history file.
*
* @return
*/
protected File getHistoryFile() {
String defaultHistoryPath = new File(System.getProperty("user.home"), ".karaf/karaf.history").toString();
return new File(System.getProperty("karaf.history", defaultHistoryPath));
}
@Override
public Terminal getTerminal() {
return terminal;
}
public History getHistory() {
return history;
}
@Override
public Registry getRegistry() {
return registry;
}
@Override
public SessionFactory getFactory() {
return factory;
}
public void close() {
if (!running) {
return;
}
out.println();
if (reader.getHistory() instanceof PersistentHistory) {
try {
((PersistentHistory) reader.getHistory()).flush();
} catch (IOException e) {
// ignore
}
}
running = false;
pipe.interrupt();
if (thread != Thread.currentThread()) {
thread.interrupt();
}
reader.shutdown();
if (closeCallback != null) {
closeCallback.run();
}
if (terminal instanceof Closeable) {
try {
((Closeable) terminal).close();
} catch (IOException e) {
// Ignore
}
}
}
public void run() {
try {
threadIO.setStreams(session.getKeyboard(), out, err);
thread = Thread.currentThread();
running = true;
pipe.start();
Properties brandingProps = Branding.loadBrandingProperties(terminal);
welcome(brandingProps);
setSessionProperties(brandingProps);
String scriptFileName = System.getProperty(SHELL_INIT_SCRIPT);
executeScript(scriptFileName);
while (running) {
try {
String command = readAndParseCommand();
if (command == null) {
break;
}
//session.getConsole().println("Executing: " + line);
Object result = session.execute(command);
if (result != null) {
session.getConsole().println(session.format(result, Converter.INSPECT));
}
} catch (InterruptedIOException e) {
//System.err.println("^C");
// TODO: interrupt current thread
} catch (InterruptedException e) {
//interrupt current thread
} catch (Throwable t) {
ShellUtil.logException(this, t);
}
}
close();
} finally {
try {
threadIO.close();
} catch (Throwable t) {
// Ignore
}
}
}
@Override
public Object execute(CharSequence commandline) throws Exception {
return session.execute(commandline);
}
@Override
public Object get(String name) {
return session.get(name);
}
@Override
public void put(String name, Object value) {
session.put(name, value);
}
@Override
public InputStream getKeyboard() {
return session.getKeyboard();
}
@Override
public PrintStream getConsole() {
return session.getConsole();
}
@Override
public String resolveCommand(String name) {
// TODO: optimize
if (!name.contains(":")) {
String[] scopes = ((String) get(Session.SCOPE)).split(":");
List<Command> commands = registry.getCommands();
for (String scope : scopes) {
for (Command command : commands) {
if ((Session.SCOPE_GLOBAL.equals(scope) || command.getScope().equals(scope)) && command.getName().equals(name)) {
return command.getScope() + ":" + name;
}
}
}
}
return name;
}
@Override
public String readLine(String prompt, Character mask) throws IOException {
reader.setHistoryEnabled(false);
try {
return reader.readLine(prompt, mask);
} finally {
reader.setHistoryEnabled(true);
}
}
private String loadCompletionMode() {
String mode;
try {
File shellCfg = new File(System.getProperty("karaf.etc"), "/org.apache.karaf.shell.cfg");
Properties properties = new Properties();
properties.load(new FileInputStream(shellCfg));
mode = (String) properties.get("completionMode");
if (mode == null) {
LOGGER.debug("completionMode property is not defined in etc/org.apache.karaf.shell.cfg file. Using default completion mode.");
mode = Session.COMPLETION_MODE_GLOBAL;
}
} catch (Exception e) {
LOGGER.warn("Can't read {}/org.apache.karaf.shell.cfg file. The completion is set to default.", System.getProperty("karaf.etc"));
mode = Session.COMPLETION_MODE_GLOBAL;
}
return mode;
}
private String readAndParseCommand() throws IOException {
String command = null;
boolean loop = true;
boolean first = true;
while (loop) {
checkInterrupt();
String line = reader.readLine(first ? getPrompt() : "> ");
if (line == null) {
break;
}
if (command == null) {
command = line;
} else {
if (command.charAt(command.length() - 1) == '\\') {
command = command.substring(0, command.length() - 1) + line;
} else {
command += "\n" + line;
}
}
if (reader.getHistory().size() == 0) {
reader.getHistory().add(command);
} else {
// jline doesn't add blank lines to the history so we don't
// need to replace the command in jline's console history with
// an indented one
if (command.length() > 0 && !" ".equals(command)) {
reader.getHistory().replace(command);
}
}
if (command.length() > 0 && command.charAt(command.length() - 1) == '\\') {
loop = true;
first = false;
} else {
try {
Class<?> cl = CommandSession.class.getClassLoader().loadClass("org.apache.felix.gogo.runtime.Parser");
Object parser = cl.getConstructor(CharSequence.class).newInstance(command);
cl.getMethod("program").invoke(parser);
loop = false;
} catch (Exception e) {
loop = true;
first = false;
} catch (Throwable t) {
// Reflection problem ? just quit
loop = false;
}
}
}
return command;
}
private void executeScript(String scriptFileName) {
if (scriptFileName != null) {
Reader r = null;
try {
File scriptFile = new File(scriptFileName);
r = new InputStreamReader(new FileInputStream(scriptFile));
CharArrayWriter w = new CharArrayWriter();
int n;
char[] buf = new char[8192];
while ((n = r.read(buf)) > 0) {
w.write(buf, 0, n);
}
session.execute(new String(w.toCharArray()));
} catch (Exception e) {
LOGGER.debug("Error in initialization script", e);
System.err.println("Error in initialization script: " + e.getMessage());
} finally {
if (r != null) {
try {
r.close();
} catch (IOException e) {
// Ignore
}
}
}
}
}
protected void welcome(Properties brandingProps) {
String welcome = brandingProps.getProperty("welcome");
if (welcome != null && welcome.length() > 0) {
session.getConsole().println(welcome);
}
}
protected void setSessionProperties(Properties brandingProps) {
for (Map.Entry<Object, Object> entry : brandingProps.entrySet()) {
String key = (String) entry.getKey();
if (key.startsWith("session.")) {
session.put(key.substring("session.".length()), entry.getValue());
}
}
}
protected String getPrompt() {
try {
String prompt;
try {
Object p = session.get(PROMPT);
if (p != null) {
prompt = p.toString();
} else {
Properties properties = Branding.loadBrandingProperties(terminal);
if (properties.getProperty("prompt") != null) {
prompt = properties.getProperty("prompt");
// we put the PROMPT in ConsoleSession to avoid to read
// the properties file each time.
session.put(PROMPT, prompt);
} else {
prompt = DEFAULT_PROMPT;
}
}
} catch (Throwable t) {
prompt = DEFAULT_PROMPT;
}
Matcher matcher = Pattern.compile("\\$\\{([^}]+)\\}").matcher(prompt);
while (matcher.find()) {
Object rep = session.get(matcher.group(1));
if (rep != null) {
prompt = prompt.replace(matcher.group(0), rep.toString());
matcher.reset(prompt);
}
}
return prompt;
} catch (Throwable t) {
return "$ ";
}
}
private void checkInterrupt() throws IOException {
if (Thread.interrupted() || interrupt) {
interrupt = false;
throw new InterruptedIOException("Keyboard interruption");
}
}
private void interrupt() {
interrupt = true;
thread.interrupt();
}
private String getPid() {
String name = ManagementFactory.getRuntimeMXBean().getName();
String[] parts = name.split("@");
return parts[0];
}
private class ConsoleInputStream extends InputStream {
private int read(boolean wait) throws IOException {
if (!running) {
return -1;
}
checkInterrupt();
if (eof && queue.isEmpty()) {
return -1;
}
Integer i;
if (wait) {
try {
i = queue.take();
} catch (InterruptedException e) {
throw new InterruptedIOException();
}
checkInterrupt();
} else {
i = queue.poll();
}
if (i == null) {
return -1;
}
return i;
}
@Override
public int read() throws IOException {
return read(true);
}
@Override
public int read(byte b[], int off, int len) throws IOException {
if (b == null) {
throw new NullPointerException();
} else if (off < 0 || len < 0 || len > b.length - off) {
throw new IndexOutOfBoundsException();
} else if (len == 0) {
return 0;
}
int nb = 1;
int i = read(true);
if (i < 0) {
return -1;
}
b[off++] = (byte) i;
while (nb < len) {
i = read(false);
if (i < 0) {
return nb;
}
b[off++] = (byte) i;
nb++;
}
return nb;
}
@Override
public int available() throws IOException {
return queue.size();
}
}
private class Pipe extends Thread {
public Pipe() {
super("Karaf shell pipe thread");
setDaemon(true);
}
public void run() {
boolean useAvailable = !System.getProperty("os.name").toLowerCase().contains("windows");
try {
while (running) {
try {
while (useAvailable && in.available() == 0) {
if (!running) {
return;
}
Thread.sleep(50);
}
int c = in.read();
if (c == -1) {
return;
} else if (c == 4 && !ShellUtil.getBoolean(ConsoleSessionImpl.this, Session.IGNORE_INTERRUPTS)) {
err.print("^D");
err.flush();
return;
} else if (c == 3 && !ShellUtil.getBoolean(ConsoleSessionImpl.this, Session.IGNORE_INTERRUPTS)) {
err.println("^C");
reader.getCursorBuffer().clear();
ConsoleSessionImpl.this.interrupt();
}
queue.put(c);
} catch (Throwable t) {
return;
}
}
} finally {
eof = true;
try {
queue.put(-1);
} catch (InterruptedException e) {
}
}
}
}
}