/**
   * Set up the execution classpath for Jasper.
   *
   * <p>Put everything in the classesDirectory and all of the dependencies on the classpath.
   *
   * @returns a list of the urls of the dependencies
   * @throws Exception
   */
  private List<URL> setUpWebAppClassPath() throws Exception {
    // add any classes from the webapp
    List<URL> urls = new ArrayList<URL>();
    String classesDir = classesDirectory.getCanonicalPath();
    classesDir = classesDir + (classesDir.endsWith(File.pathSeparator) ? "" : File.separator);
    urls.add(Resource.toURL(new File(classesDir)));

    if (getLog().isDebugEnabled()) getLog().debug("Adding to classpath classes dir: " + classesDir);

    // add the dependencies of the webapp (which will form WEB-INF/lib)
    for (Iterator<Artifact> iter = project.getArtifacts().iterator(); iter.hasNext(); ) {
      Artifact artifact = (Artifact) iter.next();

      // Include runtime and compile time libraries
      if (!Artifact.SCOPE_TEST.equals(artifact.getScope())
          && !Artifact.SCOPE_PROVIDED.equals(artifact.getScope())) {
        String filePath = artifact.getFile().getCanonicalPath();
        if (getLog().isDebugEnabled())
          getLog().debug("Adding to classpath dependency file: " + filePath);

        urls.add(Resource.toURL(artifact.getFile()));
      }
    }
    return urls;
  }
  /**
   * Look for jars in WEB-INF/lib
   *
   * @param context
   * @return the list of jar resources found within context
   * @throws Exception
   */
  protected List<Resource> findJars(WebAppContext context) throws Exception {
    List<Resource> jarResources = new ArrayList<Resource>();

    Resource web_inf = context.getWebInf();
    if (web_inf == null || !web_inf.exists()) return null;

    Resource web_inf_lib = web_inf.addPath("/lib");

    if (web_inf_lib.exists() && web_inf_lib.isDirectory()) {
      String[] files = web_inf_lib.list();
      for (int f = 0; files != null && f < files.length; f++) {
        try {
          Resource file = web_inf_lib.addPath(files[f]);
          String fnlc = file.getName().toLowerCase(Locale.ENGLISH);
          int dot = fnlc.lastIndexOf('.');
          String extension = (dot < 0 ? null : fnlc.substring(dot));
          if (extension != null && (extension.equals(".jar") || extension.equals(".zip"))) {
            jarResources.add(file);
          }
        } catch (Exception ex) {
          LOG.warn(Log.EXCEPTION, ex);
        }
      }
    }
    return jarResources;
  }
  /**
   * Parse a single entry in a jar file
   *
   * @param jar
   * @param entry
   * @param resolver
   * @throws Exception
   */
  protected void parseJarEntry(URI jar, JarEntry entry, final ClassNameResolver resolver)
      throws Exception {
    if (jar == null || entry == null) return;

    // skip directories
    if (entry.isDirectory()) return;

    String name = entry.getName();

    // check file is a valid class file name
    if (isValidClassFileName(name) && isValidClassFilePath(name)) {
      String shortName = name.replace('/', '.').substring(0, name.length() - 6);

      if ((resolver == null)
          || (!resolver.isExcluded(shortName)
              && (!isParsed(shortName) || resolver.shouldOverride(shortName)))) {
        Resource clazz = Resource.newResource("jar:" + jar + "!/" + name);
        if (LOG.isDebugEnabled()) {
          LOG.debug("Scanning class from jar {}", clazz);
        }
        ;
        scanClass(clazz.getInputStream());
      }
    }
  }
