Back to index...

	/*
	* Copyright (c) 2000, 2006, Oracle and/or its affiliates. All rights reserved.
	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	*
	* This code is free software; you can redistribute it and/or modify it
	* under the terms of the GNU General Public License version 2 only, as
	* published by the Free Software Foundation. Oracle designates this
	* particular file as subject to the "Classpath" exception as provided
	* by Oracle in the LICENSE file that accompanied this code.
	*
	* This code is distributed in the hope that it will be useful, but WITHOUT
	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	* version 2 for more details (a copy is included in the LICENSE file that
	* accompanied this code).
	*
	* You should have received a copy of the GNU General Public License version
	* 2 along with this work; if not, write to the Free Software Foundation,
	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	*
	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	* or visit www.oracle.com if you need additional information or have any
	* questions.
	*/

	package javax.management.relation;

	import static com.sun.jmx.defaults.JmxProperties.RELATION_LOGGER;
	import static com.sun.jmx.mbeanserver.Util.cast;
	import com.sun.jmx.mbeanserver.GetPropertyAction;

	import java.io.IOException;
	import java.io.ObjectInputStream;
	import java.io.ObjectOutputStream;
	import java.io.ObjectStreamField;

	import java.security.AccessController;

	import java.util.ArrayList;
	import java.util.HashMap;
	import java.util.HashSet;
	import java.util.List;
	import java.util.Map;
	import java.util.Set;
	import java.util.logging.Level;

	/**
	* A RelationTypeSupport object implements the RelationType interface.
	* <P>It represents a relation type, providing role information for each role
	* expected to be supported in every relation of that type.
	*
	* <P>A relation type includes a relation type name and a list of
	* role infos (represented by RoleInfo objects).
	*
	* <P>A relation type has to be declared in the Relation Service:
	* <P>- either using the createRelationType() method, where a RelationTypeSupport
	* object will be created and kept in the Relation Service
	* <P>- either using the addRelationType() method where the user has to create
	* an object implementing the RelationType interface, and this object will be
	* used as representing a relation type in the Relation Service.
	*
	* <p>The <b>serialVersionUID</b> of this class is <code>4611072955724144607L</code>.
	*
	* @since 1.5
	*/
	@SuppressWarnings("serial") // serialVersionUID not constant
	public class RelationTypeSupport implements RelationType {

	// Serialization compatibility stuff:
	// Two serial forms are supported in this class. The selected form depends
	// on system property "jmx.serial.form":
	// - "1.0" for JMX 1.0
	// - any other value for JMX 1.1 and higher
	//
	// Serial version for old serial form
	private static final long oldSerialVersionUID = -8179019472410837190L;
	//
	// Serial version for new serial form
	private static final long newSerialVersionUID = 4611072955724144607L;
	//
	// Serializable fields in old serial form
	private static final ObjectStreamField[] oldSerialPersistentFields =
	{
	new ObjectStreamField("myTypeName", String.class),
	new ObjectStreamField("myRoleName2InfoMap", HashMap.class),
	new ObjectStreamField("myIsInRelServFlg", boolean.class)
	};
	//
	// Serializable fields in new serial form
	private static final ObjectStreamField[] newSerialPersistentFields =
	{
	new ObjectStreamField("typeName", String.class),
	new ObjectStreamField("roleName2InfoMap", Map.class),
	new ObjectStreamField("isInRelationService", boolean.class)
	};
	//
	// Actual serial version and serial form
	private static final long serialVersionUID;
	/**
	* @serialField typeName String Relation type name
	* @serialField roleName2InfoMap Map {@link Map} holding the mapping:
	* <role name ({@link String})> -> <role info ({@link RoleInfo} object)>
	* @serialField isInRelationService boolean Flag specifying whether the relation type has been declared in the
	* Relation Service (so can no longer be updated)
	*/
	private static final ObjectStreamField[] serialPersistentFields;
	private static boolean compat = false;
	static {
	try {
	GetPropertyAction act = new GetPropertyAction("jmx.serial.form");
	String form = AccessController.doPrivileged(act);
	compat = (form != null && form.equals("1.0"));
	} catch (Exception e) {
	// OK : Too bad, no compat with 1.0
	}
	if (compat) {
	serialPersistentFields = oldSerialPersistentFields;
	serialVersionUID = oldSerialVersionUID;
	} else {
	serialPersistentFields = newSerialPersistentFields;
	serialVersionUID = newSerialVersionUID;
	}
	}
	//
	// END Serialization compatibility stuff

	//
	// Private members
	//

	/**
	* @serial Relation type name
	*/
	private String typeName = null;

	/**
	* @serial {@link Map} holding the mapping:
	* <role name ({@link String})> -> <role info ({@link RoleInfo} object)>
	*/
	private Map<String,RoleInfo> roleName2InfoMap =
	new HashMap<String,RoleInfo>();

	/**
	* @serial Flag specifying whether the relation type has been declared in the
	* Relation Service (so can no longer be updated)
	*/
	private boolean isInRelationService = false;

	//
	// Constructors
	//

	/**
	* Constructor where all role definitions are dynamically created and
	* passed as parameter.
	*
	* @param relationTypeName Name of relation type
	* @param roleInfoArray List of role definitions (RoleInfo objects)
	*
	* @exception IllegalArgumentException if null parameter
	* @exception InvalidRelationTypeException if:
	* <P>- the same name has been used for two different roles
	* <P>- no role info provided
	* <P>- one null role info provided
	*/
	public RelationTypeSupport(String relationTypeName,
	RoleInfo[] roleInfoArray)
	throws IllegalArgumentException,
	InvalidRelationTypeException {

	if (relationTypeName == null \|\| roleInfoArray == null) {
	String excMsg = "Invalid parameter.";
	throw new IllegalArgumentException(excMsg);
	}

	RELATION_LOGGER.entering(RelationTypeSupport.class.getName(),
	"RelationTypeSupport", relationTypeName);

	// Can throw InvalidRelationTypeException, ClassNotFoundException
	// and NotCompliantMBeanException
	initMembers(relationTypeName, roleInfoArray);

	RELATION_LOGGER.exiting(RelationTypeSupport.class.getName(),
	"RelationTypeSupport");
	return;
	}

	/**
	* Constructor to be used for subclasses.
	*
	* @param relationTypeName Name of relation type.
	*
	* @exception IllegalArgumentException if null parameter.
	*/
	protected RelationTypeSupport(String relationTypeName)
	{
	if (relationTypeName == null) {
	String excMsg = "Invalid parameter.";
	throw new IllegalArgumentException(excMsg);
	}

	RELATION_LOGGER.entering(RelationTypeSupport.class.getName(),
	"RelationTypeSupport", relationTypeName);

	typeName = relationTypeName;

	RELATION_LOGGER.exiting(RelationTypeSupport.class.getName(),
	"RelationTypeSupport");
	return;
	}

	//
	// Accessors
	//

	/**
	* Returns the relation type name.
	*
	* @return the relation type name.
	*/
	public String getRelationTypeName() {
	return typeName;
	}

	/**
	* Returns the list of role definitions (ArrayList of RoleInfo objects).
	*/
	public List<RoleInfo> getRoleInfos() {
	return new ArrayList<RoleInfo>(roleName2InfoMap.values());
	}

	/**
	* Returns the role info (RoleInfo object) for the given role info name
	* (null if not found).
	*
	* @param roleInfoName role info name
	*
	* @return RoleInfo object providing role definition
	* does not exist
	*
	* @exception IllegalArgumentException if null parameter
	* @exception RoleInfoNotFoundException if no role info with that name in
	* relation type.
	*/
	public RoleInfo getRoleInfo(String roleInfoName)
	throws IllegalArgumentException,
	RoleInfoNotFoundException {

	if (roleInfoName == null) {
	String excMsg = "Invalid parameter.";
	throw new IllegalArgumentException(excMsg);
	}

	RELATION_LOGGER.entering(RelationTypeSupport.class.getName(),
	"getRoleInfo", roleInfoName);

	// No null RoleInfo allowed, so use get()
	RoleInfo result = roleName2InfoMap.get(roleInfoName);

	if (result == null) {
	StringBuilder excMsgStrB = new StringBuilder();
	String excMsg = "No role info for role ";
	excMsgStrB.append(excMsg);
	excMsgStrB.append(roleInfoName);
	throw new RoleInfoNotFoundException(excMsgStrB.toString());
	}

	RELATION_LOGGER.exiting(RelationTypeSupport.class.getName(),
	"getRoleInfo");
	return result;
	}

	//
	// Misc
	//

	/**
	* Add a role info.
	* This method of course should not be used after the creation of the
	* relation type, because updating it would invalidate that the relations
	* created associated to that type still conform to it.
	* Can throw a RuntimeException if trying to update a relation type
	* declared in the Relation Service.
	*
	* @param roleInfo role info to be added.
	*
	* @exception IllegalArgumentException if null parameter.
	* @exception InvalidRelationTypeException if there is already a role
	* info in current relation type with the same name.
	*/
	protected void addRoleInfo(RoleInfo roleInfo)
	throws IllegalArgumentException,
	InvalidRelationTypeException {

	if (roleInfo == null) {
	String excMsg = "Invalid parameter.";
	throw new IllegalArgumentException(excMsg);
	}

	RELATION_LOGGER.entering(RelationTypeSupport.class.getName(),
	"addRoleInfo", roleInfo);

	if (isInRelationService) {
	// Trying to update a declared relation type
	String excMsg = "Relation type cannot be updated as it is declared in the Relation Service.";
	throw new RuntimeException(excMsg);
	}

	String roleName = roleInfo.getName();

	// Checks if the role info has already been described
	if (roleName2InfoMap.containsKey(roleName)) {
	StringBuilder excMsgStrB = new StringBuilder();
	String excMsg = "Two role infos provided for role ";
	excMsgStrB.append(excMsg);
	excMsgStrB.append(roleName);
	throw new InvalidRelationTypeException(excMsgStrB.toString());
	}

	roleName2InfoMap.put(roleName, new RoleInfo(roleInfo));

	RELATION_LOGGER.exiting(RelationTypeSupport.class.getName(),
	"addRoleInfo");
	return;
	}

	// Sets the internal flag to specify that the relation type has been
	// declared in the Relation Service
	void setRelationServiceFlag(boolean flag) {
	isInRelationService = flag;
	return;
	}

	// Initializes the members, i.e. type name and role info list.
	//
	// -param relationTypeName Name of relation type
	// -param roleInfoArray List of role definitions (RoleInfo objects)
	//
	// -exception IllegalArgumentException if null parameter
	// -exception InvalidRelationTypeException If:
	// - the same name has been used for two different roles
	// - no role info provided
	// - one null role info provided
	private void initMembers(String relationTypeName,
	RoleInfo[] roleInfoArray)
	throws IllegalArgumentException,
	InvalidRelationTypeException {

	if (relationTypeName == null \|\| roleInfoArray == null) {
	String excMsg = "Invalid parameter.";
	throw new IllegalArgumentException(excMsg);
	}

	RELATION_LOGGER.entering(RelationTypeSupport.class.getName(),
	"initMembers", relationTypeName);

	typeName = relationTypeName;

	// Verifies role infos before setting them
	// Can throw InvalidRelationTypeException
	checkRoleInfos(roleInfoArray);

	for (int i = 0; i < roleInfoArray.length; i++) {
	RoleInfo currRoleInfo = roleInfoArray[i];
	roleName2InfoMap.put(currRoleInfo.getName(),
	new RoleInfo(currRoleInfo));
	}

	RELATION_LOGGER.exiting(RelationTypeSupport.class.getName(),
	"initMembers");
	return;
	}

	// Checks the given RoleInfo array to verify that:
	// - the array is not empty
	// - it does not contain a null element
	// - a given role name is used only for one RoleInfo
	//
	// -param roleInfoArray array to be checked
	//
	// -exception IllegalArgumentException
	// -exception InvalidRelationTypeException If:
	// - the same name has been used for two different roles
	// - no role info provided
	// - one null role info provided
	static void checkRoleInfos(RoleInfo[] roleInfoArray)
	throws IllegalArgumentException,
	InvalidRelationTypeException {

	if (roleInfoArray == null) {
	String excMsg = "Invalid parameter.";
	throw new IllegalArgumentException(excMsg);
	}

	if (roleInfoArray.length == 0) {
	// No role info provided
	String excMsg = "No role info provided.";
	throw new InvalidRelationTypeException(excMsg);
	}


	Set<String> roleNames = new HashSet<String>();

	for (int i = 0; i < roleInfoArray.length; i++) {
	RoleInfo currRoleInfo = roleInfoArray[i];

	if (currRoleInfo == null) {
	String excMsg = "Null role info provided.";
	throw new InvalidRelationTypeException(excMsg);
	}

	String roleName = currRoleInfo.getName();

	// Checks if the role info has already been described
	if (roleNames.contains(roleName)) {
	StringBuilder excMsgStrB = new StringBuilder();
	String excMsg = "Two role infos provided for role ";
	excMsgStrB.append(excMsg);
	excMsgStrB.append(roleName);
	throw new InvalidRelationTypeException(excMsgStrB.toString());
	}
	roleNames.add(roleName);
	}

	return;
	}


	/**
	* Deserializes a {@link RelationTypeSupport} from an {@link ObjectInputStream}.
	*/
	private void readObject(ObjectInputStream in)
	throws IOException, ClassNotFoundException {
	if (compat)
	{
	// Read an object serialized in the old serial form
	//
	ObjectInputStream.GetField fields = in.readFields();
	typeName = (String) fields.get("myTypeName", null);
	if (fields.defaulted("myTypeName"))
	{
	throw new NullPointerException("myTypeName");
	}
	roleName2InfoMap = cast(fields.get("myRoleName2InfoMap", null));
	if (fields.defaulted("myRoleName2InfoMap"))
	{
	throw new NullPointerException("myRoleName2InfoMap");
	}
	isInRelationService = fields.get("myIsInRelServFlg", false);
	if (fields.defaulted("myIsInRelServFlg"))
	{
	throw new NullPointerException("myIsInRelServFlg");
	}
	}
	else
	{
	// Read an object serialized in the new serial form
	//
	in.defaultReadObject();
	}
	}


	/**
	* Serializes a {@link RelationTypeSupport} to an {@link ObjectOutputStream}.
	*/
	private void writeObject(ObjectOutputStream out)
	throws IOException {
	if (compat)
	{
	// Serializes this instance in the old serial form
	//
	ObjectOutputStream.PutField fields = out.putFields();
	fields.put("myTypeName", typeName);
	fields.put("myRoleName2InfoMap", roleName2InfoMap);
	fields.put("myIsInRelServFlg", isInRelationService);
	out.writeFields();
	}
	else
	{
	// Serializes this instance in the new serial form
	//
	out.defaultWriteObject();
	}
	}
	}

Back to index...