groovy.jmx.builder.JmxBeanFactory.groovy Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of groovy-all Show documentation
Show all versions of groovy-all Show documentation
Groovy: A powerful, dynamic language for the JVM
/*
* Copyright 2008 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package groovy.jmx.builder
import javax.management.MBeanServer
import javax.management.ObjectName
import javax.management.modelmbean.ModelMBeanInfo
/**
* This factory returns the bean() node. This node is used to declaratively expose a POGO/POJO
* to be exported to the MBeanServer for management.
*
* The following shows all of the different syntax forms supported by the node.
*
*
*bean(instance)
*bean(target:instance, name:ObjectName|"...", desc|description:"...")
*bean(target:instance,
* name:ObjectName()|"...",
* desc|description:"...",
* attribs|attributes:"*",
* attribs|attributes:[]
* attribs|attributes:["attribName1","attribName2",..."attribNameN"]
* attribs|attributes:[
* "attribName0":"*",
* "attribName1":[desc|description:"...", default:value, writable|editable:true|false,...]
* "attribName2":[onChange:{event->
* // onChange event callback code here.
* ]
* ],
*
* ctors|constructors:"*",
* ctors|constructors:[
* "CtorName0":[],
* "CtorName1":["paramType1","paramType2"],
* "CtorName2":[
* desc|description:"...",
* params:[
* "type0":"*"
* "type1":[desc|description:"...", name:"...", ]
* ]
* ]
* ],
*
* ops|operations:"*",
* ops|operations:["opName1", "opName2", "opName3",...,"opNameN"],
* ops|operations:[
* "opName0":"*",
* "opName1":["type1","type2,"type3"]
* "opName2":[
* desc:"description",
* params:[
* "type0":"*"
* "type1":[desc|description:"...", name:"...", ],
* "typeN":[desc|description:"...", name:"...", ],
* ],
* ],
* "opName3":[
* onCall:{event->
* // onCall event callaback code here.
* }]
* ],
*
* listeners:[
* ListenerName:[
* event: "eventType", from:"object name"|ObjectName(),
* call:{event->
* // handler code for event
* }],
* ]
*)
*
*
* @author Vladimir Vivien
*/
class JmxBeanFactory extends AbstractFactory {
public Object newInstance(FactoryBuilderSupport builder, Object nodeName, Object nodeParam, Map nodeAttributes) {
JmxBuilder fsb = (JmxBuilder) builder
MBeanServer server = (MBeanServer) fsb.getMBeanServer()
def target = nodeParam ?: ((nodeAttributes) ? nodeAttributes.target : null)
if (!target) {
throw new JmxBuilderException("Unable to export MBean, no target object was specified.")
}
def metaMap = initMetaMap(target)
def declaredMap = retrieveDeclaredMetaMap(target, nodeAttributes) ?: null
def embeddedMap = retrieveEmbeddedMetaMap(target) ?: null
ModelMBeanInfo info
def jmxName = getObjectName(declaredMap) ?:
getObjectName(embeddedMap) ?:
JmxBeanInfoManager.buildDefaultObjectName(
fsb.getDefaultJmxNameDomain(),
fsb.getDefaultJmxNameType(),
target)
metaMap.jmxName = jmxName
//if target implements MBean,MxBean,or Dyanmic bean, skip metaMap step
boolean classIsMBean = JmxBuilderTools.isClassMBean(target.getClass())
if (classIsMBean) {
metaMap.isMBean = true
} else {
// target provided as bean(object)
if (!declaredMap) {
// build implicit meta map
def implicitMap = JmxMetaMapBuilder.buildObjectMapFrom(target)
metaMap.putAll(combineMaps(embeddedMap, implicitMap))
} else {
// if only the name is provided
if (declaredMap.name && declaredMap.target && !declaredMap.attributes && !declaredMap.constructors && !declaredMap.operations) {
declaredMap.putAll(JmxMetaMapBuilder.buildObjectMapFrom(target))
}
metaMap.putAll(declaredMap)
}
}
return metaMap
}
public boolean onHandleNodeAttributes(FactoryBuilderSupport builder, Object node, Map nodeAttribs) {
return false;
}
public void onNodeCompleted(FactoryBuilderSupport builder, Object parentNode, Object thisNode) {
JmxBuilder fsb = (JmxBuilder) builder
MBeanServer server = (MBeanServer) fsb.getMBeanServer()
def metaMap = thisNode
// get modelmbean info from meta map
def info = JmxBeanInfoManager.getModelMBeanInfoFromMap(metaMap)
// Do mbean export: if target is already mbean, ignore, otherwise build modelmbean
def mbean
if (metaMap.isMBean) {
mbean = metaMap.target
} else {
mbean = new JmxBuilderModelMBean(info)
mbean.setManagedResource(metaMap.target)
mbean.addOperationCallListeners metaMap.attributes
mbean.addOperationCallListeners metaMap.operations
if (metaMap.listeners) {
mbean.addEventListeners server, metaMap.listeners
}
}
def regPolicy = fsb.getParentFactory()?.registrationPolicy ?: "replace"
def registeredBean = registerObject(server, regPolicy, mbean, metaMap.jmxName, parentNode)
// only add if bean was successfully registered.
if (parentNode != null && registeredBean) {
parentNode.add(registeredBean)
}
}
public boolean isLeaf() {
return false
}
private def initMetaMap(target) {
def metaMap = [:]
metaMap.target = target
metaMap.name = target.class.canonicalName
metaMap
}
private def getObjectName(def map) {
if (!map) return null
def jmxName
if (map && map?.name instanceof String) {
jmxName = new ObjectName(map?.name)
} else if (map && map.name instanceof ObjectName) {
jmxName = map.name
}
jmxName
}
private def retrieveDeclaredMetaMap(def target, def nodeAttribs) {
if (!nodeAttribs) return null
def map = [:]
map.name = nodeAttribs.name
map.target = target
map.attributes = JmxMetaMapBuilder.buildAttributeMapFrom(target, nodeAttribs.attributes ?: nodeAttribs.attribs)
map.constructors = JmxMetaMapBuilder.buildConstructorMapFrom(target, nodeAttribs.constructors ?: nodeAttribs.ctors)
map.operations = JmxMetaMapBuilder.buildOperationMapFrom(target, nodeAttribs.operations ?: nodeAttribs.ops)
map.listeners = JmxMetaMapBuilder.buildListenerMapFrom(nodeAttribs.listeners ?: nodeAttribs.notifications)
return map
}
private def retrieveEmbeddedMetaMap(def object) {
if (!object) return null
def prop = object.metaClass.getMetaProperty("descriptor") ?: object.metaClass.getMetaProperty("jmx")
if (prop)
return object.metaClass.getProperty(object.getClass(), prop?.name)
else null
}
// rolls map1 into map0
private def combineMaps(embedded, implicit) {
def map0 = [:]
map0.displayName = embedded?.description ?: embedded?.desc ?: implicit?.displayName
map0.attributes = embedded?.attributes ?: embedded?.attribs ?: implicit?.attributes
map0.constructors = embedded?.constructors ?: embedded?.ctors ?: implicit?.constructors
map0.operations = embedded?.operations ?: embedded?.ops ?: implicit?.operations
// Todo pull notifications
map0.notifications = embedded?.notifications ?: implicit?.notifications
return map0
}
private def registerObject(server, policy, bean, name, exportList) {
def gbean
switch (policy) {
case "replace":
if (server.isRegistered(name)) {
for (Iterator i = exportList.iterator(); i.hasNext();) {
def exportedBean = i.next()
if (exportedBean.name().equals(name)) {
i.remove()
}
}
server.unregisterMBean name
}
server.registerMBean(bean, name)
gbean = new GroovyMBean(server, name)
break
case "ignore":
if (server.isRegistered(name))
break
case "error":
default:
if (server.isRegistered(name)) {
throw new JmxBuilderException("A Bean with name ${name} is already registered on the server.")
} else {
server.registerMBean(bean, name)
gbean = new GroovyMBean(server, name)
}
}
return gbean
}
}