Overview | Package | Class | Tree | Deprecated | Index | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

## com.bea.wli.management.configuration
Interface ProcessConfigurationMBean

All Superinterfaces:
  weblogic.management.configuration.ConfigurationMBean, javax.management.DynamicMBean, javax.management.MBeanRegistration, javax.management.NotificationBroadcaster, weblogic.management.WebLogicMBean

public interface ProcessConfigurationMBean
extends weblogic.management.configuration.ConfigurationMBean

MBean for managing properties of a particular type of process. This mbean exposes certain configurable properties of a process type and allows them to be dynamically changed. There is one instance of ProcessConfigurationMBean for each service type. Use `ProcessRuntimeMBean` to manage instances of a process.

Field Summary
`static long` | `CACHING_STUB_SVUID` The magic number that is used to generate the serialVersionUID of the generated MBean Stub (xxxMBean_Stub).

Fields inherited from interface weblogic.management.configuration.ConfigurationMBean
`DEFAULT_EMPTY_BYTE_ARRAY`

Method Summary
`long` | `getActivationTime()` Return the activation time in seconds since 1/1/1970 GMT.
`String` | `getAppName()` Returns the application name where this process is deployed.
`ArchivingPolicy` | `getArchivingPolicy()` Returns the archiving policy for this process.
`boolean` | `getB2BInboundFlag()` get flag on whether a process type whose instance will be started by a B2B(either ebXML or RN) message.
`boolean` | `getB2BOutboundFlag()` get flag on whether a process type has a B2B(either ebXML or RN) control.
`String` | `getCallbackClassName()` Returns the class name for the client callback if there is any.
`Set` | `getControlCallbackPolicy(String controlId)` Returns the callback authorization policy for a given control.
`long` | `getDeactivationTime()` Returns the deactivation time in seconds since 1/1/1970 GMT.
`String` | `getDeploymentId()` Return id which is different for each deployment of this process.
`String` | `getDescription()` Returns the description for this process type.
`String` | `getDisplayName()` Returns the display name.
`String` | `getEjbModuleName()` Returns the ejb module name for this jpd.
`String[]` | `getExternalCallbackControls()` Returns the names of all controls in this process which are externall callback targets.
`String` | `getFlowTag()` Returns the flow definiton in String format.
`String` | `getInheritedPolicy(String methodName)` Returns the effective authorization policy expression for the given method when no policy has been explicitly assigned to the method.
`Map` | `getMethodControlInfo()` Return info about a method's associated control.
`Set` | `getMethodPolicy(String methodName)` Returns the method authorization policy.
`ProcessNodeInfo[]` | `getNodes()` Returns an array of all the nodes in the process definition.
`ProcessNodeInfo[]` | `getNodes(int type)` Returns an array of nodes of a certain type.
`Set` | `getProcessPolicy()` Returns the process-level authorization policy.
`ProcessVariable` | `getProcessVariable(String varName)` Returns the type information for the given process variable.
`ProcessVariable[]` | `getProcessVariables()` Returns type information about process variables (excluding controls, callbacks, and other special variables).
`String` | `getPublicURI()` Returns the public URI of this process type.
`String` | `getRelativeEJBPath()` Returns the relative EJB path where the ejb for this process resides.
`String` | `getRunAs()` Returns the run-as attribute for this process.
`String` | `getServiceURI()` Returns the service of the process type represented by this MBean.
`URL` | `getServiceURL()` Returns the service URL for this process.
`long` | `getSLA()` Returns the SLA in milliseconds.
`double` | `getSLAWarningThreshold()` Returns the SLA warning threshold as fraction of the actual SLAin milliseconds.
`TrackingLevel` | `getTrackingLevel()` Returns the tracking level for this process.
`String` | `getTypeName()` Returns the type name (name of the class implementing this process).
`String` | `getWebappName()` Returns the name of the webapp where this process is deployed.
`boolean` | `hasDeclarativeAuthorization()` Returns true if: 1) there is a roles-allowed annotation at the class level, 2) there is a callback-roles-allowed annotation at the class level or, 3) there is a roles-allowed annotation on at least one method in this process.
`boolean` | `isExecutionPolicyModifiable()` Returns false if there is a common:security annotation on the jpd file, otherwise returns true.
`boolean` | `isRunnable()` Returns whether the process is runnable.
`boolean` | `isServiceExists()` Returns whether the process represented by this MBean has been compiled and a disp structure exists for it.
`boolean` | `isSinglePrincipalRequired()` Returns true iff this process requires that all incoming client requests come from the same principal.
`boolean` | `isStateless()` Returns whether the process is stateless.
`boolean` | `isVersioned()` Returns `true` if this process is part of a version group.
`void` | `resetState()` Re-initializes the MBean state.
`void` | `setActivationAttributes(boolean runnable, long activationTime, long deactivationTime)` Set all activation attributes for the process.
`void` | `setActivationTime(long time)` Set the activation time in seconds since 1/1/1970 GMT.
`void` | `setArchivingPolicy(ArchivingPolicy archivingPolicy)` Sets the archiving policy for this process type.
`void` | `setControlCallbackPolicy(String controlId, Set roles)` Sets the callback authorization policy for a given control.
`void` | `setDeactivationTime(long time)` Set the deactivation time in seconds since 1/1/1970 GMT.
`void` | `setDisplayName(String displayName)` Sets the display name.
`void` | `setMethodPolicy(String methodName, Set roles)` Sets the method authorization policy.
`void` | `setProcessPolicy(Set roles)` Sets the process-level authorization policy.
`void` | `setRunAs(String runAs)` Sets the run-as attribute for this process.
`void` | `setRunnable(boolean runnable)` Enable or disable process.
`void` | `setSinglePrincipalRequired(boolean flag)` Sets the single-principal flag for this process.
`void` | `setSLA(long sla)` Sets the SLA.
`void` | `setSLAWarningThreshold(double ratio)` Sets the SLA warning threshold.
`void` | `setTrackingLevel(TrackingLevel trackingLevel)` Sets the tracking level for this process type.

