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

@Test
public void testGetFilterFromString() {
    Filter f = null;
    try {
        f = FuchsiaUtils.getFilter("(!(key=value))");
    } catch (InvalidFilterException e) {
        fail("GetFilter thrown an exception on a valid String filter", e);
    }
    assertThat(f).isNotNull().isInstanceOf(Filter.class);

    Map<String, Object> map = new HashMap<String, Object>();
    map.put("key", "value");
    assertThat(f.matches(map)).isFalse();

    map.clear();
    map.put("key", "not-value");
    assertThat(f.matches(map)).isTrue();

    map.clear();
    map.put("not-key", "value");
    assertThat(f.matches(map)).isTrue();
}

/**
 * Constructor
 *
 * @param log
 *            the log service to use
 */
public RepoIndex(LogService log) {
    this.log = log;

    this.bundleAnalyzer = new BundleAnalyzer(log);
    this.frameworkAnalyzer = new OSGiFrameworkAnalyzer(log);
    this.scrAnalyzer = new SCRAnalyzer(log);
    this.blueprintAnalyzer = new BlueprintAnalyzer(log);

    try {
        Filter allFilter = createFilter("(name=*.jar)");

        addAnalyzer(bundleAnalyzer, allFilter);
        addAnalyzer(frameworkAnalyzer, allFilter);
        addAnalyzer(scrAnalyzer, allFilter);
        addAnalyzer(blueprintAnalyzer, allFilter);
    } catch (InvalidSyntaxException e) {
        throw new ExceptionInInitializerError("Unexpected internal error compiling filter");
    }
}

public IndexResult indexFile(File file) throws Exception {
    IndexResult result = new IndexResult();
    result.resource = new JarResource(file);
    result.signature = getSignature();
    synchronized (analyzers) {
        for (Pair<ResourceAnalyzer, Filter> entry : analyzers) {
            ResourceAnalyzer analyzer = entry.getFirst();
            Filter filter = entry.getSecond();

            if (filter == null || filter.match(result.resource.getProperties())) {
                analyzer.analyzeResource(result.resource, result.capabilities, result.requirements);
            }
        }
    }
    return result;
}

@Override
public void testExistingReference() {
    Hashtable<String, Object> properties = new Hashtable<String, Object>();
    properties.put("testservice", "true");

    @SuppressWarnings("rawtypes")
    ServiceRegistration<List> existingSR = bundleContext.registerService(List.class,
            new ArrayList<String>(Arrays.asList("Test")), properties);

    try {
        Filter filter = createTestFilter();
        Reference reference = new Reference(bundleContext, new Class<?>[] { List.class }, filter, 1);

        Assert.assertEquals(filter, reference.getFilter());

        reference.open();

        List<String> proxyInstance = reference.getProxyInstance();

        Assert.assertTrue(proxyInstance.contains("Test"));

        reference.close();
    } finally {
        existingSR.unregister();
    }
}

/**
 * A constructor that initializes the object and creates the necessary {@link ServiceTracker}. The {@link #open()}
 * function has to be called before using the {@link #proxyInstance}.
 * 
 * @param context
 *            The context of the bundle that needs the reference.
 * @param interfaces
 *            The interfaces that the {@link #proxyInstance} should be able to be casted.
 * @param filter
 *            The filter expression that the available services will be checked against.
 * @param timeout
 *            The timeout until the functions calls on {@link #proxyInstance} will wait if no service is available.
 */
public Reference(final BundleContext context, final Class<?>[] interfaces, final Filter filter,
        final long timeout) {
    if (filter == null) {
        throw new IllegalArgumentException("The filter parameter cannot be null");
    }
    if ((interfaces == null) || (interfaces.length == 0)) {
        throw new IllegalArgumentException("The number of required interfaces must be at least one.");
    }
    this.filter = filter;
    serviceTrackerCustomizer = new ReferenceTrackerCustomizer(context, interfaces);

    serviceTracker = new ServiceTracker<Object, Object>(context, filter, serviceTrackerCustomizer);
    referenceInvocationHandler =
            new ReferenceInvocationHandler(this, serviceTracker, filter.toString(), timeout);

    Bundle blueprintBundle = context.getBundle();
    ClassLoader classLoader = blueprintBundle.adapt(BundleWiring.class).getClassLoader();
    // TODO check if classloader is null and handle it. It could be null in case of special security circumstances.

    proxyInstance = Proxy.newProxyInstance(classLoader, interfaces,
            referenceInvocationHandler);
}

/**
 * @return the instance Location service
 */
