Java Examples for org.apache.logging.log4j.core.Logger

public static synchronized void stopLogger(Logger log) {
    log.info("stop logger");
    String key = ThreadContext.get("logFileName");
    org.apache.logging.log4j.core.Logger coreLogger = (org.apache.logging.log4j.core.Logger) log;
    org.apache.logging.log4j.core.LoggerContext context = (org.apache.logging.log4j.core.LoggerContext) coreLogger.getContext();
    RoutingAppender appender = (RoutingAppender) context.getConfiguration().getAppender("RoutingAppender");
    try {
        Method method = appender.getClass().getDeclaredMethod("getControl", String.class, LogEvent.class);
        method.setAccessible(true);
        AppenderControl appenderControl = (AppenderControl) method.invoke(appender, key, null);
        appenderControl.getAppender().stop();
    } catch (NoSuchMethodExceptionSecurityException | IllegalAccessException | IllegalArgumentException | InvocationTargetException |  e) {
        log.error("Unable to close the logger", e);
    }
}

/**
     * Filter an event.
     *
     * @param logger
     *            The Logger.
     * @param level
     *            The event logging Level.
     * @param marker
     *            The Marker for the event or null.
     * @param msg
     *            String text to filter on.
     * @param p0 the message parameters
     * @param p1 the message parameters
     * @param p2 the message parameters
     * @param p3 the message parameters
     * @return the Result.
     */
@Override
public Result filter(final Logger logger, final Level level, final Marker marker, final String msg, final Object p0, final Object p1, final Object p2, final Object p3) {
    Result result = Result.NEUTRAL;
    for (int i = 0; i < filters.length; i++) {
        result = filters[i].filter(logger, level, marker, msg, p0, p1, p2, p3);
        if (result == Result.ACCEPT || result == Result.DENY) {
            return result;
        }
    }
    return result;
}

public static void addRootAppenderListener(AppenderListener appenderListener) {
    org.apache.logging.log4j.Logger logger = org.apache.logging.log4j.LogManager.getRootLogger();
    org.apache.logging.log4j.core.Logger coreLogger = (org.apache.logging.log4j.core.Logger) logger;
    InternalAppenderListener internalAppenderListener = new InternalAppenderListener(appenderListener);
    internalAppenderListener.start();
    coreLogger.addAppender(internalAppenderListener);
}

// endregion Tests
// region Private methods
private ApplicationInsightsAppender getApplicationInsightsAppender() {
    Logger logger = LogManager.getRootLogger();
    org.apache.logging.log4j.core.Logger coreLogger = (org.apache.logging.log4j.core.Logger) logger;
    Map<String, Appender> appenderMap = coreLogger.getAppenders();
    ApplicationInsightsAppender appender = (ApplicationInsightsAppender) appenderMap.get("test");
    return appender;
}

public void setLevel(String level) {
    Level new_level = strToLevel(level);
    if (new_level == null)
        return;
    if (logger instanceof org.apache.logging.log4j.core.Logger)
        ((org.apache.logging.log4j.core.Logger) logger).setLevel(new_level);
    else if (logger instanceof SimpleLogger)
        ((SimpleLogger) logger).setLevel(new_level);
}

public static String addFileLogger(String logFile) {
    LoggerContext ctx = (LoggerContext) LogManager.getContext(false);
    Configuration config = ctx.getConfiguration();
    // Default log layout
    Layout<? extends Serializable> layout = PatternLayout.createLayout("%d %p [%t] %m%n", null, null, null, true, true, null, null);
    // Create a new file appender for the given filename
    FileAppender appender = FileAppender.createAppender(logFile, "false", "false", "FileAppender", "false", "true", "true", null, layout, null, null, null, config);
    appender.start();
    ((Logger) LogManager.getRootLogger()).addAppender(appender);
    return appender.getFileName();
}

private Logger getLogger() {
    final ClassLoader currentClassLoader = resolveLoggerContextClassLoader(Thread.currentThread().getContextClassLoader());
    if (useThisLoggerContextClassLoader(currentClassLoader)) {
        return originalLogger;
    }
    // ask contextSelector for the correct context
    return contextSelector.getContext(getName(), currentClassLoader, true).getLogger(getName(), getMessageFactory());
}

/**
	 * 아래는 �바코드� isLevelEnabeld() 메서드와 log4j2.xml� 설정한 Log Level 관계를 테스트하는 메소드
	 * egovframework Logger: level=DEBUG, appender=Console
	 * targetLogger: level=DEBUG, appender=Console
	 * 
	 * 테스트방법
	 * 1. �바코드로 �접 Log Level� 변경해가면서 테스트
	 * */
@Test
public void testLogLevelWithIsLevelEnabled() throws Exception {
    SomeVO vo = new SomeVO();
    vo.setSomeAttr("some");
    // 로그출력
    // 아래 메소드 내�서 호출하는 logger는 log4j2.xml � 존재하지 않으므로
    //  Named Hierarchy� 따� �름� 가장 많� 매칭�는 "egovframework" �름� Logger설정� 따른다.
    // DEBUG, INFO, WARN, ERROR, FATAL � 대한 모든 로그가 출력�
    logTestService.executeSomeLogic(vo);
    // 하단 Console�서 로그 확�
    // 지금부터 LogTestServiceImpl� 선언� Logger� Log Level� 변경해가며 테스트
    // Log Level� 변경� 로그는 Logger� File Appender를 추가하여 ./logs/file/sample.log 파�� 출력하�� 함
    // LogTestServiceImpl� 선언� Logger ��
    Logger targetLogger = (Logger) LogManager.getLogger(LogTestServiceImpl.class.getName());
    assertEquals("egovframework.rte.fdl.logging.sample.service.impl.LogTestServiceImpl", targetLogger.getName());
    // 위 Logger Name으로 설정� 로거가 없으므로 Parent Logger� "egovframework" �름� Logger 설정� 따름 
    Logger parentLogger = targetLogger.getParent();
    assertEquals("egovframework", parentLogger.getName());
    // targetLogger 설정 확�
    assertTrue(targetLogger.isDebugEnabled());
    assertEquals(Level.DEBUG, targetLogger.getLevel());
    assertTrue(!targetLogger.isAdditive());
    // egovframework�는 console appender만 추가�어 있�
    assertNotNull(targetLogger.getAppenders().get("console"));
    assertNull(targetLogger.getAppenders().get("file"));
    // targetLogger�File Appender 추가
    // �를 위해 File Appender 를 가지고 있는 debugLogger로부터 File Appender ��
    Logger debugLogger = (Logger) LogManager.getLogger("egovframework.rte.fdl.logging.sample.LogLevelDebug");
    // debugLogger� 걸린 AppenderRef 설정 확�, "file" �름� File Appender가 설정�어 있�
    Map<String, Appender> appenders = debugLogger.getAppenders();
    FileAppender fileAppender = (FileAppender) appenders.get("file");
    assertNotNull(fileAppender);
    // Parent Logger� �접 추가하면 targetLogger가 참조할 수 있다.
    parentLogger.addAppender(fileAppender);
    // targetLogger.addAppender(fileAppender); --> egovframework Logger� 추가�는 것� 아니다.
    // targetLoggerì—? File Appenderê°€ 추가ë??는지 확ì?¸
    assertNotNull(targetLogger.getAppenders().get("console"));
    assertNotNull(targetLogger.getAppenders().get("file"));
    // targetLogger� Log Level 변경 - INFO
    LogManager.getLogger("sysoutLogger").debug("==== targetLogger� Log Level 변경 - INFO ====");
    targetLogger.setLevel(Level.INFO);
    logTestService.executeSomeLogic(vo);
    String[] tailLines = LogFileUtil.getTailLines(logFile, 4);
    assertTrue(tailLines[0].endsWith("INFO - LogTestServiceImpl.executeSomeLogic executed"));
    assertTrue(tailLines[1].endsWith("WARN - LogTestServiceImpl.executeSomeLogic executed"));
    assertTrue(tailLines[2].endsWith("ERROR - LogTestServiceImpl.executeSomeLogic executed"));
    assertTrue(tailLines[3].endsWith("FATAL - LogTestServiceImpl.executeSomeLogic executed"));
    // targetLogger� Log Level 변경 - WARN
    LogManager.getLogger("sysoutLogger").debug("==== targetLogger� Log Level 변경 - WARN ====");
    targetLogger.setLevel(Level.WARN);
    logTestService.executeSomeLogic(vo);
    // 마지막 ��부터 3줄 까지만 WARN으로 변경한 후 출력� 로그�지만
    // �전 ��터 �부를 함께 가져와 새롭게 �용� 내용� 확�함
    tailLines = LogFileUtil.getTailLines(logFile, 4);
    // �전 INFO 레벨� 때 마지막 �� 확�
    assertTrue(tailLines[0].endsWith("FATAL - LogTestServiceImpl.executeSomeLogic executed"));
    // 새로운 WARN 레벨 �후 기�� �� 확� - WARN �� 로그만 나옴
    assertTrue(tailLines[1].endsWith("WARN - LogTestServiceImpl.executeSomeLogic executed"));
    assertTrue(tailLines[2].endsWith("ERROR - LogTestServiceImpl.executeSomeLogic executed"));
    assertTrue(tailLines[3].endsWith("FATAL - LogTestServiceImpl.executeSomeLogic executed"));
    // targetLogger� Log Level 변경 - ERROR
    LogManager.getLogger("sysoutLogger").debug("==== targetLogger� Log Level 변경 - ERROR ====");
    targetLogger.setLevel(Level.ERROR);
    logTestService.executeSomeLogic(vo);
    // 마지막 ��부터 2줄 까지만 ERROR으로 변경한 후 출력� 로그�지만
    // �전 ��터 �부를 함께 가져와 새롭게 �용� 내용� 확�함
    tailLines = LogFileUtil.getTailLines(logFile, 4);
    // �전 WARN 레벨� 때 마지막 2 �� 확�
    assertTrue(tailLines[0].endsWith("ERROR - LogTestServiceImpl.executeSomeLogic executed"));
    assertTrue(tailLines[1].endsWith("FATAL - LogTestServiceImpl.executeSomeLogic executed"));
    // 새로운 ERROR 레벨 �후 기�� �� 확� - ERROR �� 로그만 나옴
    assertTrue(tailLines[2].endsWith("ERROR - LogTestServiceImpl.executeSomeLogic executed"));
    assertTrue(tailLines[3].endsWith("FATAL - LogTestServiceImpl.executeSomeLogic executed"));
    // targetLogger� Log Level 변경 - FATAL
    targetLogger.setLevel(Level.FATAL);
    LogManager.getLogger("sysoutLogger").debug("==== targetLogger� Log Level 변경 - FATAL ====");
    logTestService.executeSomeLogic(vo);
    // 마지막 ��부터 1줄만 FATAL으로 변경한 후 출력� 로그�지만
    // �전 ��터 �부를 함께 가져와 새롭게 �용� 내용� 확�함
    tailLines = LogFileUtil.getTailLines(logFile, 4);
    // �전 ERROR 레벨� 때 마지막 3 �� 확�
    assertTrue(tailLines[0].endsWith("FATAL - LogTestServiceImpl.executeSomeLogic executed"));
    assertTrue(tailLines[1].endsWith("ERROR - LogTestServiceImpl.executeSomeLogic executed"));
    assertTrue(tailLines[2].endsWith("FATAL - LogTestServiceImpl.executeSomeLogic executed"));
    // 새로운 FATAL 레벨 �후 기�� �� 확� - ERROR �� 로그만 나옴
    assertTrue(tailLines[3].endsWith("FATAL - LogTestServiceImpl.executeSomeLogic executed"));
}

