Example #1
0
  public static void installCustomFormatter() {
    final boolean installCustomFormatter =
        Boolean.parseBoolean(
            OSystemVariableResolver.resolveSystemVariables(
                "${" + ENV_INSTALL_CUSTOM_FORMATTER + "}", "true"));

    if (!installCustomFormatter) return;

    try {
      // ASSURE TO HAVE THE ORIENT LOG FORMATTER TO THE CONSOLE EVEN IF NO CONFIGURATION FILE IS
      // TAKEN
      final Logger log = Logger.getLogger("");
      if (log.getHandlers().length == 0) {
        // SET DEFAULT LOG FORMATTER
        final Handler h = new ConsoleHandler();
        h.setFormatter(new OLogFormatter());
        log.addHandler(h);
      } else {
        for (Handler h : log.getHandlers()) {
          if (h instanceof ConsoleHandler
              && !h.getFormatter().getClass().equals(OLogFormatter.class))
            h.setFormatter(new OLogFormatter());
        }
      }
    } catch (Exception e) {
      System.err.println(
          "Error while installing custom formatter. Logging could be disabled. Cause: "
              + e.toString());
    }
  }
Example #2
0
  public static synchronized void createLoggers(boolean reinit) {

    if (m_initialized == true && reinit == false) {
      return;
    }

    if (!m_initialized) {
      Logger.getLogger("").removeHandler(Logger.getLogger("").getHandlers()[0]);
    }

    if (m_initialized) {
      m_severeLogger.removeHandler(m_severeLogger.getHandlers()[0]);
      m_nonSevereLogger.removeHandler(m_nonSevereLogger.getHandlers()[0]);
    }

    Handler severeHandler = new AMyConsoleHandler(System.err);
    severeHandler.setFormatter(new SingleLineFormatter());
    m_severeLogger.addHandler(severeHandler);
    m_severeLogger.setLevel(getLoggingLevel());

    Handler nonSevereHandler = new AMyConsoleHandler(System.out);
    nonSevereHandler.setFormatter(new SingleLineFormatter());
    m_nonSevereLogger.addHandler(nonSevereHandler);
    m_nonSevereLogger.setLevel(getLoggingLevel());

    m_initialized = true;
  }
Example #3
0
  /**
   * Set up a pair of Handlers for jOVAL system logging events, one logging to the specified logFile
   * and the other to the console, at the indicated logging level, and return a Logger configured to
   * use them.
   */
  public static Logger createDuplex(File logFile, Level level) throws IOException {
    Handler logfileHandler = new FileHandler(logFile.getPath(), false);
    logfileHandler.setFormatter(new LogFormatter(Type.FILE));
    logfileHandler.setLevel(level);

    Handler consoleHandler = new ConsoleHandler();
    consoleHandler.setFormatter(new LogFormatter(Type.CONSOLE));
    consoleHandler.setLevel(level);

    Logger logger = Logger.getLogger(JOVALMsg.getLogger().getName());
    logger.setLevel(level);
    logger.addHandler(logfileHandler);
    logger.addHandler(consoleHandler);
    return logger;
  }
  public void initialize() throws Exception {
    LogManager logManager = LogManager.getLogManager();
    logManager.reset();

    File logDir = new File(PlatformUtils.getWorkingDirectory() + File.separator + "Logs");
    logDir.mkdirs();

    Handler fileHandler =
        new FileHandler(new File(logDir, "spoutcraft_%g.log").getPath(), 100000, 5, true);
    fileHandler.setFormatter(new ClientLoggerFormatter());
    Logger.getLogger("").addHandler(fileHandler);

    PrintStream stdout = System.out;
    /*PrintStream stderr = System.err;*/

    Handler ConsoleHandle = new StreamHandler(stdout, new ClientLoggerFormatter());
    Logger.getLogger("").addHandler(ConsoleHandle);

    /*Handler ErrHandle = new StreamHandler(stderr, new ClientLoggerFormatter());
    Logger.getLogger("").addHandler(ErrHandle);  */

    Logger logger;
    SystemListenerStream los;

    logger = Logger.getLogger("stdout");
    los = new SystemListenerStream(logger, SystemListenerLevel.STDOUT);
    System.setOut(new PrintStream(los, true));

    /*logger = Logger.getLogger("stderr");
    los= new SystemListenerStream(logger, SystemListenerLevel.STDERR);
    System.setErr(new PrintStream(los, true));*/

  }
  private UnexpectedErrorLogger() throws SecurityException, IOException {
    handler = new FileHandler("UnexpecterErrorLogger");
    formatter = new SimpleFormatter();

    handler.setFormatter(formatter);
    logger.addHandler(handler);
  }
