import org.opendaylight.controller.config.api.DependencyResolver; //导入依赖的package包/类
@Test
public void testCreateInstance() throws Exception {
    // configure mocks
    DependencyResolver dependencyResolver = mock(DependencyResolver.class);
    BindingAwareBroker broker = mock(BindingAwareBroker.class);
    when(dependencyResolver.resolveInstance(eq(BindingAwareBroker.class), any(ObjectName.class), any(JmxAttribute.class))).thenReturn(broker);

    // create instance of module with injected mocks
    HelloModule module = new HelloModule(mock(ModuleIdentifier.class), dependencyResolver);

    // getInstance calls resolveInstance to get the broker dependency and then calls createInstance
    AutoCloseable closeable = module.getInstance();

    // verify that the module registered the returned provider with the broker
    verify(broker).registerProvider((HelloProvider)closeable);

    // ensure no exceptions on close
    closeable.close();
}
 

import org.opendaylight.controller.config.api.DependencyResolver; //导入依赖的package包/类
@Test
public void testCreateInstance() throws Exception {
    // configure mocks
    DependencyResolver dependencyResolver = mock(DependencyResolver.class);
    BindingAwareBroker broker = mock(BindingAwareBroker.class);
    when(dependencyResolver.resolveInstance(eq(BindingAwareBroker.class), any(ObjectName.class), any(JmxAttribute.class))).thenReturn(broker);

    // create instance of module with injected mocks
    SdnaModule module = new SdnaModule(mock(ModuleIdentifier.class), dependencyResolver);

    // getInstance calls resolveInstance to get the broker dependency and then calls createInstance
    AutoCloseable closeable = module.getInstance();

    // verify that the module registered the returned provider with the broker
    verify(broker).registerProvider((SdnaProvider)closeable);

    // ensure no exceptions on close
    closeable.close();
}
 

import org.opendaylight.controller.config.api.DependencyResolver; //导入依赖的package包/类
@Override
public synchronized ObjectName createModule(final String factoryName, final String instanceName)
        throws InstanceAlreadyExistsException {

    transactionStatus.checkNotCommitStarted();
    transactionStatus.checkNotAborted();
    ModuleIdentifier moduleIdentifier = new ModuleIdentifier(factoryName, instanceName);
    dependencyResolverManager.assertNotExists(moduleIdentifier);

    // find factory
    ModuleFactory moduleFactory = factoriesHolder.findByModuleName(factoryName);

    DependencyResolver dependencyResolver = dependencyResolverManager.getOrCreate(moduleIdentifier);
    BundleContext bundleContext = getModuleFactoryBundleContext(moduleFactory.getImplementationName());
    Module module = moduleFactory.createModule(instanceName, dependencyResolver, bundleContext);
    boolean defaultBean = false;
    return putConfigBeanToJMXAndInternalMaps(moduleIdentifier, module, moduleFactory, null, dependencyResolver,
            defaultBean, bundleContext);
}
 

import org.opendaylight.controller.config.api.DependencyResolver; //导入依赖的package包/类
@Override
public Module createModule(final String instanceName, final DependencyResolver dependencyResolver,
        final DynamicMBeanWithInstance old, final BundleContext bundleContext) throws Exception {
    TestingScheduledThreadPoolImpl oldInstance;
    try {
        oldInstance = (TestingScheduledThreadPoolImpl) old.getInstance();
    } catch (final ClassCastException e) {
        // happens after OSGi update
        oldInstance = null;
    }

    TestingScheduledThreadPoolModule configBean = new TestingScheduledThreadPoolModule(
            new ModuleIdentifier(NAME, instanceName), old.getInstance(), oldInstance);
    // copy attributes
    configBean.setRecreate((Boolean) old.getAttribute("Recreate"));
    return configBean;
}
 

import org.opendaylight.controller.config.api.DependencyResolver; //导入依赖的package包/类
@Override
public Module createModule(final String instanceName, final DependencyResolver dependencyResolver,
        final DynamicMBeanWithInstance old, final BundleContext bundleContext) throws Exception {
    int threadCount = (Integer) old.getAttribute("ThreadCount");
    // is the instance compatible?
    TestingFixedThreadPool oldInstance;
    try {
        // reconfigure existing instance
        oldInstance = (TestingFixedThreadPool) old.getInstance();
    } catch (final ClassCastException e) {
        // old instance will be closed, new needs to be created
        oldInstance = null;
    }
    TestingFixedThreadPoolModule result = new TestingFixedThreadPoolModule(new ModuleIdentifier(NAME, instanceName),
            old.getInstance(), oldInstance);
    result.setThreadCount(threadCount);
    return result;
}
 

import org.opendaylight.controller.config.api.DependencyResolver; //导入依赖的package包/类
@Override
public TestingParallelAPSPModule createModule(final String instanceName,
        final DependencyResolver dependencyResolver, final DynamicMBeanWithInstance old,
        final BundleContext context) throws Exception {
    TestingParallelAPSPImpl oldInstance;
    try {
        oldInstance = (TestingParallelAPSPImpl) old.getInstance();
    } catch (final ClassCastException e) {
        oldInstance = null;
    }
    TestingParallelAPSPModule result = new TestingParallelAPSPModule(new ModuleIdentifier(NAME, instanceName),
            dependencyResolver, old.getInstance(), oldInstance);
    // copy attributes
    String someParam = (String) old.getAttribute("SomeParam");
    result.setSomeParam(someParam);
    ObjectName threadPool = (ObjectName) old.getAttribute("ThreadPool");
    result.setThreadPool(threadPool);
    return result;
}
 

import org.opendaylight.controller.config.api.DependencyResolver; //导入依赖的package包/类
private Module constructModule(final String instanceName, final DependencyResolver dependencyResolver,
        final DynamicMBeanWithInstance old)
        throws InstantiationException, IllegalAccessException, InvocationTargetException {
    Preconditions.checkNotNull(dependencyResolver);
    ModuleIdentifier moduleIdentifier = new ModuleIdentifier(implementationName, instanceName);
    Constructor<? extends Module> declaredConstructor;
    try {
        declaredConstructor = configBeanClass.getDeclaredConstructor(DynamicMBeanWithInstance.class,
                ModuleIdentifier.class);
    } catch (final NoSuchMethodException e) {
        throw new IllegalStateException(
                "Did not find constructor with parameters (DynamicMBeanWithInstance) in " + configBeanClass, e);
    }
    Preconditions.checkState(declaredConstructor != null);
    return declaredConstructor.newInstance(old, moduleIdentifier);
}
 

import org.opendaylight.controller.config.api.DependencyResolver; //导入依赖的package包/类
@Override
public Module createModule(String instanceName,
                           DependencyResolver dependencyResolver,
                           DynamicMBeanWithInstance old,
                           BundleContext bundleContext)
        throws Exception {

    MessageBusAppImplModule module =
            (MessageBusAppImplModule) super.createModule(instanceName,
                    dependencyResolver,
                    old,
                    bundleContext);

    module.setBundleContext(bundleContext);

    return module;
}
 

import org.opendaylight.controller.config.api.DependencyResolver; //导入依赖的package包/类
@Test
public void testCreateInstance() throws Exception {
    // configure mocks
    DependencyResolver dependencyResolver = mock(DependencyResolver.class);
    BindingAwareBroker broker = mock(BindingAwareBroker.class);
    when(dependencyResolver.resolveInstance(eq(BindingAwareBroker.class), any(ObjectName.class), any(JmxAttribute.class))).thenReturn(broker);

    // create instance of module with injected mocks
    ExampleModule module = new ExampleModule(mock(ModuleIdentifier.class), dependencyResolver);

    // getInstance calls resolveInstance to get the broker dependency and then calls createInstance
    AutoCloseable closeable = module.getInstance();

    // verify that the module registered the returned provider with the broker
    verify(broker).registerProvider((ExampleProvider)closeable);

    // ensure no exceptions on close
    closeable.close();
}
 

import org.opendaylight.controller.config.api.DependencyResolver; //导入依赖的package包/类
@Test
public void testCustomValidation() {
    HelloModule module = new HelloModule(mock(ModuleIdentifier.class), mock(DependencyResolver.class));

    // ensure no exceptions on validation
    // currently this method is empty
    module.customValidation();
}
 

import org.opendaylight.controller.config.api.DependencyResolver; //导入依赖的package包/类
@Test
public void testCustomValidation() {
    SdnaModule module = new SdnaModule(mock(ModuleIdentifier.class), mock(DependencyResolver.class));

    // ensure no exceptions on validation
    // currently this method is empty
    module.customValidation();
}
 

import org.opendaylight.controller.config.api.DependencyResolver; //导入依赖的package包/类
private synchronized ObjectName putConfigBeanToJMXAndInternalMaps(final ModuleIdentifier moduleIdentifier,
        final Module module, final ModuleFactory moduleFactory,
        @Nullable final ModuleInternalInfo maybeOldConfigBeanInfo, final DependencyResolver dependencyResolver,
        final boolean isDefaultBean, final BundleContext bundleContext) throws InstanceAlreadyExistsException {

    LOG.debug("Adding module {} to transaction {}", moduleIdentifier, this);
    if (!moduleIdentifier.equals(module.getIdentifier())) {
        throw new IllegalStateException("Incorrect name reported by module. Expected " + moduleIdentifier + ", got "
                + module.getIdentifier());
    }
    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().getName(), readOnlyAtomicBoolean, transactionsMBeanServer,
            configMBeanServer);

    ObjectName writableON = ObjectNameUtil.createTransactionModuleON(getTransactionIdentifier().getName(),
            moduleIdentifier);
    // put wrapper to jmx
    TransactionModuleJMXRegistration transactionModuleJMXRegistration = getTxModuleJMXRegistrator()
            .registerMBean(writableDynamicWrapper, writableON);

    dependencyResolverManager.put(moduleIdentifier, module, moduleFactory, maybeOldConfigBeanInfo,
            transactionModuleJMXRegistration, isDefaultBean, bundleContext);
    return writableON;
}
 

import org.opendaylight.controller.config.api.DependencyResolver; //导入依赖的package包/类
public TestingParallelAPSPModule(final ModuleIdentifier identifier, final DependencyResolver dependencyResolver,
        @Nullable final AutoCloseable oldCloseable, @Nullable final TestingParallelAPSPImpl oldInstance) {
    this.identifier = identifier;
    this.dependencyResolver = dependencyResolver;
    this.oldCloseable = oldCloseable;
    this.oldInstance = oldInstance;
}
 

import org.opendaylight.controller.config.api.DependencyResolver; //导入依赖的package包/类
@Override
public Module createModule(final String instanceName, final DependencyResolver dependencyResolver,
        final BundleContext bundleContext) {
    try {
        return constructModule(instanceName, dependencyResolver, null);
    } catch (InstantiationException | IllegalAccessException | InvocationTargetException e) {
        throw new RuntimeException(e);
    }
}
 

import org.opendaylight.controller.config.api.DependencyResolver; //导入依赖的package包/类
@Override
public GlobalEventExecutorModule instantiateModule(final String instanceName, final DependencyResolver dependencyResolver, final GlobalEventExecutorModule oldModule, final AutoCloseable oldInstance, final BundleContext bundleContext) {
    checkArgument(SINGLETON_NAME.equals(instanceName),"Illegal instance name '" + instanceName + "', only allowed name is " + SINGLETON_NAME);
    GlobalEventExecutorModule module = super.instantiateModule(instanceName, dependencyResolver, oldModule,
            oldInstance, bundleContext);
    module.setBundleContext(bundleContext);
    return module;
}
 

import org.opendaylight.controller.config.api.DependencyResolver; //导入依赖的package包/类
@Override
public HashedWheelTimerModule instantiateModule(final String instanceName, final DependencyResolver dependencyResolver,
        final HashedWheelTimerModule oldModule, final AutoCloseable oldInstance, final BundleContext bundleContext) {
    HashedWheelTimerModule module = super.instantiateModule(instanceName, dependencyResolver, oldModule,
            oldInstance, bundleContext);
    module.setBundleContext(bundleContext);
    return module;
}
 

import org.opendaylight.controller.config.api.DependencyResolver; //导入依赖的package包/类
@Override
public NettyThreadgroupModule instantiateModule(final String instanceName, final DependencyResolver dependencyResolver,
        final NettyThreadgroupModule oldModule, final AutoCloseable oldInstance, final BundleContext bundleContext) {
    NettyThreadgroupModule module = super.instantiateModule(instanceName, dependencyResolver, oldModule, oldInstance, bundleContext);
    module.setBundleContext(bundleContext);
    return module;
}
 

import org.opendaylight.controller.config.api.DependencyResolver; //导入依赖的package包/类
@Override
public Set<ShutdownModule> getDefaultModules(final DependencyResolverFactory dependencyResolverFactory, final BundleContext bundleContext) {
    ModuleIdentifier id = new ModuleIdentifier(NAME, NAME);
    DependencyResolver dependencyResolver = dependencyResolverFactory.createDependencyResolver(id);
    ShutdownModule shutdownModule = instantiateModule(NAME, dependencyResolver, bundleContext);
    return new java.util.HashSet<>(Arrays.asList(shutdownModule));
}
 

import org.opendaylight.controller.config.api.DependencyResolver; //导入依赖的package包/类
private static String getNewConstructor(FullyQualifiedName abstractFQN) {
    LinkedHashMap<String, String> parameters = new LinkedHashMap<>();
    parameters.put(ModuleIdentifier.class.getCanonicalName(), "identifier");
    parameters.put(DependencyResolver.class.getCanonicalName(), "dependencyResolver");
    String init = "super(identifier, dependencyResolver);\n";
    return getConstructorStart(abstractFQN, parameters, init);
}
 

import org.opendaylight.controller.config.api.DependencyResolver; //导入依赖的package包/类
private static String getCopyFromOldConstructor(FullyQualifiedName abstractFQN) {
    LinkedHashMap<String, String> parameters = new LinkedHashMap<>();
    parameters.put(ModuleIdentifier.class.getCanonicalName(), "identifier");
    parameters.put(DependencyResolver.class.getCanonicalName(), "dependencyResolver");
    parameters.put(abstractFQN.getTypeName(), "oldModule");
    parameters.put(AutoCloseable.class.getCanonicalName(), "oldInstance");
    String init = "super(identifier, dependencyResolver, oldModule, oldInstance);\n";
    return getConstructorStart(abstractFQN, parameters, init);
}