public Object call() throws Exception {
    // Setup for capturing logger messages
    Appender mockAppender = mock(Appender.class);
    when(mockAppender.getName()).thenReturn("MockAppender");
    when(mockAppender.isStarted()).thenReturn(true);
    when(mockAppender.isStopped()).thenReturn(false);
    Logger logger = (Logger) LogManager.getLogger(ColocationLogger.class);
    logger.addAppender(mockAppender);
    logger.setLevel(Level.WARN);
    loggingEventCaptor = ArgumentCaptor.forClass(LogEvent.class);
    // Logger interval may have been hooked by the test, so adjust test delays here
    int logInterval = ColocationLogger.getLogInterval();
    List<LogEvent> logEvents = Collections.emptyList();
    AtomicBoolean isDone = new AtomicBoolean(false);
    try {
        createPR(PR_REGION_NAME, true);
        // Let this thread continue running long enough for the missing region to be logged a
        // couple times.
        // Child regions do not get created by this thread.
        await().atMost(MAX_WAIT, TimeUnit.MILLISECONDS).until(() -> {
            verify(mockAppender, times(numExpectedLogMessages)).append(loggingEventCaptor.capture());
        });
    // createPR("region2", PR_REGION_NAME, true); // This child region is never created
    } finally {
        logEvents = loggingEventCaptor.getAllValues();
        assertEquals(String.format("Expected %d messages to be logged, got %d.", numExpectedLogMessages, logEvents.size()), numExpectedLogMessages, logEvents.size());
        String logMsg = logEvents.get(0).getMessage().getFormattedMessage();
        logger.removeAppender(mockAppender);
        numExpectedLogMessages = 1;
        return logMsg;
    }
}

public void register() {
    Logger rootLogger = (Logger) LogManager.getRootLogger();
    rootLogger.addFilter(new Filter() {

        @Override
        public Result filter(LogEvent event) {
            if (!commandSilencer.isFiltersRegistered())
                return Result.NEUTRAL;
            if (event.getMessage().getFormattedMessage() == null)
                return Result.NEUTRAL;
            if (!event.getLoggerName().endsWith(".PlayerConnection"))
                return Result.NEUTRAL;
            Matcher matcher = commandSilencer.getMatcherForMsg(event.getMessage().getFormattedMessage());
            if (matcher.find()) {
                String username = matcher.group(1);
                String label = matcher.group(2);
                Player player = PlayerUtils.getPlayer(username);
                // typed e.g. "/logni 1234" instead of "/login 1234".
                if (!getSessionManager().isSessionAlive(player) && getCore().isPlayerForcedToLogIn(player)) {
                    return Result.DENY;
                }
                if (commandSilencer.isCommandSilenced(label)) {
                    return Result.DENY;
                }
            }
            return Result.NEUTRAL;
        }

        @Override
        public Result filter(Logger logger, Level level, Marker marker, Message msg, Throwable t) {
            return Result.NEUTRAL;
        }

        @Override
        public Result filter(Logger logger, Level level, Marker marker, Object msg, Throwable t) {
            return Result.NEUTRAL;
        }

        @Override
        public Result filter(Logger logger, Level level, Marker marker, String msg, Object... params) {
            return Result.NEUTRAL;
        }

        @Override
        public Result getOnMismatch() {
            return Result.NEUTRAL;
        }

        @Override
        public Result getOnMatch() {
            return Result.NEUTRAL;
        }
    });
}

@Test
public void testDefaults() throws Exception {
    Logger logger = loggerContext.getLogger(getClass().getName());
    logger.info(LOG_MESSAGE);
    assertThat(GelfTestSender.getMessages()).hasSize(1);
    GelfMessage gelfMessage = GelfTestSender.getMessages().get(0);
    assertThat(gelfMessage.getField("propertyField1")).isEqualTo(System.getProperty("user.language"));
    assertThat(gelfMessage.getField("propertyField2")).isEqualTo("${sys:myproperty}");
    assertThat(gelfMessage.getField("propertyField3")).isEqualTo("${sys:otherproperty:fallback}");
    assertThat(gelfMessage.getField("propertyField4")).isEqualTo("embedded${sys:myproperty}property");
}

@Test
public void canRecordError() throws Exception {
    Logger logger = context.getLogger(this.getClass().getName());
    long initialErrorCount = registry.meter(METRIC_NAME_PREFIX + ".error").getCount();
    logger.error("an error message");
    assertThat(registry.meter(METRIC_NAME_PREFIX + ".all").getCount()).isEqualTo(initialErrorCount + 1);
}