Example #6
0
  private static void initLogger(Level loglevel) {
    logger.setLevel(loglevel);
    logger.setUseParentHandlers(false);

    Handler handler = new ConsoleHandler();
    handler.setFormatter(
        new Formatter() {
          @Override
          public String format(LogRecord record) {
            GregorianCalendar cal = new GregorianCalendar();
            cal.setTimeInMillis(record.getMillis());

            StringBuilder out = new StringBuilder();
            out.append(
                String.format(
                    "[ %02d:%02d:%02d ] ",
                    cal.get(Calendar.HOUR_OF_DAY),
                    cal.get(Calendar.MINUTE),
                    cal.get(Calendar.SECOND)));
            out.append(record.getLevel().getName()).append(": ").append(record.getMessage());
            if (logger.getLevel().intValue() <= Level.FINE.intValue()) {
              out.append("  [ ")
                  .append(record.getSourceClassName())
                  .append(".")
                  .append(record.getSourceMethodName())
                  .append("() ]");
            }
            out.append(System.getProperty("line.separator"));

            return out.toString();
          }
        });
    logger.addHandler(handler);
  }
Example #7
0
 public static void main(String args[]) {
   try {
     Handler fh = new FileHandler("logging.txt");
     fh.setFormatter(new SimpleFormatter());
     java.util.logging.Logger.getLogger("de.javawi.stun").addHandler(fh);
     java.util.logging.Logger.getLogger("de.javawi.stun").setLevel(Level.ALL);
     BindingLifetimeTest test = new BindingLifetimeTest("jstun.javawi.de", 3478);
     // iphone-stun.freenet.de:3478
     // larry.gloo.net:3478
     // stun.xten.net:3478
     test.test();
     boolean continueWhile = true;
     while (continueWhile) {
       Thread.sleep(5000);
       if (test.getLifetime() != -1) {
         System.out.println(
             "Lifetime: " + test.getLifetime() + " Finished: " + test.isCompleted());
         if (test.isCompleted()) continueWhile = false;
       }
     }
   } catch (Exception e) {
     System.out.println(e.getMessage());
     e.printStackTrace();
   }
 }
Example #8
0
 static {
   Formatter formatter = new SingleLineFormatter();
   Logger rootLogger = Logger.getLogger("");
   for (Handler h : rootLogger.getHandlers()) {
     h.setFormatter(formatter);
   }
 }
  public static void main(String[] args) {
    JmeFormatter formatter = new JmeFormatter();

    Handler consoleHandler = new ConsoleHandler();
    consoleHandler.setFormatter(formatter);

    Logger.getLogger("").removeHandler(Logger.getLogger("").getHandlers()[0]);
    Logger.getLogger("").addHandler(consoleHandler);

    createCanvas(appClass);

    try {
      Thread.sleep(500);
    } catch (InterruptedException ex) {
    }

    SwingUtilities.invokeLater(
        new Runnable() {
          public void run() {
            JPopupMenu.setDefaultLightWeightPopupEnabled(false);

            createFrame();

            currentPanel.add(canvas, BorderLayout.CENTER);
            frame.pack();
            startApp();
            frame.setLocationRelativeTo(null);
            frame.setVisible(true);
          }
        });
  }
Example #10
0
 public void startFile(String logfile) {
   File parent = new File(logfile).getParentFile();
   if (!parent.isDirectory() && !parent.mkdirs()) {
     logger.warning("Could not create log folder: " + parent);
   }
   Handler fileHandler = new RotatingFileHandler(logfile);
   fileHandler.setFormatter(new DateOutputFormatter(FILE_DATE));
   logger.addHandler(fileHandler);
 }
Example #11
0
 private Import() {
   try {
     Handler fh = new FileHandler("%h/jgnashimport%g.log");
     fh.setFormatter(new SimpleFormatter());
     logger.addHandler(fh);
     logger.setLevel(Level.FINE);
   } catch (IOException ioe) {
     logger.severe("Could not install file handler");
   }
 }
Example #12
0
 @Override
 public Handler getHandler() {
   Handler handler = null;
   try {
     handler = new ConsoleHandler();
     handler.setFormatter(new SimpleFormatter());
   } catch (Exception e) {
     LoggerManager.DEFAULT_LOGGER.severe(ERROR_MESSAGE);
   }
   return handler;
 }
Example #13
0
 static {
   if ((System.getProperty("java.util.logging.config.file") == null)
       && (System.getProperty("java.util.logging.config.class") == null)) {
     LOGGER.setUseParentHandlers(false);
     final Handler handler = new ConsoleHandler();
     handler.setFormatter(new PlainFormatter());
     addOrSetHandler(handler);
     LOGGER.setLevel(Level.INFO);
     handler.setLevel(Level.ALL);
   }
 }
Example #14
0
  /**
   * Initialization of the task.
   *
   * @throws BuildException in case an error occured
   */
  @Override
  public void init() throws BuildException {
    Logger baselogger = Logger.getLogger("org.cesta");
    baselogger.setLevel(Level.ALL);

    // we want to disable other handlers and pass everything to Ant
    for (Handler h : baselogger.getHandlers()) baselogger.removeHandler(h);

    // create TaskLogHandler, which forwards all messages to Ant logging subsystem
    Handler handler = new TaskLogHandler(this);
    handler.setFormatter(new TaskLogFormatter());
    handler.setLevel(Level.ALL);
    baselogger.addHandler(handler);
  }
Example #15
0
 void initialize() {
   // set this as a top level logger, to control console level
   logger = Logger.getLogger("com.jaivox.util.Log");
   logger.setUseParentHandlers(false);
   Handler hConsole = new ConsoleHandler();
   hConsole.setFormatter(new Logformat());
   hConsole.setLevel(Level.FINEST);
   logger.addHandler(hConsole);
   logger.setLevel(Level.FINEST);
   // what is the level of this logger?
   String s = logger.getLevel().toString();
   System.out.println("Logger log level after creating " + s);
   initialized = true;
 }
Example #16
0
  private static void configureLogging(CommandLineOptionHelper helper) {
    Level logLevel =
        helper.isParamPresent("-debug") ? Level.FINE : LoggingOptions.getDefaultLogLevel();
    if (logLevel == null) {
      logLevel = Level.INFO;
    }
    Logger.getLogger("").setLevel(logLevel);
    Logger.getLogger("org.openqa.jetty").setLevel(Level.WARNING);

    String logFilename =
        helper.isParamPresent("-log")
            ? helper.getParamValue("-log")
            : LoggingOptions.getDefaultLogOutFile();
    if (logFilename != null) {
      for (Handler handler : Logger.getLogger("").getHandlers()) {
        if (handler instanceof ConsoleHandler) {
          Logger.getLogger("").removeHandler(handler);
        }
      }
      try {
        Handler logFile = new FileHandler(new File(logFilename).getAbsolutePath(), true);
        logFile.setFormatter(new TerseFormatter(true));
        logFile.setLevel(logLevel);
        Logger.getLogger("").addHandler(logFile);
      } catch (IOException e) {
        throw new RuntimeException(e);
      }
    } else {
      boolean logLongForm = helper.isParamPresent("-logLongForm");
      for (Handler handler : Logger.getLogger("").getHandlers()) {
        if (handler instanceof ConsoleHandler) {
          handler.setLevel(logLevel);
          handler.setFormatter(new TerseFormatter(logLongForm));
        }
      }
    }
  }
Example #17
0
  private Handler setupLogHandler(String fileName) {
    Handler handler;
    try {
      checkDirectory(logRoot);
      handler =
          new FileHandler(
              logRoot + System.getProperty("file.separator") + fileName + ".txt", 0, 1, true);
      handler.setFormatter(new SimpleFormatter());
    } catch (IOException e) {
      throw new RuntimeException(e);
    }
    Logger.getLogger("").addHandler(handler);

    return handler;
  }
  private static Logger createLogger() {
    Handler fh = null;

    try {
      fh = new FileHandler("logs/Disassembler.java.log");
    } catch (IOException e) {
      e.printStackTrace();
      System.exit(0);
    }

    Logger logger = Logger.getLogger(Disassembler.class.getName());
    logger.setUseParentHandlers(false);
    SimpleFormatter formatter = new SimpleFormatter();
    fh.setFormatter(formatter);
    logger.addHandler(fh);

    return logger;
  }
Example #19
0
  private static void initLogger() throws IOException {
    File logFolder = new File(BBCTMain.LOG_FOLDER_NAME);

    if (!logFolder.exists()) {
      logFolder.mkdir();
    }

    // TODO: Configure logger using a property file.
    boolean append = true;
    Handler handler = new FileHandler(BBCTMain.LOG_FILE_NAME, append);
    handler.setFormatter(new SimpleFormatter());

    Logger logger = Logger.getLogger("");
    logger.setLevel(Level.INFO);
    logger.addHandler(handler);

    // TODO: Should I set this in a property file?
    System.setProperty("hsqldb.reconfig_logging", "false");
  }