Methods inherited from interface weblogic.management.configuration.ConfigurationMBean
`freezeCurrentValue, getAttributeStringValue, getComments, getNotes, getSetFields, getXml, getXmlConverter, isDefaultedMBean, isPersistenceEnabled, preDeregister, registerConfigMBean, restoreDefaultValue, setComments, setDefaultedMBean, setNotes, setPersistenceEnabled, touch, unRegisterConfigMBean`

Methods inherited from interface weblogic.management.WebLogicMBean
`getMBeanInfo, getName, getObjectName, getParent, getType, isCachingDisabled, isRegistered, setName, setParent`

Methods inherited from interface javax.management.DynamicMBean
`getAttribute, getAttributes, invoke, setAttribute, setAttributes`

Methods inherited from interface javax.management.MBeanRegistration
`postDeregister, postRegister, preRegister`

Methods inherited from interface javax.management.NotificationBroadcaster
`addNotificationListener, getNotificationInfo, removeNotificationListener`

Field Detail

### CACHING_STUB_SVUID

    public static final long CACHING_STUB_SVUID

  The magic number that is used to generate the serialVersionUID of the generated MBean Stub (xxxMBean_Stub). You must change this value whenever you make one of the changes to this interface:

  - remove an existing method.
  - change the signature of an existing "getter" or "setter" method.
  - change the signature of an existing "boolean getter", i.e, "boolean isEnabled()"

  Otherwise you don't need to change this value. For instance you can add new methods, or you can change the signature of methods that don't start with "get", "set" or "is". If you are in doubt then change the SVUID. It is a good idea to increment this value when changing.

  See Also:
    Constant Field Values

Method Detail

### getServiceURI

    public String getServiceURI()

  Returns the service of the process type represented by this MBean.

### getServiceURL

    public URL getServiceURL()
                      throws ProcessNotFoundException

  Returns the service URL for this process.

  Throws:
    `ProcessNotFoundException`

### getSLA

    public long getSLA()
                throws javax.management.MBeanException

  Returns the SLA in milliseconds. A return value that is less than or equal to `0` indicates that SLA is not defined for this process type

  Throws:
    `javax.management.MBeanException`