public Location getInstanceLocation()
{
    if (locationTracker == null)
    {
        Filter filter = null;
        try
        {
            filter = context.createFilter(Location.INSTANCE_FILTER);
        }
        catch (InvalidSyntaxException e)
        {
            // ignore this. It should never happen as we have tested the
            // above format.
        }
        locationTracker = new ServiceTracker<Location, Location>(context, filter, null);
        locationTracker.open();
    }
    return locationTracker.getService();
}

static Filter createFilter(BundleContext context, String driverClass, String puName) {
    if (driverClass == null) {
        throw new IllegalArgumentException("No javax.persistence.jdbc.driver supplied in persistence.xml");
    }
    String filter = String.format("(&(objectClass=%s)(%s=%s))",
                                  DataSourceFactory.class.getName(),
                                  DataSourceFactory.OSGI_JDBC_DRIVER_CLASS,
                                  driverClass);
    LOGGER.info("Tracking DataSourceFactory for punit " + puName + " with filter " + filter);
    try {
        return context.createFilter(filter);
    } catch (InvalidSyntaxException e) {
        throw new IllegalArgumentException(e);
    }
}

static Filter createFilter(BundleContext context, String dsName, String puName) {
    if (dsName == null) {
        throw new IllegalArgumentException("No DataSource supplied in persistence.xml");
    }
    String subFilter = getSubFilter(dsName);
    String filter = String.format("(&(objectClass=%s)%s)",
                                  DataSource.class.getName(),
                                  subFilter);
    LOGGER.info("Tracking DataSource for punit " + puName + " with filter " + filter);
    try {
        return context.createFilter(filter);
    } catch (InvalidSyntaxException e) {
        throw new IllegalArgumentException(e);
    }
}

@SuppressWarnings("unchecked")
@Before
public void setup() throws Exception {

    when(punit.getPersistenceUnitName()).thenReturn("test-props");
    when(punit.getPersistenceProviderClassName())
        .thenReturn(ECLIPSE_PERSISTENCE_PROVIDER);
    when(punit.getTransactionType()).thenReturn(PersistenceUnitTransactionType.JTA);
    when(punit.getBundle()).thenReturn(punitBundle);
    when(punit.getProperties()).thenReturn(punitProperties);

    when(punitBundle.getBundleContext()).thenReturn(punitContext);
    when(punitBundle.getVersion()).thenReturn(Version.parseVersion("1.2.3"));

    when(containerContext.registerService(eq(ManagedService.class), 
            any(ManagedService.class), any(Dictionary.class))).thenReturn(msReg);
    when(containerContext.getService(dsfRef)).thenReturn(dsf);
    when(containerContext.getService(dsRef)).thenReturn(ds);
    when(containerContext.createFilter(Mockito.anyString()))
        .thenAnswer(new Answer<Filter>() {
            @Override
            public Filter answer(InvocationOnMock i) throws Throwable {
                return FrameworkUtil.createFilter(i.getArguments()[0].toString());
            }
        });

    when(punitContext.registerService(eq(EntityManagerFactory.class), any(EntityManagerFactory.class), 
            any(Dictionary.class))).thenReturn(emfReg);

    when(emf.isOpen()).thenReturn(true);


    Properties jdbcProps = new Properties();
    jdbcProps.setProperty("url", JDBC_URL);
    jdbcProps.setProperty("user", JDBC_USER);
    jdbcProps.setProperty("password", JDBC_PASSWORD);

    when(dsf.createDataSource(jdbcProps)).thenReturn(ds);

}

public ObjectPoolTracker ( final BundleContext context, final String poolClass ) throws InvalidSyntaxException
{
    final Map<String, String> parameters = new HashMap<String, String> ();
    parameters.put ( ObjectPool.OBJECT_POOL_CLASS, poolClass );
    final Filter filter = FilterUtil.createAndFilter ( ObjectPool.class.getName (), parameters );

    this.poolTracker = new ServiceTracker<ObjectPool<S>, ObjectPool<S>> ( context, filter, new ServiceTrackerCustomizer<ObjectPool<S>, ObjectPool<S>> () {

        @Override
        public void removedService ( final ServiceReference<ObjectPool<S>> reference, final ObjectPool<S> service )
        {
            context.ungetService ( reference );
            ObjectPoolTracker.this.removePool ( service );
        }

        @Override
        public void modifiedService ( final ServiceReference<ObjectPool<S>> reference, final ObjectPool<S> service )
        {
            ObjectPoolTracker.this.modifyPool ( service, reference );
        }

        @Override
        public ObjectPool<S> addingService ( final ServiceReference<ObjectPool<S>> reference )
        {
            final ObjectPool<S> o = context.getService ( reference );
            ObjectPoolTracker.this.addPool ( o, reference );
            return o;
        }
    } );
}