Example #20
0
 public static synchronized LocalOnlyAcsLogger getInstance(String namespace, Level level) {
   if (instance == null) {
     LogConfig testLogConfig = new LogConfig();
     testLogConfig.setDefaultMinLogLevelLocal(AcsLogLevel.getNativeLevel(level).getAcsLevel());
     instance = new LocalOnlyAcsLogger(namespace, testLogConfig);
     instance.setUseParentHandlers(false);
     Handler logHandler = new StdOutConsoleHandler(testLogConfig, namespace, null);
     logHandler.setFormatter(
         new AcsXMLLogFormatter() {
           public String format(LogRecord lr) {
             String xml = super.format(lr);
             return xml + '\n';
           }
         });
     logHandler.setLevel(level);
     instance.addHandler(logHandler);
   }
   return instance;
 }
  public static void main(String[] args) {
    board = new Board(new State(100, 100), new State(400, 400));
    logger = Logger.getLogger(main.class.getName());
    finalCost = 0;

    try {
      handler = new FileHandler("logfile%g.txt");
      handler.setFormatter(new SimpleFormatter());
      logger.addHandler(handler);
    } catch (IOException Err) {
      System.out.println(Err.getMessage());
      logger.log(Level.WARNING, "Error creating log file.");
    }

    try {
      board.setBoard("terrain.png");
      logger.log(Level.INFO, "Loaded terrain image.");
    } catch (IOException NoFile) {
      logger.log(Level.SEVERE, "Error loading terrain image.");
      logger.log(Level.SEVERE, NoFile.getMessage());
      return;
    }

    board.createOutImage();

    logger.log(Level.INFO, "Starting.");
    finalCost = board.findPath(logger);
    if (finalCost == -1) {
      logger.log(Level.INFO, "No path found.");
    } else {
      logger.log(Level.INFO, "Cost was " + Integer.toString(finalCost));
    }

    board.drawPath();
    logger.log(Level.INFO, "Creating output image.");
    try {
      board.setOutImage("path.png");
    } catch (IOException FileErr) {
      logger.log(Level.SEVERE, "Error creating path image.");
    }

    logger.log(Level.INFO, "Complete.");
  }
 /**
  * A simple file logger which outputs only the message.
  *
  * @param fileName path to the output file
  * @return the logger
  */
 private static Logger getFileLogger(String fileName) {
   // make sure parent directories exist
   new File(fileName).getParentFile().mkdirs();
   final Logger logger = Logger.getLogger(fileName);
   try {
     logger.setUseParentHandlers(false);
     Handler handler = new FileHandler(fileName, true);
     handler.setFormatter(
         new Formatter() {
           @Override
           public String format(LogRecord record) {
             return record.getMessage() + "\n";
           }
         });
     logger.addHandler(handler);
   } catch (Exception e) {
     throw new RuntimeException(e);
   }
   return logger;
 }
Example #23
0
  /**
   * Utility main for importing a log into a BDB-JE environment or moving a database between
   * environments (2 arguments), or simply dumping a log to stderr in a more readable format (1
   * argument).
   *
   * @param args command-line arguments
   * @throws DatabaseException
   * @throws IOException
   */
  public static void main(String[] args) throws DatabaseException, IOException {
    Handler handler = new ConsoleHandler();
    handler.setLevel(Level.ALL);
    handler.setFormatter(new OneLineSimpleLogger());
    logger.addHandler(handler);
    logger.setUseParentHandlers(false);

    if (args.length == 2) {
      logger.setLevel(Level.INFO);
      populatePersistEnv(args[0], new File(args[1]));
    } else if (args.length == 1) {
      logger.setLevel(Level.FINE);
      populatePersistEnv(args[0], null);
    } else {
      System.out.println("Arguments: ");
      System.out.println("    source [target]");
      System.out.println("...where source is either a txtser log file or BDB env dir");
      System.out.println("and target, if present, is a BDB env dir. ");
      return;
    }
  }
  private static void configureLogging() throws IOException {
    // We're no longer using LogManager and a logging.properties file to initialize
    // java.util.logging, because of
    // a limitation with Webstart limiting the use of handlers and formatters residing in the
    // system's classpath,
    // i.e. built-in ones.

    //        // Read the java.util.logging configuration file bundled with the muCommander JAR,
    // replacing the JRE's
    //        // logging.properties configuration.
    //        InputStream resIn =
    // ResourceLoader.getRootPackageAsFile(Launcher.class).getChild("com/mucommander/logging.properties").getInputStream();
    //        LogManager.getLogManager().readConfiguration(resIn);
    //        resIn.close();

    // Remove default handlers
    Logger rootLogger = LogManager.getLogManager().getLogger("");
    Handler handlers[] = rootLogger.getHandlers();
    for (Handler handler : handlers) rootLogger.removeHandler(handler);

    // and add ours
    handlers = new Handler[] {new ConsoleHandler(), new DebugConsoleHandler()};
    Formatter formatter = new SingleLineFormatter();
    for (Handler handler : handlers) {
      handler.setFormatter(formatter);
      rootLogger.addHandler(handler);
    }

    // Set the log level to the value defined in the configuration
    updateLogLevel(getLogLevel());

    //        Logger fileLogger = FileLogger.getLogger();
    //        fileLogger.finest("fileLogger finest");
    //        fileLogger.finer("fileLogger finer");
    //        fileLogger.fine("fileLogger fine");
    //        fileLogger.config("fileLogger config");
    //        fileLogger.info("fileLogger info");
    //        fileLogger.warning("fileLogger warning");
    //        fileLogger.severe("fileLogger severe");
  }
