servicebinder/src/main/java/org/apache/felix/servicebinder/GenericActivator.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.servicebinder;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

import java.io.InputStream;

import org.apache.felix.servicebinder.architecture.DependencyChangeEvent;
import org.apache.felix.servicebinder.architecture.InstanceChangeEvent;
import org.apache.felix.servicebinder.impl.ArchitectureServiceImpl;
import org.apache.felix.servicebinder.parser.KxmlParser;
import org.osgi.framework.BundleActivator;
import org.osgi.framework.BundleContext;


import java.io.BufferedReader;
import java.io.InputStreamReader;

/**
 * The GenericActivator, it will read information from the metadata.xml file
 * and will create the corresponding instance managers
 *
 * @author <a href="mailto:dev@felix.apache.org">Felix Project Team</a>
 */
abstract public class GenericActivator implements BundleActivator
{
    private BundleContext m_context = null;
    private List m_instanceManagers = new ArrayList();

    private static boolean m_trace = false;
    private static boolean m_error = true;

    private static String m_version = "1.1.1 (17062004)";

    // Static initializations based on system properties
    static {
        // Get system properties to see if traces or errors need to be displayed
        String result = System.getProperty("servicebinder.showtrace");
        if(result != null && result.equals("true"))
        {
            m_trace = true;
        }
        result = System.getProperty("servicebinder.showerrors");
        if(result != null && result.equals("false"))
        {
            m_error = false;
        }
        result = System.getProperty("servicebinder.showversion");
        if(result != null && result.equals("true"))
        {
            System.out.println("[ ServiceBinder version = "+m_version+" ]\n");
        }        
    }

    public GenericActivator()
    {
    }

    /**
    * Called upon starting of the bundle. This method invokes initialize() which
    * parses the meta data and creates the instance managers
    *
    * @param   context  The bundle context passed by the framework
    * @exception   Exception any exception thrown from initialize
    */
    public void start(BundleContext context) throws Exception
    {
        m_context = context;
        try
        {
            initialize();
        }
        catch (Exception e)
        {
            GenericActivator.error("GenericActivator : in bundle ["
                + context.getBundle().getBundleId() + "] : " + e);
            e.printStackTrace();
            throw e;
        }
    }

    /**
    * Gets the MetaData location, parses the meta data and requests the processing
    * of binder instances
    *
    * @throws java.io.FileNotFoundException if the metadata file is not found
    * @throws javax.xml.parsers.ParserConfigurationException
    * @throws org.xml.sax.SAXException
    * @throws java.io.IOException
    * @throws java.lang.ClassNotFoundException it the instance class is not found
    * @throws java.lang.NoSuchMethodException if binder methods are not found
    * @throws org.osgi.framework.InvalidSyntaxException if the filter has an incorrect syntax
    * @throws Exception if any exception is thrown during the validation of the InstanceManagers
    */
    private void initialize() throws Exception
    {
        // Get the Metadata-Location value from the manifest

        String metadataLocation = "";
        //Dictionary dict = m_context.getBundle().getHeaders();
        
        metadataLocation = (String) m_context.getBundle().getHeaders().get("Metadata-Location");

        if (metadataLocation == null)
        {
            throw new java.io.FileNotFoundException("Metadata-Location entry not found in the manifest");
        }

        if (metadataLocation.startsWith("/") == false)
        {
            metadataLocation="/"+metadataLocation;
        }

        InputStream stream = getClass().getResourceAsStream(metadataLocation);

        if (stream == null)
        {
            throw new java.io.FileNotFoundException("MetaData file not found at:"+metadataLocation);
        }

        // Create the parser

        XmlHandler handler = new XmlHandler();
        BufferedReader in = new BufferedReader(new InputStreamReader(stream));
        KxmlParser parser = new KxmlParser(in);

        parser.parseXML(handler);

        // Create An instance manager for every entry

        Iterator i = handler.getInstanceMetadatas().iterator();

        while (i.hasNext())
        {
            InstanceMetadata descriptor = (InstanceMetadata) i.next();
                        
            if(descriptor.isFactory()) 
            {
                // NOT YET SUPPORTED IN THIS VERSION
            }
            else // deployment instance
            {
                // create the instance manager
                InstanceManager currentinstance = new InstanceManager(this,descriptor);
                // start managing lifecycle
                currentinstance.validate();
            }
        }
    }

