java类org.osgi.framework.ServiceListener的实例源码

public void testRemoveServiceListener() throws Exception {
    ServiceListener listener = new ServiceListener() {
        public void serviceChanged(ServiceEvent event) {
        }
    };

    Set listeners = mock.getServiceListeners();

    mock.removeServiceListener(null);

    assertEquals(0, listeners.size());

    mock.removeServiceListener(listener);
    assertEquals(0, listeners.size());

    mock.addServiceListener(listener);
    assertEquals(1, listeners.size());

    mock.removeServiceListener(listener);
    assertEquals(0, listeners.size());
}

@SuppressWarnings("rawtypes")
public ServiceRegistration registerService(String[] clazzes, final Object service, Dictionary properties) {
    MockServiceRegistration reg = new MockServiceRegistration(properties);

    MockServiceReference ref = new MockServiceReference(getBundle(), properties, reg, clazzes) {

        @Override
        public Object getProperty(String key) {
            if (SERVICE_PROPERTY.equals(key)) {
                return service;
            } else {
                return super.getProperty(key);
            }
        }

    };
    ServiceEvent event = new ServiceEvent(ServiceEvent.REGISTERED, ref);

    for (Iterator iter = serviceListeners.iterator(); iter.hasNext();) {
        ServiceListener listener = (ServiceListener) iter.next();
        listener.serviceChanged(event);
    }

    return reg;
}

public void testServiceReferenceMemberType() throws Exception {
    serviceFactoryBean.setMemberType(MemberType.SERVICE_REFERENCE);
    serviceFactoryBean.setInterfaces(new Class<?>[] { Runnable.class });
    serviceFactoryBean.afterPropertiesSet();

    Collection col = (Collection) serviceFactoryBean.getObject();

    assertFalse(col.isEmpty());
    assertSame(ref, col.iterator().next());

    Set listeners = bundleContext.getServiceListeners();
    ServiceListener list = (ServiceListener) listeners.iterator().next();
    ServiceReference ref2 = new MockServiceReference();
    list.serviceChanged(new ServiceEvent(ServiceEvent.REGISTERED, ref2));

    assertEquals(2, col.size());
    Iterator iter = col.iterator();
    iter.next();
    assertSame(ref2, iter.next());
}

public void testUnbind() {
    interceptor.afterPropertiesSet();

    assertEquals(1, SimpleTargetSourceLifecycleListener.BIND);
    assertEquals(0, SimpleTargetSourceLifecycleListener.UNBIND);

    ServiceListener sl = (ServiceListener) bundleContext.getServiceListeners().iterator().next();

    // save old ref and invalidate it so new services are not found
    ServiceReference oldRef = refs[0];
    refs = null;

    sl.serviceChanged(new ServiceEvent(ServiceEvent.UNREGISTERING, oldRef));

    assertEquals(1, SimpleTargetSourceLifecycleListener.BIND);
    assertEquals(1, SimpleTargetSourceLifecycleListener.UNBIND);
}

public void testStickinessWhenABetterServiceIsAvailable() throws Exception {
    interceptor.setSticky(true);
    interceptor.afterPropertiesSet();

    ServiceListener sl = (ServiceListener) bundleContext.getServiceListeners().iterator().next();

    Dictionary props = new Hashtable();
    // increase service ranking
    props.put(Constants.SERVICE_RANKING, 10);

    ServiceReference ref = new MockServiceReference(null, props, null);
    ServiceEvent event = new ServiceEvent(ServiceEvent.REGISTERED, ref);

    assertEquals(1, SimpleTargetSourceLifecycleListener.BIND);
    assertEquals(0, SimpleTargetSourceLifecycleListener.UNBIND);

    sl.serviceChanged(event);

    assertEquals("the proxy is not sticky", 1, SimpleTargetSourceLifecycleListener.BIND);
    assertEquals(0, SimpleTargetSourceLifecycleListener.UNBIND);
}

public void testStickinessWhenServiceGoesDown() throws Exception {
    interceptor.setSticky(true);
    interceptor.afterPropertiesSet();

    ServiceListener sl = (ServiceListener) bundleContext.getServiceListeners().iterator().next();

    Dictionary props = new Hashtable();
    // increase service ranking
    props.put(Constants.SERVICE_RANKING, 10);

    ServiceReference higherRankingRef = new MockServiceReference(null, props, null);
    refs = new ServiceReference[] { new MockServiceReference(), higherRankingRef };

    assertTrue(Arrays.equals(bundleContext.getServiceReferences((String)null, null), refs));

    assertEquals(1, SimpleTargetSourceLifecycleListener.BIND);
    assertEquals(0, SimpleTargetSourceLifecycleListener.UNBIND);

    sl.serviceChanged(new ServiceEvent(ServiceEvent.UNREGISTERING, refs[0]));

    assertEquals(2, SimpleTargetSourceLifecycleListener.BIND);
    assertEquals(0, SimpleTargetSourceLifecycleListener.UNBIND);

    assertSame("incorrect backing reference selected", higherRankingRef, ((ServiceReferenceProxy) interceptor
            .getServiceReference()).getTargetServiceReference());
}

