jetty with resteasy http/https

import com.google.inject.Inject;
import com.google.inject.Injector;
import org.eclipse.jetty.http.HttpVersion;
import org.eclipse.jetty.security.ConstraintMapping;
import org.eclipse.jetty.security.ConstraintSecurityHandler;
import org.eclipse.jetty.security.HashLoginService;
import org.eclipse.jetty.security.SecurityHandler;
import org.eclipse.jetty.security.authentication.BasicAuthenticator;
import org.eclipse.jetty.security.authentication.DigestAuthenticator;
import org.eclipse.jetty.server.*;
import org.eclipse.jetty.server.handler.HandlerCollection;
import org.eclipse.jetty.server.handler.RequestLogHandler;
import org.eclipse.jetty.servlet.ServletContextHandler;
import org.eclipse.jetty.servlet.ServletHolder;
import org.eclipse.jetty.util.security.Constraint;
import org.eclipse.jetty.util.security.Credential;
import org.eclipse.jetty.util.security.Password;
import org.eclipse.jetty.util.ssl.SslContextFactory;
import org.jboss.resteasy.plugins.server.servlet.HttpServletDispatcher;

import javax.management.*;
import java.io.IOException;
import java.io.InputStream;
import java.lang.management.ManagementFactory;
import java.net.URISyntaxException;
import java.security.KeyStore;
import java.security.KeyStoreException;
import java.security.NoSuchAlgorithmException;
import java.security.cert.CertificateException;
import java.util.stream.Stream;

import static java.lang.System.getProperty;

