Moved main parts of the configuration to bkucommon

git-svn-id: https://joinup.ec.europa.eu/svn/mocca/trunk@78 8a26b1a7-26f0-462f-b9ef-d0e30c41f5a4

3 files changed, 437 insertions, 0 deletions

diff --git a/BKULocalApp/src/main/java/at/gv/egiz/bku/local/app/BKULauncher.java b/BKULocalApp/src/main/java/at/gv/egiz/bku/local/app/BKULauncher.java
new file mode 100644
index 00000000..091843e1
--- /dev/null
+++ b/BKULocalApp/src/main/java/at/gv/egiz/bku/local/app/BKULauncher.java
@@ -0,0 +1,222 @@
+package at.gv.egiz.bku.local.app;

+

+import java.io.File;

+import java.io.FileInputStream;

+import java.io.FileOutputStream;

+import java.io.IOException;

+import java.io.InputStream;

+import java.io.OutputStream;

+import java.security.KeyStore;

+import java.util.Enumeration;

+import java.util.Locale;

+import java.util.MissingResourceException;

+import java.util.ResourceBundle;

+import java.util.zip.ZipEntry;

+import java.util.zip.ZipFile;

+

+import org.apache.commons.cli.CommandLine;

+import org.apache.commons.cli.CommandLineParser;

+import org.apache.commons.cli.HelpFormatter;

+import org.apache.commons.cli.Options;

+import org.apache.commons.cli.ParseException;

+import org.apache.commons.cli.PosixParser;

+import org.apache.commons.logging.Log;

+import org.apache.commons.logging.LogFactory;

+

+import at.gv.egiz.bku.local.ui.BKUControllerInterface;

+import at.gv.egiz.bku.local.ui.TrayIconDialog;

+import at.gv.egiz.bku.utils.StreamUtil;

+

