protected void configureConnectors() {
if (server != null) {
if (_useNIO) {
SelectChannelConnector nioConnector = new SelectChannelConnector();
nioConnector.setUseDirectBuffers(false);
nioConnector.setPort(_port);
server.addConnector(nioConnector);
} else {
SocketConnector bioConnector = new SocketConnector();
bioConnector.setPort(_port);
bioConnector.setMaxIdleTime(3000);
server.addConnector(bioConnector);
}
if (_useSSL) {
SslSocketConnector sslConnector = new SslSocketConnector();
sslConnector.setPort(_sslPort);
// sslConnector.setKeystore("/sdcard/jetty/etc/keystore");
sslConnector.setKeystore(_keystoreFile);
sslConnector.setKeystoreType("bks");
// sslConnector.setTruststore("/sdcard/jetty/etc/keystore");
sslConnector.setTruststore(_truststoreFile);
// sslConnector.setPassword("OBF:1vny1zlo1x8e1vnw1vn61x8g1zlu1vn4");
sslConnector.setPassword(_keystorePassword);
// sslConnector.setKeyPassword("OBF:1u2u1wml1z7s1z7a1wnl1u2g");
sslConnector.setKeyPassword(_keymgrPassword);
// sslConnector.setTrustPassword("OBF:1vny1zlo1x8e1vnw1vn61x8g1zlu1vn4");
sslConnector.setTrustPassword(_truststorePassword);
sslConnector.setTruststoreType("bks");
server.addConnector(sslConnector);
}
}
}
private static void initSSL(
Server server,
int sslport,
String keystore,
String password,
String keyPassword,
boolean needClientAuth) {
if (keystore == null) {
throw new IllegalStateException(
"you need to provide argument -Drjrkeystore with -Drjrsslport");
}
if (password == null) {
throw new IllegalStateException(
"you need to provide argument -Drjrpassword with -Drjrsslport");
}
if (keyPassword == null) {
throw new IllegalStateException(
"you need to provide argument -Drjrkeypassword with -Drjrsslport");
}
SslSocketConnector sslConnector = new SslSocketConnector();
sslConnector.setKeystore(keystore);
sslConnector.setPassword(password);
sslConnector.setKeyPassword(keyPassword);
if (needClientAuth) {
System.err.println("Enable NeedClientAuth.");
sslConnector.setNeedClientAuth(needClientAuth);
}
sslConnector.setMaxIdleTime(30000);
sslConnector.setPort(sslport);
server.addConnector(sslConnector);
}
private static SslSocketConnector getSslConnector(int port) {
SslSocketConnector sslConnector = new SslSocketConnector();
sslConnector.setKeystore(resourceBase + "/keystore");
sslConnector.setKeyPassword("pulkkisenjorma");
sslConnector.setPort(port);
sslConnector.setMaxIdleTime(30000);
return sslConnector;
}
private static SslSocketConnector createSslConnector() {
SslSocketConnector sslConnector = new SslSocketConnector();
sslConnector.setPort(sslPort);
sslConnector.setKeyPassword("secret");
sslConnector.setKeystore("src/test/resources/keystore");
sslConnector.setTrustPassword("secret");
sslConnector.setTruststore("src/main/resources/truststore");
sslConnector.setPassword("secret");
sslConnector.setWantClientAuth(true);
// sslConnector.setNeedClientAuth(true);
return sslConnector;
}
public static void main(String[] args) throws Exception {
ApplicationProperties properties = new ApplicationProperties();
Server server = new Server();
SocketConnector connector = new SocketConnector();
// Set some timeout options to make debugging easier.
connector.setMaxIdleTime(1000 * 60 * 60);
connector.setSoLingerTime(-1);
int port = Integer.getInteger("jetty.port", properties.getHttpPort());
connector.setPort(port);
SslSocketConnector sslConnector = new SslSocketConnector();
sslConnector.setMaxIdleTime(1000 * 60 * 60);
sslConnector.setSoLingerTime(-1);
sslConnector.setKeyPassword("password");
sslConnector.setPassword("password");
sslConnector.setKeystore("src/main/webapp/WEB-INF/keystore");
port = Integer.getInteger("jetty.sslport", properties.getHttpsPort());
sslConnector.setPort(port);
server.setConnectors(new Connector[] {connector, sslConnector});
WebAppContext bb = new WebAppContext();
bb.setServer(server);
bb.setContextPath("/");
bb.setWar("src/main/webapp");
// START JMX SERVER
// MBeanServer mBeanServer = ManagementFactory.getPlatformMBeanServer();
// MBeanContainer mBeanContainer = new MBeanContainer(mBeanServer);
// server.getContainer().addEventListener(mBeanContainer);
// mBeanContainer.start();
server.addHandler(bb);
try {
System.out.println(">>> STARTING EMBEDDED JETTY SERVER, PRESS ANY KEY TO STOP");
server.start();
while (System.in.available() == 0) {
Thread.sleep(5000);
}
server.stop();
server.join();
} catch (Exception e) {
e.printStackTrace();
System.exit(100);
}
}
public void start(SoapMonitor soapMonitor, int localPort) {
Settings settings = soapMonitor.getProject().getSettings();
server.setThreadPool(new SoapUIJettyThreadPool());
Context context = new Context(server, ROOT, 0);
if (sslEndpoint != null) {
if (sslEndpoint.startsWith(HTTPS)) {
sslConnector = new SslSocketConnector();
sslConnector.setKeystore(
settings.getString(SoapMonitorAction.SecurityTabForm.SSLTUNNEL_KEYSTORE, "JKS"));
sslConnector.setPassword(
settings.getString(SoapMonitorAction.SecurityTabForm.SSLTUNNEL_PASSWORD, ""));
sslConnector.setKeyPassword(
settings.getString(SoapMonitorAction.SecurityTabForm.SSLTUNNEL_KEYPASSWORD, ""));
sslConnector.setTruststore(
settings.getString(SoapMonitorAction.SecurityTabForm.SSLTUNNEL_TRUSTSTORE, "JKS"));
sslConnector.setTrustPassword(
settings.getString(
SoapMonitorAction.SecurityTabForm.SSLTUNNEL_TRUSTSTORE_PASSWORD, ""));
sslConnector.setNeedClientAuth(false);
sslConnector.setMaxIdleTime(30000);
sslConnector.setPort(localPort);
server.addConnector(sslConnector);
context.addServlet(new ServletHolder(new TunnelServlet(soapMonitor, sslEndpoint)), ROOT);
} else {
if (sslEndpoint.startsWith(HTTP)) {
connector.setPort(localPort);
server.addConnector(connector);
context.addServlet(new ServletHolder(new TunnelServlet(soapMonitor, sslEndpoint)), ROOT);
} else {
UISupport.showErrorMessage("Unsupported/unknown protocol tunnel will not start");
return;
}
}
proxyOrTunnel = false;
} else {
proxyOrTunnel = true;
connector.setPort(localPort);
server.addConnector(connector);
context.addServlet(new ServletHolder(new ProxyServlet(soapMonitor)), ROOT);
}
try {
server.start();
} catch (Exception e) {
UISupport.showErrorMessage("Error starting monitor: " + e.getMessage());
}
}
@BeforeClass
public static void startJetty() throws Exception {
port = PortFactory.findFreePort();
server = new Server();
SslSocketConnector sslSocketConnector = new SslSocketConnector();
sslSocketConnector.setKeystore("src/test/resources/keystore");
sslSocketConnector.setKeyPassword("password");
sslSocketConnector.setPort(port);
server.setConnectors(new Connector[] {sslSocketConnector});
server.addHandler(
new AbstractHandler() {
public void handle(
String target, HttpServletRequest request, HttpServletResponse response, int dispatch)
throws IOException, ServletException {
response.setStatus(Response.Status.OK.getStatusCode());
Request base_request =
request instanceof Request
? (Request) request
: HttpConnection.getCurrentConnection().getRequest();
base_request.setHandled(true);
}
});
server.start();
}
/**
* 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();
}
}
public static void main(String[] args) throws Exception {
SocketConnector socketConnector = new SocketConnector();
socketConnector.setPort(6080);
SslSocketConnector sslSocketConnector = new SslSocketConnector();
sslSocketConnector.setPort(6443);
// sslSocketConnector.setNeedClientAuth(true); //why not use mutual authentication when
// we can
String serverKeystore =
MockHttpListenerWithAuthentication.class
.getClassLoader()
.getResource("cert/serverkeystore.jks")
.getPath();
sslSocketConnector.setKeystore(serverKeystore);
sslSocketConnector.setKeyPassword("serverpass");
String serverTruststore =
MockHttpListenerWithAuthentication.class
.getClassLoader()
.getResource("cert/servertruststore.jks")
.getPath();
sslSocketConnector.setTruststore(serverTruststore);
sslSocketConnector.setTrustPassword("serverpass");
server.addConnector(socketConnector);
server.addConnector(sslSocketConnector);
SecurityHandler securityHandler = createBasicAuthenticationSecurityHandler();
HandlerList handlerList = new HandlerList();
handlerList.addHandler(securityHandler);
handlerList.addHandler(
new AbstractHandler() {
@Override
public void handle(
String s,
HttpServletRequest httpServletRequest,
HttpServletResponse httpServletResponse,
int i)
throws IOException, ServletException {
System.out.println("uri: " + httpServletRequest.getRequestURI());
System.out.println("queryString: " + httpServletRequest.getQueryString());
System.out.println("method: " + httpServletRequest.getMethod());
ByteArrayOutputStream baos = new ByteArrayOutputStream();
IOUtils.copy(httpServletRequest.getInputStream(), baos);
System.out.println("body: " + baos.toString());
PrintWriter writer = httpServletResponse.getWriter();
writer.append("testsvar");
Random r = new Random();
for (int j = 0; j < 10; j++) {
int value = r.nextInt(Integer.MAX_VALUE);
writer.append(value + "");
}
System.out.println();
writer.close();
httpServletResponse.setStatus(HttpServletResponse.SC_OK);
}
});
server.addHandler(handlerList);
server.start();
}
@SuppressWarnings("unchecked")
public static void startup(String args[]) {
try {
Server server = new Server();
System.err.println("mycat init ... ");
int httpPort = 7066;
int httpsPort = -1;
String contextPath = "/";
String keyStorePath = null;
String keyStorePassword = null;
String updateServer = null;
boolean disableUpdateCenterSwitch = false;
boolean skipInitSetup = false;
for (int i = 0; i < args.length; ++i) {
String portStr;
if (args[i].startsWith("--httpPort=")) {
portStr = args[i].substring("--httpPort=".length());
httpPort = Integer.parseInt(portStr);
}
if (args[i].startsWith("--httpsPort=")) {
portStr = args[i].substring("--httpsPort=".length());
httpsPort = Integer.parseInt(portStr);
}
if (args[i].startsWith("--httpsKeyStore=")) {
keyStorePath = args[i].substring("--httpsKeyStore=".length());
}
if (args[i].startsWith("--httpsKeyStorePassword="******"--httpsKeyStorePassword="******"--prefix=")) {
String prefix = args[i].substring("--prefix=".length());
if (prefix.startsWith("/")) contextPath = prefix;
else {
contextPath = "/" + prefix;
}
}
if (args[i].startsWith("--updateServer=")) {
updateServer = args[i].substring("--updateServer=".length());
}
if (args[i].startsWith("--disableUpdateCenterSwitch")) {
disableUpdateCenterSwitch = true;
}
if (args[i].startsWith("--skipInitSetup")) {
skipInitSetup = true;
}
}
List connectors = new ArrayList();
if (httpPort != -1) {
SelectChannelConnector httpConnector = new SelectChannelConnector();
httpConnector.setPort(httpPort);
connectors.add(httpConnector);
}
if (httpsPort != -1) {
SslSocketConnector httpsConnector = new SslSocketConnector();
httpsConnector.setPort(httpsPort);
if (keyStorePath != null) {
httpsConnector.setKeystore(keyStorePath);
}
if (keyStorePassword != null) {
httpsConnector.setKeyPassword(keyStorePassword);
}
connectors.add(httpsConnector);
}
server.setConnectors((Connector[]) connectors.toArray(new Connector[connectors.size()]));
ProtectionDomain protectionDomain = Executable.class.getProtectionDomain();
URL location = protectionDomain.getCodeSource().getLocation();
String url = java.net.URLDecoder.decode(location.getPath(), "utf-8");
System.out.println(url);
File tempDir = new File(getHomeDir(), "war");
tempDir.mkdirs();
WebAppContext webapp = new WebAppContext();
webapp.setContextPath("/mycat"); //
webapp.setDescriptor(url + "/WEB-INF/web.xml");
webapp.setResourceBase(url);
webapp.setTempDirectory(tempDir);
server.setHandler(webapp);
System.err.println("mycat start success,port: " + httpsPort);
server.start();
server.join();
} catch (Exception e) {
System.exit(-1);
}
}
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;
}
}