*/
package org.opendaylight.controller.config.manager.impl;
-import static com.google.common.base.Preconditions.checkNotNull;
-import static java.lang.String.format;
-
+import com.google.common.base.Preconditions;
import com.google.common.collect.Lists;
import java.util.ArrayList;
import java.util.Collection;
import javax.management.MBeanServer;
import javax.management.ObjectName;
import org.opendaylight.controller.config.api.DependencyResolver;
+import org.opendaylight.controller.config.api.ModuleFactoryNotFoundException;
import org.opendaylight.controller.config.api.ModuleIdentifier;
import org.opendaylight.controller.config.api.ValidationException;
import org.opendaylight.controller.config.api.annotations.ServiceInterfaceAnnotation;
import org.opendaylight.controller.config.manager.impl.jmx.TransactionModuleJMXRegistrator.TransactionModuleJMXRegistration;
import org.opendaylight.controller.config.manager.impl.osgi.mapping.BindingContextProvider;
import org.opendaylight.controller.config.manager.impl.util.InterfacesHelper;
+import org.opendaylight.controller.config.spi.AbstractModule;
import org.opendaylight.controller.config.spi.Module;
import org.opendaylight.controller.config.spi.ModuleFactory;
import org.opendaylight.yangtools.concepts.Identifiable;
import org.osgi.framework.BundleContext;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
+
/**
* This is a JMX bean representing current transaction. It contains
* transaction identifier, unique version and parent version for
private final ConfigTransactionLookupRegistry txLookupRegistry;
private final ObjectName controllerON;
- private final long parentVersion, currentVersion;
+ private final long parentVersion;
+ private final long currentVersion;
private final HierarchicalConfigMBeanFactoriesHolder factoriesHolder;
private final DependencyResolverManager dependencyResolverManager;
private final TransactionStatus transactionStatus;
List<ModuleFactory> toBeAdded = new ArrayList<>();
List<ModuleFactory> toBeRemoved = new ArrayList<>();
for (ModuleFactory moduleFactory : factoriesHolder.getModuleFactories()) {
- if (oldSet.contains(moduleFactory) == false) {
+ if (!oldSet.contains(moduleFactory)) {
toBeAdded.add(moduleFactory);
}
}
for (ModuleFactory moduleFactory : lastListOfFactories) {
- if (newSet.contains(moduleFactory) == false) {
+ if (!newSet.contains(moduleFactory)) {
toBeRemoved.add(moduleFactory);
}
}
}
- private synchronized void copyExistingModule(ModuleInternalInfo oldConfigBeanInfo) throws InstanceAlreadyExistsException {
+ private synchronized void copyExistingModule(ModuleInternalInfo oldConfigBeanInfo)
+ throws InstanceAlreadyExistsException {
transactionStatus.checkNotCommitStarted();
transactionStatus.checkNotAborted();
try {
moduleFactory = factoriesHolder.findByModuleName(moduleIdentifier.getFactoryName());
bc = getModuleFactoryBundleContext(moduleFactory.getImplementationName());
- } catch (InstanceNotFoundException e) {
+ } catch (ModuleFactoryNotFoundException e) {
throw new IllegalStateException(e);
}
moduleIdentifier.getInstanceName(), dependencyResolver,
oldConfigBeanInfo.getReadableModule(), bc);
} catch (Exception e) {
- throw new IllegalStateException(format(
+ throw new IllegalStateException(String.format(
"Error while copying old configuration from %s to %s",
oldConfigBeanInfo, moduleFactory), e);
}
}
@Override
- public synchronized ObjectName createModule(String factoryName,
- String instanceName) throws InstanceAlreadyExistsException {
+ public synchronized ObjectName createModule(String factoryName, String instanceName)
+ throws InstanceAlreadyExistsException {
transactionStatus.checkNotCommitStarted();
transactionStatus.checkNotAborted();
dependencyResolverManager.assertNotExists(moduleIdentifier);
// find factory
- ModuleFactory moduleFactory;
- try {
- moduleFactory = factoriesHolder.findByModuleName(factoryName);
- } catch (InstanceNotFoundException e) {
- throw new IllegalArgumentException(e);
- }
+ ModuleFactory moduleFactory = factoriesHolder.findByModuleName(factoryName);
+
DependencyResolver dependencyResolver = dependencyResolverManager.getOrCreate(moduleIdentifier);
BundleContext bundleContext = getModuleFactoryBundleContext(moduleFactory.getImplementationName());
Module module = moduleFactory.createModule(instanceName, dependencyResolver,
moduleFactory, null, dependencyResolver, defaultBean, bundleContext);
}
+ @Override
+ public synchronized void reCreateModule(ObjectName objectName) throws InstanceNotFoundException {
+ transactionStatus.checkNotCommitStarted();
+ transactionStatus.checkNotAborted();
+ checkTransactionName(objectName);
+ ObjectNameUtil.checkDomain(objectName);
+ ModuleIdentifier moduleIdentifier = ObjectNameUtil.fromON(objectName, ObjectNameUtil.TYPE_MODULE);
+
+ ModuleInternalTransactionalInfo txInfo = dependencyResolverManager.findModuleInternalTransactionalInfo(moduleIdentifier);
+ Module realModule = txInfo.getRealModule();
+ if(realModule instanceof AbstractModule) {
+ ((AbstractModule<?>)realModule).setCanReuseInstance(false);
+ }
+ }
+
private synchronized ObjectName putConfigBeanToJMXAndInternalMaps(
ModuleIdentifier moduleIdentifier, Module module,
ModuleFactory moduleFactory,
throws InstanceAlreadyExistsException {
LOG.debug("Adding module {} to transaction {}", moduleIdentifier, this);
- if (moduleIdentifier.equals(module.getIdentifier()) == false) {
+ if (!moduleIdentifier.equals(module.getIdentifier())) {
throw new IllegalStateException("Incorrect name reported by module. Expected "
+ moduleIdentifier + ", got " + module.getIdentifier());
}
- if (dependencyResolver.getIdentifier().equals(moduleIdentifier) == false) {
+ if (!dependencyResolver.getIdentifier().equals(moduleIdentifier)) {
throw new IllegalStateException("Incorrect name reported by dependency resolver. Expected "
+ moduleIdentifier + ", got " + dependencyResolver.getIdentifier());
}
DynamicMBean writableDynamicWrapper = new DynamicWritableWrapper(
- module, moduleIdentifier, getTransactionIdentifier(),
+ module, moduleIdentifier, getTransactionIdentifier().getName(),
readOnlyAtomicBoolean, transactionsMBeanServer,
configMBeanServer);
private void checkTransactionName(ObjectName objectName) {
String foundTransactionName = ObjectNameUtil
.getTransactionName(objectName);
- if (getTransactionIdentifier().getName().equals(foundTransactionName) == false) {
+ if (!getTransactionIdentifier().getName().equals(foundTransactionName)) {
throw new IllegalArgumentException("Wrong transaction name "
+ objectName);
}
transactionStatus.checkNotAborted();
ModuleInternalTransactionalInfo found = dependencyResolverManager.findModuleInternalTransactionalInfo(moduleIdentifier);
- if (blankTransaction == false &&
+ if (!blankTransaction &&
found.isDefaultBean()) {
LOG.warn("Warning: removing default bean. This will be forbidden in next version of config-subsystem");
}
validateNoLocks();
} catch (ValidationException e) {
LOG.trace("Commit failed on validation");
- configBeanModificationDisabled.set(false); // recoverable error
+ // recoverable error
+ configBeanModificationDisabled.set(false);
throw e;
}
// errors in this state are not recoverable. modules are not mutable
public synchronized List<ModuleIdentifier> secondPhaseCommit() {
transactionStatus.checkNotAborted();
transactionStatus.checkCommitStarted();
- if (configBeanModificationDisabled.get() == false) {
+ if (!configBeanModificationDisabled.get()) {
throw new IllegalStateException(
"Internal error - validateBeforeCommitAndLockTransaction should be called "
+ "to obtain a lock");
LOG.debug("About to commit {} in transaction {}",
moduleIdentifier, getTransactionIdentifier());
AutoCloseable instance = module.getInstance();
- checkNotNull(instance, "Instance is null:{} in transaction {}", moduleIdentifier, getTransactionIdentifier());
+ Preconditions.checkNotNull(instance, "Instance is null:{} in transaction {}", moduleIdentifier, getTransactionIdentifier());
} catch (Exception e) {
LOG.error("Commit failed on {} in transaction {}", moduleIdentifier,
getTransactionIdentifier(), e);
internalAbort();
throw new IllegalStateException(
- format("Error - getInstance() failed for %s in transaction %s",
+ String.format("Error - getInstance() failed for %s in transaction %s",
moduleIdentifier, getTransactionIdentifier()), e);
}
}
}
@Override
- public synchronized void abortConfig() {
+ public void abortConfig() {
transactionStatus.checkNotCommitStarted();
transactionStatus.checkNotAborted();
internalAbort();
close();
}
+ @Override
public void close() {
dependencyResolverManager.close();
txLookupRegistry.close();