diff --git a/netx/net/sourceforge/jnlp/AppletLog.java b/netx/net/sourceforge/jnlp/AppletLog.java deleted file mode 100644 --- a/netx/net/sourceforge/jnlp/AppletLog.java +++ /dev/null @@ -1,92 +0,0 @@ -/* AppletLog.java - Copyright (C) 2011 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; - -import java.io.ByteArrayOutputStream; -import java.io.File; -import java.io.PrintStream; -import java.util.logging.FileHandler; -import java.util.logging.Level; -import java.util.logging.Logger; -import java.util.logging.XMLFormatter; - -import net.sourceforge.jnlp.util.FileUtils; - -/** - * This class writes log information to file. - * - * @author Andrew Su (asu@redhat.com, andrew.su@utoronto.ca) - * - */ -class AppletLog extends Log { - private static Logger logger; - static { - try { - // If logging is enabled, we create logger. - if (enableLogging) { - String fn = icedteaLogDir + "plugin" + java.lang.System.currentTimeMillis() + ".log"; - FileUtils.createRestrictedFile(new File(fn), true); - FileHandler fh = new FileHandler(fn, false); - fh.setFormatter(new XMLFormatter()); - String logClassName = AppletLog.class.getName(); - logger = Logger.getLogger(logClassName); - logger.setLevel(Level.ALL); - logger.addHandler(fh); - } - } catch (Exception e) { - e.printStackTrace(); - } - } - - private AppletLog() { - } - - /** - * Log the exception to file. - * - * @param e Exception that was thrown. - */ - public synchronized static void log(Throwable e) { - if (enableLogging && logger != null) { - ByteArrayOutputStream baos = new ByteArrayOutputStream(); - PrintStream ps = new PrintStream(baos); - e.printStackTrace(ps); - logger.log(Level.FINE, baos.toString()); - } - } -} diff --git a/netx/net/sourceforge/jnlp/Log.java b/netx/net/sourceforge/jnlp/Log.java deleted file mode 100644 --- a/netx/net/sourceforge/jnlp/Log.java +++ /dev/null @@ -1,79 +0,0 @@ -/* Log.java - Copyright (C) 2011 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; - -import java.io.File; - -import net.sourceforge.jnlp.config.DeploymentConfiguration; -import net.sourceforge.jnlp.runtime.JNLPRuntime; - -/** - * This file provides the information required to do logging. - * - * @author Andrew Su (asu@redhat.com, andrew.su@utoronto.ca) - * - */ -abstract class Log { - - // Directory where the logs are stored. - protected static String icedteaLogDir; - - protected static boolean enableLogging = false; - protected static boolean enableTracing = false; - - // Prepare for logging. - static { - DeploymentConfiguration config = JNLPRuntime.getConfiguration(); - - // Check whether logging and tracing is enabled. - enableLogging = Boolean.parseBoolean(config.getProperty(DeploymentConfiguration.KEY_ENABLE_LOGGING)); - enableTracing = Boolean.parseBoolean(config.getProperty(DeploymentConfiguration.KEY_ENABLE_TRACING)); - - // 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; - enableTracing = false; - } - } - } -} diff --git a/netx/net/sourceforge/jnlp/util/logging/FileLog.java b/netx/net/sourceforge/jnlp/util/logging/FileLog.java new file mode 100644 --- /dev/null +++ b/netx/net/sourceforge/jnlp/util/logging/FileLog.java @@ -0,0 +1,92 @@ +/* FileLog.java + Copyright (C) 2011 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. + * + * retired log used to log into separate file + * + * + * + */ +public class FileLog implements SingleStreamLogger { + + private Logger impl; + + public FileLog() { + this(LogConfig.getLogConfig().getIcedteaLogDir() + "itw-" + java.lang.System.currentTimeMillis() + ".log"); + } + + public FileLog(String fileName) { + try{ + FileUtils.createRestrictedFile(new File(fileName), true); + FileHandler fh = new FileHandler(fileName, false); + fh.setFormatter(new Formatter() { + @Override + public String format(LogRecord record) { + return record.getMessage() + "\n"; + } + }); + impl = Logger.getLogger("IcedTea-Web file-logger"); + 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); + } +} diff --git a/netx/net/sourceforge/jnlp/util/logging/LogConfig.java b/netx/net/sourceforge/jnlp/util/logging/LogConfig.java new file mode 100644 --- /dev/null +++ b/netx/net/sourceforge/jnlp/util/logging/LogConfig.java @@ -0,0 +1,130 @@ +/* LogConfig.java + Copyright (C) 2011 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; + } + + + + +} diff --git a/netx/net/sourceforge/jnlp/util/logging/OutputController.java b/netx/net/sourceforge/jnlp/util/logging/OutputController.java new file mode 100644 --- /dev/null +++ b/netx/net/sourceforge/jnlp/util/logging/OutputController.java @@ -0,0 +1,368 @@ +/*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 messageQue = new LinkedList(); + 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())) { + consume(); + } + } + + } catch (Throwable t) { + OutputController.getLogger().log(t); + } + } + } + }; + + public synchronized void flush() { + + while (!messageQue.isEmpty()) { + consume(); + } + } + + 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. + */ + protected OutputController(PrintStream out, PrintStream err) { + if (out == null || err == null) { + throw new IllegalArgumentException("No stream canbe null"); + } + outLog = new PrintStreamLogger(out); + errLog = new PrintStreamLogger(err); + //itw logger have to be fully initialised before start + new Thread(messageQueConsumer).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 SingleStreamLogger 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"; + } + } +} diff --git a/netx/net/sourceforge/jnlp/util/logging/PrintStreamLogger.java b/netx/net/sourceforge/jnlp/util/logging/PrintStreamLogger.java new file mode 100644 --- /dev/null +++ b/netx/net/sourceforge/jnlp/util/logging/PrintStreamLogger.java @@ -0,0 +1,68 @@ +/*Copyright (C) 2011 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 --- /dev/null +++ b/netx/net/sourceforge/jnlp/util/logging/SingleStreamLogger.java @@ -0,0 +1,46 @@ +/*Copyright (C) 2011 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 --- /dev/null +++ b/netx/net/sourceforge/jnlp/util/logging/UnixSystemLog.java @@ -0,0 +1,57 @@ +/*Copyright (C) 2011 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 --- /dev/null +++ b/netx/net/sourceforge/jnlp/util/logging/WinSystemLog.java @@ -0,0 +1,57 @@ +/*Copyright (C) 2011 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 + } + + + + + +}