| /* |
| * |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you 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 org.apache.qpid.management.domain.model; |
| |
| import java.nio.ByteBuffer; |
| import java.util.ArrayList; |
| import java.util.HashMap; |
| import java.util.Iterator; |
| import java.util.List; |
| import java.util.Map; |
| import java.util.Map.Entry; |
| import java.util.concurrent.BlockingQueue; |
| import java.util.concurrent.SynchronousQueue; |
| import java.util.concurrent.TimeUnit; |
| import java.util.concurrent.TimeoutException; |
| |
| import javax.management.Attribute; |
| import javax.management.AttributeList; |
| import javax.management.AttributeNotFoundException; |
| import javax.management.InvalidAttributeValueException; |
| import javax.management.MBeanAttributeInfo; |
| import javax.management.MBeanException; |
| import javax.management.MBeanInfo; |
| import javax.management.MBeanOperationInfo; |
| import javax.management.MBeanRegistration; |
| import javax.management.MBeanServer; |
| import javax.management.ObjectName; |
| import javax.management.ReflectionException; |
| import javax.management.RuntimeOperationsException; |
| |
| import org.apache.qpid.management.Messages; |
| import org.apache.qpid.management.domain.handler.impl.IMethodInvocationListener; |
| import org.apache.qpid.management.domain.handler.impl.InvocationResult; |
| import org.apache.qpid.management.domain.handler.impl.MethodOrEventDataTransferObject; |
| import org.apache.qpid.management.domain.model.type.Binary; |
| import org.apache.qpid.management.domain.services.SequenceNumberGenerator; |
| import org.apache.qpid.transport.codec.BBDecoder; |
| import org.apache.qpid.transport.util.Logger; |
| |
| /** |
| * Qpid Class definition. |
| * A type definition for a manageable object. |
| * This class is also responsible to manage incoming obejct instance data (configuration & instrumentation). |
| * How can we handle data before schema is injected into this class? simply we must retain that data in raw format. |
| * This class has 2 states : |
| * 1) first state is when schema is not yet injected. In this case the incoming object data is retained as is (in raw format); |
| * 2) second state is when schema is injected. In this case each injection of data will result in an update / create / delete of |
| * the corresponding object instance. In addition, the first time the state change, the old retained raw data is cnverted in |
| * object instance(s). |
| * |
| * @author Andrea Gazzarini |
| */ |
| class QpidClass extends QpidEntity |
| { |
| /** |
| * State interface for this class definition. |
| * Each state is responsible to handle the injection of the data and / or schema. |
| * |
| * @author Andrea Gazzarini |
| */ |
| interface State |
| { |
| /** |
| * Adds configuration data for the object instance associated to the given object identifier. |
| * |
| * @param objectId the object identifier. |
| * @param rawData the raw configuration data. |
| */ |
| void addInstrumentationData (Binary objectId, byte[] rawData); |
| |
| /** |
| * Adds instrumentation data for the object instance associated to the given object identifier. |
| * |
| * @param objectId the object identifier. |
| * @param rawData the raw instrumentation data. |
| */ |
| void addConfigurationData (Binary objectId, byte[] rawData); |
| |
| /** |
| * Inject the schema into this class definition. |
| * |
| * @param propertyDefinitions |
| * @param statisticDefinitions |
| * @param methodDefinitions |
| * @throws UnableToBuildFeatureException when it's not possibile to parse schema and build the class definition. |
| */ |
| public void setSchema ( |
| List<Map<String, Object>> propertyDefinitions, |
| List<Map<String, Object>> statisticDefinitions, |
| List<MethodOrEventDataTransferObject> methodDefinitions) throws UnableToBuildFeatureException; |
| }; |
| |
| /** |
| * This is the initial state of every qpid class. |
| * The class definition instance is created but its schema has not been injected. |
| * Incoming configuration & instrumentation data will be stored in raw format because we don't know how to |
| * parse it until the schema arrives. |
| * In addition, this state is responsible (when data arrives) to request its schema. |
| */ |
| final State _schemaNotRequested = new State() { |
| |
| /** |
| * Stores the incoming data in raw format and request the schema for this class. |
| * After that a transition to the next state is made. |
| * |
| * @param objectId the object instance identifier. |
| * @param rawData incoming configuration data. |
| */ |
| public synchronized void addConfigurationData (Binary objectId, byte[] rawData) |
| { |
| try |
| { |
| requestSchema(); |
| _state = _schemaRequestedButNotYetInjected; |
| } catch (Exception e) |
| { |
| _logger.error( |
| Messages.QMAN_100015_UNABLE_TO_SEND_SCHEMA_REQUEST, |
| _parent.getName(), |
| _name); |
| } finally { |
| QpidManagedObject instance = getObjectInstance(objectId,false); |
| instance._rawConfigurationData.add(rawData); |
| } |
| } |
| |
| /** |
| * Stores the incoming data in raw format and request the schema for this class. |
| * After that a transition to the next state is made. |
| * |
| * @param objectId the object instance identifier. |
| * @param rawData incoming instrumentation data. |
| */ |
| public synchronized void addInstrumentationData (Binary objectId, byte[] rawData) |
| { |
| try |
| { |
| requestSchema(); |
| _state = _schemaRequestedButNotYetInjected; |
| } catch (Exception e) |
| { |
| _logger.error( |
| Messages.QMAN_100015_UNABLE_TO_SEND_SCHEMA_REQUEST, |
| _parent.getName(), |
| _name); |
| } finally { |
| QpidManagedObject instance = getObjectInstance(objectId,false); |
| instance._rawConfigurationData.add(rawData); |
| } |
| } |
| |
| /** |
| * This method only throws an illegal state exception because when a schema arrives |
| * this state is no longer valid. |
| */ |
| public void setSchema ( |
| List<Map<String, Object>> propertyDefinitions, |
| List<Map<String, Object>> statisticDefinitions, |
| List<MethodOrEventDataTransferObject> methodDefinitions) throws UnableToBuildFeatureException |
| { |
| throw new IllegalStateException("When a schema arrives it's not possible for this class to be in this state."); |
| } |
| }; |
| |
| /** |
| * This is the first state of this class definition : the schema is not yet injected so each injection of object data will be |
| * retained in raw format. |
| */ |
| final State _schemaRequestedButNotYetInjected = new State() |
| { |
| /** |
| * Stores the incoming data in raw format. |
| * |
| * @param objectId the object instance identifier. |
| * @param rawData incoming configuration data. |
| */ |
| public void addConfigurationData (Binary objectId, byte[] rawData) |
| { |
| QpidManagedObject instance = getObjectInstance(objectId,false); |
| instance._rawConfigurationData.add(rawData); |
| } |
| |
| /** |
| * Stores the incoming data in raw format. |
| * |
| * @param objectId the object instance identifier. |
| * @param rawData incoming instrumentation data. |
| */ |
| public void addInstrumentationData (Binary objectId, byte[] rawData) |
| { |
| QpidManagedObject instance = getObjectInstance(objectId,false); |
| instance._rawInstrumentationData.add(rawData); |
| } |
| |
| /** |
| * When a schema is injected into this defintiion the following should happen : |
| * 1) the incoming schema is parsed and the class definition is built; |
| * 2) the retained raw data is converted into object instance(s) |
| * 3) the internal state of this class changes; |
| * |
| * If someting is wrong during that process the schema is not built and the state don't change. |
| */ |
| public synchronized void setSchema ( |
| List<Map<String, Object>> propertyDefinitions, |
| List<Map<String, Object>> statisticDefinitions, |
| List<MethodOrEventDataTransferObject> methodDefinitions) throws UnableToBuildFeatureException |
| { |
| |
| MBeanAttributeInfo [] attributesMetadata = new MBeanAttributeInfo[propertyDefinitions.size()+statisticDefinitions.size()]; |
| MBeanOperationInfo [] operationsMetadata = new MBeanOperationInfo[methodDefinitions.size()]; |
| |
| buildAttributes(propertyDefinitions,statisticDefinitions,attributesMetadata); |
| buildMethods(methodDefinitions,operationsMetadata); |
| |
| _metadata = new MBeanInfo(_name,_name,attributesMetadata,null,operationsMetadata,null); |
| |
| // Converting stored object instances into JMX MBean and removing raw instance data. |
| for (Entry<Binary, QpidManagedObject> instanceEntry : _objectInstances.entrySet()) |
| { |
| Binary objectId = instanceEntry.getKey(); |
| QpidManagedObject instance = instanceEntry.getValue(); |
| |
| for (Iterator<byte[]> iterator = instance._rawInstrumentationData.iterator(); iterator.hasNext();) |
| { |
| updateInstanceWithInstrumentationData(instance,iterator.next()); |
| iterator.remove(); |
| } |
| |
| for (Iterator<byte[]> iterator = instance._rawConfigurationData.iterator(); iterator.hasNext();) |
| { |
| updateInstanceWithConfigurationData(instance, iterator.next()); |
| iterator.remove(); |
| } |
| |
| JMX_SERVICE.registerObjectInstance(instance,_parent.getOwnerId(),_parent.getName(),_name,objectId); |
| } |
| _state = _schemaInjected; |
| } |
| }; |
| |
| /** |
| * After a schema is built into this definition this is the current state of the class. |
| */ |
| final State _schemaInjected = new State() |
| { |
| /** |
| * Updates the configuration state of the object instance associates with the given object identifier. |
| * |
| * @param objectId the object identifier. |
| * @param rawData the configuration data (raw format). |
| */ |
| public void addConfigurationData (Binary objectId, byte[] rawData) |
| { |
| QpidManagedObject instance = getObjectInstance(objectId,true); |
| updateInstanceWithConfigurationData(instance, rawData); |
| } |
| |
| /** |
| * Updates the instrumentation state of the object instance associates with the given object identifier. |
| * |
| * @param objectId the object identifier. |
| * @param rawData the instrumentation data (raw format). |
| */ |
| public void addInstrumentationData (Binary objectId, byte[] rawData) |
| { |
| QpidManagedObject instance = getObjectInstance(objectId,true); |
| updateInstanceWithInstrumentationData(instance, rawData); |
| } |
| |
| /** |
| * Never called when the class definition has this state. |
| */ |
| public void setSchema ( |
| List<Map<String, Object>> propertyDefinitions, |
| List<Map<String, Object>> statisticDefinitions, |
| List<MethodOrEventDataTransferObject> methodDefinitions) throws UnableToBuildFeatureException |
| { |
| throw new IllegalStateException("When a schema arrives it's not possible for this class to be in this state."); |
| } |
| }; |
| |
| /** |
| * MBean used for representing remote broker object instances. |
| * This is the core component of the QMan domain model |
| * |
| * @author Andrea Gazzarini |
| */ |
| class QpidManagedObject extends QpidManagedEntity implements MBeanRegistration |
| { |
| private Binary _objectId; |
| |
| // Arrays used for storing raw data before this mbean is registered to mbean server. |
| List<byte[]> _rawInstrumentationData = new ArrayList<byte[]>(); |
| List<byte[]> _rawConfigurationData = new ArrayList<byte[]>(); |
| |
| /** |
| * Builds a new managed object with the given object identifier. |
| * |
| * @param objectId the object identifier. |
| */ |
| QpidManagedObject(Binary objectId) |
| { |
| this._objectId = objectId; |
| } |
| |
| /** |
| * Returns the value of the given attribute.s |
| * |
| * @throws AttributeNotFoundException when no attribute is found with the given name. |
| */ |
| public Object getAttribute (String attributeName) throws AttributeNotFoundException, MBeanException, ReflectionException |
| { |
| if (attributeName == null) |
| { |
| throw new RuntimeOperationsException(new IllegalArgumentException("attribute name must not be null")); |
| } |
| |
| if (_properties.containsKey(attributeName) || _statistics.containsKey(attributeName)) |
| { |
| return _attributes.get(attributeName); |
| } else |
| { |
| throw new AttributeNotFoundException(attributeName); |
| } |
| } |
| |
| /** |
| * Executes an operation on this object instance. |
| * |
| * @param actionName the name of the method. |
| * @param params the method parameters |
| * @param signature the method signature. |
| */ |
| public Object invoke (String actionName, Object[] params, String[] signature) throws MBeanException,ReflectionException |
| { |
| // TODO : Overloaded methods |
| QpidMethod method = _methods.get(actionName); |
| if (method != null) |
| { |
| try |
| { |
| method.validate(params); |
| return invokeMethod(_objectId, method, params); |
| } catch (Exception exception) |
| { |
| throw new MBeanException(exception); |
| } |
| } else { |
| throw new ReflectionException(new NoSuchMethodException(actionName)); |
| } |
| } |
| |
| /** |
| * Sets the value of the given attribute on this object instance. |
| * |
| * @param attribute contains the new value of the attribute. |
| * @throws AttributeNotFoundException when the given attribute is not found on this object instance. |
| * @throws InvalidAttributeValueException when the given value is violating one attribute invariant. |
| */ |
| public void setAttribute (Attribute attribute) throws AttributeNotFoundException, |
| InvalidAttributeValueException, MBeanException, ReflectionException |
| { |
| QpidProperty property = _properties.get(attribute.getName()); |
| try |
| { |
| property.validate(attribute.getValue()); |
| } catch(ValidationException exception) |
| { |
| throw new InvalidAttributeValueException(exception.getMessage()); |
| } |
| throw new RuntimeException("Not yet implemented."); |
| } |
| |
| /** |
| * Sets the values of several attributes of this MBean. |
| * |
| * @param attributes a list of attributes: The identification of the attributes to be set and the values they are to be set to. |
| * @return The list of attributes that were set, with their new values. |
| */ |
| public AttributeList setAttributes (AttributeList attributes) |
| { |
| throw new RuntimeException("Not yet implemented."); |
| } |
| |
| /** |
| * MBean server callback after deregistration. |
| */ |
| public void postDeregister () |
| { |
| } |
| |
| /** |
| * After the object is registered the raw data is set to null. |
| * This is done because we no longer need this data : it has already been |
| * injected into this object instance. |
| * |
| * @param registrationDone a flag indicating if the instance has been registered to mbean server. |
| */ |
| public void postRegister (Boolean registrationDone) |
| { |
| if (registrationDone) |
| { |
| _rawConfigurationData = null; |
| _rawInstrumentationData = null; |
| } |
| } |
| |
| /** |
| * MBean server callback before deregistration. |
| */ |
| public void preDeregister () throws Exception |
| { |
| } |
| |
| /** |
| * MBean server callback before registration. |
| */ |
| public ObjectName preRegister (MBeanServer server, ObjectName name) throws Exception |
| { |
| return name; |
| } |
| } |
| |
| Map<String, QpidProperty> _properties = new HashMap<String, QpidProperty>(); |
| Map<String, QpidStatistic> _statistics = new HashMap<String, QpidStatistic>(); |
| private Map<String, QpidMethod> _methods = new HashMap<String, QpidMethod>(); |
| |
| private List<QpidProperty> _schemaOrderedProperties = new ArrayList<QpidProperty>(); |
| private List<QpidStatistic> _schemaOrderedStatistics= new ArrayList<QpidStatistic>(); |
| |
| private int _howManyPresenceBitMasks; |
| private BlockingQueue<InvocationResult> _exchangeChannelForMethodInvocations; |
| private final IMethodInvocationListener _methodInvocationListener; |
| |
| Map<Binary, QpidManagedObject> _objectInstances = new HashMap<Binary, QpidManagedObject>(); |
| State _state = _schemaNotRequested;; |
| |
| private final static class Log |
| { |
| private final static Logger LOGGER = Logger.get(QpidClass.class); |
| final static void logMethodInvocationResult(InvocationResult result) |
| { |
| if (LOGGER.isDebugEnabled()) |
| { |
| LOGGER.debug(String.valueOf(result)); |
| } |
| } |
| } |
| |
| /** |
| * Builds a new class with the given name and package as parent. |
| * |
| * @param className the name of the class. |
| * @param hash the class schema hash. |
| * @param parentPackage the parent of this class. |
| */ |
| QpidClass(String className, Binary hash, QpidPackage parentPackage) |
| { |
| super(className,hash, parentPackage); |
| this._methodInvocationListener = _parent.getMethodInvocationListener(); |
| this._exchangeChannelForMethodInvocations = new SynchronousQueue<InvocationResult>(); |
| } |
| |
| /** |
| * Adds the configuration data for the object instance associated to the given object identifier. |
| * |
| * @param objectId the object identifier. |
| * @param rawData the raw configuration data. |
| */ |
| void addInstrumentationData (Binary objectId, byte[] rawData) |
| { |
| _logger.debug( |
| Messages.QMAN_200014_INCOMING_INSTRUMENTATION_DATA, |
| _parent.getOwnerId(), |
| _parent.getName(), |
| _name, |
| objectId); |
| _state.addInstrumentationData(objectId, rawData); |
| } |
| |
| /** |
| * Adds the instrumentation data for the object instance associated to the given object identifier. |
| * |
| * @param objectId the object identifier. |
| * @param rawData the raw instrumentation data. |
| */ |
| void addConfigurationData (Binary objectId, byte[] rawData) |
| { |
| _logger.debug( |
| Messages.QMAN_200015_INCOMING_CONFIGURATION_DATA, |
| _parent.getOwnerId(), |
| _parent.getName(), |
| _name, |
| objectId); |
| _state.addConfigurationData(objectId, rawData); |
| } |
| |
| /** |
| * Sets the schema for this class definition. |
| * A schema is basically a metadata description of all properties, statistics, methods and events of this class. |
| * |
| * @param propertyDefinitions properties metadata. |
| * @param statisticDefinitions statistics metadata. |
| * @param methodDefinitions methods metadata. |
| * @throws UnableToBuildFeatureException when some error occurs while parsing the incoming schema. |
| */ |
| void setSchema ( |
| List<Map<String, Object>> propertyDefinitions, |
| List<Map<String, Object>> statisticDefinitions, |
| List<MethodOrEventDataTransferObject> methodDefinitions) throws UnableToBuildFeatureException |
| { |
| _logger.info(Messages.QMAN_000010_INCOMING_SCHEMA,_parent.getOwnerId(),_parent.getName(),_name); |
| _state.setSchema(propertyDefinitions, statisticDefinitions, methodDefinitions); |
| } |
| |
| /** |
| * Internal method used for building attributes definitions. |
| * |
| * @param props the map contained in the properties schema. |
| * @param stats the map contained in the statistics schema. |
| * @param attributes the management metadata for attributes. |
| * @throws UnableToBuildFeatureException when it's not possibile to build one attribute definition. |
| */ |
| void buildAttributes ( |
| List<Map<String, Object>> props, |
| List<Map<String, Object>> stats, |
| MBeanAttributeInfo[] attributes) throws UnableToBuildFeatureException |
| { |
| int index = 0; |
| int howManyOptionalProperties = 0; |
| |
| for (Map<String, Object> propertyDefinition : props) |
| { |
| QpidFeatureBuilder builder = QpidFeatureBuilder.createPropertyBuilder(propertyDefinition); |
| builder.build(); |
| |
| QpidProperty property = (QpidProperty) builder.getQpidFeature(); |
| |
| howManyOptionalProperties += (property.isOptional()) ? 1 : 0; |
| |
| _properties.put(property.getName(),property); |
| _schemaOrderedProperties.add(property); |
| attributes[index++]=(MBeanAttributeInfo) builder.getManagementFeature(); |
| |
| _logger.debug( |
| Messages.QMAN_200016_PROPERTY_DEFINITION_HAS_BEEN_BUILT, |
| _parent.getName(), |
| _name, |
| property); |
| } |
| |
| _howManyPresenceBitMasks = (int)Math.ceil((double)howManyOptionalProperties / 8); |
| |
| _logger.debug( |
| Messages.QMAN_200018_OPTIONAL_PROPERTIES_INFO, |
| _parent.getOwnerId(), |
| _parent.getName(), |
| _name, |
| _howManyPresenceBitMasks); |
| |
| for (Map<String, Object> statisticDefinition : stats) |
| { |
| QpidFeatureBuilder builder = QpidFeatureBuilder.createStatisticBuilder(statisticDefinition); |
| builder.build(); |
| QpidStatistic statistic = (QpidStatistic) builder.getQpidFeature(); |
| |
| _statistics.put(statistic.getName(),statistic); |
| _schemaOrderedStatistics.add(statistic); |
| attributes[index++]=(MBeanAttributeInfo) builder.getManagementFeature(); |
| |
| _logger.debug( |
| Messages.QMAN_200017_STATISTIC_DEFINITION_HAS_BEEN_BUILT, |
| _parent.getName(), |
| _name, |
| statistic); |
| } |
| } |
| |
| /** |
| * Returns the object instance associated to the given identifier. |
| * Note that if the identifier is not associated to any obejct instance, a new one will be created. |
| * |
| * @param objectId the object identifier. |
| * @param registration a flag indicating whenever the (new ) instance must be registered with MBean server. |
| * @return the object instance associated to the given identifier. |
| */ |
| QpidManagedObject getObjectInstance(Binary objectId, boolean registration) |
| { |
| QpidManagedObject objectInstance = _objectInstances.get(objectId); |
| if (objectInstance == null) |
| { |
| objectInstance = new QpidManagedObject(objectId); |
| _objectInstances.put(objectId, objectInstance); |
| if (registration) |
| { |
| JMX_SERVICE.registerObjectInstance(objectInstance,_parent.getOwnerId(),_parent.getName(),_name,objectId); |
| } |
| } |
| return objectInstance; |
| } |
| |
| /** |
| * Internal method used for building method defintiions. |
| * |
| * @param definitions the properties map contained in the incoming schema. |
| * @param operationsMetadata |
| * @throws UnableToBuildFeatureException when it's not possibile to build one or more definitions. |
| */ |
| void buildMethods (List<MethodOrEventDataTransferObject> definitions, MBeanOperationInfo[] operationsMetadata) throws UnableToBuildFeatureException |
| { |
| int index = 0; |
| for (MethodOrEventDataTransferObject definition: definitions) |
| { |
| QpidFeatureBuilder builder = QpidFeatureBuilder.createMethodBuilder(definition); |
| builder.build(); |
| operationsMetadata [index++]= (MBeanOperationInfo) builder.getManagementFeature(); |
| QpidMethod method = (QpidMethod) builder.getQpidFeature(); |
| _methods.put(method.getName(),method); |
| } |
| } |
| |
| /** |
| * Header (opcode='M') |
| * ObjectId of target object (128 bits) |
| * Package name (str8) |
| * Class name (str8) |
| * Class hash (bin128) |
| * Method name (str8) [as defined in the schema] |
| * Now encode all input ("I") and i/o (IO) arguments in the order in which they are defined in the schema. |
| * (i.e. make one pass over the argument list and encode arguments that are either input or inptu/output). |
| |
| * @param objectId |
| * @param method |
| * @param parameters |
| * @throws Exception |
| */ |
| private InvocationResult invokeMethod(Binary objectId,QpidMethod method,Object [] parameters) throws Exception |
| { |
| try |
| { |
| _service.connect(); |
| |
| int sequenceNumber = SequenceNumberGenerator.getNextSequenceNumber(); |
| _methodInvocationListener.operationIsGoingToBeInvoked(new InvocationEvent(this,sequenceNumber,_exchangeChannelForMethodInvocations)); |
| _service.invoke(_parent.getName(), _name, _hash,objectId,parameters, method,sequenceNumber,objectId.getBankId(),objectId.getBrokerId()); |
| |
| InvocationResult result = _exchangeChannelForMethodInvocations.poll(5000,TimeUnit.MILLISECONDS); |
| |
| if (result == null) |
| { |
| throw new TimeoutException(); |
| } |
| |
| Map<String, Object> output = method.decodeParameters(result.getOutputAndBidirectionalArgumentValues()); |
| result.setOutputSection(output); |
| |
| Log.logMethodInvocationResult(result); |
| |
| if (result.isException()) |
| { |
| result.createAndThrowException(); |
| } |
| return result; |
| } finally |
| { |
| _service.close(); |
| } |
| } |
| |
| /** |
| * Updates the given obejct instance with the given incoming configuration data. |
| * |
| * @param instance the managed object instance. |
| * @param rawData the incoming configuration data which contains new values for instance properties. |
| */ |
| void updateInstanceWithConfigurationData(QpidManagedObject instance,byte [] rawData) |
| { |
| BBDecoder decoder = new BBDecoder(); |
| decoder.init(ByteBuffer.wrap(rawData)); |
| |
| byte [] presenceBitMasks = decoder.readBytes(_howManyPresenceBitMasks); |
| for (QpidProperty property : _schemaOrderedProperties) |
| { |
| try { |
| Object value = property.decodeValue(decoder,presenceBitMasks); |
| instance.createOrReplaceAttributeValue(property.getName(),value); |
| } catch(Exception ignore) { |
| _logger.error(Messages.QMAN_100016_UNABLE_TO_DECODE_FEATURE_VALUE, _parent.getName(),_name,property.getName()); |
| } |
| } |
| } |
| |
| /** |
| * Updates the given object instance with the given incoming instrumentation data. |
| * |
| * @param instance the managed object instance. |
| * @param rawData the incoming instrumentation data which contains new values for instance properties. |
| */ |
| void updateInstanceWithInstrumentationData(QpidManagedObject instance,byte [] rawData) |
| { |
| BBDecoder decoder = new BBDecoder(); |
| decoder.init(ByteBuffer.wrap(rawData)); |
| |
| for (QpidStatistic statistic : _schemaOrderedStatistics) |
| { |
| try { |
| Object value = statistic.decodeValue(decoder); |
| instance.createOrReplaceAttributeValue(statistic.getName(),value); |
| } catch(Exception ignore) { |
| _logger.error(Messages.QMAN_100016_UNABLE_TO_DECODE_FEATURE_VALUE, _parent.getName(),_name,statistic.getName()); |
| } |
| } |
| } |
| |
| @Override |
| public String toString () |
| { |
| return new StringBuilder() |
| .append(_parent.getOwnerId()) |
| .append("::") |
| .append(_parent.getName()) |
| .append('.') |
| .append(_name) |
| .toString(); |
| } |
| |
| /** |
| * Removes the object instance associated to the given identifier. |
| * |
| * @param objectId the object identifier. |
| */ |
| void removeObjectInstance (Binary objectId) |
| { |
| QpidManagedObject toBeRemoved = _objectInstances.remove(objectId); |
| if (toBeRemoved != null) |
| { |
| JMX_SERVICE.unregisterObjectInstance(_parent.getOwnerId(),_parent.getName(),_name,toBeRemoved._objectId); |
| } |
| } |
| |
| /** |
| * Deregisters all the object instances and release all previously acquired resources. |
| */ |
| void releaseResources () |
| { |
| _objectInstances.clear(); |
| JMX_SERVICE.unregisterObjectInstances(); |
| _service.close(); |
| } |
| } |