Example #25
0
  /** @throws IllegalArgumentException */
  private static void createLoggerIfNotExists() throws IllegalArgumentException {

    // Nothing to do if already exists
    if (CLIENT_LOGGER != null) {
      return;
    }

    try {

      File logDir =
          new File(FrameworkFileUtil.getUserHomeDotKawansoftDir() + File.separator + "log");
      logDir.mkdirs();

      String logFilePattern = logDir.toString() + File.separator + "KawanfwClient.log";

      CLIENT_LOGGER = Logger.getLogger("ClientLogger");
      int limit = 50 * 1024 * 1024;
      Handler fh = new FileHandler(logFilePattern, limit, 4, true);
      fh.setFormatter(new SingleLineFormatterUtil(false));
      CLIENT_LOGGER.addHandler(fh);
    } catch (Exception e) {
      throw new IllegalArgumentException("Impossible to create the CLIENT_LOGGER logger", e);
    }
  }
Example #26
0
  public static Logger initLogger() {
    Logger initlogger = Logger.getLogger(settings.getMainClass());
    initlogger.setLevel(settings.getLogLevel());
    boolean addconsole = false;
    if (settings.getLogToFile()) {
      try {
        Handler handler = new FileHandler(settings.getLogFile(), true);
        handler.setFormatter(new SimpleFormatter());
        initlogger.addHandler(handler);
      } catch (Exception e) {
        Logger().warning("Could not set logfile " + settings.getLogFile() + ": " + e.getMessage());
        addconsole = true;
      }
    }
    addconsole = settings.getLogToConsole() || addconsole;
    if (addconsole) {
      initlogger.addHandler(new ConsoleHandler());
    }
    // restore original log state
    logger.setLevel(templevel);
    templevel = null;

    return initlogger;
  }
Example #27
0
  public static void main(String[] args) throws Exception {
    Security.addProvider(new BouncyCastleProvider()); // add
    logger.setUseParentHandlers(false);
    Handler ch = new ConsoleHandler();
    ch.setFormatter(new TextFormatter());
    logger.addHandler(ch);

    if (args == null
        || (args.length != 1 && args.length != 2 && args.length != 5 && args.length != 6)) {
      usage();
      return;
    }
    InetSocketAddress listen;
    try {
      int port = Integer.parseInt(args[0]);
      listen = new InetSocketAddress("localhost", port);
    } catch (NumberFormatException nfe) {
      usage();
      return;
    }
    String proxy = "DIRECT";
    if (args.length == 2 || args.length == 6) {
      proxy = args[1];
    }
    DataSource dataSource = null;
    if (args.length == 5) {
      dataSource = createDataSource(args[1], args[2], args[3], args[4]);
    } else if (args.length == 6) {
      dataSource = createDataSource(args[2], args[3], args[4], args[5]);
    }

    final ProxySelector ps = getProxySelector(proxy);

    DefaultHttpRequestHandler drh =
        new DefaultHttpRequestHandler() {
          @Override
          protected HttpClient createClient() {
            HttpClient client = super.createClient();
            client.setProxySelector(ps);
            client.setSoTimeout(90000);
            return client;
          }
        };
    ServerGroup sg = new ServerGroup();
    sg.addServer(listen);
    drh.setServerGroup(sg);
    HttpRequestHandler rh = drh;
    rh = new LoggingHttpRequestHandler(rh);

    if (dataSource != null) {
      JdbcMessageDAO dao = new JdbcMessageDAO();
      dao.setDataSource(dataSource);
      dao.createTables();
      rh = new RecordingHttpRequestHandler(dao, rh, 1024 * 1024);
      rh = new ConversationServiceHttpRequestHandler("127.0.0.2", dao, rh);
    }
    BufferedMessageInterceptor bmi =
        new BufferedMessageInterceptor() {
          @Override
          public Action directResponse(RequestHeader request, MutableResponseHeader response) {
            // System.err.println(new String(request.getHeader())
            // + "+++++++++++\n" + new String(response.getHeader())
            // + "===========");
            return Action.BUFFER;
          }

          @Override
          public Action directRequest(MutableRequestHeader request) {
            // System.err.println(new String(request.getHeader())
            // + "===========");
            return Action.BUFFER;
          }
        };
    rh = new BufferingHttpRequestHandler(rh, bmi, 1024 * 1024);

    HttpProxyConnectionHandler hpch = new HttpProxyConnectionHandler(rh);
    SSLContextSelector cp = getSSLContextSelector();
    TargetedConnectionHandler tch = new SSLConnectionHandler(cp, true, hpch);
    tch = new LoopAvoidingTargetedConnectionHandler(sg, tch);
    hpch.setConnectHandler(tch);
    TargetedConnectionHandler socks = new SocksConnectionHandler(tch, true);
    Proxy p = new Proxy(listen, socks, null);
    p.setSocketTimeout(90000);
    p.start();

    System.out.println("Listener started on " + listen);
    System.out.println("Press Enter to terminate");
    new BufferedReader(new InputStreamReader(System.in)).readLine();
    p.stop();
    System.out.println("Terminated");
    System.exit(0);
  }