@Test
public void canRecordError() throws Exception {
    Logger logger = context.getLogger(this.getClass().getName());
    long initialErrorCount = registry.meter(METRIC_NAME_PREFIX + ".error").getCount();
    logger.error("an error message");
    assertThat(registry.meter(METRIC_NAME_PREFIX + ".all").getCount()).isEqualTo(initialErrorCount + 1);
}

@Test
public void canRecordError() throws Exception {
    Logger logger = context.getLogger(this.getClass().getName());
    long initialErrorCount = registry.meter(METRIC_NAME_PREFIX + ".error").getCount();
    logger.error("an error message");
    assertThat(registry.meter(METRIC_NAME_PREFIX + ".all").getCount()).isEqualTo(initialErrorCount + 1);
}

/* @Override
  public org.slf4j.Logger getLogger(String name) {
    name = StringUtil2.replace(name.trim(), ' ', "_");
    org.slf4j.Logger result = map.get(name);
    if (result != null) return result;

    try {
      org.apache.logging.log4j.core.Logger log4j = (org.apache.logging.log4j.core.Logger) LogManager.getLogger(name, new MyMessageFactory());
      log4j.info( new MyMapMessage(name));
      startupLog.info("LoggerFactorySpecial add logger= {}", name);

      result = org.slf4j.LoggerFactory.getLogger(name); // get wrapper in slf4j
      map.put(name, result);
      return result;

    } catch (Throwable ioe) {
      startupLog.error("LoggerFactorySpecial failed on " + name, ioe);

      // standard slf4j - rely on external configuration
      return org.slf4j.LoggerFactory.getLogger(name);
    }
  }

  private class MyMessageFactory implements MessageFactory {

    @Override
    public Message newMessage(Object o) {
      return null;  //To change body of implemented methods use File | Settings | File Templates.
    }

    @Override
    public Message newMessage(String s) {
      return null;  //To change body of implemented methods use File | Settings | File Templates.
    }

    @Override
    public Message newMessage(String s, Object... objects) {
      return null;  //To change body of implemented methods use File | Settings | File Templates.
    }
  }

  /* <RollingFile name="fc" fileName="${tds.log.dir}/fc.${map:collectionName}.log" filePattern="${tds.log.dir}/fc.${map:collectionName}.%i.log">
      <PatternLayout pattern="%d{yyyy-MM-dd'T'HH:mm:ss.SSS Z} %-5p - %m%n"/>
      <Policies>
        <SizeBasedTriggeringPolicy size="1 MB"/>
      </Policies>
      <DefaultRolloverStrategy max="10"/>
    </RollingFile>
   *
  private class MyMapMessage extends MapMessage {
    MyMapMessage(String name) {
      super();
      put("collectionName", name);
    }
  }  */
public org.slf4j.Logger getLogger(String name) {
    name = StringUtil2.replace(name.trim(), ' ', "_");
    org.slf4j.Logger result = map.get(name);
    if (result != null)
        return result;
    try {
        String fileName = dir + "/" + name + ".log";
        String fileNamePattern = dir + "/" + name + "%i.log";
        // create logger in log4j2
        // TODO: There are Builders that make this logger creation less awkward.
        // LOOK: Why are we using this? Why not DefaultConfiguration?
        Configuration config = new NullConfiguration();
        PatternLayout layout = PatternLayout.createLayout(// final String pattern,
        "%d{yyyy-MM-dd'T'HH:mm:ss.SSS Z} %-5p - %m%n", // ?? PatternSelector patternSelector,
        null, // Configuration config,
        config, // RegexReplacement replace,
        null, // Charset charset,
        null, // boolean alwaysWriteExceptions,
        true, // boolean noConsoleNoAnsi,
        false, // String headerPattern,
        null, // String footerPattern
        null);
        DefaultRolloverStrategy.createStrategy(// String max,
        Integer.toString(maxBackups), // String min,
        "1", // String fileIndex,
        "max", // String compressionLevelStr,
        null, // ?? Action[] customActions,
        null, // boolean stopCustomActionsOnError,
        true, //Configuration config
        config);
        RollingFileAppender app = RollingFileAppender.createAppender(// String fileName
        fileName, // String filePattern
        fileNamePattern, // String append
        "true", // String name
        name, // String bufferedIO
        "true", // String bufferSizeStr
        null, // String immediateFlush
        "true", // TriggeringPolicy policy
        SizeBasedTriggeringPolicy.createPolicy(Long.toString(maxSize)), // RolloverStrategy strategy
        DefaultRolloverStrategy.createStrategy(// String max,
        Integer.toString(maxBackups), // String min,
        "1", // String fileIndex,
        "max", // String compressionLevelStr,
        null, // ?? Action[] customActions,
        null, // boolean stopCustomActionsOnError,
        true, //Configuration config
        config), // Layout<? extends Serializable> layout
        layout, // Filter filter
        null, // String ignore
        "true", // String advertise
        "false", // String advertiseURI
        null, // Configuration config
        config);
        app.start();
        /*LoggerContext ctx = (LoggerContext) LogManager.getContext(false);
      Configuration conf = ctx.getConfiguration();
      LoggerConfig lconf = conf.getLoggerConfig(name);
      lconf.setAdditive(false); // otherwise, it also gets sent to root logger (threddsServlet.log)
      lconf.setLevel(level);
      lconf.addAppender(app, level, null);
      ctx.updateLoggers(conf);  */
        org.apache.logging.log4j.core.Logger log4j = (org.apache.logging.log4j.core.Logger) LogManager.getLogger(name);
        log4j.addAppender(app);
        log4j.setLevel(level);
        // otherwise, it also gets sent to root logger (threddsServlet.log)
        log4j.setAdditive(false);
        startupLog.info("LoggerFactorySpecial add logger= {} file= {}", name, fileName);
        // get wrapper in slf4j
        result = org.slf4j.LoggerFactory.getLogger(name);
        map.put(name, result);
        return result;
    } catch (Throwable ioe) {
        startupLog.error("LoggerFactorySpecial failed on " + name, ioe);
        return org.slf4j.LoggerFactory.getLogger(name);
    }
}

@Override
public void onEnable() {
    plugin = this;
    getServer().getScheduler().cancelTasks(this);
    saveDefaultConfig();
    new File("plugins/NetworkManager/bungee-config.yml").delete();
    saveResource("bungee-config.yml", "plugins/NetworkManager/bungee-config.yml");
    loadBungeeConfig();
    password = getConfig().getString("password");
    restartMessage = MessageUtils.translateToColorCode(getConfig().getString("restartMessage"));
    restartWarnMessage = MessageUtils.translateToColorCode(getConfig().getString("restartWarnMessage"));
    api = new NetworkAPI(this);
    cst = new CommandSenderTask(this);
    sst = new SocketSenderThread(this);
    sst.start();
    getServer().getPluginManager().registerEvents(new LoginListener(this), this);
    getServer().getScheduler().runTaskTimer(this, cst, 20L, 20L);
    networkListenerTask = new NetworkListenerTask(this);
    networkListenerTask.start();
    ((org.apache.logging.log4j.core.Logger) LogManager.getRootLogger()).addFilter(new Filter() {

        @Override
        public Result filter(LogEvent event) {
            if (loggedConsoleLines.size() >= 500) {
                loggedConsoleLines.clear();
            }
            loggedConsoleLines.add(df.format(new Date(event.getMillis())) + " " + event.getMessage().getFormattedMessage());
            return Result.ACCEPT;
        }

        @Override
        public Result getOnMatch() {
            return Result.ACCEPT;
        }

        @Override
        public Result getOnMismatch() {
            return Result.ACCEPT;
        }

        @Override
        public Filter.Result filter(Logger logger, Level level, Marker marker, String string, Object... os) {
            return Result.ACCEPT;
        }

        @Override
        public Filter.Result filter(Logger logger, Level level, Marker marker, Object o, Throwable thrwbl) {
            return Result.ACCEPT;
        }

        @Override
        public Filter.Result filter(Logger logger, Level level, Marker marker, Message msg, Throwable thrwbl) {
            return Result.ACCEPT;
        }
    });
    if (getConfig().getStringList("lastReboots") != null) {
        lastReboots.addAll(getConfig().getStringList("lastReboots"));
    }
    lastReboots.add(String.valueOf(System.currentTimeMillis() / 1000L));
    getConfig().set("lastReboots", lastReboots);
    saveConfig();
}

