public void startServer(String host, int port) throws Exception {
info("starting Jetty server on " + host + ":" + port);
/*
* do all preparatory chores before starting the server
*/
Thinkcap.get().setBaseUrl("http://" + host + ":" + port);
if (server != null) throw new ThinkcapException("thinkcap server is already active");
server = new Server();
SelectChannelConnector connector = new SelectChannelConnector();
connector.setHost(host);
connector.setPort(port);
server.setConnectors(new Connector[] {connector});
WebAppContext wah = new WebAppContext();
wah.setContextPath("/");
wah.setWar(Thinkcap.get().getWebSpace().toString());
ClassLoader cl = this.getClass().getClassLoader();
WebAppClassLoader wacl = new WebAppClassLoader(cl, wah);
wah.setClassLoader(wacl);
server.addHandler(wah);
server.setStopAtShutdown(true);
server.start();
server.join();
}
/**
* Starts the Jetty server at a specified port.
*
* @param portno Port number.
* @throws Exception When an error occurs.
*/
private void startServer(int portno) throws Exception {
port = portno;
SelectChannelConnector connector1 = new SelectChannelConnector();
connector1.setHost("127.0.0.1");
connector1.setPort(port);
server.addConnector(connector1);
server.start();
}
/**
* Starts the Jetty server at a specified port and redirection parameter.
*
* @param portno Port number.
* @param redirection whether redirection
*/
private void startServer(int portno, boolean redirection) throws Exception {
port = portno;
setUp(redirection);
SelectChannelConnector connector = new SelectChannelConnector();
connector.setHost("127.0.0.1");
connector.setPort(port);
server.addConnector(connector);
server.start();
}
/** Run couchdb-lucene. */
public static void main(String[] args) throws Exception {
final HierarchicalINIConfiguration configuration =
new HierarchicalINIConfiguration(
Main.class.getClassLoader().getResource("couchdb-lucene.ini"));
configuration.setReloadingStrategy(new FileChangedReloadingStrategy());
final File dir = new File(configuration.getString("lucene.dir", "indexes"));
if (dir == null) {
LOG.error("lucene.dir not set.");
System.exit(1);
}
if (!dir.exists() && !dir.mkdir()) {
LOG.error("Could not create " + dir.getCanonicalPath());
System.exit(1);
}
if (!dir.canRead()) {
LOG.error(dir + " is not readable.");
System.exit(1);
}
if (!dir.canWrite()) {
LOG.error(dir + " is not writable.");
System.exit(1);
}
LOG.info("Index output goes to: " + dir.getCanonicalPath());
final Server server = new Server();
final SelectChannelConnector connector = new SelectChannelConnector();
connector.setHost(configuration.getString("lucene.host", "localhost"));
connector.setPort(configuration.getInt("lucene.port", 5985));
LOG.info("Accepting connections with " + connector);
server.setConnectors(new Connector[] {connector});
server.setStopAtShutdown(true);
server.setSendServerVersion(false);
HttpClientFactory.setIni(configuration);
final HttpClient httpClient = HttpClientFactory.getInstance();
final LuceneServlet servlet = new LuceneServlet(httpClient, dir, configuration);
final Context context = new Context(server, "/", Context.NO_SESSIONS | Context.NO_SECURITY);
context.addServlet(new ServletHolder(servlet), "/*");
context.addFilter(new FilterHolder(new GzipFilter()), "/*", Handler.DEFAULT);
context.setErrorHandler(new JSONErrorHandler());
server.setHandler(context);
server.start();
server.join();
}
@Override
public void bind(InetSocketAddress addr, int backlog) throws IOException {
if (_started) throw new BindException("Already started");
// check if there is already a connector listening
Connector[] connectors = _server.getConnectors();
if (connectors != null) throw new BindException("Server already bound");
this._addr = addr;
if (_executor != null && _server.getThreadPool() == null) {
if (Log.isDebugEnabled()) Log.debug("using given Executor for server thread pool");
_server.setThreadPool(new ThreadPoolExecutorAdapter(_executor));
}
SelectChannelConnector connector = new SelectChannelConnector();
connector.setAcceptors(1);
connector.setAcceptQueueSize(backlog);
connector.setPort(addr.getPort());
connector.setHost(addr.getHostName());
_server.addConnector(connector);
}
/**
* Method to start the Jetty server
*
* @param jobDataMap
*/
private void startServer(JobDataMap jobDataMap) {
if (LOG.isDebugEnabled()) {
LOG.debug("Initialising HTTP server");
}
int port = Integer.parseInt(jobDataMap.getString("port"));
String bindAddress = jobDataMap.getString("bindAddress");
String authConfigFile = jobDataMap.getString("authConfigFile");
String keystore = jobDataMap.getString("keystore");
Server server = new Server();
if (keystore == null || keystore.equals("")) {
LOG.info("Starting with HTTP (non-encrypted) protocol");
SelectChannelConnector connector = new SelectChannelConnector();
connector.setHost(bindAddress);
connector.setPort(port);
server.addConnector(connector);
} else {
LOG.info("Starting with HTTPS (encrypted) protocol");
SslSocketConnector sslConnector = new SslSocketConnector();
sslConnector.setHost(bindAddress);
sslConnector.setPort(port);
sslConnector.setKeystore(jobDataMap.getString("keystore"));
sslConnector.setKeyPassword(jobDataMap.getString("keyPassword"));
sslConnector.setTruststore(jobDataMap.getString("trustStore"));
sslConnector.setTrustPassword(jobDataMap.getString("trustPassword"));
sslConnector.setPassword(jobDataMap.getString("password"));
server.addConnector(sslConnector);
}
if (authConfigFile != null && !(authConfigFile.equals(""))) {
if (LOG.isDebugEnabled()) {
LOG.debug("Requiring basic auth");
}
Constraint constraint = new Constraint();
constraint.setName(Constraint.__BASIC_AUTH);
;
constraint.setRoles(new String[] {"user", "grouper"});
constraint.setAuthenticate(true);
ConstraintMapping cm = new ConstraintMapping();
cm.setConstraint(constraint);
cm.setPathSpec("/*");
SecurityHandler sh = new SecurityHandler();
try {
sh.setUserRealm(new HashUserRealm("Grouper", authConfigFile));
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
sh.setConstraintMappings(new ConstraintMapping[] {cm});
Handler[] handlers = new Handler[] {sh, new EsbHttpHandler()};
server.setHandlers(handlers);
} else {
if (LOG.isDebugEnabled()) {
LOG.debug("Not requiring basic auth");
}
server.setHandler(new EsbHttpHandler());
}
try {
server.start();
LOG.info("HTTP server started on address " + bindAddress + " port " + port);
server.join();
} catch (Exception e) {
e.printStackTrace();
}
}
private void deployWebApp() {
try {
Server server = new Server();
SelectChannelConnector connector = new SelectChannelConnector();
connector.setMaxIdleTime(MAX_IDLE_TIME_MILLIS);
connector.setHeaderBufferSize(HEADER_BUFFER_SIZE);
connector.setHost(getHost());
connector.setPort(getPort());
if (isHttpsEnabled()) {
connector.setConfidentialPort(getHttpsPort());
}
server.addConnector(connector);
if (isHttpsEnabled()) {
SslSocketConnector sslConnector = new SslSocketConnector();
sslConnector.setMaxIdleTime(MAX_IDLE_TIME_MILLIS);
sslConnector.setHeaderBufferSize(HEADER_BUFFER_SIZE);
sslConnector.setHost(getHost());
sslConnector.setPort(getHttpsPort());
sslConnector.setKeystore(
System.getProperty(
"subsonic.ssl.keystore",
getClass().getResource("/subsonic.keystore").toExternalForm()));
sslConnector.setPassword(System.getProperty("subsonic.ssl.password", "subsonic"));
server.addConnector(sslConnector);
}
WebAppContext context = new WebAppContext();
context.setTempDirectory(getJettyDirectory());
context.setContextPath(getContextPath());
context.setWar(getWar());
context.setOverrideDescriptor("/web-jetty.xml");
if (isHttpsEnabled()) {
// Allow non-https for streaming and cover art (for Chromecast, UPnP, Sonos etc)
context
.getSecurityHandler()
.setConstraintMappings(
new ConstraintMapping[] {
createConstraintMapping("/stream", Constraint.DC_NONE),
createConstraintMapping("/coverArt.view", Constraint.DC_NONE),
createConstraintMapping("/ws/*", Constraint.DC_NONE),
createConstraintMapping("/sonos/*", Constraint.DC_NONE),
createConstraintMapping("/", Constraint.DC_CONFIDENTIAL)
});
}
server.addHandler(context);
server.start();
System.err.println("Subsonic running on: " + getUrl());
if (isHttpsEnabled()) {
System.err.println(" and: " + getHttpsUrl());
}
} catch (Throwable x) {
x.printStackTrace();
exception = x;
}
}
private SelectChannelConnector selectChannelConnector() {
SelectChannelConnector connector = new SelectChannelConnector();
connector.setPort(systemEnvironment.getServerPort());
connector.setHost(systemEnvironment.getListenHost());
return connector;
}
