this.config = config; if (supportsDataField(TYPE_FIELD_ID) && hasConfigField(TYPE_FIELD_ID)) { setDataField(TYPE_FIELD_ID, getConfigField(TYPE_FIELD_ID)); if (supportsDataField(TYPE_FIELD_LABEL) && hasConfigField(TYPE_FIELD_LABEL)) { setDataField(TYPE_FIELD_LABEL, getConfigField(TYPE_FIELD_LABEL)); if (isActive() && !currentScope.equals(detectScope(config))) { currentScope = detectScope(); super.init(currentScope);
private Scope detectScope() throws NotAvailableException { synchronized (CONFIG_LOCK) { return detectScope(getConfig()); } }
protected final Object getConfigField(String name) throws CouldNotPerformException { synchronized (CONFIG_LOCK) { return getConfigField(name, getConfig()); } }
@Override public void init(Scope scope, ParticipantConfig participantConfig) throws InitializationException, InterruptedException { super.init(scope, participantConfig); try { RPCHelper.registerInterface(AuthenticatedRequestable.class, this, server); } catch (CouldNotPerformException ex) { throw new InitializationException(this, ex); } }
/** * Initialize the controller with a configuration. * * @param config the configuration * @throws InitializationException if the initialization fails * @throws java.lang.InterruptedException if the initialization is interrupted */ @Override public void init(final CONFIG config) throws InitializationException, InterruptedException { synchronized (CONFIG_LOCK) { try { if (config == null) { throw new NotAvailableException("config"); } currentScope = detectScope(config); applyConfigUpdate(config); super.init(currentScope); } catch (CouldNotPerformException ex) { throw new InitializationException(this, ex); } } }
return super.applyConfigUpdate(config);
private Scope detectScope(final CONFIG config) throws NotAvailableException { try { return (Scope) getConfigField(FIELD_SCOPE, config); } catch (CouldNotPerformException ex) { throw new NotAvailableException("scope"); } }
public AbstractUnitController(final Class unitClass, final DB builder) throws InstantiationException { super(builder); this.serviceList = new ArrayList<>(); this.unitDataObservableMap = new HashMap<>(); this.serviceTempusServiceTypeObservableMap = new HashMap<>(); for (final ServiceTempus serviceTempus : ServiceTempus.values()) { unitDataObservableMap.put(serviceTempus, new UnitDataFilteredObservable<>(this, serviceTempus)); super.addDataObserver((Observable<D> source, D data) -> { unitDataObservableMap.get(serviceTempus).notifyObservers(data); }); serviceTempusServiceTypeObservableMap.put(serviceTempus, new HashMap<>()); } this.unitRegistryObserver = new Observer<UnitRegistryData>() { @Override public void update(Observable<UnitRegistryData> source, UnitRegistryData data) throws Exception { try { final UnitConfig newUnitConfig = Registries.getUnitRegistry(true).getUnitConfigById(getId()); if (!newUnitConfig.equals(getConfig())) { applyConfigUpdate(newUnitConfig); } } catch (NotAvailableException ex) { // unit config has been removed, probably because of deletion and a higher controller will do the shutdown in this case logger.debug("Could not update unit controller", ex); } catch (CouldNotPerformException ex) { ExceptionPrinter.printHistory("Could not update unit config of " + this, ex, logger); } } }; }
@Override protected void postInit() throws InitializationException, InterruptedException { try { super.postInit(); if (!initialized) { Registries.getUnitRegistry().addDataObserver(unitRegistryObserver); initialized = true; } } catch (CouldNotPerformException ex) { throw new InitializationException(this, ex); } }
@Override protected void notifyDataUpdate(final D data) throws CouldNotPerformException { super.notifyDataUpdate(data); for (final ServiceTempus serviceTempus : ServiceTempus.values()) { final Set<ServiceType> serviceTypeSet = new HashSet<>(); for (final ServiceDescription serviceDescription : getUnitTemplate().getServiceDescriptionList()) { // check if already handled if (!serviceTypeSet.contains(serviceDescription.getType())) { serviceTypeSet.add(serviceDescription.getType()); try { Object serviceData = Services.invokeServiceMethod(serviceDescription.getType(), ServicePattern.PROVIDER, serviceTempus, data); serviceTempusServiceTypeObservableMap.get(serviceTempus).get(serviceDescription.getType()).notifyObservers(serviceData); } catch (CouldNotPerformException ex) { logger.debug("Could not notify state update for service[" + serviceDescription.getType() + "] because this service is not supported by this controller.", ex); } } } } }
@Override public void init(ScopeType.Scope scope) throws InitializationException, InterruptedException { try { super.init(Registries.getUnitRegistry(true).getUnitConfigByScope(scope)); } catch (CouldNotPerformException ex) { throw new InitializationException(this, ex); } }
@Override public void init(final UnitConfig config) throws InitializationException, InterruptedException { try { if (config == null) { throw new NotAvailableException("config"); } if (!config.hasId()) { throw new NotAvailableException("config.id"); } if (config.getId().isEmpty()) { throw new NotAvailableException("Field config.id is empty!"); } if (!config.hasLabel()) { throw new NotAvailableException("config.label"); } if (config.getLabel().isEmpty()) { throw new NotAvailableException("Field config.label is emty!"); } super.init(config); } catch (CouldNotPerformException ex) { throw new InitializationException(this, ex); } }