@Override public void init() { SLF4JBridgeHandler.removeHandlersForRootLogger(); SLF4JBridgeHandler.install(); final List<String> keyList = new LinkedList<>(); final List<String> valueList = new LinkedList<>(); if (!Strings.isNullOrEmpty(SecondBase.serviceName)) { keyList.add("service"); valueList.add(SecondBase.serviceName); } if (!Strings.isNullOrEmpty(SecondBase.environment)) { keyList.add("environment"); valueList.add(SecondBase.environment); } if (!Strings.isNullOrEmpty(JsonLoggerConfiguration.datacenter)) { keyList.add("datacenter"); valueList.add(JsonLoggerConfiguration.datacenter); } SecondBaseLogger.setupLoggingStdoutOnly( keyList.toArray(new String[] {}), valueList.toArray(new String[] {}), JsonLoggerConfiguration.requestLoggerClassName, true); }
public TestServiceRunnerJetty.Runtime start() { SLF4JBridgeHandler.removeHandlersForRootLogger(); SLF4JBridgeHandler.install(); ServiceConfig serviceConfigwithProps = serviceConfig.addPropertiesAndApplyToBindings(propertyMap); ServiceRunner serviceRunner = new ServiceRunner(serviceConfigwithProps, propertyMap); ServiceRunner runningServiceRunner = serviceRunner.start(); URI uri = runningServiceRunner.jettyServer.server.getURI(); uri = UriBuilder.fromUri(uri).host("localhost").build(); ClientGenerator clientGenerator = clientConfigurator.apply( ClientGenerator.defaults(serviceConfigwithProps.serviceDefinition) ); Client client = clientGenerator.generate(); StubGenerator stubGenerator = stubConfigurator.apply(StubGenerator.defaults(client, UriBuilder.fromUri(uri).build())); TargetGenerator targetGenerator = targetConfigurator.apply(TargetGenerator.defaults(client, uri)); return new Runtime(runningServiceRunner, uri, stubGenerator, clientGenerator, targetGenerator); }
@BeforeClass public static void setup() throws NodeValidationException, IOException { SLF4JBridgeHandler.removeHandlersForRootLogger(); SLF4JBridgeHandler.install(); ServiceConfig serviceConfig = ServiceConfig .defaults(ServiceDefinitionUtil.simple(Resource.class)) .addon(ElasticsearchAddonMockImpl.defaults) // .addon(ElasticsearchAddonImpl.defaults // .coordinatorPort(9300) // .coordinatorUrl("127.0.0.1") // .clustername("test-search-api-5-local_jonas") // .clientname("banan") // .unitTest(true) // ) .addon(ExceptionMapperAddon.defaults) .addon(ServerLogAddon.defaults) .addon(ElasticsearchIndexAddon.defaults("oneIndex", TestService.Payload.class) .doIndexing(true) ) .bind(ResourceImpl.class, Resource.class); testServiceRunner = TestServiceRunner.defaults(serviceConfig); TestServiceRunner.defaults(serviceConfig); }
@BeforeClass public static void setup() throws NodeValidationException, UnknownHostException { SLF4JBridgeHandler.removeHandlersForRootLogger(); SLF4JBridgeHandler.install(); ServiceConfig serviceConfig = ServiceConfig .defaults(ServiceDefinitionUtil.simple(Resource.class)) .addon(ExceptionMapperAddon.defaults) .addon(ServerLogAddon.defaults) .addon(ElasticsearchAddonMockImpl.defaults) .addon(ElasticsearchIndexAddon.defaults("oneIndex", TestService.Payload.class)) .addon(ElasticsearchIndexAddon.defaults("anotherIndex", String.class)) .bind(ResourceImpl.class, Resource.class); testServiceRunner = TestServiceRunner.defaults(serviceConfig); TestServiceRunner.defaults(serviceConfig); }
public CCOWContextListener(final ContextState commonContext, final Module... behaviourModules) { super(); SLF4JBridgeHandler.removeHandlersForRootLogger(); SLF4JBridgeHandler.install(); logger.info("Starting up servlet ..."); this.modules = ImmutableList.<Module> builder().add(behaviourModules).add(new EndpointModule(commonContext)) .add(new JerseyServletModule() { @Override protected void configureServlets() { final Map<String, String> params = ImmutableMap.<String, String> builder() .put(ResourceConfig.PROPERTY_CONTAINER_RESPONSE_FILTERS, GZIPContentEncodingFilter.class.getName()) .build(); bind(CORSFilter.class).in(Singleton.class); bind(UrlRewriteFilter.class).in(Singleton.class); serve("/*").with(GuiceContainer.class, params); filter("/*").through(CORSFilter.class); filter("/*").through(UrlRewriteFilter.class); requestStaticInjection(WebSocketsConfigurator.class); } }).build(); }
private void initializeLogback() { Path logbackFilePath = Paths.get(configPath, "logback.xml"); if (logbackFilePath.toFile().exists()) { try { // Load logback configuration LoggerContext context = (LoggerContext) LoggerFactory.getILoggerFactory(); context.reset(); JoranConfigurator configurator = new JoranConfigurator(); configurator.setContext(context); configurator.doConfigure(logbackFilePath.toFile()); // Install java.util.logging bridge SLF4JBridgeHandler.removeHandlersForRootLogger(); SLF4JBridgeHandler.install(); } catch (JoranException e) { throw new GossipInitializeException("Misconfiguration on logback.xml, check it.", e); } } }
/** * Initialize Logging * * @param isClient client */ public static void initialize(final boolean isClient) { if (s_initialized.getAndSet(true)) { return; } // // Forward all logs from JUL to SLF4J { SLF4JBridgeHandler.uninstall(); SLF4JBridgeHandler.install(); } if (isClient) { // FRESH-267: in server mode, do not (re)set the loglevels. They are coming out of logback.xml and/or application properties and were probably fine-tuned. // resetting them to info might cause the disk to run full. setLevel(Level.INFO); } }
public static void startIfRequired() throws Exception { if (server == null) { SLF4JBridgeHandler.removeHandlersForRootLogger(); SLF4JBridgeHandler.install(); server = new Server(TEST_PORT); WebAppContext context = new WebAppContext(); context.setDescriptor("src/test/resources/jetty/WEB-INF/web.xml"); context.setResourceBase("src/main/webapp"); context.setContextPath(TEST_CONTEXT); context.setParentLoaderPriority(true); server.setHandler(context); server.start(); } }
private void installJulBridge() { // Workaround for strange ClassCircularityErrors in the JUL bridge when very // strange classloader hierarchies are // set up and logging occurs from inside classloaders themselves (eg: some // strange Tomcat deployments) try { Class.forName("java.util.logging.LogRecord"); } catch (ClassNotFoundException e) { throw new AssertionError(e); } LoggerContext loggerContext = (LoggerContext) getContext(); if (!SLF4JBridgeHandler.isInstalled()) { SLF4JBridgeHandler.removeHandlersForRootLogger(); SLF4JBridgeHandler.install(); } LevelChangePropagator julLevelChanger = new LevelChangePropagator(); julLevelChanger.setContext(loggerContext); julLevelChanger.setResetJUL(true); julLevelChanger.start(); loggerContext.addListener(julLevelChanger); }
public void start(BundleContext context) throws Exception { createUUIDFile(); String versionString = context.getBundle().getVersion().toString(); // if the version string contains a qualifier, remove it! if (StringUtils.countMatches(versionString, ".") == 3) { versionString = StringUtils.substringBeforeLast(versionString, "."); } createVersionFile(versionString); logger.info("openHAB runtime has been started (v{}).", versionString); java.util.logging.Logger rootLogger = java.util.logging.LogManager.getLogManager().getLogger(""); Handler[] handlers = rootLogger.getHandlers(); for (Handler handler : handlers) { rootLogger.removeHandler(handler); } SLF4JBridgeHandler.install(); }
/** Starts the server with HTTPS. */ @BeforeClass public static void startServer() throws Exception { SLF4JBridgeHandler.removeHandlersForRootLogger(); SLF4JBridgeHandler.install(); ssc = new SelfSignedCertificate("example.com"); ServerBuilder sb = new ServerBuilder() .port(0, SessionProtocol.HTTPS) .defaultMaxRequestLength(16 * 1024 * 1024) .sslContext(GrpcSslContexts.forServer(ssc.certificate(), ssc.privateKey()) .applicationProtocolConfig(ALPN) .trustManager(TestUtils.loadCert("ca.pem")) .build()); final ArmeriaGrpcServerBuilder builder = new ArmeriaGrpcServerBuilder(sb, new GrpcServiceBuilder(), ctxCapture); startStaticServer(builder); server = builder.builtServer(); }
public static void main(final String... args) throws Exception { SLF4JBridgeHandler.removeHandlersForRootLogger(); SLF4JBridgeHandler.install(); final App app = new App(); app.startServer(); Injector injector = app.getInjector(); // Bootstrap the database final Bootstrapper bootstrappper = injector.getInstance(Bootstrapper.class); bootstrappper.parseFromResource("/bootstrap/test-bootstrapper.json"); // Init inserted rooms final RoomBackend roomBackend = injector.getInstance(RoomBackend.class); roomBackend.initializeRooms(); app.joinThread(); }
/** * Constructor. */ public LoggingConfig() { boolean bridgeJULtoSLF4J = ConfigManager.getInstance().getBoolean("logging.bridgeJULtoSLF4J", true); if (bridgeJULtoSLF4J) { try { // Remove existing handlers Logger rootLogger = LoggingConfig.getRootLogger(); Handler[] handlers = rootLogger.getHandlers(); for (Handler handler : handlers) { rootLogger.removeHandler(handler); } // Install bridge handler as only handler SLF4JBridgeHandler bridgeToSlf4j = new SLF4JBridgeHandler(); rootLogger.addHandler(bridgeToSlf4j); } catch (Exception e) { System.err.println("Unable to configure java logging due to exception: " + e.getMessage()); e.printStackTrace(); } } }
public static void main(String[] args) throws Exception { SLF4JBridgeHandler.removeHandlersForRootLogger(); SLF4JBridgeHandler.install(); Server server = new Server(9090); ClassList classlist = Configuration.ClassList.setServerDefault(server); classlist.addBefore("org.eclipse.jetty.webapp.JettyWebXmlConfiguration", "org.eclipse.jetty.annotations.AnnotationConfiguration"); WebAppContext webapp = new WebAppContext(); webapp.setParentLoaderPriority(true); webapp.setConfigurationDiscovered(true); webapp.setContextPath("/"); webapp.setResourceBase("src/main/webapp"); webapp.setWar("src/main/webapp"); ServletHolder servletHolder = webapp.addServlet(DemoUIServlet.class, "/*"); servletHolder.setAsyncSupported(true); servletHolder.setInitParameter("org.atmosphere.cpr.asyncSupport", JSR356AsyncSupport.class.getName()); server.setHandler(webapp); ServerContainer webSocketServer = WebSocketServerContainerInitializer.configureContext(webapp); webSocketServer.setDefaultMaxSessionIdleTimeout(10000000); server.start(); log.info("Browse http://localhost:9090 to see the demo"); server.join(); }
/** slf4j / Logback initialization */ private static void init() throws SecurityException, IllegalStateException { final LoggerContext loggerContext = (LoggerContext) LoggerFactory.getILoggerFactory(); final URL logConf = ResourceUtils.getResource(JMMC_LOGBACK_CONFIG_RESOURCE); try { final JoranConfigurator configurator = new JoranConfigurator(); configurator.setContext(loggerContext); loggerContext.reset(); configurator.doConfigure(logConf.openStream()); } catch (IOException ioe) { throw new IllegalStateException("IO Exception occured", ioe); } catch (JoranException je) { StatusPrinter.printInCaseOfErrorsOrWarnings((LoggerContext) LoggerFactory.getILoggerFactory()); } // Remove existing handlers attached to j.u.l root logger SLF4JBridgeHandler.removeHandlersForRootLogger(); // (since SLF4J 1.6.5) // add SLF4JBridgeHandler to j.u.l's root logger, should be done once during // the initialization phase of your application SLF4JBridgeHandler.install(); }
/** * Creates an {@link OSClientFactory} with a custom {@link OSClientCreator}. * * @param apiAccessConfig * API access configuration that describes how to authenticate * with and communicate over the OpenStack API. * */ public OSClientFactory(ApiAccessConfig apiAccessConfig, OSClientBuilder clientBuilder) { checkArgument(apiAccessConfig != null, "no apiAccessConfig given"); checkArgument(clientBuilder != null, "no clientBuilder given"); apiAccessConfig.validate(); this.apiAccessConfig = apiAccessConfig; this.clientBuilder = clientBuilder; if (apiAccessConfig.shouldLogHttpRequests()) { LOG.debug("setting up HTTP request logging"); // enable logging of each http request from openstack4j OSFactory.enableHttpLoggingFilter(true); // Install slf4j logging bridge to capture java.util.logging output // from the openstack4j. NOTE: the logger appears to be named 'os'. SLF4JBridgeHandler.removeHandlersForRootLogger(); SLF4JBridgeHandler.install(); } }
public static void main(String[] args) throws Exception { SLF4JBridgeHandler.removeHandlersForRootLogger(); SLF4JBridgeHandler.install(); AppContext.setup(); ProfileSyncI ssg = AppContext.getService(SyncServiceGIT.class); File localFolder = new File("/mnt/SSD/scratch/gitTesting"); ssg.setRootLocation(localFolder); String username = "username"; String password = "password"; ssg.linkAndFetchFromRemote("https://github.com/" + username + "/test.git", username, password); ssg.linkAndFetchFromRemote("ssh://" + username + "@csfe.aceworkspace.net:29418/testrepo", username, password); ssg.addUntrackedFiles(); System.out.println("UpdateCommitAndPush result: " + ssg.updateCommitAndPush("mergetest2", username, password, MergeFailOption.FAIL, (String[])null)); ssg.removeFiles("b"); System.out.println("Update from remote result: " + ssg.updateFromRemote(username, password, MergeFailOption.FAIL)); HashMap<String, MergeFailOption> resolutions = new HashMap<>(); resolutions.put("b", MergeFailOption.KEEP_REMOTE); System.out.println("resolve merge failures result: " + ssg.resolveMergeFailures(resolutions)); System.out.println("UpdateCommitAndPush result: " + ssg.updateCommitAndPush("mergetest2", username, password, MergeFailOption.FAIL, (String[])null)); }
/** * Application entry point. * * @param args the command line arguments * @throws Exception the exception */ public static void main(String[] args) throws Exception { // Set up like ISAAC App. SLF4JBridgeHandler.removeHandlersForRootLogger(); SLF4JBridgeHandler.install(); AppContext.setup(); // TODO OTF fix: this needs to be fixed so I don't have to hack it with // reflection....(https://jira.ihtsdotools.org/browse/OTFISSUE-11) Field f = Hk2Looker.class.getDeclaredField("looker"); f.setAccessible(true); f.set(null, AppContext.getServiceLocator()); System.setProperty(BdbTerminologyStore.BDB_LOCATION_PROPERTY, new File( "../isaac-app/berkeley-db").getAbsolutePath()); // FHIM Models RS. SampleTest tester = new SampleTest(); tester.shutdown(); }
/** * @param args * @throws IOException * @throws ClassNotFoundException * @throws IllegalAccessException * @throws IllegalArgumentException * @throws SecurityException * @throws NoSuchFieldException */ public static void main(String[] args) throws ClassNotFoundException, IOException, IllegalArgumentException, IllegalAccessException, NoSuchFieldException, SecurityException { // Configure Java logging into logback SLF4JBridgeHandler.removeHandlersForRootLogger(); SLF4JBridgeHandler.install(); AppContext.setup(); // TODO OTF fix: this needs to be fixed so I don't have to hack it with reflection.... https://jira.ihtsdotools.org/browse/OTFISSUE-11 Field f = Hk2Looker.class.getDeclaredField("looker"); f.setAccessible(true); f.set(null, AppContext.getServiceLocator()); System.setProperty(BdbTerminologyStore.BDB_LOCATION_PROPERTY, new File("../../ISAAC-PA/app/berkeley-db").getCanonicalPath()); System.setProperty(LuceneIndexer.LUCENE_ROOT_LOCATION_PROPERTY, new File("../../ISAAC-PA/app/berkeley-db").getCanonicalPath()); launch(args); }
/** * Call this method to recreate a jersey test runtime with the following * configuration changes to the default. * <ul> * <li>Enabled logging of HTTP traffic to the STDERR device.</li> * <li>Enabled dumping of HTTP traffic entities to the STDERR device.</li> * <li>Registered the resource specific as the generic type argument with * the Jersey runtime.</li> * <li>Registered all provides declared in the * <code>chirp.service.providers</code> package.</li> * </ul> */ @Override protected Application configure() { // enable logging of HTTP traffic enable(TestProperties.LOG_TRAFFIC); // enable logging of dumped HTTP traffic entities enable(TestProperties.DUMP_ENTITY); // Jersey uses java.util.logging - bridge to slf4 SLF4JBridgeHandler.removeHandlersForRootLogger(); SLF4JBridgeHandler.install(); // create an instance of the parameterized declared class @SuppressWarnings("unchecked") final Class<R> resourceClass = (Class<R>) ((ParameterizedType) getClass() .getGenericSuperclass()).getActualTypeArguments()[0]; // ResourceConfig is a Jersey specific javax.ws.rs.core.Application // subclass return new ResourceConfig().register(resourceClass); }
@BeforeClass public static void startTomcat() throws ServletException, LifecycleException { SLF4JBridgeHandler.removeHandlersForRootLogger(); SLF4JBridgeHandler.install(); tomcat = new Tomcat(); tomcat.setPort(8081); tomcat.setBaseDir("."); Context ctx = tomcat.addWebapp("/", "src/main/webapp"); ctx.setJarScanner(new JarScanner() { @Override public void scan(ServletContext context, ClassLoader classloader, JarScannerCallback callback, Set<String> jarsToSkip) { } }); ((Host) ctx.getParent()).setAppBase(""); tomcat.start(); server = tomcat.getServer(); server.start(); }
private static Logger getResetRootLogger() { // reset JUL logging LogManager.getLogManager().reset(); // set JUL to allow *all* logging to be enabled // have to do this otherwise it'll filter before slf4j does java.util.logging.Logger.getLogger("").setLevel(java.util.logging.Level.FINEST); // now, reset the JUL handlers and route its messages to slf4j SLF4JBridgeHandler.removeHandlersForRootLogger(); SLF4JBridgeHandler.install(); // note that netty by default will use slf4j // so we don't have to do anything special to get its output // reset the logback system Logger root = (Logger) LoggerFactory.getLogger(ROOT_LOGGER_NAME); root.setLevel(Level.ALL); root.detachAndStopAllAppenders(); return root; }
@Test public void configureSlf4jLogging() throws ServletException { final RequestParameterPolicyEnforcementFilter filter = new RequestParameterPolicyEnforcementFilter(); // mock up filter config. final Set<String> initParameterNames = new HashSet<String>(); initParameterNames.add(RequestParameterPolicyEnforcementFilter.CHARACTERS_TO_FORBID); initParameterNames.add(AbstractSecurityFilter.LOGGER_HANDLER_CLASS_NAME); final Enumeration parameterNamesEnumeration = Collections.enumeration(initParameterNames); final FilterConfig filterConfig = mock(FilterConfig.class); when(filterConfig.getInitParameterNames()).thenReturn(parameterNamesEnumeration); when(filterConfig.getInitParameter(RequestParameterPolicyEnforcementFilter.CHARACTERS_TO_FORBID)) .thenReturn("none"); when(filterConfig.getInitParameter(RequestParameterPolicyEnforcementFilter.PARAMETERS_TO_CHECK)) .thenReturn(null); when(filterConfig.getInitParameter(AbstractSecurityFilter.LOGGER_HANDLER_CLASS_NAME)) .thenReturn(SLF4JBridgeHandler.class.getCanonicalName()); filter.init(filterConfig); assertTrue(filter.getLogger().getHandlers().length > 0); assertTrue(filter.getLogger().getHandlers()[0] instanceof SLF4JBridgeHandler); }
@Before public void initImpl() throws LifecycleException, ServletException { if (!inited.contains(getClass())) { inited.add(getClass()); SLF4JBridgeHandler.removeHandlersForRootLogger(); SLF4JBridgeHandler.install(); tomcat = new Tomcat(); tomcat.setPort(PORT); tomcat.setBaseDir("."); final Context ctx = tomcat.addWebapp("", "src/test"); ctx.setJarScanner(NO_SCAN); ((Host) ctx.getParent()).setAppBase(""); init(ctx); tomcat.start(); } }
public static void main(String... args) throws Exception { Boot boot = new Boot(); LogManager.getLogManager().reset(); SLF4JBridgeHandler.install(); try { boot.boot(); } catch (Exception e) { e.printStackTrace(); System.exit(1); } //in case of an exception we don't arrive here because of system.exit! System.out.println("Stopping normally."); System.exit(0); }
/** * Starts a new {@link GitServer} instance on a specified port. You can specify a HTTP port by providing an argument * of the form <code>--httpPort=xxxx</code> where <code>xxxx</code> is a port number. If no such argument is * specified the HTTP port defaults to 8080. * * @param args * The arguments to influence the start-up phase of the {@link GitServer} instance. * @throws Exception * In case the {@link GitServer} instance could not be started. */ public static void main(String[] args) throws Exception { SLF4JBridgeHandler.removeHandlersForRootLogger(); SLF4JBridgeHandler.install(); // TODO: Fix this... SshSessionFactory.setInstance(new JschConfigSessionFactory() { @Override protected void configure(Host hc, Session session) { session.setConfig("StrictHostKeyChecking", "no"); } }); Config config = new Config(); config.reload(); GitServer server = new GitServer(config); server.start(); server.join(); }
@Test public void pumpMessages() throws Exception { java.util.logging.LogManager.getLogManager().getLogger("").setLevel(Level.FINEST); SLF4JBridgeHandler.removeHandlersForRootLogger(); SLF4JBridgeHandler.install(); log.info("Creating UNIT TEST Class"); createOracleAQQueue(); Clob message = CLOB.createTemporary(dbConnection, false, CLOB.DURATION_SESSION); message.setString(1, TEST_MESSAGE); String plsql = String.format("begin mdb_aq.send_message('" + DB_SCHEMA_NAME + ".%1$s', ?); end;", oracleQueueName); CallableStatement statement = dbConnection.prepareCall(plsql); statement.setClob(1, message); statement.execute(); statement.close(); message.free(); }
private void start() throws LifecycleException, ServletException { SLF4JBridgeHandler.removeHandlersForRootLogger(); SLF4JBridgeHandler.install(); tomcat = new Tomcat(); tomcat.setPort(port); tomcat.setBaseDir("."); Context ctx = tomcat.addWebapp("", Ramls.clientDir("src/test")); ctx.setJarScanner(NO_SCAN); ((Host) ctx.getParent()).setAppBase(""); contextIniter.initContext(ctx); tomcat.start(); Server server = tomcat.getServer(); server.start(); }
private static void initializeLogging() { if (!loggingInitialized.get()) { synchronized (UdidbServer.class) { if (!loggingInitialized.get()) { System.setProperty("vertx.logger-delegate-factory-class-name", "io.vertx.core.logging.SLF4JLogDelegateFactory"); SLF4JBridgeHandler.removeHandlersForRootLogger(); SLF4JBridgeHandler.install(); loggingInitialized.set(true); } } } }
private void install(Level level) { if (installed) { return; } LogManager.getLogManager().reset(); SLF4JBridgeHandler.install(); logger.setLevel(level); installed = true; }
protected void run(String[] args) { SLF4JBridgeHandler.removeHandlersForRootLogger(); SLF4JBridgeHandler.install(); LaunchOptions res = parseArguments( args ); final CompositeConfiguration config; try { config = ConfigUtil.load( res.getSource() ); } catch( final ConfigurationException e ) { throw new JBakeException( "Configuration error: " + e.getMessage(), e ); } run(res, config); }
public static void main(String[] args) throws Exception { SLF4JBridgeHandler.removeHandlersForRootLogger(); SLF4JBridgeHandler.install(); Server server = new Server(); ServerConnector connector = new ServerConnector(server); connector.setPort(8080); server.setConnectors(new Connector[]{connector}); WebAppContext context = new WebAppContext(); context.setServer(server); context.setContextPath("/"); context.setAttribute("org.eclipse.jetty.server.webapp.ContainerIncludeJarPattern", ".*/[^/]*taglibs.*\\.jar$"); context.setAttribute("org.eclipse.jetty.containerInitializers", jspInitializers()); context.setAttribute(InstanceManager.class.getName(), new SimpleInstanceManager()); context.addBean(new ServletContainerInitializersStarter(context), true); // Prevent loading of logging classes context.getSystemClasspathPattern().add("org.apache.log4j."); context.getSystemClasspathPattern().add("org.slf4j."); context.getSystemClasspathPattern().add("org.apache.commons.logging."); ProtectionDomain protectionDomain = EmbeddedJettyServer.class.getProtectionDomain(); URL location = protectionDomain.getCodeSource().getLocation(); context.setWar(location.toExternalForm()); server.setHandler(context); try { server.start(); server.join(); } catch (Exception e) { e.printStackTrace(); System.exit(-1); } }
@Override public void start( BundleContext context ) throws Exception { // Remove existing handlers attached to j.u.l root logger SLF4JBridgeHandler.removeHandlersForRootLogger(); SLF4JBridgeHandler.install(); }
/** * Redirect JUL from third-party libraries to SLF4J */ private void redirectJULtoSLF4J() { LOGGER.info("Redirecting JUL to SLF4J"); LogManager.getLogManager().reset(); SLF4JBridgeHandler.removeHandlersForRootLogger(); SLF4JBridgeHandler.install(); java.util.logging.Logger.getGlobal().setLevel(Level.FINEST); }
public static void main(String[] args) throws Exception { SLF4JBridgeHandler.removeHandlersForRootLogger(); SLF4JBridgeHandler.install(); int port = 8888; if (args.length > 0) { port = Integer.parseInt(args[0]); } if (port == 80) { System.out.println("Dorset web demo running on http://localhost/"); } else { System.out.println("Dorset web demo running on http://localhost:" + String.valueOf(port) + "/"); } Server server = new Server(port); WebAppContext context = new WebAppContext(); context.setServer(server); context.setContextPath("/"); // turn off class loading from WEB-INF due to logging context.setParentLoaderPriority(true); ProtectionDomain protectionDomain = Runner.class.getProtectionDomain(); URL location = protectionDomain.getCodeSource().getLocation(); context.setWar(location.toExternalForm()); server.setHandler(context); server.start(); server.join(); }
@Override public void execute() throws MojoFailureException, MojoExecutionException { SLF4JBridgeHandler.install(); List<CarnotzetExtension> runtimeExtensions = findRuntimeExtensions(); CarnotzetModuleCoordinates coordinates = new CarnotzetModuleCoordinates(project.getGroupId(), project.getArtifactId(), project.getVersion()); if (instanceId == null) { instanceId = Carnotzet.getModuleName(coordinates, Pattern.compile(CarnotzetConfig.DEFAULT_MODULE_FILTER_PATTERN), Pattern.compile(CarnotzetConfig.DEFAULT_CLASSIFIER_INCLUDE_PATTERN)); } Path resourcesPath = Paths.get(project.getBuild().getDirectory(), "carnotzet"); if (SystemUtils.IS_OS_WINDOWS) { // we avoid using ${project.build.directory} because "mvn clean" when the sandbox is running would try to delete mounted files, // which is not supported on Windows. resourcesPath = Paths.get("/var/tmp/carnotzet_" + instanceId); } CarnotzetConfig config = CarnotzetConfig.builder() .topLevelModuleId(coordinates) .resourcesPath(resourcesPath) .topLevelModuleResourcesPath(project.getBasedir().toPath().resolve("src/main/resources")) .failOnDependencyCycle(failOnDependencyCycle) .extensions(runtimeExtensions) .build(); carnotzet = new Carnotzet(config); if (bindLocalPorts == null) { bindLocalPorts = !SystemUtils.IS_OS_LINUX; } runtime = new DockerComposeRuntime(carnotzet, instanceId, DefaultCommandRunner.INSTANCE, bindLocalPorts); executeInternal(); SLF4JBridgeHandler.uninstall(); }
/** * Configureer JUL. */ public final void configure() { LOGGER.debug("Configure java.util.logging to log via SLF4j"); // Remove existing handlers SLF4JBridgeHandler.removeHandlersForRootLogger(); // Install SLF4j bridge SLF4JBridgeHandler.install(); // Uit performance oogpunt sturen we alleen INFO logs door LogManager.getLogManager().getLogger("").setLevel(Level.INFO); }
public ServiceRunner start() { SLF4JBridgeHandler.removeHandlersForRootLogger(); SLF4JBridgeHandler.install(); jerseyConfig .addRegistrators(serviceConfig.registrators) .addBinders(serviceConfig.binders); serviceConfig.addons.forEach(it -> it.addToJerseyConfig(jerseyConfig)); serviceConfig.addons.forEach(it -> it.addToJettyServer(jettyServer)); jettyServer.start(); return this; }
/** * Entry point. You must provide a single argument on the command line: a valid Graph API access token. * * @param args * Command-line arguments. * @throws IllegalArgumentException * If no command-line arguments are provided. */ public static void main(String[] args) { if (args.length == 0) throw new IllegalArgumentException( "You must provide an OAuth access token parameter. See README for more information."); SLF4JBridgeHandler.removeHandlersForRootLogger(); SLF4JBridgeHandler.install(); new GraphReaderExample(args[0]).runEverything(); }
@Override protected void initGlobalSettings () { // Logging: JUL to SLF4J SLF4JBridgeHandler.removeHandlersForRootLogger (); SLF4JBridgeHandler.install (); if (GlobalDebug.isDebugMode ()) RequestTracker.getInstance ().getRequestTrackingMgr ().setLongRunningCheckEnabled (false); HttpDebugger.setEnabled (false); }