How to use

WebServer

in

org.h2.server.web

@Override
public void init() {
  ServletConfig config = getServletConfig();
  Enumeration<?> en = config.getInitParameterNames();
  ArrayList<String> list = New.arrayList();
  while (en.hasMoreElements()) {
    String name = en.nextElement().toString();
    String value = config.getInitParameter(name);
    if (!name.startsWith("-")) {
      name = "-" + name;
    }
    list.add(name);
    if (value.length() > 0) {
      list.add(value);
    }
  }
  String[] args = list.toArray(new String[0]);
  server = new WebServer();
  server.setAllowChunked(false);
  server.init(args);
}

String sessionId = attributes.getProperty("jsessionid");
if (sessionId != null) {
  session = server.getSession(sessionId);
boolean cache = app.getCache();
if (cache && server.getStartDateTime().equals(ifModifiedSince)) {
  resp.setStatus(HttpServletResponse.SC_NOT_MODIFIED);
  return;
byte[] bytes = server.getFile(file);
if (bytes == null) {
  resp.sendError(HttpServletResponse.SC_NOT_FOUND);
  } else {
    resp.setHeader("Cache-Control", "max-age=10");
    resp.setHeader("Last-Modified", server.getStartDateTime());

WebServer webServer = new WebServer();
String[] args;
if (ignoreProperties) {
Server server = new Server();
server.web = web;
webServer.setShutdownHandler(server);
String url = webServer.addSession(conn);
try {
  Server.openBrowser(url);
  while (!webServer.isStopped()) {
    Thread.sleep(1000);

private boolean allow() {
  if (server.getAllowOthers()) {
    return true;
  }
  try {
    return NetUtils.isLocalAddress(socket);
  } catch (UnknownHostException e) {
    server.traceError(e);
    return false;
  }
}

/**
 * Create a new web server, but does not start it yet. Example:
 *
 * <pre>
 * Server server = Server.createWebServer("-trace").start();
 * </pre>
 * Supported options are:
 * -webPort, -webSSL, -webAllowOthers, -webDaemon,
 * -trace, -ifExists, -baseDir, -properties.
 * See the main method for details.
 *
 * @param args the argument list
 * @return the server
 */
public static Server createWebServer(String... args) throws SQLException {
  WebServer service = new WebServer();
  Server server = new Server(service, args);
  service.setShutdownHandler(server);
  return server;
}

private String admin() {
  session.put("port", "" + server.getPort());
  session.put("allowOthers", "" + server.getAllowOthers());
  session.put("ssl", String.valueOf(server.getSSL()));
  session.put("sessions", server.getSessions());
  return "admin.jsp";
}

int begin = head.indexOf('/'), end = head.lastIndexOf(' ');
String file = head.substring(begin + 1, end).trim();
server.trace(head + ": " + file);
file = getAllowedFile(file);
attributes = new Properties();
  String sessionId = attributes.getProperty("jsessionid");
  file = file.substring(0, paramIndex);
  session = server.getSession(sessionId);
if (cache && ifModifiedSince != null && ifModifiedSince.equals(server.getStartDateTime())) {
  bytes = null;
  message = "HTTP/1.1 304 Not Modified\n";
} else {
  bytes = server.getFile(file);
  if (bytes == null) {
    message = "HTTP/1.0 404 Not Found\n";
        bytes = StringUtils.utf8Encode(page);
      } catch (SQLException e) {
        server.traceError(e);
    } else {
      message += "Cache-Control: max-age=10\n";
      message += "Last-Modified: " + server.getStartDateTime() + "\n";
server.trace(message);
output.write(message.getBytes());
if (bytes != null) {

/**
 * Create a new web session id and object.
 *
 * @param hostAddr the host address
 * @return the web session object
 */
WebSession createNewSession(String hostAddr) {
  String newId;
  do {
    newId = generateSessionId();
  } while (sessions.get(newId) != null);
  WebSession session = new WebSession(this);
  session.lastAccess = System.currentTimeMillis();
  session.put("sessionId", newId);
  session.put("ip", hostAddr);
  session.put("language", DEFAULT_LANGUAGE);
  session.put("frame-border", "0");
  session.put("frameset-border", "4");
  sessions.put(newId, session);
  // always read the english translation,
  // so that untranslated text appears at least in english
  readTranslations(session, DEFAULT_LANGUAGE);
  return getSession(newId);
}

private String adminSave() {
  try {
    Properties prop = new SortedProperties();
    int port = Integer.decode((String) attributes.get("port"));
    prop.setProperty("webPort", String.valueOf(port));
    server.setPort(port);
    boolean allowOthers = Utils.parseBoolean((String) attributes.get("allowOthers"), false, false);
    prop.setProperty("webAllowOthers", String.valueOf(allowOthers));
    server.setAllowOthers(allowOthers);
    boolean ssl = Utils.parseBoolean((String) attributes.get("ssl"), false, false);
    prop.setProperty("webSSL", String.valueOf(ssl));
    server.setSSL(ssl);
    server.saveProperties(prop);
  } catch (Exception e) {
    trace(e.toString());
  }
  return admin();
}

private String adminSave() {
  try {
    server.setPort(MathUtils.decodeInt((String) attributes.get("port")));
    server.setAllowOthers(Boolean.valueOf((String) attributes.get("allowOthers")).booleanValue());
    server.setSSL(Boolean.valueOf((String) attributes.get("ssl")).booleanValue());
    server.saveSettings();
  } catch (Exception e) {
    server.trace(e.toString());
  }
  return admin();
}

public HackedWebServer(String[] args, HackedWebServlet servlet)
{
  //without this response won't be written back
  super.setAllowChunked(false);
  super.setAllowOthers(true);
  super.init(args);
  //if there was ever h2 installation then servlet will try to init defaults again
  super.setAllowChunked(false);
  super.setAllowOthers(true);
  
  this.servlet = servlet;
  //create single session which will be maintained through plugin lifecycle
  this.session = this.createNewSession("local");
}

/**
 * Start debug console if needed.
 *
 * @throws IgniteCheckedException If failed.
 */
private void startDebugConsole() throws IgniteCheckedException {
  try {
    if (getString(IGNITE_H2_DEBUG_CONSOLE) != null) {
      Connection c = DriverManager.getConnection(dbUrl);
      int port = getInteger(IGNITE_H2_DEBUG_CONSOLE_PORT, 0);
      WebServer webSrv = new WebServer();
      Server web = new Server(webSrv, "-webPort", Integer.toString(port));
      web.start();
      String url = webSrv.addSession(c);
      U.quietAndInfo(log, "H2 debug console URL: " + url);
      try {
        Server.openBrowser(url);
      }
      catch (Exception e) {
        U.warn(log, "Failed to open browser: " + e.getMessage());
      }
    }
  }
  catch (SQLException e) {
    throw new IgniteCheckedException(e);
  }
}

/**
 * Read the translation for this language and save them in the 'text'
 * property of this session.
 *
 * @param session the session
 * @param language the language
 */
void readTranslations(WebSession session, String language) {
  Properties text = new Properties();
  try {
    trace("translation: "+language);
    byte[] trans = getFile("_text_"+language+".prop");
    trace("  "+new String(trans));
    text = SortedProperties.fromLines(new String(trans, StandardCharsets.UTF_8));
    // remove starting # (if not translated yet)
    for (Entry<Object, Object> entry : text.entrySet()) {
      String value = (String) entry.getValue();
      if (value.startsWith("#")) {
        entry.setValue(value.substring(1));
      }
    }
  } catch (IOException e) {
    DbException.traceThrowable(e);
  }
  session.put("text", new HashMap<>(text));
}

public void init() throws ServletException {
  ServletConfig config = getServletConfig();
  Enumeration en = config.getInitParameterNames();
  ArrayList list = new ArrayList();
  while (en.hasMoreElements()) {
    String name = en.nextElement().toString();
    String value = config.getInitParameter(name);
    if (!name.startsWith("-")) {
      name = "-" + name;
    }
    list.add(name);
    if (value.length() > 0) {
      list.add(value);
    }
  }
  String[] args = new String[list.size()];
  list.toArray(args);
  server = new WebServer();
  try {
    server.init(args);
  } catch (Exception e) {
    throw new ServletException("Init failed", e);
  }
}

if (SysProperties.CONSOLE_STREAM && server.getAllowChunked()) {
  String page = new String(server.getFile("result.jsp"), StandardCharsets.UTF_8);
  int idx = page.indexOf("${result}");

private boolean allow(HttpServletRequest req) {
  if (server.getAllowOthers()) {
    return true;
  }
  String addr = req.getRemoteAddr();
  try {
    InetAddress address = InetAddress.getByName(addr);
    return address.isLoopbackAddress();
  } catch (UnknownHostException e) {
    return false;
  } catch (NoClassDefFoundError e) {
    // Google App Engine does not allow java.net.InetAddress
    return false;
  }
}

 includeOnce('./bin/WebServer.js');

function Lara() {
 this.webServer = new WebServer();
 this.webServer.start();
}

Lara.prototype.webServer = null;

module.exports.Lara = Lara;

/**
 * Create a session with a given connection.
 *
 * @param conn the connection
 * @return the URL of the web site to access this connection
 */
public String addSession(Connection conn) throws SQLException {
  WebSession session = createNewSession("local");
  session.setShutdownServerOnDisconnect();
  session.setConnection(conn);
  session.put("url", conn.getMetaData().getURL());
  String s = (String) session.get("sessionId");
  return url + "/frame.jsp?jsessionid=" + s;
}

  mimeType = "text/html";
  if (session == null) {
    session = server.createNewSession(hostAddr);
    if (!"notAllowed.jsp".equals(file)) {
      file = "index.do";
  mimeType = "text/html";
  file = "error.jsp";
  server.trace("unknown mime type, file " + file);
server.trace("mimeType=" + mimeType);
server.trace(file);
if (file.endsWith(".do")) {
  file = process(file);

  @Override
  public WebSession getSession(String s)
  {
    //#getSession is called as part of #createNewSession, it's just hackaround to ignore first time invocation
    if (this.session == null)
    {
      this.session = super.getSession(s);
    }

    // if setter is used then BNF will be reset and autocomplete won't work
    HackedWebServlet.inject(this.session.getClass(), this.session, "conn", servlet.getConnection());
    HackedWebServlet.inject(this.session.getClass(), this.session, "meta", servlet.getConnectionMetaData());

    return this.session;
  }
}