Examples with Ensure org.apache.felix.dm.itest.util.Ensure used on opensource projects

Example 76 with Ensure

use of org.apache.felix.dm.itest.util.Ensure in project felix by apache.

the class ServiceDependencyPropagateTest method testServiceDependencyPropagateCallback.

/**
 * Checks that a ServiceDependency propagates the dependency service properties to the provided service properties,
 * using a callback method.
 */
public void testServiceDependencyPropagateCallback() {
    DependencyManager m = getDM();
    // helper class that ensures certain steps get executed in sequence
    Ensure e = new Ensure();
    Component c1 = m.createComponent().setImplementation(new C1(e)).add(m.createServiceDependency().setService(C2.class).setRequired(true).setCallbacks("bind", null));
    C2 c2Impl = new C2();
    Component c2 = m.createComponent().setInterface(C2.class.getName(), new Hashtable() {

        {
            put("foo", "bar");
        }
    }).setImplementation(c2Impl).add(m.createServiceDependency().setService(C3.class).setRequired(true).setPropagate(c2Impl, "getServiceProperties"));
    Component c3 = m.createComponent().setInterface(C3.class.getName(), null).setImplementation(new C3());
    m.add(c1);
    m.add(c2);
    m.add(c3);
    e.waitForStep(3, 10000);
    m.clear();
}

Example 77 with Ensure

use of org.apache.felix.dm.itest.util.Ensure in project felix by apache.

the class ServiceRaceTest method doTest.

void doTest(int loop) throws Throwable {
    debug("loop#%d -------------------------", loop);
    final Ensure step = new Ensure(false);
    // Create one client component, which depends on many service dependencies
    final Component client = m_dm.createComponent();
    final Client clientImpl = new Client(step);
    client.setImplementation(clientImpl);
    // Create client service dependencies
    final ServiceDependency[] dependencies = new ServiceDependency[DEPENDENCIES];
    for (int i = 0; i < DEPENDENCIES; i++) {
        final String filter = "(id=loop" + loop + "." + i + ")";
        dependencies[i] = m_dm.createServiceDependency().setService(Dep.class, filter).setRequired(true).setCallbacks("add", "remove");
        client.add(dependencies[i]);
    }
    String pid = "pid." + loop;
    final ConfigurationDependency confDependency = m_dm.createConfigurationDependency().setPid(pid);
    client.add(confDependency);
    // Create Configuration (concurrently).
    final Configuration conf = m_cm.getConfiguration(pid, null);
    final Hashtable props = new Hashtable();
    props.put("foo", "bar");
    schedule(new Runnable() {

        public void run() {
            try {
                conf.update(props);
            } catch (IOException e) {
                error("update failed", e);
            }
        }
    });
    // Activate the client service dependencies concurrently.
    List<Component> deps = new ArrayList();
    for (int i = 0; i < DEPENDENCIES; i++) {
        Hashtable h = new Hashtable();
        h.put("id", "loop" + loop + "." + i);
        final Component s = m_dm.createComponent().setInterface(Dep.class.getName(), h).setImplementation(new DepImpl());
        deps.add(s);
        schedule(new Runnable() {

            public void run() {
                m_dm.add(s);
            }
        });
    }
    // Start the client (concurrently)
    schedule(new Runnable() {

        public void run() {
            m_dm.add(client);
        }
    });
    // Ensure that client has been started.
    int expectedStep = 1 + /* conf */
    DEPENDENCIES + 1;
    step.waitForStep(expectedStep, STEP_WAIT);
    Assert.assertEquals(DEPENDENCIES, clientImpl.getDependencies());
    Assert.assertNotNull(clientImpl.getConfiguration());
    // Stop all dependencies concurrently.
    for (Component dep : deps) {
        final Component dependency = dep;
        schedule(new Runnable() {

            public void run() {
                m_dm.remove(dependency);
            }
        });
    }
    // Stop client concurrently.
    schedule(new Runnable() {

        public void run() {
            m_dm.remove(client);
        }
    });
    // Remove configuration (asynchronously)
    final Ensure stepConfDeleted = new Ensure(false);
    schedule(new Runnable() {

        public void run() {
            try {
                conf.delete();
                stepConfDeleted.step(1);
            } catch (IOException e) {
                warn("error while unconfiguring", e);
            }
        }
    });
    // Ensure that client has been stopped, then destroyed, then unbound from all dependencies
    // stop/destroy
    expectedStep += 2;
    // removed all dependencies
    expectedStep += DEPENDENCIES;
    step.waitForStep(expectedStep, STEP_WAIT);
    // Make sure configuration is removed
    stepConfDeleted.waitForStep(1, STEP_WAIT);
    step.ensure();
    Assert.assertEquals(0, clientImpl.getDependencies());
    m_threadPool.awaitQuiescence(5000, TimeUnit.MILLISECONDS);
    if (super.errorsLogged()) {
        throw new IllegalStateException("Race test interrupted (some error occured, see previous logs)");
    }
    debug("finished one test loop");
    if ((loop + 1) % 100 == 0) {
        long duration = System.currentTimeMillis() - m_timeStamp;
        warn("Performed 100 tests (total=%d) in %d ms.", (loop + 1), duration);
        m_timeStamp = System.currentTimeMillis();
    }
}

Example 78 with Ensure

use of org.apache.felix.dm.itest.util.Ensure in project felix by apache.

the class ServiceUpdateTest method testServiceUpdate.