public class OmsDBRestful implements OmsDBRestfulMBean {
private static final String KEY_MANAGER_PASSWORD = "OBF:1v2j1uum1xtv1zej1zer1xtn1uvk1v1v";
// private static final String KEY_MANAGER_PASSWORD = "password";
private static final String KEY_STORE_PASSWORD = "OBF:1v2j1uum1xtv1zej1zer1xtn1uvk1v1v";
private static final String KEY_STORE_PATH = "/oms-db-restful-auth-keystore.prd";
public static final String JKS = "JKS";
// private static final String KEY_STORE_PASSWORD = "password";
private final int port;
private final int sslPort;
private final ApplicationEvent eventLogger;
private Server server;
private final boolean authEnabled;
private Status status;

public static void main(String[] args) throws Exception {
Injector injector = GuiceContext.instance().injector();
OmsDBRestful process = injector.getInstance(OmsDBRestful.class);
registerMBean(process);
process.start().join();
}


@Inject
public OmsDBRestful(OmsDBRestfulConfig config, ApplicationEvent eventLogger) {
this.eventLogger = eventLogger;
this.port = config.restfulPort();
this.sslPort = config.restfulSslPort();
this.authEnabled = config.isAuthEnabled();
this.status = Status.STARTING;
}

public OmsDBRestful start() throws Exception {
server = new Server();
HandlerCollection handlers = new HandlerCollection();
if (authEnabled) {
handlers.setHandlers(new Handler[]{servletContextHandlerWithAuth(), servletContextHandler()});
server.addConnector(httpsConnector());
} else {
handlers.setHandlers(new Handler[]{servletContextHandler()});
}

server.setHandler(handlers);
server.addConnector(httpConnector());

server.start();
eventLogger.processStarted();
this.status = Status.UP;
return this;
}

private Connector httpConnector() {
ServerConnector http = new ServerConnector(server,
new HttpConnectionFactory());
http.setPort(port);
http.setIdleTimeout(30000);
return http;
}

private ServerConnector httpsConnector() throws URISyntaxException, CertificateException, NoSuchAlgorithmException, KeyStoreException, IOException {
HttpConfiguration httpsConfig = new HttpConfiguration();
httpsConfig.setSecureScheme("https");
httpsConfig.setSecurePort(sslPort);
httpsConfig.setOutputBufferSize(32768);
httpsConfig.addCustomizer(new SecureRequestCustomizer());

ServerConnector https = new ServerConnector(server,
new SslConnectionFactory(sslContextFactory(), HttpVersion.HTTP_1_1.asString()),
new HttpConnectionFactory(httpsConfig));
https.setPort(sslPort);
https.setIdleTimeout(500000);
return https;
}

private SslContextFactory sslContextFactory() throws URISyntaxException, KeyStoreException, CertificateException, NoSuchAlgorithmException, IOException {
KeyStore keyStore = KeyStore.getInstance(JKS);

Password realPassword = Password.getPassword("org.eclipse.jetty.ssl.password", KEY_STORE_PASSWORD, null);
InputStream keyStoreStream = getClass().getResourceAsStream(KEY_STORE_PATH);
if (keyStoreStream == null) {
throw new IllegalArgumentException("Can't find keystore: " + KEY_STORE_PATH);
}
keyStore.load(keyStoreStream, realPassword.toString().toCharArray());

SslContextFactory sslContextFactory = new SslContextFactory();
sslContextFactory.setKeyStore(keyStore);
sslContextFactory.setKeyManagerPassword(KEY_MANAGER_PASSWORD);
return sslContextFactory;
}

private RequestLogHandler createRequestLogHandler(String logFilePrefix) {
AsyncNCSARequestLog requestLog = new AsyncNCSARequestLog();
requestLog.setFilename(getProperty("app.logpath", "local") + "/" + logFilePrefix + "access-yyyy_MM_dd.log");
requestLog.setLogDateFormat("yyyy-MM-dd HH:mm:ss,sss");
requestLog.setAppend(true);
%A requestLog.setExtended(false);
requestLog.setLogTimeZone("UTC");
requestLog.setRetainDays(10);
RequestLogHandler requestLogHandler = new RequestLogHandler();
requestLogHandler.setRequestLog(requestLog);
return requestLogHandler;
}

private ServletContextHandler servletContextHandler() {
final ServletHolder restEasyServletHolder = new ServletHolder(new HttpServletDispatcher());
restEasyServletHolder.setInitOrder(1);
restEasyServletHolder.setInitParameter("javax.ws.rs.Application", OmsDBRestApplication.class.getCanonicalName());

final ServletContextHandler contextHandler = new ServletContextHandler(ServletContextHandler.SESSIONS);
contextHandler.setContextPath("/oms-db");
contextHandler.addServlet(restEasyServletHolder, "/*");
contextHandler.setHandler(createRequestLogHandler(""));
return contextHandler;
}

private ServletContextHandler servletContextHandlerWithAuth() {
final ServletHolder restEasyServletHolder = new ServletHolder(new HttpServletDispatcher());
restEasyServletHolder.setInitOrder(2);
restEasyServletHolder.setInitParameter("javax.ws.rs.Application", OmsDBRestApplication.class.getCanonicalName());

final ServletContextHandler contextHandler = new ServletContextHandler(ServletContextHandler.SESSIONS);
contextHandler.setContextPath("/v1/oms-db");
contextHandler.addServlet(restEasyServletHolder, "/*");
contextHandler.setHandler(createRequestLogHandler("secured-"));

contextHandler.setSecurityHandler(
basicAuth(
new UserCredential("support", "support", "OMS Database Restful site"),
new UserCredential("COG", "ClientOrderGateway", "OMS Database Restful site")
)
);

return contextHandler;
}

public void join() throws InterruptedException {
server.join();
}

public void stop() throws Exception {
server.stop();
status = Status.SHUTDOWN;
}

private static SecurityHandler basicAuth(UserCredential... userCredentials) {

HashLoginService l = new HashLoginService();
Stream.of(userCredentials).forEach(userCredential -> {
l.putUser(userCredential.userName, Credential.getCredential(userCredential.password), new String[]{"user"});
l.setName(userCredential.realm);
});

Constraint constraint = new Constraint();
constraint.setName(Constraint.__BASIC_AUTH);
constraint.setRoles(new String[]{"user"});
constraint.setAuthenticate(true);

ConstraintMapping cm = new ConstraintMapping();
cm.setConstraint(constraint);
cm.setPathSpec("/*");

ConstraintSecurityHandler csh = new ConstraintSecurityHandler();
csh.setAuthenticator(new BasicAuthenticator());
csh.setRealmName("myrealm");
csh.addConstraintMapping(cm);
csh.setLoginService(l);

return csh;
}

private static SecurityHandler digestAuth(UserCredential... userCredentials) {
HashLoginService l = new HashLoginService();
Stream.of(userCredentials).forEach(userCredential -> {
l.putUser(userCredential.userName, Credential.getCredential(userCredential.password), new String[]{"user"});
l.setName(userCredential.realm);
});

Constraint constraint = new Constraint();
constraint.setName(Constraint.__DIGEST_AUTH);
constraint.setRoles(new String[]{"user"});
constraint.setAuthenticate(true);

ConstraintMapping cm = new ConstraintMapping();
cm.setConstraint(constraint);
cm.setPathSpec("/*");

ConstraintSecurityHandler csh = new ConstraintSecurityHandler();
csh.setAuthenticator(new DigestAuthenticator());
csh.setRealmName("myrealm");
csh.addConstraintMapping(cm);
csh.setLoginService(l);

return csh;
}

@Override
public boolean isUp() {
return getStatus().equals(Status.UP.name());
}

@Override
public String getStatus() {
return Status.UP.name();
}

private static class UserCredential {
private String userName;
private String password;
private String realm;

public UserCredential(String userName, String password, String realm) {
this.userName = userName;
this.password = password;
this.realm = realm;
}

public String userName() {
return userName;
}

public String password() {
return password;
}

public String realm() {
return realm;
}
}

private static void registerMBean(OmsDBRestful process) throws MalformedObjectNameException, InstanceAlreadyExistsException, MBeanRegistrationException, NotCompliantMBeanException {
MBeanServer mbs = ManagementFactory.getPlatformMBeanServer();
ObjectName name = new ObjectName("com.hsbc.efx.orders:type=OmsDBRestful");
mbs.registerMBean(process, name);
}
}