Java tutorial
/* * 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.jackrabbit.standalone.cli; import java.io.IOException; import java.io.PrintWriter; import java.util.ArrayList; import java.util.Collection; import java.util.List; import java.util.Locale; import java.util.ResourceBundle; import javax.jcr.InvalidItemStateException; import javax.jcr.Item; import javax.jcr.Node; import javax.jcr.RepositoryException; import jline.ArgumentCompletor; import jline.Completor; import jline.ConsoleReader; import jline.History; import jline.SimpleCompletor; import org.apache.commons.chain.Context; import org.apache.commons.chain.impl.ContextBase; import org.apache.commons.cli.BasicParser; import org.apache.commons.cli.HelpFormatter; import org.apache.commons.cli.Options; import org.apache.commons.cli.ParseException; import org.apache.commons.cli.Parser; import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; import org.apache.jackrabbit.standalone.cli.CommandException; import org.apache.jackrabbit.standalone.cli.CommandHelper; import org.apache.jackrabbit.util.ChildrenCollectorFilter; /** * Command line interface client */ public class JcrClient { /** logger */ private static Log log = LogFactory.getLog(JcrClient.class); /** Resource bundle */ private ResourceBundle bundle = CommandHelper.getBundle(); /** exit control variable */ private boolean exit = false; /** Execution context */ private Context ctx; /** run options */ private Options options; /** * Constructor */ JcrClient() { super(); ctx = new ContextBase(); initOptions(); initContext(); } /** * Constructor * @param ctx * the <code>Context</code> */ public JcrClient(Context ctx) { super(); this.ctx = ctx; } /** * @param args * the arguments */ public static void main(String[] args) { JcrClient client = new JcrClient(); client.run(args); } /** * Run client * @param args * the arguments */ private void run(String[] args) { try { // parse arguments Parser parser = new BasicParser(); org.apache.commons.cli.CommandLine cl = parser.parse(options, args); // Set locale this.setLocale(cl); // Welcome message System.out.println(bundle.getString("word.welcome")); // check interactive mode if (cl.hasOption("source")) { this.runNonInteractive(cl); } else { this.runInteractive(); } } catch (Exception e) { HelpFormatter hf = new HelpFormatter(); hf.printHelp("jcrclient", options); e.printStackTrace(); return; } } /** * jline ConsoleReader tab completor that completes on the children of the * current jcr node (both nodes and properties). * * @author <a href="mailto:alexander(dot)klimetschek(at)mindquarry(dot)com"> * Alexander Klimetschek</a> * */ private class JcrChildrenCompletor implements Completor { public int complete(String buffer, int cursor, List clist) { String start = (buffer == null) ? "" : buffer; Node node; try { node = CommandHelper.getNode(ctx, "."); Collection items = new ArrayList(); ChildrenCollectorFilter collector = new ChildrenCollectorFilter("*", items, true, true, 1); collector.visit(node); for (Object item : items) { String can = ((Item) item).getName(); if (can.startsWith(start)) { clist.add(can); } } return 0; } catch (CommandException e) { e.printStackTrace(); } catch (RepositoryException e) { e.printStackTrace(); } return -1; } } /** * Run in interactive mode * @throws Exception * if an Exception occurs */ public void runInteractive() throws Exception { // built jline console reader with history + tab completion ConsoleReader reader = new ConsoleReader(); reader.setHistory(new History()); reader.setUseHistory(true); // get all available commands for command tab completion Collection<CommandLine> commands = CommandLineFactory.getInstance().getCommandLines(); List<String> commandNames = new ArrayList<String>(); for (CommandLine c : commands) { commandNames.add(c.getName()); for (Object alias : c.getAlias()) { commandNames.add((String) alias); } } commandNames.add("exit"); commandNames.add("quit"); // first part is the command, then all arguments will get children tab completion reader.addCompletor(new ArgumentCompletor(new Completor[] { new SimpleCompletor(commandNames.toArray(new String[] {})), new JcrChildrenCompletor() })); while (!exit) { try { String input = reader.readLine("[" + this.getPrompt() + "] > "); if (input == null) { input = "exit"; } else { input = input.trim(); } log.debug("running: " + input); if (input.equals("exit") || input.equals("quit")) { // exit? exit = true; System.out.println("Good bye..."); } else if (input.length() > 0) { this.runCommand(input); } } catch (JcrParserException e) { System.out.println(e.getLocalizedMessage()); System.out.println(); } catch (Exception e) { handleException(reader, e); } } } /** * Run in non interactive mode * @param cl * the <code>CommandLine</code> * @throws Exception * if an <code>Exception</code> occurs while running the * <code>Command</code> */ private void runNonInteractive(org.apache.commons.cli.CommandLine cl) throws Exception { this.runCommand("source " + cl.getOptionValue("source")); } /** * Parses the input and runs the specified command * @param input * the user's input * @throws Exception * if an <code>Exception</code> occurs while running the * <code>Command</code> */ void runCommand(String input) throws Exception { if (input.startsWith("#") || input.length() == 0) { return; } // Process user input JcrParser parser = new JcrParser(); parser.parse(input); // populate ctx parser.populateContext(ctx); // Execute command long start = System.currentTimeMillis(); parser.getCommand().execute(ctx); long elapsed = System.currentTimeMillis() - start; // depopulate ctx parser.depopulateContext(ctx); // Display elapsed timed System.out.println(); System.out.println(bundle.getString("phrase.elapsedtime") + ": " + elapsed + " ms."); System.out.println(); } /** * Handle the Exception. <br> * Shows a short message and prompt the user to show the entire stacktrace. * @param ex * the <code>Exception</code> to handle */ private void handleException(ConsoleReader cr, Exception ex) { System.out.println(); System.out.println(bundle.getString("exception.occurred")); System.out.println(); System.out.println(bundle.getString("exception") + ": " + ex.getClass().getName()); System.out.println(bundle.getString("word.message") + ": " + ex.getLocalizedMessage()); System.out.println(); String prompt = bundle.getString("phrase.display.stacktrace") + "? [y/n]"; String str = ""; int tries = 0; while (!str.equals("y") && !str.equals("n") && tries < 3) { tries++; try { str = cr.readLine(prompt); } catch (IOException e) { e.printStackTrace(); } } if (str.equals("y")) { ex.printStackTrace(); } } /** * Prompt message * @return prompt the prompt message * @throws RepositoryException * if the current <code>Repository</code> throws a * <code>RepositoryException</code> */ private String getPrompt() throws RepositoryException { try { CommandHelper.getRepository(ctx); } catch (CommandException e) { return bundle.getString("phrase.not.connected"); } boolean unsaved = false; try { unsaved = CommandHelper.getSession(ctx).hasPendingChanges(); } catch (CommandException e) { return bundle.getString("phrase.not.logged.in"); } try { Node n = CommandHelper.getCurrentNode(ctx); // the current node might be Invalid String path; try { path = n.getPath(); } catch (InvalidItemStateException e) { CommandHelper.setCurrentNode(ctx, CommandHelper.getSession(ctx).getRootNode()); path = CommandHelper.getCurrentNode(ctx).getPath(); } if (unsaved) { return path + "*"; } else { return path; } } catch (CommandException e) { return bundle.getString("phrase.not.logged.in"); } } /** * Init allowed CommandLine options */ private void initOptions() { options = new Options(); options.addOption("lang", "code", true, "Language code"); options.addOption("country", "code", true, "Country code"); options.addOption("source", "path", true, "Script for noninteractive mode"); } /** * Sets the default Locale for the given CommandLine * @param cl * the CLI <code>CommandLine</code> * @throws ParseException * if cl can't be parsed */ private void setLocale(org.apache.commons.cli.CommandLine cl) throws ParseException { Locale locale = null; if (cl.hasOption("lang") && cl.hasOption("country")) { locale = new Locale(cl.getOptionValue("lang"), cl.getOptionValue("country")); } if (cl.hasOption("lang") && !cl.hasOption("country")) { locale = new Locale(cl.getOptionValue("lang")); } if (locale != null) { Locale.setDefault(locale); } } /** * Init context. <br> * Sets the Context Output to the console */ private void initContext() { CommandHelper.setOutput(ctx, new PrintWriter(System.out, true)); } }