/**
 * Test method for
 * {@link org.eclipse.gemini.blueprint.util.OsgiListenerUtils#addServiceListener(org.osgi.framework.BundleContext, org.osgi.framework.ServiceListener, java.lang.String)}.
 */
public void testAddServiceListenerBundleContextServiceListenerString() {
    final List refs = new ArrayList();

    ServiceListener list = new ServiceListener() {

        public void serviceChanged(ServiceEvent event) {
            if (ServiceEvent.REGISTERED == event.getType())
                refs.add(event.getSource());
        }
    };

    OsgiListenerUtils.addServiceListener(bundleContext, list, (String) null);

    assertFalse(refs.isEmpty());
    assertEquals(3, refs.size());
    assertSame(ref1, refs.get(0));
    assertSame(ref2, refs.get(1));
    assertSame(ref3, refs.get(2));
}

/**
 * Test method for
 * {@link org.eclipse.gemini.blueprint.util.OsgiListenerUtils#addSingleServiceListener(org.osgi.framework.BundleContext, org.osgi.framework.ServiceListener, java.lang.String)}.
 */
public void testAddSingleServiceListenerBundleContextServiceListenerString() {
    final List refs = new ArrayList();

    ServiceListener listener = new ServiceListener() {

        public void serviceChanged(ServiceEvent event) {
            if (ServiceEvent.REGISTERED == event.getType())
                refs.add(event.getSource());
        }
    };

    OsgiListenerUtils.addSingleServiceListener(bundleContext, listener, (String) null);

    assertFalse(refs.isEmpty());
    assertEquals(1, refs.size());
    assertSame(ref1, refs.get(0));
}

public RemoteServiceAdminCore(BundleContext context, BundleContext apiContext, DistributionProvider provider) {
    this.bctx = context;
    this.apictx = apiContext;
    this.eventProducer = new EventProducer(bctx);
    this.provider = provider;
    // listen for exported services being unregistered so we can close the export
    this.exportedServiceListener = new ServiceListener() {
        public void serviceChanged(ServiceEvent event) {
            if (event.getType() == ServiceEvent.UNREGISTERING) {
                removeServiceExports(event.getServiceReference());
            }
        }
    };
    try {
        String filter = "(" + RemoteConstants.SERVICE_EXPORTED_INTERFACES + "=*)";
        context.addServiceListener(exportedServiceListener, filter);
    } catch (InvalidSyntaxException ise) {
        throw new RuntimeException(ise); // can never happen
    }
}

@Test
public void testListeners() throws Exception {
  Future<PentahoCacheProvidingService> serviceFuture;

  factory.init();
  verify( bundleContext ).addServiceListener( serviceListenerCaptor.capture(), argThat( matchesFilter ) );

  serviceFuture = factory.getProviderService( MOCK_PID );
  assertThat( serviceFuture.isDone(), is( true ) );
  assertThat( serviceFuture.get( 1, TimeUnit.SECONDS ), is( providingService ) );

  ServiceListener serviceListener = serviceListenerCaptor.getValue();

  serviceListener.serviceChanged( new ServiceEvent( ServiceEvent.UNREGISTERING, serviceReference ) );

  serviceFuture = factory.getProviderService( MOCK_PID );
  assertThat( serviceFuture.isDone(), is( false ) );

  serviceListener.serviceChanged( new ServiceEvent( ServiceEvent.REGISTERED, serviceReference ) );

  serviceFuture = factory.getProviderService( MOCK_PID );
  assertThat( serviceFuture.isDone(), is( true ) );
  assertThat( serviceFuture.get( 1, TimeUnit.SECONDS ), is( providingService ) );
}

private void registerForServiceNotAvailable(final Bundle bundle, final String filterDataSource) throws InvalidSyntaxException {
    //serviceHideManager.hideService(filterDataSource);
    context.addServiceListener(new ServiceListener() {

        @Override
        public void serviceChanged(ServiceEvent event) {
            if (event.getType() == ServiceEvent.REGISTERED) {

                try {
                    checkAndRunLiquibase(bundle);
                } catch (Exception e) {
                    LOG.error(
                            MessageFormat.format("An error occured while processing bundle {0} for liquibase extender.",
                                    bundle.getSymbolicName()), e);
                }
                context.removeServiceListener(this);
                //serviceHideManager.showService(filterDataSource);
            }
        }
    }, filterDataSource);
}