public void testServiceUpdate() throws Exception {
    final DependencyManager m = getDM();
    // helper class that ensures certain steps get executed in sequence
    Ensure e = new Ensure();
    // create a resource provider
    ResourceProvider provider = new ResourceProvider(context, new URL("file://localhost/path/to/file1.txt"));
    // activate it
    m.add(m.createComponent().setImplementation(new ServiceProvider(e)).add(m.createServiceDependency().setService(ServiceInterface.class).setRequired(true).setCallbacks("add", "change", "remove")));
    m.add(m.createComponent().setImplementation(provider).add(m.createServiceDependency().setService(ResourceHandler.class).setCallbacks("add", "remove")));
    // create a resource adapter for our single resource
    // note that we can provide an actual implementation instance here because there will be only one
    // adapter, normally you'd want to specify a Class here
    CallbackInstance callbackInstance = new CallbackInstance(e);
    Hashtable<String, String> serviceProps = new Hashtable<String, String>();
    serviceProps.put("number", "1");
    Component component = m.createResourceAdapterService("(&(path=/path/to/*.txt)(host=localhost))", false, callbackInstance, "changed").setImplementation(new ResourceAdapter(e)).setInterface(ServiceInterface.class.getName(), serviceProps).setCallbacks(callbackInstance, "init", "start", "stop", "destroy");
    m.add(component);
    // wait until the single resource is available
    e.waitForStep(1, 5000);
    // wait until the component gets the dependency injected
    e.waitForStep(2, 5000);
    // trigger a 'change' in our resource
    provider.change();
    // wait until the changed callback is invoked
    e.waitForStep(3, 5000);
    // wait until the changed event arrived at the component
    e.waitForStep(4, 5000);
    System.out.println("Done!");
    m.clear();
}

Example 79 with Ensure

use of org.apache.felix.dm.itest.util.Ensure in project felix by apache.

the class TemporalServiceDependencyTest method testFELIX4858_ServiceAdapterConsumptionWithCallbackAndIntermittentAvailability.

// Same test as testServiceConsumptionWithCallbackAndIntermittentAvailability, but the consumer is now
// an adapter for the Adaptee interface.
public void testFELIX4858_ServiceAdapterConsumptionWithCallbackAndIntermittentAvailability() {
    final DependencyManager m = getDM();
    // helper class that ensures certain steps get executed in sequence
    Ensure e = new Ensure();
    // create a service provider and consumer
    TemporalServiceProvider provider = new TemporalServiceProvider(e);
    Component sp = m.createComponent().setImplementation(provider).setInterface(TemporalServiceInterface.class.getName(), null);
    TemporalServiceProvider2 provider2 = new TemporalServiceProvider2(e);
    Component sp2 = m.createComponent().setImplementation(provider2).setInterface(TemporalServiceInterface.class.getName(), null);
    TemporalServiceConsumerAdapterWithCallback consumer = new TemporalServiceConsumerAdapterWithCallback(e);
    ServiceDependency temporalDep = m.createTemporalServiceDependency(10000).setService(TemporalServiceInterface.class).setRequired(true).setCallbacks("add", "remove");
    Component sc = m.createAdapterService(Adaptee.class, null).setImplementation(consumer).add(temporalDep);
    Component adaptee = m.createComponent().setImplementation(new Adaptee()).setInterface(Adaptee.class.getName(), null);
    // add the adapter service consumer
    m.add(sc);
    // add the adaptee (the adapter service depends on it)
    m.add(adaptee);
    // now add the first provider
    m.add(sp);
    e.waitForStep(2, 5000);
    // and remove it again (this should not affect the consumer yet)
    m.remove(sp);
    // now add the second provider
    m.add(sp2);
    e.step(3);
    e.waitForStep(4, 5000);
    // and remove it again
    m.remove(sp2);
    // finally remove the consumer
    m.remove(sc);
    // Wait for the consumer.remove callback
    e.waitForStep(6, 5000);
    // ensure we executed all steps inside the component instance
    e.step(7);
    m.clear();
}

Example 80 with Ensure

use of org.apache.felix.dm.itest.util.Ensure in project felix by apache.

the class AdapterWithCallbackInstanceTest method testServiceWithAdapterAndConsumer.

public void testServiceWithAdapterAndConsumer() {
    DependencyManager m = getDM();
    // helper class that ensures certain steps get executed in sequence
    Ensure e = new Ensure();
    ServiceProvider serviceProvider = new ServiceProvider(e);
    Component provider = m.createComponent().setInterface(OriginalService.class.getName(), null).setImplementation(serviceProvider);
    Component consumer = m.createComponent().setImplementation(new ServiceConsumer(e)).add(m.createServiceDependency().setService(AdaptedService.class).setRequired(true));
    ServiceAdapterCallbackInstance callbackInstance = new ServiceAdapterCallbackInstance(e);
    Component adapter = m.createAdapterService(OriginalService.class, null, "m_originalService", callbackInstance, "set", "changed", "unset", null, true).setInterface(AdaptedService.class.getName(), null).setImplementation(new ServiceAdapter(e));
    // add the provider and the adapter
    m.add(provider);
    m.add(adapter);
    // Checks if the callbackInstances is called, and if the adapter start method is called
    e.waitForStep(2, 5000);
    // add a consumer that will invoke the adapter
    // which will in turn invoke the original provider
    m.add(consumer);
    // now validate that both have been invoked in the right order
    e.waitForStep(4, 5000);
    // change the service properties of the provider, and check that the adapter callback instance is changed.
    serviceProvider.changeServiceProperties();
    e.waitForStep(5, 5000);
    // remove the provider
    m.remove(provider);
    // ensure that the consumer is stopped, the adapter callback is called in its unset method, and the adapter is stopped.
    e.waitForStep(8, 5000);
    // remove adapter and consumer
    m.remove(adapter);
    m.remove(consumer);
}