@Override public Server apply(@Nullable String baseResource) { if (!jetty.getState().equals(Server.STARTED) // TODO code smell = hard coding addresses or ports!! && !new InetSocketAddressConnect().apply(new IPSocket("localhost", port))) { ResourceHandler resource_handler = new ResourceHandler(); resource_handler.setDirectoriesListed(true); resource_handler.setWelcomeFiles(new String[] {"index.html"}); resource_handler.setResourceBase(baseResource); logger.info("serving " + resource_handler.getBaseResource()); HandlerList handlers = new HandlerList(); handlers.setHandlers(new Handler[] {resource_handler, new DefaultHandler()}); jetty.setHandler(handlers); try { jetty.start(); } catch (Exception e) { logger.error(e, "Server jetty could not be started at this %s", baseResource); } return jetty; } else { logger.debug("Server jetty serving %s already running. Skipping start", baseResource); return jetty; } }
public void start(Injector injector) throws Exception { ResourceHandler resHandler = new ResourceHandler(); resHandler.setDirectoriesListed(false); resHandler.setWelcomeFiles(new String[] {"index.html"}); resHandler.setResourceBase(args.get("jetty.resourcebase", "./src/main/webapp")); server = new Server(); // getSessionHandler and getSecurityHandler should always return null ServletContextHandler servHandler = new ServletContextHandler( ServletContextHandler.NO_SECURITY | ServletContextHandler.NO_SESSIONS); servHandler.setContextPath("/"); servHandler.addServlet(new ServletHolder(new InvalidRequestServlet()), "/*"); FilterHolder guiceFilter = new FilterHolder(injector.getInstance(GuiceFilter.class)); servHandler.addFilter(guiceFilter, "/*", EnumSet.allOf(DispatcherType.class)); SelectChannelConnector connector0 = new SelectChannelConnector(); int httpPort = args.getInt("jetty.port", 8989); String host = args.get("jetty.host", ""); connector0.setPort(httpPort); if (!host.isEmpty()) connector0.setHost(host); server.addConnector(connector0); HandlerList handlers = new HandlerList(); handlers.setHandlers(new Handler[] {resHandler, servHandler}); server.setHandler(handlers); server.start(); logger.info("Started server at HTTP " + host + ":" + httpPort); }
private static Handler resourceHandler() { ResourceHandler resourceHandler = new ResourceHandler(); resourceHandler.setBaseResource(Resource.newClassPathResource("/web", false, false)); resourceHandler.setWelcomeFiles(new String[] {"index.html"}); resourceHandler.setMinMemoryMappedContentLength(-1); return resourceHandler; }
@Test public void testReplaceHandler() throws Exception { ServletContextHandler servletContextHandler = new ServletContextHandler(); ServletHolder sh = new ServletHolder(new TestServlet()); servletContextHandler.addServlet(sh, "/foo"); final AtomicBoolean contextInit = new AtomicBoolean(false); final AtomicBoolean contextDestroy = new AtomicBoolean(false); servletContextHandler.addEventListener( new ServletContextListener() { @Override public void contextInitialized(ServletContextEvent sce) { if (sce.getServletContext() != null) contextInit.set(true); } @Override public void contextDestroyed(ServletContextEvent sce) { if (sce.getServletContext() != null) contextDestroy.set(true); } }); ServletHandler shandler = servletContextHandler.getServletHandler(); ResourceHandler rh = new ResourceHandler(); servletContextHandler.insertHandler(rh); assertEquals(shandler, servletContextHandler.getServletHandler()); assertEquals(rh, servletContextHandler.getHandler()); assertEquals(rh.getHandler(), shandler); _server.setHandler(servletContextHandler); _server.start(); assertTrue(contextInit.get()); _server.stop(); assertTrue(contextDestroy.get()); }
public static void main(String[] args) throws Exception { int port = 8080; if (args.length == 1) { String portString = args[0]; port = Integer.valueOf(portString); } System.out.append("Starting at port: ").append(String.valueOf(port)).append('\n'); AccountService accountService = new AccountService(); Servlet frontend = new Frontend(); Servlet auth = new AuthServlet(accountService); Server server = new Server(port); ServletContextHandler context = new ServletContextHandler(ServletContextHandler.SESSIONS); context.addServlet(new ServletHolder(frontend), "/api/v1/auth/signin"); context.addServlet(new ServletHolder(auth), "/auth/*"); ResourceHandler resource_handler = new ResourceHandler(); resource_handler.setDirectoriesListed(true); resource_handler.setResourceBase("public_html"); HandlerList handlers = new HandlerList(); handlers.setHandlers(new Handler[] {resource_handler, context}); server.setHandler(handlers); server.start(); server.join(); }
public static void main(String[] args) throws Exception { if (args.length < 1) { throw new RuntimeException("Expected >=1 command line arguments"); } String sourceDir = args[0]; logger.log(Level.INFO, "Source directory: " + sourceDir); int port = args.length > 1 ? Integer.parseInt(args[1]) : 8080; Server server = new Server(port); ServletContextHandler servletHandler = new ServletContextHandler(ServletContextHandler.SESSIONS); servletHandler.setContextPath("/"); servletHandler.addServlet(ProxyingServlet.class, "/mirror"); servletHandler.addServlet(AwtThumbnailServlet.class, "/thumb"); servletHandler.addServlet(OAuthServlet.class, "/oauth"); final ResourceHandler fileServlet = new ResourceHandler(); fileServlet.setResourceBase(sourceDir); fileServlet.setDirectoriesListed(true); // Don't let the corp proxy cache content served out of the filesystem, // since we expect this may be used by a developer who's modifying it. fileServlet.setCacheControl("no-cache"); HandlerList handlers = new HandlerList(); handlers.setHandlers( new Handler[] { fileServlet, servletHandler, new DartHandler(sourceDir), new DefaultHandler() }); server.setHandler(handlers); System.out.println("Sample dart apps served at:\n" + "http://localhost:" + port + "/samples/"); server.start(); server.join(); }
private void initialize(int port) throws Exception { System.out.println("Starting web server..."); webServer = new Server(port); ServletContextHandler requestHandler = new ServletContextHandler(); requestHandler.setContextPath("/"); requestHandler.setClassLoader(Thread.currentThread().getContextClassLoader()); requestHandler.addServlet(new ServletHolder(new RequestServlet()), "/xmlrpc/*"); ServletContextHandler uploadHandler = new ServletContextHandler(); uploadHandler.setContextPath("/upload"); uploadHandler.setClassLoader(Thread.currentThread().getContextClassLoader()); uploadHandler.addFilter(MultiPartFilter.class, "/", FilterMapping.ALL); uploadHandler.addServlet(new ServletHolder(new DesignUploadServlet()), "/"); ResourceHandler resourceHandler = new ResourceHandler(); resourceHandler.setDirectoriesListed(false); resourceHandler.setResourceBase("./web"); resourceHandler.setWelcomeFiles(new String[] {"index.html"}); HandlerList handlers = new HandlerList(); handlers.addHandler(requestHandler); handlers.addHandler(uploadHandler); handlers.addHandler(resourceHandler); webServer.setHandler(handlers); }
@Test public void test() throws Exception { // Create a basic Jetty server object that will listen on port 8080. Note that if you set this // to port 0 // then a randomly available port will be assigned that you can either look in the logs for the // port, // or programmatically obtain it for use in test cases. Server server = new Server(8080); // Create the ResourceHandler. It is the object that will actually handle the request for a // given file. It is // a Jetty Handler object so it is suitable for chaining with other handlers as you will see in // other examples. ResourceHandler resource_handler = new ResourceHandler(); // Configure the ResourceHandler. Setting the resource base indicates where the files should be // served out of. // In this example it is the current directory but it can be configured to anything that the jvm // has access to. resource_handler.setDirectoriesListed(true); resource_handler.setWelcomeFiles(new String[] {"index.html"}); resource_handler.setResourceBase("C:\\work\\wget_files"); // Add the ResourceHandler to the server. HandlerList handlers = new HandlerList(); handlers.setHandlers(new Handler[] {resource_handler, new DefaultHandler()}); server.setHandler(handlers); // Start things up! By using the server.join() the server thread will join with the current // thread. // See "http://docs.oracle.com/javase/1.5.0/docs/api/java/lang/Thread.html#join()" for more // details. server.start(); server.join(); }
public void applyHandle(Boolean warDeployFlag) { if (StringUtils.isBlank(webDefault)) { webDefault = "org.eclipse.jetty.webapp.webdefault.xml"; } // contexts handler ContextHandlerCollection contexthandler = new ContextHandlerCollection(); WebAppContext webapp = new WebAppContext(); webapp.setContextPath(contextPath); webapp.setDefaultsDescriptor(webDefault); webapp.setTempDirectory(new File(warTmp)); // webapp.setParentLoaderPriority(true); if (!warDeployFlag) { webapp.setResourceBase(resourceBase); webapp.setDescriptor(webXmlPath); } else { webapp.setWar(warPath); } ResourceHandler resource_handler = new ResourceHandler(); resource_handler.setDirectoriesListed(true); resource_handler.setWelcomeFiles(new String[] {"index.html"}); resource_handler.setResourceBase(resourceBase); contexthandler.setHandlers( new Handler[] { webapp, resource_handler, new DefaultHandler(), new StatisticsHandler(), new GzipHandler() }); super.setHandler(contexthandler); }
private ResourceHandler buildStaticResourcesHandler() { ResourceHandler staticHandler = new ResourceHandler(); URL staticResources = TestWebServer.class.getClassLoader().getResource("website/static"); staticHandler.setResourceBase(staticResources.toExternalForm()); staticHandler.setWelcomeFiles(new String[] {"index.html"}); staticHandler.setDirectoriesListed(false); return staticHandler; }
@BeforeClass public static void setup() throws Exception { server.setStopAtShutdown(true); ResourceHandler handler = new ResourceHandler(); handler.setBaseResource(Resource.newClassPathResource("/ontologies/import/")); server.setHandler(handler); server.start(); }
public void run() { Properties jettyProperties = new Properties(); String pFileName = PropertiesUtil.getJettyPropertiesFile(); try { jettyProperties.load(new FileInputStream(pFileName)); } catch (IOException e) { log.error("load properties from {} error.", pFileName); return; } // crate server server = new Server(Integer.parseInt(jettyProperties.getProperty(PropList.HTTP_PORT))); // Create the ResourceHandler. It is the object that will actually handle the request for a // given file. It is // a Jetty Handler object so it is suitable for chaining with other handlers as you will see in // other examples. ResourceHandler resource_handler = new ResourceHandler(); // Configure the ResourceHandler. Setting the resource base indicates where the files should be // served out of. // In this example it is the current directory but it can be configured to anything that the jvm // has access to. resource_handler.setDirectoriesListed(true); resource_handler.setWelcomeFiles(new String[] {"index.html"}); resource_handler.setResourceBase(PropertiesUtil.getWebBaseDir()); log.debug(PropertiesUtil.getWebBaseDir()); // Add a single handler on context "/hello" ContextHandler context = new ContextHandler(); context.setContextPath("/LoadT"); context.setHandler(new LoadTHandler()); // Add the ResourceHandler to the server. GzipHandler gzip = new GzipHandler(); server.setHandler(gzip); // make handler chain HandlerList handlers = new HandlerList(); handlers.setHandlers(new Handler[] {resource_handler, context, new DefaultHandler()}); gzip.setHandler(handlers); try { server.start(); } catch (Exception e) { log.error("embedded jetty server start error.", e); } server.dumpStdErr(); /* try { server.join(); } catch (InterruptedException e) { log.info("jetty server interrupted", e); }*/ }
public void staticResources(String resourceBase) { ResourceHandler extResourceHandler = new ResourceHandler(); extResourceHandler.setResourceBase(resourceBase); extResourceHandler.setWelcomeFiles(new String[] {"index.html"}); extResourceHandler.setDirectoriesListed(true); ContextHandler contextHandler = new ContextHandler(rootContext); contextHandler.setHandler(extResourceHandler); handlerList.add(contextHandler); }
private void run() throws Exception { ResourceHandler resourceHandler = new ResourceHandler(); resourceHandler.setDirectoriesListed(true); resourceHandler.setResourceBase("web"); Server server = new Server(8080); server.setHandler(resourceHandler); server.start(); server.join(); }
/* * 启动Jetty的Web服务器功能 */ private static void startJettyWebServer() throws Exception { Server server = new Server(8080); ResourceHandler resourceHandler = new ResourceHandler(); resourceHandler.setResourceBase("/home"); server.setHandler(resourceHandler); resourceHandler.setDirectoriesListed(true); server.start(); log.info("Jetty Start Up Successfully :D"); }
@Override public void handle( String target, Request baseRequest, HttpServletRequest request, HttpServletResponse response) throws IOException, ServletException { HttpServletRequestWrapper modifiedRequest = new HttpServletRequestWrapper(request) { // Prevent NOT_MODIFIED_SINCE 304 response private static final long WAS_MODIFIED = -1; @Override public long getDateHeader(String name) { HttpServletRequest request = (HttpServletRequest) getRequest(); if (HttpHeaders.IF_MODIFIED_SINCE.equals(name)) { return WAS_MODIFIED; } return request.getDateHeader(name); }; }; HttpServletResponseWrapper modifiedResponce = new HttpServletResponseWrapper(response) { // Prevent "if-modified-since" headers handling @Override public void setDateHeader(String name, long date) {} }; super.handle(target, baseRequest, modifiedRequest, modifiedResponce); }
public static void main(String[] args) throws Exception { // Create the Server object and a corresponding ServerConnector and then set the port for the // connector. In // this example the server will listen on port 8090. If you set this to port 0 then when the // server has been // started you can called connector.getLocalPort() to programmatically get the port the server // started on. Server server = new Server(); ServerConnector connector = new ServerConnector(server); connector.setPort(8090); server.setConnectors(new Connector[] {connector}); // Create a Context Handler and ResourceHandler. The ContextHandler is getting set to "/" path // but this could // be anything you like for builing out your url. Note how we are setting the ResourceBase using // our jetty // maven testing utilities to get the proper resource directory, you needn't use these, // you simply need to supply the paths you are looking to serve content from. ContextHandler context0 = new ContextHandler(); context0.setContextPath("/"); ResourceHandler rh0 = new ResourceHandler(); rh0.setBaseResource(Resource.newResource(MavenTestingUtils.getTestResourceDir("dir0"))); context0.setHandler(rh0); // Rinse and repeat the previous item, only specifying a different resource base. ContextHandler context1 = new ContextHandler(); context1.setContextPath("/"); ResourceHandler rh1 = new ResourceHandler(); rh1.setBaseResource(Resource.newResource(MavenTestingUtils.getTestResourceDir("dir1"))); context1.setHandler(rh1); // Create a ContextHandlerCollection and set the context handlers to it. This will let jetty // process urls // against the declared contexts in order to match up content. ContextHandlerCollection contexts = new ContextHandlerCollection(); contexts.setHandlers(new Handler[] {context0, context1}); server.setHandler(contexts); // Start things up! By using the server.join() the server thread will join with the current // thread. // See "http://docs.oracle.com/javase/1.5.0/docs/api/java/lang/Thread.html#join()" for more // details. server.start(); System.err.println(server.dump()); server.join(); }
/** * Populate the server with handlers and start it. * * @throws Exception if unable to set up and start Jetty server. */ public void start() throws Exception { final SocketConnector connector = new SocketConnector(); connector.setPort(port); server.setConnectors(new Connector[] {connector}); // Configure a basic resource handler. ResourceHandler rh = new ResourceHandler(); rh.setDirectoriesListed(true); rh.setWelcomeFiles(new String[] {"index.html"}); rh.setResourceBase(staticResourcePath); HandlerList handlers = new HandlerList(); handlers.setHandlers(new Handler[] {rh, new DefaultHandler()}); server.setHandler(handlers); server.start(); }
@Before public void startHttp() throws Exception { server = new Server(); SelectChannelConnector connector = new SelectChannelConnector(); connector.setPort(8778); server.addConnector(connector); ResourceHandler resource_handler = new ResourceHandler(); resource_handler.setDirectoriesListed(false); resource_handler.setWelcomeFiles(new String[] {}); resource_handler.setResourceBase("target/test-classes/repo2"); HandlerList handlers = new HandlerList(); handlers.setHandlers(new Handler[] {resource_handler, new DefaultHandler()}); server.setHandler(handlers); server.start(); }
@BeforeClass public static void setUpFakeMavenRepo() throws Exception { repo = TestDataHelper.getTestDataDirectory(new ResolverIntegrationTest()); // If we're running this test in IJ, then this path doesn't exist. Fall back to one that does if (!Files.exists(repo)) { repo = Paths.get("test/com/facebook/buck/maven/testdata"); } httpd = new HttpdForTests(); ResourceHandler resourceHandler = new ResourceHandler(); resourceHandler.setDirectoriesListed(true); resourceHandler.setResourceBase(repo.toAbsolutePath().toString()); ContextHandler contextHandler = new ContextHandler("/"); contextHandler.setHandler(resourceHandler); contextHandler.setLogger(new StdErrLog()); httpd.addHandler(contextHandler); httpd.start(); }
public static void main(String[] args) throws Exception { Server server = new Server(8080); int options = ServletContextHandler.NO_SECURITY; ServletContextHandler context = new ServletContextHandler(server, "/", options); FilterHolder filter = new FilterHolder(LoggerFilter.class); FilterHolder filter2 = new FilterHolder(PreParseFilter.class); context.addFilter(filter, "/*", null); context.addFilter(filter2, "/*", null); ResourceHandler resource_handler = new ResourceHandler(); resource_handler.setDirectoriesListed(true); resource_handler.setWelcomeFiles(new String[] {"index.html"}); resource_handler.setResourceBase("."); context.addServlet("DummyServlet", "/*"); server.start(); server.join(); }
private void addResourceHandler(String contextPath, String filePath) throws Exception { if (handlerCollection != null) { logger.log(Level.INFO, "Adding resource : " + contextPath + "=>" + filePath); ResourceHandler resourceHandler = new ResourceHandler(); resourceHandler.setResourceBase(filePath); logger.log(Level.INFO, "serving: " + resourceHandler.getBaseResource()); ContextHandler contextHandler = new ContextHandler(contextPath); contextHandler.setHandler(resourceHandler); handlerCollection.addHandler(contextHandler); try { resourceHandler.start(); contextHandler.start(); } catch (Exception e) { logger.log(Level.INFO, "Could not start resource context", e); } } }
public static void main(String[] args) throws Exception { AccountService accountService = new AccountService(); accountService.addNewUser(new UserProfile("admin")); accountService.addNewUser(new UserProfile("Test")); ServletContextHandler context = new ServletContextHandler(ServletContextHandler.SESSIONS); context.addServlet(new ServletHolder(new UsersServlet(accountService)), "/users"); context.addServlet(new ServletHolder(new SessionsServlet(accountService)), "/sessions"); ResourceHandler resource_handler = new ResourceHandler(); resource_handler.setResourceBase("templates/lab2/public"); HandlerList handlers = new HandlerList(); handlers.setHandlers(new Handler[] {resource_handler, context}); Server server = new Server(8080); server.setHandler(handlers); server.start(); server.join(); }
public Server jettyServer() { if (jettyServer == null) { jettyServer = new Server(); ServerConnector connector = new ServerConnector(jettyServer); connector.setHost(settings.serverHost()); connector.setPort(settings.serverPort()); connector.setIdleTimeout(settings.serverIdleTimeout()); jettyServer.addConnector(connector); JettyHandler appHandler = jettyHandler(); ResourceHandler resourceHandler = new ResourceHandler(); resourceHandler.setResourceBase(settings.assetsPath()); HandlerList handlers = new HandlerList(); handlers.setHandlers(new Handler[] {appHandler, resourceHandler}); jettyServer.setHandler(handlers); } return jettyServer; }
public static void main(String[] args) { DBService dbService = new DBService(); dbService.printConnectInfo(); ServletContextHandler context = new ServletContextHandler(ServletContextHandler.SESSIONS); // context.setContextPath("/"); // context.addServlet(new ServletHolder(new MainServlet()), "/"); context.addServlet(new ServletHolder(new SignUpServlet(dbService)), "/signup"); context.addServlet(new ServletHolder(new SignInServlet(dbService)), "/signin"); ResourceHandler resource_handler = new ResourceHandler(); resource_handler.setResourceBase("./public_html"); HandlerList handlers = new HandlerList(); handlers.setHandlers(new Handler[] {resource_handler, context}); Server server = new Server(8080); server.setHandler(handlers); try { long userId = dbService.addUser("test1", "test1"); System.out.println("Added user id: " + userId); UsersDataSet dataSet = dbService.getUser(userId); System.out.println("User data set: " + dataSet); // dbService.cleanUp(); } catch (DBException e) { e.printStackTrace(); } try { server.start(); System.out.println("Server started"); server.join(); } catch (Exception e) { e.printStackTrace(); } }
public void start() { server = new Server(port); // Override the context classloader, so that Jetty uses the plugin classloader not the main // DMDirc loader. final Thread currentThread = Thread.currentThread(); final ClassLoader classLoader = currentThread.getContextClassLoader(); currentThread.setContextClassLoader(getClass().getClassLoader()); try { final ResourceHandler resourceHandler = new ResourceHandler(); resourceHandler.setWelcomeFiles(new String[] {"index.html"}); resourceHandler.setBaseResource(Resource.newClassPathResource("/www")); final ResourceHandler clientResourceHandler = new ResourceHandler(); clientResourceHandler.setBaseResource(Resource.newClassPathResource("/com/dmdirc/res/")); final ContextHandler clientResourceContext = new ContextHandler("/res"); clientResourceContext.setHandler(clientResourceHandler); final ServletContextHandler wsHandler = new ServletContextHandler(); wsHandler.setContextPath("/"); wsHandler.addServlet(WebUiWebSocketServlet.class, "/ws"); HandlerList handlers = new HandlerList(); handlers.setHandlers( new Handler[] {resourceHandler, clientResourceContext, wsHandler, new DefaultHandler()}); server.setHandler(handlers); server.start(); } catch (Exception ex) { LOG.error(LogUtils.USER_ERROR, "Unable to start web server", ex); server = null; } finally { // Restore the usual context class loader. currentThread.setContextClassLoader(classLoader); } }
@Override public void handle( String target, Request baseRequest, HttpServletRequest request, HttpServletResponse response) throws IOException, ServletException { final String suffix = RequestPath.suffix(target); final String path = path(suffix); if (!paths.contains(path)) { if (!whitelist.contains(suffix)) return; if (!"GET".equals(baseRequest.getMethod())) baseRequest.setMethod(HttpMethod.GET, HttpMethod.GET.toString()); super.handle(target, baseRequest, request, allowCrossOrigin(response)); } else { baseRequest .getContext() .getContext(path) .getRequestDispatcher(target) .forward(request, allowCrossOrigin(response)); } }
@Override public void run() { try { Server server = new Server(httpPort); ResourceHandler rh1 = new ResourceHandler(); rh1.setDirectoriesListed(false); rh1.setResourceBase(httpdir); rh1.setWelcomeFiles(new String[] {fileName}); ResourceHandler rh2 = new ResourceHandler(); rh2.setDirectoriesListed(false); rh2.setResourceBase(runtimePath); HandlerList handlers = new HandlerList(); handlers.setHandlers(new Handler[] {rh1, rh2, new DefaultHandler()}); server.setHandler(handlers); server.start(); this.server = server; this.server.join(); } catch (BindException e) { httpPort++; run(); } catch (Exception e) { ex = e; } }
public void start(String args[]) { Logger.getRootLogger().setLevel(Level.ERROR); PropertiesManager pm = new PropertiesManager(); File propFile = new File(propFileName); if (propFile.isFile()) pm.join(propFile); pm.importSystemProps(); try { pm.update(); } catch (IllegalArgumentException e) { System.err.println("invalid configuration, can't start: " + e.getMessage()); System.exit(1); } if (pm.withjmx) { doJmx(pm); } System.setProperty("org.eclipse.jetty.util.log.class", "org.eclipse.jetty.util.log.Slf4jLog"); System.setProperty("org.eclipse.jetty.LEVEL", "DEBUG"); final Server server = new Server(); ServerConnector connector = new ServerConnector(server); if (host != null) { connector.setHost(host); } connector.setPort(port); // Let's try to start the connector before the application try { connector.open(); } catch (IOException e) { connector.close(); throw new RuntimeException("Jetty server failed to start", e); } server.setConnectors(new Connector[] {connector}); WebAppContext webapp = new WebAppContext(); webapp.setContextPath("/"); webapp.setResourceBase(webRoot); webapp.setClassLoader(getClass().getClassLoader()); webapp.setInitParameter("propertiesFile", propFileName); ResourceHandler staticFiles = new ResourceHandler(); staticFiles.setWelcomeFiles(new String[] {"index.html"}); staticFiles.setResourceBase(webRoot); if (pm.security) { LoginService loginService = new HashLoginService("jrds", pm.userfile); server.addBean(loginService); Authenticator auth = new BasicAuthenticator(); Constraint constraint = new Constraint(); constraint.setName("jrds"); constraint.setRoles(new String[] {Constraint.ANY_ROLE}); constraint.setAuthenticate(true); constraint.setDataConstraint(Constraint.DC_NONE); ConstraintMapping cm = new ConstraintMapping(); cm.setConstraint(constraint); cm.setPathSpec("/*"); ConstraintSecurityHandler sh = new ConstraintSecurityHandler(); sh.setConstraintMappings(Collections.singletonList(cm)); sh.setAuthenticator(auth); webapp.setSecurityHandler(sh); } HandlerCollection handlers = new HandlerList(); handlers.setHandlers(new Handler[] {staticFiles, webapp}); server.setHandler(handlers); if (pm.withjmx || MBeanServerFactory.findMBeanServer(null).size() > 0) { MBeanServer mbs = java.lang.management.ManagementFactory.getPlatformMBeanServer(); server.addBean(new MBeanContainer(mbs)); handlers.addHandler(new StatisticsHandler()); } // Properties are not needed any more pm = null; Thread finish = new Thread() { public void run() { try { server.stop(); } catch (Exception e) { throw new RuntimeException("Jetty server failed to stop", e); } } }; Runtime.getRuntime().addShutdownHook(finish); try { server.start(); server.join(); } catch (Exception e) { throw new RuntimeException("Jetty server failed to start", e); } }
@SuppressWarnings({"unchecked", "rawtypes"}) public Task<Void> start() { // Ensuring that jersey will use singletons from the orbit container. ServiceLocator locator = Injections.createLocator(); DynamicConfigurationService dcs = locator.getService(DynamicConfigurationService.class); DynamicConfiguration dc = dcs.createDynamicConfiguration(); final List<Class<?>> classes = new ArrayList<>(providers); if (container != null) { classes.addAll(container.getClasses()); for (final Class<?> c : container.getClasses()) { if (c.isAnnotationPresent(Singleton.class)) { Injections.addBinding( Injections.newFactoryBinder( new Factory() { @Override public Object provide() { return container.get(c); } @Override public void dispose(final Object instance) {} }) .to(c), dc); } } } dc.commit(); final ResourceConfig resourceConfig = new ResourceConfig(); // installing jax-rs classes known by the orbit container. for (final Class c : classes) { if (c.isAnnotationPresent(javax.ws.rs.Path.class) || c.isAnnotationPresent(javax.ws.rs.ext.Provider.class)) { resourceConfig.register(c); } } final WebAppContext webAppContext = new WebAppContext(); final ProtectionDomain protectionDomain = EmbeddedHttpServer.class.getProtectionDomain(); final URL location = protectionDomain.getCodeSource().getLocation(); logger.info(location.toExternalForm()); webAppContext.setInitParameter("useFileMappedBuffer", "false"); webAppContext.setWar(location.toExternalForm()); // this sets the default service locator to one that bridges to the orbit container. webAppContext.getServletContext().setAttribute(ServletProperties.SERVICE_LOCATOR, locator); webAppContext.setContextPath("/*"); webAppContext.addServlet(new ServletHolder(new ServletContainer(resourceConfig)), "/*"); final ContextHandler resourceContext = new ContextHandler(); ResourceHandler resourceHandler = new ResourceHandler(); resourceHandler.setDirectoriesListed(true); resourceHandler.setWelcomeFiles(new String[] {"index.html"}); resourceHandler.setBaseResource(Resource.newClassPathResource("/web")); resourceContext.setHandler(resourceHandler); resourceContext.setInitParameter("useFileMappedBuffer", "false"); final ContextHandlerCollection contexts = new ContextHandlerCollection(); contexts.setHandlers( new Handler[] { wrapHandlerWithMetrics(resourceContext, "resourceContext"), wrapHandlerWithMetrics(webAppContext, "webAppContext") }); server = new Server(port); server.setHandler(contexts); try { /// Initialize javax.websocket layer final ServerContainer serverContainer = WebSocketServerContainerInitializer.configureContext(webAppContext); for (Class c : classes) { if (c.isAnnotationPresent(ServerEndpoint.class)) { final ServerEndpoint annotation = (ServerEndpoint) c.getAnnotation(ServerEndpoint.class); final ServerEndpointConfig serverEndpointConfig = ServerEndpointConfig.Builder.create(c, annotation.value()) .configurator( new ServerEndpointConfig.Configurator() { @Override public <T> T getEndpointInstance(final Class<T> endpointClass) throws InstantiationException { return container.get(endpointClass); } }) .build(); serverContainer.addEndpoint(serverEndpointConfig); } } } catch (Exception e) { logger.error("Error starting jetty", e); throw new UncheckedException(e); } try { server.start(); } catch (Exception e) { logger.error("Error starting jetty", e); throw new UncheckedException(e); } return Task.done(); }