path: root/dozentenmodul/src/main/java/org/openslx/dozmod/App.java

package org.openslx.dozmod;

import java.io.File;
import java.io.IOException;
import java.io.PrintWriter;
import java.io.StringWriter;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

import org.apache.log4j.AppenderSkeleton;
import org.apache.log4j.BasicConfigurator;
import org.apache.log4j.FileAppender;
import org.apache.log4j.Logger;
import org.apache.log4j.PatternLayout;
import org.apache.log4j.spi.LoggingEvent;
import org.openslx.dozmod.gui.Gui;
import org.openslx.dozmod.gui.MainWindow;
import org.openslx.dozmod.util.ProxyConfigurator;
import org.openslx.thrifthelper.ThriftManager;

public class App {

	// Logger
	private final static Logger LOGGER = Logger.getLogger(App.class);

	private static Thread proxyThread = null;

	private static void setupLogger() {

		// path to the log file
		final String logFilePath = Config.getPath() + System.getProperty("file.separator") + "bwSuite.log";

		// check if we had an old log file
		final File logFile = new File(logFilePath);
		if (logFile.exists() && !logFile.isDirectory()) {
			// we have one, rename it to 'bwSuite.log.old'
			LOGGER.info("renaming old log file");
			try {
				File oldFile = new File(logFilePath + ".old");
				oldFile.delete();
				logFile.renameTo(oldFile);
				logFile.delete();
			} catch (Exception e) {
				LOGGER.error("Could not move '" + logFilePath + "' to '" + logFilePath + ".old'", e);
			}
		}

		// add file appender to global logger
		FileAppender fa = null;
		try {
			fa = new FileAppender(new PatternLayout("%d [%F:%M] %m%n"), logFilePath);
			// All classes should log to file, configure global file appender.
		} catch (IOException e) {
			e.printStackTrace();
			BasicConfigurator.configure();
			return;
		}

		final FileAppender ffa = fa;
		final Pattern re = Pattern.compile("authorization:(\\w|\\+|/|\\s)+", Pattern.CASE_INSENSITIVE
				| Pattern.MULTILINE);

		AppenderSkeleton ap = new AppenderSkeleton() {

			@Override
			public boolean requiresLayout() {
				return ffa.requiresLayout();
			}

			@Override
			public void close() {
				ffa.close();
			}

			@Override
			protected void append(LoggingEvent event) {
				String s = event.getRenderedMessage();
				if (s.contains("uthorization")) {
					Matcher m = re.matcher(s);
					if (m.find()) {
						s = m.replaceAll("Authorization: ***********");
					}
				}
				ffa.append(new LoggingEvent(event.getFQNOfLoggerClass(), event.getLogger(),
						event.getTimeStamp(), event.getLevel(), s, event.getThreadName(),
						event.getThrowableInformation(), event.getNDC(), event.getLocationInformation(),
						event.getProperties()));
			}
		};

		BasicConfigurator.configure(ap);
		LOGGER.info("Starting logging to: " + logFilePath);
	}

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

		try {
			Config.init();
		} catch (Exception e) {
			showAwtMessage("Error loading configuration", e);
			return;
		}

		setupLogger();

		// Initialize the proxy settings
		proxyThread = new Thread() {
			@Override
			public void run() {
				ProxyConfigurator.init();
			}
		};
		proxyThread.start();

		// Check if we can load SWT by calling some library function
		try {
			Gui.display.getActiveShell();
		} catch (Throwable e) {
			showAwtMessage("Error loading SWT libraries", e);
			return;
		}

		// setup global thrift connection error handler before anything else
		// Set master server to use (TODO: make configurable via command line)
		ThriftManager.setMasterServerAddress("bwlp-masterserver.ruf.uni-freiburg.de");

		MainWindow.open();

		// start the main window
		Gui.mainloop();
	}

	private static void showAwtMessage(String message, Throwable e) {
		LOGGER.error(message, e);
		if (e != null) {
			StringWriter sw = new StringWriter();
			e.printStackTrace(new PrintWriter(sw));
			message += "\n\n" + sw.toString();
		}
		new AwtBox(null, message);
	}

	/**
	 * Blocks as long as initialization is still going on. Currently this is
	 * just the proxy setup, so this should be used before any network
	 * communication happens.
	 */
	public static synchronized void waitForInit() {
		if (proxyThread == null)
			return;
		try {
			proxyThread.join();
		} catch (InterruptedException e) {
		}
		proxyThread = null;
	}
}