Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * Copyright 2003-2007 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.util;
 
 
 import java.util.*;

A GroovyObject facade for an underlying MBean which acts like a normal groovy object but which is actually implemented via an underlying JMX MBean. Properties and normal method invocations delegate to the MBeanServer to the actual MBean.

Author(s):
James Strachan
Steve Button
Paul King
Version:
$Revision: 7934 $
 
 public class GroovyMBean extends GroovyObjectSupport {
     private final MBeanServerConnection server;
     private final ObjectName name;
     private MBeanInfo beanInfo;
     private final boolean ignoreErrors;
     private final Map operations = new HashMap();
 
     public GroovyMBean(MBeanServerConnection serverString objectNamethrows JMExceptionIOException {
         this(serverobjectNamefalse);
     }
 
     public GroovyMBean(MBeanServerConnection serverString objectNameboolean ignoreErrorsthrows JMExceptionIOException {
         this(servernew ObjectName(objectName), ignoreErrors);
     }
 
     public GroovyMBean(MBeanServerConnection serverObjectName namethrows JMExceptionIOException {
         this(servernamefalse);
     }
 
     public GroovyMBean(MBeanServerConnection serverObjectName nameboolean ignoreErrorsthrows JMExceptionIOException {
         this. = server;
         this. = name;
         this. = ignoreErrors;
         this. = server.getMBeanInfo(name);
 
         MBeanOperationInfo[] operationInfos = .getOperations();
         for (int i = 0; i < operationInfos.lengthi++) {
             MBeanOperationInfo info = operationInfos[i];
             String signature[] = createSignature(info);
 
             // Include a simple fix here to support overloaded operations on the MBean.
             // Construct a simple key for an operation by adding the number of parameters it uses
             String operationKey = createOperationKey(info.getName(), signature.length);
             .put(operationKeysignature);
         }
     }
 
     public MBeanServerConnection server() {
         return ;
     }
 
     public ObjectName name() {
         return ;
     }
 
     public MBeanInfo info() {
         return ;
     }
 
     public Object getProperty(String property) {
         try {
             return .getAttribute(property);
         }
         catch (MBeanException e) {
             throwExceptionWithTarget("Could not access property: " + property + ". Reason: "e);
         }
         catch (Exception e) {
             if (!)
             throwException("Could not access property: " + property + ". Reason: "e);
         }
         return null;
     }
 
    public void setProperty(String propertyObject value) {
        try {
            .setAttribute(new Attribute(propertyvalue));
        }
        catch (MBeanException e) {
            throwExceptionWithTarget("Could not set property: " + property + ". Reason: "e);
        }
        catch (Exception e) {
            throwException("Could not set property: " + property + ". Reason: "e);
        }
    }
    public Object invokeMethod(String methodObject arguments) {
        // Moved this outside the try block so we can obtain the number of parameters
        // specified in the arguments array, which is needed to find the correct method.
        Object[] argArray = null;
        if (arguments instanceof Object[]) {
            argArray = (Object[]) arguments;
        } else {
            argArray = new Object[]{arguments};
        }
        // Locate the specific method based on the name and number of parameters
        String operationKey = createOperationKey(methodargArray.length);
        String[] signature = (String[]) .get(operationKey);
        if (signature != null) {
            try {
                return .invoke(methodargArraysignature);
            }
            catch (MBeanException e) {
                throwExceptionWithTarget("Could not invoke method: " + method + ". Reason: "e);
            }
            catch (Exception e) {
                throwException("Could not invoke method: " + method + ". Reason: "e);
            }
            return null;
        } else {
            return super.invokeMethod(methodarguments);
        }
    }
    protected String[] createSignature(MBeanOperationInfo info) {
        MBeanParameterInfo[] params = info.getSignature();
        String[] answer = new String[params.length];
        for (int i = 0; i < params.lengthi++) {
            answer[i] = params[i].getType();
        }
        return answer;
    }

    
Construct a simple key based on the method name and the number of parameters

Parameters:
operation - the mbean operation name
params - the number of parameters the operation supports
Returns:
simple unique identifier for a method
    protected String createOperationKey(String operationint params) {
        // This could be changed to support some hash of the parameter types, etc.
        return operation + "_" + params;
    }

    
List of the names of each of the attributes on the MBean

Returns:
list of attribute names
    public Collection listAttributeNames() {
        List list = new ArrayList();
        try {
            MBeanAttributeInfo[] attrs = .getAttributes();
            for (int i = 0; i < attrs.lengthi++) {
                MBeanAttributeInfo attr = attrs[i];
                list.add(attr.getName());
            }
        } catch (Exception e) {
            throwException("Could not list attribute names. Reason: "e);
        }
        return list;
    }

    
The values of each of the attributes on the MBean

Returns:
list of values of each attribute
    public List listAttributeValues() {
        List list = new ArrayList();
        Collection names = listAttributeNames();
        for (Iterator iterator = names.iterator(); iterator.hasNext();) {
            String name = (Stringiterator.next();
            try {
                Object val = this.getProperty(name);
                if (val != null) {
                    list.add(name + " : " + val.toString());
                }
            } catch (Exception e) {
                throwException("Could not list attribute values. Reason: "e);
            }
        }
        return list;
    }

    
List of string representations of all of the attributes on the MBean.

Returns:
list of descriptions of each attribute on the mbean
        List list = new ArrayList();
        try {
            MBeanAttributeInfo[] attrs = .getAttributes();
            for (int i = 0; i < attrs.lengthi++) {
                MBeanAttributeInfo attr = attrs[i];
                list.add(describeAttribute(attr));
            }
        } catch (Exception e) {
            throwException("Could not list attribute descriptions. Reason: "e);
        }
        return list;
    }

    
Description of the specified attribute name.

Parameters:
attr - the attribute
Returns:
String the description
    protected String describeAttribute(MBeanAttributeInfo attr) {
        StringBuffer buf = new StringBuffer();
        buf.append("(");
        if (attr.isReadable()) {
            buf.append("r");
        }
        if (attr.isWritable()) {
            buf.append("w");
        }
        buf.append(") ")
                .append(attr.getType())
                .append(" ")
                .append(attr.getName());
        return buf.toString();
    }

    
Description of the specified attribute name.

Parameters:
attributeName - stringified name of the attribute
Returns:
the description
    public String describeAttribute(String attributeName) {
        String ret = "Attribute not found";
        try {
            MBeanAttributeInfo[] attributes = .getAttributes();
            for (int i = 0; i < attributes.lengthi++) {
                MBeanAttributeInfo attribute = attributes[i];
                if (attribute.getName().equals(attributeName)) {
                    return describeAttribute(attribute);
                }
            }
        } catch (Exception e) {
            throwException("Could not describe attribute '" + attributeName + "'. Reason: "e);
        }
        return ret;
    }

    
Names of all the operations available on the MBean.

Returns:
all the operations on the MBean
    public Collection listOperationNames() {
        List list = new ArrayList();
        try {
            MBeanOperationInfo[] operations = .getOperations();
            for (int i = 0; i < operations.lengthi++) {
                MBeanOperationInfo operation = operations[i];
                list.add(operation.getName());
            }
        } catch (Exception e) {
            throwException("Could not list operation names. Reason: "e);
        }
        return list;
    }

    
Description of all of the operations available on the MBean.

Returns:
full description of each operation on the MBean
        List list = new ArrayList();
        try {
            MBeanOperationInfo[] operations = .getOperations();
            for (int i = 0; i < operations.lengthi++) {
                MBeanOperationInfo operation = operations[i];
                list.add(describeOperation(operation));
            }
        } catch (Exception e) {
            throwException("Could not list operation descriptions. Reason: "e);
        }
        return list;
    }

    
Get the description of the specified operation. This returns a Collection since operations can be overloaded and one operationName can have multiple forms.

Parameters:
operationName the name of the operation to describe
Returns:
Collection of operation description
    public List describeOperation(String operationName) {
        List list = new ArrayList();
        try {
            MBeanOperationInfo[] operations = .getOperations();
            for (int i = 0; i < operations.lengthi++) {
                MBeanOperationInfo operation = operations[i];
                if (operation.getName().equals(operationName)) {
                    list.add(describeOperation(operation));
                }
            }
        } catch (Exception e) {
            throwException("Could not describe operations matching name '" + operationName + "'. Reason: "e);
        }
        return list;
    }

    
Description of the operation.

Parameters:
operation the operation to describe
Returns:
pretty-printed description
    protected String describeOperation(MBeanOperationInfo operation) {
        StringBuffer buf = new StringBuffer();
        buf.append(operation.getReturnType())
                .append(" ")
                .append(operation.getName())
                .append("(");
        MBeanParameterInfo[] params = operation.getSignature();
        for (int j = 0; j < params.lengthj++) {
            MBeanParameterInfo param = params[j];
            if (j != 0) {
                buf.append(", ");
            }
            buf.append(param.getType())
                    .append(" ")
                    .append(param.getName());
        }
        buf.append(")");
        return buf.toString();
    }

    
Return an end user readable representation of the underlying MBean

Returns:
the user readable description
    public String toString() {
        StringBuffer buf = new StringBuffer();
        buf.append("MBean Name:")
                .append("\n  ")
                .append(.getCanonicalName())
                .append("\n  ");
        if (!listAttributeDescriptions().isEmpty()) {
            buf.append("\nAttributes:");
            for (Iterator iterator = listAttributeDescriptions().iterator(); iterator.hasNext();) {
                buf.append("\n  ")
                        .append((Stringiterator.next());
            }
        }
        if (!listOperationDescriptions().isEmpty()) {
            buf.append("\nOperations:");
            for (Iterator iterator = listOperationDescriptions().iterator(); iterator.hasNext();) {
                buf.append("\n  ")
                        .append((Stringiterator.next());
            }
        }
        return buf.toString();
    }
    private void throwException(String mException e) {
        if (!) {
            throw new GroovyRuntimeException(m + ee);
        }
    }
    private void throwExceptionWithTarget(String mMBeanException e) {
        if (!) {
            throw new GroovyRuntimeException(m + ee.getTargetException());
        }
    }
New to GrepCode? Check out our FAQ X