Exemple #4
0
  /* ------------------------------------------------------------ */
  private HttpContent load(String pathInContext, Resource resource) throws IOException {
    Content content = null;

    if (resource == null || !resource.exists()) return null;

    // Will it fit in the cache?
    if (!resource.isDirectory() && isCacheable(resource)) {
      // Create the Content (to increment the cache sizes before adding the content
      content = new Content(pathInContext, resource);

      // reduce the cache to an acceptable size.
      shrinkCache();

      // Add it to the cache.
      Content added = _cache.putIfAbsent(pathInContext, content);
      if (added != null) {
        content.invalidate();
        content = added;
      }

      return content;
    }

    return new HttpContent.ResourceAsHttpContent(
        resource,
        _mimeTypes.getMimeByExtension(resource.toString()),
        getMaxCachedFileSize(),
        _etags);
  }
  /**
   * Parse a resource that is a jar file.
   *
   * @param jarResource
   * @param resolver
   * @throws Exception
   */
  public void parseJar(Resource jarResource, final ClassNameResolver resolver) throws Exception {
    if (jarResource == null) return;

    URI uri = jarResource.getURI();
    if (jarResource.toString().endsWith(".jar")) {
      if (LOG.isDebugEnabled()) {
        LOG.debug("Scanning jar {}", jarResource);
      }
      ;

      // treat it as a jar that we need to open and scan all entries from
      InputStream in = jarResource.getInputStream();
      if (in == null) return;

      JarInputStream jar_in = new JarInputStream(in);
      try {
        JarEntry entry = jar_in.getNextJarEntry();
        while (entry != null) {
          parseJarEntry(uri, entry, resolver);
          entry = jar_in.getNextJarEntry();
        }
      } finally {
        jar_in.close();
      }
    }
  }
 @Before
 public void setUp() throws Exception {
   Resource configRes =
       Resource.newClassPathResource("/org/eclipse/jetty/monitor/jetty-monitor-service.xml");
   XmlConfiguration xmlConfig = new XmlConfiguration(configRes.getURL());
   xmlConfig.configure();
 }
  /**
   * Check to see if the ServletContainerIntializer loaded via the ServiceLoader came from a jar
   * that is excluded by the fragment ordering. See ServletSpec 3.0 p.85.
   *
   * @param context
   * @param sci
   * @return true if excluded
   */
  public boolean isFromExcludedJar(
      WebAppContext context, ServletContainerInitializer sci, Resource sciResource)
      throws Exception {
    if (sci == null) throw new IllegalArgumentException("ServletContainerInitializer null");
    if (context == null) throw new IllegalArgumentException("WebAppContext null");

    if (LOG.isDebugEnabled()) LOG.debug("Checking {} for jar exclusion", sci);

    // A ServletContainerInitializer that came from the container's classpath cannot be excluded by
    // an ordering
    // of WEB-INF/lib jars
    if (isFromContainerClassPath(context, sci)) return false;

    List<Resource> orderedJars = context.getMetaData().getOrderedWebInfJars();

    // If no ordering, nothing is excluded
    if (context.getMetaData().getOrdering() == null) return false;

    // there is an ordering, but there are no jars resulting from the ordering, everything excluded
    if (orderedJars.isEmpty()) return true;

    if (sciResource == null)
      return false; // not from a jar therefore not from WEB-INF so not excludable

    URI loadingJarURI = sciResource.getURI();
    boolean found = false;
    Iterator<Resource> itor = orderedJars.iterator();
    while (!found && itor.hasNext()) {
      Resource r = itor.next();
      found = r.getURI().equals(loadingJarURI);
    }

    return !found;
  }
  public void doStart() {
    try {
      TaskLog.logWithTimestamp("Starting web application " + this.getDescriptor());
      if (jettyEnvXml != null && jettyEnvXml.exists())
        envConfiguration.setJettyEnvXml(Resource.toURL(jettyEnvXml));

      ClassLoader parentLoader = this.getClass().getClassLoader();
      if (parentLoader instanceof AntClassLoader)
        parentLoader = new AntURLClassLoader((AntClassLoader) parentLoader);

      setClassLoader(new WebAppClassLoader(parentLoader, this));
      if (attributes != null && attributes.getAttributes() != null) {
        for (Attribute a : attributes.getAttributes()) setAttribute(a.getName(), a.getValue());
      }

      // apply a context xml file if one was supplied
      if (contextXml != null) {
        XmlConfiguration xmlConfiguration = new XmlConfiguration(Resource.toURL(contextXml));
        TaskLog.log("Applying context xml file " + contextXml);
        xmlConfiguration.configure(this);
      }

      super.doStart();
    } catch (Exception e) {
      TaskLog.log(e.toString());
    }
  }
 @Override
 public Resource getJarFor(ServletContainerInitializer service)
     throws MalformedURLException, IOException {
   Resource resource = super.getJarFor(service);
   // TODO This is not correct, but implemented like this to be bug for bug compatible
   // with previous implementation that could only handle actual jars and not bundles.
   if (resource != null && !resource.toString().endsWith(".jar")) return null;
   return resource;
 }
 public File findWorkDirectory(WebAppContext context) throws IOException {
   if (context.getBaseResource() != null) {
     Resource web_inf = context.getWebInf();
     if (web_inf != null && web_inf.exists()) {
       return new File(web_inf.getFile(), "work");
     }
   }
   return null;
 }