public static void setSlf4jTargetStream(Class<?> clazz, PrintStream stream) {
    try {
        Log4jLogger log4Jlogger = (Log4jLogger) LoggerFactory.getLogger(clazz);
        Field field = clazz.getClassLoader().loadClass("org.apache.logging.slf4j.Log4jLogger").getDeclaredField("logger");
        field.setAccessible(true);
        Logger logger = (Logger) field.get(log4Jlogger);
        if (logger.getAppenders().containsKey("string")) {
            Appender appender = logger.getAppenders().get("string");
            logger.removeAppender(appender);
        }
        logger.addAppender(new StringAppender("string", stream));
    } catch (Exception e) {
        throw new RuntimeException(e);
    }
}

@Override
public void evaluate() throws Throwable {
    Map<Class<?>, Level> oldLevels = new HashMap<Class<?>, Level>();
    Map<String, Level> oldCatLevels = new HashMap<String, Level>();
    LogLevelAdjuster.this.classes.stream().forEach( cls -> {
        oldLevels.put(cls, LogManager.getLogger(cls).getLevel());
        ((Logger) LogManager.getLogger(cls)).setLevel(LogLevelAdjuster.this.level);
    });
    LogLevelAdjuster.this.categories.stream().forEach( cat -> {
        oldCatLevels.put(cat, LogManager.getLogger(cat).getLevel());
        ((Logger) LogManager.getLogger(cat)).setLevel(LogLevelAdjuster.this.level);
    });
    Map<String, ch.qos.logback.classic.Level> oldLbLevels = applyLogBack();
    logger.debug("++++++++++++++++++++++++++++ " + "Overridden log level setting for: " + LogLevelAdjuster.this.classes.stream().map(Class::getSimpleName).collect(Collectors.toList()) + " and " + LogLevelAdjuster.this.categories + " for test " + method.getName());
    try {
        base.evaluate();
    } finally {
        logger.debug("++++++++++++++++++++++++++++ " + "Restoring log level setting for test " + method.getName());
        LogLevelAdjuster.this.categories.stream().forEach( cat -> {
            if (!cat.contains("BrokerRunning")) {
                ((Logger) LogManager.getLogger(cat)).setLevel(oldCatLevels.get(cat));
            }
        });
        LogLevelAdjuster.this.classes.stream().forEach( cls -> {
            if (!cls.equals(BrokerRunning.class)) {
                ((Logger) LogManager.getLogger(cls)).setLevel(oldLevels.get(cls));
            }
        });
        revertLogBack(oldLbLevels);
    }
}

private final void applyFilters() {
    java.util.logging.Logger logger = plugin.getServer().getLogger();
    Filter current = logger.getFilter();
    if (current == null || current instanceof LogFilterHandler) {
        logger.setFilter(this);
    } else {
        logger.setFilter(new FilterDelegate(current, this));
    }
    ((Logger) LogManager.getRootLogger()).addFilter(this);
}

@Override
protected void executeInternal(JobExecutionContext arg0) throws JobExecutionException {
    if (!configurationManager.getSendLogsCronConfiguration().isActive())
        return;
    long start = System.currentTimeMillis();
    LOGGER.info("SCHEDULER : Send Administrative logs.");
    if (!DHuS.isStarted()) {
        LOGGER.warn("SCHEDULER : Not run while system not fully initialized.");
        return;
    }
    String[] addresses = configurationManager.getSendLogsCronConfiguration().getAddresses().split(",");
    // Case of no addresses available: use system support
    if ((addresses == null) || (addresses.length == 0) || "".equals(addresses[0].trim())) {
        String email = configurationManager.getSupportConfiguration().getMail();
        if ((email == null) || "".equals(email)) {
            throw new MailException("Support e-mail not configured, " + "system logs will not be send");
        }
        addresses = new String[] { email };
    }
    RollingFileAppender rollingFileAppender = (RollingFileAppender) ((org.apache.logging.log4j.core.Logger) LogManager.getRootLogger()).getAppenders().get("RollingFile");
    if (rollingFileAppender == null) {
        throw new MailException("No rolling log file defined");
    }
    String logPath = rollingFileAppender.getFileName();
    if ((logPath == null) || logPath.trim().equals("")) {
        throw new MailException("Log file not defined");
    }
    File logs = new File(logPath);
    if (!logs.exists()) {
        throw new MailException("Log file not present : " + logs.getPath());
    }
    Date now = new Date();
    SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd'@'HH:mm:ss");
    df.setTimeZone(TimeZone.getTimeZone("GMT"));
    String docFilename = configurationManager.getNameConfiguration().getShortName().toLowerCase() + "-" + df.format(now);
    File zipLogs;
    try {
        zipLogs = File.createTempFile(docFilename, ".zip");
    } catch (IOException e) {
        throw new MailException("Cannot create temporary zip log file.", e);
    }
    // compress logs file to zip format
    FileOutputStream fos;
    ZipOutputStream zos = null;
    FileInputStream fis = null;
    try {
        int length;
        byte[] buffer = new byte[1024];
        ZipEntry entry = new ZipEntry(docFilename + ".txt");
        fos = new FileOutputStream(zipLogs);
        zos = new ZipOutputStream(fos);
        fis = new FileInputStream(logs);
        zos.setLevel(Deflater.BEST_COMPRESSION);
        zos.putNextEntry(entry);
        while ((length = fis.read(buffer)) > 0) {
            zos.write(buffer, 0, length);
        }
    } catch (IOException e) {
        throw new MailException("An error occurred during compression " + "logs file, cannot send logs !", e);
    } finally {
        try {
            if (fis != null) {
                fis.close();
            }
            if (zos != null) {
                zos.closeEntry();
                zos.close();
            }
        } catch (IOException e) {
            throw new MailException("An error occurred during compression " + "logs file, cannot send logs !", e);
        }
    }
    EmailAttachment attachment = new EmailAttachment();
    attachment.setDescription(configurationManager.getNameConfiguration().getShortName() + " Logs " + now.toString());
    attachment.setPath(zipLogs.getPath());
    attachment.setName(zipLogs.getName());
    // Prepare the addresses
    List<String> ads = new ArrayList<String>();
    for (String email : addresses) {
        StringTokenizer tk = new StringTokenizer(email, ", ");
        while (tk.hasMoreTokens()) {
            String token = tk.nextToken().trim();
            if (!token.isEmpty())
                ads.add(token);
        }
    }
    for (String email : ads) {
        try {
            String server = configurationManager.getServerConfiguration().getExternalHostname();
            String url = configurationManager.getServerConfiguration().getExternalUrl();
            mailServer.send(email, null, null, "[" + configurationManager.getNameConfiguration().getShortName().toLowerCase() + "@" + server + "] logs of " + df.format(now), "Here is attached " + configurationManager.getNameConfiguration().getShortName() + " logs of \"" + url + "\" host.\n\n" + "Kind Regards.\nThe " + configurationManager.getNameConfiguration().getShortName() + " Team.", attachment);
            LOGGER.info("Logs Sent to " + email);
        } catch (EmailException e) {
            throw new MailException("Cannot send logs to " + email, e);
        }
    }
    if (!zipLogs.delete()) {
        LOGGER.warn("Cannot remove mail attachment: " + zipLogs.getAbsolutePath());
    }
    LOGGER.info("SCHEDULER : Send Administrative logs done - " + (System.currentTimeMillis() - start) + "ms");
}

public Response loggerajax(Request request) {
    Map<String, Object> body = request.getBodyAsJsonMap();
    if (body != null && body.size() > 0) {
        String clazz = body.get("class").toString();
        String level = body.get("level").toString();
        if (StringUtils.isNotBlank(clazz) && StringUtils.isNotBlank(level)) {
            LoggerContext loggerContext = (LoggerContext) LogManager.getContext(false);
            for (Logger logger : loggerContext.getLoggers()) {
                //NOSONAR
                if (clazz.equals(logger.getName())) {
                    logger.setLevel(Level.getLevel(level));
                    break;
                }
            }
        }
    }
    return Response.withOk().andEmptyBody();
}

