coordinator/src/main/java/org/apache/felix/coordinator/impl/LogWrapper.java - felix - Git at Google

 /*
  * 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;
         }
     }
 }
	/*
	* 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;
	}
	}
	}