opendaylight/config/threadpool-config-impl/src/test/java/org/opendaylight/controller/config/threadpool/fixed/FixedThreadPoolConfigBeanTest.java

   1 /*
   2  * Copyright (c) 2013 Cisco Systems, Inc. and others.  All rights reserved.
   3  *
   4  * This program and the accompanying materials are made available under the
   5  * terms of the Eclipse Public License v1.0 which accompanies this distribution,
   6  * and is available at http://www.eclipse.org/legal/epl-v10.html
   7  */
   8 package org.opendaylight.controller.config.threadpool.fixed;
   9
  10 import static org.hamcrest.CoreMatchers.containsString;
  11 import static org.junit.Assert.assertEquals;
  12 import static org.junit.Assert.assertThat;
  13 import static org.junit.Assert.fail;
  14
  15 import java.lang.management.ManagementFactory;
  16 import java.lang.management.ThreadInfo;
  17 import java.lang.management.ThreadMXBean;
  18 import java.util.ArrayList;
  19 import java.util.List;
  20 import javax.management.InstanceAlreadyExistsException;
  21 import javax.management.InstanceNotFoundException;
  22 import javax.management.ObjectName;
  23 import org.junit.Before;
  24 import org.junit.Test;
  25 import org.opendaylight.controller.config.api.ConflictingVersionException;
  26 import org.opendaylight.controller.config.api.ValidationException;
  27 import org.opendaylight.controller.config.api.jmx.CommitStatus;
  28 import org.opendaylight.controller.config.manager.impl.AbstractConfigTest;
  29 import org.opendaylight.controller.config.manager.impl.factoriesresolver.HardcodedModuleFactoriesResolver;
  30 import org.opendaylight.controller.config.util.ConfigTransactionJMXClient;
  31 import org.opendaylight.controller.config.yang.threadpool.impl.NamingThreadFactoryModuleFactory;
  32 import org.opendaylight.controller.config.yang.threadpool.impl.NamingThreadFactoryModuleMXBean;
  33 import org.opendaylight.controller.config.yang.threadpool.impl.fixed.FixedThreadPoolModuleFactory;
  34 import org.opendaylight.controller.config.yang.threadpool.impl.fixed.FixedThreadPoolModuleMXBean;
  35 import org.slf4j.Logger;
  36 import org.slf4j.LoggerFactory;
  37
  38 public class FixedThreadPoolConfigBeanTest extends AbstractConfigTest {
  39     private static final Logger LOG = LoggerFactory.getLogger(FixedThreadPoolConfigBeanTest.class);
  40
  41     private FixedThreadPoolModuleFactory factory;
  42     private final String nameInstance = "fixedInstance";
  43     private ObjectName threadFactoryON;
  44
  45     @Before
  46     public void setUp() {
  47         factory = new FixedThreadPoolModuleFactory();
  48         super.initConfigTransactionManagerImpl(new HardcodedModuleFactoriesResolver(mockedContext, factory,
  49                 new NamingThreadFactoryModuleFactory()));
  50     }
  51
  52     @Test
  53     public void testCreateBean() throws InstanceAlreadyExistsException, ValidationException,
  54             ConflictingVersionException {
  55         ConfigTransactionJMXClient transaction = configRegistryClient.createTransaction();
  56         createFixed(transaction, nameInstance, 2, nameInstance);
  57
  58         transaction.validateConfig();
  59         CommitStatus status = transaction.commit();
  60
  61         assertBeanCount(1, factory.getImplementationName());
  62         assertStatus(status, 2, 0, 0);
  63     }
  64
  65     @Test
  66     public void testReusingOldInstance() throws InstanceAlreadyExistsException, ConflictingVersionException,
  67             ValidationException {
  68         ConfigTransactionJMXClient transaction = configRegistryClient.createTransaction();
  69         createFixed(transaction, nameInstance, 4, nameInstance);
  70
  71         transaction.validateConfig();
  72         transaction.commit();
  73
  74         assertBeanCount(1, factory.getImplementationName());
  75
  76         transaction = configRegistryClient.createTransaction();
  77         NamingThreadFactoryModuleMXBean namingThreadFactoryModuleMXBean = transaction.newMXBeanProxy(threadFactoryON, NamingThreadFactoryModuleMXBean.class);
  78         namingThreadFactoryModuleMXBean.setNamePrefix("newPrefix");
  79         CommitStatus status = transaction.commit();
  80
  81         assertBeanCount(1, factory.getImplementationName());
  82         assertStatus(status, 0, 2, 0);
  83     }
  84
  85     @Test
  86     public void testNegative() throws ConflictingVersionException, ValidationException, InstanceAlreadyExistsException {
  87         ConfigTransactionJMXClient transaction = configRegistryClient.createTransaction();
  88
  89         createFixed(transaction, nameInstance, 5, nameInstance);
  90         transaction.commit();
  91
  92         transaction = configRegistryClient.createTransaction();
  93         try {
  94             createFixed(transaction, nameInstance, 0, nameInstance);
  95             fail();
  96         } catch (InstanceAlreadyExistsException e) {
  97             assertThat(
  98                     e.getMessage(),
  99                     containsString("There is an instance registered with name ModuleIdentifier{factoryName='threadpool-fixed', instanceName='fixedInstance'}"));
 100         }
 101     }
 102
 103     private int countThreadsByPrefix(String prefix) {
 104         ThreadMXBean threadMXBean = ManagementFactory.getThreadMXBean();
 105         int result = 0;
 106         List<String> names = new ArrayList<>();
 107         for (ThreadInfo threadInfo : threadMXBean.dumpAllThreads(false, false)) {
 108             names.add(threadInfo.getThreadName());
 109             if (threadInfo.getThreadName().startsWith(prefix)) {
 110                 result++;
 111             }
 112         }
 113         LOG.info("Current threads {}", names);
 114         return result;
 115     }
 116
 117     @Test
 118     public void testDestroy() throws InstanceAlreadyExistsException, ValidationException, ConflictingVersionException,
 119             InstanceNotFoundException, InterruptedException {
 120
 121         String prefix = org.apache.commons.lang3.RandomStringUtils.randomAlphabetic(10);
 122
 123         int numberOfThreads = 100;
 124         int threadCount1 = countThreadsByPrefix(prefix);
 125         assertEquals(0, threadCount1);
 126         ConfigTransactionJMXClient transaction = configRegistryClient.createTransaction();
 127
 128         createFixed(transaction, nameInstance, numberOfThreads, prefix);
 129         transaction.commit();
 130         int threadCount2 = countThreadsByPrefix(prefix);
 131         assertEquals(numberOfThreads, threadCount2);
 132
 133         transaction = configRegistryClient.createTransaction();
 134         transaction.destroyModule(factory.getImplementationName(), nameInstance);
 135         CommitStatus status = transaction.commit();
 136
 137         assertBeanCount(0, factory.getImplementationName());
 138         assertStatus(status, 0, 0, 1);
 139
 140         for (int i = 0; i < 60; i++) {
 141             if (countThreadsByPrefix(prefix) == 0) {
 142                 return;
 143             }
 144             Thread.sleep(1000);
 145         }
 146         assertEquals(0, countThreadsByPrefix(prefix));
 147     }
 148
 149     @Test
 150     public void testValidationException() throws InstanceAlreadyExistsException {
 151         ConfigTransactionJMXClient transaction = configRegistryClient.createTransaction();
 152         createFixed(transaction, nameInstance, -1, nameInstance);
 153         try {
 154             transaction.validateConfig();
 155             fail();
 156         } catch (ValidationException e) {
 157             assertThat(e.getMessage(), containsString("MaxThreadCount must be greater than zero"));
 158         }
 159     }
 160
 161     private ObjectName createFixed(ConfigTransactionJMXClient transaction, String name, int numberOfThreads, String prefix)
 162             throws InstanceAlreadyExistsException {
 163         ObjectName nameCreated = transaction.createModule(factory.getImplementationName(), name);
 164         FixedThreadPoolModuleMXBean mxBean = transaction.newMXBeanProxy(nameCreated, FixedThreadPoolModuleMXBean.class);
 165         mxBean.setMaxThreadCount(numberOfThreads);
 166
 167         threadFactoryON = transaction.createModule(NamingThreadFactoryModuleFactory.NAME, "naming");
 168         NamingThreadFactoryModuleMXBean namingThreadFactoryModuleMXBean = transaction.newMXBeanProxy(threadFactoryON,
 169                 NamingThreadFactoryModuleMXBean.class);
 170         namingThreadFactoryModuleMXBean.setNamePrefix(prefix);
 171
 172         mxBean.setThreadFactory(threadFactoryON);
 173
 174         return nameCreated;
 175     }
 176
 177 }