package org.jolokia.client.request;
/*
* Copyright 2009-2010 Roland Huss
*
* 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.
*/
import java.util.*;
import javax.management.MalformedObjectNameException;
import javax.management.ObjectName;
import org.json.simple.JSONObject;
/**
* Response for a {@link org.jolokia.client.request.J4pType#READ} request. Since a single
* READ request can result in multiple values returned, this response object
* allows for obtaining iteration of those values in case the MBean name given for the request
* was a pattern of when multiple attributes were requested.
*
* @author roland
* @since Apr 26, 2010
*/
public final class J4pReadResponse extends J4pResponse<J4pReadRequest> {
/**
* Constructor, which should be used directly.
*
* @param pRequest the request which lead to this response.
* @param pJsonResponse the JSON response as obtained from the server agent.
*/
J4pReadResponse(J4pReadRequest pRequest, JSONObject pJsonResponse) {
super(pRequest, pJsonResponse);
}
/**
* Get all MBean names for which the request fetched values. If the request
* contained an MBean pattern then all MBean names matching this pattern and which contained
* attributes of the given name are returned. If the MBean wasnt a pattern a single
* value collection with the single MBean name of the request is returned.
*
* @return list of MBean names
* @throws MalformedObjectNameException if the returned MBean names could not be converted to
* {@link ObjectName}s. Shouldnt occur, though.
*/
public Collection<ObjectName> getObjectNames() throws MalformedObjectNameException {
ObjectName mBean = getRequest().getObjectName();
if (mBean.isPattern()) {
// The result value contains the list of fetched object names
JSONObject values = getValue();
Set<ObjectName> ret = new HashSet<ObjectName>();
for (Object name : values.keySet()) {
ret.add(new ObjectName((String) name));
}
return ret;
} else {
return Arrays.asList(mBean);
}
}
/**
* Get the name of all attributes fetched for a certain MBean name. If the request was
* performed for a single MBean, then the given name must match that of the MBean name
* provided in the request. If <code>null</code> is given as argument, then this method
* will return all attributes for the single MBean given in the request
*
* @param pObjectName MBean for which to get the attribute names,
* @return a collection of attribute names
*/
public Collection<String> getAttributes(ObjectName pObjectName) {
ObjectName requestMBean = getRequest().getObjectName();
if (requestMBean.isPattern()) {
// We need to got down one level in the returned values
JSONObject attributes = getAttributesForObjectNameWithPatternRequest(pObjectName);
return attributes.keySet();
} else {
if (pObjectName != null && !pObjectName.equals(requestMBean)) {
throw new IllegalArgumentException("Given ObjectName " + pObjectName + " doesn't match with" +
" the single ObjectName " + requestMBean + " given in the request");
}
return getAttributes();
}
}
/**
* Get all attributes obtained. This method can be only used, if the requested MBean
* was not a pattern (i.e. the request was for a single MBean).
*
* @return a list of attributes for this request. If the request was performed for
* only a single attribute, the attribute name of the request is returend as
* a single valued list. For more than one attribute, the attribute names
* a returned from the returned list.
*/
public Collection<String> getAttributes() {
J4pReadRequest request = getRequest();
ObjectName requestBean = request.getObjectName();
if (requestBean.isPattern()) {
throw new IllegalArgumentException(
"Attributes can be fetched only for non-pattern request (current: " +
requestBean.getCanonicalName() + ")");
}
// The attribute names are the same as from the request
if (request.hasSingleAttribute()) {
// Contains only a single attribute:
return request.getAttributes();
} else {
JSONObject attributes = getValue();
return attributes.keySet();
}
}
/**
* Get the value for a certain MBean and a given attribute. This method is especially
* useful if the request leading to this response was done for multiple MBeans (i.e.
* a read for an MBean pattern) and multiple attributes. However, this method can be
* used for a request for single MBeans and single attributes as well, but then the given
* parameters must match the parameters given in the request.
*
* @param pObjectName name of the Mbean or <code>null</code> if the request was only for a single
* Mbeans in which case this single MBean is taken from the request
* @param pAttribute the attribute or <code>null</code> if the request was for a single
* attribute in which case the attribute name is taken from the request
* @param <V> the object type of the return value ({@link String},{@link Map} or {@link List})
* @return the value
* @throws IllegalArgumentException if there was no value for the given parameters or if <code>null</code>
* was given for given for one or both arguments and the request was for multiple MBeans
* or attributes.
*/
public <V> V getValue(ObjectName pObjectName,String pAttribute) {
ObjectName requestMBean = getRequest().getObjectName();
if (requestMBean.isPattern()) {
JSONObject mAttributes = getAttributesForObjectNameWithPatternRequest(pObjectName);
if (!mAttributes.containsKey(pAttribute)) {
throw new IllegalArgumentException("No attribute " + pAttribute + " for ObjectName " + pObjectName + " returned for" +
" the given request");
}
return (V) mAttributes.get(pAttribute);
} else {
return (V) getValue(pAttribute);
}
}
/**
* Get the value for a single attribute. This method is appropriate if the request was done for a single
* MBean (no pattern), but multiple attributes. If it is called for a request with non-pattern MBean
* and a single attribute, the given attribute must match the attribute of the request. If this method is
* called with a <code>null</code> argument, then it will return the value if the request was for
* a single attribute, otherwise it will raise an {@link IllegalArgumentException}
*
* @param pAttribute attribute for which to get the value
* @param <V> value type
* @return value
* @throws IllegalArgumentException if the attribute could not be found in the return value or if this method
* is called with a <code>null</code> argument, but the request leads to multiple attribute return values.
*/
public <V> V getValue(String pAttribute) {
J4pReadRequest request = getRequest();
ObjectName requestBean = request.getObjectName();
if (requestBean.isPattern()) {
throw new IllegalArgumentException(
"Attributes without ObjectName can be fetched only for non-pattern request (current: " +
requestBean.getCanonicalName() + ")");
}
// The attribute names are the same as from the request
if (request.hasSingleAttribute()) {
// Contains only a single attribute:
if (pAttribute != null && !pAttribute.equals(request.getAttribute())) {
throw new IllegalArgumentException("Given attribute " + pAttribute + " doesnt match single attribute " +
"given " + request.getAttribute() + " in the request");
}
return (V) getValue();
} else {
JSONObject attributes = getValue();
if (pAttribute == null) {
throw new IllegalArgumentException("Cannot use null-attribute name to fetch a value from a multi-attribute request");
}
if (!attributes.containsKey(pAttribute)) {
throw new IllegalArgumentException("No such key " + pAttribute + " in the set of returned attribute values");
}
return (V) attributes.get(pAttribute);
}
}
// ============================================================================================================
private JSONObject getAttributesForObjectNameWithPatternRequest(ObjectName pObjectName) {
ObjectName pMBeanFromRequest = getRequest().getObjectName();
ObjectName objectName = pObjectName == null ? pMBeanFromRequest : pObjectName;
JSONObject values = getValue();
JSONObject attributes = (JSONObject) values.get(objectName.getCanonicalName());
if (attributes == null) {
throw new IllegalArgumentException("No ObjectName " + objectName + " found in the set of returned " +
" ObjectNames for requested pattern " + pMBeanFromRequest);
}
return attributes;
}
}