private void onContainerAdded(Entity newContainer) { subscriptions().subscribe(newContainer, Startable.SERVICE_UP, eventHandler); if (!(newContainer instanceof Startable) || Boolean.TRUE.equals(newContainer.getAttribute(Startable.SERVICE_UP))) { onContainerUp(newContainer); } }
/** * @deprecated since 0.9.0; see {@code subscriptions().subscribeToMembers(producer, sensor, listener)} */ @Override @Deprecated public <T> SubscriptionHandle subscribeToMembers(Group group, Sensor<T> sensor, SensorEventListener<? super T> listener) { return subscriptions().subscribeToMembers(group, sensor, listener); }
private void onItemRemoved(Entity item) { if (items.remove(item)) { subscriptions().unsubscribe(item); sensors().emit(ITEM_REMOVED, item); } }
if (urlMappings!=null && urlMappingsMemberTrackerPolicy==null) { targetAddressesHandler = subscriptions().subscribeToMembers(urlMappings, UrlMapping.TARGET_ADDRESSES, new SensorEventListener<Collection<String>>() { @Override public void onEvent(SensorEvent<Collection<String>> event) { updateNeeded();
@Override public synchronized void recompute() { if (subscriptionHandle != null) subscriptions().unsubscribe(subscriptionHandle); if (subscriptionHandle2 != null) subscriptions().unsubscribe(subscriptionHandle2); Entity t = getTarget(); if (t != null) { subscriptionHandle = subscriptions().subscribeToChildren(t, Startable.SERVICE_UP, new SensorEventListener<Boolean>() { @Override public void onEvent(SensorEvent<Boolean> event) { boolean changed = (event.getValue()) ? addMember(event.getSource()) : removeMember(event.getSource()); if (changed) { recomputeAddresses(); } }}); subscriptionHandle2 = subscriptions().subscribe(t, Changeable.MEMBER_REMOVED, new SensorEventListener<Entity>() { @Override public void onEvent(SensorEvent<Entity> event) { removeMember(event.getValue()); // recompute, irrespective of change, because framework may have already invoked the removeMember call recomputeAddresses(); }}); setMembers(t.getChildren(), EntityPredicates.attributeEqualTo(Startable.SERVICE_UP, true)); } recomputeAddresses(); }
private void onReconstruct() { if (getConfig(SUBSCRIBE) != null) { subscriptions().getSubscriptionContext().subscribe(null, getConfig(SUBSCRIBE), new SensorEventListener<Object>() { @Override public void onEvent(SensorEvent<Object> event) { events.add(event.getValue()); }}); } if (getConfig(PUBLISH) != null) { sensors().set(MY_SENSOR, getConfig(PUBLISH)); } if (latching) { reconstructStartedLatch.countDown(); try { reconstructContinuesLatch.await(); } catch (InterruptedException e) { throw new RuntimeInterruptedException(e); } } }
@Override public void setContents(Group containerGroup, Group itemGroup) { this.containerGroup = containerGroup; this.itemGroup = itemGroup; if (resizable == null && containerGroup instanceof Resizable) resizable = (Resizable) containerGroup; subscriptions().subscribe(containerGroup, AbstractGroup.MEMBER_ADDED, eventHandler); subscriptions().subscribe(containerGroup, AbstractGroup.MEMBER_REMOVED, eventHandler); subscriptions().subscribe(itemGroup, AbstractGroup.MEMBER_ADDED, eventHandler); subscriptions().subscribe(itemGroup, AbstractGroup.MEMBER_REMOVED, eventHandler); // Process extant containers and items for (Entity existingContainer : containerGroup.getMembers()) { onContainerAdded((BalanceableContainer<?>)existingContainer); } for (Entity existingItem : itemGroup.getMembers()) { onItemAdded(existingItem); } }
public void propagateSensorStringReplacingWithSubnetAddress(final Entity target, final AttributeSensor<String> sensor) { SensorPropagaterWithReplacement mapper = new SensorPropagaterWithReplacement(this, sensor, new Function<String,String>() { @Override public String apply(String input) { if (input==null) return null; String subnetHostname = target.getAttribute(SUBNET_HOSTNAME_SENSOR); log.debug("sensor mapper replacing address in "+this+"->"+sensor+", with "+subnetHostname+", where old address in "+target); String output = input; output = replaceIfNotNull(output, target.getAttribute(SoftwareProcess.HOSTNAME), subnetHostname); output = replaceIfNotNull(output, target.getAttribute(SoftwareProcess.ADDRESS), subnetHostname); return output; } }); subscriptions().subscribe(target, sensor, mapper); mapper.apply( target.getAttribute(sensor) ); }
@Override public void setContents(Group containerGroup, Group itemGroup) { this.containerGroup = containerGroup; this.itemGroup = itemGroup; subscriptions().subscribe(containerGroup, AbstractGroup.MEMBER_ADDED, eventHandler); subscriptions().subscribe(containerGroup, AbstractGroup.MEMBER_REMOVED, eventHandler); subscriptions().subscribe(itemGroup, AbstractGroup.MEMBER_ADDED, eventHandler); subscriptions().subscribe(itemGroup, AbstractGroup.MEMBER_REMOVED, eventHandler); // Process extant containers and items for (Entity existingContainer : containerGroup.getMembers()) { onContainerAdded(existingContainer); } for (Entity existingItem : itemGroup.getMembers()) { onItemAdded(existingItem); } }
protected SubscriptionTracker getSubscriptionTracker() { if (_subscriptionTracker != null) { return _subscriptionTracker; } // TODO Would be nice to simplify concurrent model, and not synchronize on // AbstractEntity.this; perhaps could get rid of lazy-initialisation, but then // would need to first ensure `managementSupport` is definitely initialised. SubscriptionContext subscriptionContext = getSubscriptionContext(); synchronized (AbstractEntity.this) { if (_subscriptionTracker == null) { _subscriptionTracker = new SubscriptionTracker(subscriptionContext); } return _subscriptionTracker; } } }
private void onContainerRemoved(Entity oldContainer) { subscriptions().unsubscribe(oldContainer); onContainerDown(oldContainer); }
private void onContainerRemoved(BalanceableContainer<?> oldContainer) { subscriptions().unsubscribe(oldContainer); onContainerDown(oldContainer); }
@Override public <T> SubscriptionHandle subscribeToMembers(Group parent, Sensor<T> sensor, SensorEventListener<? super T> listener) { return subscriptions().subscribeToMembers(parent, sensor, listener); }
private void initSubscriptions() { subscriptions().subscribeToMembers(this, MySqlNode.SERVICE_PROCESS_IS_RUNNING, new NodeRunningListener(this)); subscriptions().subscribe(this, MEMBER_REMOVED, new MemberRemovedListener()); }
@Override public void openFirewallPortAndAssign(Entity serviceToForward, AttributeSensor<?> servicePortSensor, Integer optionalPublicPort, Cidr accessingCidr, Entity whereToAdvertisePublicServiceEndpoint, AttributeSensor<String> sensorAdvertisingHostnameAndPort) { FirewallUpdater updater = new FirewallUpdater(serviceToForward, servicePortSensor, optionalPublicPort, accessingCidr, whereToAdvertisePublicServiceEndpoint, sensorAdvertisingHostnameAndPort); subscriptions().subscribe(serviceToForward, servicePortSensor, updater); // either of these may be null when the above comes through // FIXME Should PUBLIC_HOSTNAME be subscribed to `this`, rather than serviceToForward subscriptions().subscribe(serviceToForward, Attributes.HOSTNAME, updater); subscriptions().subscribe(serviceToForward, PUBLIC_HOSTNAME, updater); }
private void onContainerAdded(BalanceableContainer<?> newContainer) { subscriptions().subscribe(newContainer, Startable.SERVICE_UP, eventHandler); if (!(newContainer instanceof Startable) || Boolean.TRUE.equals(newContainer.getAttribute(Startable.SERVICE_UP))) { onContainerUp(newContainer); } }
protected void subscribeToServiceState() { stateListener = new RecordingSensorEventListener<Lifecycle>(); subscriptions().subscribe(this, SERVICE_STATE_ACTUAL, stateListener); upListener = new RecordingSensorEventListener<Boolean>(); subscriptions().subscribe(this, SERVICE_UP, upListener); processRunningListener = new RecordingSensorEventListener<Boolean>(); subscriptions().subscribe(this, SERVICE_PROCESS_IS_RUNNING, processRunningListener); }
@Override public void openFirewallPortRange(EntityAndAttribute<String> publicIp, int lowerBoundPort, int upperBoundPort, FirewallRule.Protocol protocol, Cidr accessingCidr) { SimpleFirewallUpdater updater = new SimpleFirewallUpdater(publicIp, lowerBoundPort, upperBoundPort, protocol, accessingCidr); subscriptions().subscribe(publicIp.getEntity(), publicIp.getAttribute(), updater); updater.apply(publicIp.getEntity(), publicIp.getValue()); }
@Override public void openPublicIp(EntityAndAttribute<String> whereToAdvertiseHostname) { PublicIPUpdater updater = new PublicIPUpdater(whereToAdvertiseHostname); subscriptions().subscribe(this, NETWORK_ID, updater); }