### getSLAWarningThreshold

    public double getSLAWarningThreshold()
                                  throws javax.management.MBeanException

  Returns the SLA warning threshold as fraction of the actual SLAin milliseconds. A return value that is less than or equal to `0.0` indicates that SLA warning is not defined for this process type

  Throws:
    `javax.management.MBeanException`

### getDescription

    public String getDescription()
                          throws ProcessNotFoundException

  Returns the description for this process type. THis is the same as the description text entered for the top level node in the workshop.

  Throws:
    `ProcessNotFoundException` - if the process is not found

### getDisplayName

    public String getDisplayName()
                          throws javax.management.MBeanException

  Returns the display name. This is mainly used for pretty printing in the Console.

  Throws:
    `javax.management.MBeanException`

### getTrackingLevel

    public TrackingLevel getTrackingLevel()
                                   throws javax.management.MBeanException

  Returns the tracking level for this process.

  Throws:
    `javax.management.MBeanException`

### getArchivingPolicy

    public ArchivingPolicy getArchivingPolicy()
                                       throws javax.management.MBeanException

  Returns the archiving policy for this process.

  Throws:
    `javax.management.MBeanException`

### getAppName

    public String getAppName()
                      throws ProcessNotFoundException

  Returns the application name where this process is deployed.

  Throws:
    `ProcessNotFoundException` - if the process is not found

### getWebappName

    public String getWebappName()
                         throws ProcessNotFoundException

  Returns the name of the webapp where this process is deployed.

  Throws:
    `ProcessNotFoundException` - if the process is not found

### getRelativeEJBPath

    public String getRelativeEJBPath()
                              throws ProcessNotFoundException

  Returns the relative EJB path where the ejb for this process resides.

  Throws:
    `ProcessNotFoundException` - if the process is not found

### getTypeName

    public String getTypeName()
                       throws ProcessNotFoundException

  Returns the type name (name of the class implementing this process).

  Throws:
    `ProcessNotFoundException` - if the process is not found

### getProcessVariables

    public ProcessVariable[] getProcessVariables()
                                          throws javax.management.MBeanException,
                                                 ProcessNotFoundException

  Returns type information about process variables (excluding controls, callbacks, and other special variables).

  Throws:
    `ProcessNotFoundException` - if the process is not found
    `javax.management.MBeanException`

### getProcessVariable

    public ProcessVariable getProcessVariable(String varName)
                                       throws javax.management.MBeanException,
                                              ProcessNotFoundException

  Returns the type information for the given process variable.

  Parameters:
    `varName` - name of the variable
  Throws:
    `ProcessNotFoundException` - if the process is not found
    `javax.management.MBeanException`

### getFlowTag

    public String getFlowTag()
                      throws ProcessNotFoundException,
                             ProcessNotFoundException

  Returns the flow definiton in String format.

  Throws:
    `ProcessNotFoundException` - if the process is not found

### getPublicURI

    public String getPublicURI()

  Returns the public URI of this process type. If the process is a part of a version group then the group URI of the version group is returned. Otherwise the service URI is returned as the public URI

### setActivationAttributes

    public void setActivationAttributes(boolean runnable,
                                        long activationTime,
                                        long deactivationTime)

  Set all activation attributes for the process.

  Parameters:
    `runnable` - is this process runnable?
    `activationTime` - time from which the process will be active. (in seconds since 1/1/1970 GMT)
    `deactivationTime` - time at which the process cease to be active. (in seconds since 1/1/1970 GMT)

### getActivationTime

    public long getActivationTime()

  Return the activation time in seconds since 1/1/1970 GMT.

### setActivationTime

    public void setActivationTime(long time)

  Set the activation time in seconds since 1/1/1970 GMT.

  Parameters:
    `time` - time in seconds since 1/1/1970 GMT.

### getDeactivationTime

    public long getDeactivationTime()

  Returns the deactivation time in seconds since 1/1/1970 GMT.

  Returns:
    the deactivation time in seconds since 1/1/1970 GMT.

### setDeactivationTime

    public void setDeactivationTime(long time)

  Set the deactivation time in seconds since 1/1/1970 GMT.

  Parameters:
    `time` - deactivation time in seconds since 1/1/1970