    /**
    * Stop method that destroys all the instance managers
    *
    * @param   context The Bundle Context passed by the framework
    * @exception Exception any exception thrown during destruction of the instance managers
    */
    public void stop(BundleContext context) throws java.lang.Exception
    {
        GenericActivator.trace("GenericActivator : Bundle ["+context.getBundle().getBundleId()+"] will destroy "+m_instanceManagers.size()+" instances");

        while (m_instanceManagers.size() !=0 )
        {
            InstanceManager current = (InstanceManager)m_instanceManagers.get(0);
            try
            {
                current.destroy();
            }
            catch(Exception e)
            {
                GenericActivator.error("GenericActivator : Exception during invalidate : "+e);
                e.printStackTrace();
            }
        }

        m_context = null;

        GenericActivator.trace("GenericActivator : Bundle ["+context.getBundle().getBundleId()+"] STOPPED");
    }

    /**
    * Returns the list of instance references currently associated to this activator
    *
    * @return the list of instance references
    */
    protected List getInstanceReferences()
    {
        return m_instanceManagers;
    }

    /**
    * Returns the BundleContext
    *
    * @return the BundleContext
    */
    protected BundleContext getBundleContext()
    {
        return m_context;
    }

    /**
    * Add an instance manager to the list
    *
    * @param instance an instance manager
    */
    synchronized void addInstanceManager(InstanceManager instance)
    {
        ArchitectureServiceImpl.addInstanceReference(instance);

        m_instanceManagers.add(instance);
    }

    /**
    * Removes a binder instance from the list
    *
    * @param instance an instance manager
    */
    synchronized void removeInstanceManager(InstanceManager instance)
    {
        ArchitectureServiceImpl.removeInstanceReference(instance);

        m_instanceManagers.remove(instance);
    }

    /**
     * Method to display traces
     *
     * @param s a string to be displayed
    **/
    static void trace(String s)
    {
        if(m_trace)
        {
            System.out.println("--- "+s);
        }
    }

    /**
     * Method to display errors
     *
     * @param s a string to be displayed
    **/
    static void error(String s)
    {
        if(m_error)
        {
            System.err.println("### "+s);
        }
    }

    /**
     * Method called before an object implementing services is registered
     * in the OSGi framework. This method is provided so that subclasses of
     * the generic activator may proxy the object. The default implementation
     * returns the passed in object.
     *
     * @param obj the instance object
     * @param descriptor the instance descriptor that provides information relevant to
     *          the instance object
    **/
    protected Object proxyProvidedServiceObject(Object obj, InstanceMetadata descriptor)
    {
        return obj;
    }

    /**
     * Method called before the binding of the service object occurs.
     * This method is provided so that subclasses of the generic activator
     * may proxy the object. The default implementation returns the passed in object.
     *
     * @param obj the instance object
     * @param descriptor the dependency descriptor that provides information relevant to
     *          the service object
    **/
    protected Object proxyRequiredServiceObject(Object obj, DependencyMetadata descriptor)
    {
        return obj;
    }

    /**
     * Fires an event when an instance has changed
     * The generic activator always requests a reference of EvtGeneratorImpl
     * since this class can be instantiated at anytime since it is
     * the service implementation.
     *
     * @evt The InstanceChangeEvent
    **/
    void fireInstanceChangeEvent(InstanceChangeEvent evt)
    {
        ArchitectureServiceImpl evtGenerator = ArchitectureServiceImpl.getReference();

        if(evtGenerator != null)
        {
            evtGenerator.fireInstanceChangeEvent(evt);
        }
    }

    /**
     * Fires an event when a dependency has changed
     *
     * @evt The InstanceChangeEvent
     **/
    void fireDependencyChangeEvent(DependencyChangeEvent evt)
    {
        ArchitectureServiceImpl evtGenerator = ArchitectureServiceImpl.getReference();

        if(evtGenerator != null)
        {
            evtGenerator.fireDependencyChangeEvent(evt);
        }
    }
}