Exemple #11
0
    /* ------------------------------------------------------------ */
    boolean isValid() {
      if (_lastModified == _resource.lastModified() && _length == _resource.length()) {
        _lastAccessed = System.currentTimeMillis();
        return true;
      }

      if (this == _cache.remove(_key)) invalidate();
      return false;
    }
Exemple #12
0
 /* ------------------------------------------------------------ */
 @Override
 public String toString() {
   return String.format(
       "%s %s %d %s %s",
       _resource,
       _resource.exists(),
       _resource.lastModified(),
       _contentType,
       _lastModifiedBytes);
 }
Exemple #13
0
  /**
   * Get the resource list as a HTML directory listing.
   *
   * @param base The base URL
   * @param parent True if the parent directory should be included
   * @return String of HTML
   */
  public String getListHTML(String base, boolean parent) throws IOException {
    base = URIUtil.canonicalPath(base);
    if (base == null || !isDirectory()) return null;

    String[] ls = list();
    if (ls == null) return null;
    Arrays.sort(ls);

    String decodedBase = URIUtil.decodePath(base);
    String title = "Directory: " + deTag(decodedBase);

    StringBuilder buf = new StringBuilder(4096);
    buf.append("<HTML><HEAD>");
    buf.append("<LINK HREF=\"")
        .append("jetty-dir.css")
        .append("\" REL=\"stylesheet\" TYPE=\"text/css\"/><TITLE>");
    buf.append(title);
    buf.append("</TITLE></HEAD><BODY>\n<H1>");
    buf.append(title);
    buf.append("</H1>\n<TABLE BORDER=0>\n");

    if (parent) {
      buf.append("<TR><TD><A HREF=\"");
      buf.append(URIUtil.addPaths(base, "../"));
      buf.append("\">Parent Directory</A></TD><TD></TD><TD></TD></TR>\n");
    }

    String encodedBase = hrefEncodeURI(base);

    DateFormat dfmt = DateFormat.getDateTimeInstance(DateFormat.MEDIUM, DateFormat.MEDIUM);
    for (int i = 0; i < ls.length; i++) {
      Resource item = addPath(ls[i]);

      buf.append("\n<TR><TD><A HREF=\"");
      String path = URIUtil.addPaths(encodedBase, URIUtil.encodePath(ls[i]));

      buf.append(path);

      if (item.isDirectory() && !path.endsWith("/")) buf.append(URIUtil.SLASH);

      // URIUtil.encodePath(buf,path);
      buf.append("\">");
      buf.append(deTag(ls[i]));
      buf.append("&nbsp;");
      buf.append("</A></TD><TD ALIGN=right>");
      buf.append(item.length());
      buf.append(" bytes&nbsp;</TD><TD>");
      buf.append(dfmt.format(new Date(item.lastModified())));
      buf.append("</TD></TR>");
    }
    buf.append("</TABLE>\n");
    buf.append("</BODY></HTML>\n");

    return buf.toString();
  }
Exemple #14
0
  /**
   * Start Jetty web server
   *
   * @param version of bigloupe-chart
   * @return
   * @throws Exception
   */
  private Server startWebServer(String version) throws Exception {
    if (!cmd.hasOption(OPTION_NO_WEBSERVER)) {

      applyOptionWithWebServer();

      Server server = new Server(getPortWebServer());

      WebAppContext root = new WebAppContext();
      root.setContextPath("/");

      if (cmd.hasOption(OPTION_WEBSERVER_WEBROOT)) {
        String webRoot = cmd.getOptionValue(OPTION_WEBSERVER_WEBROOT);
        Resource resource = FileResource.newResource(webRoot);
        root.setBaseResource(resource);

      } else {
        String webFiles = "bigloupe-chart-" + version + "-webapp.war";
        File fileWebApp = new File(webFiles);
        if (!fileWebApp.exists()) {
          if (version.equals("'undefined'")) {
            Resource resource = FileResource.newResource("src/main/webapp");
            root.setBaseResource(resource);
            root.setDefaultsDescriptor("./etc/webdefault.xml");
            logger.info(
                "Embedded webServer started with base resource "
                    + resource.getFile().getAbsolutePath());
          } else {
            logger.info(webFiles + " file not available");
            logger.info("Embedded webServer will be not started");
            return null;
          }
        } else {
          root.setWar(fileWebApp.getAbsolutePath());
        }
      }

      File tmp = new File("tmp");
      if (!tmp.exists()) tmp.mkdir();
      root.setTempDirectory(tmp);

      ContextHandlerCollection contexts = new ContextHandlerCollection();
      Handler handlerHawtIO = addWebApplicationHawtIO();
      if (handlerHawtIO != null) contexts.setHandlers(new Handler[] {root, handlerHawtIO});
      else contexts.setHandlers(new Handler[] {root});
      server.setHandler(contexts);

      server.start();
      addWebServerJMXSupport(server);
      return server;
    } else {
      applyOptionWithoutWebServer();
      return null;
    }
  }
 /**
  * Overriden method which, contrary to the original implementation in the parent class, add
  * directly the web-fragment.xml resource to the MetaData, instead of re-creating it with a forced
  * jar prefix.
  */
 @Override
 @SuppressWarnings("unchecked")
 public void findWebFragments(final WebAppContext context, final MetaData metaData)
     throws Exception {
   List<Resource> frags = (List<Resource>) context.getAttribute(FRAGMENT_RESOURCES);
   if (frags != null) {
     for (Resource frag : frags) {
       Resource parentResource = Util.chop(frag.getURL(), "/META-INF/web-fragment.xml");
       metaData.addFragment(parentResource, frag);
     }
   }
 }
  @Test
  public void testStandardTestWar() throws Exception {
    PreconfigureStandardTestWar.main(new String[] {});

    WebDescriptor descriptor =
        new WebDescriptor(
            Resource.newResource(
                "./target/test-standard-preconfigured/WEB-INF/quickstart-web.xml"));
    descriptor.setValidating(true);
    descriptor.parse();
    Node node = descriptor.getRoot();
    assertThat(node, Matchers.notNullValue());

    System.setProperty("jetty.home", "target");

    // war file or dir to start
    String war = "target/test-standard-preconfigured";

    // optional jetty context xml file to configure the webapp
    Resource contextXml = Resource.newResource("src/test/resources/test.xml");

    Server server = new Server(0);

    QuickStartWebApp webapp = new QuickStartWebApp();
    webapp.setAutoPreconfigure(true);
    webapp.setWar(war);
    webapp.setContextPath("/");

    // apply context xml file
    if (contextXml != null) {
      // System.err.println("Applying "+contextXml);
      XmlConfiguration xmlConfiguration = new XmlConfiguration(contextXml.getURL());
      xmlConfiguration.configure(webapp);
    }

    server.setHandler(webapp);

    server.start();

    URL url =
        new URL(
            "http://127.0.0.1:"
                + server.getBean(NetworkConnector.class).getLocalPort()
                + "/test/dump/info");
    HttpURLConnection connection = (HttpURLConnection) url.openConnection();
    assertEquals(200, connection.getResponseCode());
    assertThat(
        IO.toString((InputStream) connection.getContent()),
        Matchers.containsString("Dump Servlet"));

    server.stop();
  }
 /**
  * Parse the given classes
  *
  * @param classNames
  * @param resolver
  * @throws Exception
  */
 public void parse(List<String> classNames, ClassNameResolver resolver) throws Exception {
   for (String s : classNames) {
     if ((resolver == null)
         || (!resolver.isExcluded(s) && (!isParsed(s) || resolver.shouldOverride(s)))) {
       s = s.replace('.', '/') + ".class";
       URL resource = Loader.getResource(this.getClass(), s, false);
       if (resource != null) {
         Resource r = Resource.newResource(resource);
         scanClass(r.getInputStream());
       }
     }
   }
 }
  /* ------------------------------------------------------------ */
  @Test
  public void testJarFileLastModified() throws Exception {
    String s = "jar:" + __userURL + "TestData/test.zip!/subdir/numbers";
    ZipFile zf =
        new ZipFile(
            MavenTestingUtils.getProjectFile(
                "src/test/resources/org/eclipse/jetty/util/resource/TestData/test.zip"));

    long last = zf.getEntry("subdir/numbers").getTime();

    Resource r = Resource.newResource(s);
    assertEquals(last, r.lastModified());
  }
  /**
   * Parse a given class
   *
   * @param className
   * @param resolver
   * @throws Exception
   */
  public void parse(String className, ClassNameResolver resolver) throws Exception {
    if (className == null) return;

    if (!resolver.isExcluded(className)) {
      if (!isParsed(className) || resolver.shouldOverride(className)) {
        className = className.replace('.', '/') + ".class";
        URL resource = Loader.getResource(this.getClass(), className, false);
        if (resource != null) {
          Resource r = Resource.newResource(resource);
          scanClass(r.getInputStream());
        }
      }
    }
  }
  @Test
  public void testJarFileIsContainedIn() throws Exception {
    String s = "jar:" + __userURL + "TestData/test.zip!/subdir/";
    Resource r = Resource.newResource(s);
    Resource container = Resource.newResource(__userURL + "TestData/test.zip");

    assertTrue(r instanceof JarFileResource);
    JarFileResource jarFileResource = (JarFileResource) r;

    assertTrue(jarFileResource.isContainedIn(container));

    container = Resource.newResource(__userURL + "TestData");
    assertFalse(jarFileResource.isContainedIn(container));
  }
  /** Test a class path resource for existence. */
  @Test
  public void testClassPathResourceClassAbsolute() {
    final String classPathName = "/org/eclipse/jetty/util/resource/Resource.class";

    Resource resource = Resource.newClassPathResource(classPathName);

    assertTrue(resource != null);

    // A class path cannot be a directory
    assertFalse("Class path cannot be a directory.", resource.isDirectory());

    // A class path must exist
    assertTrue("Class path resource does not exist.", resource.exists());
  }
  /** Test a class path resource for existence. */
  @Test
  public void testClassPathResourceClassRelative() {
    final String classPathName = "Resource.class";

    Resource resource = Resource.newClassPathResource(classPathName);

    assertTrue(resource != null);

    // A class path cannot be a directory
    assertFalse("Class path cannot be a directory.", resource.isDirectory());

    // A class path must exist
    assertTrue("Class path resource does not exist.", resource.exists());
  }
    protected void applyMetaInfContextXml(Resource rootResource) throws Exception {
      if (_bundle == null) return;
      if (_webApp == null) return;

      ClassLoader cl = Thread.currentThread().getContextClassLoader();
      LOG.debug("Context classloader = " + cl);
      try {

        Thread.currentThread().setContextClassLoader(_webApp.getClassLoader());

        // TODO replace this with getting the InputStream so we don't cache in URL
        // find if there is a META-INF/context.xml file
        URL contextXmlUrl = _bundle.getEntry("/META-INF/jetty-webapp-context.xml");
        if (contextXmlUrl == null) return;

        // Apply it just as the standard jetty ContextProvider would do
        LOG.info("Applying " + contextXmlUrl + " to " + _webApp);

        XmlConfiguration xmlConfiguration = new XmlConfiguration(contextXmlUrl);
        HashMap properties = new HashMap();
        properties.put("Server", getDeploymentManager().getServer());
        properties.put(OSGiWebappConstants.JETTY_BUNDLE_ROOT, rootResource.toString());
        properties.put(
            OSGiServerConstants.JETTY_HOME,
            getDeploymentManager().getServer().getAttribute(OSGiServerConstants.JETTY_HOME));
        xmlConfiguration.getProperties().putAll(properties);
        xmlConfiguration.configure(_webApp);
      } finally {
        Thread.currentThread().setContextClassLoader(cl);
      }
    }
