Working revision

Author: CarolynRountree

core/src/main/java/oracle/weblogic/deploy/logging/SummaryHandler.java

@@ -1,69 +1,69 @@
 package oracle.weblogic.deploy.logging;
 
-import java.util.ArrayList;
-import java.util.List;
-import java.util.Properties;
+import java.text.MessageFormat;
+import java.util.*;
 import java.util.logging.*;
+import java.util.logging.Formatter;
 
 
 public class SummaryHandler extends MemoryHandler implements WLSDeployLogEndHandler {
     private static final String CLASS = SummaryHandler.class.getName();
-    private static final PlatformLogger LOGGER = WLSDeployLogFactory.getLogger("wlsdeploy");
     private static final String LEVEL_PROPERTY = "level";
     private static final String TARGET_PROPERTY = "target";
+    private static final String FORMATTER_PROPERTY = "formatter";
     private static final String SIZE_PROPERTY = "size";
     private static final int DEFAULT_SIZE = 3000;
+    private static final String LINE_SEPARATION = System.lineSeparator();
 
+    private PlatformLogger LOGGER = WLSDeployLogFactory.getLogger("wlsdeploy.exit");
     private boolean online = false;
     private int bufferSize;
 
-    private LevelHandler infoMemoryHandler = new NoActionHandler(Level.INFO);
-    private LevelHandler warnMemoryHandler = new NoActionHandler(Level.WARNING);
-    private LevelHandler errMemoryHandler = new NoActionHandler(Level.SEVERE);
-    private LevelHandler[] handlers = {infoMemoryHandler, warnMemoryHandler, errMemoryHandler};
+    private Handler target;
+    private List<LevelHandler> handlers = new ArrayList<>();
     private boolean closed = false;
 
     public SummaryHandler() {
         super();
         configure();
-        infoMemoryHandler = getLevelHandler(Level.INFO);
-        infoMemoryHandler = getLevelHandler(Level.WARNING);
-        infoMemoryHandler = getLevelHandler(Level.SEVERE);
+        target = getConsoleHandler();
+        LOGGER.setLevel(Level.INFO);
+        addLevelHandler(Level.INFO);
+        addLevelHandler(Level.WARNING);
+        addLevelHandler(Level.SEVERE);
+        System.out.println("*** summary handler");
     }
 
     @Override
     public synchronized void publish(LogRecord record) {
         // after close, take yourself out of the mix. The stored up log messages are going to go to the
         // console handler anyway
         if (!closed) {
-            infoMemoryHandler.publish(record);
-            warnMemoryHandler.publish(record);
-            errMemoryHandler.publish(record);
+            for (Handler handler : handlers) {
+                handler.publish(record);
+            }
         }
     }
 
     @Override
     public synchronized void push() {
+        System.out.println("i am in push ");
         String METHOD = "push";
         LOGGER.entering(CLASS, METHOD);
         closed = true;
-        List<Integer> counts = new ArrayList<>();
+        setPushLevel(getLevel());
+        StringBuffer buffer = new StringBuffer();
+        java.util.Formatter fmt = new java.util.Formatter(buffer);
         for (LevelHandler handler : handlers) {
             int count = handler.pushSection();
+            super.push();
             if (count >= 0) {
-                counts.add(count);
+                fmt.format("  %1$s : %2$,5d", handler.getLevel().getName(), count);
             }
         }
-        int size = counts.size();
-        String msgNbr = "WLSDPLY-21004";
-        if (size == 2) {
-            msgNbr = "WLSDPLY-21003";
-        } else if (size == 3) {
-            msgNbr = "WLSDPLY-21002";
-        }
-        // got to fix this as this isn't allowed ? check to see if it resolves the msg nbr. Is this going to be 1 arg?
-        LOGGER.log(Level.ALL, msgNbr, (Object[])counts.toArray(new Object[size]));
-        LOGGER.exiting(CLASS, METHOD);
+
+        System.out.println(LINE_SEPARATION);
+        target.publish(getLogRecord("WLSDPLY-21002", buffer));
     }
 
     @Override
@@ -93,48 +93,41 @@ public void logEnd(boolean online) {
     /**
      * The WLSDeployLoggingConfig will call this method to add to the logging.properties files.
      * If the logging.properties already contains the property, the property in this list will be ignored.
+     *
      * @return properties to set in logging.properties
      */
     public static Properties getHandlerProperties() {
-        String METHOD = "getHandlerProperties";
-        LOGGER.entering(CLASS, METHOD);
         Properties properties = new Properties();
         properties.setProperty(LEVEL_PROPERTY, Level.INFO.getName());
         properties.setProperty(TARGET_PROPERTY, WLSDeployLoggingConsoleHandler.class.getName());
-        LOGGER.exiting(CLASS, METHOD, properties);
+        properties.setProperty(FORMATTER_PROPERTY, SummaryFormatter.class.getName());
         return properties;
     }
 
-    private class SummaryFormatter extends Formatter {
+    public class SummaryFormatter extends Formatter {
         public synchronized String format(LogRecord logRecord) {
             // for now, only format the message in summary - maybe add logger name or other later
             return formatMessage(logRecord);
         }
     }
 
-    private LevelHandler getLevelHandler(Level compareTo) {
-        LevelHandler handler;
-        if (getLevel().intValue() <= compareTo.intValue()) {
-            handler = new LevelHandler(this, bufferSize, Level.ALL);
-            setLevel(compareTo);
-            setFilter(getFilter());
-            setFormatter(new SummaryFormatter());
-        } else {
-            handler = new NoActionHandler(compareTo);
+    private void addLevelHandler(Level level) {
+        LevelHandler handler = null;
+        if (getLevel().intValue() <= level.intValue()) {
+            handler = new LevelHandler(target, bufferSize, level);
+            handler.setLevel(level);
+            handler.setFilter(getFilter());
+            //handler.setFormatter(new SummaryFormatter());
+            handlers.add(handler);
         }
-        return handler;
     }
 
     private class LevelHandler extends MemoryHandler {
 
         private int totalRecords;
 
         LevelHandler(Handler handler, int size, Level level) {
-            super(handler, size, Level.ALL);
-            setLevel(level);
-        }
-
-        LevelHandler(Level level) {
+            super(handler, size, Level.OFF);
             setLevel(level);
         }
 
@@ -146,7 +139,7 @@ public synchronized void publish(LogRecord record) {
             }
         }
 
-        public int pushSection() {
+        public synchronized int pushSection() {
             if (isOnline()) {
                 logStart();
                 super.push();
@@ -160,18 +153,23 @@ int getTotalRecords() {
         }
 
         void logStart() {
-            LOGGER.log(Level.ALL, "WLSDPLY-2100", getLevel().getName());
+            if (getTotalRecords() > 0) {
+                System.out.println(LINE_SEPARATION);
+                target.publish(getLogRecord("WLSDPLY-21000", getLevel().getName()));
+                System.out.println(LINE_SEPARATION);
+            }
         }
 
         void logEnd() {
-            LOGGER.log(Level.ALL, "WLSDPLY-2101", getLevel().getName(), getTotalRecords());
+            System.out.println(LINE_SEPARATION);
+            target.publish(getLogRecord("WLSDPLY-21001", getLevel().getName(), getTotalRecords()));
         }
     }
 
     private class NoActionHandler extends LevelHandler {
 
-        NoActionHandler(Level level) {
-            super(level);
+        NoActionHandler(Handler handler, int size, Level level) {
+            super(handler, size, level);
         }
 
 
@@ -233,4 +231,27 @@ private int getSize(String propSize) {
         return handlerSize;
     }
 
+    private ConsoleHandler getConsoleHandler() {
+        ConsoleHandler handler = null;
+        try {
+            handler = (ConsoleHandler) Class.forName(WLSDeployLoggingConfig.getConsoleHandler()).newInstance();
+        } catch (ClassNotFoundException | IllegalAccessException cne) {
+            System.out.println("Class not found " + WLSDeployLoggingConfig.getConsoleHandler());
+        } catch (InstantiationException ie) {
+            handler = new ConsoleHandler();
+        }
+        return handler;
+    }
+
+    private LogRecord getLogRecord(String msg, Object... params) {
+        LogRecord record = new LogRecord(Level.INFO, msg);
+        record.setLoggerName(LOGGER.getName());
+        if (params != null && params.length != 0) {
+            record.setParameters(params);
+        }
+        record.setSourceClassName(CLASS);
+        record.setSourceMethodName("");
+        record.setResourceBundle(LOGGER.getUnderlyingLogger().getResourceBundle());
+        return record;
+    }
 }

core/src/main/java/oracle/weblogic/deploy/logging/WLSDeployCustomizeLoggingConfig.java

@@ -0,0 +1,97 @@
+package oracle.weblogic.deploy.logging;
+
+import oracle.weblogic.deploy.util.StringUtils;
+
+import java.lang.reflect.Method;
+import java.text.MessageFormat;
+import java.util.*;
+import java.util.logging.Handler;
+
+public class WLSDeployCustomizeLoggingConfig extends WLSDeployLoggingConfig {
+
+    private static final String WLSDEPLOY_HANDLER_PROP = WLSDEPLOY_LOGGER_NAME + ".handlers";
+    private static final String WLSDEPLOY_HANDLER_METHOD = "getHandlerProperties";
+
+    @Override
+    public void customizeLoggingProperties(String programName, Properties logProps) {
+        List<Class<?>> classList  = new ArrayList<>();
+        for (String handlerName : findExtraHandlers(logProps)) {
+            classList.add(getHandlerClass(handlerName));
+        }
+        List<String> handlerList = new ArrayList<>();
+        for (Class<?> handler : classList) {
+            handlerList.add(handler.getName());
+            addHandlerProperties(logProps, handler);
+        }
+        logProps.setProperty(WLSDEPLOY_HANDLER_PROP, StringUtils.getCommaSeparatedListString(handlerList));
+    }
+
+    private static Set<String> findExtraHandlers(Properties logProps) {
+        // The handlers are applied in order - process environment variable first, then logging properties
+        Set<String> handlers = new HashSet<>();
+        String[] addTo = StringUtils.splitCommaSeparatedList(System.getenv(WLSDEPLOY_LOG_HANDLERS_ENV_VARIABLE));
+        if (addTo.length > 0) {
+            handlers.addAll(Arrays.asList(addTo));
+        }
+        addTo = StringUtils.splitCommaSeparatedList(logProps.getProperty(WLSDEPLOY_HANDLER_PROP));
+        if (addTo.length > 0) {
+            handlers.addAll(Arrays.asList(addTo));
+        }
+        return handlers;
+    }
+    private static Class<?> getHandlerClass(String handlerName) {
+        String message = null;
+        Class<?> handler = null;
+        try {
+            handler = Class.forName(handlerName);
+            if (!Handler.class.isAssignableFrom(handler)) {
+                message = MessageFormat.format("Class {0} is not a Handler", handlerName);
+            }
+        } catch(ClassNotFoundException cnf) {
+            message = MessageFormat.format("Unable to find handler class {0} so skipping logging configuration",
+                    handlerName);
+        }
+        if (message != null) {
+            System.err.println(message);
+            System.exit(ERROR_EXIT_CODE);
+        }
+        return handler;
+    }
+
+    private static void addHandlerProperties(Properties logProps, Class<?> clazz) {
+        Properties props = null;
+        // a forEach would be good here!
+        String clazzName = clazz.getName();
+        // make sure some formatter is set
+        //logProps.setProperty(clazzName + HANDLER_FORMATTER_PROP, LOG_FORMATTER);
+        Set<String> propSet = logProps.stringPropertyNames();
+        try {
+            // only look in this class
+            Method method = clazz.getDeclaredMethod(WLSDEPLOY_HANDLER_METHOD);
+            props =  (Properties)method.invoke(null);
+        } catch (NoSuchMethodException nsm) {
+            return;
+        } catch (Exception e) {
+            String message = MessageFormat.format("Unable to successfully populate properties for handler {0} " +
+                    "so skipping logging configuration : {1}", clazzName, e.getLocalizedMessage());
+            System.err.println(message);
+            System.exit(ERROR_EXIT_CODE);
+        }
+
+        if (props != null) {
+            for (Map.Entry<?, ?> listItem : props.entrySet()) {
+                if (listItem.getKey() instanceof String && listItem.getValue() instanceof String) {
+                    // requires the handler property name without the handler class name
+                    // this method will add the class to make sure the handler is not setting global properties
+                    // or properties for other handlers
+                    String property = clazzName + '.' + listItem.getKey();
+                    if (!propSet.contains(property)) {
+                        // logging.properties property takes precedent
+                        logProps.setProperty(property, (String)listItem.getValue());
+                    }
+                }
+            }
+        }
+    }
+
+}

core/src/main/java/oracle/weblogic/deploy/logging/WLSDeployLogEndHandler.java

@@ -9,7 +9,7 @@
  * before ending within a weblogic deploy tool. A class that implements this interface should include
  * the appropriate wrap-up action in the logEnd method.
  *
- * The corresponding WLSDeployBeforeExitAction will look through the Handlers on the LogManager and call the logEnd
+ * The corresponding WLSDeployExit will look through the Handlers on the LogManager and call the logEnd
  * method if the interface is implemented.
  */
 public interface WLSDeployLogEndHandler {