use of org.apache.felix.dm.itest.util.Ensure in project felix by apache.
the class TemporalAnnotationsTest method testTemporalServiceDependency.
public void testTemporalServiceDependency() {
Ensure ensure = new Ensure();
ServiceRegistration ensureReg = register(ensure, TemporalAnnotations.ENSURE);
Dictionary props = new Hashtable() {
{
put("test", "temporal");
}
};
Runnable r = Ensure.createRunnableStep(ensure, 1);
ServiceRegistration sr = context.registerService(Runnable.class.getName(), r, props);
ensure.waitForStep(1, 15000);
System.out.println("unregistering R");
sr.unregister();
ensure.step(2);
sleep(500);
r = Ensure.createRunnableStep(ensure, 3);
sr = context.registerService(Runnable.class.getName(), r, props);
ensure.waitForStep(3, 15000);
sr.unregister();
ensure.step(4);
sleep(1500);
ensure.waitForStep(5, 15000);
ensureReg.unregister();
}
use of org.apache.felix.dm.itest.util.Ensure in project felix by apache.
the class RemovedDependencyTest method testRemoveDependencyAndConsumerMustRemainStarted.
public void testRemoveDependencyAndConsumerMustRemainStarted() {
DependencyManager m = getDM();
// helper class that ensures certain steps get executed in sequence
Ensure e = new Ensure();
// Create two providers
Hashtable props = new Hashtable();
props.put("name", "provider1");
Component sp = m.createComponent().setImplementation(new ServiceProvider(e)).setInterface(ServiceInterface.class.getName(), props);
props = new Properties();
props.put("name", "provider2");
Component sp2 = m.createComponent().setImplementation(new ServiceProvider(e)).setInterface(ServiceInterface.class.getName(), props);
props = new Properties();
props.put("name", "provider3");
Component sp3 = m.createComponent().setImplementation(new ServiceProvider(e)).setInterface(ServiceInterface.class.getName(), props);
// Create the consumer, and start it
Dependency d1 = m.createServiceDependency().setService(ServiceInterface.class, "(name=provider1)").setRequired(true).setCallbacks("add", "remove");
Dependency d2 = m.createServiceDependency().setService(ServiceInterface.class, "(name=provider2)").setRequired(true).setCallbacks("add", "remove");
Dependency d3 = m.createServiceDependency().setService(ServiceInterface.class, "(name=provider3)").setRequired(true).setCallbacks("add", "remove");
ServiceConsumer consumer = new ServiceConsumer(e, d3);
Component sc = m.createComponent().setImplementation(consumer).add(d1, d2);
// Add the first two providers and the consumer
m.add(sp);
m.add(sp2);
m.add(sp3);
m.add(sc);
// Check if consumer has been bound to the three providers
e.waitForStep(3, 5000);
Assert.assertEquals(3, consumer.getProvidersCount());
Assert.assertNotNull(consumer.getProvider("provider1"));
Assert.assertNotNull(consumer.getProvider("provider2"));
Assert.assertNotNull(consumer.getProvider("provider3"));
// Now remove the provider2, and check if the consumer is still alive
sc.remove(d2);
Assert.assertFalse(consumer.isStopped());
Assert.assertEquals(2, consumer.getProvidersCount());
Assert.assertNotNull(consumer.getProvider("provider1"));
Assert.assertNull(consumer.getProvider("provider2"));
Assert.assertNotNull(consumer.getProvider("provider3"));
// Now remove the provider3 (the consumer has an instance bound dependency on it), and check if the consumer is still alive
sc.remove(d3);
Assert.assertFalse(consumer.isStopped());
Assert.assertEquals(1, consumer.getProvidersCount());
Assert.assertNotNull(consumer.getProvider("provider1"));
Assert.assertNull(consumer.getProvider("provider2"));
Assert.assertNull(consumer.getProvider("provider3"));
m.clear();
}
use of org.apache.felix.dm.itest.util.Ensure in project felix by apache.
the class ResourceAdapterDependencyAddAndRemoveTest method testBasicResourceAdapter.
public void testBasicResourceAdapter() throws Exception {
DependencyManager m = getDM();
// helper class that ensures certain steps get executed in sequence
Ensure e = new Ensure();
// create and add a service provider
m.add(m.createComponent().setInterface(ServiceInterface.class.getName(), null).setImplementation(new ServiceProvider(e)));
// create and add a resource provider
ResourceProvider provider = new ResourceProvider(context, new URL("file://localhost/path/to/file1.txt"));
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
// also, create a callback instance which will be used for both callbacks on resource changes and
// life cycle callbacks on the adapters themselves
Dependency d = m.createServiceDependency().setService(ServiceInterface.class).setRequired(true);
CallbackInstance callbackInstance = new CallbackInstance(e, d);
Component component = m.createResourceAdapterService("(&(path=/path/to/*.txt)(host=localhost))", false, callbackInstance, "changed").setImplementation(new ResourceAdapter(e)).setCallbacks(callbackInstance, "init", "start", "stop", "destroy");
// add the resource adapter
m.add(component);
// wait until the single resource is available (the adapter has been started)
e.waitForStep(1, 5000);
// trigger a 'change' in our resource
provider.change();
// wait until the changed callback is invoked
e.waitForStep(2, 5000);
// and has completed (ensuring no "extra" steps are invoked in the mean time)
e.waitForStep(3, 5000);
// remove the resource adapter again
// add a component state listener, in order to track resource adapter destruction
component.add(new ComponentStateListenerImpl(e));
m.remove(component);
// wait for the stopped callback in the state listener
e.waitForStep(4, 5000);
m.clear();
}
use of org.apache.felix.dm.itest.util.Ensure in project felix by apache.
the class ServiceDependencyTest method testServiceRegistrationAndConsumption.
public void testServiceRegistrationAndConsumption() {
DependencyManager m = getDM();
// helper class that ensures certain steps get executed in sequence
Ensure e = new Ensure();
// create a service provider and consumer
Component sp = m.createComponent().setImplementation(new ServiceProvider(e)).setInterface(ServiceInterface.class.getName(), null);
Component sc = m.createComponent().setImplementation(new ServiceConsumer(e)).add(m.createServiceDependency().setService(ServiceInterface.class).setRequired(true));
Component sc2 = m.createComponent().setImplementation(new ServiceConsumerCallbacks(e)).add(m.createServiceDependency().setService(ServiceInterface.class).setRequired(false).setCallbacks("add", "remove"));
m.add(sp);
m.add(sc);
m.remove(sc);
m.add(sc2);
m.remove(sp);
m.remove(sc2);
// ensure we executed all steps inside the component instance
e.step(6);
}
use of org.apache.felix.dm.itest.util.Ensure in project felix by apache.
the class ServiceRaceWithOrderedUnbindTest 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);
// Before creating the client, register a component listener to check
// the client is really started or deactivated.
ComponentStateListener clientListener = (c, s) -> {
switch(s) {
case TRACKING_OPTIONAL:
step.step(1);
break;
case INACTIVE:
step.step(2);
break;
default:
break;
}
};
client.add(clientListener);
// 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]);
}
// 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(() -> m_dm.add(s));
}
// Start the client (concurrently)
schedule(() -> m_dm.add(client));
// Ensure that client has been started.
// client has entered in TRACKING_OPTIONAL state
step.waitForStep(1, STEP_WAIT);
Assert.assertEquals(DEPENDENCIES, clientImpl.getDependencies());
// Make sure threadpool is quiescent, then deactivate all components.
if (!m_threadPool.awaitQuiescence(5000, TimeUnit.MILLISECONDS)) {
throw new RuntimeException("Could not start components timely.");
}
// Stop all dependencies, and client
schedule(() -> {
for (Component dep : deps) {
final Component dependency = dep;
m_dm.remove(dependency);
}
m_dm.remove(client);
});
// Ensure that client has been stopped, then destroyed, then unbound from all dependencies
// Client entered in INACTIVE state
step.waitForStep(2, STEP_WAIT);
step.ensure();
Assert.assertEquals(0, clientImpl.getDependencies());
// Make sure threadpool is quiescent before doing next iteration.
if (!m_threadPool.awaitQuiescence(5000, TimeUnit.MILLISECONDS)) {
throw new RuntimeException("Could not start components timely.");
}
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();
}
}
Aggregations