Exemple #24
0
 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;
 }
Exemple #25
0
    /* ------------------------------------------------------------ */
    public InputStream getInputStream() throws IOException {
      Buffer indirect = getIndirectBuffer();
      if (indirect != null && indirect.array() != null)
        return new ByteArrayInputStream(indirect.array(), indirect.getIndex(), indirect.length());

      return _resource.getInputStream();
    }
  /** Test a class path resource for directories. */
  @Test
  public void testClassPathResourceDirectory() throws Exception {
    final String classPathName = "/";

    Resource resource = Resource.newClassPathResource(classPathName);

    assertTrue(resource != null);

    // A class path must be a directory
    assertTrue("Class path must be a directory.", resource.isDirectory());

    assertTrue("Class path returned file must be a directory.", resource.getFile().isDirectory());

    // A class path must exist
    assertTrue("Class path resource does not exist.", resource.exists());
  }
  private void addDependencies(final MavenProject project, final JettyWebAppContext webAppConfig)
      throws Exception {
    List<File> dependencyFiles = new ArrayList<File>();
    List<Resource> overlays = new ArrayList<Resource>();

    for (Artifact artifact : project.getArtifacts()) {
      if (artifact.getType().equals("war")) {
        overlays.add(Resource.newResource("jar:" + artifact.getFile().toURL().toString() + "!/"));
      } else if ((!Artifact.SCOPE_PROVIDED.equals(artifact.getScope()))
          && (!Artifact.SCOPE_TEST.equals(artifact.getScope()))) {
        File dependencyFile = artifact.getFile();

        if (dependencyFile == null || !dependencyFile.exists()) {
          String coordinates =
              String.format(
                  "%s:%s:%s",
                  artifact.getGroupId(), artifact.getArtifactId(), artifact.getVersion());

          LOG.log(
              Level.WARNING,
              "Dependency '" + coordinates + "' does not exist in repository. Skipping!");
          continue;
        }

        dependencyFiles.add(artifact.getFile());
      }
    }

    webAppConfig.setOverlays(overlays);
    webAppConfig.setWebInfLib(dependencyFiles);
  }
  /* ------------------------------------------------------------ */
  protected ByteBuffer getDirectBuffer(Resource resource) {
    // Only use file mapped buffers for cached resources, otherwise too much virtual memory
    // commitment for
    // a non shared resource.  Also ignore max buffer size
    try {
      if (_useFileMappedBuffer
          && resource.getFile() != null
          && resource.length() < Integer.MAX_VALUE)
        return BufferUtil.toMappedBuffer(resource.getFile());

      return BufferUtil.toBuffer(resource, true);
    } catch (IOException | IllegalArgumentException e) {
      LOG.warn(e);
      return null;
    }
  }
 Data(String url, boolean exists, boolean dir, String content) throws Exception {
   this.test = url;
   this.exists = exists;
   this.dir = dir;
   this.content = content;
   resource = Resource.newResource(url);
 }
Exemple #30
0
  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();
  }