+public class BKULauncher implements BKUControllerInterface {

+  private static Log log = LogFactory.getLog(BKULauncher.class);

+

+  private ResourceBundle resourceBundle = null;

+  private Container server;

+

+  private void startUpServer() throws Exception {

+    server = new Container();

+    // XmlConfiguration xcfg = new XmlConfiguration(getClass().getClassLoader()

+    // .getResourceAsStream("at/gv/egiz/bku/local/app/jetty.xml"));

+    // xcfg.configure(server);

+    server.init();

+    server.start();

+  }

+

+  private void initTrayIcon() {

+    Locale loc = Locale.getDefault();

+    try {

+      resourceBundle = ResourceBundle.getBundle(

+          "at/gv/egiz/bku/local/ui/UIMessages", loc);

+    } catch (MissingResourceException mx) {

+      resourceBundle = ResourceBundle.getBundle(

+          "at/gv/egiz/bku/local/ui/UIMessages", Locale.ENGLISH);

+    }

+    TrayIconDialog.getInstance().init(resourceBundle);

+    TrayIconDialog.getInstance().setShutdownHook(this);

+    TrayIconDialog.getInstance().displayInfo("Greetings.Caption",

+        "Greetings.Message");

+  }

+

+  private void initFinished() {

+    try {

+      server.join();

+    } catch (InterruptedException e) {

+      log.info(e);

+    }

+  }

+

+  private void copyDirs(File srcDir, File dstDir) {

+    for (File cf : srcDir.listFiles()) {

+      File of = new File(dstDir, cf.getName());

+      if (cf.isDirectory()) {

+        log.debug("Creating directory: " + of);

+        of.mkdir();

+        copyDirs(cf, of);

+      } else {

+        log.debug("Writing file: " + of);

+        try {

+          FileInputStream fis = new FileInputStream(cf);

+          FileOutputStream fos = new FileOutputStream(of);

+          StreamUtil.copyStream(fis, fos);

+          fis.close();

+          fos.close();

+        } catch (IOException e) {

+          log.error("Cannot copy default configuration", e);

+        }

+      }

+    }

+  }

+

+  private void unzip(File zipfile) throws IOException {

+    File dir = zipfile.getParentFile();

+    ZipFile zipFile = new ZipFile(zipfile);

+    Enumeration<? extends ZipEntry> entries = zipFile.entries();

+    while (entries.hasMoreElements()) {

+      ZipEntry entry = entries.nextElement();

+      File eF = new File(dir, entry.getName());

+      if (entry.isDirectory()) {

+        eF.mkdirs();

+        continue;

+      }

+      File f = new File(eF.getParent());

+      f.mkdirs();

+      StreamUtil.copyStream(zipFile.getInputStream(entry),

+          new FileOutputStream(eF));

+    }

+    zipFile.close();

+  }

+

+  private void checkConfig(String[] args) {

+    CommandLineParser parser = new PosixParser();

+    Options options = new Options();

+    options.addOption("c", true, "the configuration's base directory");

+    options.addOption("h", false, "print this message");

+    try {

+      File cfgDir = new File(System.getProperty("user.home") + "/.mocca/conf");

+      CommandLine cmd = parser.parse(options, args);

+      if (cmd.hasOption("h")) {

+        HelpFormatter formatter = new HelpFormatter();

+        formatter.printHelp("BKULauncher", options);

+        System.exit(0);

+      }

+

+      if (cmd.hasOption("c")) {

+        cfgDir = new File(cmd.getOptionValue("c"));

+      }

+      log.debug("using config directory: " + cfgDir);

+      if (cfgDir.exists() && cfgDir.isFile()) {

+        log.error("Configuration directory must not be a file");

+      }

+      if (!cfgDir.exists()) {

+        log.debug("Creating config directory: " + cfgDir);

+        cfgDir.mkdirs();

+        try {

+          InputStream is = getClass().getClassLoader().getResourceAsStream(

+              "at/gv/egiz/bku/local/defaultConf/template.zip");

+          OutputStream os = new FileOutputStream(new File(cfgDir,

+              "template.zip"));

+          StreamUtil.copyStream(is, os);

+          os.close();

+          unzip(new File(cfgDir, "template.zip"));

+        } catch (IOException iox) {

+          log.error("Cannot create user directory", iox);

+          return;

+        }

+        CA ca = new CA();

+        char[] password = "changeMe".toCharArray();

+        KeyStore ks = ca.generateKeyStore(password);

+        if (ks != null) {

+          File ksdir = new File(cfgDir, "keystore");

+          ksdir.mkdirs();

+          FileOutputStream fos;

+          try {

+            fos = new FileOutputStream(new File(ksdir, "keystore.ks"));

+            ks.store(fos, password);

+            fos.close();

+          } catch (Exception e) {

+            log.error("Cannot store keystore", e);

+          }

+        } else {

+          log.error("Cannot create ssl certificate");

+        }

+      }

+    } catch (ParseException e1) {

+      log.error(e1);

+      HelpFormatter formatter = new HelpFormatter();

+      formatter.printHelp("BKULauncher", options);

+      System.exit(0);

+    }

+  }

+

+  public void jwsHack() {

+    InputStream is = getClass().getClassLoader().getResourceAsStream(

+        "BKULocal-1.0-SNAPSHOT.war");

+    File f = new File(System.getProperty("user.home") + "/.mocca/war");

+    f.mkdirs();

+    try {

+      OutputStream os = new FileOutputStream(new File(f, "mocca.war"));

+      StreamUtil.copyStream(is, os);

+      os.close();

+    } catch (Exception e) {

+      log.error(e);

+    }

+  }

+

+  /**

+   * @param args

+   */

+  public static void main(String[] args) {

+

+    try {

+      BKULauncher launcher = new BKULauncher();

+      //launcher.jwsHack();

+      launcher.checkConfig(args);

+      launcher.startUpServer();

+      launcher.initTrayIcon();

+      launcher.initFinished();

+    } catch (Exception e) {

+      log.fatal("Cannot launch BKU", e);

+      System.exit(-1000);

+    }

+

+  }

+

+  public void shutDown() {

+    log.info("Shutting down server");

+    if ((server != null) && (server.isRunning())) {

+      try {

+        if (server.isRunning()) {

+          server.stop();

+        }

+      } catch (Exception e) {

+        log.debug(e.toString());

+      } finally {

+        if (server.isRunning()) {

+          server.destroy();

+        }

+      }

+    }

+    System.exit(0);

+  }

+

+}

diff --git a/BKULocalApp/src/main/java/at/gv/egiz/bku/local/app/CA.java b/BKULocalApp/src/main/java/at/gv/egiz/bku/local/app/CA.java
new file mode 100644
index 00000000..31d21ef7
--- /dev/null
+++ b/BKULocalApp/src/main/java/at/gv/egiz/bku/local/app/CA.java
@@ -0,0 +1,117 @@
+package at.gv.egiz.bku.local.app;

