org.apache.tinkerpop.gremlin.console.Console.groovy Maven / Gradle / Ivy
/*
* 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.tinkerpop.gremlin.console
import jline.TerminalFactory
import jline.console.history.FileHistory
import org.apache.commons.cli.Option
import org.apache.tinkerpop.gremlin.console.commands.BytecodeCommand
import org.apache.tinkerpop.gremlin.console.commands.GremlinSetCommand
import org.apache.tinkerpop.gremlin.console.commands.InstallCommand
import org.apache.tinkerpop.gremlin.console.commands.PluginCommand
import org.apache.tinkerpop.gremlin.console.commands.RemoteCommand
import org.apache.tinkerpop.gremlin.console.commands.SubmitCommand
import org.apache.tinkerpop.gremlin.console.commands.UninstallCommand
import org.apache.tinkerpop.gremlin.groovy.loaders.GremlinLoader
import org.apache.tinkerpop.gremlin.jsr223.CoreGremlinPlugin
import org.apache.tinkerpop.gremlin.jsr223.GremlinPlugin
import org.apache.tinkerpop.gremlin.jsr223.ImportCustomizer
import org.apache.tinkerpop.gremlin.jsr223.console.RemoteException
import org.apache.tinkerpop.gremlin.process.traversal.util.TraversalExplanation
import org.apache.tinkerpop.gremlin.structure.Edge
import org.apache.tinkerpop.gremlin.structure.T
import org.apache.tinkerpop.gremlin.structure.Vertex
import org.apache.tinkerpop.gremlin.util.Gremlin
import org.apache.tinkerpop.gremlin.util.iterator.ArrayIterator
import org.codehaus.groovy.tools.shell.ExitNotification
import org.codehaus.groovy.tools.shell.Groovysh
import org.codehaus.groovy.tools.shell.IO
import org.codehaus.groovy.tools.shell.InteractiveShellRunner
import org.codehaus.groovy.tools.shell.commands.SetCommand
import org.codehaus.groovy.tools.shell.util.HelpFormatter
import org.fusesource.jansi.Ansi
import sun.misc.Signal
import sun.misc.SignalHandler
import java.util.concurrent.atomic.AtomicBoolean
/**
* @author Stephen Mallette (http://stephen.genoprime.com)
*/
class Console {
static {
// this is necessary so that terminal doesn't lose focus to AWT
System.setProperty("java.awt.headless", "true")
Colorizer.installAnsi()
}
private static final String ELLIPSIS = "..."
private Iterator tempIterator = Collections.emptyIterator()
private final IO io
private final Groovysh groovy
private final boolean interactive
public Console(final IO io, final List> scriptsAndArgs, final boolean interactive) {
this.io = io
this.interactive = interactive
if (!io.quiet) {
io.out.println()
io.out.println(" " + Colorizer.render(Preferences.gremlinColor, "\\,,,/"))
io.out.println(" " + Colorizer.render(Preferences.gremlinColor, "(o o)"))
io.out.println("" + Colorizer.render(Preferences.gremlinColor, "-----oOOo-(3)-oOOo-----"))
}
final Mediator mediator = new Mediator(this)
// make sure that remotes are closed on jvm shutdown
addShutdownHook { mediator.close() }
// try to grab ctrl+c to interrupt an evaluation.
final Thread main = Thread.currentThread()
Signal.handle(new Signal("INT"), new SignalHandler() {
@Override
void handle(final Signal signal) {
if (mediator.evaluating.get()) {
io.out.println("Execution interrupted by ctrl+c")
main.interrupt()
}
}
})
groovy = new GremlinGroovysh(mediator)
def commandsToRemove = groovy.getRegistry().commands().findAll { it instanceof SetCommand }
commandsToRemove.each { groovy.getRegistry().remove(it) }
groovy.register(new GremlinSetCommand(groovy))
groovy.register(new UninstallCommand(groovy, mediator))
groovy.register(new InstallCommand(groovy, mediator))
groovy.register(new PluginCommand(groovy, mediator))
groovy.register(new RemoteCommand(groovy, mediator))
groovy.register(new SubmitCommand(groovy, mediator))
groovy.register(new BytecodeCommand(groovy, mediator))
// hide output temporarily while imports execute
showShellEvaluationOutput(false)
def imports = (ImportCustomizer) CoreGremlinPlugin.instance().getCustomizers("gremlin-groovy").get()[0]
imports.getClassPackages().collect { Mediator.IMPORT_SPACE + it.getName() + Mediator.IMPORT_WILDCARD }.each { groovy.execute(it) }
imports.getMethodClasses().collect { Mediator.IMPORT_STATIC_SPACE + it.getCanonicalName() + Mediator.IMPORT_WILDCARD}.each{ groovy.execute(it) }
imports.getEnumClasses().collect { Mediator.IMPORT_STATIC_SPACE + it.getCanonicalName() + Mediator.IMPORT_WILDCARD}.each{ groovy.execute(it) }
final InteractiveShellRunner runner = new InteractiveShellRunner(groovy, handlePrompt)
runner.setErrorHandler(handleError)
try {
final FileHistory history = new FileHistory(new File(ConsoleFs.HISTORY_FILE))
groovy.setHistory(history)
runner.setHistory(history)
} catch (IOException ignored) {
io.err.println(Colorizer.render(Preferences.errorColor, "Unable to create history file: " + ConsoleFs.HISTORY_FILE))
}
GremlinLoader.load()
// check for available plugins on the path and track them by plugin class name
def activePlugins = Mediator.readPluginState()
ServiceLoader.load(GremlinPlugin, groovy.getInterp().getClassLoader()).each { plugin ->
if (!mediator.availablePlugins.containsKey(plugin.class.name)) {
def pluggedIn = new PluggedIn((GremlinPlugin) plugin, groovy, io, false)
mediator.availablePlugins.put(plugin.class.name, pluggedIn)
}
}
// if there are active plugins then initialize them in the order that they are listed
activePlugins.each { pluginName ->
def pluggedIn = mediator.availablePlugins[pluginName]
pluggedIn.activate()
if (!io.quiet)
io.out.println(Colorizer.render(Preferences.infoColor, "plugin activated: " + pluggedIn.getPlugin().getName()))
}
// remove any "uninstalled" plugins from plugin state as it means they were installed, activated, but not
// deactivated, and are thus hanging about (e.g. user deleted the plugin directories to uninstall). checking
// the number of expected active plugins from the plugins.txt file against the number activated on startup
// should be enough to tell if something changed which would justify that the file be re-written
if (activePlugins.size() != mediator.activePlugins().size())
mediator.writePluginState()
try {
// if the init script contains :x command it will throw an ExitNotification so init script execution
// needs to appear in the try/catch
if (scriptsAndArgs != null && !scriptsAndArgs.isEmpty()) executeInShell(scriptsAndArgs)
// start iterating results to show as output
showShellEvaluationOutput(true)
runner.run()
} catch (ExitNotification ignored) {
// occurs on exit
} catch (Throwable t) {
t.printStackTrace()
} finally {
// shutdown hook defined above will kill any open remotes
System.exit(0)
}
}
def showShellEvaluationOutput(final boolean show) {
if (show)
groovy.setResultHook(handleResultIterate)
else
groovy.setResultHook(handleResultShowNothing)
}
private def handlePrompt = {
if (interactive) {
int lineNo = groovy.buffers.current().size()
if (lineNo > 0 ) {
String lineStr = lineNo.toString() + ">"
int pad = Preferences.inputPrompt.length()
return Colorizer.render(Preferences.inputPromptColor, lineStr.toString().padLeft(pad, '.') + ' ')
} else {
return Colorizer.render(Preferences.inputPromptColor, Preferences.inputPrompt + ' ')
}
} else {
return ""
}
}
private def handleResultShowNothing = { args -> null }
private def handleResultIterate = { result ->
try {
// necessary to save persist history to file
groovy.getHistory().flush()
} catch (IOException e) {
throw new RuntimeException(e.getMessage(), e)
}
while (true) {
// give ctrl+c a chance
Thread.yield()
// if this is true then ctrl+c was triggered
if (Thread.interrupted()) {
this.tempIterator = Collections.emptyIterator()
return null
}
if (this.tempIterator.hasNext()) {
int counter = 0
while (this.tempIterator.hasNext() && (Preferences.maxIteration == -1 || counter < Preferences.maxIteration)) {
// give ctrl+c a chance
Thread.yield()
// if this is true then ctrl+c was triggered
if (Thread.interrupted()) {
this.tempIterator = Collections.emptyIterator()
return null
}
printResult(tempIterator.next())
counter++
}
if (this.tempIterator.hasNext())
io.out.println(Colorizer.render(Preferences.resultPromptColor,ELLIPSIS))
this.tempIterator = Collections.emptyIterator()
break
} else {
try {
// if the result is an empty iterator then the tempIterator needs to be set to one, as a
// future assignment to the strategies that produced the iterator will maintain that reference
// and try to iterate it above. in other words, this:
//
// x =[]
// x << "test"
//
// would throw a ConcurrentModificationException because the assignment of x to the tempIterator
// on the first line would maintain a reference on the next result iteration call and would
// drop into the other part of this if statement and throw.
if (result instanceof Iterator) {
this.tempIterator = (Iterator) result
if (!this.tempIterator.hasNext()) {
this.tempIterator = Collections.emptyIterator()
return null
}
} else if (result instanceof Iterable) {
this.tempIterator = ((Iterable) result).iterator()
if (!this.tempIterator.hasNext()) {
this.tempIterator = Collections.emptyIterator()
return null
}
} else if (result instanceof Object[]) {
this.tempIterator = new ArrayIterator((Object[]) result)
if (!this.tempIterator.hasNext()) {
this.tempIterator = Collections.emptyIterator()
return null
}
} else if (result instanceof Map) {
this.tempIterator = ((Map) result).entrySet().iterator()
if (!this.tempIterator.hasNext()) {
this.tempIterator = Collections.emptyIterator()
return null
}
} else if (result instanceof TraversalExplanation) {
final int width = TerminalFactory.get().getWidth()
io.out.println(Colorizer.render(Preferences.resultPromptColor,(buildResultPrompt() + result.prettyPrint(width < 20 ? 80 : width))))
return null
} else {
printResult(result)
return null
}
} catch (final Exception e) {
this.tempIterator = Collections.emptyIterator()
throw e
}
}
}
}
def printResult(def object) {
final String prompt = Colorizer.render(Preferences.resultPromptColor, buildResultPrompt())
// if preference is set to empty string then don't print any result
if (object != null) {
io.out.println(prompt + colorizeResult(object))
} else {
if (!Preferences.emptyResult.isEmpty()) {
io.out.println(prompt + Preferences.emptyResult)
}
}
}
def colorizeResult = { object ->
if (object instanceof Vertex) {
return Colorizer.render(Preferences.vertexColor, object.toString())
} else if (object instanceof Edge) {
return Colorizer.render(Preferences.edgeColor, object.toString())
} else if (object instanceof Iterable) {
List buf = new ArrayList<>()
def pathIter = object.iterator()
while (pathIter.hasNext()) {
Object n = pathIter.next()
buf.add(colorizeResult(n))
}
return ("[" + buf.join(",") + "]")
} else if (object instanceof Map) {
List buf = new ArrayList<>()
object.each{k, v ->
buf.add(colorizeResult(k) + ":" + colorizeResult(v))
}
return ("[" + buf.join(",") + "]")
} else if (object instanceof String) {
return Colorizer.render(Preferences.stringColor, object)
} else if (object instanceof Number) {
return Colorizer.render(Preferences.numberColor, object)
} else if (object instanceof T) {
return Colorizer.render(Preferences.tColor, object)
} else {
return object.toString()
}
}
private def handleError = { err ->
this.tempIterator = Collections.emptyIterator()
if (err instanceof Throwable) {
try {
final Throwable e = (Throwable) err
String message = e.getMessage()
if (null != message) {
message = message.replace("startup failed:", "")
io.err.println(Colorizer.render(Preferences.errorColor, message.trim()))
} else {
io.err.println(Colorizer.render(Preferences.errorColor,e))
}
if (interactive) {
io.err.println(Colorizer.render(Preferences.infoColor,"Type ':help' or ':h' for help."))
io.err.print(Colorizer.render(Preferences.errorColor, "Display stack trace? [yN]"))
io.err.flush()
String line = new BufferedReader(io.in).readLine()
if (null == line)
line = ""
io.err.print(line.trim())
io.err.println()
if (line.trim().equals("y") || line.trim().equals("Y")) {
if (err instanceof RemoteException && err.remoteStackTrace.isPresent()) {
io.err.print(err.remoteStackTrace.get())
io.err.flush()
} else {
e.printStackTrace(io.err)
}
}
} else {
e.printStackTrace(io.err)
System.exit(1)
}
} catch (Exception ignored) {
io.err.println(Colorizer.render(Preferences.errorColor, "An undefined error has occurred: " + err))
if (!interactive) System.exit(1)
}
} else {
io.err.println(Colorizer.render(Preferences.errorColor, "An undefined error has occurred: " + err.toString()))
if (!interactive) System.exit(1)
}
groovy.buffers.current().clear()
return null
}
private static String buildResultPrompt() {
final String groovyshellProperty = System.getProperty("gremlin.prompt")
if (groovyshellProperty != null)
return groovyshellProperty
final String groovyshellEnv = System.getenv("GREMLIN_PROMPT")
if (groovyshellEnv != null)
return groovyshellEnv
return Preferences.resultPrompt
}
private void executeInShell(final List> scriptsAndArgs) {
scriptsAndArgs.eachWithIndex { scriptAndArgs, idx ->
final String scriptFile = scriptAndArgs[0]
try {
// check if this script comes with arguments. if so then set them up in an "args" bundle
if (scriptAndArgs.size() > 1) {
List args = scriptAndArgs.subList(1, scriptAndArgs.size())
groovy.execute("args = [\"" + args.join('\",\"') + "\"]")
} else {
groovy.execute("args = []")
}
File file = new File(scriptFile)
if (!file.exists() && !file.isAbsolute()) {
final String userWorkingDir = System.getProperty("user.working_dir")
if (userWorkingDir != null) {
file = new File(userWorkingDir, scriptFile)
}
}
int lineNumber = 0
def lines = file.readLines()
for (String line : lines) {
try {
lineNumber++
groovy.execute(line)
} catch (Exception ex) {
io.err.println(Colorizer.render(Preferences.errorColor, "Error in $scriptFile at [$lineNumber: $line] - ${ex.message}"))
if (interactive)
break
else {
ex.printStackTrace(io.err)
System.exit(1)
}
}
}
} catch (FileNotFoundException ignored) {
io.err.println(Colorizer.render(Preferences.errorColor, "Gremlin file not found at [$scriptFile]."))
if (!interactive) System.exit(1)
} catch (Exception ex) {
io.err.println(Colorizer.render(Preferences.errorColor, "Failure processing Gremlin script [$scriptFile] - ${ex.message}"))
if (!interactive) System.exit(1)
}
}
if (!interactive) System.exit(0)
}
public static void main(final String[] args) {
Preferences.expandoMagic()
IO io = new IO(System.in, System.out, System.err)
final CliBuilder cli = new CliBuilder(usage: 'gremlin.sh [options] [...]', formatter: new HelpFormatter(), stopAtNonOption: false)
// note that the inclusion of -l is really a setting handled by gremlin.sh and not by Console class itself.
// it is mainly listed here for informational purposes when the user starts things up with -h
cli.with {
h(longOpt: 'help', "Display this help message")
v(longOpt: 'version', "Display the version")
l("Set the logging level of components that use standard logging output independent of the Console")
V(longOpt: 'verbose', "Enable verbose Console output")
Q(longOpt: 'quiet', "Suppress superfluous Console output")
D(longOpt: 'debug', "Enabled debug Console output")
i(longOpt: 'interactive', argName: "SCRIPT ARG1 ARG2 ...", args: Option.UNLIMITED_VALUES, valueSeparator: ' ' as char, "Execute the specified script and leave the console open on completion")
e(longOpt: 'execute', argName: "SCRIPT ARG1 ARG2 ...", args: Option.UNLIMITED_VALUES, valueSeparator: ' ' as char, "Execute the specified script (SCRIPT ARG1 ARG2 ...) and close the console on completion")
C(longOpt: 'color', "Disable use of ANSI colors")
}
OptionAccessor options = cli.parse(args)
if (options == null) {
// CliBuilder prints error, but does not exit
System.exit(22) // Invalid Args
}
if (options.C) {
Ansi.enabled = false
}
if (options.h) {
cli.usage()
System.exit(0)
}
if (options.v) {
if (args.length == 1 && !args[0].startsWith("-"))
new Console(io, [args[0]], true)
println("gremlin " + Gremlin.version())
System.exit(0)
}
if (options.V) io.verbosity = IO.Verbosity.VERBOSE
if (options.D) io.verbosity = IO.Verbosity.DEBUG
if (options.Q) io.verbosity = IO.Verbosity.QUIET
// override verbosity if not explicitly set and -e is used
if (options.e && (!options.V && !options.D && !options.Q))
io.verbosity = IO.Verbosity.QUIET
if (options.i && options.e) {
println("-i and -e options are mutually exclusive - provide one or the other")
System.exit(0)
}
def scriptAndArgs = parseArgs(options.e ? ["-e", "--execute"] : ["-i", "--interactive"], args, cli)
new Console(io, scriptAndArgs, !options.e)
}
/**
* Provides a bit of a hack around the limitations of the {@code CliBuilder}. This method directly parses the
* argument list to allow for multiple {@code -e} and {@code -i} values and parses such parameters into a list
* of lists where the inner list is a script file and its arguments.
*/
private static List> parseArgs(final List options, final String[] args, final CliBuilder cli) {
def parsed = []
def normalizedArgs = normalizeArgs(options, args)
for (int ix = 0; ix < normalizedArgs.length; ix++) {
if (normalizedArgs[ix] in options) {
// increment the counter to move past the option that was found. should now be positioned on the
// first argument to that option
ix++
def parsedSet = []
for (ix; ix < normalizedArgs.length; ix++) {
// this is a do nothing as there's no arguments to the option or it's the start of a new option
if (cli.options.options.any { "-" + it.opt == normalizedArgs[ix] || "--" + it.longOpt == normalizedArgs[ix] }) {
// rollback the counter now that we hit the next option
ix--
break
}
parsedSet << normalizedArgs[ix]
}
if (!parsedSet.isEmpty()) {
// check if the params were passed in with double quotes such that they arrive as a single arg
if (parsedSet.size() == 1)
parsed << parsedSet[0].toString().split(" ").toList()
else
parsed << parsedSet
}
}
}
return parsed
}
/**
* The {@code args} value contains the individual flagged parameters provided on the command line which may come
* with or without an "=" to separate the flag from the argument to the flag. This method normalizes these values
* to split the flag from the argument so that it can be evaluated in a consistent way by {@code parseArgs()}.
*/
private static def normalizeArgs(final List options, final String[] args) {
return args.collect{ arg ->
// arguments that match -i/-e options should be normalized where long forms need to be split on "="
// and short forms need to have the "=" included with the argument
if (options.any{ arg.startsWith(it) }) {
return arg.matches("^-[e,i]=.*") ? [arg.substring(0, 2), arg.substring(2)] : arg.split("=", 2)
}
return arg
}.flatten().toArray()
}
}
© 2015 - 2025 Weber Informatics LLC | Privacy Policy