@Before
public void setup() throws Exception {
    serviceReference = context.mock(ServiceReference.class, "serviceReference");
    bundleContext = context.mock(BundleContext.class);
    listener = context.mock(GDEventListener.class);
    eventManager = new EventManager();
    eventManager.setContext(bundleContext);

    timer = new Timer();
    timer.schedule(new ShutdownTask(), 3000);

    context.checking(new Expectations() {
        {
            //oneOf(bundleContext).createFilter(with(aNonNull(String.class)));
            allowing(bundleContext).addServiceListener(with(any(ServiceListener.class)), with(aNonNull(String.class)));
            allowing(bundleContext).removeServiceListener(with(any(ServiceListener.class)));
            allowing(bundleContext).getServiceReferences(with(any(Class.class)), with(any(String.class)));
            allowing(bundleContext).getServiceReferences(with(any(String.class)), with(any(String.class)));
        }
    });

    registerDevice("zwave32");
    registerDevice("zwave31");
    registerDevice("dev");
}

/**
 * Called by the framework for initialisation when the Activator class is loaded.
 * The method first get a service reference on the osgi logging service, used for
 * logging whithin the bundle.
 *
 * If the method cannot get a reference to the logging service, a NullPointerException is thrown.
 * @param context
 * @throws BundleException
 */
public void start(BundleContext context) throws Exception {
    // TODO Auto-generated method stub
    Activator.bc = context;

    // we construct a listener to detect if the log service appear or disapear.
    String filter = "(objectclass=" + logServiceName + ")";
    ServiceListener logServiceListener = new LogServiceListener();
    try {
        bc.addServiceListener( logServiceListener, filter);
        // in case the service is already registered, we send a REGISTERED event to its listener.
        ServiceReference srLog = bc.getServiceReference( logServiceName );
        if( srLog != null ) {
            logServiceListener.serviceChanged(new ServiceEvent( ServiceEvent.REGISTERED, srLog ));
        }
    } catch ( InvalidSyntaxException e ) {
        throw new BundleException("Error in filter string while registering LogServiceListener." + e.toString());
    }

    piService = new PiService();
}

/**
    * Called by the framework for initialisation when the Activator class is
    * loaded. The method first get a service reference on the osgi logging
    * service, used for logging whithin the bundle.
    * 
    * If the method cannot get a reference to the logging service, a
    * NullPointerException is thrown.
    * 
    * @param context
    * @throws BundleException
    */
   public void start(BundleContext context) throws BundleException {

Activator.bc = context;

// we construct a listener to detect if the log service appear or
// disapear.
String logFilter = "(objectclass=" + logServiceName + ")";
ServiceListener logServiceListener = new LogServiceListener();
try {
    bc.addServiceListener(logServiceListener, logFilter);
    // in case the service is already registered, we send a REGISTERED
    // event to its listener.
    ServiceReference srLog = bc.getServiceReference(logServiceName);
    if (srLog != null) {
    logServiceListener.serviceChanged(new ServiceEvent(ServiceEvent.REGISTERED, srLog));
    }
} catch (InvalidSyntaxException e) {
    throw new BundleException("Error in filter string while registering LogServiceListener." + e.toString());
}

log(LogService.LOG_INFO, "Starting version " + bc.getBundle().getHeaders().get("Bundle-Version"));

influxDbFactory.start();
   }

public void testRemoveServiceListener() throws Exception {
    ServiceListener listener = new ServiceListener() {
        public void serviceChanged(ServiceEvent event) {
        }
    };

    Set listeners = mock.getServiceListeners();

    mock.removeServiceListener(null);

    assertEquals(0, listeners.size());

    mock.removeServiceListener(listener);
    assertEquals(0, listeners.size());

    mock.addServiceListener(listener);
    assertEquals(1, listeners.size());

    mock.removeServiceListener(listener);
    assertEquals(0, listeners.size());
}

public void testMandatoryServiceUnAvailableWhileWorking() {
    serviceFactoryBean.setInterfaces(new Class[] { Serializable.class });
    serviceFactoryBean.afterPropertiesSet();

    Collection col = (Collection) serviceFactoryBean.getObject();

    assertFalse(col.isEmpty());
    Set listeners = bundleContext.getServiceListeners();

    ServiceListener list = (ServiceListener) listeners.iterator().next();
    list.serviceChanged(new ServiceEvent(ServiceEvent.UNREGISTERING, ref));

    try {
        // disable filter
        col.isEmpty();
        fail("should have thrown exception");
    }
    catch (ServiceUnavailableException ex) {
        // expected
    }
}