+

+import iaik.asn1.ObjectID;

+import iaik.asn1.structures.AlgorithmID;

+import iaik.asn1.structures.Name;

+import iaik.x509.X509Certificate;

+import iaik.x509.extensions.BasicConstraints;

+import iaik.x509.extensions.KeyUsage;

+

+import java.math.BigInteger;

+import java.net.InetAddress;

+import java.net.UnknownHostException;

+import java.security.GeneralSecurityException;

+import java.security.KeyPair;

+import java.security.KeyPairGenerator;

+import java.security.KeyStore;

+import java.security.NoSuchAlgorithmException;

+import java.util.Calendar;

+import java.util.GregorianCalendar;

+import java.util.Random;

+

+import org.apache.commons.logging.Log;

+import org.apache.commons.logging.LogFactory;

+

+public class CA {

+  private final static Log log = LogFactory.getLog(CA.class);

+

+  private KeyPair caKeyPair;

+  private X509Certificate caCert;

+

+  private KeyPair serverKeyPair;

+  private X509Certificate serverCert;

+

+  public CA() {

+  }

+

+  private KeyPair generateKeyPair() throws NoSuchAlgorithmException {

+    KeyPairGenerator gen = KeyPairGenerator.getInstance("RSA");

+    gen.initialize(2048);

+    return gen.generateKeyPair();

+  }

+

+  private void generateCA() throws GeneralSecurityException {

+    log.debug("Generating CA certificate");

+    Name subject = new Name();

+    subject.addRDN(ObjectID.country, "AT");

+    subject.addRDN(ObjectID.organization, "MOCCA");

+    subject.addRDN(ObjectID.organizationalUnit, "MOCCA-CA");

+

+    caKeyPair = generateKeyPair();

+    caCert = new X509Certificate();

+    caCert.setSerialNumber(new BigInteger(20, new Random()));

+    caCert.setSubjectDN(subject);

+    caCert.setPublicKey(caKeyPair.getPublic());

+    caCert.setIssuerDN(subject);

+

+    caCert.addExtension(new BasicConstraints(true));

+    caCert.addExtension(new KeyUsage(KeyUsage.keyCertSign | KeyUsage.cRLSign

+        | KeyUsage.digitalSignature));

+

+    GregorianCalendar date = new GregorianCalendar();

+    date.add(Calendar.HOUR_OF_DAY, -1);

+    caCert.setValidNotBefore(date.getTime());

+    date.add(Calendar.YEAR, 7);

+    caCert.setValidNotAfter(date.getTime());

+    caCert.sign(AlgorithmID.sha1WithRSAEncryption, caKeyPair.getPrivate());

+    log.debug("Successfully signed CA certificate");

+  }

+

+  private void generateServerCert() throws GeneralSecurityException {

+    log.debug("Generating SSL certificate");

+    Name subject = new Name();

+    subject.addRDN(ObjectID.country, "AT");

+    subject.addRDN(ObjectID.organization, "MOCCA");

+    try {

+      subject.addRDN(ObjectID.commonName, InetAddress.getLocalHost()

+          .getHostName());

+    } catch (UnknownHostException e) {

+      subject.addRDN(ObjectID.commonName, "localhost");

+    }

+    serverKeyPair = generateKeyPair();

+    serverCert = new X509Certificate();

+    serverCert.setSerialNumber(new BigInteger(20, new Random()));

+    serverCert.setSubjectDN(subject);

+    serverCert.setPublicKey(serverKeyPair.getPublic());

+    serverCert.setIssuerDN(caCert.getSubjectDN());

+

+    serverCert.addExtension(new BasicConstraints(false));

+    serverCert.addExtension(new KeyUsage(KeyUsage.keyEncipherment

+        | KeyUsage.digitalSignature));

+

+    GregorianCalendar date = new GregorianCalendar();

+    date.add(Calendar.HOUR_OF_DAY, -1);

+    serverCert.setValidNotBefore(date.getTime());

+    date.add(Calendar.YEAR, 7);

+    date.add(Calendar.HOUR_OF_DAY, -1);

+    serverCert.setValidNotAfter(date.getTime());

+    serverCert.sign(AlgorithmID.sha1WithRSAEncryption, caKeyPair.getPrivate());

+    log.debug("Successfully signed server certificate");

+    caKeyPair = null;

+  }

+

+  public KeyStore generateKeyStore(char[] password) {

+    try {

+      generateCA();

+      generateServerCert();

+      KeyStore ks = KeyStore.getInstance("JKS");

+      ks.load(null, null);

+      ks.setKeyEntry("server", serverKeyPair.getPrivate(), password, new X509Certificate[]{serverCert, caCert});

+      return ks;

+    } catch (Exception e) {

+      log.error("Cannot generate certificate", e);

+    }

+    return null;

+  }

+

+}

