Java TestingScheduledThreadPoolModuleFactory类代码示例

import org.opendaylight.controller.config.manager.testingservices.scheduledthreadpool.TestingScheduledThreadPoolModuleFactory; //导入依赖的package包/类
@Test
public void testRecreate() throws Exception {
    ObjectName createdConfigBean = createScheduled();
    // empty transaction
    ConfigTransactionJMXClient configTransaction = configRegistryClient.createTransaction();
    ObjectName scheduledWritableON = configTransaction
            .lookupConfigBean(TestingScheduledThreadPoolModuleFactory.NAME, SCHEDULED1);
    TestingScheduledThreadPoolConfigBeanMXBean scheduledWritableProxy = configTransaction
            .newMXBeanProxy(scheduledWritableON, TestingScheduledThreadPoolConfigBeanMXBean.class);
    scheduledWritableProxy.setRecreate(true);
    CommitStatus commitInfo = configTransaction.commit();
    // check that it was recreated
    ObjectName readableConfigBean = ObjectNameUtil.withoutTransactionName(createdConfigBean);
    List<ObjectName> newInstances = Collections.<ObjectName>emptyList();
    List<ObjectName> reusedInstances = Collections.<ObjectName>emptyList();
    List<ObjectName> recreatedInstaces = Lists.newArrayList(readableConfigBean);
    assertEquals(new CommitStatus(newInstances, reusedInstances, recreatedInstaces), commitInfo);
    checkRuntimeBeans();
}
 

import org.opendaylight.controller.config.manager.testingservices.scheduledthreadpool.TestingScheduledThreadPoolModuleFactory; //导入依赖的package包/类
@Test
public void tryToRegisterThreadPoolWithSameName() throws InstanceAlreadyExistsException {
    ConfigTransactionJMXClient transaction = configRegistryClient.createTransaction();

    transaction.createModule(TestingScheduledThreadPoolModuleFactory.NAME, SCHEDULED1);
    try {
        transaction.createModule(TestingScheduledThreadPoolModuleFactory.NAME, SCHEDULED1);
        fail();
    } catch (final InstanceAlreadyExistsException e) {
        assertThat(e.getMessage(), containsString(
                "There is an instance registered with name "
                + "ModuleIdentifier{factoryName='scheduled', instanceName='scheduled1'}"));
    }
}
 

import org.opendaylight.controller.config.manager.testingservices.scheduledthreadpool.TestingScheduledThreadPoolModuleFactory; //导入依赖的package包/类
@Test
public void testRegisteringAllIfcNames() throws Exception {
    ConfigTransactionJMXClient transaction = configRegistryClient.createTransaction();
    transaction.createModule(TestingScheduledThreadPoolModuleFactory.NAME, SCHEDULED1);
    transaction.commit();
    assertExists(TestingScheduledThreadPoolModuleFactory.NAME, SCHEDULED1);
    // another transaction
    transaction = configRegistryClient.createTransaction();
    assertExists(transaction, TestingScheduledThreadPoolModuleFactory.NAME, SCHEDULED1);
}
 

import org.opendaylight.controller.config.manager.testingservices.scheduledthreadpool.TestingScheduledThreadPoolModuleFactory; //导入依赖的package包/类
@Test
public void testWithAPSP_useScheduledNames() throws InstanceAlreadyExistsException, ValidationException {
    ConfigTransactionJMXClient transaction = configRegistryClient.createTransaction();
    ObjectName scheduledName = transaction.createModule(TestingScheduledThreadPoolModuleFactory.NAME, SCHEDULED1);

    ObjectName apspName = transaction.createModule(TestingParallelAPSPModuleFactory.NAME, "apsp1");
    TestingParallelAPSPConfigMXBean apspProxy = transaction.newMXBeanProxy(apspName,
            TestingParallelAPSPConfigMXBean.class);
    apspProxy.setThreadPool(scheduledName);
    apspProxy.setSomeParam("someParam");
    transaction.validateConfig();

}
 