public void testUnbind() {
    interceptor.afterPropertiesSet();

    assertEquals(1, SimpleTargetSourceLifecycleListener.BIND);
    assertEquals(0, SimpleTargetSourceLifecycleListener.UNBIND);

    ServiceListener sl = (ServiceListener) bundleContext.getServiceListeners().iterator().next();

    // save old ref and invalidate it so new services are not found
    ServiceReference oldRef = refs[0];
    refs = null;

    sl.serviceChanged(new ServiceEvent(ServiceEvent.UNREGISTERING, oldRef));

    assertEquals(1, SimpleTargetSourceLifecycleListener.BIND);
    assertEquals(1, SimpleTargetSourceLifecycleListener.UNBIND);
}

protected void removeService(Object service) {
    ServiceReference ref = new MockServiceReference();

    for (Iterator iter = services.entrySet().iterator(); iter.hasNext();) {
        Map.Entry entry = (Map.Entry) iter.next();
        if (entry.getValue().equals(service)) {
            ref = (ServiceReference) entry.getKey();
            continue;
        }
    }

    services.remove(ref);

    ServiceEvent event = new ServiceEvent(ServiceEvent.UNREGISTERING, ref);

    for (Iterator iter = context.getServiceListeners().iterator(); iter.hasNext();) {
        ServiceListener listener = (ServiceListener) iter.next();
        listener.serviceChanged(event);
    }

}

/**
 * Test method for
 * {@link org.springframework.osgi.util.OsgiListenerUtils#addServiceListener(org.osgi.framework.BundleContext, org.osgi.framework.ServiceListener, java.lang.String)}.
 */
public void testAddServiceListenerBundleContextServiceListenerString() {
    final List refs = new ArrayList();

    ServiceListener list = new ServiceListener() {

        public void serviceChanged(ServiceEvent event) {
            if (ServiceEvent.REGISTERED == event.getType())
                refs.add(event.getSource());
        }
    };

    OsgiListenerUtils.addServiceListener(bundleContext, list, (String) null);

    assertFalse(refs.isEmpty());
    assertEquals(3, refs.size());
    assertSame(ref1, refs.get(0));
    assertSame(ref2, refs.get(1));
    assertSame(ref3, refs.get(2));
}

/**
 * Test method for
 * {@link org.springframework.osgi.util.OsgiListenerUtils#addSingleServiceListener(org.osgi.framework.BundleContext, org.osgi.framework.ServiceListener, java.lang.String)}.
 */
public void testAddSingleServiceListenerBundleContextServiceListenerString() {
    final List refs = new ArrayList();

    ServiceListener listener = new ServiceListener() {

        public void serviceChanged(ServiceEvent event) {
            if (ServiceEvent.REGISTERED == event.getType())
                refs.add(event.getSource());
        }
    };

    OsgiListenerUtils.addSingleServiceListener(bundleContext, listener, (String) null);

    assertFalse(refs.isEmpty());
    assertEquals(1, refs.size());
    assertSame(ref1, refs.get(0));
}

public void testActivator() throws Exception {
    ServiceRegistration sreg = mock(ServiceRegistration.class);
    BundleContext bc = mock(BundleContext.class);
    when(bc.registerService(anyString(), anyObject(), any(Dictionary.class))).thenReturn(sreg); 

    Activator a = new Activator();
    a.start(bc);

    verify(bc).registerService(eq(EventHook.class.getName()), isA(HidingEventHook.class), any(Dictionary.class));
    verify(bc).registerService(eq(FindHook.class.getName()), isA(HidingFindHook.class), any(Dictionary.class));
    verify(bc).addServiceListener(isA(ServiceJockeyListener.class));

    verify(bc, never()).removeServiceListener((ServiceListener) anyObject());
    verify(sreg, never()).unregister();
    a.stop(bc);
    verify(bc).removeServiceListener(isA(ServiceJockeyListener.class));
    verify(sreg, times(2)).unregister();
}

/**
 * Executed when the service is activated.
 * 
 * @param context
 *            the service's context
 * @throws InvalidSyntaxException
 */
protected void activate(final ComponentContext context)
        throws InvalidSyntaxException {
    log.info("activate");

    bundleContext = context.getBundleContext();

    sl = new ServiceListener() {
        public void serviceChanged(ServiceEvent event) {
            if (event.getType() == ServiceEvent.UNREGISTERING) {
                cache.unregisterComponentBindingsProvider(event
                        .getServiceReference());
            } else if (event.getType() == ServiceEvent.REGISTERED) {
                cache.registerComponentBindingsProvider(event
                        .getServiceReference());
            }
        }
    };
    bundleContext.addServiceListener(sl, "(" + Constants.OBJECTCLASS + "="
            + ComponentBindingsProvider.class.getName() + ")");
    reloadCache();
    log.info("Activation successful");
}

public void testServiceAliveDuringUnregistration() throws Exception {
    service = new Polygon();

    ServiceRegistration reg = bundleContext.registerService(Shape.class.getName(), service, null);

    String filter = OsgiFilterUtils.unifyFilter(Shape.class, null);

    ServiceListener listener = new ServiceListener() {

        public void serviceChanged(ServiceEvent event) {
            if (ServiceEvent.UNREGISTERING == event.getType()) {
                ServiceReference ref = event.getServiceReference();
                Object aliveService = bundleContext.getService(ref);
                assertNotNull("services not available during unregistration", aliveService);
                assertSame(service, aliveService);
            }
        }
    };

    try {
        bundleContext.addServiceListener(listener, filter);
        reg.unregister();
    }
    finally {
        bundleContext.removeServiceListener(listener);
    }
}

/**
 * Constructs a new <code>MockBundleContext</code> instance allowing both
 * the bundle and the context properties to be specified.
 * 
 * @param bundle associated bundle
 * @param props context properties
 */
public MockBundleContext(Bundle bundle, Properties props) {
    this.bundle = (bundle == null ? new MockBundle(this) : bundle);
    properties = new Properties(DEFAULT_PROPERTIES);
    if (props != null)
        properties.putAll(props);

       // make sure the order is preserved
       this.serviceListeners = new LinkedHashSet<ServiceListener>(2);
       this.bundleListeners = new LinkedHashSet<BundleListener>(2);
}

public void addServiceListener(ServiceListener listener) {
    try {
        addServiceListener(listener, null);
    } catch (InvalidSyntaxException ex) {
        throw new IllegalStateException("exception should not occur");
    }
}

public void testAddServiceListener() throws Exception {
    ServiceListener listener = new ServiceListener() {
        public void serviceChanged(ServiceEvent event) {
        }
    };
    mock.addServiceListener(listener);

    assertEquals(1, mock.getServiceListeners().size());
    assertSame(listener, mock.getServiceListeners().iterator().next());
}

private static void registerListener(BundleContext context, ServiceListener listener, String filter) {
    Assert.notNull(context);
    Assert.notNull(listener);

    try {
        // add listener
        context.addServiceListener(listener, filter);
    }
    catch (InvalidSyntaxException isex) {
        throw (RuntimeException) new IllegalArgumentException("Invalid filter").initCause(isex);
    }
}

private static void dispatchServiceRegistrationEvents(ServiceReference[] alreadyRegistered, ServiceListener listener) {
    if (log.isTraceEnabled())
        log.trace("Calling listener for already registered services: "
                + ObjectUtils.nullSafeToString(alreadyRegistered));

    if (alreadyRegistered != null) {
        for (int i = 0; i < alreadyRegistered.length; i++) {
            listener.serviceChanged(new ServiceEvent(ServiceEvent.REGISTERED, alreadyRegistered[i]));
        }
    }
}

/**
 * Removes a service listener from the given bundle context. This method
 * simply takes care of any exceptions that might be thrown (in case the
 * context is invalid).
 * 
 * @param context bundle context to unregister the listener from
 * @param listener service listener to unregister
 * @return true if the listener unregistration has succeeded, false
 * otherwise (for example if the bundle context is invalid)
 */
public static boolean removeServiceListener(BundleContext context, ServiceListener listener) {
    if (context == null || listener == null)
        return false;

    try {
        context.removeServiceListener(listener);
        return true;
    }
    catch (IllegalStateException e) {
        // Bundle context is no longer valid
    }

    return false;
}

public void testMandatoryServiceUnAvailableWhileWorking() {
    serviceFactoryBean.setInterfaces(new Class<?>[] { Runnable.class });
    serviceFactoryBean.afterPropertiesSet();

    Collection col = (Collection) serviceFactoryBean.getObject();

    assertFalse(col.isEmpty());
    Set listeners = bundleContext.getServiceListeners();

    ServiceListener list = (ServiceListener) listeners.iterator().next();
    // disable filter
    list.serviceChanged(new ServiceEvent(ServiceEvent.UNREGISTERING, ref));
    col.isEmpty();
}