Introduced logging bottleneck

7 files changed, 889 insertions, 0 deletions

diff --git a/netx/net/sourceforge/jnlp/util/logging/FileLog.java b/netx/net/sourceforge/jnlp/util/logging/FileLog.java
new file mode 100644
index 0000000..05b079a
--- /dev/null
+++ b/netx/net/sourceforge/jnlp/util/logging/FileLog.java
@@ -0,0 +1,107 @@
+/* FileLog.java
+ Copyright (C) 2011, 2013 Red Hat, Inc.
+
+ This file is part of IcedTea.
+
+ IcedTea is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2, or (at your option)
+ any later version.
+
+ IcedTea is distributed in the hope that it will be useful, but
+ WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with IcedTea; see the file COPYING.  If not, write to the
+ Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
+ 02110-1301 USA.
+
+ Linking this library statically or dynamically with other modules is
+ making a combined work based on this library.  Thus, the terms and
+ conditions of the GNU General Public License cover the whole
+ combination.
+
+ As a special exception, the copyright holders of this library give you
+ permission to link this library with independent modules to produce an
+ executable, regardless of the license terms of these independent
+ modules, and to copy and distribute the resulting executable under
+ terms of your choice, provided that you also meet, for each linked
+ independent module, the terms and conditions of the license of that
+ module.  An independent module is a module which is not derived from
+ or based on this library.  If you modify this library, you may extend
+ this exception to your version of the library, but you are not
+ obligated to do so.  If you do not wish to do so, delete this
+ exception statement from your version. */
+package net.sourceforge.jnlp.util.logging;
+
+import java.io.File;
+import java.io.IOException;
+import java.util.logging.FileHandler;
+import java.util.logging.Formatter;
+import java.util.logging.Level;
+import java.util.logging.LogRecord;
+import java.util.logging.Logger;
+import net.sourceforge.jnlp.util.FileUtils;
+
+/**
+ * This class writes log information to file.
+ *
+ */
+public final class FileLog implements SingleStreamLogger {
+
+    private final Logger impl;
+    private final FileHandler fh;
+    private static final String defaultloggerName = "IcedTea-Web file-logger";
+
+    public FileLog() {
+        this(defaultloggerName, LogConfig.getLogConfig().getIcedteaLogDir() + "itw-" + java.lang.System.currentTimeMillis() + ".log", false);
+    }
+    
+     public FileLog(boolean append) {
+        this(defaultloggerName, LogConfig.getLogConfig().getIcedteaLogDir() + "itw-" + java.lang.System.currentTimeMillis() + ".log", append);
+    }
+
+
+     
+     public FileLog(String fileName, boolean append) {
+         this(fileName, fileName, append);
+     }
+     
+     public FileLog(String loggerName, String fileName, boolean append) {
+        try{
+            File futureFile = new File(fileName);
+            if (!futureFile.exists()) {
+                FileUtils.createRestrictedFile(futureFile, true);
+            }
+            fh  = new FileHandler(fileName, append);
+            fh.setFormatter(new Formatter() {
+                @Override
+                public String format(LogRecord record) {
+                    return record.getMessage() + "\n";
+                }
+            });
+            impl = Logger.getLogger(loggerName);
+            impl.setLevel(Level.ALL);
+            impl.addHandler(fh);
+            log(OutputController.getHeader(null, null));
+        } catch (IOException e) {
+           throw new RuntimeException(e);
+        }
+    }
+
+    /**
+     * Log the String to file.
+     *
+     * @param e Exception that was thrown.
+     */
+    @Override
+    public synchronized void log(String s) {
+        impl.log(Level.FINE, s);
+    }
+    
+    public void close(){
+        fh.close();
+    }
+}
diff --git a/netx/net/sourceforge/jnlp/util/logging/LogConfig.java b/netx/net/sourceforge/jnlp/util/logging/LogConfig.java
new file mode 100644
index 0000000..5e1644c
--- /dev/null
+++ b/netx/net/sourceforge/jnlp/util/logging/LogConfig.java
@@ -0,0 +1,156 @@
+/* LogConfig.java
+ Copyright (C) 2011, 2013 Red Hat, Inc.
+
+ This file is part of IcedTea.
+
+ IcedTea is free software; you can redistribute it and/or
+ modify it under the terms of the GNU General Public License as published by
+ the Free Software Foundation, version 2.
+
+ IcedTea is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with IcedTea; see the file COPYING.  If not, write to
+ the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
+ 02110-1301 USA.
+
+ Linking this library statically or dynamically with other modules is
+ making a combined work based on this library.  Thus, the terms and
+ conditions of the GNU General Public License cover the whole
+ combination.
+
+ As a special exception, the copyright holders of this library give you
+ permission to link this library with independent modules to produce an
+ executable, regardless of the license terms of these independent
+ modules, and to copy and distribute the resulting executable under
+ terms of your choice, provided that you also meet, for each linked
+ independent module, the terms and conditions of the license of that
+ module.  An independent module is a module which is not derived from
+ or based on this library.  If you modify this library, you may extend
+ this exception to your version of the library, but you are not
+ obligated to do so.  If you do not wish to do so, delete this
+ exception statement from your version.
+ */
+package net.sourceforge.jnlp.util.logging;
+
+import java.io.File;
+import javax.naming.ConfigurationException;
+
+import net.sourceforge.jnlp.config.DeploymentConfiguration;
+import net.sourceforge.jnlp.runtime.JNLPRuntime;
+
+/**
+ * This file provides the information required to do logging.
+ *
+ */
+public class LogConfig {
+
+    // Directory where the logs are stored.
+    private String icedteaLogDir;
+    private boolean enableLogging;
+    private boolean enableHeaders;
+    private boolean logToFile;
+    private boolean logToStreams;
+    private boolean logToSysLog;
+    
+    private static LogConfig logConfig;
+
+    public LogConfig() {
+        try {
+            DeploymentConfiguration config = JNLPRuntime.getConfiguration();
+            if (config.getRaw().isEmpty()){
+                config = new DeploymentConfiguration();//JNLPRuntime.getConfiguration() cannotbe loaded time
+                config.load(); //read one prior
+                //todo fix JNLPRuntime.getConfiguration(); to be correct singleton - not easy task!
+            }
+
+            // Check whether logging and tracing is enabled.
+            enableLogging = Boolean.parseBoolean(config.getProperty(DeploymentConfiguration.KEY_ENABLE_LOGGING));
+            //enagle disable headers
+            enableHeaders = Boolean.parseBoolean(config.getProperty(DeploymentConfiguration.KEY_ENABLE_LOGGING_HEADERS));
+            //enable/disable individual channels
+            logToFile = Boolean.parseBoolean(config.getProperty(DeploymentConfiguration.KEY_ENABLE_LOGGING_TOFILE));
+            logToStreams = Boolean.parseBoolean(config.getProperty(DeploymentConfiguration.KEY_ENABLE_LOGGING_TOSTREAMS));
+            logToSysLog = Boolean.parseBoolean(config.getProperty(DeploymentConfiguration.KEY_ENABLE_LOGGING_TOSYSTEMLOG));
+
+            // Get log directory, create it if it doesn't exist. If unable to create and doesn't exist, don't log.
+            icedteaLogDir = config.getProperty(DeploymentConfiguration.KEY_USER_LOG_DIR);
+            if (icedteaLogDir != null) {
+                File f = new File(icedteaLogDir);
+                if (f.isDirectory() || f.mkdirs()) {
+                    icedteaLogDir += File.separator;
+                } else {
+                    enableLogging = false;
+                }
+            }
+        } catch (ConfigurationException e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    public static LogConfig getLogConfig() {
+        if (logConfig == null) {
+            logConfig = new LogConfig();
+        }
+        return logConfig;
+    }
+
+    public String getIcedteaLogDir() {
+        return icedteaLogDir;
+    }
+
+    public boolean isEnableLogging() {
+        return enableLogging;
+    }
+
+    public boolean isLogToFile() {
+        return logToFile;
+    }
+
+    public boolean isLogToStreams() {
+        return logToStreams;
+    }
+
+    public boolean isLogToSysLog() {
+        return logToSysLog;
+    }
+
+    public boolean isEnableHeaders() {
+        return enableHeaders;
+    }
+    
+    
+    
+    //package private setters for testing
+
+    void setEnableHeaders(boolean enableHeaders) {
+        this.enableHeaders = enableHeaders;
+    }
+
+    void setEnableLogging(boolean enableLogging) {
+        this.enableLogging = enableLogging;
+    }
+
+    void setIcedteaLogDir(String icedteaLogDir) {
+        this.icedteaLogDir = icedteaLogDir;
+    }
+
+    void setLogToFile(boolean logToFile) {
+        this.logToFile = logToFile;
+    }
+
+    void setLogToStreams(boolean logToStreams) {
+        this.logToStreams = logToStreams;
+    }
+
+    void setLogToSysLog(boolean logToSysLog) {
+        this.logToSysLog = logToSysLog;
+    }
+    
+    
+    
+    
+}
diff --git a/netx/net/sourceforge/jnlp/util/logging/OutputController.java b/netx/net/sourceforge/jnlp/util/logging/OutputController.java
new file mode 100644
index 0000000..1efc691
--- /dev/null
+++ b/netx/net/sourceforge/jnlp/util/logging/OutputController.java
@@ -0,0 +1,398 @@
+/*Copyright (C) 2013 Red Hat, Inc.
+
+ This file is part of IcedTea.
+
+ IcedTea is free software; you can redistribute it and/or
+ modify it under the terms of the GNU General Public License as published by
+ the Free Software Foundation, version 2.
+
+ IcedTea is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with IcedTea; see the file COPYING.  If not, write to
+ the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
+ 02110-1301 USA.
+
+ Linking this library statically or dynamically with other modules is
+ making a combined work based on this library.  Thus, the terms and
+ conditions of the GNU General Public License cover the whole
+ combination.
+
+ As a special exception, the copyright holders of this library give you
+ permission to link this library with independent modules to produce an
+ executable, regardless of the license terms of these independent
+ modules, and to copy and distribute the resulting executable under
+ terms of your choice, provided that you also meet, for each linked
+ independent module, the terms and conditions of the license of that
+ module.  An independent module is a module which is not derived from
+ or based on this library.  If you modify this library, you may extend
+ this exception to your version of the library, but you are not
+ obligated to do so.  If you do not wish to do so, delete this
+ exception statement from your version.
+ */
+package net.sourceforge.jnlp.util.logging;
+
+import java.io.PrintStream;
+import java.io.PrintWriter;
+import java.io.StringWriter;
+import java.util.Date;
+import java.util.LinkedList;
+import java.util.List;
+import net.sourceforge.jnlp.runtime.JNLPRuntime;
+
+public class OutputController {
+
+    public static enum Level {
+
+        MESSAGE_ALL, // - stdout/log in all cases
+        MESSAGE_DEBUG, // - stdout/log in verbose/debug mode
+        WARNING_ALL, // - stdout+stderr/log in all cases (default for
+        WARNING_DEBUG, // - stdou+stde/logrr in verbose/debug mode
+        ERROR_ALL, // - stderr/log in all cases (default for
+        ERROR_DEBUG, // - stderr/log in verbose/debug mode
+        //ERROR_DEBUG is default for Throwable
+        //MESSAGE_VERBOSE is defautrl  for String
+    }
+
+    private static final class MessageWithLevel {
+
+        public final String message;
+        public final Level level;
+        public final StackTraceElement[] stack = Thread.currentThread().getStackTrace();
+
+        public MessageWithLevel(String message, Level level) {
+            this.message = message;
+            this.level = level;
+        }
+    }
+    /*
+     * singleton instance
+     */
+    private static OutputController logger;
+    private static final String NULL_OBJECT = "Trying to log null object";
+    private FileLog fileLog;
+    private PrintStreamLogger outLog;
+    private PrintStreamLogger errLog;
+    private SingleStreamLogger sysLog;
+    private List<MessageWithLevel> messageQue = new LinkedList<MessageWithLevel>();
+    private MessageQueConsumer messageQueConsumer = new MessageQueConsumer();
+
+    //bounded to instance
+    private class MessageQueConsumer implements Runnable {
+
+        @Override
+        public void run() {
+            while (true) {
+                try {
+                    synchronized (OutputController.this) {
+                        OutputController.this.wait();
+                        if (!(OutputController.this == null || messageQue.isEmpty())) {
+                            flush();
+                        }
+                    }
+
+                } catch (Throwable t) {
+                    OutputController.getLogger().log(t);
+                }
+            }
+        }
+    };
+
+    public synchronized void flush() {
+
+        while (!messageQue.isEmpty()) {
+            consume();
+        }
+    }
+    
+    public void close() {
+        flush();
+        if (LogConfig.getLogConfig().isLogToFile()){
+            getFileLog().close();
+        }
+    }
+
+    private void consume() {
+        MessageWithLevel s = messageQue.get(0);
+        messageQue.remove(0);
+        if (!JNLPRuntime.isDebug() && (s.level == Level.MESSAGE_DEBUG
+                || s.level == Level.WARNING_DEBUG
+                || s.level == Level.ERROR_DEBUG)) {
+            //filter out debug messages
+            //must be here to prevent deadlock, casued by exception form jnlpruntime, loggers or configs themselves
+            return;
+        }
+        String message = s.message;
+        if (LogConfig.getLogConfig().isEnableHeaders()) {
+            if (message.contains("\n")) {
+                message = getHeader(s.level, s.stack) + "\n" + message;
+            } else {
+                message = getHeader(s.level, s.stack) + " " + message;
+            }
+        }
+        if (LogConfig.getLogConfig().isLogToStreams()) {
+            if (s.level == Level.MESSAGE_ALL
+                    || s.level == Level.MESSAGE_DEBUG
+                    || s.level == Level.WARNING_ALL
+                    || s.level == Level.WARNING_DEBUG) {
+                outLog.log(message);
+            }
+            if (s.level == Level.ERROR_ALL
+                    || s.level == Level.ERROR_DEBUG
+                    || s.level == Level.WARNING_ALL
+                    || s.level == Level.WARNING_DEBUG) {
+                errLog.log(message);
+            }
+        }
+        if (LogConfig.getLogConfig().isLogToFile()) {
+            getFileLog().log(message);
+        }
+        if (LogConfig.getLogConfig().isLogToSysLog()) {
+            getSystemLog().log(message);
+        }
+
+    }
+
+    private OutputController() {
+        this(System.out, System.err);
+    }
+
+    /**
+     * This should be the only legal way to get logger for ITW
+     *
+     * @return logging singleton
+     */
+    synchronized public static OutputController getLogger() {
+        if (logger == null) {
+            logger = new OutputController();
+        }
+        return logger;
+    }
+
+    /**
+     * for testing purposes the logger with custom streams can be created
+     * otherwise only getLogger()'s singleton can be called.
+     */
+     public OutputController(PrintStream out, PrintStream err) {
+        if (out == null || err == null) {
+            throw new IllegalArgumentException("No stream can be null");
+        }
+        outLog = new PrintStreamLogger(out);
+        errLog = new PrintStreamLogger(err);
+        //itw logger have to be fully initialised before start
+        Thread t = new Thread(messageQueConsumer);
+        t.setDaemon(true);
+        t.start();
+        //some messages were probably posted before start of consumer
+        synchronized (this){
+            this.notifyAll();
+        }
+        Runtime.getRuntime().addShutdownHook(new Thread(new Runnable() {
+            @Override
+            public void run() {
+                while (!messageQue.isEmpty()) {
+                    consume();
+                }
+            }
+        }));
+    }
+
+    /**
+     *
+     * @return current stream for std.out reprint
+     */
+    public PrintStream getOut() {
+        flush();
+        return outLog.getStream();
+    }
+
+    /**
+     *
+     * @return current stream for std.err reprint
+     */
+    public PrintStream getErr() {
+        flush();
+        return errLog.getStream();
+    }
+
+    /**
+     * Some tests may require set the output stream and check the output. This
+     * is the gate for it.
+     */
+    public void setOut(PrintStream out) {
+        flush();
+        this.outLog.setStream(out);
+    }
+
+    /**
+     * Some tests may require set the output stream and check the output. This
+     * is the gate for it.
+     */
+    public void setErr(PrintStream err) {
+        flush();
+        this.errLog.setStream(err);
+    }
+
+    public static String exceptionToString(Throwable t) {
+        if (t == null) {
+            return null;
+        }
+        String s = "Error during processing of exception";
+        try {
+            StringWriter sw = new StringWriter();
+            PrintWriter pw = new PrintWriter(sw);
+            t.printStackTrace(pw);
+            s = sw.toString();
+            pw.close();
+            sw.close();
+        } catch (Exception ex) {
+            throw new RuntimeException(ex);
+        }
+        return s;
+    }
+
+    public void log(Level level, String s) {
+        log(level, (Object) s);
+    }
+
+    public void log(Level level, Throwable s) {
+        log(level, (Object) s);
+    }
+
+    public void log(String s) {
+        log(Level.MESSAGE_DEBUG, (Object) s);
+    }
+
+    public void log(Throwable s) {
+        log(Level.ERROR_DEBUG, (Object) s);
+    }
+
+    private synchronized void log(Level level, Object o) {
+        if (o == null) {
+            messageQue.add(new MessageWithLevel(NULL_OBJECT, level));
+        } else if (o instanceof Throwable) {
+            messageQue.add(new MessageWithLevel(exceptionToString((Throwable) o), level));
+        } else {
+            messageQue.add(new MessageWithLevel(o.toString(), level));
+        }
+        this.notifyAll();
+    }
+
+    private FileLog getFileLog() {
+        if (fileLog == null) {
+            fileLog = new FileLog();
+        }
+        return fileLog;
+    }
+
+    private SingleStreamLogger getSystemLog() {
+        if (sysLog == null) {
+            if (JNLPRuntime.isWindows()) {
+                sysLog = new WinSystemLog();
+            } else {
+                sysLog = new UnixSystemLog();
+            }
+        }
+        return sysLog;
+    }
+
+    public void printErrorLn(String e) {
+        getErr().println(e);
+
+    }
+
+    public void printOutLn(String e) {
+        getOut().println(e);
+
+    }
+
+    public void printWarningLn(String e) {
+        printOutLn(e);
+        printErrorLn(e);
+    }
+
+    public void printError(String e) {
+        getErr().print(e);
+
+    }
+
+    public void printOut(String e) {
+        getOut().print(e);
+
+    }
+
+    public void printWarning(String e) {
+        printOut(e);
+        printError(e);
+    }
+
+    public static String getHeader(Level level, StackTraceElement[] stack) {
+        StringBuilder sb = new StringBuilder();
+        try {
+            String user = System.getProperty("user.name");
+            sb.append("[").append(user).append("]");
+            if (JNLPRuntime.isWebstartApplication()) {
+                sb.append("[ITW-JAVAWS]");
+            } else {
+                sb.append("[ITW]");
+            }
+            if (level != null) {
+                sb.append('[').append(level.toString()).append(']');
+            }
+            sb.append('[').append(new Date().toString()).append(']');
+            if (stack != null) {
+                sb.append('[').append(getCallerClass(stack)).append(']');
+            }
+        } catch (Exception ex) {
+            getLogger().log(ex);
+        }
+        return sb.toString();
+
+    }
+
+    static String getCallerClass(StackTraceElement[] stack) {
+        try {
+            //0 is always thread
+            //1..? is OutputController itself
+            //pick up first after.
+            StackTraceElement result = stack[0];
+            int i = 1;
+            for (; i < stack.length; i++) {
+                result = stack[i];//at least moving up
+                if (stack[i].getClassName().contains(OutputController.class.getName())) {
+                    continue;
+                } else {
+                    break;
+                }
+            }
+            return result.toString();
+        } catch (Exception ex) {
+            getLogger().log(ex);
+            return "Unknown caller";
+        }
+    }
+    
+    
+   //package private setters for testing
+
+    void setErrLog(PrintStreamLogger errLog) {
+        this.errLog = errLog;
+    }
+
+    void setFileLog(FileLog fileLog) {
+        this.fileLog = fileLog;
+    }
+
+    void setOutLog(PrintStreamLogger outLog) {
+        this.outLog = outLog;
+    }
+
+    void setSysLog(SingleStreamLogger sysLog) {
+        this.sysLog = sysLog;
+    }
+    
+    
+}
diff --git a/netx/net/sourceforge/jnlp/util/logging/PrintStreamLogger.java b/netx/net/sourceforge/jnlp/util/logging/PrintStreamLogger.java
new file mode 100644
index 0000000..2cba912
--- /dev/null
+++ b/netx/net/sourceforge/jnlp/util/logging/PrintStreamLogger.java
@@ -0,0 +1,68 @@
+/*Copyright (C) 2013 Red Hat, Inc.
+
+ This file is part of IcedTea.
+
+ IcedTea is free software; you can redistribute it and/or
+ modify it under the terms of the GNU General Public License as published by
+ the Free Software Foundation, version 2.
+
+ IcedTea is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with IcedTea; see the file COPYING.  If not, write to
+ the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
+ 02110-1301 USA.
+
+ Linking this library statically or dynamically with other modules is
+ making a combined work based on this library.  Thus, the terms and
+ conditions of the GNU General Public License cover the whole
+ combination.
+
+ As a special exception, the copyright holders of this library give you
+ permission to link this library with independent modules to produce an
+ executable, regardless of the license terms of these independent
+ modules, and to copy and distribute the resulting executable under
+ terms of your choice, provided that you also meet, for each linked
+ independent module, the terms and conditions of the license of that
+ module.  An independent module is a module which is not derived from
+ or based on this library.  If you modify this library, you may extend
+ this exception to your version of the library, but you are not
+ obligated to do so.  If you do not wish to do so, delete this
+ exception statement from your version.
+ */
+
+package net.sourceforge.jnlp.util.logging;
+
+import java.io.PrintStream;
+
+public class PrintStreamLogger implements SingleStreamLogger{
+    private  PrintStream stream;
+
+    public PrintStreamLogger(PrintStream stream){
+        this.stream = stream;
+    }
+    
+
+    @Override
+    public void log(String s) {
+        stream.println(s);
+    }
+
+    public PrintStream getStream() {
+        return stream;
+    }
+
+    public void setStream(PrintStream stream) {
+        this.stream = stream;
+    }
+    
+    
+ 
+    
+      
+
+
+}
diff --git a/netx/net/sourceforge/jnlp/util/logging/SingleStreamLogger.java b/netx/net/sourceforge/jnlp/util/logging/SingleStreamLogger.java
new file mode 100644
index 0000000..6e34b99
--- /dev/null
+++ b/netx/net/sourceforge/jnlp/util/logging/SingleStreamLogger.java
@@ -0,0 +1,46 @@
+/*Copyright (C) 2013 Red Hat, Inc.
+
+ This file is part of IcedTea.
+
+ IcedTea is free software; you can redistribute it and/or
+ modify it under the terms of the GNU General Public License as published by
+ the Free Software Foundation, version 2.
+
+ IcedTea is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with IcedTea; see the file COPYING.  If not, write to
+ the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
+ 02110-1301 USA.
+
+ Linking this library statically or dynamically with other modules is
+ making a combined work based on this library.  Thus, the terms and
+ conditions of the GNU General Public License cover the whole
+ combination.
+
+ As a special exception, the copyright holders of this library give you
+ permission to link this library with independent modules to produce an
+ executable, regardless of the license terms of these independent
+ modules, and to copy and distribute the resulting executable under
+ terms of your choice, provided that you also meet, for each linked
+ independent module, the terms and conditions of the license of that
+ module.  An independent module is a module which is not derived from
+ or based on this library.  If you modify this library, you may extend
+ this exception to your version of the library, but you are not
+ obligated to do so.  If you do not wish to do so, delete this
+ exception statement from your version.
+ */
+
+package net.sourceforge.jnlp.util.logging;
+
+public interface SingleStreamLogger {
+ 
+    
+     
+      public  void log(String s);
+
+
+}
diff --git a/netx/net/sourceforge/jnlp/util/logging/UnixSystemLog.java b/netx/net/sourceforge/jnlp/util/logging/UnixSystemLog.java
new file mode 100644
index 0000000..157d91f
--- /dev/null
+++ b/netx/net/sourceforge/jnlp/util/logging/UnixSystemLog.java
@@ -0,0 +1,57 @@
+/*Copyright (C) 2013 Red Hat, Inc.
+
+ This file is part of IcedTea.
+
+ IcedTea is free software; you can redistribute it and/or
+ modify it under the terms of the GNU General Public License as published by
+ the Free Software Foundation, version 2.
+
+ IcedTea is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with IcedTea; see the file COPYING.  If not, write to
+ the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
+ 02110-1301 USA.
+
+ Linking this library statically or dynamically with other modules is
+ making a combined work based on this library.  Thus, the terms and
+ conditions of the GNU General Public License cover the whole
+ combination.
+
+ As a special exception, the copyright holders of this library give you
+ permission to link this library with independent modules to produce an
+ executable, regardless of the license terms of these independent
+ modules, and to copy and distribute the resulting executable under
+ terms of your choice, provided that you also meet, for each linked
+ independent module, the terms and conditions of the license of that
+ module.  An independent module is a module which is not derived from
+ or based on this library.  If you modify this library, you may extend
+ this exception to your version of the library, but you are not
+ obligated to do so.  If you do not wish to do so, delete this
+ exception statement from your version.
+ */
+
+package net.sourceforge.jnlp.util.logging;
+
+
+
+public class UnixSystemLog implements SingleStreamLogger{
+    
+    public UnixSystemLog(){
+    
+    }
+    
+ 
+    @Override
+    public void log(String s) {
+        
+    }
+ 
+    
+      
+
+
+}
diff --git a/netx/net/sourceforge/jnlp/util/logging/WinSystemLog.java b/netx/net/sourceforge/jnlp/util/logging/WinSystemLog.java
new file mode 100644
index 0000000..59f015b
--- /dev/null
+++ b/netx/net/sourceforge/jnlp/util/logging/WinSystemLog.java
@@ -0,0 +1,57 @@
+/*Copyright (C) 2013 Red Hat, Inc.
+
+ This file is part of IcedTea.
+
+ IcedTea is free software; you can redistribute it and/or
+ modify it under the terms of the GNU General Public License as published by
+ the Free Software Foundation, version 2.
+
+ IcedTea is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with IcedTea; see the file COPYING.  If not, write to
+ the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
+ 02110-1301 USA.
+
+ Linking this library statically or dynamically with other modules is
+ making a combined work based on this library.  Thus, the terms and
+ conditions of the GNU General Public License cover the whole
+ combination.
+
+ As a special exception, the copyright holders of this library give you
+ permission to link this library with independent modules to produce an
+ executable, regardless of the license terms of these independent
+ modules, and to copy and distribute the resulting executable under
+ terms of your choice, provided that you also meet, for each linked
+ independent module, the terms and conditions of the license of that
+ module.  An independent module is a module which is not derived from
+ or based on this library.  If you modify this library, you may extend
+ this exception to your version of the library, but you are not
+ obligated to do so.  If you do not wish to do so, delete this
+ exception statement from your version.
+ */
+
+package net.sourceforge.jnlp.util.logging;
+
+
+
+public class WinSystemLog implements SingleStreamLogger{
+    
+    public WinSystemLog(){
+    
+    }
+    
+ 
+    @Override
+    public void log(String s) {
+     //not yet implemented   
+    }
+ 
+    
+      
+
+
+}