import org.opendaylight.controller.config.manager.testingservices.scheduledthreadpool.TestingScheduledThreadPoolModuleFactory; //导入依赖的package包/类
@Test
public void testWithAPSP_useIfcNameMismatch() throws Exception {
    ConfigTransactionJMXClient transaction = configRegistryClient.createTransaction();
    transaction.createModule(TestingScheduledThreadPoolModuleFactory.NAME, SCHEDULED1);

    ObjectName apspName = transaction.createModule(TestingParallelAPSPModuleFactory.NAME, "apsp1");
    TestingParallelAPSPConfigMXBean apspProxy = transaction.newMXBeanProxy(apspName,
            TestingParallelAPSPConfigMXBean.class);
    apspProxy.setThreadPool(
            ObjectNameUtil.createReadOnlyModuleON(TestingScheduledThreadPoolModuleFactory.NAME, SCHEDULED1));
    apspProxy.setSomeParam("someParam");
    transaction.validateConfig();
    transaction.commit();

}
 

import org.opendaylight.controller.config.manager.testingservices.scheduledthreadpool.TestingScheduledThreadPoolModuleFactory; //导入依赖的package包/类
@Before
public final void setUp() {
    assertEquals(0,
            TestingScheduledThreadPoolImpl.getNumberOfCloseMethodCalls());
    super.initConfigTransactionManagerImpl(new HardcodedModuleFactoriesResolver(mockedContext,
            new TestingScheduledThreadPoolModuleFactory(),
            new TestingFixedThreadPoolModuleFactory(),
            new TestingParallelAPSPModuleFactory()));
}
 

import org.opendaylight.controller.config.manager.testingservices.scheduledthreadpool.TestingScheduledThreadPoolModuleFactory; //导入依赖的package包/类
private ObjectName createScheduled()
        throws InstanceAlreadyExistsException, ConflictingVersionException, ValidationException {
    ConfigTransactionJMXClient transaction = configRegistryClient.createTransaction();

    // create using TestingThreadPoolIfc:
    ObjectName createdConfigBean = transaction.createModule(TestingScheduledThreadPoolModuleFactory.NAME,
            SCHEDULED1);
    // commit
    transaction.commit();
    return createdConfigBean;
}
 

import org.opendaylight.controller.config.manager.testingservices.scheduledthreadpool.TestingScheduledThreadPoolModuleFactory; //导入依赖的package包/类
@Test
public void twoInterfaceNamesAfterCreatingConfigBean() throws Exception {
    ConfigTransactionJMXClient transaction = configRegistryClient.createTransaction();

    // create using TestingThreadPoolIfc:
    ObjectName scheduled1name = transaction.createModule(TestingScheduledThreadPoolModuleFactory.NAME, SCHEDULED1);

    ObjectName retrievedName = transaction.lookupConfigBean(TestingScheduledThreadPoolModuleFactory.NAME,
            SCHEDULED1);
    assertEquals(scheduled1name, retrievedName);

    // getExistingConfigBean should resolve moduleName
    String moduleName = TestingScheduledThreadPoolModuleFactory.NAME;
    retrievedName = transaction.lookupConfigBean(moduleName, SCHEDULED1);
    ObjectName expected = ObjectNameUtil.createTransactionModuleON(transaction.getTransactionName(), moduleName,
            SCHEDULED1);
    assertEquals(expected, retrievedName);

    // commit
    transaction.commit();
    assertEquals(1, TestingScheduledThreadPoolImpl.ALLEXECUTORS.size());
    assertFalse(TestingScheduledThreadPoolImpl.ALLEXECUTORS.get(0).isTerminated());
    assertEquals(0, TestingScheduledThreadPoolImpl.getNumberOfCloseMethodCalls());

    assertExists(moduleName, SCHEDULED1);

    // destroy using ThreadPool ifc
    transaction = configRegistryClient.createTransaction();
    transaction.destroyModule(
            ObjectNameUtil.createTransactionModuleON(transaction.getTransactionName(), moduleName, SCHEDULED1));
    transaction.commit();
    assertEquals(1, TestingScheduledThreadPoolImpl.ALLEXECUTORS.size());
    assertTrue(TestingScheduledThreadPoolImpl.ALLEXECUTORS.get(0).isTerminated());
    assertEquals(1, TestingScheduledThreadPoolImpl.getNumberOfCloseMethodCalls());

    // should not be in platform:

    assertNotExists(moduleName, SCHEDULED1);

    transaction = configRegistryClient.createTransaction();
    // should not be in transaction
    assertNotExists(transaction, moduleName, SCHEDULED1);
}
 

import org.opendaylight.controller.config.manager.testingservices.scheduledthreadpool.TestingScheduledThreadPoolModuleFactory; //导入依赖的package包/类
@Before
public void setUp() {
    super.initConfigTransactionManagerImpl(
            new HardcodedModuleFactoriesResolver(mockedContext, new TestingFixedThreadPoolModuleFactory(),
                    new TestingParallelAPSPModuleFactory(), new TestingScheduledThreadPoolModuleFactory()));
}
 

import org.opendaylight.controller.config.manager.testingservices.scheduledthreadpool.TestingScheduledThreadPoolModuleFactory; //导入依赖的package包/类
@Test
public void test() throws Exception {
    ConfigTransactionJMXClient transaction1 = configRegistryClient.createTransaction();
    // create fixed1
    int fixedNrOfThreads = 20;
    int scheduledNrOfThreads = 30;

    ObjectName fixedTPTransactionON = transaction1.createModule(getThreadPoolImplementationName(), fixed1);
    platformMBeanServer.setAttribute(fixedTPTransactionON, new Attribute("ThreadCount", fixedNrOfThreads));

    ObjectName scheduledTPTransactionON = transaction1.createModule(TestingScheduledThreadPoolModuleFactory.NAME,
            "scheduled1");
    platformMBeanServer.setAttribute(scheduledTPTransactionON, new Attribute("ThreadCount", scheduledNrOfThreads));

    String refName = "ref";
    ObjectName serviceReference = transaction1.saveServiceReference(TestingThreadPoolServiceInterface.QNAME,
            refName, fixedTPTransactionON);
    // create apsp-parallel
    createParallelAPSP(transaction1, serviceReference);
    transaction1.commit();

    // check fixed1 is used
    ServiceReferenceMXBean serviceReferenceMXBean = JMX.newMXBeanProxy(platformMBeanServer,
            withoutTransactionName(serviceReference), ServiceReferenceMXBean.class);
    assertEquals(withoutTransactionName(fixedTPTransactionON), serviceReferenceMXBean.getCurrentImplementation());
    checkApspThreadCount(fixedNrOfThreads);
    // check OSGi SR
    List<RegistrationHolder> registrations =
            ((RecordingBundleContextServiceRegistrationHandler) currentBundleContextServiceRegistrationHandler)
            .getRegistrations();
    assertEquals(1, registrations.size());
    RegistrationHolder record = registrations.get(0);
    assertEquals(TestingThreadPoolIfc.class, record.clazz);
    assertEquals(ImmutableMap.of("name", "ref"), record.props);

    // switch reference to scheduled
    ConfigTransactionJMXClient transaction2 = configRegistryClient.createTransaction();
    transaction2.saveServiceReference(TestingThreadPoolServiceInterface.QNAME, refName,
            ObjectNameUtil.withTransactionName(scheduledTPTransactionON, transaction2.getTransactionName()));
    transaction2.commit();
    // check scheduled is used
    checkApspThreadCount(scheduledNrOfThreads);
    // check that dummy MXBean points to scheduled
    assertEquals(withoutTransactionName(scheduledTPTransactionON),
            serviceReferenceMXBean.getCurrentImplementation());

    // empty transaction
    configRegistryClient.createTransaction().commit();

    // get service mapping
    Map<String, Map<String, ObjectName>> serviceMapping = configRegistryClient.getServiceMapping();
    Map<String, Map<String, ObjectName>> expectedMapping = ImmutableMap.of(TestingThreadPoolServiceInterface.QNAME,
            (Map<String, ObjectName>) ImmutableMap.of(refName, withoutTransactionName(scheduledTPTransactionON)));
    assertEquals(expectedMapping, serviceMapping);

    // destroy all
    ConfigTransactionJMXClient transaction4 = configRegistryClient.createTransaction();
    Set<ObjectName> objectNames = transaction4.lookupConfigBeans();
    for (ObjectName on : objectNames) {
        transaction4.destroyModule(on);
    }
    transaction4.commit();

    serviceMapping = configRegistryClient.getServiceMapping();
    assertTrue(serviceMapping.isEmpty());
}