/**
     * Internal callback
     * 
     * @param phase phase to go to 
     */
static void gotoPhase(Phase phase) {
    if (phase == null || phase.ordinal < 0) {
        throw new IllegalArgumentException("Cannot go to the specified phase, phase is null or invalid");
    }
    if (phase.ordinal > getCurrentPhase().ordinal) {
        MixinBootstrap.addProxy();
    }
    if (phase == Phase.DEFAULT) {
        // remove appender
        org.apache.logging.log4j.core.Logger log = (org.apache.logging.log4j.core.Logger) LogManager.getLogger("FML");
        log.removeAppender(MixinLogger.appender);
    }
    MixinEnvironment.currentPhase = phase;
    MixinEnvironment.currentEnvironment = MixinEnvironment.getEnvironment(MixinEnvironment.getCurrentPhase());
}

/**
    * Reconfigures the logging level of the root logger and all suitable appenders.
    *
    * @param level
    *       The desired level.
    */
public static void setLoggingLevel(final Level level) {
    final Logger log = LogManager.getLogger(Utils.class);
    final org.apache.logging.log4j.core.Logger coreLogger = (org.apache.logging.log4j.core.Logger) log;
    final LoggerContext context = coreLogger.getContext();
    context.getConfiguration().getLoggers().get("org.perfcake").setLevel(level);
    context.updateLoggers();
}

@Override
public Collection<LoggerInfo> getAllLoggers() {
    Logger root = LogManager.getRootLogger();
    Map<String, LoggerInfo> map = new HashMap<String, LoggerInfo>();
    LoggerContext ctx = (LoggerContext) LogManager.getContext(false);
    for (org.apache.logging.log4j.core.Logger logger : ctx.getLoggers()) {
        String name = logger.getName();
        if (logger == root || root.equals(logger) || isRootLogger(name))
            continue;
        map.put(name, new Log4j2Info(name, logger));
        while (true) {
            int dot = name.lastIndexOf(".");
            if (dot < 0)
                break;
            name = name.substring(0, dot);
            if (!map.containsKey(name))
                map.put(name, new Log4j2Info(name, null));
        }
    }
    map.put(LoggerInfo.ROOT_NAME, new Log4j2Info(LoggerInfo.ROOT_NAME, root));
    return map.values();
}

@Mod.EventHandler
public void preInit(FMLPreInitializationEvent event) {
    LoggingHandler.felog = event.getModLog();
    LoggingHandler.felog.info(//
    String.format(//
    "Running ForgeEssentials %s #%d (%s)", BuildInfo.VERSION, BuildInfo.getBuildNumber(), BuildInfo.getBuildHash()));
    // Initialize core configuration
    initializeConfigurationManager();
    registerNetworkMessages();
    Translator.load();
    // Set up logger level
    if (debugMode)
        ((Logger) LoggingHandler.felog).setLevel(Level.DEBUG);
    else
        ((Logger) LoggingHandler.felog).setLevel(Level.INFO);
    // Register core submodules
    factory = new ForgeEssentialsEventFactory();
    wandHandler = new SelectionEventHandler();
    teleportHelper = new TeleportHelper();
    questioner = new Questioner();
    // Load submodules
    moduleLauncher = new ModuleLauncher();
    moduleLauncher.preLoad(event);
}

@SuppressWarnings("unchecked")
public static void main(String[] args) throws IOException, HiveException {
    String planFileName = null;
    String jobConfFileName = null;
    boolean noLog = false;
    String files = null;
    String libjars = null;
    boolean localtask = false;
    try {
        for (int i = 0; i < args.length; i++) {
            if (args[i].equals("-plan")) {
                planFileName = args[++i];
            } else if (args[i].equals("-jobconffile")) {
                jobConfFileName = args[++i];
            } else if (args[i].equals("-nolog")) {
                noLog = true;
            } else if (args[i].equals("-files")) {
                files = args[++i];
            } else if (args[i].equals("-libjars")) {
                libjars = args[++i];
            } else if (args[i].equals("-localtask")) {
                localtask = true;
            }
        }
    } catch (IndexOutOfBoundsException e) {
        System.err.println("Missing argument to option");
        printUsage();
    }
    JobConf conf;
    if (localtask) {
        conf = new JobConf(MapredLocalTask.class);
    } else {
        conf = new JobConf(ExecDriver.class);
    }
    if (jobConfFileName != null) {
        conf.addResource(new Path(jobConfFileName));
    }
    // Initialize the resources from command line
    if (files != null) {
        conf.set("tmpfiles", files);
    }
    if (libjars != null) {
        conf.set("tmpjars", libjars);
    }
    if (UserGroupInformation.isSecurityEnabled()) {
        String hadoopAuthToken = System.getenv(UserGroupInformation.HADOOP_TOKEN_FILE_LOCATION);
        if (hadoopAuthToken != null) {
            conf.set("mapreduce.job.credentials.binary", hadoopAuthToken);
        }
    }
    boolean isSilent = HiveConf.getBoolVar(conf, HiveConf.ConfVars.HIVESESSIONSILENT);
    String queryId = HiveConf.getVar(conf, HiveConf.ConfVars.HIVEQUERYID, "").trim();
    if (queryId.isEmpty()) {
        queryId = "unknown-" + System.currentTimeMillis();
        HiveConf.setVar(conf, HiveConf.ConfVars.HIVEQUERYID, queryId);
    }
    System.setProperty(HiveConf.ConfVars.HIVEQUERYID.toString(), queryId);
    LogUtils.registerLoggingContext(conf);
    if (noLog) {
        // If started from main(), and noLog is on, we should not output
        // any logs. To turn the log on, please set -Dtest.silent=false
        org.apache.logging.log4j.Logger logger = org.apache.logging.log4j.LogManager.getRootLogger();
        NullAppender appender = NullAppender.createNullAppender();
        appender.addToLogger(logger.getName(), Level.ERROR);
        appender.start();
    } else {
        setupChildLog4j(conf);
    }
    Logger LOG = LoggerFactory.getLogger(ExecDriver.class.getName());
    LogHelper console = new LogHelper(LOG, isSilent);
    if (planFileName == null) {
        console.printError("Must specify Plan File Name");
        printUsage();
    }
    // that it's easy to find reason for local mode execution failures
    for (Appender appender : ((org.apache.logging.log4j.core.Logger) LogManager.getRootLogger()).getAppenders().values()) {
        if (appender instanceof FileAppender) {
            console.printInfo("Execution log at: " + ((FileAppender) appender).getFileName());
        } else if (appender instanceof RollingFileAppender) {
            console.printInfo("Execution log at: " + ((RollingFileAppender) appender).getFileName());
        }
    }
    // the plan file should always be in local directory
    Path p = new Path(planFileName);
    FileSystem fs = FileSystem.getLocal(conf);
    InputStream pathData = fs.open(p);
    // child process. so we add it here explicitly
    try {
        // see also - code in CliDriver.java
        ClassLoader loader = conf.getClassLoader();
        if (StringUtils.isNotBlank(libjars)) {
            loader = Utilities.addToClassPath(loader, StringUtils.split(libjars, ","));
        }
        conf.setClassLoader(loader);
        // Also set this to the Thread ContextClassLoader, so new threads will
        // inherit
        // this class loader, and propagate into newly created Configurations by
        // those
        // new threads.
        Thread.currentThread().setContextClassLoader(loader);
    } catch (Exception e) {
        throw new HiveException(e.getMessage(), e);
    }
    int ret;
    if (localtask) {
        memoryMXBean = ManagementFactory.getMemoryMXBean();
        MapredLocalWork plan = SerializationUtilities.deserializePlan(pathData, MapredLocalWork.class);
        MapredLocalTask ed = new MapredLocalTask(plan, conf, isSilent);
        ret = ed.executeInProcess(new DriverContext());
    } else {
        MapredWork plan = SerializationUtilities.deserializePlan(pathData, MapredWork.class);
        ExecDriver ed = new ExecDriver(plan, conf, isSilent);
        ret = ed.execute(new DriverContext());
    }
    if (ret != 0) {
        System.exit(ret);
    }
}

