JRE 8 rt.jar - javax.* Package Source Code
JRE 8 rt.jar is the JAR file for JRE 8 RT (Runtime) libraries.
JRE (Java Runtime) 8 is the runtime environment included in JDK 8.
JRE 8 rt.jar libraries are divided into 6 packages:
com.* - Internal Oracle and Sun Microsystems libraries java.* - Standard Java API libraries. javax.* - Extended Java API libraries. jdk.* - JDK supporting libraries. org.* - Third party libraries. sun.* - Old libraries developed by Sun Microsystems.
JAR File Information:
Directory of C:\fyicenter\jdk-1.8.0_191\jre\lib
63,596,151 rt.jar
Here is the list of Java classes of the javax.* package in JRE 1.8.0_191 rt.jar. Java source codes are also provided.
✍: FYIcenter
⏎ javax/management/relation/RelationSupport.java
/*
* Copyright (c) 2000, 2013, Oracle and/or its affiliates. All rights reserved.
* ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*/
package javax.management.relation;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.List;
import java.util.concurrent.atomic.AtomicBoolean;
import static com.sun.jmx.defaults.JmxProperties.RELATION_LOGGER;
import static com.sun.jmx.mbeanserver.Util.cast;
import javax.management.InstanceNotFoundException;
import javax.management.MBeanException;
import javax.management.MBeanRegistration;
import javax.management.MBeanServer;
import javax.management.ObjectName;
import javax.management.ReflectionException;
/**
* A RelationSupport object is used internally by the Relation Service to
* represent simple relations (only roles, no properties or methods), with an
* unlimited number of roles, of any relation type. As internal representation,
* it is not exposed to the user.
* <P>RelationSupport class conforms to the design patterns of standard MBean. So
* the user can decide to instantiate a RelationSupport object himself as
* a MBean (as it follows the MBean design patterns), to register it in the
* MBean Server, and then to add it in the Relation Service.
* <P>The user can also, when creating his own MBean relation class, have it
* extending RelationSupport, to retrieve the implementations of required
* interfaces (see below).
* <P>It is also possible to have in a user relation MBean class a member
* being a RelationSupport object, and to implement the required interfaces by
* delegating all to this member.
* <P> RelationSupport implements the Relation interface (to be handled by the
* Relation Service).
* <P>It implements also the MBeanRegistration interface to be able to retrieve
* the MBean Server where it is registered (if registered as a MBean) to access
* to its Relation Service.
*
* @since 1.5
*/
public class RelationSupport
implements RelationSupportMBean, MBeanRegistration {
//
// Private members
//
// Relation identifier (expected to be unique in the Relation Service where
// the RelationSupport object will be added)
private String myRelId = null;
// ObjectName of the Relation Service where the relation will be added
// REQUIRED if the RelationSupport is created by the user to be registered as
// a MBean, as it will have to access the Relation Service via the MBean
// Server to perform the check regarding the relation type.
// Is null if current object is directly created by the Relation Service,
// as the object will directly access it.
private ObjectName myRelServiceName = null;
// Reference to the MBean Server where the Relation Service is
// registered
// REQUIRED if the RelationSupport is created by the user to be registered as
// a MBean, as it will have to access the Relation Service via the MBean
// Server to perform the check regarding the relation type.
// If the Relationbase object is created by the Relation Service (use of
// createRelation() method), this is null as not needed, direct access to
// the Relation Service.
// If the Relationbase object is created by the user and registered as a
// MBean, this is set by the preRegister() method below.
private MBeanServer myRelServiceMBeanServer = null;
// Relation type name (must be known in the Relation Service where the
// relation will be added)
private String myRelTypeName = null;
// Role map, mapping <role-name> -> <Role>
// Initialized by role list in the constructor, then updated:
// - if the relation is a MBean, via setRole() and setRoles() methods, or
// via Relation Service setRole() and setRoles() methods
// - if the relation is internal to the Relation Service, via
// setRoleInt() and setRolesInt() methods.
private final Map<String,Role> myRoleName2ValueMap = new HashMap<String,Role>();
// Flag to indicate if the object has been added in the Relation Service
private final AtomicBoolean myInRelServFlg = new AtomicBoolean();
//
// Constructors
//
/**
* Creates a {@code RelationSupport} object.
* <P>This constructor has to be used when the RelationSupport object will
* be registered as a MBean by the user, or when creating a user relation
* MBean whose class extends RelationSupport.
* <P>Nothing is done at the Relation Service level, i.e.
* the {@code RelationSupport} object is not added to the
* {@code RelationService} and no checks are performed to
* see if the provided values are correct.
* The object is always created, EXCEPT if:
* <P>- any of the required parameters is {@code null}.
* <P>- the same name is used for two roles.
* <P>To be handled as a relation, the {@code RelationSupport} object has
* to be added to the Relation Service using the Relation Service method
* addRelation().
*
* @param relationId relation identifier, to identify the relation in the
* Relation Service.
* <P>Expected to be unique in the given Relation Service.
* @param relationServiceName ObjectName of the Relation Service where
* the relation will be registered.
* <P>This parameter is required as it is the Relation Service that is
* aware of the definition of the relation type of the given relation,
* so that will be able to check update operations (set).
* @param relationTypeName Name of relation type.
* <P>Expected to have been created in the given Relation Service.
* @param list list of roles (Role objects) to initialize the
* relation. Can be {@code null}.
* <P>Expected to conform to relation info in associated relation type.
*
* @exception InvalidRoleValueException if the same name is used for two
* roles.
* @exception IllegalArgumentException if any of the required parameters
* (relation id, relation service ObjectName, or relation type name) is
* {@code null}.
*/
public RelationSupport(String relationId,
ObjectName relationServiceName,
String relationTypeName,
RoleList list)
throws InvalidRoleValueException,
IllegalArgumentException {
super();
RELATION_LOGGER.entering(RelationSupport.class.getName(),
"RelationSupport");
// Can throw InvalidRoleValueException and IllegalArgumentException
initMembers(relationId,
relationServiceName,
null,
relationTypeName,
list);
RELATION_LOGGER.exiting(RelationSupport.class.getName(),
"RelationSupport");
}
/**
* Creates a {@code RelationSupport} object.
* <P>This constructor has to be used when the user relation MBean
* implements the interfaces expected to be supported by a relation by
* delegating to a RelationSupport object.
* <P>This object needs to know the Relation Service expected to handle the
* relation. So it has to know the MBean Server where the Relation Service
* is registered.
* <P>According to a limitation, a relation MBean must be registered in the
* same MBean Server as the Relation Service expected to handle it. So the
* user relation MBean has to be created and registered, and then the
* wrapped RelationSupport object can be created within the identified MBean
* Server.
* <P>Nothing is done at the Relation Service level, i.e.
* the {@code RelationSupport} object is not added to the
* {@code RelationService} and no checks are performed to
* see if the provided values are correct.
* The object is always created, EXCEPT if:
* <P>- any of the required parameters is {@code null}.
* <P>- the same name is used for two roles.
* <P>To be handled as a relation, the {@code RelationSupport} object has
* to be added to the Relation Service using the Relation Service method
* addRelation().
*
* @param relationId relation identifier, to identify the relation in the
* Relation Service.
* <P>Expected to be unique in the given Relation Service.
* @param relationServiceName ObjectName of the Relation Service where
* the relation will be registered.
* <P>This parameter is required as it is the Relation Service that is
* aware of the definition of the relation type of the given relation,
* so that will be able to check update operations (set).
* @param relationServiceMBeanServer MBean Server where the wrapping MBean
* is or will be registered.
* <P>Expected to be the MBean Server where the Relation Service is or will
* be registered.
* @param relationTypeName Name of relation type.
* <P>Expected to have been created in the given Relation Service.
* @param list list of roles (Role objects) to initialize the
* relation. Can be {@code null}.
* <P>Expected to conform to relation info in associated relation type.
*
* @exception InvalidRoleValueException if the same name is used for two
* roles.
* @exception IllegalArgumentException if any of the required parameters
* (relation id, relation service ObjectName, relation service MBeanServer,
* or relation type name) is {@code null}.
*/
public RelationSupport(String relationId,
ObjectName relationServiceName,
MBeanServer relationServiceMBeanServer,
String relationTypeName,
RoleList list)
throws InvalidRoleValueException,
IllegalArgumentException {
super();
if (relationServiceMBeanServer == null) {
String excMsg = "Invalid parameter.";
throw new IllegalArgumentException(excMsg);
}
RELATION_LOGGER.entering(RelationSupport.class.getName(),
"RelationSupport");
// Can throw InvalidRoleValueException and
// IllegalArgumentException
initMembers(relationId,
relationServiceName,
relationServiceMBeanServer,
relationTypeName,
list);
RELATION_LOGGER.exiting(RelationSupport.class.getName(),
"RelationSupport");
}
//
// Relation Interface
//
/**
* Retrieves role value for given role name.
* <P>Checks if the role exists and is readable according to the relation
* type.
*
* @param roleName name of role
*
* @return the ArrayList of ObjectName objects being the role value
*
* @exception IllegalArgumentException if null role name
* @exception RoleNotFoundException if:
* <P>- there is no role with given name
* <P>- the role is not readable.
* @exception RelationServiceNotRegisteredException if the Relation
* Service is not registered in the MBean Server
*
* @see #setRole
*/
public List<ObjectName> getRole(String roleName)
throws IllegalArgumentException,
RoleNotFoundException,
RelationServiceNotRegisteredException {
if (roleName == null) {
String excMsg = "Invalid parameter.";
throw new IllegalArgumentException(excMsg);
}
RELATION_LOGGER.entering(RelationSupport.class.getName(),
"getRole", roleName);
// Can throw RoleNotFoundException and
// RelationServiceNotRegisteredException
List<ObjectName> result = cast(
getRoleInt(roleName, false, null, false));
RELATION_LOGGER.exiting(RelationSupport.class.getName(), "getRole");
return result;
}
/**
* Retrieves values of roles with given names.
* <P>Checks for each role if it exists and is readable according to the
* relation type.
*
* @param roleNameArray array of names of roles to be retrieved
*
* @return a RoleResult object, including a RoleList (for roles
* successfully retrieved) and a RoleUnresolvedList (for roles not
* retrieved).
*
* @exception IllegalArgumentException if null role name
* @exception RelationServiceNotRegisteredException if the Relation
* Service is not registered in the MBean Server
*
* @see #setRoles
*/
public RoleResult getRoles(String[] roleNameArray)
throws IllegalArgumentException,
RelationServiceNotRegisteredException {
if (roleNameArray == null) {
String excMsg = "Invalid parameter.";
throw new IllegalArgumentException(excMsg);
}
RELATION_LOGGER.entering(RelationSupport.class.getName(), "getRoles");
// Can throw RelationServiceNotRegisteredException
RoleResult result = getRolesInt(roleNameArray, false, null);
RELATION_LOGGER.exiting(RelationSupport.class.getName(), "getRoles");
return result;
}
/**
* Returns all roles present in the relation.
*
* @return a RoleResult object, including a RoleList (for roles
* successfully retrieved) and a RoleUnresolvedList (for roles not
* readable).
*
* @exception RelationServiceNotRegisteredException if the Relation
* Service is not registered in the MBean Server
*/
public RoleResult getAllRoles()
throws RelationServiceNotRegisteredException {
RELATION_LOGGER.entering(RelationSupport.class.getName(),
"getAllRoles");
RoleResult result = null;
try {
result = getAllRolesInt(false, null);
} catch (IllegalArgumentException exc) {
// OK : Invalid parameters, ignore...
}
RELATION_LOGGER.exiting(RelationSupport.class.getName(), "getAllRoles");
return result;
}
/**
* Returns all roles in the relation without checking read mode.
*
* @return a RoleList
*/
public RoleList retrieveAllRoles() {
RELATION_LOGGER.entering(RelationSupport.class.getName(),
"retrieveAllRoles");
RoleList result;
synchronized(myRoleName2ValueMap) {
result =
new RoleList(new ArrayList<Role>(myRoleName2ValueMap.values()));
}
RELATION_LOGGER.exiting(RelationSupport.class.getName(),
"retrieveAllRoles");
return result;
}
/**
* Returns the number of MBeans currently referenced in the given role.
*
* @param roleName name of role
*
* @return the number of currently referenced MBeans in that role
*
* @exception IllegalArgumentException if null role name
* @exception RoleNotFoundException if there is no role with given name
*/
public Integer getRoleCardinality(String roleName)
throws IllegalArgumentException,
RoleNotFoundException {
if (roleName == null) {
String excMsg = "Invalid parameter.";
throw new IllegalArgumentException(excMsg);
}
RELATION_LOGGER.entering(RelationSupport.class.getName(),
"getRoleCardinality", roleName);
// Try to retrieve the role
Role role;
synchronized(myRoleName2ValueMap) {
// No null Role is allowed, so direct use of get()
role = (myRoleName2ValueMap.get(roleName));
}
if (role == null) {
int pbType = RoleStatus.NO_ROLE_WITH_NAME;
// Will throw a RoleNotFoundException
//
// Will not throw InvalidRoleValueException, so catch it for the
// compiler
try {
RelationService.throwRoleProblemException(pbType,
roleName);
} catch (InvalidRoleValueException exc) {
// OK : Do not throw InvalidRoleValueException as
// a RoleNotFoundException will be thrown.
}
}
List<ObjectName> roleValue = role.getRoleValue();
RELATION_LOGGER.exiting(RelationSupport.class.getName(),
"getRoleCardinality");
return roleValue.size();
}
/**
* Sets the given role.
* <P>Will check the role according to its corresponding role definition
* provided in relation's relation type
* <P>Will send a notification (RelationNotification with type
* RELATION_BASIC_UPDATE or RELATION_MBEAN_UPDATE, depending if the
* relation is a MBean or not).
*
* @param role role to be set (name and new value)
*
* @exception IllegalArgumentException if null role
* @exception RoleNotFoundException if there is no role with the supplied
* role's name or if the role is not writable (no test on the write access
* mode performed when initializing the role)
* @exception InvalidRoleValueException if value provided for
* role is not valid, i.e.:
* <P>- the number of referenced MBeans in given value is less than
* expected minimum degree
* <P>- the number of referenced MBeans in provided value exceeds expected
* maximum degree
* <P>- one referenced MBean in the value is not an Object of the MBean
* class expected for that role
* <P>- a MBean provided for that role does not exist
* @exception RelationServiceNotRegisteredException if the Relation
* Service is not registered in the MBean Server
* @exception RelationTypeNotFoundException if the relation type has not
* been declared in the Relation Service
* @exception RelationNotFoundException if the relation has not been
* added in the Relation Service.
*
* @see #getRole
*/
public void setRole(Role role)
throws IllegalArgumentException,
RoleNotFoundException,
RelationTypeNotFoundException,
InvalidRoleValueException,
RelationServiceNotRegisteredException,
RelationNotFoundException {
if (role == null) {
String excMsg = "Invalid parameter.";
throw new IllegalArgumentException(excMsg);
}
RELATION_LOGGER.entering(RelationSupport.class.getName(),
"setRole", role);
// Will return null :)
Object result = setRoleInt(role, false, null, false);
RELATION_LOGGER.exiting(RelationSupport.class.getName(), "setRole");
return;
}
/**
* Sets the given roles.
* <P>Will check the role according to its corresponding role definition
* provided in relation's relation type
* <P>Will send one notification (RelationNotification with type
* RELATION_BASIC_UPDATE or RELATION_MBEAN_UPDATE, depending if the
* relation is a MBean or not) per updated role.
*
* @param list list of roles to be set
*
* @return a RoleResult object, including a RoleList (for roles
* successfully set) and a RoleUnresolvedList (for roles not
* set).
*
* @exception IllegalArgumentException if null role list
* @exception RelationServiceNotRegisteredException if the Relation
* Service is not registered in the MBean Server
* @exception RelationTypeNotFoundException if the relation type has not
* been declared in the Relation Service.
* @exception RelationNotFoundException if the relation MBean has not been
* added in the Relation Service.
*
* @see #getRoles
*/
public RoleResult setRoles(RoleList list)
throws IllegalArgumentException,
RelationServiceNotRegisteredException,
RelationTypeNotFoundException,
RelationNotFoundException {
if (list == null) {
String excMsg = "Invalid parameter.";
throw new IllegalArgumentException(excMsg);
}
RELATION_LOGGER.entering(RelationSupport.class.getName(),
"setRoles", list);
RoleResult result = setRolesInt(list, false, null);
RELATION_LOGGER.exiting(RelationSupport.class.getName(), "setRoles");
return result;
}
/**
* Callback used by the Relation Service when a MBean referenced in a role
* is unregistered.
* <P>The Relation Service will call this method to let the relation
* take action to reflect the impact of such unregistration.
* <P>BEWARE. the user is not expected to call this method.
* <P>Current implementation is to set the role with its current value
* (list of ObjectNames of referenced MBeans) without the unregistered
* one.
*
* @param objectName ObjectName of unregistered MBean
* @param roleName name of role where the MBean is referenced
*
* @exception IllegalArgumentException if null parameter
* @exception RoleNotFoundException if role does not exist in the
* relation or is not writable
* @exception InvalidRoleValueException if role value does not conform to
* the associated role info (this will never happen when called from the
* Relation Service)
* @exception RelationServiceNotRegisteredException if the Relation
* Service is not registered in the MBean Server
* @exception RelationTypeNotFoundException if the relation type has not
* been declared in the Relation Service.
* @exception RelationNotFoundException if this method is called for a
* relation MBean not added in the Relation Service.
*/
public void handleMBeanUnregistration(ObjectName objectName,
String roleName)
throws IllegalArgumentException,
RoleNotFoundException,
InvalidRoleValueException,
RelationServiceNotRegisteredException,
RelationTypeNotFoundException,
RelationNotFoundException {
if (objectName == null || roleName == null) {
String excMsg = "Invalid parameter.";
throw new IllegalArgumentException(excMsg);
}
RELATION_LOGGER.entering(RelationSupport.class.getName(),
"handleMBeanUnregistration",
new Object[]{objectName, roleName});
// Can throw RoleNotFoundException, InvalidRoleValueException,
// or RelationTypeNotFoundException
handleMBeanUnregistrationInt(objectName,
roleName,
false,
null);
RELATION_LOGGER.exiting(RelationSupport.class.getName(),
"handleMBeanUnregistration");
return;
}
/**
* Retrieves MBeans referenced in the various roles of the relation.
*
* @return a HashMap mapping:
* <P> ObjectName {@literal ->} ArrayList of String (role names)
*/
public Map<ObjectName,List<String>> getReferencedMBeans() {
RELATION_LOGGER.entering(RelationSupport.class.getName(),
"getReferencedMBeans");
Map<ObjectName,List<String>> refMBeanMap =
new HashMap<ObjectName,List<String>>();
synchronized(myRoleName2ValueMap) {
for (Role currRole : myRoleName2ValueMap.values()) {
String currRoleName = currRole.getRoleName();
// Retrieves ObjectNames of MBeans referenced in current role
List<ObjectName> currRefMBeanList = currRole.getRoleValue();
for (ObjectName currRoleObjName : currRefMBeanList) {
// Sees if current MBean has been already referenced in
// roles already seen
List<String> mbeanRoleNameList =
refMBeanMap.get(currRoleObjName);
boolean newRefFlg = false;
if (mbeanRoleNameList == null) {
newRefFlg = true;
mbeanRoleNameList = new ArrayList<String>();
}
mbeanRoleNameList.add(currRoleName);
if (newRefFlg) {
refMBeanMap.put(currRoleObjName, mbeanRoleNameList);
}
}
}
}
RELATION_LOGGER.exiting(RelationSupport.class.getName(),
"getReferencedMBeans");
return refMBeanMap;
}
/**
* Returns name of associated relation type.
*/
public String getRelationTypeName() {
return myRelTypeName;
}
/**
* Returns ObjectName of the Relation Service handling the relation.
*
* @return the ObjectName of the Relation Service.
*/
public ObjectName getRelationServiceName() {
return myRelServiceName;
}
/**
* Returns relation identifier (used to uniquely identify the relation
* inside the Relation Service).
*
* @return the relation id.
*/
public String getRelationId() {
return myRelId;
}
//
// MBeanRegistration interface
//
// Pre-registration: retrieves the MBean Server (useful to access to the
// Relation Service)
// This is the way to retrieve the MBean Server when the relation object is
// a MBean created by the user outside of the Relation Service.
//
// No exception thrown.
public ObjectName preRegister(MBeanServer server,
ObjectName name)
throws Exception {
myRelServiceMBeanServer = server;
return name;
}
// Post-registration: does nothing
public void postRegister(Boolean registrationDone) {
return;
}
// Pre-unregistration: does nothing
public void preDeregister()
throws Exception {
return;
}
// Post-unregistration: does nothing
public void postDeregister() {
return;
}
//
// Others
//
/**
* Returns an internal flag specifying if the object is still handled by
* the Relation Service.
*/
public Boolean isInRelationService() {
return myInRelServFlg.get();
}
public void setRelationServiceManagementFlag(Boolean flag)
throws IllegalArgumentException {
if (flag == null) {
String excMsg = "Invalid parameter.";
throw new IllegalArgumentException(excMsg);
}
myInRelServFlg.set(flag);
}
//
// Misc
//
// Gets the role with given name
// Checks if the role exists and is readable according to the relation
// type.
//
// This method is called in getRole() above.
// It is also called in the Relation Service getRole() method.
// It is also called in getRolesInt() below (used for getRoles() above
// and for Relation Service getRoles() method).
//
// Depending on parameters reflecting its use (either in the scope of
// getting a single role or of getting several roles), will return:
// - in case of success:
// - for single role retrieval, the ArrayList of ObjectNames being the
// role value
// - for multi-role retrieval, the Role object itself
// - in case of failure (except critical exceptions):
// - for single role retrieval, if role does not exist or is not
// readable, an RoleNotFoundException exception is raised
// - for multi-role retrieval, a RoleUnresolved object
//
// -param roleName name of role to be retrieved
// -param relationServCallFlg true if call from the Relation Service; this
// will happen if the current RelationSupport object has been created by
// the Relation Service (via createRelation()) method, so direct access is
// possible.
// -param relationServ reference to Relation Service object, if object
// created by Relation Service.
// -param multiRoleFlg true if getting the role in the scope of a
// multiple retrieval.
//
// -return:
// - for single role retrieval (multiRoleFlg false):
// - ArrayList of ObjectName objects, value of role with given name, if
// the role can be retrieved
// - raise a RoleNotFoundException exception else
// - for multi-role retrieval (multiRoleFlg true):
// - the Role object for given role name if role can be retrieved
// - a RoleUnresolved object with problem.
//
// -exception IllegalArgumentException if null parameter
// -exception RoleNotFoundException if multiRoleFlg is false and:
// - there is no role with given name
// or
// - the role is not readable.
// -exception RelationServiceNotRegisteredException if the Relation
// Service is not registered in the MBean Server
Object getRoleInt(String roleName,
boolean relationServCallFlg,
RelationService relationServ,
boolean multiRoleFlg)
throws IllegalArgumentException,
RoleNotFoundException,
RelationServiceNotRegisteredException {
if (roleName == null ||
(relationServCallFlg && relationServ == null)) {
String excMsg = "Invalid parameter.";
throw new IllegalArgumentException(excMsg);
}
RELATION_LOGGER.entering(RelationSupport.class.getName(),
"getRoleInt", roleName);
int pbType = 0;
Role role;
synchronized(myRoleName2ValueMap) {
// No null Role is allowed, so direct use of get()
role = (myRoleName2ValueMap.get(roleName));
}
if (role == null) {
pbType = RoleStatus.NO_ROLE_WITH_NAME;
} else {
// Checks if the role is readable
Integer status;
if (relationServCallFlg) {
// Call from the Relation Service, so direct access to it,
// avoiding MBean Server
// Shall not throw a RelationTypeNotFoundException
try {
status = relationServ.checkRoleReading(roleName,
myRelTypeName);
} catch (RelationTypeNotFoundException exc) {
throw new RuntimeException(exc.getMessage());
}
} else {
// Call from getRole() method above
// So we have a MBean. We must access the Relation Service
// via the MBean Server.
Object[] params = new Object[2];
params[0] = roleName;
params[1] = myRelTypeName;
String[] signature = new String[2];
signature[0] = "java.lang.String";
signature[1] = "java.lang.String";
// Can throw InstanceNotFoundException if the Relation
// Service is not registered (to be catched in any case and
// transformed into RelationServiceNotRegisteredException).
//
// Shall not throw a MBeanException, or a ReflectionException
// or an InstanceNotFoundException
try {
status = (Integer)
(myRelServiceMBeanServer.invoke(myRelServiceName,
"checkRoleReading",
params,
signature));
} catch (MBeanException exc1) {
throw new RuntimeException("incorrect relation type");
} catch (ReflectionException exc2) {
throw new RuntimeException(exc2.getMessage());
} catch (InstanceNotFoundException exc3) {
throw new RelationServiceNotRegisteredException(
exc3.getMessage());
}
}
pbType = status.intValue();
}
Object result;
if (pbType == 0) {
// Role can be retrieved
if (!(multiRoleFlg)) {
// Single role retrieved: returns its value
// Note: no need to test if role value (list) not null before
// cloning, null value not allowed, empty list if
// nothing.
result = new ArrayList<ObjectName>(role.getRoleValue());
} else {
// Role retrieved during multi-role retrieval: returns the
// role
result = (Role)(role.clone());
}
} else {
// Role not retrieved
if (!(multiRoleFlg)) {
// Problem when retrieving a simple role: either role not
// found or not readable, so raises a RoleNotFoundException.
try {
RelationService.throwRoleProblemException(pbType,
roleName);
// To keep compiler happy :)
return null;
} catch (InvalidRoleValueException exc) {
throw new RuntimeException(exc.getMessage());
}
} else {
// Problem when retrieving a role in a multi-role retrieval:
// returns a RoleUnresolved object
result = new RoleUnresolved(roleName, null, pbType);
}
}
RELATION_LOGGER.exiting(RelationSupport.class.getName(), "getRoleInt");
return result;
}
// Gets the given roles
// For each role, verifies if the role exists and is readable according to
// the relation type.
//
// This method is called in getRoles() above and in Relation Service
// getRoles() method.
//
// -param roleNameArray array of names of roles to be retrieved
// -param relationServCallFlg true if call from the Relation Service; this
// will happen if the current RelationSupport object has been created by
// the Relation Service (via createRelation()) method, so direct access is
// possible.
// -param relationServ reference to Relation Service object, if object
// created by Relation Service.
//
// -return a RoleResult object
//
// -exception IllegalArgumentException if null parameter
// -exception RelationServiceNotRegisteredException if the Relation
// Service is not registered in the MBean Server
RoleResult getRolesInt(String[] roleNameArray,
boolean relationServCallFlg,
RelationService relationServ)
throws IllegalArgumentException,
RelationServiceNotRegisteredException {
if (roleNameArray == null ||
(relationServCallFlg && relationServ == null)) {
String excMsg = "Invalid parameter.";
throw new IllegalArgumentException(excMsg);
}
RELATION_LOGGER.entering(RelationSupport.class.getName(),
"getRolesInt");
RoleList roleList = new RoleList();
RoleUnresolvedList roleUnresList = new RoleUnresolvedList();
for (int i = 0; i < roleNameArray.length; i++) {
String currRoleName = roleNameArray[i];
Object currResult;
// Can throw RelationServiceNotRegisteredException
//
// RoleNotFoundException: not possible but catch it for compiler :)
try {
currResult = getRoleInt(currRoleName,
relationServCallFlg,
relationServ,
true);
} catch (RoleNotFoundException exc) {
return null; // :)
}
if (currResult instanceof Role) {
// Can throw IllegalArgumentException if role is null
// (normally should not happen :(
try {
roleList.add((Role)currResult);
} catch (IllegalArgumentException exc) {
throw new RuntimeException(exc.getMessage());
}
} else if (currResult instanceof RoleUnresolved) {
// Can throw IllegalArgumentException if role is null
// (normally should not happen :(
try {
roleUnresList.add((RoleUnresolved)currResult);
} catch (IllegalArgumentException exc) {
throw new RuntimeException(exc.getMessage());
}
}
}
RoleResult result = new RoleResult(roleList, roleUnresList);
RELATION_LOGGER.exiting(RelationSupport.class.getName(),
"getRolesInt");
return result;
}
// Returns all roles present in the relation
//
// -return a RoleResult object, including a RoleList (for roles
// successfully retrieved) and a RoleUnresolvedList (for roles not
// readable).
//
// -exception IllegalArgumentException if null parameter
// -exception RelationServiceNotRegisteredException if the Relation
// Service is not registered in the MBean Server
//
RoleResult getAllRolesInt(boolean relationServCallFlg,
RelationService relationServ)
throws IllegalArgumentException,
RelationServiceNotRegisteredException {
if (relationServCallFlg && relationServ == null) {
String excMsg = "Invalid parameter.";
throw new IllegalArgumentException(excMsg);
}
RELATION_LOGGER.entering(RelationSupport.class.getName(),
"getAllRolesInt");
List<String> roleNameList;
synchronized(myRoleName2ValueMap) {
roleNameList =
new ArrayList<String>(myRoleName2ValueMap.keySet());
}
String[] roleNames = new String[roleNameList.size()];
roleNameList.toArray(roleNames);
RoleResult result = getRolesInt(roleNames,
relationServCallFlg,
relationServ);
RELATION_LOGGER.exiting(RelationSupport.class.getName(),
"getAllRolesInt");
return result;
}
// Sets the role with given value
//
// This method is called in setRole() above.
// It is also called by the Relation Service setRole() method.
// It is also called in setRolesInt() method below (used in setRoles()
// above and in RelationService setRoles() method).
//
// Will check the role according to its corresponding role definition
// provided in relation's relation type
// Will send a notification (RelationNotification with type
// RELATION_BASIC_UPDATE or RELATION_MBEAN_UPDATE, depending if the
// relation is a MBean or not) if not initialization of role.
//
// -param aRole role to be set (name and new value)
// -param relationServCallFlg true if call from the Relation Service; this
// will happen if the current RelationSupport object has been created by
// the Relation Service (via createRelation()) method, so direct access is
// possible.
// -param relationServ reference to Relation Service object, if internal
// relation
// -param multiRoleFlg true if getting the role in the scope of a
// multiple retrieval.
//
// -return (except other "critical" exceptions):
// - for single role retrieval (multiRoleFlg false):
// - null if the role has been set
// - raise an InvalidRoleValueException
// else
// - for multi-role retrieval (multiRoleFlg true):
// - the Role object for given role name if role has been set
// - a RoleUnresolved object with problem else.
//
// -exception IllegalArgumentException if null parameter
// -exception RoleNotFoundException if multiRoleFlg is false and:
// - internal relation and the role does not exist
// or
// - existing role (i.e. not initializing it) and the role is not
// writable.
// -exception InvalidRoleValueException ifmultiRoleFlg is false and
// value provided for:
// - the number of referenced MBeans in given value is less than
// expected minimum degree
// or
// - the number of referenced MBeans in provided value exceeds expected
// maximum degree
// or
// - one referenced MBean in the value is not an Object of the MBean
// class expected for that role
// or
// - a MBean provided for that role does not exist
// -exception RelationServiceNotRegisteredException if the Relation
// Service is not registered in the MBean Server
// -exception RelationTypeNotFoundException if relation type unknown
// -exception RelationNotFoundException if a relation MBean has not been
// added in the Relation Service
Object setRoleInt(Role aRole,
boolean relationServCallFlg,
RelationService relationServ,
boolean multiRoleFlg)
throws IllegalArgumentException,
RoleNotFoundException,
InvalidRoleValueException,
RelationServiceNotRegisteredException,
RelationTypeNotFoundException,
RelationNotFoundException {
if (aRole == null ||
(relationServCallFlg && relationServ == null)) {
String excMsg = "Invalid parameter.";
throw new IllegalArgumentException(excMsg);
}
RELATION_LOGGER.entering(RelationSupport.class.getName(),
"setRoleInt", new Object[] {aRole, relationServCallFlg,
relationServ, multiRoleFlg});
String roleName = aRole.getRoleName();
int pbType = 0;
// Checks if role exists in the relation
// No error if the role does not exist in the relation, to be able to
// handle initialization of role when creating the relation
// (roles provided in the RoleList parameter are directly set but
// roles automatically initialized are set using setRole())
Role role;
synchronized(myRoleName2ValueMap) {
role = (myRoleName2ValueMap.get(roleName));
}
List<ObjectName> oldRoleValue;
Boolean initFlg;
if (role == null) {
initFlg = true;
oldRoleValue = new ArrayList<ObjectName>();
} else {
initFlg = false;
oldRoleValue = role.getRoleValue();
}
// Checks if the role can be set: is writable (except if
// initialization) and correct value
try {
Integer status;
if (relationServCallFlg) {
// Call from the Relation Service, so direct access to it,
// avoiding MBean Server
//
// Shall not raise a RelationTypeNotFoundException
status = relationServ.checkRoleWriting(aRole,
myRelTypeName,
initFlg);
} else {
// Call from setRole() method above
// So we have a MBean. We must access the Relation Service
// via the MBean Server.
Object[] params = new Object[3];
params[0] = aRole;
params[1] = myRelTypeName;
params[2] = initFlg;
String[] signature = new String[3];
signature[0] = "javax.management.relation.Role";
signature[1] = "java.lang.String";
signature[2] = "java.lang.Boolean";
// Can throw InstanceNotFoundException if the Relation Service
// is not registered (to be transformed into
// RelationServiceNotRegisteredException in any case).
//
// Can throw a MBeanException wrapping a
// RelationTypeNotFoundException:
// throw wrapped exception.
//
// Shall not throw a ReflectionException
status = (Integer)
(myRelServiceMBeanServer.invoke(myRelServiceName,
"checkRoleWriting",
params,
signature));
}
pbType = status.intValue();
} catch (MBeanException exc2) {
// Retrieves underlying exception
Exception wrappedExc = exc2.getTargetException();
if (wrappedExc instanceof RelationTypeNotFoundException) {
throw ((RelationTypeNotFoundException)wrappedExc);
} else {
throw new RuntimeException(wrappedExc.getMessage());
}
} catch (ReflectionException exc3) {
throw new RuntimeException(exc3.getMessage());
} catch (RelationTypeNotFoundException exc4) {
throw new RuntimeException(exc4.getMessage());
} catch (InstanceNotFoundException exc5) {
throw new RelationServiceNotRegisteredException(exc5.getMessage());
}
Object result = null;
if (pbType == 0) {
// Role can be set
if (!(initFlg.booleanValue())) {
// Not initializing the role
// If role being initialized:
// - do not send an update notification
// - do not try to update internal map of Relation Service
// listing referenced MBeans, as role is initialized to an
// empty list
// Sends a notification (RelationNotification)
// Can throw a RelationNotFoundException
sendRoleUpdateNotification(aRole,
oldRoleValue,
relationServCallFlg,
relationServ);
// Updates the role map of the Relation Service
// Can throw RelationNotFoundException
updateRelationServiceMap(aRole,
oldRoleValue,
relationServCallFlg,
relationServ);
}
// Sets the role
synchronized(myRoleName2ValueMap) {
myRoleName2ValueMap.put(roleName,
(Role)(aRole.clone()));
}
// Single role set: returns null: nothing to set in result
if (multiRoleFlg) {
// Multi-roles retrieval: returns the role
result = aRole;
}
} else {
// Role not set
if (!(multiRoleFlg)) {
// Problem when setting a simple role: either role not
// found, not writable, or incorrect value:
// raises appropriate exception, RoleNotFoundException or
// InvalidRoleValueException
RelationService.throwRoleProblemException(pbType,
roleName);
// To keep compiler happy :)
return null;
} else {
// Problem when retrieving a role in a multi-role retrieval:
// returns a RoleUnresolved object
result = new RoleUnresolved(roleName,
aRole.getRoleValue(),
pbType);
}
}
RELATION_LOGGER.exiting(RelationSupport.class.getName(), "setRoleInt");
return result;
}
// Requires the Relation Service to send a notification
// RelationNotification, with type being either:
// - RelationNotification.RELATION_BASIC_UPDATE if the updated relation is
// a relation internal to the Relation Service
// - RelationNotification.RELATION_MBEAN_UPDATE if the updated relation is
// a relation MBean.
//
// -param newRole new role
// -param oldRoleValue old role value (ArrayList of ObjectNames)
// -param relationServCallFlg true if call from the Relation Service; this
// will happen if the current RelationSupport object has been created by
// the Relation Service (via createRelation()) method, so direct access is
// possible.
// -param relationServ reference to Relation Service object, if object
// created by Relation Service.
//
// -exception IllegalArgumentException if null parameter provided
// -exception RelationServiceNotRegisteredException if the Relation
// Service is not registered in the MBean Server
// -exception RelationNotFoundException if:
// - relation MBean
// and
// - it has not been added into the Relation Service
private void sendRoleUpdateNotification(Role newRole,
List<ObjectName> oldRoleValue,
boolean relationServCallFlg,
RelationService relationServ)
throws IllegalArgumentException,
RelationServiceNotRegisteredException,
RelationNotFoundException {
if (newRole == null ||
oldRoleValue == null ||
(relationServCallFlg && relationServ == null)) {
String excMsg = "Invalid parameter.";
throw new IllegalArgumentException(excMsg);
}
RELATION_LOGGER.entering(RelationSupport.class.getName(),
"sendRoleUpdateNotification", new Object[] {newRole,
oldRoleValue, relationServCallFlg, relationServ});
if (relationServCallFlg) {
// Direct call to the Relation Service
// Shall not throw a RelationNotFoundException for an internal
// relation
try {
relationServ.sendRoleUpdateNotification(myRelId,
newRole,
oldRoleValue);
} catch (RelationNotFoundException exc) {
throw new RuntimeException(exc.getMessage());
}
} else {
Object[] params = new Object[3];
params[0] = myRelId;
params[1] = newRole;
params[2] = oldRoleValue;
String[] signature = new String[3];
signature[0] = "java.lang.String";
signature[1] = "javax.management.relation.Role";
signature[2] = "java.util.List";
// Can throw InstanceNotFoundException if the Relation Service
// is not registered (to be transformed).
//
// Can throw a MBeanException wrapping a
// RelationNotFoundException (to be raised in any case): wrapped
// exception to be thrown
//
// Shall not throw a ReflectionException
try {
myRelServiceMBeanServer.invoke(myRelServiceName,
"sendRoleUpdateNotification",
params,
signature);
} catch (ReflectionException exc1) {
throw new RuntimeException(exc1.getMessage());
} catch (InstanceNotFoundException exc2) {
throw new RelationServiceNotRegisteredException(
exc2.getMessage());
} catch (MBeanException exc3) {
Exception wrappedExc = exc3.getTargetException();
if (wrappedExc instanceof RelationNotFoundException) {
throw ((RelationNotFoundException)wrappedExc);
} else {
throw new RuntimeException(wrappedExc.getMessage());
}
}
}
RELATION_LOGGER.exiting(RelationSupport.class.getName(),
"sendRoleUpdateNotification");
return;
}
// Requires the Relation Service to update its internal map handling
// MBeans referenced in relations.
// The Relation Service will also update its recording as a listener to
// be informed about unregistration of new referenced MBeans, and no longer
// informed of MBeans no longer referenced.
//
// -param newRole new role
// -param oldRoleValue old role value (ArrayList of ObjectNames)
// -param relationServCallFlg true if call from the Relation Service; this
// will happen if the current RelationSupport object has been created by
// the Relation Service (via createRelation()) method, so direct access is
// possible.
// -param relationServ reference to Relation Service object, if object
// created by Relation Service.
//
// -exception IllegalArgumentException if null parameter
// -exception RelationServiceNotRegisteredException if the Relation
// Service is not registered in the MBean Server
// -exception RelationNotFoundException if:
// - relation MBean
// and
// - the relation is not added in the Relation Service
private void updateRelationServiceMap(Role newRole,
List<ObjectName> oldRoleValue,
boolean relationServCallFlg,
RelationService relationServ)
throws IllegalArgumentException,
RelationServiceNotRegisteredException,
RelationNotFoundException {
if (newRole == null ||
oldRoleValue == null ||
(relationServCallFlg && relationServ == null)) {
String excMsg = "Invalid parameter.";
throw new IllegalArgumentException(excMsg);
}
RELATION_LOGGER.entering(RelationSupport.class.getName(),
"updateRelationServiceMap", new Object[] {newRole,
oldRoleValue, relationServCallFlg, relationServ});
if (relationServCallFlg) {
// Direct call to the Relation Service
// Shall not throw a RelationNotFoundException
try {
relationServ.updateRoleMap(myRelId,
newRole,
oldRoleValue);
} catch (RelationNotFoundException exc) {
throw new RuntimeException(exc.getMessage());
}
} else {
Object[] params = new Object[3];
params[0] = myRelId;
params[1] = newRole;
params[2] = oldRoleValue;
String[] signature = new String[3];
signature[0] = "java.lang.String";
signature[1] = "javax.management.relation.Role";
signature[2] = "java.util.List";
// Can throw InstanceNotFoundException if the Relation Service
// is not registered (to be transformed).
// Can throw a MBeanException wrapping a RelationNotFoundException:
// wrapped exception to be thrown
//
// Shall not throw a ReflectionException
try {
myRelServiceMBeanServer.invoke(myRelServiceName,
"updateRoleMap",
params,
signature);
} catch (ReflectionException exc1) {
throw new RuntimeException(exc1.getMessage());
} catch (InstanceNotFoundException exc2) {
throw new
RelationServiceNotRegisteredException(exc2.getMessage());
} catch (MBeanException exc3) {
Exception wrappedExc = exc3.getTargetException();
if (wrappedExc instanceof RelationNotFoundException) {
throw ((RelationNotFoundException)wrappedExc);
} else {
throw new RuntimeException(wrappedExc.getMessage());
}
}
}
RELATION_LOGGER.exiting(RelationSupport.class.getName(),
"updateRelationServiceMap");
return;
}
// Sets the given roles
// For each role:
// - will check the role according to its corresponding role definition
// provided in relation's relation type
// - will send a notification (RelationNotification with type
// RELATION_BASIC_UPDATE or RELATION_MBEAN_UPDATE, depending if the
// relation is a MBean or not) for each updated role.
//
// This method is called in setRoles() above and in Relation Service
// setRoles() method.
//
// -param list list of roles to be set
// -param relationServCallFlg true if call from the Relation Service; this
// will happen if the current RelationSupport object has been created by
// the Relation Service (via createRelation()) method, so direct access is
// possible.
// -param relationServ reference to Relation Service object, if object
// created by Relation Service.
//
// -return a RoleResult object
//
// -exception IllegalArgumentException if null parameter
// -exception RelationServiceNotRegisteredException if the Relation
// Service is not registered in the MBean Server
// -exception RelationTypeNotFoundException if:
// - relation MBean
// and
// - unknown relation type
// -exception RelationNotFoundException if:
// - relation MBean
// and
// - not added in the RS
RoleResult setRolesInt(RoleList list,
boolean relationServCallFlg,
RelationService relationServ)
throws IllegalArgumentException,
RelationServiceNotRegisteredException,
RelationTypeNotFoundException,
RelationNotFoundException {
if (list == null ||
(relationServCallFlg && relationServ == null)) {
String excMsg = "Invalid parameter.";
throw new IllegalArgumentException(excMsg);
}
RELATION_LOGGER.entering(RelationSupport.class.getName(),
"setRolesInt",
new Object[] {list, relationServCallFlg, relationServ});
RoleList roleList = new RoleList();
RoleUnresolvedList roleUnresList = new RoleUnresolvedList();
for (Role currRole : list.asList()) {
Object currResult = null;
// Can throw:
// RelationServiceNotRegisteredException,
// RelationTypeNotFoundException
//
// Will not throw, due to parameters, RoleNotFoundException or
// InvalidRoleValueException, but catch them to keep compiler
// happy
try {
currResult = setRoleInt(currRole,
relationServCallFlg,
relationServ,
true);
} catch (RoleNotFoundException exc1) {
// OK : Do not throw a RoleNotFoundException.
} catch (InvalidRoleValueException exc2) {
// OK : Do not throw an InvalidRoleValueException.
}
if (currResult instanceof Role) {
// Can throw IllegalArgumentException if role is null
// (normally should not happen :(
try {
roleList.add((Role)currResult);
} catch (IllegalArgumentException exc) {
throw new RuntimeException(exc.getMessage());
}
} else if (currResult instanceof RoleUnresolved) {
// Can throw IllegalArgumentException if role is null
// (normally should not happen :(
try {
roleUnresList.add((RoleUnresolved)currResult);
} catch (IllegalArgumentException exc) {
throw new RuntimeException(exc.getMessage());
}
}
}
RoleResult result = new RoleResult(roleList, roleUnresList);
RELATION_LOGGER.exiting(RelationSupport.class.getName(), "setRolesInt");
return result;
}
// Initializes all members
//
// -param relationId relation identifier, to identify the relation in the
// Relation Service.
// Expected to be unique in the given Relation Service.
// -param relationServiceName ObjectName of the Relation Service where
// the relation will be registered.
// It is required as this is the Relation Service that is aware of the
// definition of the relation type of given relation, so that will be able
// to check update operations (set). Direct access via the Relation
// Service (RelationService.setRole()) do not need this information but
// as any user relation is a MBean, setRole() is part of its management
// interface and can be called directly on the user relation MBean. So the
// user relation MBean must be aware of the Relation Service where it will
// be added.
// -param relationTypeName Name of relation type.
// Expected to have been created in given Relation Service.
// -param list list of roles (Role objects) to initialized the
// relation. Can be null.
// Expected to conform to relation info in associated relation type.
//
// -exception InvalidRoleValueException if the same name is used for two
// roles.
// -exception IllegalArgumentException if a required value (Relation
// Service Object Name, etc.) is not provided as parameter.
private void initMembers(String relationId,
ObjectName relationServiceName,
MBeanServer relationServiceMBeanServer,
String relationTypeName,
RoleList list)
throws InvalidRoleValueException,
IllegalArgumentException {
if (relationId == null ||
relationServiceName == null ||
relationTypeName == null) {
String excMsg = "Invalid parameter.";
throw new IllegalArgumentException(excMsg);
}
RELATION_LOGGER.entering(RelationSupport.class.getName(),
"initMembers", new Object[] {relationId, relationServiceName,
relationServiceMBeanServer, relationTypeName, list});
myRelId = relationId;
myRelServiceName = relationServiceName;
myRelServiceMBeanServer = relationServiceMBeanServer;
myRelTypeName = relationTypeName;
// Can throw InvalidRoleValueException
initRoleMap(list);
RELATION_LOGGER.exiting(RelationSupport.class.getName(), "initMembers");
return;
}
// Initialize the internal role map from given RoleList parameter
//
// -param list role list. Can be null.
// As it is a RoleList object, it cannot include null (rejected).
//
// -exception InvalidRoleValueException if the same role name is used for
// several roles.
//
private void initRoleMap(RoleList list)
throws InvalidRoleValueException {
if (list == null) {
return;
}
RELATION_LOGGER.entering(RelationSupport.class.getName(),
"initRoleMap", list);
synchronized(myRoleName2ValueMap) {
for (Role currRole : list.asList()) {
// No need to check if role is null, it is not allowed to store
// a null role in a RoleList :)
String currRoleName = currRole.getRoleName();
if (myRoleName2ValueMap.containsKey(currRoleName)) {
// Role already provided in current list
StringBuilder excMsgStrB = new StringBuilder("Role name ");
excMsgStrB.append(currRoleName);
excMsgStrB.append(" used for two roles.");
throw new InvalidRoleValueException(excMsgStrB.toString());
}
myRoleName2ValueMap.put(currRoleName,
(Role)(currRole.clone()));
}
}
RELATION_LOGGER.exiting(RelationSupport.class.getName(), "initRoleMap");
return;
}
// Callback used by the Relation Service when a MBean referenced in a role
// is unregistered.
// The Relation Service will call this method to let the relation
// take action to reflect the impact of such unregistration.
// Current implementation is to set the role with its current value
// (list of ObjectNames of referenced MBeans) without the unregistered
// one.
//
// -param objectName ObjectName of unregistered MBean
// -param roleName name of role where the MBean is referenced
// -param relationServCallFlg true if call from the Relation Service; this
// will happen if the current RelationSupport object has been created by
// the Relation Service (via createRelation()) method, so direct access is
// possible.
// -param relationServ reference to Relation Service object, if internal
// relation
//
// -exception IllegalArgumentException if null parameter
// -exception RoleNotFoundException if:
// - the role does not exist
// or
// - role not writable.
// -exception InvalidRoleValueException if value provided for:
// - the number of referenced MBeans in given value is less than
// expected minimum degree
// or
// - the number of referenced MBeans in provided value exceeds expected
// maximum degree
// or
// - one referenced MBean in the value is not an Object of the MBean
// class expected for that role
// or
// - a MBean provided for that role does not exist
// -exception RelationServiceNotRegisteredException if the Relation
// Service is not registered in the MBean Server
// -exception RelationTypeNotFoundException if unknown relation type
// -exception RelationNotFoundException if current relation has not been
// added in the RS
void handleMBeanUnregistrationInt(ObjectName objectName,
String roleName,
boolean relationServCallFlg,
RelationService relationServ)
throws IllegalArgumentException,
RoleNotFoundException,
InvalidRoleValueException,
RelationServiceNotRegisteredException,
RelationTypeNotFoundException,
RelationNotFoundException {
if (objectName == null ||
roleName == null ||
(relationServCallFlg && relationServ == null)) {
String excMsg = "Invalid parameter.";
throw new IllegalArgumentException(excMsg);
}
RELATION_LOGGER.entering(RelationSupport.class.getName(),
"handleMBeanUnregistrationInt", new Object[] {objectName,
roleName, relationServCallFlg, relationServ});
// Retrieves current role value
Role role;
synchronized(myRoleName2ValueMap) {
role = (myRoleName2ValueMap.get(roleName));
}
if (role == null) {
StringBuilder excMsgStrB = new StringBuilder();
String excMsg = "No role with name ";
excMsgStrB.append(excMsg);
excMsgStrB.append(roleName);
throw new RoleNotFoundException(excMsgStrB.toString());
}
List<ObjectName> currRoleValue = role.getRoleValue();
// Note: no need to test if list not null before cloning, null value
// not allowed for role value.
List<ObjectName> newRoleValue = new ArrayList<ObjectName>(currRoleValue);
newRoleValue.remove(objectName);
Role newRole = new Role(roleName, newRoleValue);
// Can throw InvalidRoleValueException,
// RelationTypeNotFoundException
// (RoleNotFoundException already detected)
Object result =
setRoleInt(newRole, relationServCallFlg, relationServ, false);
RELATION_LOGGER.exiting(RelationSupport.class.getName(),
"handleMBeanUnregistrationInt");
return;
}
}
⏎ javax/management/relation/RelationSupport.java
Or download all of them as a single archive file:
File name: jre-rt-javax-1.8.0_191-src.zip File size: 5381005 bytes Release date: 2018-10-28 Download
⇒ JRE 8 rt.jar - org.* Package Source Code
2024-03-15, 213018👍, 6💬
Related Topics: