LogWrapper.java

/*
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 *
 *   http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 */
package org.apache.felix.coordinator.impl;

import java.util.Comparator;
import java.util.Iterator;
import java.util.Set;
import java.util.TreeSet;

import org.osgi.framework.BundleContext;
import org.osgi.framework.BundleException;
import org.osgi.framework.Constants;
import org.osgi.framework.InvalidSyntaxException;
import org.osgi.framework.ServiceEvent;
import org.osgi.framework.ServiceListener;
import org.osgi.framework.ServiceReference;

/**
 * This class mimics the standard OSGi <tt>LogService</tt> interface. It logs to an
 * available log service with the highest service ranking.
 *
 * @see org.osgi.service.log.LogService
**/
public class LogWrapper
{
    /**
     * ERROR LEVEL
     *
     * @see org.osgi.service.log.LogService#LOG_ERROR
     */
    public static final int LOG_ERROR = 1;

    /**
     * WARNING LEVEL
     *
     * @see org.osgi.service.log.LogService#LOG_WARNING
     */
    public static final int LOG_WARNING = 2;

    /**
     * INFO LEVEL
     *
     * @see org.osgi.service.log.LogService#LOG_INFO
     */
    public static final int LOG_INFO = 3;

    /**
     * DEBUG LEVEL
     *
     * @see org.osgi.service.log.LogService#LOG_DEBUG
     */
    public static final int LOG_DEBUG = 4;

    /** A sorted set containing the currently available LogServices.
     * Furthermore used as lock
     */
    private final Set<ServiceReference> loggerRefs = new TreeSet<ServiceReference>(
            new Comparator<ServiceReference>() {

                public int compare(ServiceReference o1, ServiceReference o2) {
                    return o2.compareTo(o1);
                }

            });

    /**
     *  Only null while not set and loggerRefs is empty hence, only needs to be
     *  checked in case m_loggerRefs is empty otherwise it will not be null.
     */
    private BundleContext context;

    private ServiceListener logServiceListener;

    /**
     * Current log level. Message with log level less than or equal to
     * current log level will be logged.
     * The default value is {@link #LOG_WARNING}
     *
     * @see #setLogLevel(int)
     */
    private int logLevel = LOG_WARNING;

    /**
     * Create the singleton
     */
    private static class LogWrapperLoader
    {
        static final LogWrapper SINGLETON = new LogWrapper();
    }

    /**
     * Returns the singleton instance of this LogWrapper that can be used to send
     * log messages to all currently available LogServices or to standard output,
     * respectively.
     *
     * @return the singleton instance of this LogWrapper.
     */
    public static LogWrapper getLogger()
    {
        return LogWrapperLoader.SINGLETON;
    }

    /**
     * Set the <tt>BundleContext</tt> of the bundle. This method registers a service
     * listener for LogServices with the framework that are subsequently used to
     * log messages.
     * <p>
     * If the bundle context is <code>null</code>, the service listener is
     * unregistered and all remaining references to LogServices dropped before
     * internally clearing the bundle context field.
     *
     *  @param context The context of the bundle.
     */
    public static void setContext( final BundleContext context )
    {
        final LogWrapper logWrapper = LogWrapperLoader.SINGLETON;

        // context is removed, unregister and drop references
        if ( context == null )
        {
            if ( logWrapper.logServiceListener != null )
            {
                logWrapper.context.removeServiceListener( logWrapper.logServiceListener );
                logWrapper.logServiceListener = null;
            }
            logWrapper.removeLoggerRefs();
        }

        // set field
        logWrapper.setBundleContext( context );

        // context is set, register and get existing services
        if ( context != null )
        {
            try
            {
                final ServiceListener listener = new ServiceListener()
                {
                    // Add a newly available LogService reference to the singleton.
                    public void serviceChanged( final ServiceEvent event )
                    {
                        if ( ServiceEvent.REGISTERED == event.getType() )
                        {
                            LogWrapperLoader.SINGLETON.addLoggerRef( event.getServiceReference() );
                        }
                        else if ( ServiceEvent.UNREGISTERING == event.getType() )
                        {
                            LogWrapperLoader.SINGLETON.removeLoggerRef( event.getServiceReference() );
                        }
                    }

                };
                context.addServiceListener( listener, "(" + Constants.OBJECTCLASS + "=org.osgi.service.log.LogService)" );
                logWrapper.logServiceListener = listener;

                // Add all available LogService references to the singleton.
                final ServiceReference[] refs = context.getServiceReferences( "org.osgi.service.log.LogService", null );

                if ( null != refs )
                {
                    for ( int i = 0; i < refs.length; i++ )
                    {
                        logWrapper.addLoggerRef( refs[i] );
                    }
                }
            }
            catch ( InvalidSyntaxException e )
            {
                // this never happens
            }
        }
    }


    /**
     * The private singleton constructor.
     */
    LogWrapper()
    {
        // Singleton
    }

    /**
     * Removes all references to LogServices still kept
     */
    void removeLoggerRefs()
    {
        synchronized ( loggerRefs )
        {
            loggerRefs.clear();
        }
    }

    /**
     * Add a reference to a newly available LogService
     */
    void addLoggerRef( final ServiceReference ref )
    {
        synchronized (loggerRefs)
        {
            loggerRefs.add(ref);
        }
    }

    /**
     * Remove a reference to a LogService
     */
    void removeLoggerRef( final ServiceReference ref )
    {
        synchronized (loggerRefs)
        {
            loggerRefs.remove(ref);
        }
    }

    /**
     * Set the context of the bundle in the singleton implementation.
     */
    private void setBundleContext(final BundleContext context)
    {
        synchronized(loggerRefs)
        {
            this.context = context;
        }
    }

    public void log(final int level, final String msg)
    {
        log(null, level, msg, null);
    }

    public void log(final int level, final String msg, final Throwable ex)
    {
        log(null, level, msg, null);
    }

    public void log(final ServiceReference sr, final int level, final String msg)
    {
        log(sr, level, msg, null);
    }

    public void log(final ServiceReference sr, final int level, final String msg,
        final Throwable ex)
    {
        // The method will remove any unregistered service reference as well.
        synchronized (loggerRefs)
        {
            if (level > logLevel)
            {
                return; // don't log
            }

            boolean logged = false;

            if (!loggerRefs.isEmpty())
            {
                // There is at least one LogService available hence, we can use the
                // class as well.
                for (Iterator<ServiceReference> iter = loggerRefs.iterator(); iter.hasNext();)
                {
                    final ServiceReference next = iter.next();

                    org.osgi.service.log.LogService logger =
                        (org.osgi.service.log.LogService) context.getService(next);

                    if (null != logger)
                    {
                        if ( sr == null )
                        {
                            if ( ex == null )
                            {
                                logger.log(level, msg);
                            }
                            else
                            {
                                logger.log(level, msg, ex);
                            }
                        }
                        else
                        {
                            if ( ex == null )
                            {
                                logger.log(sr, level, msg);
                            }
                            else
                            {
                                logger.log(sr, level, msg, ex);
                            }
                        }
                        context.ungetService(next);
                        // we logged, so we can finish
                        logged = true;
                        break;
                    }
                    else
                    {
                        // The context returned null for the reference - it follows
                        // that the service is unregistered and we can remove it
                        iter.remove();
                    }
                }
            }
            if ( !logged)
            {
                _log(sr, level, msg, ex);
            }
        }
    }

    /*
     * Log the message to standard output. This appends the level to the message.
     * null values are handled appropriate.
     */
    private void _log(final ServiceReference sr, final int level, final String msg,
        Throwable ex)
    {
        String s = (sr == null) ? null : "SvcRef " + sr;
        s = (s == null) ? msg : s + " " + msg;
        s = (ex == null) ? s : s + " (" + ex + ")";

        switch (level)
        {
            case LOG_DEBUG:
                System.out.println("DEBUG: " + s);
                break;
            case LOG_ERROR:
                System.out.println("ERROR: " + s);
                if (ex != null)
                {
                    if ((ex instanceof BundleException)
                        && (((BundleException) ex).getNestedException() != null))
                    {
                        ex = ((BundleException) ex).getNestedException();
                    }

                    ex.printStackTrace();
                }
                break;
            case LOG_INFO:
                System.out.println("INFO: " + s);
                break;
            case LOG_WARNING:
                System.out.println("WARNING: " + s);
                break;
            default:
                System.out.println("UNKNOWN[" + level + "]: " + s);
        }
    }

    /**
     * Change the current log level. Log level decides what messages gets
     * logged. Any message with a log level higher than the currently set
     * log level is not logged.
     *
     * @param logLevel new log level
     */
    public void setLogLevel(int logLevel)
    {
        synchronized (loggerRefs)
        {
            logLevel = logLevel;
        }
    }

    /**
     * @return current log level.
     */
    public int getLogLevel()
    {
        synchronized (loggerRefs)
        {
            return logLevel;
        }
    }
}