Examples with DestroyedModule org.opendaylight.controller.config.manager.impl.dependencyresolver.DestroyedModule used on opensource projects

Example 1 with DestroyedModule

use of org.opendaylight.controller.config.manager.impl.dependencyresolver.DestroyedModule in project controller by opendaylight.

the class ConfigRegistryImpl method secondPhaseCommit.

@GuardedBy("configTransactionLock")
private CommitStatus secondPhaseCommit(final ConfigTransactionControllerInternal configTransactionController, final CommitInfo commitInfo, final ConfigTransactionLookupRegistry txLookupRegistry) {
    // (hopefully) runtime beans
    for (DestroyedModule toBeDestroyed : commitInfo.getDestroyedFromPreviousTransactions()) {
        // closes instance (which should close
        // runtime jmx registrator),
        // also closes osgi registration and ModuleJMXRegistrator
        // registration
        toBeDestroyed.close();
        currentConfig.remove(toBeDestroyed.getIdentifier());
    }
    // set RuntimeBeanRegistrators on beans implementing
    // RuntimeBeanRegistratorAwareModule
    Map<ModuleIdentifier, RootRuntimeBeanRegistratorImpl> runtimeRegistrators = new HashMap<>();
    for (ModuleInternalTransactionalInfo entry : commitInfo.getCommitted().values()) {
        // set runtime jmx registrator if required
        Module module = entry.getProxiedModule();
        RootRuntimeBeanRegistratorImpl runtimeBeanRegistrator = null;
        if (module instanceof RuntimeBeanRegistratorAwareModule) {
            if (entry.hasOldModule()) {
                if (module.canReuse(entry.getOldInternalInfo().getReadableModule().getModule())) {
                    runtimeBeanRegistrator = entry.getOldInternalInfo().getRuntimeBeanRegistrator();
                    ((RuntimeBeanRegistratorAwareModule) module).setRuntimeBeanRegistrator(runtimeBeanRegistrator);
                } else {
                    runtimeBeanRegistrator = baseJMXRegistrator.createRuntimeBeanRegistrator(entry.getIdentifier());
                    entry.getOldInternalInfo().getRuntimeBeanRegistrator().close();
                    ((RuntimeBeanRegistratorAwareModule) module).setRuntimeBeanRegistrator(runtimeBeanRegistrator);
                }
            } else {
                runtimeBeanRegistrator = baseJMXRegistrator.createRuntimeBeanRegistrator(entry.getIdentifier());
                ((RuntimeBeanRegistratorAwareModule) module).setRuntimeBeanRegistrator(runtimeBeanRegistrator);
            }
        }
        // save it to info so it is accessible afterwards
        if (runtimeBeanRegistrator != null) {
            runtimeRegistrators.put(entry.getIdentifier(), runtimeBeanRegistrator);
        }
    }
    // can register runtime beans
    List<ModuleIdentifier> orderedModuleIdentifiers = configTransactionController.secondPhaseCommit();
    txLookupRegistry.close();
    configTransactionController.close();
    // copy configuration to read only mode
    List<ObjectName> newInstances = new LinkedList<>();
    List<ObjectName> reusedInstances = new LinkedList<>();
    List<ObjectName> recreatedInstances = new LinkedList<>();
    Map<Module, ModuleInternalInfo> newConfigEntries = new HashMap<>();
    int orderingIdx = 0;
    for (ModuleIdentifier moduleIdentifier : orderedModuleIdentifiers) {
        LOG.trace("Registering {}", moduleIdentifier);
        ModuleInternalTransactionalInfo entry = commitInfo.getCommitted().get(moduleIdentifier);
        if (entry == null) {
            throw new NullPointerException("Module not found " + moduleIdentifier);
        }
        ObjectName primaryReadOnlyON = ObjectNameUtil.createReadOnlyModuleON(moduleIdentifier);
        // determine if current instance was recreated or reused or is new
        // rules for closing resources:
        // osgi registration - will be reused if possible.
        // module jmx registration - will be (re)created every time, needs
        // to be closed here
        // runtime jmx registration - should be taken care of by module
        // itself
        // instance - is closed only if it was destroyed
        ModuleJMXRegistrator newModuleJMXRegistrator = baseJMXRegistrator.createModuleJMXRegistrator();
        OsgiRegistration osgiRegistration = null;
        AutoCloseable instance = entry.getProxiedModule().getInstance();
        if (entry.hasOldModule()) {
            ModuleInternalInfo oldInternalInfo = entry.getOldInternalInfo();
            DynamicReadableWrapper oldReadableConfigBean = oldInternalInfo.getReadableModule();
            currentConfig.remove(entry.getIdentifier());
            // test if old instance == new instance
            if (oldReadableConfigBean.getInstance().equals(instance)) {
                // reused old instance:
                // wrap in readable dynamic mbean
                reusedInstances.add(primaryReadOnlyON);
                osgiRegistration = oldInternalInfo.getOsgiRegistration();
            } else {
                // recreated instance:
                // it is responsibility of module to call the old instance -
                // we just need to unregister configbean
                recreatedInstances.add(primaryReadOnlyON);
                // close old osgi registration
                oldInternalInfo.getOsgiRegistration().close();
            }
            // close old module jmx registrator
            oldInternalInfo.getModuleJMXRegistrator().close();
            // We no longer need old internal info. Clear it out, so we do not create a
            // serial leak evidenced
            // by BUG-4514. The reason is that modules retain their resolver, which retains
            // modules. If we retain
            // the old module, we would have the complete reconfiguration history held in
            // heap for no good reason.
            entry.clearOldInternalInfo();
        } else {
            // new instance:
            // wrap in readable dynamic mbean
            newInstances.add(primaryReadOnlyON);
        }
        Module realModule = entry.getRealModule();
        DynamicReadableWrapper newReadableConfigBean = new DynamicReadableWrapper(realModule, instance, moduleIdentifier, registryMBeanServer, configMBeanServer);
        // register to JMX
        try {
            newModuleJMXRegistrator.registerMBean(newReadableConfigBean, primaryReadOnlyON);
        } catch (final InstanceAlreadyExistsException e) {
            throw new IllegalStateException("Possible code error, already registered:" + primaryReadOnlyON, e);
        }
        // register services to OSGi
        Map<ServiceInterfaceAnnotation, String> annotationMapping = configTransactionController.getWritableRegistry().findServiceInterfaces(moduleIdentifier);
        BundleContext bc = configTransactionController.getModuleFactoryBundleContext(entry.getModuleFactory().getImplementationName());
        if (osgiRegistration == null) {
            osgiRegistration = beanToOsgiServiceManager.registerToOsgi(newReadableConfigBean.getInstance(), moduleIdentifier, bc, annotationMapping);
        } else {
            osgiRegistration.updateRegistrations(annotationMapping, bc, instance);
        }
        RootRuntimeBeanRegistratorImpl runtimeBeanRegistrator = runtimeRegistrators.get(entry.getIdentifier());
        ModuleInternalInfo newInfo = new ModuleInternalInfo(entry.getIdentifier(), newReadableConfigBean, osgiRegistration, runtimeBeanRegistrator, newModuleJMXRegistrator, orderingIdx, entry.isDefaultBean(), entry.getModuleFactory(), entry.getBundleContext());
        newConfigEntries.put(realModule, newInfo);
        orderingIdx++;
    }
    currentConfig.addAll(newConfigEntries.values());
    // update version
    version = configTransactionController.getVersion();
    // switch readable Service Reference Registry
    synchronized (readableSRRegistryLock) {
        readableSRRegistry.close();
        readableSRRegistry = ServiceReferenceRegistryImpl.createSRReadableRegistry(configTransactionController.getWritableRegistry(), this, baseJMXRegistrator);
    }
    return new CommitStatus(newInstances, reusedInstances, recreatedInstances);
}

Example 2 with DestroyedModule

use of org.opendaylight.controller.config.manager.impl.dependencyresolver.DestroyedModule in project controller by opendaylight.

the class ConfigRegistryImpl method close.

/**
 * Abort open transactions and unregister read only modules. Since this class is
 * not responsible for registering itself under
 * {@link org.opendaylight.controller.config.api.ConfigRegistry#OBJECT_NAME}, it
 * will not unregister itself here.
 */
@Override
public void close() {
    if (!closed.compareAndSet(false, true)) {
        return;
    }
    // abort transactions
    Map<String, Entry<ConfigTransactionControllerInternal, ConfigTransactionLookupRegistry>> transactions = transactionsHolder.getCurrentTransactions();
    for (Entry<ConfigTransactionControllerInternal, ConfigTransactionLookupRegistry> configTransactionControllerEntry : transactions.values()) {
        ConfigTransactionControllerInternal configTransactionController = configTransactionControllerEntry.getKey();
        configTransactionControllerEntry.getValue().close();
        configTransactionController.abortConfig();
    }
    // destroy all live objects one after another in order of the dependency
    // hierarchy, from top to bottom
    List<DestroyedModule> destroyedModules = currentConfig.getModulesToBeDestroyed();
    LOG.info("ConfigRegistry closing - destroying {} modules", destroyedModules.size());
    for (DestroyedModule destroyedModule : destroyedModules) {
        destroyedModule.close();
    }
    // unregister MBeans that failed to unregister properly
    baseJMXRegistrator.close();
    // remove jmx servers
    MBeanServerFactory.releaseMBeanServer(registryMBeanServer);
    MBeanServerFactory.releaseMBeanServer(transactionsMBeanServer);
    LOG.info("ConfigRegistry closed");
}