### isRunnable

    public boolean isRunnable()

  Returns whether the process is runnable.

### setRunnable

    public void setRunnable(boolean runnable)

  Enable or disable process.

### isStateless

    public boolean isStateless()
                        throws ProcessNotFoundException

  Returns whether the process is stateless.

  Throws:
    `ProcessNotFoundException` - if the process is not found

### isVersioned

    public boolean isVersioned()

  Returns `true` if this process is part of a version group.

### isServiceExists

    public boolean isServiceExists()

  Returns whether the process represented by this MBean has been compiled and a disp structure exists for it.

### getNodes

    public ProcessNodeInfo[] getNodes()
                               throws ProcessNotFoundException

  Returns an array of all the nodes in the process definition.

  Throws:
    `ProcessNotFoundException` - if the process is not found

### getNodes

    public ProcessNodeInfo[] getNodes(int type)
                               throws ProcessNotFoundException

  Returns an array of nodes of a certain type.

  Parameters:
    `type` - the type of the nodes to be returned. Types are defined in `com.bea.wli.bpm.common.NodeTypes`
  Returns:
    an array of nodes of the given type. If there are no nodes of that type an empty array is returned.
  Throws:
    `ProcessNotFoundException` - if the process is not found

### setSLA

    public void setSLA(long sla)
                throws javax.management.MBeanException

  Sets the SLA.

  Parameters:
    `sla` - SLA in milliseconds. A value that is less than or equal to 0 unsets the SLA
  Throws:
    `javax.management.MBeanException`

### setSLAWarningThreshold

    public void setSLAWarningThreshold(double ratio)
                                throws javax.management.MBeanException

  Sets the SLA warning threshold.

  Parameters:
    `ratio` - SLA warning threshold as a fraction of actual SLA. A value that is less than or equal to 0 unsets the SLA warning.
  Throws:
    `javax.management.MBeanException`

### setDisplayName

    public void setDisplayName(String displayName)
                        throws javax.management.MBeanException

  Sets the display name. This can be any short descriptive name.

  Throws:
    `javax.management.MBeanException`

### setTrackingLevel

    public void setTrackingLevel(TrackingLevel trackingLevel)
                          throws javax.management.MBeanException,
                                 javax.management.InvalidAttributeValueException,
                                 ProcessNotFoundException

  Sets the tracking level for this process type.

  Parameters:
    `trackingLevel` - the new tracking level.
  Throws:
    `ProcessNotFoundException` - if the process is not found
    `javax.management.MBeanException`
    `javax.management.InvalidAttributeValueException`

### setArchivingPolicy

    public void setArchivingPolicy(ArchivingPolicy archivingPolicy)
                            throws javax.management.MBeanException,
                                   javax.management.InvalidAttributeValueException

  Sets the archiving policy for this process type.

  Parameters:
    `archivingPolicy` - the new archiving policy.
  Throws:
    `javax.management.MBeanException`
    `javax.management.InvalidAttributeValueException`

### getCallbackClassName

    public String getCallbackClassName()
                                throws ProcessNotFoundException

  Returns the class name for the client callback if there is any.

  Returns:
    callback class name, null if there is no callback
  Throws:
    `ProcessNotFoundException` - if the process is not found

### getMethodControlInfo

    public Map getMethodControlInfo()
                             throws ProcessNotFoundException

  Return info about a method's associated control. Currently only relevant for controlSend nodes. Used to get correct icon for process graph. Internal use only.

  Throws:
    `ProcessNotFoundException` - if the process is not found

### getDeploymentId

    public String getDeploymentId()
                           throws ProcessNotFoundException

  Return id which is different for each deployment of this process. Internal use only.

  Throws:
    `ProcessNotFoundException` - if the process is not found

### hasDeclarativeAuthorization

    public boolean hasDeclarativeAuthorization()
                                        throws ProcessNotFoundException

  Returns true if: 1) there is a roles-allowed annotation at the class level, 2) there is a callback-roles-allowed annotation at the class level or, 3) there is a roles-allowed annotation on at least one method in this process. Otherwise returns false. If the jpd file has declarative security then authorization policies cannot be set dynamically.

  Returns:
    true/false
  Throws:
    `ProcessNotFoundException` - if the process is not found

