FELIX-3740 Use a single ManagedService[Factory] tracker for all
MetaTypeInformationImpl instances
git-svn-id: https://svn.apache.org/repos/asf/felix/trunk@1403227 13f79535-47bb-0310-9956-ffa450edef68
diff --git a/metatype/src/main/java/org/apache/felix/metatype/internal/ManagedServiceHolder.java b/metatype/src/main/java/org/apache/felix/metatype/internal/ManagedServiceHolder.java
new file mode 100644
index 0000000..615d17f
--- /dev/null
+++ b/metatype/src/main/java/org/apache/felix/metatype/internal/ManagedServiceHolder.java
@@ -0,0 +1,84 @@
+/*************************************************************************
+*
+* ADOBE CONFIDENTIAL
+* ___________________
+*
+* Copyright 2012 Adobe Systems Incorporated
+* All Rights Reserved.
+*
+* NOTICE: All information contained herein is, and remains
+* the property of Adobe Systems Incorporated and its suppliers,
+* if any. The intellectual and technical concepts contained
+* herein are proprietary to Adobe Systems Incorporated and its
+* suppliers and are protected by trade secret or copyright law.
+* Dissemination of this information or reproduction of this material
+* is strictly forbidden unless prior written permission is obtained
+* from Adobe Systems Incorporated.
+**************************************************************************/
+package org.apache.felix.metatype.internal;
+
+import java.util.Arrays;
+
+import org.osgi.framework.ServiceReference;
+import org.osgi.service.metatype.MetaTypeProvider;
+
+class ManagedServiceHolder
+{
+ private final ServiceReference ref;
+ private final MetaTypeProvider provider;
+ private String[] pids;
+ private boolean isSingleton;
+ private boolean isFactory;
+
+
+ ManagedServiceHolder( final ServiceReference ref, final MetaTypeProvider provider )
+ {
+ this.ref = ref;
+ this.provider = provider;
+ this.pids = ServiceMetaTypeInformation.getServicePids( ref );
+ this.isSingleton = ServiceMetaTypeInformation.isService( ref, ManagedServiceTracker.MANAGED_SERVICE );
+ this.isFactory = ServiceMetaTypeInformation.isService( ref, ManagedServiceTracker.MANAGED_SERVICE_FACTORY );
+ }
+
+
+ public ServiceReference getRef()
+ {
+ return ref;
+ }
+
+
+ public MetaTypeProvider getProvider()
+ {
+ return provider;
+ }
+
+
+ public String[] getPids()
+ {
+ return pids;
+ }
+
+
+ public boolean isSingleton()
+ {
+ return isSingleton;
+ }
+
+
+ public boolean isFactory()
+ {
+ return isFactory;
+ }
+
+
+ void update( final MetaTypeServiceImpl mts )
+ {
+ final String[] newPids = ServiceMetaTypeInformation.getServicePids( getRef() );
+ if ( !Arrays.equals( this.getPids(), newPids ) )
+ {
+ mts.removeService( this );
+ this.pids = newPids;
+ mts.addService( this );
+ }
+ }
+}
\ No newline at end of file
diff --git a/metatype/src/main/java/org/apache/felix/metatype/internal/ManagedServiceTracker.java b/metatype/src/main/java/org/apache/felix/metatype/internal/ManagedServiceTracker.java
new file mode 100644
index 0000000..ff37c19
--- /dev/null
+++ b/metatype/src/main/java/org/apache/felix/metatype/internal/ManagedServiceTracker.java
@@ -0,0 +1,102 @@
+/*
+ * 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.metatype.internal;
+
+
+
+import org.osgi.framework.BundleContext;
+import org.osgi.framework.InvalidSyntaxException;
+import org.osgi.framework.ServiceReference;
+import org.osgi.service.metatype.MetaTypeProvider;
+import org.osgi.util.tracker.ServiceTracker;
+
+
+/**
+ * The {@code ManagedServiceTracker} tracks ManagedService and
+ * ManagedServiceFactory services on behalf of MetaTypeInformation
+ * implementations not being based on a metatype descriptor.
+ */
+public class ManagedServiceTracker extends ServiceTracker
+{
+
+ static final String MANAGED_SERVICE = "org.osgi.service.cm.ManagedService";
+
+ static final String MANAGED_SERVICE_FACTORY = "org.osgi.service.cm.ManagedServiceFactory";
+
+ /**
+ * The filter specification to find <code>ManagedService</code>s and
+ * <code>ManagedServiceFactory</code>s as well as to register a service
+ * listener for those services (value is
+ * "(|(objectClass=org.osgi.service.cm.ManagedService)(objectClass=org.osgi.service.cm.ManagedServiceFactory))").
+ * We use the hard coded class name here to not create a dependency on the
+ * ConfigurationAdmin service, which may not be available.
+ */
+ private static final String FILTER = "(|(objectClass=" + MANAGED_SERVICE + ")(objectClass="
+ + MANAGED_SERVICE_FACTORY + "))";
+
+ private final MetaTypeServiceImpl mts;
+
+
+ /**
+ * Creates an instance of this class handling services of the given
+ * <code>bundle</code>.
+ *
+ * @param bundleContext The <code>BundleContext</code> used to get and
+ * unget services.
+ * @param bundle The <code>Bundle</code> whose services are handled by
+ * this class.
+ */
+ public ManagedServiceTracker( BundleContext bundleContext, MetaTypeServiceImpl mts ) throws InvalidSyntaxException
+ {
+ super( bundleContext, bundleContext.createFilter( FILTER ), null );
+
+ this.mts = mts;
+ }
+
+
+ public Object addingService( ServiceReference reference )
+ {
+ Object service = this.context.getService( reference );
+ if ( service instanceof MetaTypeProvider )
+ {
+ final ManagedServiceHolder holder = new ManagedServiceHolder( reference, ( MetaTypeProvider ) service );
+ mts.addService( holder );
+ return holder;
+ }
+
+ // not a MetaTypeProvider implementation, don't track
+ this.context.ungetService( reference );
+ return null;
+
+ }
+
+
+ public void modifiedService( ServiceReference reference, Object service )
+ {
+ ( ( ManagedServiceHolder ) service ).update( this.mts );
+ }
+
+
+ public void removedService( ServiceReference reference, Object service )
+ {
+ final ManagedServiceHolder holder = ( ManagedServiceHolder ) service;
+ mts.removeService( holder );
+ this.context.ungetService( reference );
+ }
+}
diff --git a/metatype/src/main/java/org/apache/felix/metatype/internal/MetaTypeInformationImpl.java b/metatype/src/main/java/org/apache/felix/metatype/internal/MetaTypeInformationImpl.java
index 02b0314..637cbce 100644
--- a/metatype/src/main/java/org/apache/felix/metatype/internal/MetaTypeInformationImpl.java
+++ b/metatype/src/main/java/org/apache/felix/metatype/internal/MetaTypeInformationImpl.java
@@ -33,7 +33,6 @@
import org.apache.felix.metatype.MetaData;
import org.apache.felix.metatype.OCD;
import org.osgi.framework.Bundle;
-import org.osgi.framework.BundleContext;
import org.osgi.service.metatype.MetaTypeInformation;
import org.osgi.service.metatype.MetaTypeProvider;
import org.osgi.service.metatype.ObjectClassDefinition;
@@ -60,7 +59,7 @@
private Set locales;
- protected MetaTypeInformationImpl( final BundleContext serviceBundleContext, Bundle bundle )
+ protected MetaTypeInformationImpl( Bundle bundle )
{
this.bundle = bundle;
this.pids = new HashSet();
@@ -291,6 +290,16 @@
}
+ protected void addService( String[] pids, boolean isSingleton, boolean isFactory, final MetaTypeProvider mtp )
+ {
+ }
+
+
+ protected void removeService( String[] pids, boolean isSingleton, boolean isFactory )
+ {
+ }
+
+
private void addValues( Collection dest, Object[] values )
{
if ( values != null && values.length > 0 )
diff --git a/metatype/src/main/java/org/apache/felix/metatype/internal/MetaTypeServiceImpl.java b/metatype/src/main/java/org/apache/felix/metatype/internal/MetaTypeServiceImpl.java
index 67de54c..24bc7e6 100644
--- a/metatype/src/main/java/org/apache/felix/metatype/internal/MetaTypeServiceImpl.java
+++ b/metatype/src/main/java/org/apache/felix/metatype/internal/MetaTypeServiceImpl.java
@@ -33,6 +33,7 @@
import org.osgi.framework.BundleContext;
import org.osgi.framework.BundleEvent;
import org.osgi.framework.Constants;
+import org.osgi.framework.InvalidSyntaxException;
import org.osgi.framework.ServiceReference;
import org.osgi.framework.SynchronousBundleListener;
import org.osgi.service.log.LogService;
@@ -51,11 +52,10 @@
class MetaTypeServiceImpl implements MetaTypeService, SynchronousBundleListener
{
- /** The <code>BundleContext</code> of the providing this service. */
- private final BundleContext bundleContext;
-
private final Map bundleMetaTypeInformation;
+ private final ManagedServiceTracker managedServiceTracker;
+
private final MetaTypeProviderTracker providerTracker;
/**
@@ -66,11 +66,22 @@
*/
MetaTypeServiceImpl( BundleContext bundleContext )
{
- this.bundleContext = bundleContext;
this.bundleMetaTypeInformation = new ConcurrentHashMap();
bundleContext.addBundleListener( this );
+ ManagedServiceTracker mst = null;
+ try
+ {
+ mst = new ManagedServiceTracker( bundleContext, this );
+ mst.open();
+ }
+ catch ( InvalidSyntaxException e )
+ {
+ // this is really not expected !
+ }
+ this.managedServiceTracker = mst;
+
this.providerTracker = new MetaTypeProviderTracker( bundleContext, MetaTypeProvider.class.getName(), this );
this.providerTracker.open();
}
@@ -79,6 +90,7 @@
void dispose()
{
this.providerTracker.close();
+ this.managedServiceTracker.close();
this.bundleMetaTypeInformation.clear();
}
@@ -126,7 +138,7 @@
mti = fromDocuments( bundle );
if ( mti == null )
{
- mti = new ServiceMetaTypeInformation( bundleContext, bundle );
+ mti = new ServiceMetaTypeInformation( bundle );
}
MetaTypeInformationImpl impl = null;
@@ -161,7 +173,7 @@
return null;
}
- MetaTypeInformationImpl cmti = new MetaTypeInformationImpl( bundleContext, bundle );
+ MetaTypeInformationImpl cmti = new MetaTypeInformationImpl( bundle );
while ( docs.hasMoreElements() )
{
URL doc = ( URL ) docs.nextElement();
@@ -181,6 +193,7 @@
return cmti;
}
+ //-- register and unregister MetaTypeProvider services
protected void addSingletonMetaTypeProvider( final Bundle bundle, final String[] pids, MetaTypeProvider mtp )
{
@@ -224,8 +237,46 @@
}
+ //-- register and unregister ManagedService[Factory] services implementing MetaTypeProvider
+
+ protected void addService( final ManagedServiceHolder holder )
+ {
+ MetaTypeInformationImpl mti = getMetaTypeInformationInternal( holder.getRef().getBundle() );
+ if ( mti != null )
+ {
+ mti.addService( holder.getPids(), holder.isSingleton(), holder.isFactory(), holder.getProvider() );
+ }
+ }
+
+
+ protected void removeService( final ManagedServiceHolder holder )
+ {
+ MetaTypeInformationImpl mti = getMetaTypeInformationInternal( holder.getRef().getBundle() );
+ if ( mti != null )
+ {
+ mti.removeService( holder.getPids(), holder.isSingleton(), holder.isFactory() );
+ }
+ }
+
+
private void putMetaTypeInformationInternal( final Bundle bundle, final MetaTypeInformationImpl mti )
{
+ // initial ManagedService[Factory] implements MetaTypeProvider
+ final ServiceReference msRefs[] = this.managedServiceTracker.getServiceReferences();
+ if ( msRefs != null )
+ {
+ for ( int i = 0; i < msRefs.length; i++ )
+ {
+ ServiceReference ref = msRefs[i];
+ if ( bundle.equals( ref.getBundle() ) )
+ {
+ final ManagedServiceHolder holder = (ManagedServiceHolder) this.managedServiceTracker.getService( ref );
+ mti.addService( holder.getPids(), holder.isSingleton(), holder.isFactory(), holder.getProvider() );
+ }
+ }
+ }
+
+ // initial MetaTypeProvider
final ServiceReference refs[] = this.providerTracker.getServiceReferences();
if ( refs != null )
{
diff --git a/metatype/src/main/java/org/apache/felix/metatype/internal/ServiceMetaTypeInformation.java b/metatype/src/main/java/org/apache/felix/metatype/internal/ServiceMetaTypeInformation.java
index 2fdde3d..632903d 100644
--- a/metatype/src/main/java/org/apache/felix/metatype/internal/ServiceMetaTypeInformation.java
+++ b/metatype/src/main/java/org/apache/felix/metatype/internal/ServiceMetaTypeInformation.java
@@ -22,14 +22,8 @@
import java.util.Arrays;
import java.util.Collection;
import org.osgi.framework.Bundle;
-import org.osgi.framework.BundleContext;
import org.osgi.framework.Constants;
-import org.osgi.framework.Filter;
-import org.osgi.framework.InvalidSyntaxException;
-import org.osgi.framework.ServiceEvent;
-import org.osgi.framework.ServiceListener;
import org.osgi.framework.ServiceReference;
-import org.osgi.service.log.LogService;
import org.osgi.service.metatype.MetaTypeProvider;
@@ -41,116 +35,19 @@
*
* @author <a href="mailto:dev@felix.apache.org">Felix Project Team</a>
*/
-public class ServiceMetaTypeInformation extends MetaTypeInformationImpl implements ServiceListener
+public class ServiceMetaTypeInformation extends MetaTypeInformationImpl
{
- private static final String MANAGED_SERVICE = "org.osgi.service.cm.ManagedService";
-
- private static final String MANAGED_SERVICE_FACTORY = "org.osgi.service.cm.ManagedServiceFactory";
-
- /**
- * The filter specification to find <code>ManagedService</code>s and
- * <code>ManagedServiceFactory</code>s as well as to register a service
- * listener for those services (value is
- * "(|(objectClass=org.osgi.service.cm.ManagedService)(objectClass=org.osgi.service.cm.ManagedServiceFactory))").
- * We use the hard coded class name here to not create a dependency on the
- * ConfigurationAdmin service, which may not be available.
- */
- private static final String FILTER = "(|(objectClass=" + MANAGED_SERVICE + ")(objectClass="
- + MANAGED_SERVICE_FACTORY + "))";
-
- /**
- * The <code>BundleContext</code> used to get and unget services which
- * have to be registered and unregistered with the base class.
- */
- private final BundleContext bundleContext;
-
-
/**
* Creates an instance of this class handling services of the given
* <code>bundle</code>.
*
- * @param bundleContext The <code>BundleContext</code> used to get and
- * unget services.
* @param bundle The <code>Bundle</code> whose services are handled by
* this class.
*/
- public ServiceMetaTypeInformation( BundleContext bundleContext, Bundle bundle )
+ public ServiceMetaTypeInformation( Bundle bundle )
{
- super( bundleContext, bundle );
-
- this.bundleContext = bundleContext;
-
- // register for service events for the bundle
- try
- {
- bundleContext.addServiceListener( this, FILTER );
- }
- catch ( InvalidSyntaxException ise )
- {
- Activator.log( LogService.LOG_ERROR, "ServiceMetaTypeInformation: Cannot register for service events", ise );
- }
-
- // prepare the filter to select existing services
- Filter filter;
- try
- {
- filter = bundleContext.createFilter( FILTER );
- }
- catch ( InvalidSyntaxException ise )
- {
- Activator.log( LogService.LOG_ERROR, "ServiceMetaTypeInformation: Cannot create filter '" + FILTER + "'",
- ise );
- return;
- }
-
- // add current services of the bundle
- ServiceReference[] sr = bundle.getRegisteredServices();
- if ( sr != null )
- {
- for ( int i = 0; i < sr.length; i++ )
- {
- if ( filter.match( sr[i] ) )
- {
- addService( sr[i] );
- }
- }
- }
- }
-
-
- void dispose()
- {
- this.bundleContext.removeServiceListener( this );
- super.dispose();
- }
-
-
- // ---------- ServiceListener ----------------------------------------------
-
- /**
- * Handles service registration and unregistration events ignoring all
- * services not belonging to the <code>Bundle</code> which is handled by
- * this instance.
- *
- * @param event The <code>ServiceEvent</code>
- */
- public void serviceChanged( ServiceEvent event )
- {
- // only care for services of our bundle
- if ( !getBundle().equals( event.getServiceReference().getBundle() ) )
- {
- return;
- }
-
- if ( event.getType() == ServiceEvent.REGISTERED )
- {
- addService( event.getServiceReference() );
- }
- else if ( event.getType() == ServiceEvent.UNREGISTERING )
- {
- removeService( event.getServiceReference() );
- }
+ super( bundle );
}
@@ -167,35 +64,19 @@
* @param serviceRef The <code>ServiceReference</code> describing the
* service to be checked and handled.
*/
- protected void addService( ServiceReference serviceRef )
+ protected void addService( String[] pids, boolean isSingleton, boolean isFactory, MetaTypeProvider mtp )
{
- Object srv = bundleContext.getService( serviceRef );
-
- boolean ungetService = true;
-
- if ( srv instanceof MetaTypeProvider )
+ if ( pids != null )
{
- MetaTypeProvider mtp = ( MetaTypeProvider ) srv;
- String[] pids = getServicePids( serviceRef );
- if ( pids != null )
+ if ( isSingleton )
{
- if ( isService( serviceRef, MANAGED_SERVICE ) )
- {
- addSingletonMetaTypeProvider( pids, mtp );
- ungetService = false;
- }
-
- if ( isService( serviceRef, MANAGED_SERVICE_FACTORY ) )
- {
- addFactoryMetaTypeProvider( pids, mtp );
- ungetService = false;
- }
+ addSingletonMetaTypeProvider( pids, mtp );
}
- }
- if ( ungetService )
- {
- bundleContext.ungetService( serviceRef );
+ if ( isFactory )
+ {
+ addFactoryMetaTypeProvider( pids, mtp );
+ }
}
}
@@ -214,27 +95,20 @@
* @param serviceRef The <code>ServiceReference</code> describing the
* service to be unregistered.
*/
- protected void removeService( ServiceReference serviceRef )
+ protected void removeService( String[] pids, boolean isSingleton, boolean isFactory )
{
- boolean ungetService = false;
- String[] pids = getServicePids( serviceRef );
if ( pids != null )
{
- if ( isService( serviceRef, MANAGED_SERVICE ) )
+ if ( isSingleton )
{
- ungetService |= removeSingletonMetaTypeProvider( pids );
+ removeSingletonMetaTypeProvider( pids );
}
- if ( isService( serviceRef, MANAGED_SERVICE_FACTORY ) )
+ if ( isFactory )
{
- ungetService |= removeFactoryMetaTypeProvider( pids );
+ removeFactoryMetaTypeProvider( pids );
}
}
-
- if ( ungetService )
- {
- bundleContext.ungetService( serviceRef );
- }
}
diff --git a/metatype/src/test/java/org/apache/felix/metatype/MockBundleContext.java b/metatype/src/test/java/org/apache/felix/metatype/MockBundleContext.java
index eaedad2..08cbac0 100644
--- a/metatype/src/test/java/org/apache/felix/metatype/MockBundleContext.java
+++ b/metatype/src/test/java/org/apache/felix/metatype/MockBundleContext.java
@@ -361,6 +361,8 @@
public void setProperties( Dictionary props )
{
serviceProps = props;
+
+ bundleContext.fireServiceEvent( serviceRef, ServiceEvent.MODIFIED );
}
diff --git a/metatype/src/test/java/org/apache/felix/metatype/internal/MetaTypeServiceImplTest.java b/metatype/src/test/java/org/apache/felix/metatype/internal/MetaTypeServiceImplTest.java
index 3ef76c3..78acb04 100644
--- a/metatype/src/test/java/org/apache/felix/metatype/internal/MetaTypeServiceImplTest.java
+++ b/metatype/src/test/java/org/apache/felix/metatype/internal/MetaTypeServiceImplTest.java
@@ -98,6 +98,17 @@
assertTrue( mti.getPids().length == 1 );
assertEquals( pid, mti.getPids()[0] );
+ // change the service PID
+ String pid2 = "testAfterCreation2";
+ Dictionary props2 = new Hashtable();
+ props2.put( Constants.SERVICE_PID, pid2 );
+ sr.setProperties( props2 );
+
+ // pids must contain pid2
+ assertNotNull( mti.getPids() );
+ assertTrue( mti.getPids().length == 1 );
+ assertEquals( pid2, mti.getPids()[0] );
+
// factoryPids must be empty
assertTrue( mti.getFactoryPids() == null || mti.getFactoryPids().length == 0 );
@@ -118,7 +129,6 @@
checkEmpty( mti );
// register a service with PID
- String pid = "testAfterCreation";
String factoryPid = "testAfterCreation_factory";
MockManagedServiceFactory service = new MockManagedServiceFactory();
Dictionary props = new Hashtable();
@@ -138,6 +148,17 @@
assertTrue( mti.getFactoryPids().length == 1 );
assertEquals( factoryPid, mti.getFactoryPids()[0] );
+ // change the service PID
+ String factoryPid2 = "testAfterCreation2";
+ Dictionary props2 = new Hashtable();
+ props2.put( Constants.SERVICE_PID, factoryPid2 );
+ sr.setProperties( props2 );
+
+ // pids must contain pid2
+ assertNotNull( mti.getFactoryPids() );
+ assertTrue( mti.getFactoryPids().length == 1 );
+ assertEquals( factoryPid2, mti.getFactoryPids()[0] );
+
// unregister the service
sr.unregister();