diff --git a/BKULocalApp/src/main/java/at/gv/egiz/bku/local/app/Container.java b/BKULocalApp/src/main/java/at/gv/egiz/bku/local/app/Container.java
new file mode 100644
index 00000000..690639f4
--- /dev/null
+++ b/BKULocalApp/src/main/java/at/gv/egiz/bku/local/app/Container.java
@@ -0,0 +1,98 @@
+package at.gv.egiz.bku.local.app;

+

+import java.io.File;

+import java.io.IOException;

+

+import org.apache.commons.logging.Log;

+import org.apache.commons.logging.LogFactory;

+import org.mortbay.jetty.Connector;

+import org.mortbay.jetty.Handler;

+import org.mortbay.jetty.Server;

+import org.mortbay.jetty.handler.DefaultHandler;

+import org.mortbay.jetty.handler.HandlerCollection;

+import org.mortbay.jetty.nio.SelectChannelConnector;

+import org.mortbay.jetty.security.SslSocketConnector;

+import org.mortbay.jetty.webapp.WebAppClassLoader;

+import org.mortbay.jetty.webapp.WebAppContext;

+import org.mortbay.thread.QueuedThreadPool;

+

+public class Container {

+

+  private static Log log = LogFactory.getLog(Container.class);

+

+  private Server server;

+

+  public Container() {

+  }

+

+  public void init() {

+    Thread.currentThread().setContextClassLoader(ClassLoader.getSystemClassLoader());

+   log.debug("-----------------> "+ClassLoader.getSystemClassLoader());

+    server = new Server();

+    QueuedThreadPool qtp = new QueuedThreadPool();

+    qtp.setMaxThreads(5);

+    qtp.setMinThreads(2);

+    qtp.setLowThreads(0);

+    server.setThreadPool(qtp);

+    server.setStopAtShutdown(true);

+    server.setGracefulShutdown(3000);

+

+    SelectChannelConnector connector = new SelectChannelConnector();

+    connector.setPort(3495);

+    connector.setAcceptors(1);

+    connector.setConfidentialPort(3496);

+

+    SslSocketConnector sslConnector = new SslSocketConnector();

+    sslConnector.setPort(3496);

+    sslConnector.setAcceptors(1);

+    sslConnector.setKeystore(System.getProperty("user.home")

+        + "/.mocca/conf/keystore/keystore.ks");

+    sslConnector.setPassword("changeMe");

+    sslConnector.setKeyPassword("changeMe");

+

+    server.setConnectors(new Connector[] { connector, sslConnector });

+    HandlerCollection handlers = new HandlerCollection();

+

+    WebAppContext webappcontext = new WebAppContext();

+    webappcontext.setContextPath("/");

+    webappcontext.setExtractWAR(false);

+    

+    File tmpDir = new File(System.getProperty("user.home") + "/.mocca/tmp");

+    // tmpDir.mkdirs();

+    // webappcontext.setTempDirectory(tmpDir);

+    try {

+      File f = new File(System.getProperty("user.home")

+          + "/.mocca/war/mocca.war");

+      log.debug("Deploying war: " + f.getCanonicalPath());

+      if (!f.exists()) {

+        log.error("WAR file does not exist, cannot run MOCCA");

+      }

+      webappcontext.setWar(f.getParent());

+    } catch (IOException e) {

+      log.error(e);

+    }

+    handlers.setHandlers(new Handler[] { webappcontext, new DefaultHandler() });

+

+    server.setHandler(handlers);

+  }

+

+  public void start() throws Exception {

+    server.start();

+  }

+

+  public boolean isRunning() {

+    return server.isRunning();

+  }

+

+  public void stop() throws Exception {

+    server.stop();

+  }

+

+  public void destroy() {

+    server.destroy();

+  }

+

+  public void join() throws InterruptedException {

+    server.join();

+  }

+}
\ No newline at end of file