### getProcessPolicy

    public Set getProcessPolicy()
                         throws javax.management.MBeanException,
                                ProcessNotFoundException

  Returns the process-level authorization policy. The policy is a set of roles. A user is allowed to invoke an operation on the process if he belongs to at least one of those roles. This policy applies to all operations on the process, but individual methods can expand the policy by allowing additional roles, effectively relaxing restrictions (see `setMethodPolicy(java.lang.String, java.util.Set)`).

  Returns:
    an array of role names (the allowed roles), or an empty array if no process-level policy has been set.
  Throws:
    `ProcessNotFoundException` - if the process is not found
    `javax.management.MBeanException`

### setProcessPolicy

    public void setProcessPolicy(Set roles)
                          throws javax.management.MBeanException,
                                 ProcessNotFoundException

  Sets the process-level authorization policy. The policy is a set of roles. A user is allowed to invoke an operation on the process if he belongs to at least one of those roles. This policy applies to all operations on the process, but individual methods can expand the policy by allowing additional roles, effectively relaxing restrictions (see `setMethodPolicy(java.lang.String, java.util.Set)`). Calling this method with an empty array clears the process policy. If there are any roles-allowed annotations on the jpd file, authorization policies cannot be dynamically set. NOTE: when changing the process policy, any roles in the new process policy which were not present in the overwritten process policy are automatically added to all method policies. On the other hand, dropping roles from the process policy does not cause any side-effect on the method policies.

  Parameters:
    `roles` - an array of role names.
  Throws:
    `ProcessNotFoundException` - if the process is not found
    `javax.management.MBeanException` - if policies are read-only.

### getMethodPolicy

    public Set getMethodPolicy(String methodName)
                        throws javax.management.MBeanException,
                               ProcessNotFoundException,
                               NoSuchMethodException

  Returns the method authorization policy. The policy is a set of roles. If a method policy is specified, a user is allowed to invoke the method if he belongs to at least one of the roles. This method will return an empty array if no method-level policy has been set.

  Parameters:
    `methodName` -
  Returns:
    an array of role names (the allowed roles), or an empty array if no method-level policy has been set.
  Throws:
    `ProcessNotFoundException` - if the process is not found
    `NoSuchMethodException` - if there is no method by the given name.
    `javax.management.MBeanException`

### getInheritedPolicy

    public String getInheritedPolicy(String methodName)
                              throws javax.management.MBeanException,
                                     ProcessNotFoundException,
                                     NoSuchMethodException

  Returns the effective authorization policy expression for the given method when no policy has been explicitly assigned to the method.

  Parameters:
    `methodName` -
  Returns:
    a policy expression
  Throws:
    `ProcessNotFoundException` - if the process is not found
    `NoSuchMethodException` - if there is no method by the given name.
    `javax.management.MBeanException`

### setMethodPolicy

    public void setMethodPolicy(String methodName,
                                Set roles)
                         throws javax.management.MBeanException,
                                ProcessNotFoundException,
                                NoSuchMethodException

  Sets the method authorization policy. The policy is a set of roles. If there is a method policy, a user is allowed to invoke an operation on the process if he belongs to at least one of the roles. Note that if there is a process-level policy, all the roles in the process policy are added to the roles specified in this call to determine the actual method policy. Calling this method with an empty array clears the process policy (subject, of course, to the process policy). If there are any roles-allowed annotations on the jpd file, authorization policies cannot be dynamically set.

  Parameters:
    `methodName` -
    `roles` - an array of role names, or an empty array.
  Throws:
    `javax.management.MBeanException` - if policies are read-only
    `NoSuchMethodException` - or if there is no method by the given name.
    `ProcessNotFoundException` - if the process is not found

### getExternalCallbackControls

    public String[] getExternalCallbackControls()
                                         throws ProcessNotFoundException

  Returns the names of all controls in this process which are externall callback targets. These controls can have authorization policies assigned to their callbacks. Returns an empty array if there are no external callback target controls in this process.

  Returns:
    an array of control names.
  Throws:
    `ProcessNotFoundException` - if the process is not found

### getControlCallbackPolicy

    public Set getControlCallbackPolicy(String controlId)
                                 throws javax.management.MBeanException,
                                        ProcessNotFoundException

  Returns the callback authorization policy for a given control.

  Parameters:
    `controlId` - the id of an external callback target control on this process.
  Returns:
    the set of roles authorized at the control callback points.
  Throws:
    `ProcessNotFoundException` - if the process is not found
    `javax.management.MBeanException` - if there is any other error getting the policy

### setControlCallbackPolicy

    public void setControlCallbackPolicy(String controlId,
                                         Set roles)
                                  throws javax.management.MBeanException,
                                         ProcessNotFoundException

  Sets the callback authorization policy for a given control. If there are any roles-allowed annotations on the jpd file, authorization policies cannot be dynamically changed.

  Parameters:
    `controlId` - the id of an external callback target control on this process.
    `roles` - the set of roles authorized at the control callback points.
  Throws:
    `ProcessNotFoundException` - if the process is not found
    `javax.management.MBeanException` - if policies are read-only, or if there is no externall callback target control by the given controlId.

### isExecutionPolicyModifiable

    public boolean isExecutionPolicyModifiable()
                                        throws ProcessNotFoundException

  Returns false if there is a common:security annotation on the jpd file, otherwise returns true.

  Returns:
    true/false
  Throws:
    `ProcessNotFoundException` - if the process is not found

### getRunAs

    public String getRunAs()
                    throws javax.management.MBeanException,
                           ProcessNotFoundException

  Returns the run-as attribute for this process. This is either: <start-user>, null or a principal name. A null return value means invocations run under the caller's identity.

  Returns:
    the run-as attribute.
  Throws:
    `ProcessNotFoundException` - if the process is not found
    `javax.management.MBeanException`

### setRunAs

    public void setRunAs(String runAs)
                  throws javax.management.MBeanException,
                         ProcessNotFoundException

  Sets the run-as attribute for this process. A `null` argument represents the `"callers-identity"` execution policy (this is the default policy). Note that if there is a common:security annotation on the jpd file, then the run-as attribute is read-only and any attempt to call this method will throw an exception.

  Parameters:
    `runAs` - either "<start-user>", a WLS username or null.
  Throws:
    `ProcessNotFoundException` - if the process is not found
    `javax.management.MBeanException` - if the argument is invalid or if there is a common:security annotation in the jpd file.

### isSinglePrincipalRequired

    public boolean isSinglePrincipalRequired()
                                      throws javax.management.MBeanException,
                                             ProcessNotFoundException

  Returns true iff this process requires that all incoming client requests come from the same principal.

  Returns:
    true/flase
  Throws:
    `ProcessNotFoundException` - if the process is not found
    `javax.management.MBeanException`

### setSinglePrincipalRequired

    public void setSinglePrincipalRequired(boolean flag)
                                    throws javax.management.MBeanException,
                                           ProcessNotFoundException

  Sets the single-principal flag for this process. Note that this can only be set if it was not already set via an annotation on the jpd file.

  Parameters:
    `flag` - the new single-principal flag
  Throws:
    `ProcessNotFoundException` - if the process is not found
    `javax.management.MBeanException` - if there is already a single-principal annotation on the jpd.

### getB2BInboundFlag

    public boolean getB2BInboundFlag()
                              throws ProcessNotFoundException

  get flag on whether a process type whose instance will be started by a B2B(either ebXML or RN) message. Internal use only.

  Throws:
    `ProcessNotFoundException`

### getB2BOutboundFlag

    public boolean getB2BOutboundFlag()
                               throws ProcessNotFoundException

  get flag on whether a process type has a B2B(either ebXML or RN) control. Internal use only.

  Throws:
    `ProcessNotFoundException` - if the process is not found

### resetState

    public void resetState()
                    throws javax.management.MBeanException

  Re-initializes the MBean state. It is used only internally in development mode, when the MBean gets re-registered.

  Throws:
    `javax.management.MBeanException`

### getEjbModuleName

    public String getEjbModuleName()

  Returns the ejb module name for this jpd.

Overview | Package | Class | Tree | Deprecated | Index | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD