2 * Copyright (c) 2013 Cisco Systems, Inc. and others. All rights reserved.
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
8 package org.opendaylight.controller.config.api.jmx;
10 import java.util.Arrays;
11 import java.util.HashMap;
12 import java.util.HashSet;
13 import java.util.Hashtable;
15 import java.util.Map.Entry;
18 import javax.annotation.concurrent.ThreadSafe;
19 import javax.management.ObjectName;
21 import org.opendaylight.controller.config.api.ModuleIdentifier;
22 import org.opendaylight.controller.config.api.jmx.constants.ConfigRegistryConstants;
25 * Provides ObjectName creation. Each created ObjectName consists of domain that
26 * is defined as {@link #ON_DOMAIN} and at least one key-value pair. The only
27 * mandatory property is {@link #TYPE_KEY}. All transaction related mbeans have
28 * {@link #TRANSACTION_NAME_KEY} property set.
32 public class ObjectNameUtil {
34 public static final String ON_DOMAIN = ConfigRegistryConstants.ON_DOMAIN;
35 public static final String MODULE_FACTORY_NAME_KEY = "moduleFactoryName";
36 public static final String INSTANCE_NAME_KEY = "instanceName";
37 public static final String TYPE_KEY = ConfigRegistryConstants.TYPE_KEY;
38 public static final String TYPE_CONFIG_REGISTRY = ConfigRegistryConstants.TYPE_CONFIG_REGISTRY;
39 public static final String TYPE_CONFIG_TRANSACTION = "ConfigTransaction";
40 public static final String TYPE_MODULE = "Module";
41 public static final String TYPE_RUNTIME_BEAN = "RuntimeBean";
43 public static final String TRANSACTION_NAME_KEY = "TransactionName";
45 public static ObjectName createON(String on) {
47 return new ObjectName(on);
48 } catch (Exception e) {
49 throw new RuntimeException(e);
53 public static ObjectName createONWithDomainAndType(String type) {
54 return ConfigRegistryConstants.createONWithDomainAndType(type);
57 public static ObjectName createON(String name, String key, String value) {
58 return ConfigRegistryConstants.createON(name, key, value);
61 public static ObjectName createON(String name, Map<String, String> attribs) {
62 Hashtable<String, String> table = new Hashtable<>(attribs);
64 return new ObjectName(name, table);
65 } catch (Exception e) {
66 throw new RuntimeException(e);
71 public static ObjectName createTransactionControllerON(
72 String transactionName) {
73 Map<String, String> onParams = new HashMap<>();
74 onParams.put(TRANSACTION_NAME_KEY, transactionName);
75 onParams.put(TYPE_KEY, TYPE_CONFIG_TRANSACTION);
76 return createON(ON_DOMAIN, onParams);
79 public static ObjectName createTransactionModuleON(String transactionName,
80 ModuleIdentifier moduleIdentifier) {
81 return createTransactionModuleON(transactionName,
82 moduleIdentifier.getFactoryName(),
83 moduleIdentifier.getInstanceName());
86 public static ObjectName createTransactionModuleON(String transactionName,
87 String moduleName, String instanceName) {
88 Map<String, String> onParams = createModuleON(moduleName, instanceName);
89 onParams.put(TRANSACTION_NAME_KEY, transactionName);
90 return createON(ON_DOMAIN, onParams);
93 public static ObjectName createTransactionModuleON(String transactionName,
95 return createTransactionModuleON(transactionName, getFactoryName(on),
99 public static ObjectName createReadOnlyModuleON(
100 ModuleIdentifier moduleIdentifier) {
101 return createReadOnlyModuleON(moduleIdentifier.getFactoryName(),
102 moduleIdentifier.getInstanceName());
105 public static ObjectName createReadOnlyModuleON(String moduleName,
106 String instanceName) {
107 Map<String, String> onParams = createModuleON(moduleName, instanceName);
108 return createON(ON_DOMAIN, onParams);
111 private static Map<String, String> createModuleON(String moduleName,
112 String instanceName) {
113 Map<String, String> onParams = new HashMap<>();
114 onParams.put(TYPE_KEY, TYPE_MODULE);
115 onParams.put(MODULE_FACTORY_NAME_KEY, moduleName);
116 onParams.put(INSTANCE_NAME_KEY, instanceName);
120 public static String getFactoryName(ObjectName objectName) {
121 return objectName.getKeyProperty(MODULE_FACTORY_NAME_KEY);
124 public static String getInstanceName(ObjectName objectName) {
125 return objectName.getKeyProperty(INSTANCE_NAME_KEY);
128 public static String getTransactionName(ObjectName objectName) {
129 return objectName.getKeyProperty(TRANSACTION_NAME_KEY);
132 public static ObjectName withoutTransactionName(ObjectName on) {
133 if (getTransactionName(on) == null) {
134 throw new IllegalArgumentException(
135 "Expected ObjectName with transaction:" + on);
137 if (ON_DOMAIN.equals(on.getDomain()) == false) {
138 throw new IllegalArgumentException("Expected different domain: "
141 String moduleName = getFactoryName(on);
142 String instanceName = getInstanceName(on);
143 return createReadOnlyModuleON(moduleName, instanceName);
146 private static void assertDoesNotContain(
147 Map<String, String> additionalProperties, String key) {
148 if (additionalProperties.containsKey(key)) {
149 throw new IllegalArgumentException(
150 "Map 'additionalProperties' cannot overwrite attribute "
155 public static ObjectName createRuntimeBeanName(String moduleName,
156 String instanceName, Map<String, String> additionalProperties) {
157 // check that there is no overwriting of default attributes
158 assertDoesNotContain(additionalProperties, MODULE_FACTORY_NAME_KEY);
159 assertDoesNotContain(additionalProperties, INSTANCE_NAME_KEY);
160 assertDoesNotContain(additionalProperties, TYPE_KEY);
161 assertDoesNotContain(additionalProperties, TRANSACTION_NAME_KEY);
162 Map<String, String> map = new HashMap<>(additionalProperties);
163 map.put(MODULE_FACTORY_NAME_KEY, moduleName);
164 map.put(INSTANCE_NAME_KEY, instanceName);
165 map.put(TYPE_KEY, TYPE_RUNTIME_BEAN);
166 return createON(ON_DOMAIN, map);
169 private static Set<String> blacklist = new HashSet<>(Arrays.asList(
170 MODULE_FACTORY_NAME_KEY, INSTANCE_NAME_KEY, TYPE_KEY));
172 public static Map<String, String> getAdditionalPropertiesOfRuntimeBeanName(
174 checkType(on, TYPE_RUNTIME_BEAN);
175 Map<String, String> allProperties = getAdditionalProperties(on);
176 Map<String, String> result = new HashMap<>();
177 for (Entry<String, String> entry : allProperties.entrySet()) {
178 if (blacklist.contains(entry.getKey()) == false) {
179 result.put(entry.getKey(), entry.getValue());
185 public static Map<String, String> getAdditionalProperties(ObjectName on) {
186 Hashtable<String, String> keyPropertyList = on.getKeyPropertyList();
187 Map<String, String> result = new HashMap<>();
188 for (Entry<String, String> entry : keyPropertyList.entrySet()) {
189 result.put(entry.getKey(), entry.getValue());
194 public static void checkDomain(ObjectName objectName) {
195 if (!ON_DOMAIN.equals(objectName.getDomain())) {
196 throw new IllegalArgumentException("Wrong domain " + objectName);
201 public static void checkType(ObjectName objectName, String type) {
202 if (!type.equals(objectName.getKeyProperty(TYPE_KEY))) {
203 throw new IllegalArgumentException("Wrong type, expected '" + type
204 + "', got " + objectName);
208 public static ObjectName createModulePattern(String moduleName,
209 String instanceName) {
210 if (moduleName == null)
212 if (instanceName == null)
214 // do not return object names containing transaction name
215 ObjectName namePattern = ObjectNameUtil
216 .createON(ObjectNameUtil.ON_DOMAIN + ":"
217 + ObjectNameUtil.TYPE_KEY + "="
218 + ObjectNameUtil.TYPE_MODULE + ","
219 + ObjectNameUtil.MODULE_FACTORY_NAME_KEY + "="
220 + moduleName + "," + ""
221 + ObjectNameUtil.INSTANCE_NAME_KEY + "=" + instanceName);
225 public static ObjectName createModulePattern(String ifcName,
226 String instanceName, String transactionName) {
227 return ObjectNameUtil.createON(ObjectNameUtil.ON_DOMAIN
228 + ":type=Module," + ObjectNameUtil.MODULE_FACTORY_NAME_KEY
229 + "=" + ifcName + "," + ObjectNameUtil.INSTANCE_NAME_KEY + "="
230 + instanceName + "," + ObjectNameUtil.TRANSACTION_NAME_KEY
231 + "=" + transactionName);
234 public static ObjectName createRuntimeBeanPattern(String moduleName,
235 String instanceName) {
236 return ObjectNameUtil.createON(ObjectNameUtil.ON_DOMAIN + ":"
237 + ObjectNameUtil.TYPE_KEY + "="
238 + ObjectNameUtil.TYPE_RUNTIME_BEAN + ","
239 + ObjectNameUtil.MODULE_FACTORY_NAME_KEY + "=" + moduleName
240 + "," + ObjectNameUtil.INSTANCE_NAME_KEY + "=" + instanceName
245 public static ModuleIdentifier fromON(ObjectName objectName,
246 String expectedType) {
247 checkType(objectName, expectedType);
248 String factoryName = getFactoryName(objectName);
249 if (factoryName == null)
250 throw new IllegalArgumentException(
251 "ObjectName does not contain module name");
252 String instanceName = getInstanceName(objectName);
253 if (instanceName == null)
254 throw new IllegalArgumentException(
255 "ObjectName does not contain instance name");
256 return new ModuleIdentifier(factoryName, instanceName);