@Override public <T> SubscriptionHandle subscribe(Map<String, ?> newFlags, Entity producer, Sensor<T> sensor, SensorEventListener<? super T> listener) { Map<String,Object> subscriptionFlags = Maps.newLinkedHashMap(flags); if (newFlags != null) subscriptionFlags.putAll(newFlags); return manager.subscribe(subscriptionFlags, producer, sensor, listener); }
/** @see SubscriptionManager#publish(SensorEvent) */ @Override public <T> void publish(SensorEvent<T> event) { manager.publish(event); }
/** Return the subscriptions associated with this context */ @Override public Set<SubscriptionHandle> getSubscriptions() { return manager.getSubscriptionsForSubscriber(subscriber); }
final List<Object> events = new CopyOnWriteArrayList<Object>(); newManagementContext.getSubscriptionManager().subscribe(null, MyLatchingEntityImpl.MY_SENSOR, new SensorEventListener<Object>() { @Override public void onEvent(SensorEvent<Object> event) { events.add(event.getValue()); newManagementContext.getSubscriptionManager().publish(new BasicSensorEvent<String>(TestApplication.MY_ATTRIBUTE, null, "myvaltooearly")); Asserts.continually(Suppliers.ofInstance(MyLatchingEntityImpl.events), Predicates.equalTo(Collections.emptyList())); newManagementContext.getSubscriptionManager().publish(new BasicSensorEvent<String>(TestApplication.MY_ATTRIBUTE, null, "myvaltoreceive")); Asserts.eventually(Suppliers.ofInstance(MyLatchingEntityImpl.events), Predicates.<List<Object>>equalTo(ImmutableList.of((Object)"myvaltoreceive")));
@Override public <T> SubscriptionHandle subscribeToChildren(Map<String, Object> newFlags, Entity parent, Sensor<T> sensor, SensorEventListener<? super T> listener) { Map<String,Object> subscriptionFlags = Maps.newLinkedHashMap(flags); if (newFlags != null) subscriptionFlags.putAll(newFlags); return manager.subscribeToChildren(subscriptionFlags, parent, sensor, listener); }
@Override public <T> SubscriptionHandle subscribeToMembers(Map<String, Object> newFlags, Group parent, Sensor<T> sensor, SensorEventListener<? super T> listener) { Map<String,Object> subscriptionFlags = Maps.newLinkedHashMap(flags); if (newFlags != null) subscriptionFlags.putAll(newFlags); return manager.subscribeToMembers(subscriptionFlags, parent, sensor, listener); }
@SuppressWarnings("rawtypes") @Override public boolean unsubscribe(SubscriptionHandle subscriptionId) { Preconditions.checkNotNull(subscriptionId, "subscriptionId must not be null"); Preconditions.checkArgument(Objects.equal(subscriber, ((Subscription) subscriptionId).subscriber), "The subscriptionId is for a different "+subscriber+"; expected "+((Subscription) subscriptionId).subscriber); return manager.unsubscribe(subscriptionId); }
@BeforeMethod(alwaysRun=true) @Override public void setUp() throws Exception { super.setUp(); events = new CopyOnWriteArrayList<SensorEvent<FailureDescriptor>>(); app.getManagementContext().getSubscriptionManager().subscribe( app, HASensors.CONNECTION_FAILED, new SensorEventListener<FailureDescriptor>() { @Override public void onEvent(SensorEvent<FailureDescriptor> event) { events.add(event); } }); app.getManagementContext().getSubscriptionManager().subscribe( app, HASensors.CONNECTION_RECOVERED, new SensorEventListener<FailureDescriptor>() { @Override public void onEvent(SensorEvent<FailureDescriptor> event) { events.add(event); } }); serverSocketAddress = startServerSocket(); }
app.getManagementContext().getSubscriptionManager().subscribe(javaProcess, VanillaJavaApp.PROCESS_CPU_TIME_FRACTION_LAST, new SensorEventListener<Double>() { @Override public void onEvent(SensorEvent<Double> event) {
subscriptionManager.subscribe(MutableMap.<String, Object>of("subscriber", i), entities.get(1), TestEntity.SEQUENCE, new SensorEventListener<Integer>() { @Override public void onEvent(SensorEvent<Integer> event) { throw exception.get(); }}); subscriptionManager.subscribe(MutableMap.<String, Object>of("subscriber", i), entity, TestEntity.MY_NOTIF, new SensorEventListener<Integer>() { @Override public void onEvent(SensorEvent<Integer> event) {
@BeforeMethod(alwaysRun=true) @Override public void setUp() throws Exception { super.setUp(); events = new CopyOnWriteArrayList<SensorEvent<FailureDescriptor>>(); eventListener = new SensorEventListener<FailureDescriptor>() { @Override public void onEvent(SensorEvent<FailureDescriptor> event) { events.add(event); } }; e1 = app.createAndManageChild(EntitySpec.create(TestEntity.class)); e1.enrichers().add(ServiceStateLogic.newEnricherForServiceStateFromProblemsAndUp()); app.getManagementContext().getSubscriptionManager().subscribe(e1, HASensors.ENTITY_FAILED, eventListener); app.getManagementContext().getSubscriptionManager().subscribe(e1, HASensors.ENTITY_RECOVERED, eventListener); }
subscriptionManager.subscribe(MutableMap.<String, Object>of("subscriber", i), entity, TestEntity.SEQUENCE, new SensorEventListener<Integer>() { @Override public void onEvent(SensorEvent<Integer> event) {
@Test public void testAddingAndRemovingGroupEmitsNotification() throws Exception { final RecordingSensorEventListener<Group> groupAddedListener = new RecordingSensorEventListener<>(); final RecordingSensorEventListener<Group> groupRemovedListener = new RecordingSensorEventListener<>(); mgmt.getSubscriptionManager().subscribe(entity1, AbstractEntity.GROUP_ADDED, groupAddedListener); mgmt.getSubscriptionManager().subscribe(entity1, AbstractEntity.GROUP_REMOVED, groupRemovedListener); group.addMember(entity1); Asserts.succeedsEventually(new Runnable() { @Override public void run() { String msg = "events="+groupAddedListener.getEvents(); assertEquals(groupAddedListener.getEvents().size(), 1, msg); assertEquals(groupAddedListener.getEvents().get(0).getSource(), entity1, msg); assertEquals(groupAddedListener.getEvents().get(0).getSensor(), AbstractEntity.GROUP_ADDED, msg); }}); assertEquals(groupRemovedListener.getEvents().size(), 0, "events="+groupRemovedListener.getEvents()); group.removeMember(entity1); Asserts.succeedsEventually(new Runnable() { @Override public void run() { String msg = "events="+groupRemovedListener.getEvents(); assertEquals(groupRemovedListener.getEvents().size(), 1, msg); assertEquals(groupRemovedListener.getEvents().get(0).getSource(), entity1, msg); assertEquals(groupRemovedListener.getEvents().get(0).getSensor(), AbstractEntity.GROUP_REMOVED, msg); }}); assertEquals(groupAddedListener.getEvents().size(), 1, "events="+groupAddedListener.getEvents()); }
subscriptionManager.subscribe(MutableMap.<String, Object>of("subscriber", i), entity, TestEntity.SEQUENCE, new SensorEventListener<Integer>() { @Override public void onEvent(SensorEvent<Integer> event) {
@BeforeMethod(alwaysRun=true) @Override public void setUp() throws Exception { super.setUp(); events = new CopyOnWriteArrayList<SensorEvent<FailureDescriptor>>(); e1 = app.createAndManageChild(EntitySpec.create(TestEntity.class)); e1.sensors().set(TestEntity.SERVICE_UP, true); ServiceStateLogic.setExpectedState(e1, Lifecycle.RUNNING); app.getManagementContext().getSubscriptionManager().subscribe( e1, HASensors.ENTITY_FAILED, new SensorEventListener<FailureDescriptor>() { @Override public void onEvent(SensorEvent<FailureDescriptor> event) { events.add(event); } }); app.getManagementContext().getSubscriptionManager().subscribe( e1, HASensors.ENTITY_RECOVERED, new SensorEventListener<FailureDescriptor>() { @Override public void onEvent(SensorEvent<FailureDescriptor> event) { events.add(event); } }); }
@Test public void testServiceFailureDetectorWorksAfterRebind() throws Exception { origEntity.enrichers().add(EnricherSpec.create(ServiceFailureDetector.class)); // rebind TestApplication newApp = rebind(); final TestEntity newEntity = (TestEntity) Iterables.find(newApp.getChildren(), Predicates.instanceOf(TestEntity.class)); newApp.getManagementContext().getSubscriptionManager().subscribe(newEntity, HASensors.ENTITY_FAILED, eventListener); newEntity.sensors().set(TestEntity.SERVICE_UP, true); ServiceStateLogic.setExpectedState(newEntity, Lifecycle.RUNNING); // trigger the failure newEntity.sensors().set(TestEntity.SERVICE_UP, false); assertHasEventEventually(HASensors.ENTITY_FAILED, Predicates.<Object>equalTo(newEntity), null); assertEquals(events.size(), 1, "events="+events); }
@Test public void testTransformingRespectsUnchangedButWillRepublish() throws Exception { RecordingSensorEventListener<String> record = new RecordingSensorEventListener<>(); app.getManagementContext().getSubscriptionManager().subscribe(entity, STR2, record);
public void testTransformingSuppressDuplicates() { RecordingSensorEventListener<String> record = new RecordingSensorEventListener<>(); app.getManagementContext().getSubscriptionManager().subscribe(entity, STR2, record); entity.enrichers().add(Enrichers.builder() .transforming(STR1) .publishing(STR2) .computing(Functions.<String>identity()) .suppressDuplicates(true) .build()); entity.sensors().set(STR1, "myval"); Asserts.eventually(Suppliers.ofInstance(record), CollectionFunctionals.sizeEquals(1)); EntityAsserts.assertAttributeEquals(entity, STR2, "myval"); entity.sensors().set(STR1, "myval2"); entity.sensors().set(STR1, "myval2"); entity.sensors().set(STR1, "myval3"); EntityAsserts.assertAttributeEqualsContinually(entity, STR2, "myval3"); Asserts.assertThat(record.getEvents(), CollectionFunctionals.sizeEquals(3)); }