| /* |
| * 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.aries.jmx.blueprint; |
| |
| import java.io.IOException; |
| |
| import javax.management.openmbean.ArrayType; |
| import javax.management.openmbean.CompositeData; |
| import javax.management.openmbean.CompositeType; |
| import javax.management.openmbean.SimpleType; |
| |
| |
| public interface BlueprintMetadataMBean { |
| |
| /** |
| * The object name for this MBean. |
| */ |
| String OBJECTNAME = JmxConstants.ARIES_BLUEPRINT+":service=blueprintMetadata,version=1.0"; |
| |
| |
| /////////////////////////////////////////////////////////////// |
| // Define <value>'s CompositeType |
| /////////////////////////////////////////////////////////////// |
| |
| /** |
| * The key STRING_VALUE, used in {@link #STRING_VALUE_ITEM}. |
| */ |
| String STRING_VALUE = "StringValue"; |
| |
| /** |
| * The item containing the un-converted string representation of the value. |
| * The key is {@link #STRING_VALUE}, and the type is {@link SimpleType#STRING}. |
| */ |
| Item STRING_VALUE_ITEM = new Item( |
| STRING_VALUE, |
| "The un-converted string representation of a value", |
| SimpleType.STRING); |
| |
| /** |
| * The key TYPE, used in {@link #TYPE_ITEM}. |
| */ |
| String TYPE = "Type"; |
| |
| /** |
| * The item containing the name of the type to which the value should be converted. |
| * The key is {@link #TYPE}, and the type is {@link SimpleType#STRING}. |
| */ |
| Item TYPE_ITEM = new Item( |
| TYPE, |
| "The type of a value", |
| SimpleType.STRING); |
| |
| /** |
| * The name of CompositeType for ValueMetadata objects, used in {@link #VALUE_METADATA_TYPE}. |
| */ |
| String VALUE_METADATA = "ValueMetadata"; |
| |
| |
| /** |
| * The CompositeType encapsulates ValueMetadata objects. It contains the following items: |
| * <ul> |
| * <li>{@link #STRING_VALUE}</li> |
| * <li>{@link #TYPE}</li> |
| * </ul> |
| */ |
| CompositeType VALUE_METADATA_TYPE = Item.compositeType( |
| VALUE_METADATA, |
| "This type encapsulates ValueMetadata objects", |
| STRING_VALUE_ITEM, |
| TYPE_ITEM); |
| |
| /////////////////////////////////////////////////////////////// |
| // Define <null>'s CompositeType |
| /////////////////////////////////////////////////////////////// |
| |
| /** |
| * The key PLACEHOLDER, used in {@link #PLACEHOLDER_ITEM}. |
| */ |
| String PLACEHOLDER = "Placeholder"; |
| |
| /** |
| * The item is a placeholder in the null metadata type. |
| * The key is {@link #PLACEHOLDER}, and the type is {@link SimpleType#STRING}. |
| */ |
| Item PLACEHOLDER_ITEM = new Item( |
| PLACEHOLDER, |
| "This is a placeholder", |
| SimpleType.VOID); |
| |
| /** |
| * The name of CompositeType for NullMetadata objects, used in {@link #NULL_METADATA_TYPE}. |
| */ |
| String NULL_METADATA = "NullMetadata"; |
| |
| /** |
| * The CompositeType for NullMetadata objects. A composite type requires at least one item, so we add a placeholder item. |
| */ |
| CompositeType NULL_METADATA_TYPE = Item.compositeType( |
| NULL_METADATA, |
| "This type encapsulates NullMetadata objects", |
| PLACEHOLDER_ITEM); |
| |
| /////////////////////////////////////////////////////////////// |
| // Define <ref>'s CompositeType |
| /////////////////////////////////////////////////////////////// |
| |
| /** |
| * The key COMPONENT_ID, used in {@link #COMPONENT_ID_ITEM}. |
| */ |
| String COMPONENT_ID = "ComponentId"; |
| |
| /** |
| * The item containing the component id to which the "ref" associates. |
| * The key is {@link #COMPONENT_ID}, and the type is {@link SimpleType#STRING}. |
| */ |
| Item COMPONENT_ID_ITEM = new Item( |
| COMPONENT_ID, |
| "The component id", |
| SimpleType.STRING); |
| /** |
| * The name of CompositeType for RefMetadata objects, used in {@link #REF_METADATA_TYPE}. |
| */ |
| String REF_METADATA = "RefMetadata"; |
| |
| /** |
| * The CompositeType for a RefMetadata object. It contains the following items: |
| * <ul> |
| * <li>{@link #COMPONENT_ID}</li> |
| * </ul> |
| */ |
| CompositeType REF_METADATA_TYPE = Item.compositeType( |
| REF_METADATA, |
| "This type encapsulates RefMetadata objects", |
| COMPONENT_ID_ITEM); |
| |
| /////////////////////////////////////////////////////////////// |
| // Define <idref>'s CompositeType |
| // COMPONENT_ID_ITEM defined in <ref>'s definition |
| /////////////////////////////////////////////////////////////// |
| /** |
| * The name of CompositeType for IdRefMetadata objects, used in {@link #ID_REF_METADATA_TYPE}. |
| */ |
| String ID_REF_METADATA = "IdRefMetadata"; |
| |
| /** |
| * The CompositeType for an IdRefMetadata object. It contains the following items: |
| * <ul> |
| * <li>{@link #COMPONENT_ID}</li> |
| * </ul> |
| */ |
| CompositeType ID_REF_METADATA_TYPE = Item.compositeType( |
| ID_REF_METADATA, |
| "This type encapsulates IdRefMetadata objects", |
| COMPONENT_ID_ITEM); |
| |
| /////////////////////////////////////////////////////////////// |
| // Define <entry>'s CompositeType, |
| // used by MapMetadata, PropsMetadata, and Service properties |
| /////////////////////////////////////////////////////////////// |
| |
| /** |
| * The key KEY, used in {@link #KEY_ITEM}. |
| */ |
| String KEY = "Key"; |
| |
| /** |
| * The item containing the key of an entry. |
| * The key is {@link #KEY}, and the type is {@link SimpleType#STRING}. |
| */ |
| Item KEY_ITEM = new Item( |
| KEY, |
| "The key of an entry", |
| JmxConstants.BYTE_ARRAY_TYPE); |
| |
| /** |
| * The key VALUE, used in {@link #VALUE_ITEM}. |
| */ |
| String VALUE = "Value"; |
| |
| /** |
| * The item containing a value and this will be used by |
| * BeanArgument, BeanProperty, MapEntry and CollectionMetadata. |
| * The key is {@link #VALUE}, and the type is {@link JmxConstants#BYTE_ARRAY_TYPE}. |
| */ |
| Item VALUE_ITEM = new Item( |
| VALUE, |
| "A value", |
| JmxConstants.BYTE_ARRAY_TYPE); |
| |
| /** |
| * The name of CompositeType for MapEntry objects, used in {@link #MAP_ENTRY_TYPE}. |
| */ |
| String MAP_ENTRY = "MapEntry"; |
| |
| /** |
| * The CompositeType for a MapEntry object. It contains the following items: |
| * <ul> |
| * <li>{@link #KEY}</li> |
| * <li>{@link #VALUE}</li> |
| * </ul> |
| */ |
| CompositeType MAP_ENTRY_TYPE = Item.compositeType( |
| MAP_ENTRY, |
| "This type encapsulates MapEntry objects", |
| KEY_ITEM, |
| VALUE_ITEM); |
| |
| /////////////////////////////////////////////////////////////// |
| // Define <map>'s CompositeType |
| /////////////////////////////////////////////////////////////// |
| |
| /** |
| * The key ENTRIES, used in {@link #ENTRIES_ITEM}. |
| */ |
| String ENTRIES = "Entries"; |
| |
| /** |
| * The item containing an array of entries |
| * The key is {@link #ENTRIES}, and the type is {@link ArrayType}. |
| */ |
| Item ENTRIES_ITEM = new Item( |
| ENTRIES, |
| "An array of entries", |
| Item.arrayType(1, MAP_ENTRY_TYPE)); |
| |
| /** |
| * The key KEY_TYPE, used in {@link #KEY_TYPE_ITEM}. |
| */ |
| String KEY_TYPE = "KeyType"; |
| |
| /** |
| * The item containing the key type of the entries. |
| * The key is {@link #KEY_TYPE}, and the type is {@link SimpleType#STRING}. |
| */ |
| Item KEY_TYPE_ITEM = new Item( |
| KEY_TYPE, |
| "The key type of the entries", |
| SimpleType.STRING); |
| |
| /** |
| * The key VALUE_TYPE, used in {@link #VALUE_TYPE_ITEM}. |
| */ |
| String VALUE_TYPE = "ValueType"; |
| |
| /** |
| * The item containing the value type that the value should be |
| * The key is {@link #VALUE_TYPE}, and the type is {@link SimpleType#STRING}. |
| */ |
| Item VALUE_TYPE_ITEM = new Item( |
| VALUE_TYPE, |
| "The value type", |
| SimpleType.STRING); |
| |
| /** |
| * The name of CompositeType for MapMetadata objects, used in {@link #MAP_METADATA_TYPE}. |
| */ |
| String MAP_METADATA = "MapMetadata"; |
| |
| /** |
| * The CompositeType for a MapMetadata object. It contains the following items: |
| * <ul> |
| * <li>{@link #ENTRIES}</li> |
| * <li>{@link #KEY_TYPE}</li> |
| * <li>{@link #VALUE_TYPE}</li> |
| * </ul> |
| */ |
| CompositeType MAP_METADATA_TYPE = Item.compositeType( |
| MAP_METADATA, |
| "This type encapsulates MapMetadata objects", |
| ENTRIES_ITEM, |
| KEY_TYPE_ITEM, |
| VALUE_TYPE_ITEM); |
| |
| /////////////////////////////////////////////////////////////// |
| // Define <props>'s CompositeType |
| // ENTRIES_ITEM defined in <map>'s definition |
| /////////////////////////////////////////////////////////////// |
| |
| /** |
| * The name of CompositeType for PropsMetadata objects, used in {@link #PROPS_METADATA_TYPE}. |
| */ |
| String PROPS_METADATA = "PropsMetadata"; |
| |
| /** |
| * The CompositeType for a PropsMetadata object. It contains the following items: |
| * <ul> |
| * <li>{@link #ENTRIES}</li> |
| * </ul> |
| */ |
| CompositeType PROPS_METADATA_TYPE = Item.compositeType( |
| PROPS_METADATA, |
| "This type encapsulates PropsMetadata objects", |
| ENTRIES_ITEM); |
| |
| /////////////////////////////////////////////////////////////// |
| // Define <collection>'s CompositeType |
| // VALUE_TYPE_ITEM defined in <map>'s definition |
| /////////////////////////////////////////////////////////////// |
| |
| /** |
| * The key COLLECTION_CLASS, used in {@link #KEY_TYPE_ITEM}. |
| */ |
| String COLLECTION_CLASS = "CollectionClass"; |
| |
| /** |
| * The item containing the type of this collection |
| * The key is {@link #COLLECTION_CLASS}, and the type is {@link SimpleType#STRING}. |
| */ |
| Item COLLECTION_CLASS_ITEM = new Item( |
| COLLECTION_CLASS, |
| "The type of this collection", |
| SimpleType.STRING); |
| |
| /** |
| * The key VALUES, used in {@link #VALUES_ITEM}. |
| */ |
| String VALUES = "Values"; |
| |
| /** |
| * The item containing all the values |
| * The key is {@link #VALUES}, and the type is {@link ArrayType}. |
| */ |
| Item VALUES_ITEM = new Item( |
| VALUES, |
| "All the values", |
| Item.arrayType(2, SimpleType.BYTE)); |
| |
| |
| /** |
| * The name of CompositeType for CollectionMetadata objects, used in {@link #COLLECTION_METADATA_TYPE}. |
| */ |
| String COLLECTION_METADATA = "CollectionMetadata"; |
| |
| /** |
| * The CompositeType for a CollectionMetadata object. It contains the following items: |
| * <ul> |
| * <li>{@link #COLLECTION_CLASS}</li> |
| * <li>{@link #VALUES}</li> |
| * <li>{@link #VALUE_TYPE}</li> |
| * </ul> |
| */ |
| CompositeType COLLECTION_METADATA_TYPE= Item.compositeType( |
| COLLECTION_METADATA, |
| "This type encapsulates CollectionMetadata objects", |
| COLLECTION_CLASS_ITEM, |
| VALUES_ITEM, |
| VALUE_TYPE_ITEM); |
| |
| /////////////////////////////////////////////////////////////// |
| // Define <argument>'s CompositeType |
| // VALUE_TYPE_ITEM defined in <map>'s definition |
| /////////////////////////////////////////////////////////////// |
| |
| /** |
| * The key INDEX, used in {@link #INDEX_ITEM}. |
| */ |
| String INDEX = "Index"; |
| |
| /** |
| * The item containing the zero-based index into the parameter list of |
| * the factory method or constructor to be invoked for this argument. |
| * The key is {@link #INDEX}, and the type is {@link SimpleType#INTEGER}. |
| */ |
| Item INDEX_ITEM = new Item( |
| INDEX, |
| "The zero-based index", |
| SimpleType.INTEGER); |
| |
| /** |
| * The name of CompositeType for BeanArgument objects, used in {@link #BEAN_ARGUMENT_TYPE}. |
| */ |
| String BEAN_ARGUMENT = "BeanArgument"; |
| |
| |
| /** |
| * The CompositeType for a Argument object. It contains the following items: |
| * <ul> |
| * <li>{@link #INDEX}</li> |
| * <li>{@link #VALUE_TYPE}</li> |
| * <li>{@link #VALUE}</li> |
| * </ul> |
| */ |
| CompositeType BEAN_ARGUMENT_TYPE = Item.compositeType( |
| BEAN_ARGUMENT, |
| "This type encapsulates BeanArgument objects", |
| INDEX_ITEM, |
| VALUE_TYPE_ITEM, |
| VALUE_ITEM); |
| |
| /////////////////////////////////////////////////////////////// |
| // Define <property>'s CompositeType |
| /////////////////////////////////////////////////////////////// |
| |
| /** |
| * The key NAME, used in {@link #NAME_ITEM}. |
| */ |
| String NAME = "Name"; |
| |
| /** |
| * The item containing the name of the property to be injected. |
| * The key is {@link #NAME}, and the type is {@link SimpleType#STRING}. |
| */ |
| Item NAME_ITEM = new Item( |
| NAME, |
| "The name of the property", |
| SimpleType.STRING); |
| |
| /** |
| * The name of CompositeType for BeanProperty objects, used in {@link #BEAN_PROPERTY_TYPE}. |
| */ |
| String BEAN_PROPERTY = "BeanProperty"; |
| |
| /** |
| * The CompositeType for property type. It contains the following items: |
| * <ul> |
| * <li>{@link #NAME}</li> |
| * <li>{@link #VALUE}</li> |
| * </ul> |
| */ |
| CompositeType BEAN_PROPERTY_TYPE = Item.compositeType( |
| BEAN_PROPERTY, |
| "This type encapsulates BeanProperty objects", |
| NAME_ITEM, |
| VALUE_ITEM); |
| |
| /////////////////////////////////////////////////////////////// |
| // Define Component's CompositeType |
| // <bean>, <service> & Service Reference's CompositeType will |
| // extend this. |
| /////////////////////////////////////////////////////////////// |
| |
| /** |
| * The key ID, used in {@link #ID_ITEM}. |
| */ |
| String ID = "Id"; |
| |
| /** |
| * The item containing the component id of a component. |
| * The key is {@link #ID}, and the type is {@link SimpleType#STRING}. |
| */ |
| Item ID_ITEM = new Item( |
| ID, |
| "The id of the component", |
| SimpleType.STRING); |
| /** |
| * The key ACTIVATION, used in {@link #ACTIVATION_ITEM}. |
| */ |
| String ACTIVATION = "Activation"; |
| |
| /** |
| * The item containing the activation strategy for a component. |
| * The key is {@link #ACTIVATION}, and the type is {@link SimpleType#INTEGER}. |
| */ |
| Item ACTIVATION_ITEM = new Item( |
| ACTIVATION, |
| "The activation strategy for a component", |
| SimpleType.INTEGER); |
| |
| /** |
| * The key DEPENDS_ON, used in {@link #DEPENDS_ON_ITEM}. |
| */ |
| String DEPENDS_ON = "DependsOn"; |
| |
| /** |
| * The item containing the ids of any components listed in a <code>depends-on</code> attribute for the component. |
| * The key is {@link #DEPENDS_ON}, and the type is {@link JmxConstants#STRING_ARRAY_TYPE}. |
| */ |
| Item DEPENDS_ON_ITEM = new Item( |
| DEPENDS_ON, |
| "The ids of any components listed in a depends-on attribute", |
| JmxConstants.STRING_ARRAY_TYPE); |
| |
| /** |
| * The name of CompositeType for ComponentMetadata objects, used in {@link #COMPONENT_METADATA_TYPE}. |
| */ |
| String COMPONENT_METADATA = "ComponentMetadata"; |
| |
| /** |
| * The CompositeType for a ComponentMetadata object, it contains |
| * the following items: |
| * <ul> |
| * <li>{@link #ID}</li> |
| * <li>{@link #ACTIVATION}</li> |
| * <li>{@link #DEPENDS_ON}</li> |
| * </ul> |
| */ |
| CompositeType COMPONENT_METADATA_TYPE = Item.compositeType( |
| COMPONENT_METADATA, |
| "This type encapsulates ComponentMetadata objects", |
| ID_ITEM, |
| ACTIVATION_ITEM, |
| DEPENDS_ON_ITEM); |
| |
| /////////////////////////////////////////////////////////////// |
| // Define <bean>'s CompositeType |
| /////////////////////////////////////////////////////////////// |
| |
| /** |
| * The key CLASS_NAME, used in {@link #CLASS_NAME_ITEM}. |
| */ |
| String CLASS_NAME = "ClassName"; |
| |
| /** |
| * The item containing the name of the class specified for the bean. |
| * The key is {@link #CLASS_NAME}, and the type is {@link SimpleType#STRING}. |
| */ |
| Item CLASS_NAME_ITEM = new Item( |
| CLASS_NAME, |
| "The name of the class specified for the bean", |
| SimpleType.STRING |
| ); |
| |
| /** |
| * The key INIT_METHOD, used in {@link #INIT_METHOD_ITEM}. |
| */ |
| String INIT_METHOD = "InitMethod"; |
| |
| /** |
| * The item containing the name of the init method specified for the bean. |
| * The key is {@link #INIT_METHOD}, and the type is {@link SimpleType#STRING}. |
| */ |
| Item INIT_METHOD_ITEM = new Item( |
| INIT_METHOD, |
| "The name of the init method specified for the bean", |
| SimpleType.STRING); |
| |
| /** |
| * The key DESTROY_METHOD, used in {@link #DESTROY_METHOD_ITEM}. |
| */ |
| String DESTROY_METHOD = "DestroyMethod"; |
| |
| /** |
| * The item containing the name of the destroy method specified for the bean. |
| * The key is {@link #DESTROY_METHOD}, and the type is {@link SimpleType#STRING}. |
| */ |
| Item DESTROY_METHOD_ITEM = new Item( |
| DESTROY_METHOD, |
| "The name of the destroy method specified for the bean", |
| SimpleType.STRING); |
| |
| /** |
| * The key FACTORY_METHOD, used in {@link #FACTORY_METHOD_ITEM}. |
| */ |
| String FACTORY_METHOD = "FactoryMethod"; |
| |
| /** |
| * The item containing the name of the factory method specified for the bean. |
| * The key is {@link #FACTORY_METHOD}, and the type is {@link SimpleType#STRING}. |
| */ |
| Item FACTORY_METHOD_ITEM = new Item( |
| FACTORY_METHOD, |
| "The name of the factory method specified for the bean", |
| SimpleType.STRING); |
| |
| /** |
| * The key FACTORY_COMPONENT, used in {@link #FACTORY_COMPONENT_ITEM}. |
| */ |
| String FACTORY_COMPONENT = "FactoryComponent"; |
| |
| /** |
| * The item containing the id of the factory component on which to invoke the factory method for the bean. |
| * The key is {@link #FACTORY_COMPONENT}, and the type is {@link JmxConstants#BYTE_ARRAY_TYPE}. |
| */ |
| Item FACTORY_COMPONENT_ITEM = new Item( |
| FACTORY_COMPONENT, |
| "The factory component on which to invoke the factory method for the bean", |
| JmxConstants.BYTE_ARRAY_TYPE); |
| |
| /** |
| * The key SCOPE, used in {@link #SCOPE_ITEM}. |
| */ |
| String SCOPE = "Scope"; |
| |
| /** |
| * The item containing the scope for the bean. |
| * The key is {@link #SCOPE}, and the type is {@link SimpleType#STRING}. |
| */ |
| Item SCOPE_ITEM = new Item( |
| SCOPE, |
| "The scope for the bean", |
| SimpleType.STRING); |
| |
| /** |
| * The key ARGUMENT, used in {@link #ARGUMENTS_ITEM}. |
| */ |
| String ARGUMENTS = "Arguments"; |
| |
| /** |
| * The item containing the bean argument for the bean's compositeType. |
| * The key is {@link #ARGUMENTS}, and the type is {@link #BEAN_ARGUMENT_TYPE}. |
| */ |
| Item ARGUMENTS_ITEM = new Item( |
| ARGUMENTS, |
| "The bean argument", |
| Item.arrayType(1, BEAN_ARGUMENT_TYPE)); |
| |
| /** |
| * The key PROPERTY, used in {@link #PROPERTIES_ITEM}. |
| */ |
| String PROPERTIES = "Properties"; |
| |
| /** |
| * The item containing the bean property for the bean's compositeType. |
| * The key is {@link #PROPERTIES}, and the type is {@link #BEAN_PROPERTY_TYPE}. |
| */ |
| Item PROPERTIES_ITEM = new Item( |
| PROPERTIES, |
| "The bean property", |
| Item.arrayType(1, BEAN_PROPERTY_TYPE)); |
| |
| /** |
| * The name of CompositeType for BeanMetadata objects, used in {@link #BEAN_METADATA_TYPE}. |
| */ |
| String BEAN_METADATA = "BeanMetadata"; |
| |
| /** |
| * The CompositeType for a BeanMetadata object, it extends {@link #COMPONENT_METADATA_TYPE} |
| * and adds the following items: |
| * <ul> |
| * <li>{@link #CLASS_NAME}</li> |
| * <li>{@link #INIT_METHOD}</li> |
| * <li>{@link #DESTROY_METHOD}</li> |
| * <li>{@link #FACTORY_METHOD}</li> |
| * <li>{@link #FACTORY_COMPONENT}</li> |
| * <li>{@link #SCOPE}</li> |
| * <li>{@link #ARGUMENTS}</li> |
| * <li>{@link #PROPERTIES}</li> |
| * </ul> |
| */ |
| CompositeType BEAN_METADATA_TYPE = Item.extend( |
| COMPONENT_METADATA_TYPE, |
| BEAN_METADATA, |
| "This type encapsulates BeanMetadata objects", |
| CLASS_NAME_ITEM, |
| INIT_METHOD_ITEM, |
| DESTROY_METHOD_ITEM, |
| FACTORY_METHOD_ITEM, |
| FACTORY_COMPONENT_ITEM, |
| SCOPE_ITEM, |
| ARGUMENTS_ITEM, |
| PROPERTIES_ITEM); |
| |
| /////////////////////////////////////////////////////////////// |
| // Define <registration-listener>'s CompositeType |
| /////////////////////////////////////////////////////////////// |
| |
| /** |
| * The key LISTENER_COMPONENT, used in {@link #LISTENER_COMPONENT_ITEM}. |
| */ |
| String LISTENER_COMPONENT = "ListenerComponent"; |
| |
| /** |
| * The item containing the listener component. |
| * The key is {@link #LISTENER_COMPONENT}, and the type is {@link JmxConstants#BYTE_ARRAY_TYPE}. |
| */ |
| Item LISTENER_COMPONENT_ITEM = new Item( |
| LISTENER_COMPONENT, |
| "The listener component", |
| JmxConstants.BYTE_ARRAY_TYPE); |
| |
| /** |
| * The key REGISTRATION_METHOD, used in {@link #REGISTRATION_METHOD_ITEM}. |
| */ |
| String REGISTRATION_METHOD = "RegistrationMethod"; |
| |
| /** |
| * The item containing the name of the registration method. |
| * The key is {@link #REGISTRATION_METHOD}, and the type is {@link SimpleType#STRING}. |
| */ |
| Item REGISTRATION_METHOD_ITEM = new Item( |
| REGISTRATION_METHOD, |
| "The name of the registration method", |
| SimpleType.STRING); |
| |
| /** |
| * The key UNREGISTRATION_METHOD, used in {@link #UNREGISTRATION_METHOD_ITEM}. |
| */ |
| String UNREGISTRATION_METHOD = "UnregistrationMethod"; |
| |
| /** |
| * The item containing the name of the unregistration method. |
| * The key is {@link #UNREGISTRATION_METHOD}, and the type is {@link SimpleType#STRING}. |
| */ |
| Item UNREGISTRATION_METHOD_ITEM = new Item( |
| UNREGISTRATION_METHOD, |
| "The name of the unregistration method", |
| SimpleType.STRING); |
| |
| /** |
| * The name of CompositeType for RegistrationListener objects, used in {@link #REGISTRATION_LISTENER_TYPE}. |
| */ |
| String REGISTRATION_LISTENER = "RegistrationListener"; |
| |
| /** |
| * The CompositeType for a registration listener, and it contains the following items: |
| * <ul> |
| * <li>{@link #LISTENER_COMPONENT}</li> |
| * <li>{@link #REGISTRATION_METHOD}</li> |
| * <li>{@link #UNREGISTRATION_METHOD}</li> |
| * </ul> |
| */ |
| CompositeType REGISTRATION_LISTENER_TYPE = Item.compositeType( |
| REGISTRATION_LISTENER, |
| "This type encapsulates RegistrationListener objects", |
| LISTENER_COMPONENT_ITEM, |
| REGISTRATION_METHOD_ITEM, |
| UNREGISTRATION_METHOD_ITEM); |
| |
| |
| /////////////////////////////////////////////////////////////// |
| // Define <service>'s CompositeType |
| /////////////////////////////////////////////////////////////// |
| |
| /** |
| * The key INTERFACES, used in {@link #INTERFACES_ITEM}. |
| */ |
| String INTERFACES = "Interfaces"; |
| |
| /** |
| * The item containing the type names of the interfaces that the service should be advertised as supporting. |
| * The key is {@link #INTERFACES}, and the type is {@link JmxConstants#STRING_ARRAY_TYPE}. |
| */ |
| Item INTERFACES_ITEM = new Item( |
| INTERFACES, |
| "The type names of the interfaces", |
| JmxConstants.STRING_ARRAY_TYPE); |
| /** |
| * The key AUTO_EXPORT, used in {@link #AUTO_EXPORT_ITEM}. |
| */ |
| String AUTO_EXPORT = "AutoExport"; |
| |
| /** |
| * The item containing the auto-export mode for the service. |
| * The key is {@link #AUTO_EXPORT}, and the type is {@link SimpleType#INTEGER}. |
| */ |
| //TODO describe integer |
| Item AUTO_EXPORT_ITEM = new Item( |
| AUTO_EXPORT, |
| "The auto-export mode for the service", |
| SimpleType.INTEGER); |
| |
| /** |
| * The key RANKING, used in {@link #RANKING_ITEM}. |
| */ |
| String RANKING = "Ranking"; |
| |
| /** |
| * The item containing the ranking value to use when advertising the service. |
| * The key is {@link #RANKING}, and the type is {@link SimpleType#INTEGER}. |
| */ |
| Item RANKING_ITEM = new Item( |
| RANKING, |
| "The ranking value when advertising the service", |
| SimpleType.INTEGER); |
| |
| /** |
| * The key SERVICE_COMPONENT, used in {@link #SERVICE_COMPONENT_ITEM}. |
| */ |
| String SERVICE_COMPONENT = "ServiceComponent"; |
| |
| /** |
| * The item containing the id of the component to be exported as a service. |
| * The key is {@link #SERVICE_COMPONENT}, and the type is {@link JmxConstants#BYTE_ARRAY_TYPE}. |
| */ |
| Item SERVICE_COMPONENT_ITEM = new Item( |
| SERVICE_COMPONENT, |
| "The component to be exported as a service", |
| JmxConstants.BYTE_ARRAY_TYPE); |
| |
| /** |
| * The key SERVICE_PROPERTIES, used in {@link #SERVICE_PROPERTIES_ITEM}. |
| */ |
| String SERVICE_PROPERTIES = "ServiceProperties"; |
| |
| /** |
| * The item containing the user declared properties to be advertised with the service. |
| * The key is {@link #SERVICE_COMPONENT}, and the type is {@link SimpleType#STRING}. |
| */ |
| Item SERVICE_PROPERTIES_ITEM = new Item( |
| SERVICE_PROPERTIES, |
| "The user declared properties to be advertised with the service", |
| Item.arrayType(1, MAP_ENTRY_TYPE)); |
| |
| /** |
| * The key REGISTRATION_LISTENERS, used in {@link #REGISTRATION_LISTENERS_ITEM}. |
| */ |
| String REGISTRATION_LISTENERS = "RegistrationListeners"; |
| |
| /** |
| * The item containing all the registration listeners. |
| * The key is {@link #REGISTRATION_LISTENERS}, and the type is {@link ArrayType}. |
| */ |
| Item REGISTRATION_LISTENERS_ITEM = new Item( |
| REGISTRATION_LISTENERS, |
| "All the registration listeners", |
| Item.arrayType(1, REGISTRATION_LISTENER_TYPE)); |
| |
| /** |
| * The name of CompositeType for ServiceMetadata objects, used in {@link #SERVICE_METADATA_TYPE}. |
| */ |
| String SERVICE_METADATA = "ServiceMetadata"; |
| |
| /** |
| * The CompositeType for a ServiceMetadata object, it extends {@link #COMPONENT_METADATA_TYPE} |
| * and adds the following items: |
| * <ul> |
| * <li>{@link #INTERFACES}</li> |
| * <li>{@link #AUTO_EXPORT}</li> |
| * <li>{@link #RANKING}</li> |
| * <li>{@link #SERVICE_COMPONENT}</li> |
| * <li>{@link #SERVICE_PROPERTIES}</li> |
| * <li>{@link #REGISTRATION_LISTENERS}</li> |
| * </ul> |
| */ |
| CompositeType SERVICE_METADATA_TYPE = Item.extend( |
| COMPONENT_METADATA_TYPE, |
| SERVICE_METADATA, |
| "This type encapsulates ServiceMetadata objects", |
| INTERFACES_ITEM, |
| AUTO_EXPORT_ITEM, |
| RANKING_ITEM, |
| SERVICE_COMPONENT_ITEM, |
| SERVICE_PROPERTIES_ITEM, |
| REGISTRATION_LISTENERS_ITEM); |
| |
| /////////////////////////////////////////////////////////////// |
| // Define <reference-listener>'s CompositeType |
| // LISTENER_COMPONENT_ITEM defined in the <registration-listener> |
| /////////////////////////////////////////////////////////////// |
| |
| /** |
| * The key BIND_METHOD, used in {@link #BIND_METHOD_ITEM}. |
| */ |
| String BIND_METHOD = "BindMethod"; |
| |
| /** |
| * The item containing the name of the bind method. |
| * The key is {@link #BIND_METHOD}, and the type is {@link SimpleType#STRING}. |
| */ |
| Item BIND_METHOD_ITEM = new Item( |
| BIND_METHOD, |
| "The name of the bind method", |
| SimpleType.STRING); |
| |
| /** |
| * The key UNBIND_METHOD, used in {@link #UNBIND_METHOD_ITEM}. |
| */ |
| String UNBIND_METHOD = "UnbindMethod"; |
| |
| /** |
| * The item containing the name of the unbind method. |
| * The key is {@link #UNBIND_METHOD}, and the type is {@link SimpleType#STRING}. |
| */ |
| Item UNBIND_METHOD_ITEM = new Item( |
| UNBIND_METHOD, |
| "The name of the unbind method", |
| SimpleType.STRING); |
| |
| /** |
| * The name of CompositeType for ReferenceListener objects, used in {@link #REFERENCE_LISTENER_TYPE}. |
| */ |
| String REFERENCE_LISTENER = "ReferenceListener"; |
| |
| /** |
| * The CompositeType for a reference listener, and it contains the following items: |
| * <ul> |
| * <li>{@link #LISTENER_COMPONENT}</li> |
| * <li>{@link #BIND_METHOD}</li> |
| * <li>{@link #UNBIND_METHOD}</li> |
| * </ul> |
| */ |
| CompositeType REFERENCE_LISTENER_TYPE = Item.compositeType( |
| REFERENCE_LISTENER, |
| "This type encapsulates ReferenceListener objects", |
| LISTENER_COMPONENT_ITEM, |
| BIND_METHOD_ITEM, |
| UNBIND_METHOD_ITEM); |
| |
| |
| /////////////////////////////////////////////////////////////// |
| // Define Service Reference's CompositeType, |
| // <reference> & <reference-list> will extend this |
| /////////////////////////////////////////////////////////////// |
| |
| /** |
| * The key AVAILABILITY, used in {@link #AVAILABILITY_ITEM}. |
| */ |
| String AVAILABILITY = "Availability"; |
| |
| /** |
| * The item specify whether or not a matching service is required at all times. |
| * The key is {@link #AVAILABILITY}, and the type is {@link SimpleType#INTEGER}. |
| * |
| */ |
| //TODO add description for each int |
| Item AVAILABILITY_ITEM = new Item( |
| AVAILABILITY, |
| "To specify whether or not a matching service is required at all times", |
| SimpleType.INTEGER); |
| |
| /** |
| * The key INTERFACE, used in {@link #INTERFACE_ITEM}. |
| */ |
| String INTERFACE = "Interface"; |
| |
| /** |
| * The item containing the name of the interface type that a matching service must support. |
| * The key is {@link #INTERFACE}, and the type is {@link SimpleType#STRING}. |
| */ |
| Item INTERFACE_ITEM = new Item( |
| INTERFACE, |
| "the name of the interface type", |
| SimpleType.STRING); |
| |
| /** |
| * The key COMPONENT_NAME, used in {@link #COMPONENT_NAME_ITEM}. |
| */ |
| String COMPONENT_NAME = "ComponentName"; |
| |
| /** |
| * The item containing the value of the <code>component-name</code> attribute of the service reference. |
| * The key is {@link #INTERFACE}, and the type is {@link SimpleType#STRING}. |
| */ |
| Item COMPONENT_NAME_ITEM = new Item( |
| COMPONENT_NAME, |
| "The value of the component-name attribute of the service reference", |
| SimpleType.STRING); |
| /** |
| * The key FILTER, used in {@link #FILTER_ITEM}. |
| */ |
| String FILTER = "Filter"; |
| |
| /** |
| * The item containing the filter expression that a matching service must match. |
| * The key is {@link #FILTER}, and the type is {@link SimpleType#STRING}. |
| */ |
| Item FILTER_ITEM = new Item( |
| FILTER, |
| "The filter expression that a matching service must match", |
| SimpleType.STRING); |
| |
| /** |
| * The key REFERENCE_LISTENERS, used in {@link #REFERENCE_LISTENERS_ITEM}. |
| */ |
| String REFERENCE_LISTENERS = "ReferenceListeners"; |
| |
| /** |
| * The item containing all the reference listeners. |
| * The key is {@link #REFERENCE_LISTENERS}, and the type is {@link ArrayType}. |
| */ |
| Item REFERENCE_LISTENERS_ITEM= new Item( |
| REFERENCE_LISTENERS, |
| "All the reference listeners", |
| Item.arrayType(1, REFERENCE_LISTENER_TYPE)); |
| |
| /** |
| * The name of CompositeType for ServiceReferenceMetadata objects, used in {@link #SERVICE_REFERENCE_METADATA_TYPE}. |
| */ |
| String SERVICE_REFERENCE_METADATA = "ServiceReferenceMetadata"; |
| |
| /** |
| * The CompositeType for a ServiceReferenceMetadata object, it extends |
| * {@link #COMPONENT_METADATA_TYPE} and adds the following items: |
| * <ul> |
| * <li>{@link #AVAILABILITY}</li> |
| * <li>{@link #INTERFACE}</li> |
| * <li>{@link #COMPONENT_NAME}</li> |
| * <li>{@link #FILTER}</li> |
| * <li>{@link #REFERENCE_LISTENERS}</li> |
| * </ul> |
| */ |
| CompositeType SERVICE_REFERENCE_METADATA_TYPE = Item.extend( |
| COMPONENT_METADATA_TYPE, |
| SERVICE_REFERENCE_METADATA, |
| "This type encapsulates ServiceReferenceMetadata objects", |
| AVAILABILITY_ITEM, |
| INTERFACE_ITEM, |
| COMPONENT_NAME_ITEM, |
| FILTER_ITEM, |
| REFERENCE_LISTENERS_ITEM); |
| |
| /////////////////////////////////////////////////////////////// |
| // Define <reference>'s CompositeType |
| /////////////////////////////////////////////////////////////// |
| |
| /** |
| * The key TIME_OUT, used in {@link #TIMEOUT_ITEM}. |
| */ |
| String TIMEOUT = "TimeOut"; |
| |
| /** |
| * The item containing the timeout for service invocations when a backing service is is unavailable. |
| * The key is {@link #TIMEOUT}, and the type is {@link SimpleType#LONG}. |
| */ |
| Item TIMEOUT_ITEM = new Item( |
| TIMEOUT, |
| "The timeout for service invocations when a backing service is is unavailable", |
| SimpleType.LONG); |
| |
| /** |
| * The name of CompositeType for ReferenceMetadata objects, used in {@link #REFERENCE_METADATA_TYPE}. |
| */ |
| String REFERENCE_METADATA = "ReferenceMetadata"; |
| |
| /** |
| * The CompositeType for a ReferenceMetadata object, it extends |
| * {@link #SERVICE_REFERENCE_METADATA_TYPE} and adds the following items: |
| * <ul> |
| * <li>{@link #TIMEOUT}</li> |
| * </ul> |
| */ |
| CompositeType REFERENCE_METADATA_TYPE = Item.extend( |
| SERVICE_REFERENCE_METADATA_TYPE, |
| REFERENCE_METADATA, |
| "This type encapsulates ReferenceMetadata objects", |
| TIMEOUT_ITEM); |
| |
| /////////////////////////////////////////////////////////////// |
| // Define <reference-list>'s CompositeType |
| /////////////////////////////////////////////////////////////// |
| |
| /** |
| * The key MEMBER_TYPE, used in {@link #MEMBER_TYPE_ITEM}. |
| */ |
| String MEMBER_TYPE = "MemberType"; |
| |
| /** |
| * The item specify whether the List will contain service object proxies or ServiceReference objects. |
| * The key is {@link #MEMBER_TYPE}, and the type is {@link SimpleType#INTEGER}. |
| */ |
| Item MEMBER_TYPE_ITEM = new Item( |
| MEMBER_TYPE, |
| "To specify whether the List will contain service object proxies or ServiceReference objects", |
| SimpleType.INTEGER); |
| |
| /** |
| * The name of CompositeType for ReferenceListMetadata objects, used in {@link #REFERENCE_LIST_METADATA_TYPE}. |
| */ |
| String REFERENCE_LIST_METADATA = "ReferenceListMetadata"; |
| |
| /** |
| * The CompositeType for a ReferenceListMetadata object, it extends |
| * {@link #SERVICE_REFERENCE_METADATA_TYPE} and adds the following items: |
| * <ul> |
| * <li>{@link #MEMBER_TYPE}</li> |
| * </ul> |
| */ |
| CompositeType REFERENCE_LIST_METADATA_TYPE = Item.extend( |
| SERVICE_REFERENCE_METADATA_TYPE, |
| REFERENCE_LIST_METADATA, |
| "This type encapsulates ReferenceListMetadata objects", |
| MEMBER_TYPE_ITEM); |
| |
| |
| /** |
| * Returns the list of component id. |
| * |
| * @param containerServiceId The blueprint container service id |
| * @return the array of component id |
| * @throws IOException if the operation fails |
| */ |
| String[] getComponentIds(long containerServiceId) throws IOException; |
| |
| /** |
| * Returns all component ids of the specified component type |
| * |
| * @param containerServiceId The blueprint container service id |
| * @param type The string used to specify the type of component |
| * @return the array of component id |
| * @throws IOException if the operation fails |
| */ |
| String[] getComponentIdsByType(long containerServiceId, String type) throws IOException; |
| |
| /** |
| * Returns the ComponentMetadata according to the its component id. |
| * The returned Composite Data's type is actually one of {@link #BEAN_METADATA_TYPE}, |
| * {@link #SERVICE_METADATA_TYPE}, {@link #REFERENCE_METADATA_TYPE}, REFERENCE_LIST_METADATA_TYPE. |
| * |
| * @param containerServiceId The blueprint container service id |
| * @param componentId The component id |
| * @return the ComponentMetadata |
| * @throws IOException if the operation fails |
| */ |
| CompositeData getComponentMetadata(long containerServiceId, String componentId) throws IOException; |
| |
| /** |
| * Returns all the blueprint containers' service IDs, which successfully |
| * created from blueprint bundles. |
| * |
| * @return the list of all the service IDs of the blueprint containers created by current extender |
| * @throws IOException if the operation fails |
| */ |
| long[] getBlueprintContainerServiceIds() throws IOException; |
| |
| /** |
| * Returns the blueprint container's service id if the bundle specified |
| * by the bundle id is a blueprint bundle. |
| * |
| * @param bundleId The bundle id of a blueprint bundle |
| * @return the blueprint container's service id, or null if the blueprint bundle initialed failed. |
| * @throws IOException if the operation fails |
| * @throws IllegalArgumentException if the bundle is not a blueprint bundle |
| */ |
| long getBlueprintContainerServiceId(long bundleId) throws IOException; |
| } |