Example #28
0
 private static void setGLogFormatter(Logger logger) {
   for (Handler h : logger.getHandlers()) {
     h.setFormatter(new LogFormatter());
   }
 }
Example #29
0
File: Util.java Project: ncdc/qpid
  protected Util(String[] args) {
    CommandLineParser cmdLineParse = new PosixParser();

    Options options = new Options();
    options.addOption("h", "help", false, "show this help message and exit");
    options.addOption(
        OptionBuilder.withLongOpt("host")
            .withDescription("host to connect to (default 0.0.0.0)")
            .hasArg(true)
            .withArgName("HOST")
            .create('H'));
    options.addOption(
        OptionBuilder.withLongOpt("username")
            .withDescription("username to use for authentication")
            .hasArg(true)
            .withArgName("USERNAME")
            .create('u'));
    options.addOption(
        OptionBuilder.withLongOpt("password")
            .withDescription("password to use for authentication")
            .hasArg(true)
            .withArgName("PASSWORD")
            .create('w'));
    options.addOption(
        OptionBuilder.withLongOpt("port")
            .withDescription("port to connect to (default 5672)")
            .hasArg(true)
            .withArgName("PORT")
            .create('p'));
    options.addOption(
        OptionBuilder.withLongOpt("frame-size")
            .withDescription("specify the maximum frame size")
            .hasArg(true)
            .withArgName("FRAME_SIZE")
            .create('f'));
    options.addOption(
        OptionBuilder.withLongOpt("container-name")
            .withDescription("Container name")
            .hasArg(true)
            .withArgName("CONTAINER_NAME")
            .create('C'));

    options.addOption(OptionBuilder.withLongOpt("ssl").withDescription("Use SSL").create('S'));

    options.addOption(
        OptionBuilder.withLongOpt("remote-hostname")
            .withDescription("hostname to supply in the open frame")
            .hasArg(true)
            .withArgName("HOST")
            .create('O'));

    if (hasBlockOption())
      options.addOption(
          OptionBuilder.withLongOpt("block")
              .withDescription("block until messages arrive")
              .create('b'));

    if (hasCountOption())
      options.addOption(
          OptionBuilder.withLongOpt("count")
              .withDescription("number of messages to send (default 1)")
              .hasArg(true)
              .withArgName("COUNT")
              .create('c'));
    if (hasModeOption())
      options.addOption(
          OptionBuilder.withLongOpt("acknowledge-mode")
              .withDescription(
                  "acknowledgement mode: AMO|ALO|EO (At Least Once, At Most Once, Exactly Once")
              .hasArg(true)
              .withArgName("MODE")
              .create('k'));

    if (hasSubjectOption())
      options.addOption(
          OptionBuilder.withLongOpt("subject")
              .withDescription("subject message property")
              .hasArg(true)
              .withArgName("SUBJECT")
              .create('s'));

    if (hasSingleLinkPerConnectionMode())
      options.addOption(
          OptionBuilder.withLongOpt("single-link-per-connection")
              .withDescription(
                  "acknowledgement mode: AMO|ALO|EO (At Least Once, At Most Once, Exactly Once")
              .hasArg(false)
              .create('Z'));

    if (hasFilterOption())
      options.addOption(
          OptionBuilder.withLongOpt("filter")
              .withDescription("filter, e.g. exact-subject=hello; matching-subject=%.a.#")
              .hasArg(true)
              .withArgName("<TYPE>=<VALUE>")
              .create('F'));

    if (hasTxnOption()) {
      options.addOption("x", "txn", false, "use transactions");
      options.addOption(
          OptionBuilder.withLongOpt("batch-size")
              .withDescription("transaction batch size (default: 1)")
              .hasArg(true)
              .withArgName("BATCH-SIZE")
              .create('B'));
      options.addOption(
          OptionBuilder.withLongOpt("rollback-ratio")
              .withDescription("rollback ratio - must be between 0 and 1 (default: 0)")
              .hasArg(true)
              .withArgName("RATIO")
              .create('R'));
    }

    if (hasLinkDurableOption()) {
      options.addOption("d", "durable-link", false, "use a durable link");
    }

    if (hasStdInOption())
      options.addOption("i", "stdin", false, "read messages from stdin (one message per line)");

    options.addOption(
        OptionBuilder.withLongOpt("trace")
            .withDescription("trace logging specified categories: RAW, FRM")
            .hasArg(true)
            .withArgName("TRACE")
            .create('t'));
    if (hasSizeOption())
      options.addOption(
          OptionBuilder.withLongOpt("message-size")
              .withDescription("size to pad outgoing messages to")
              .hasArg(true)
              .withArgName("SIZE")
              .create('z'));

    if (hasResponseQueueOption())
      options.addOption(
          OptionBuilder.withLongOpt("response-queue")
              .withDescription("response queue to reply to")
              .hasArg(true)
              .withArgName("RESPONSE_QUEUE")
              .create('r'));

    if (hasLinkNameOption()) {
      options.addOption(
          OptionBuilder.withLongOpt("link")
              .withDescription("link name")
              .hasArg(true)
              .withArgName("LINK")
              .create('l'));
    }

    if (hasWindowSizeOption()) {
      options.addOption(
          OptionBuilder.withLongOpt("window-size")
              .withDescription("credit window size")
              .hasArg(true)
              .withArgName("WINDOW-SIZE")
              .create('W'));
    }

    CommandLine cmdLine = null;
    try {
      cmdLine = cmdLineParse.parse(options, args);

    } catch (ParseException e) {
      printUsage(options);
      System.exit(-1);
    }

    if (cmdLine.hasOption('h') || cmdLine.getArgList().isEmpty()) {
      printUsage(options);
      System.exit(0);
    }
    _host = cmdLine.getOptionValue('H', "0.0.0.0");
    _remoteHost = cmdLine.getOptionValue('O', null);
    String portStr = cmdLine.getOptionValue('p', "5672");
    String countStr = cmdLine.getOptionValue('c', "1");

    _useSSL = cmdLine.hasOption('S');

    if (hasWindowSizeOption()) {
      String windowSizeStr = cmdLine.getOptionValue('W', "100");
      _windowSize = Integer.parseInt(windowSizeStr);
    }

    if (hasSubjectOption()) {
      _subject = cmdLine.getOptionValue('s');
    }

    if (cmdLine.hasOption('u')) {
      _username = cmdLine.getOptionValue('u');
    }

    if (cmdLine.hasOption('w')) {
      _password = cmdLine.getOptionValue('w');
    }

    if (cmdLine.hasOption('F')) {
      _filter = cmdLine.getOptionValue('F');
    }

    _port = Integer.parseInt(portStr);

    _containerName = cmdLine.getOptionValue('C');

    if (hasBlockOption()) _block = cmdLine.hasOption('b');

    if (hasLinkNameOption()) _linkName = cmdLine.getOptionValue('l');

    if (hasLinkDurableOption()) _durableLink = cmdLine.hasOption('d');

    if (hasCountOption()) _count = Integer.parseInt(countStr);

    if (hasStdInOption()) _useStdIn = cmdLine.hasOption('i');

    if (hasSingleLinkPerConnectionMode()) _useMultipleConnections = cmdLine.hasOption('Z');

    if (hasTxnOption()) {
      _useTran = cmdLine.hasOption('x');
      _batchSize = Integer.parseInt(cmdLine.getOptionValue('B', "1"));
      _rollbackRatio = Double.parseDouble(cmdLine.getOptionValue('R', "0"));
    }

    if (hasModeOption()) {
      _mode = AcknowledgeMode.ALO;

      if (cmdLine.hasOption('k')) {
        _mode = AcknowledgeMode.valueOf(cmdLine.getOptionValue('k'));
      }
    }

    if (hasResponseQueueOption()) {
      _responseQueue = cmdLine.getOptionValue('r');
    }

    _frameSize = Integer.parseInt(cmdLine.getOptionValue('f', "65536"));

    if (hasSizeOption()) {
      _messageSize = Integer.parseInt(cmdLine.getOptionValue('z', "-1"));
    }

    String categoriesList = cmdLine.getOptionValue('t');
    String[] categories = categoriesList == null ? new String[0] : categoriesList.split("[, ]");
    for (String cat : categories) {
      if (cat.equalsIgnoreCase("FRM")) {
        FRAME_LOGGER.setLevel(Level.FINE);
        Formatter formatter =
            new Formatter() {
              @Override
              public String format(final LogRecord record) {
                return "[" + record.getMillis() + " FRM]\t" + record.getMessage() + "\n";
              }
            };
        for (Handler handler : FRAME_LOGGER.getHandlers()) {
          FRAME_LOGGER.removeHandler(handler);
        }
        Handler handler = new ConsoleHandler();
        handler.setLevel(Level.FINE);
        handler.setFormatter(formatter);
        FRAME_LOGGER.addHandler(handler);
      } else if (cat.equalsIgnoreCase("RAW")) {
        RAW_LOGGER.setLevel(Level.FINE);
        Formatter formatter =
            new Formatter() {
              @Override
              public String format(final LogRecord record) {
                return "[" + record.getMillis() + " RAW]\t" + record.getMessage() + "\n";
              }
            };
        for (Handler handler : RAW_LOGGER.getHandlers()) {
          RAW_LOGGER.removeHandler(handler);
        }
        Handler handler = new ConsoleHandler();
        handler.setLevel(Level.FINE);
        handler.setFormatter(formatter);
        RAW_LOGGER.addHandler(handler);
      }
    }

    _args = cmdLine.getArgs();
  }