/** {@inheritDoc} */
@Nullable
@Override
public String fileName() {
    for (Logger log = impl; log != null; log = log.getParent()) {
        for (Appender a : log.getAppenders().values()) {
            if (a instanceof FileAppender)
                return ((FileAppender) a).getFileName();
            if (a instanceof RollingFileAppender)
                return ((RollingFileAppender) a).getFileName();
            if (a instanceof RoutingAppender) {
                try {
                    RoutingAppender routing = (RoutingAppender) a;
                    Field appsFiled = routing.getClass().getDeclaredField("appenders");
                    appsFiled.setAccessible(true);
                    Map<String, AppenderControl> appenders = (Map<String, AppenderControl>) appsFiled.get(routing);
                    for (AppenderControl control : appenders.values()) {
                        Appender innerApp = control.getAppender();
                        if (innerApp instanceof FileAppender)
                            return normilize(((FileAppender) innerApp).getFileName());
                        if (innerApp instanceof RollingFileAppender)
                            return normilize(((RollingFileAppender) innerApp).getFileName());
                    }
                } catch (IllegalAccessExceptionNoSuchFieldException |  e) {
                    error("Failed to get file name (was the implementation of log4j2 changed?).", e);
                }
            }
        }
    }
    return null;
}

private List<LoggerTO> list(final LoggerType type) {
    return CollectionUtils.collect(loggerDAO.findAll(type), new Transformer<Logger, LoggerTO>() {

        @Override
        public LoggerTO transform(final Logger logger) {
            LoggerTO loggerTO = new LoggerTO();
            BeanUtils.copyProperties(logger, loggerTO);
            return loggerTO;
        }
    }, new ArrayList<LoggerTO>());
}

public void updateLoggingSeverity(@Observes @ConfigurationUpdate AppConfiguration appConfiguration) {
    String loggingLevel = appConfiguration.getLoggingLevel();
    if (StringHelper.isEmpty(loggingLevel)) {
        return;
    }
    log.info("Setting loggers level to: '{}'", loggingLevel);
    LoggerContext loggerContext = LoggerContext.getContext(false);
    if (StringHelper.equalsIgnoreCase("DEFAULT", loggingLevel)) {
        log.info("Reloading log4j configuration");
        loggerContext.reconfigure();
        return;
    }
    Level level = Level.toLevel(loggingLevel, Level.INFO);
    for (org.apache.logging.log4j.core.Logger logger : loggerContext.getLoggers()) {
        String loggerName = logger.getName();
        if (loggerName.startsWith("org.xdi.service") || loggerName.startsWith("org.xdi.oxauth") || loggerName.startsWith("org.gluu")) {
            logger.setLevel(level);
        }
    }
}

public void updateLoggingSeverity(@Observes @ConfigurationUpdate AppConfiguration appConfiguration) {
    String loggingLevel = appConfiguration.getLoggingLevel();
    if (StringHelper.isEmpty(loggingLevel)) {
        return;
    }
    log.info("Setting loggers level to: '{}'", loggingLevel);
    LoggerContext loggerContext = LoggerContext.getContext(false);
    if (StringHelper.equalsIgnoreCase("DEFAULT", loggingLevel)) {
        log.info("Reloading log4j configuration");
        loggerContext.reconfigure();
        return;
    }
    Level level = Level.toLevel(loggingLevel, Level.INFO);
    for (org.apache.logging.log4j.core.Logger logger : loggerContext.getLoggers()) {
        String loggerName = logger.getName();
        if (loggerName.startsWith("org.xdi.service") || loggerName.startsWith("org.xdi.oxauth") || loggerName.startsWith("org.gluu")) {
            logger.setLevel(level);
        }
    }
}

/**
     * Initialises the server and starts it
     */
public boolean init() throws IOException {
    Thread consoleHandlerThread = new Thread("Server console handler") {

        @Override
        public void run() {
            if (!org.bukkit.craftbukkit.Main.useConsole)
                return;
            jline.console.ConsoleReader bufferedreader = getMinecraftServer().reader;
            String sourceCommand;
            try {
                // JLine disabling compatibility
                while (!isStopped() && isRunning()) {
                    if (org.bukkit.craftbukkit.Main.useJline) {
                        sourceCommand = bufferedreader.readLine(">", null);
                    } else {
                        sourceCommand = bufferedreader.readLine();
                    }
                    // Trim to filter lines which are just spaces
                    if (sourceCommand != null && sourceCommand.trim().length() > 0) {
                        issueCommand(sourceCommand, getDedicatedServer());
                    }
                }
            } catch (IOException ioexception) {
                logger.error("Exception handling console input", ioexception);
            }
        }
    };
    java.util.logging.Logger global = java.util.logging.Logger.getLogger("");
    global.setUseParentHandlers(false);
    for (java.util.logging.Handler handler : global.getHandlers()) {
        global.removeHandler(handler);
    }
    global.addHandler(new org.bukkit.craftbukkit.util.ForwardLogHandler());
    final org.apache.logging.log4j.core.Logger logger = ((org.apache.logging.log4j.core.Logger) LogManager.getRootLogger());
    for (org.apache.logging.log4j.core.Appender appender : logger.getAppenders().values()) {
        if (appender instanceof org.apache.logging.log4j.core.appender.ConsoleAppender) {
            logger.removeAppender(appender);
        }
    }
    new Thread(new org.bukkit.craftbukkit.util.TerminalConsoleWriterThread(System.out, this.reader)).start();
    System.setOut(new PrintStream(new LoggerOutputStream(logger, Level.INFO), true));
    System.setErr(new PrintStream(new LoggerOutputStream(logger, Level.WARN), true));
    consoleHandlerThread.setDaemon(true);
    consoleHandlerThread.start();
    logger.info("Starting minecraft server version " + GAME_VERSION);
    if (Runtime.getRuntime().maxMemory() / 1024L / 1024L < 512L) {
        logger.warn("Better to start the server with more ram, launch it as \"java -d64 -server -Xmx1024M -Xms1024M -jar torchpowered.jar\"");
    }
    //logger.info("Loading properties");
    // CLI argument support
    this.getDedicatedServer().propertyManager = this.propertyManager = new PropertyManager(this.options);
    if (this.isSinglePlayer()) {
        this.setServerIp("127.0.0.1");
    } else {
        this.setOnlineMode(this.propertyManager.getBoolean("online-mode", true));
        this.setPreventProxyConnections(this.propertyManager.getBoolean("prevent-proxy-connections", false));
        this.setServerIp(this.propertyManager.getString("server-ip", ""));
    }
    this.setSpawnAnimals(this.propertyManager.getBoolean("spawn-animals", true));
    this.setSpawnNPCs(this.propertyManager.getBoolean("spawn-npcs", true));
    this.setPvpMode(this.propertyManager.getBoolean("pvp", true));
    this.setAllowFlight(this.propertyManager.getBoolean("allow-flight", false));
    this.setResourcePack(this.propertyManager.getString("resource-pack", ""), this.loadResourcePackSHA());
    this.setMotd(this.propertyManager.getString("motd", "A Minecraft Server"));
    this.setForceGamemode(this.propertyManager.getBoolean("force-gamemode", false));
    this.setIdleTimeout(this.propertyManager.getInt("player-idle-timeout", 0));
    if (this.propertyManager.getInt("difficulty", 1) < 0) {
        this.propertyManager.setProperty("difficulty", Integer.valueOf(0));
    } else if (this.propertyManager.getInt("difficulty", 1) > 3) {
        this.propertyManager.setProperty("difficulty", Integer.valueOf(3));
    }
    this.generateStructures = this.propertyManager.getBoolean("generate-structures", true);
    int i = this.propertyManager.getInt("gamemode", EnumGamemode.SURVIVAL.getId());
    this.gameMode = WorldSettings.a(i);
    logger.info("Default game type: {}", new Object[] { this.gameMode });
    InetAddress bindIp = null;
    if (!this.getServerIp().isEmpty())
        bindIp = InetAddress.getByName(this.getServerIp());
    if (this.getServerPort() < 0) {
        this.setServerPort(this.propertyManager.getInt("server-port", 25565));
    }
    // Initial the craft server in player list
    this.setPlayerList(new DedicatedPlayerList(this.getDedicatedServer()).getReactor());
    this.getServant().setPlayerList(this.playerList);
    org.spigotmc.SpigotConfig.init((File) options.valueOf("spigot-settings"));
    org.spigotmc.SpigotConfig.registerCommands();
    com.destroystokyo.paper.PaperConfig.init((File) options.valueOf("paper-settings"));
    com.destroystokyo.paper.PaperConfig.registerCommands();
    //logger.info("Generating keypair");
    this.setServerKeyPair(MinecraftEncryption.b());
    logger.info("Binding server to {}:{}", new Object[] { this.getServerIp().isEmpty() ? "*" : this.getServerIp(), Integer.valueOf(this.getServerPort()) });
    if (!org.spigotmc.SpigotConfig.lateBind) {
        try {
            this.getServerConnection().a(bindIp, this.getServerPort());
        } catch (IOException ioexception) {
            logger.warn("**** FAILED TO BIND TO PORT!");
            logger.warn("The exception was: {}", new Object[] { ioexception.toString() });
            logger.warn("Perhaps a server is already running on that port?");
            return false;
        }
    }
    craftServer.loadPlugins();
    craftServer.enablePlugins(org.bukkit.plugin.PluginLoadOrder.STARTUP);
    if (!this.getOnlineMode()) {
        logger.warn("**** SERVER IS RUNNING IN OFFLINE/INSECURE MODE!");
        logger.warn("The server will make no attempt to authenticate usernames. Beware.");
        // Spigot start
        if (org.spigotmc.SpigotConfig.bungee) {
            logger.warn("Whilst this makes it possible to use BungeeCord, unless access to your server is properly restricted, it also opens up the ability for hackers to connect with any username they choose.");
            logger.warn("Please see http://www.spigotmc.org/wiki/firewall-guide/ for further information.");
        } else {
            logger.warn("While this makes the game possible to play without internet access, it also opens up the ability for hackers to connect with any username they choose.");
        }
        // Spigot end
        logger.warn("To change this, set \"online-mode\" to \"true\" in the server.properties file.");
    }
    if (this.convertFilesUUID())
        this.getUserCache().save();
    if (!NameReferencingFileConverter.a(this.propertyManager))
        return false;
    this.anvilFileConverter = new WorldLoaderServer(craftServer.getWorldContainer(), this.getDataConverterManager());
    long j = System.nanoTime();
    if (this.getPrimaryWorldFolderName() == null) {
        this.setPrimaryWorldFolderName(this.propertyManager.getString("level-name", "world"));
    }
    String levelSeed = this.propertyManager.getString("level-seed", "");
    String levelType = this.propertyManager.getString("level-type", "DEFAULT");
    String generatorSettings = this.propertyManager.getString("generator-settings", "");
    // The generator seed we final used
    long generatorSeed = (new Random()).nextLong();
    if (!levelSeed.isEmpty()) {
        try {
            long seed = Long.parseLong(levelSeed);
            // If the given seed is invaild, use random seed
            if (seed != 0L)
                generatorSeed = seed;
        } catch (NumberFormatException numberformatexception) {
            generatorSeed = levelSeed.hashCode();
        }
    }
    WorldType worldtype = WorldType.getType(levelType);
    if (worldtype == null)
        worldtype = WorldType.NORMAL;
    this.isAnnouncingPlayerAchievements();
    this.getEnableCommandBlock();
    this.getOpPermissionLevel();
    this.getSnooperEnabled();
    this.getNetworkCompressionThreshold();
    this.setBuildLimit(this.propertyManager.getInt("max-build-height", 256));
    this.setBuildLimit((this.getBuildLimit() + 8) / 16 * 16);
    this.setBuildLimit(MathHelper.clamp(this.getBuildLimit(), 64, 256));
    this.propertyManager.setProperty("max-build-height", Integer.valueOf(this.getBuildLimit()));
    // Set user cache and session service for skulls
    TileEntitySkull.a(this.getUserCache().getServant());
    TileEntitySkull.a(this.getSessionService());
    // Set online mode for the user cache
    UserCache.setOnlineMode(this.getOnlineMode());
    logger.info("Preparing level \"{}\"", new Object[] { this.getPrimaryWorldFolderName() });
    this.loadDefaultWorlds(this.getPrimaryWorldFolderName(), this.getPrimaryWorldFolderName(), generatorSeed, worldtype, generatorSettings);
    long i1 = System.nanoTime() - j;
    String s3 = String.format("%.3fs", new Object[] { Double.valueOf(i1 / 1.0E9D) });
    logger.info("Ready for connections! ({})", new Object[] { s3 });
    if (this.propertyManager.getBoolean("enable-query", false)) {
        logger.info("Starting GS4 status listener");
        this.remoteQueryListener = new RemoteStatusListener(this.getDedicatedServer());
        // Start the rcon query thread
        this.remoteQueryListener.a();
    }
    if (this.propertyManager.getBoolean("enable-rcon", false)) {
        logger.info("Starting remote control listener");
        this.remoteControlListener = new RemoteControlListener(this.getDedicatedServer());
        // Start the rcon listener thread
        this.remoteControlListener.a();
        this.remoteConsole = new org.bukkit.craftbukkit.command.CraftRemoteConsoleCommandSender(this.remoteControlCommandListener);
    }
    if (this.craftServer.getBukkitSpawnRadius() > -1) {
        logger.info("'settings.spawn-radius' in bukkit.yml has been moved to 'spawn-protection' in server.properties. I will move your config for you.");
        this.propertyManager.properties.remove("spawn-protection");
        this.propertyManager.getInt("spawn-protection", this.craftServer.getBukkitSpawnRadius());
        this.craftServer.removeBukkitSpawnRadius();
        this.propertyManager.savePropertiesFile();
    }
    if (org.spigotmc.SpigotConfig.lateBind) {
        try {
            this.getServerConnection().a(bindIp, this.getServerPort());
        } catch (IOException ioexception) {
            logger.warn("**** FAILED TO BIND TO PORT!");
            logger.warn("The exception was: {}", new Object[] { ioexception.toString() });
            logger.warn("Perhaps a server is already running on that port?");
            return false;
        }
    }
    return true;
}

@Override
public void onEnable() {
    instance = this;
    // initialize debugger
    new Debug();
    // load configuration
    new Config();
    // try to connect to database
    Debug.info("Connecting to MySQL database");
    this.database = new MySQL(this, getConfig().getString("mysql.host"), getConfig().getString("mysql.port"), getConfig().getString("mysql.base"), getConfig().getString("mysql.user"), getConfig().getString("mysql.pass"));
    // try to connect to MySQL
    Connection con = database.getConnection();
    if (con != null) {
        Debug.broadcast("Using MySQL for storing data!");
        isMySQLUsed = true;
    // if it fails use SQLite
    } else {
        this.database = new SQLite(this, "database.db");
        Debug.broadcast("Using SQLite for storing data!");
        isMySQLUsed = false;
    }
    // create tables in the database
    database.createTables(isMySQLUsed);
    // create and start the saver object, which handles correct asynchronous
    // saving to the database
    saver = new Saver();
    saver.start();
    // load database backup
    Utils.loadDatabaseFromBackup();
    // update configuration if needed
    new ConfigUpdater();
    // add it so debug option is turned off after first start
    if (getConfig().getString("debug", null) == null) {
        getConfig().set("debug", "false");
        saveConfig();
    }
    // instantiating of these important things
    new JoinQuitListener();
    // instantiate default conversation start listener
    new CubeNPCListener();
    // instantiate journal handler
    new QuestItemHandler();
    // initialize static events
    new StaticEvents();
    // initialize combat tagging
    new CombatTagger();
    // load colors for conversations
    new ConversationColors();
    // start timer for global locations
    new GlobalLocations().runTaskTimer(this, 20, 20);
    // start mob kill listener
    new MobKillListener();
    // start custom drop listener
    new CustomDropListener();
    // register commands
    new QuestCommand();
    new JournalCommand();
    new BackpackCommand();
    new CancelQuestCommand();
    new CompassCommand();
    new LangCommand();
    // register conditions
    registerConditions("health", HealthCondition.class);
    registerConditions("permission", PermissionCondition.class);
    registerConditions("experience", ExperienceCondition.class);
    registerConditions("tag", TagCondition.class);
    registerConditions("point", PointCondition.class);
    registerConditions("and", ConjunctionCondition.class);
    registerConditions("or", AlternativeCondition.class);
    registerConditions("time", TimeCondition.class);
    registerConditions("weather", WeatherCondition.class);
    registerConditions("height", HeightCondition.class);
    registerConditions("item", ItemCondition.class);
    registerConditions("hand", HandCondition.class);
    registerConditions("location", LocationCondition.class);
    registerConditions("armor", ArmorCondition.class);
    registerConditions("effect", EffectCondition.class);
    registerConditions("rating", ArmorRatingCondition.class);
    registerConditions("sneak", SneakCondition.class);
    registerConditions("random", RandomCondition.class);
    registerConditions("journal", JournalCondition.class);
    registerConditions("testforblock", TestForBlockCondition.class);
    registerConditions("empty", EmptySlotsCondition.class);
    registerConditions("party", PartyCondition.class);
    registerConditions("monsters", MonstersCondition.class);
    registerConditions("objective", ObjectiveCondition.class);
    registerConditions("check", CheckCondition.class);
    registerConditions("chestitem", ChestItemCondition.class);
    registerConditions("score", ScoreboardCondition.class);
    registerConditions("riding", VehicleCondition.class);
    registerConditions("world", WorldCondition.class);
    registerConditions("gamemode", GameModeCondition.class);
    registerConditions("achievement", AchievementCondition.class);
    registerConditions("variable", VariableCondition.class);
    registerConditions("fly", FlyingCondition.class);
    // register events
    registerEvents("message", MessageEvent.class);
    registerEvents("objective", ObjectiveEvent.class);
    registerEvents("command", CommandEvent.class);
    registerEvents("tag", TagEvent.class);
    registerEvents("journal", JournalEvent.class);
    registerEvents("teleport", TeleportEvent.class);
    registerEvents("explosion", ExplosionEvent.class);
    registerEvents("lightning", LightningEvent.class);
    registerEvents("point", PointEvent.class);
    registerEvents("give", GiveEvent.class);
    registerEvents("take", TakeEvent.class);
    registerEvents("conversation", ConversationEvent.class);
    registerEvents("kill", KillEvent.class);
    registerEvents("effect", EffectEvent.class);
    registerEvents("spawn", SpawnMobEvent.class);
    registerEvents("time", TimeEvent.class);
    registerEvents("weather", WeatherEvent.class);
    registerEvents("folder", FolderEvent.class);
    registerEvents("setblock", SetBlockEvent.class);
    registerEvents("damage", DamageEvent.class);
    registerEvents("party", PartyEvent.class);
    registerEvents("clear", ClearEvent.class);
    registerEvents("run", RunEvent.class);
    registerEvents("givejournal", GiveJournalEvent.class);
    registerEvents("sudo", SudoEvent.class);
    registerEvents("chestgive", ChestGiveEvent.class);
    registerEvents("chesttake", ChestTakeEvent.class);
    registerEvents("chestclear", ChestClearEvent.class);
    registerEvents("compass", CompassEvent.class);
    registerEvents("cancel", CancelEvent.class);
    registerEvents("score", ScoreboardEvent.class);
    registerEvents("lever", LeverEvent.class);
    registerEvents("door", DoorEvent.class);
    registerEvents("if", IfElseEvent.class);
    registerEvents("variable", VariableEvent.class);
    registerEvents("title", TitleEvent.class);
    registerEvents("language", LanguageEvent.class);
    // register objectives
    registerObjectives("location", LocationObjective.class);
    registerObjectives("block", BlockObjective.class);
    registerObjectives("mobkill", MobKillObjective.class);
    registerObjectives("action", ActionObjective.class);
    registerObjectives("die", DieObjective.class);
    registerObjectives("craft", CraftingObjective.class);
    registerObjectives("smelt", SmeltingObjective.class);
    registerObjectives("tame", TameObjective.class);
    registerObjectives("delay", DelayObjective.class);
    registerObjectives("arrow", ArrowShootObjective.class);
    registerObjectives("experience", ExperienceObjective.class);
    registerObjectives("step", StepObjective.class);
    registerObjectives("logout", LogoutObjective.class);
    registerObjectives("password", PasswordObjective.class);
    registerObjectives("fish", FishObjective.class);
    registerObjectives("enchant", EnchantObjective.class);
    registerObjectives("shear", ShearObjective.class);
    registerObjectives("chestput", ChestPutObjective.class);
    registerObjectives("potion", PotionObjective.class);
    registerObjectives("vehicle", VehicleObjective.class);
    registerObjectives("consume", ConsumeObjective.class);
    registerObjectives("variable", VariableObjective.class);
    registerObjectives("kill", KillPlayerObjective.class);
    registerObjectives("breed", BreedObjective.class);
    // register conversation IO types
    registerConversationIO("simple", SimpleConvIO.class);
    registerConversationIO("tellraw", TellrawConvIO.class);
    registerConversationIO("chest", InventoryConvIO.class);
    // register variable types
    registerVariable("player", PlayerNameVariable.class);
    registerVariable("npc", NpcNameVariable.class);
    registerVariable("objective", ObjectivePropertyVariable.class);
    registerVariable("point", PointVariable.class);
    registerVariable("item", ItemAmountVariable.class);
    registerVariable("version", VersionVariable.class);
    registerVariable("location", LocationVariable.class);
    // initialize compatibility with other plugins
    compatibility = new Compatibility();
    // schedule quest data loading on the first tick, so all other
    // plugins can register their types
    Bukkit.getScheduler().scheduleSyncDelayedTask(this, new Runnable() {

        public void run() {
            // Load all events and conditions
            loadData();
            // load data for all online players
            for (Player player : Bukkit.getOnlinePlayers()) {
                String playerID = PlayerConverter.getID(player);
                PlayerData playerData = new PlayerData(playerID);
                playerDataMap.put(playerID, playerData);
                playerData.startObjectives();
                playerData.getJournal().update();
                if (playerData.getConversation() != null)
                    new ConversationResumer(playerID, playerData.getConversation());
            }
        }
    });
    // block betonquestanswer logging (it's just a spam)
    try {
        Class.forName("org.apache.logging.log4j.core.Filter");
        Logger coreLogger = (Logger) LogManager.getRootLogger();
        coreLogger.addFilter(new AnswerFilter());
    } catch (ClassNotFoundExceptionNoClassDefFoundError |  e) {
        Debug.info("Could not disable /betonquestanswer logging");
    }
    // metrics
    new Metrics(this);
    // updater
    updater = new Updater(this.getFile());
    // done
    Debug.broadcast("BetonQuest succesfully enabled!");
}

public static Level getEffectiveLevel(Logger logger) {
    if (logger.getLevel() != null) {
        return logger.getLevel();
    }
    if (logger.getParent() != null) {
        return getEffectiveLevel(logger.getParent());
    }
    return null;
}

private org.apache.logging.log4j.core.Logger getUnderlyingLogger() {
    return (org.apache.logging.log4j.core.Logger) LogManager.getLogger(getClass());
}

@Override
public Result filter(final Logger logger, final Level level, final Marker marker, final String msg, final Object... params) {
    return filter(level, Thread.currentThread().getName());
}

@Override
public Result filter(final Logger logger, final Level level, final Marker marker, final Message msg, final Throwable t) {
    return filter();
}

@Override
public Result filter(Logger logger, Level level, Marker marker, String msg, Object... params) {
    return filter(marker);
}

@Override
public Result filter(Logger logger, Level level, Marker marker, Message msg, Throwable t) {
    return Result.DENY;
}

@Override
public MLogger getMLogger(String name) {
    Logger lg = LogManager.getLogger(name);
    if (lg == null) {
        fallbackWarn(" with name '" + name + "'");
        return NullMLogger.instance();
    } else
        return new Log4jMLogger(lg);
}

@Override
public Result filter(Logger logger, Level level, Marker marker, String msg, Object... params) {
    return filter(logger.getName());
}