Example #30
0
  public static void main(String[] args) {
    log = Logger.getLogger(Main.class.getName());
    try {
      // Setting up logging

      Logger packageLog = Logger.getLogger(ChatBot.class.getPackage().getName());
      File logFile = new File(LOGFILE + ".log");
      if (logFile.exists()) {
        Calendar cal = Calendar.getInstance();
        File backup =
            new File(
                String.format(
                    "%s_%d_%d_%d.log",
                    LOGFILE,
                    cal.get(Calendar.YEAR),
                    cal.get(Calendar.MONTH) + 1,
                    cal.get(Calendar.DAY_OF_MONTH)));
        if (backup.exists())
          try (BufferedReader reader = new BufferedReader(new FileReader(logFile));
              PrintWriter writer = new PrintWriter(new FileWriter(backup, true))) {
            char buff[] = new char[1024];
            int n;
            while ((n = reader.read(buff)) > 0) {
              writer.write(buff, 0, n);
            }
            log.info("Appened log to backup " + backup.getName());
          } catch (IOException e) {
            log.log(Level.SEVERE, "Couldn't append log to " + backup.getName(), e);
          }
        else {
          try {
            FileUtils.moveFile(logFile, backup);
            log.info("Moved log to backup " + backup.getName());
          } catch (IOException e) {
            log.log(Level.SEVERE, "Couldn't move log to " + backup.getName(), e);
          }
        }
      }

      //noinspection ResultOfMethodCallIgnored
      // logFile.delete();
      Handler handler = new FileHandler(LOGFILE + ".log");
      handler.setFormatter(new SimpleFormatter());
      packageLog.setLevel(Level.FINE);
      packageLog.addHandler(handler);

      // Starting up XMPPCraft
      Main main = new Main();
      PipeInputStream stdinPipe = new PipeInputStream(1048576);
      PipeOutputStream stdoutPipe = new PipeOutputStream();
      main.init(
          System.in, new PipeOutputStream(stdinPipe), new PipeInputStream(stdoutPipe, 1048576));
      System.setIn(stdinPipe);
      System.setOut(new PrintStream(new TeeOutputStream(System.out, stdoutPipe)));
      main.start();
      // Starting up Minecraft
      MinecraftServer.main(args);
      // DummyMinecraftServer.main(args);
    } catch (KeyManagementException
        | NoSuchAlgorithmException
        | SmackException
        | XMPPException
        | IOException e) {
      String filename =
          String.format(
              "crashreport_%s_%s.log",
              e.getClass().getSimpleName(), new SimpleDateFormat("MM_dd.HH_mm").format(new Date()));
      File f = new File(filename);
      try {
        if (f.createNewFile()) {
          PrintWriter out = new PrintWriter(f);
          out.println("Error on startup :");
          out.printf(
              "JVM: %s %s on %s\n",
              System.getProperty("java.vm.name"),
              System.getProperty("java.runtime.version"),
              System.getProperty("os.name"));
          e.printStackTrace(out);
          out.flush();
          out.close();
        }
      } catch (IOException ignore) {
      } // lol what can you do
      log.severe("Crash detected. Generating report.");
    }
  }