BundleManagerBean (RHQ Enterprise Server JAR 4.13.0 API)

java.lang.Object
- org.rhq.enterprise.server.bundle.BundleManagerBean

All Implemented Interfaces:

BundleManagerLocal, BundleManagerRemote
```
public class BundleManagerBean
extends Object
implements BundleManagerLocal, BundleManagerRemote
```
Manages the creation and usage of bundles.

Author:

John Mazzitelli, Ian Springer, Jay Shaughnessy

Constructor Summary

Constructors
Constructor and Description

BundleManagerBean()

Constructors
Constructor and Description
`BundleManagerBean()`

Method Summary

Methods
Modifier and Type	Method and Description
`void`	`_finalizePurge(org.rhq.core.domain.auth.Subject subject, org.rhq.core.domain.bundle.BundleDeployment bundleDeployment, Map<org.rhq.core.domain.bundle.BundleResourceDeployment,String> failedToPurge)` Internal use only
`org.rhq.core.domain.bundle.BundleFile`	`addBundleFile(org.rhq.core.domain.auth.Subject subject, int bundleVersionId, String name, String version, org.rhq.core.domain.content.Architecture architecture, InputStream fileStream)` Adds a BundleFile to the BundleVersion and implicitly creates the backing PackageVersion.
`org.rhq.core.domain.bundle.BundleFile`	`addBundleFileViaByteArray(org.rhq.core.domain.auth.Subject subject, int bundleVersionId, String name, String version, org.rhq.core.domain.content.Architecture architecture, byte[] fileBytes)` A convenience method taking a byte array as opposed to a stream for the file bits.
`org.rhq.core.domain.bundle.BundleFile`	`addBundleFileViaPackageVersion(org.rhq.core.domain.auth.Subject subject, int bundleVersionId, String name, int packageVersionId)` A convenience method taking an existing PackageVersion as opposed to a stream for the file bits.
`org.rhq.core.domain.bundle.BundleFile`	`addBundleFileViaURL(org.rhq.core.domain.auth.Subject subject, int bundleVersionId, String name, String version, org.rhq.core.domain.content.Architecture architecture, String bundleFileUrl)` A convenience method taking a URL String whose content will be streamed to the server and used for the file bits.
`org.rhq.core.domain.bundle.BundleFile`	`addBundleFileViaURL(org.rhq.core.domain.auth.Subject subject, int bundleVersionId, String name, String version, org.rhq.core.domain.content.Architecture architecture, String bundleFileUrl, String userName, String password)` A variant of `BundleManagerRemote.addBundleFileViaURL(Subject, int, String, String, Architecture, String)` supporting the HTTP basic authentication.
`org.rhq.core.domain.bundle.BundleResourceDeploymentHistory`	`addBundleResourceDeploymentHistoryInNewTrans(org.rhq.core.domain.auth.Subject subject, int resourceDeploymentId, org.rhq.core.domain.bundle.BundleResourceDeploymentHistory history)` Internal use only
`void`	`assignBundlesToBundleGroups(org.rhq.core.domain.auth.Subject subject, int[] bundleGroupIds, int[] bundleIds)` Assign the specified bundles to the specified bundle groups.
`org.rhq.core.domain.bundle.Bundle`	`createBundle(org.rhq.core.domain.auth.Subject subject, String name, String description, int bundleTypeId, int[] bundleGroupIds)` Internal use only, and test entry point.
`org.rhq.core.domain.bundle.BundleVersion`	`createBundleAndBundleVersion(org.rhq.core.domain.auth.Subject subject, String bundleName, String bundleDescription, int bundleTypeId, int[] bundleGroupIds, String bundleVersionName, String bundleVersionDescription, String version, String recipe)` Deprecated. since 4.13, see `BundleManagerLocal.createBundleAndBundleVersion(org.rhq.core.domain.auth.Subject, String, String, int, int[], String, String, String, String)`
`org.rhq.core.domain.bundle.BundleDeployment`	`createBundleDeployment(org.rhq.core.domain.auth.Subject subject, int bundleVersionId, int bundleDestinationId, String description, org.rhq.core.domain.configuration.Configuration configuration)` Create a new bundle deployment.
`org.rhq.core.domain.bundle.BundleDeployment`	`createBundleDeploymentInNewTrans(org.rhq.core.domain.auth.Subject subject, int bundleVersionId, int bundleDestinationId, String name, String description, org.rhq.core.domain.configuration.Configuration configuration)` Similar to `BundleManagerRemote.createBundleDeployment(Subject, int, int, String, Configuration)` but supplies the internally generated deploymentName and has different transaction semantics.
`org.rhq.core.domain.bundle.BundleDestination`	`createBundleDestination(org.rhq.core.domain.auth.Subject subject, int bundleId, String name, String description, String destinationSpecification, String deployDir, Integer groupId)` Creates a bundle destination that describes a target for the bundle deployments.
`org.rhq.core.domain.bundle.BundleGroup`	`createBundleGroup(org.rhq.core.domain.auth.Subject subject, org.rhq.core.domain.bundle.BundleGroup bundleGroup)` Create a new bundle group.
`org.rhq.core.domain.bundle.BundleResourceDeployment`	`createBundleResourceDeploymentInNewTrans(org.rhq.core.domain.auth.Subject subject, int bundleDeploymentId, int resourceId)` This is typically not called directly, typically scheduleBundleResourceDeployment() is called externally.
`org.rhq.core.domain.bundle.BundleType`	`createBundleType(org.rhq.core.domain.auth.Subject subject, String name, int resourceTypeId)` Not generally called.
`org.rhq.core.domain.bundle.BundleVersion`	`createBundleVersion(org.rhq.core.domain.auth.Subject subject, int bundleId, String name, String description, String version, String recipe)` Deprecated. since 4.13, see `BundleManagerLocal.createBundleVersion(org.rhq.core.domain.auth.Subject, int, String, String, String, String)`
`org.rhq.core.domain.bundle.BundleVersion`	`createBundleVersionInternal(org.rhq.core.domain.bundle.Bundle bundle, String name, String version, String description, String recipe, org.rhq.core.domain.configuration.definition.ConfigurationDefinition configurationDefinition)` Used internally for transaction demarcation purposes.
`org.rhq.core.domain.bundle.BundleVersion`	`createBundleVersionViaByteArray(org.rhq.core.domain.auth.Subject subject, byte[] fileBytes)` Creates a bundle version based on the actual bytes of a Bundle Distribution file.
`org.rhq.core.domain.bundle.BundleVersion`	`createBundleVersionViaContentHandle(org.rhq.core.domain.auth.Subject subject, String temporaryContentHandle)` Like `BundleManagerRemote.createBundleVersionViaFile(org.rhq.core.domain.auth.Subject, java.io.File)` except that this method takes a `temporaryContentHandle` as parameter instead of a file.
`org.rhq.core.domain.bundle.BundleVersion`	`createBundleVersionViaFile(org.rhq.core.domain.auth.Subject subject, File distributionFile)` Creates a bundle version based on a Bundle Distribution file.
`org.rhq.core.domain.bundle.BundleVersion`	`createBundleVersionViaRecipe(org.rhq.core.domain.auth.Subject subject, String recipe)` Creates a bundle version based on single recipe string.
`org.rhq.core.domain.bundle.BundleVersion`	`createBundleVersionViaURL(org.rhq.core.domain.auth.Subject subject, String distributionFileUrl)` Creates a bundle version based on a Bundle Distribution file.
`org.rhq.core.domain.bundle.BundleVersion`	`createBundleVersionViaURL(org.rhq.core.domain.auth.Subject subject, String distributionFileUrl, String username, String password)` A version of the `BundleManagerRemote.createBundleVersionViaURL(org.rhq.core.domain.auth.Subject, String)` that accepts a username and password for basic authentication on the HTTP URLs.
`org.rhq.core.domain.bundle.BundleVersion`	`createBundleVersionViaURLImpl(org.rhq.core.domain.auth.Subject subject, String distributionFileUrl, String username, String password, boolean mustBeInitialVersion, int[] initialBundleGroupIds)`
`org.rhq.core.domain.bundle.BundleVersion`	`createInitialBundleVersionViaByteArray(org.rhq.core.domain.auth.Subject subject, int[] bundleGroupIds, byte[] fileBytes)` Like #createBundleVersionViaByteArray except this method will assume this is a new bundle and is responsible for creating the bundle as well as the bundle version.
`org.rhq.core.domain.bundle.BundleVersion`	`createInitialBundleVersionViaContentHandle(org.rhq.core.domain.auth.Subject subject, int[] bundleGroupIds, String temporaryContentHandle)` Like `BundleManagerRemote.createInitialBundleVersionViaFile(org.rhq.core.domain.auth.Subject, int[], java.io.File)`, except that this method takes a `temporaryContentHandle` as parameter instead of a file.
`org.rhq.core.domain.bundle.BundleVersion`	`createInitialBundleVersionViaFile(org.rhq.core.domain.auth.Subject subject, int[] bundleGroupIds, File distributionFile)` Like #createBundleVersionViaFile except this method will assume this is a new bundle and is responsible for creating the bundle as well as the bundle version.
`org.rhq.core.domain.bundle.BundleVersion`	`createInitialBundleVersionViaRecipe(org.rhq.core.domain.auth.Subject subject, int[] bundleGroupIds, String recipe)` Like #createBundleVersionViaRecipe except this method will assume this is a new bundle and is responsible for creating the bundle as well as the bundle version.
`org.rhq.core.domain.bundle.BundleVersion`	`createInitialBundleVersionViaToken(org.rhq.core.domain.auth.Subject subject, int[] bundleGroupIds, String token)` This method exists solely to support the GUI's wizard workflow which always first tries to create a bundle version for an existing bundle, because it does not know whether this is an initial bundle version (only the server can figure that out after it cracks open the bundle distribution, parses the recipe, and looks for the bundle).
`org.rhq.core.domain.bundle.BundleVersion`	`createInitialBundleVersionViaURL(org.rhq.core.domain.auth.Subject subject, int[] bundleGroupIds, String distributionFileUrl)` Like #createBundleVersionViaURL except this method will assume this is a new bundle and is responsible for creating the bundle as well as the bundle version.
`org.rhq.core.domain.bundle.BundleVersion`	`createInitialBundleVersionViaURL(org.rhq.core.domain.auth.Subject subject, int[] bundleGroupIds, String distributionFileUrl, String username, String password)` Like #createBundleVersionViaURL except this method will assume this is a new bundle and is responsible for creating the bundle as well as the bundle version.
`org.rhq.core.domain.bundle.BundleVersion`	`createOrStoreBundleVersionViaFile(org.rhq.core.domain.auth.Subject subject, File distributionFile)` Like `BundleManagerRemote.createBundleVersionViaFile(Subject, File)` with one additional feature.
`org.rhq.core.domain.bundle.BundleVersion`	`createOrStoreBundleVersionViaURL(org.rhq.core.domain.auth.Subject subject, String distributionFileUrl, String username, String password)` Like `BundleManagerRemote.createBundleVersionViaURL(Subject, String, String, String)` with one additional feature.
`void`	`deleteBundle(org.rhq.core.domain.auth.Subject subject, int bundleId)` Remove everything associated with the Bundle with the exception of files laid down by related deployments.
`void`	`deleteBundleDeployment(org.rhq.core.domain.auth.Subject subject, int bundleDeploymentId)` Used by GUI.
`void`	`deleteBundleDestination(org.rhq.core.domain.auth.Subject subject, int destinationId)` Used by GUI.
`void`	`deleteBundleGroups(org.rhq.core.domain.auth.Subject subject, int[] bundleGroupIds)` Delete a bundle group.
`void`	`deleteBundles(org.rhq.core.domain.auth.Subject subject, int[] bundleIds)` Remove everything associated with the Bundles with the exception of files laid down by related deployments.
`void`	`deleteBundleVersion(org.rhq.core.domain.auth.Subject subject, int bundleVersionId, boolean deleteBundleIfEmpty)` Remove everything associated with the BundleVersion with the exception of files laid down by related deployments.
`org.rhq.core.domain.bundle.BundleDeploymentStatus`	`determineBundleDeploymentStatus(int bundleDeploymentId)` Determines (and updates) the deployment status of the provided bundle deployment based on the deployment statuses of the underlying resource deployments.
`org.rhq.core.domain.util.PageList<org.rhq.core.domain.bundle.BundleDeployment>`	`findBundleDeploymentsByCriteria(org.rhq.core.domain.auth.Subject subject, org.rhq.core.domain.criteria.BundleDeploymentCriteria criteria)` Return the `BundleDeployments` narrowed by the supplied Criteria.
`org.rhq.core.domain.util.PageList<org.rhq.core.domain.bundle.BundleDestination>`	`findBundleDestinationsByCriteria(org.rhq.core.domain.auth.Subject subject, org.rhq.core.domain.criteria.BundleDestinationCriteria criteria)` Return the `BundleDestinations` narrowed by the supplied Criteria.
`org.rhq.core.domain.util.PageList<org.rhq.core.domain.bundle.BundleFile>`	`findBundleFilesByCriteria(org.rhq.core.domain.auth.Subject subject, org.rhq.core.domain.criteria.BundleFileCriteria criteria)`
`org.rhq.core.domain.util.PageList<org.rhq.core.domain.bundle.BundleGroup>`	`findBundleGroupsByCriteria(org.rhq.core.domain.auth.Subject subject, org.rhq.core.domain.criteria.BundleGroupCriteria criteria)` Return the `BundleGroups` narrowed by the supplied Criteria.
`org.rhq.core.domain.util.PageList<org.rhq.core.domain.bundle.BundleResourceDeployment>`	`findBundleResourceDeploymentsByCriteria(org.rhq.core.domain.auth.Subject subject, org.rhq.core.domain.criteria.BundleResourceDeploymentCriteria criteria)` Note that this can involves permissions on bundles and resources.
`org.rhq.core.domain.util.PageList<org.rhq.core.domain.bundle.Bundle>`	`findBundlesByCriteria(org.rhq.core.domain.auth.Subject subject, org.rhq.core.domain.criteria.BundleCriteria criteria)` Return the `Bundles` narrowed by the supplied Criteria.
`org.rhq.core.domain.util.PageList<org.rhq.core.domain.bundle.composite.BundleWithLatestVersionComposite>`	`findBundlesWithLatestVersionCompositesByCriteria(org.rhq.core.domain.auth.Subject subject, org.rhq.core.domain.criteria.BundleCriteria criteria)`
`org.rhq.core.domain.util.PageList<org.rhq.core.domain.bundle.BundleVersion>`	`findBundleVersionsByCriteria(org.rhq.core.domain.auth.Subject subject, org.rhq.core.domain.criteria.BundleVersionCriteria criteria)`
`List<org.rhq.core.domain.bundle.BundleType>`	`getAllBundleTypes(org.rhq.core.domain.auth.Subject subject)`
`HashMap<String,Boolean>`	`getAllBundleVersionFilenames(org.rhq.core.domain.auth.Subject subject, int bundleVersionId)` Used by GUI
`org.rhq.core.domain.bundle.composite.BundleGroupAssignmentComposite`	`getAssignableBundleGroups(org.rhq.core.domain.auth.Subject subject, org.rhq.core.domain.auth.Subject assigningSubject, int bundleId)` For the calling subject determines which bundle groups to which the user can assign the bundle.
`String`	`getBundleDeploymentName(org.rhq.core.domain.auth.Subject subject, int bundleDestinationId, int bundleVersionId, int prevDeploymentId)` Used by GUI.
`List<org.rhq.core.domain.bundle.BundleResourceDeploymentHistory>`	`getBundleResourceDeploymentHistories(org.rhq.core.domain.auth.Subject subject, int resourceDeploymentId)` Used by the UI.
`org.rhq.core.domain.bundle.BundleType`	`getBundleType(org.rhq.core.domain.auth.Subject subject, String bundleTypeName)`
`Set<String>`	`getBundleVersionFilenames(org.rhq.core.domain.auth.Subject subject, int bundleVersionId, boolean withoutBundleFileOnly)` Determine the files required for a BundleVersion and return all of the filenames or optionally, just those that lack BundleFiles for the BundleVersion.
`org.rhq.core.domain.bundle.ResourceTypeBundleConfiguration`	`getResourceTypeBundleConfiguration(org.rhq.core.domain.auth.Subject subject, int compatGroupId)` Given the ID for a compatible group, this will return the bundle configuration metadata for that group's resource type.
`BundleScheduleRequest`	`getScheduleRequest(org.rhq.core.domain.auth.Subject subject, int resourceDeploymentId, boolean isCleanDeployment, boolean isRevert)` Internal use only.
`void`	`purgeBundleDestination(org.rhq.core.domain.auth.Subject subject, int bundleDestinationId)` Purges the destination's live deployment content from the remote platforms.
`org.rhq.core.domain.bundle.BundleDeployment`	`scheduleBundleDeployment(org.rhq.core.domain.auth.Subject subject, int bundleDeploymentId, boolean isCleanDeployment)` Deploy the bundle to the destination, as described in the provided deployment.
`org.rhq.core.domain.bundle.BundleDeployment`	`scheduleBundleDeploymentInNewTransaction(org.rhq.core.domain.auth.Subject subject, int bundleDeploymentId, boolean isCleanDeployment, boolean isRevert, Integer revertedDeploymentReplacedDeployment)` Internal use only.
`org.rhq.core.domain.bundle.BundleDeployment`	`scheduleRevertBundleDeployment(org.rhq.core.domain.auth.Subject subject, int bundleDestinationId, String deploymentDescription, boolean isCleanDeployment)` For the specified destination, revert from the current live deployment to the deployment it had replaced.
`org.rhq.core.domain.bundle.BundleResourceDeployment`	`setBundleResourceDeploymentStatusInNewTransaction(org.rhq.core.domain.auth.Subject subject, int resourceDeploymentId, org.rhq.core.domain.bundle.BundleDeploymentStatus status)` Internal use only.
`void`	`unassignBundlesFromBundleGroups(org.rhq.core.domain.auth.Subject subject, int[] bundleGroupIds, int[] bundleIds)` Unassign the specified bundles from the specified bundle groups.
`org.rhq.core.domain.bundle.BundleGroup`	`updateBundleGroup(org.rhq.core.domain.auth.Subject subject, org.rhq.core.domain.bundle.BundleGroup bundleGroup)` Updates an existing bundle group.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Constructor Detail
  - BundleManagerBean
```
public BundleManagerBean()
```
- Method Detail
  - getResourceTypeBundleConfiguration
```
public org.rhq.core.domain.bundle.ResourceTypeBundleConfiguration getResourceTypeBundleConfiguration(org.rhq.core.domain.auth.Subject subject,
                                                                                            int compatGroupId)
                                                                                              throws Exception
```
    Description copied from interface: BundleManagerRemote
    
    Given the ID for a compatible group, this will return the bundle configuration metadata for that group's resource type. User interfaces will need to use this method in order to find out if a) the group can be a target for a bundle deployment and/or b) what different destination base locations are supported by the group.
    
    Specified by:
    
    getResourceTypeBundleConfiguration in interface BundleManagerRemote
    
    Parameters:
    subject - the user making the request
    compatGroupId - the ID for a compatible group whose type's bundle config is to be returned
    
    Returns:
    the bundle configuration for the group's resource type
    
    Throws:
    
    Exception
  - addBundleResourceDeploymentHistoryInNewTrans
```
public org.rhq.core.domain.bundle.BundleResourceDeploymentHistory addBundleResourceDeploymentHistoryInNewTrans(org.rhq.core.domain.auth.Subject subject,
                                                                                                      int resourceDeploymentId,
                                                                                                      org.rhq.core.domain.bundle.BundleResourceDeploymentHistory history)
                                                                                                        throws Exception
```
    Description copied from interface: BundleManagerLocal
    
    Internal use only
    Called internally to add history when action is taken against a deployment. This executes in a New Transaction and supports deployBundle and Agent requests.
    This method performs NO AUTHZ!
    
    Specified by:
    
    addBundleResourceDeploymentHistoryInNewTrans in interface BundleManagerLocal
    
    resourceDeploymentId - id of the deployment appending the history record
    
    Returns:
    the persisted history
    
    Throws:
    
    Exception
  - getBundleResourceDeploymentHistories
```
public List<org.rhq.core.domain.bundle.BundleResourceDeploymentHistory> getBundleResourceDeploymentHistories(org.rhq.core.domain.auth.Subject subject,
                                                                                                    int resourceDeploymentId)
```
    Description copied from interface: BundleManagerLocal
    
    Used by the UI. Performs security checks.
    
    Specified by:
    
    getBundleResourceDeploymentHistories in interface BundleManagerLocal
    
    Parameters:
    subject - the caller
    resourceDeploymentId - id of the deployment
    
    Returns:
    the list of audit entities, or an empty list if the caller is not authorized to view this deployment.
  - createBundle
```
public org.rhq.core.domain.bundle.Bundle createBundle(org.rhq.core.domain.auth.Subject subject,
                                             String name,
                                             String description,
                                             int bundleTypeId,
                                             int[] bundleGroupIds)
                                               throws Exception
```
    Description copied from interface: BundleManagerLocal
    Internal use only, and test entry point.
```
 Required Permissions (same as createInitialBundleVersionXxx): Either:
 - Global.CREATE_BUNDLES and Global.VIEW_BUNDLES
 - Global.CREATE_BUNDLES and BundleGroup.VIEW_BUNDLES_IN_GROUP for bundle group BG
 - BundleGroup.CREATE_BUNDLES_IN_GROUP for bundle group BG
 
```
    Specified by:
    
    createBundle in interface BundleManagerLocal
    
    Parameters:
    subject - user that must have proper permissions
    name - not null or empty
    description - optional long description of the bundle
    bundleTypeId - valid bundleType
    bundleGroupIds - existing bundle groups for initial bundle assignment, null or 0 length for unassigned
    
    Returns:
    the persisted Bundle (id is assigned)
    
    Throws:
    
    Exception
  - createBundleDeploymentInNewTrans
```
public org.rhq.core.domain.bundle.BundleDeployment createBundleDeploymentInNewTrans(org.rhq.core.domain.auth.Subject subject,
                                                                           int bundleVersionId,
                                                                           int bundleDestinationId,
                                                                           String name,
                                                                           String description,
                                                                           org.rhq.core.domain.configuration.Configuration configuration)
                                                                             throws Exception
```
    Description copied from interface: BundleManagerLocal
    
    Similar to BundleManagerRemote.createBundleDeployment(Subject, int, int, String, Configuration) but supplies the internally generated deploymentName and has different transaction semantics. Useful when an slsb method needs to both create a deployment and schedules it prior to returning to an external caller.
    This method performs NO AUTHZ!
    
    Specified by:
    
    createBundleDeploymentInNewTrans in interface BundleManagerLocal
    
    Throws:
    
    Exception
  - createBundleDeployment
```
public org.rhq.core.domain.bundle.BundleDeployment createBundleDeployment(org.rhq.core.domain.auth.Subject subject,
                                                                 int bundleVersionId,
                                                                 int bundleDestinationId,
                                                                 String description,
                                                                 org.rhq.core.domain.configuration.Configuration configuration)
                                                                   throws Exception
```
    Description copied from interface: BundleManagerRemote
    Create a new bundle deployment. Note that bundle deployment names are generated by this call. This provides useful, uniform naming for display. An optional, custom description can be added. This call defines a deployment. The defined deployment can then be scheduled in a separate call.
```
 Required Permissions: Either:
 - Global.DEPLOY_BUNDLES and a view of the relevant bundle and a view of the relevant resource group (may involve multiple roles)
 - Resource.DEPLOY_BUNDLES_TO_GROUP and a view of the relevant bundle and a view of the relevant resource group (may involve multiple roles)
 
```
    Specified by:
    
    createBundleDeployment in interface BundleManagerRemote
    
    Parameters:
    subject - user that must have proper permissions
    bundleVersionId - the BundleVersion being deployed by this deployment
    bundleDestinationId - the BundleDestination for the deployment
    description - an optional longer description describing this deployment
    configuration - a Configuration (pojo) to be associated with this deployment. This is validated against the configuration definition provided by the bundle version.
    
    Returns:
    the persisted deployment
    
    Throws:
    
    Exception
  - createBundleDestination
```
public org.rhq.core.domain.bundle.BundleDestination createBundleDestination(org.rhq.core.domain.auth.Subject subject,
                                                                   int bundleId,
                                                                   String name,
                                                                   String description,
                                                                   String destinationSpecification,
                                                                   String deployDir,
                                                                   Integer groupId)
                                                                     throws Exception
```
    Description copied from interface: BundleManagerRemote
    Creates a bundle destination that describes a target for the bundle deployments.
```
 Required Permissions: Either:
 - Global.DEPLOY_BUNDLES and a view of the relevant bundle and a view of the relevant resource group (may involve multiple roles)
 - Resource.DEPLOY_BUNDLES_TO_GROUP and a view of the relevant bundle and a view of the relevant resource group (may involve multiple roles)
 
```
    Specified by:
    
    createBundleDestination in interface BundleManagerRemote
    
    Parameters:
    subject - user must have MANAGE_INVENTORY permission
    bundleId - the Bundle to be deployed to this Destination
    name - a name for this destination. not null or empty
    description - an optional longer description describing this destination
    destinationSpecification - The name of the destination location where the bundle will be deployed. deployDir is relative to the directory that this name refers to. This name isn't the directory itself, it refers to the named location as defined in the agent plugin's descriptor for the resource's type.
    deployDir - the root dir for deployments to this destination or null if the type of the bundle does not require it
    groupId - the target platforms for deployments to this destination
    
    Returns:
    the persisted destination
    
    Throws:
    
    Exception
  - getBundleDeploymentName
```
public String getBundleDeploymentName(org.rhq.core.domain.auth.Subject subject,
                             int bundleDestinationId,
                             int bundleVersionId,
                             int prevDeploymentId)
```
    Description copied from interface: BundleManagerLocal
    Used by GUI. Needed by the Bundle Deploy and Revert wizards GUI to generate a deployment name for display.
```
 Required Permissions: Either:
 - Global.DEPLOY_BUNDLES and a view of the relevant bundle and a view of the relevant resource group (may involve multiple roles)
 - Resource.DEPLOY_BUNDLES_TO_GROUP and a view of the relevant bundle and a view of the relevant resource group (may involve multiple roles)
 
```
    Specified by:
    
    getBundleDeploymentName in interface BundleManagerLocal
    
    bundleDestinationId - required
    bundleVersionId - required for progressive deployment, -1 for revert
    prevDeploymentId - required for revert deployment, -1 for progressive
    
    Returns:
  - createBundleType
```
public org.rhq.core.domain.bundle.BundleType createBundleType(org.rhq.core.domain.auth.Subject subject,
                                                     String name,
                                                     int resourceTypeId)
                                                       throws Exception
```
    Description copied from interface: BundleManagerLocal
    
    Not generally called. For use by Server Side Plugins when registering a Bundle Plugin.
    Required Permissions: - Global.CREATE_BUNDLES
    
    Specified by:
    
    createBundleType in interface BundleManagerLocal
    
    name - not null or empty
    resourceTypeId - id of the ResourceType that handles this BundleType
    
    Returns:
    the persisted BundleType (id is assigned)
    
    Throws:
    
    Exception
  - createBundleAndBundleVersion
```
@Deprecated
public org.rhq.core.domain.bundle.BundleVersion createBundleAndBundleVersion(org.rhq.core.domain.auth.Subject subject,
                                                                               String bundleName,
                                                                               String bundleDescription,
                                                                               int bundleTypeId,
                                                                               int[] bundleGroupIds,
                                                                               String bundleVersionName,
                                                                               String bundleVersionDescription,
                                                                               String version,
                                                                               String recipe)
                                                                      throws Exception
```
    Deprecated. since 4.13, see BundleManagerLocal.createBundleAndBundleVersion(org.rhq.core.domain.auth.Subject, String, String, int, int[], String, String, String, String)
    
    Description copied from interface: BundleManagerLocal
    Internal use only and test entry point. Convenience method that combines #createBundle(Subject, String, int) and #createBundleVersion(Subject, int, String, String, String). This will first check to see if a bundle with the given type/name exists - if it doesn't, it will be created. If it does, it will be reused. This will then create the bundle version that will be associated with the bundle that was created or found.
```
 Required Permissions (same as createInitialBundleVersionXxx): Either:
 - Global.CREATE_BUNDLES and Global.VIEW_BUNDLES
 - Global.CREATE_BUNDLES and BundleGroup.VIEW_BUNDLES_IN_GROUP for bundle group BG
 - BundleGroup.CREATE_BUNDLES_IN_GROUP for bundle group BG
 
```
    Specified by:
    
    createBundleAndBundleVersion in interface BundleManagerLocal
    
    Parameters:
    subject - user that must have proper permissions
    bundleName - name of the bundle to use (if not found, it will be created)
    bundleDescription - optional long description of the bundle
    bundleTypeId - the bundle type for the new bundle (if it is created) for which this will be the first version
    bundleGroupIds - the bundle groups for the new bundle (if it is created) for which this will be the first version. null to leave unassigned.
    bundleVersionName - name of the bundle version
    bundleVersionDescription - optional long description of the bundle version
    version - optional. If not supplied set to 1.0 for first version, or incremented (as best as possible) for subsequent version
    
    Returns:
    the persisted BundleVersion (id is assigned)
    
    Throws:
    
    Exception
  - createBundleVersion
```
@Deprecated
public org.rhq.core.domain.bundle.BundleVersion createBundleVersion(org.rhq.core.domain.auth.Subject subject,
                                                                      int bundleId,
                                                                      String name,
                                                                      String description,
                                                                      String version,
                                                                      String recipe)
                                                             throws Exception
```
    Deprecated. since 4.13, see BundleManagerLocal.createBundleVersion(org.rhq.core.domain.auth.Subject, int, String, String, String, String)
    
    Description copied from interface: BundleManagerLocal
    Internal use only, test entry point
```
 Required Permissions: Either:
 - Global.CREATE_BUNDLES and Global.VIEW_BUNDLES
 - Global.CREATE_BUNDLES and BundleGroup.VIEW_BUNDLES_IN_GROUP for bundle group BG and the relevant bundle is assigned to BG
 - BundleGroup.CREATE_BUNDLES_IN_GROUP for bundle group BG and the relevant bundle is assigned to BG
 
```
    Specified by:
    
    createBundleVersion in interface BundleManagerLocal
    
    Parameters:
    subject - user that must have proper permissions
    bundleId - the bundle for which this will be the next version
    name - not null or empty
    description - optional long description of the bundle version
    version - optional. If not supplied set to 1.0 for first version, or incremented (as best as possible) for subsequent version
    
    Returns:
    the persisted BundleVersion (id is assigned)
    
    Throws:
    
    Exception
  - createBundleVersionInternal
```
public org.rhq.core.domain.bundle.BundleVersion createBundleVersionInternal(org.rhq.core.domain.bundle.Bundle bundle,
                                                                   String name,
                                                                   String version,
                                                                   String description,
                                                                   String recipe,
                                                                   org.rhq.core.domain.configuration.definition.ConfigurationDefinition configurationDefinition)
                                                                     throws Exception
```
    Description copied from interface: BundleManagerLocal
    
    Used internally for transaction demarcation purposes.
    
    Specified by:
    
    createBundleVersionInternal in interface BundleManagerLocal
    
    Parameters:
    bundle - the bundle to create version of
    name - the name of the bundle version
    version - the version of the bundle version
    description - the description of the bundle version
    recipe - the recipe of the bundle version
    configurationDefinition - the configuration definition of the deployment properties
    
    Returns:
    the created bundle version
    
    Throws:
    
    Exception - on error
  - createBundleVersionViaRecipe
```
public org.rhq.core.domain.bundle.BundleVersion createBundleVersionViaRecipe(org.rhq.core.domain.auth.Subject subject,
                                                                    String recipe)
                                                                      throws Exception
```
    Description copied from interface: BundleManagerRemote
    Creates a bundle version based on single recipe string. The recipe specifies the bundle name, version, version name and version description. If this is the initial version for the named bundle the bundle will be implicitly created. The bundle type is discovered by the bundle server plugin that can parse the recipe.
    If this bundle version is the initial version of a new bundle that needs to be created, the subject must have Global.VIEW_BUNDLES because the new bundle will not be associated with any bundle group.
```
 Required Permissions: Either:
 - Global.CREATE_BUNDLES and Global.VIEW_BUNDLES
 - Global.CREATE_BUNDLES and BundleGroup.VIEW_BUNDLES_IN_GROUP for bundle group BG and the relevant bundle is assigned to BG
 - BundleGroup.CREATE_BUNDLES_IN_GROUP for bundle group BG and the relevant bundle is assigned to BG
 
```
    Specified by:
    
    createBundleVersionViaRecipe in interface BundleManagerRemote
    
    Parameters:
    subject - user that must have proper permissions
    recipe - the recipe that defines the bundle version to be created
    
    Returns:
    the persisted BundleVersion with alot of the internal relationships filled in to help the caller understand all that this method did.
    
    Throws:
    
    Exception
  - createInitialBundleVersionViaRecipe
```
public org.rhq.core.domain.bundle.BundleVersion createInitialBundleVersionViaRecipe(org.rhq.core.domain.auth.Subject subject,
                                                                           int[] bundleGroupIds,
                                                                           String recipe)
                                                                             throws Exception
```
    Description copied from interface: BundleManagerRemote
    Like #createBundleVersionViaRecipe except this method will assume this is a new bundle and is responsible for creating the bundle as well as the bundle version. The caller can indicate which bundle groups the new bundle should be assigned to. If bundleGroupIds is null, then the new bundle will not be associated with any bundle group - this is only allowed if the caller has the permission Global.VIEW_BUNDLES.
```
 Required Permissions: Either:
 - Global.CREATE_BUNDLES and Global.VIEW_BUNDLES
 - Global.CREATE_BUNDLES and BundleGroup.VIEW_BUNDLES_IN_GROUP for bundle group BG
 - BundleGroup.CREATE_BUNDLES_IN_GROUP for bundle group BG
 
```
    Specified by:
    
    createInitialBundleVersionViaRecipe in interface BundleManagerRemote
    
    Parameters:
    subject - user that must have proper permissions
    bundleGroupIds - identifies the bundle groups that the new bundle will be associated with; null or zero length to leave unassigned.
    recipe - the recipe that defines the bundle version to be created
    
    Returns:
    the persisted BundleVersion with alot of the internal relationships filled in to help the caller understand all that this method did.
    
    Throws:
    
    Exception
  - createBundleVersionViaFile
```
public org.rhq.core.domain.bundle.BundleVersion createBundleVersionViaFile(org.rhq.core.domain.auth.Subject subject,
                                                                  File distributionFile)
                                                                    throws Exception
```
    Description copied from interface: BundleManagerRemote
    Creates a bundle version based on a Bundle Distribution file. Typically a zip file, the bundle distribution contains the recipe for a supported bundle type, along with 0, 1 or more bundle files that will be associated with the bundle version. The recipe specifies the bundle name, version, version name and version description. If this is the initial version for the named bundle the bundle will be implicitly created. The bundle type is discovered by inspecting the distribution file.
    If this bundle version is the initial version of a new bundle that needs to be created, the subject must have Global.VIEW_BUNDLES because the new bundle will not be associated with any bundle group.
```
 Required Permissions: Either:
 - Global.CREATE_BUNDLES and Global.VIEW_BUNDLES
 - Global.CREATE_BUNDLES and BundleGroup.VIEW_BUNDLES_IN_GROUP for bundle group BG and the relevant bundle is assigned to BG
 - BundleGroup.CREATE_BUNDLES_IN_GROUP for bundle group BG and the relevant bundle is assigned to BG
 
```
    Specified by:
    
    createBundleVersionViaFile in interface BundleManagerRemote
    
    Parameters:
    subject - user that must have proper permissions
    distributionFile - a local Bundle Distribution file. It must be read accessible by the RHQ server process.
    
    Returns:
    the persisted BundleVersion with a lot of the internal relationships filled in to help the caller understand all that this method did. Bundle files specifically are returned.
    
    Throws:
    
    Exception
  - createBundleVersionViaContentHandle
```
public org.rhq.core.domain.bundle.BundleVersion createBundleVersionViaContentHandle(org.rhq.core.domain.auth.Subject subject,
                                                                           String temporaryContentHandle)
                                                                             throws Exception
```
    Description copied from interface: BundleManagerRemote
    
    Like BundleManagerRemote.createBundleVersionViaFile(org.rhq.core.domain.auth.Subject, java.io.File) except that this method takes a temporaryContentHandle as parameter instead of a file.
    
    Specified by:
    
    createBundleVersionViaContentHandle in interface BundleManagerRemote
    
    Parameters:
    subject - user that must have proper permissions
    
    Returns:
    the persisted BundleVersion with a lot of the internal relationships filled in to help the caller understand all that this method did. Bundle files specifically are returned.
    
    Throws:
    
    Exception
    See Also:
    ContentManagerRemote.createTemporaryContentHandle(), ContentManagerRemote.uploadContentFragment(String, byte[], int, int), BundleManagerRemote.createBundleVersionViaFile(org.rhq.core.domain.auth.Subject, java.io.File)
  - createOrStoreBundleVersionViaFile
```
public org.rhq.core.domain.bundle.BundleVersion createOrStoreBundleVersionViaFile(org.rhq.core.domain.auth.Subject subject,
                                                                         File distributionFile)
                                                                           throws Exception
```
    Description copied from interface: BundleManagerLocal
    
    Like BundleManagerRemote.createBundleVersionViaFile(Subject, File) with one additional feature. This method exists solely to support the GUI's wizard workflow which always first tries to create a bundle version for an existing bundle, because it does not know whether this is an initial bundle version (only the server can figure that out after it cracks open the bundle distribution, parses the recipe, and looks for the bundle). If this is an initialBundleVersion this method does two things. First, it stores the distribution file as a temp file, this is done to avoid having to upload the file a second time. Second, it throws IllegalStateException with special message text, a token that can be sent back to BundleManagerLocal.createInitialBundleVersionViaToken(Subject, int[], String).
    
    Specified by:
    
    createOrStoreBundleVersionViaFile in interface BundleManagerLocal
    
    Throws:
    
    Exception
  - createInitialBundleVersionViaFile
```
public org.rhq.core.domain.bundle.BundleVersion createInitialBundleVersionViaFile(org.rhq.core.domain.auth.Subject subject,
                                                                         int[] bundleGroupIds,
                                                                         File distributionFile)
                                                                           throws Exception
```
    Description copied from interface: BundleManagerRemote
    Like #createBundleVersionViaFile except this method will assume this is a new bundle and is responsible for creating the bundle as well as the bundle version. The caller can indicate which bundle groups the new bundle should be assigned to. If bundleGroupIds is null, then the new bundle will not be associated with any bundle group - this is only allowed if the caller has the permission Global.VIEW_BUNDLES.
```
 Required Permissions: Either:
 - Global.CREATE_BUNDLES and Global.VIEW_BUNDLES
 - Global.CREATE_BUNDLES and BundleGroup.VIEW_BUNDLES_IN_GROUP for bundle group BG
 - BundleGroup.CREATE_BUNDLES_IN_GROUP for bundle group BG
 
```
    Specified by:
    
    createInitialBundleVersionViaFile in interface BundleManagerRemote
    
    Parameters:
    subject - user that must have proper permissions
    bundleGroupIds - identifies the bundle groups that the new bundle will be associated with; null or zero length to leave unassigned.
    distributionFile - a local Bundle Distribution file. It must be read accessible by the RHQ server process.
    
    Returns:
    the persisted BundleVersion with a lot of the internal relationships filled in to help the caller understand all that this method did. Bundle files specifically are returned.
    
    Throws:
    
    Exception
  - createInitialBundleVersionViaContentHandle
```
public org.rhq.core.domain.bundle.BundleVersion createInitialBundleVersionViaContentHandle(org.rhq.core.domain.auth.Subject subject,
                                                                                  int[] bundleGroupIds,
                                                                                  String temporaryContentHandle)
                                                                                    throws Exception
```
    Description copied from interface: BundleManagerRemote
    
    Like BundleManagerRemote.createInitialBundleVersionViaFile(org.rhq.core.domain.auth.Subject, int[], java.io.File), except that this method takes a temporaryContentHandle as parameter instead of a file.
    
    Specified by:
    
    createInitialBundleVersionViaContentHandle in interface BundleManagerRemote
    
    Parameters:
    subject - user that must have proper permissions
    bundleGroupIds - identifies the bundle groups that the new bundle will be associated with; null or zero length to leave unassigned.
    
    Returns:
    the persisted BundleVersion with a lot of the internal relationships filled in to help the caller understand all that this method did. Bundle files specifically are returned.
    
    Throws:
    
    Exception
    See Also:
    ContentManagerRemote.createTemporaryContentHandle(), ContentManagerRemote.uploadContentFragment(String, byte[], int, int), BundleManagerRemote.createInitialBundleVersionViaFile(org.rhq.core.domain.auth.Subject, int[], java.io.File)
  - createBundleVersionViaByteArray
```
public org.rhq.core.domain.bundle.BundleVersion createBundleVersionViaByteArray(org.rhq.core.domain.auth.Subject subject,
                                                                       byte[] fileBytes)
                                                                         throws Exception
```
    Description copied from interface: BundleManagerRemote
    Creates a bundle version based on the actual bytes of a Bundle Distribution file. This is essentially the same as BundleManagerRemote.createBundleVersionViaFile(Subject, File) but the caller is providing the actual bytes of the file as opposed to the file itself. WARNING: obviously, this requires the entire distribution file to have been loaded fully in memory. For very large distribution files, this could cause OutOfMemoryErrors.
    If this bundle version is the initial version of a new bundle that needs to be created, the subject must have Global.VIEW_BUNDLES because the new bundle will not be associated with any bundle group.
```
 Required Permissions: Either:
 - Global.CREATE_BUNDLES and Global.VIEW_BUNDLES
 - Global.CREATE_BUNDLES and BundleGroup.VIEW_BUNDLES_IN_GROUP for bundle group BG and the relevant bundle is assigned to BG
 - BundleGroup.CREATE_BUNDLES_IN_GROUP for bundle group BG and the relevant bundle is assigned to BG
 
```
    Specified by:
    
    createBundleVersionViaByteArray in interface BundleManagerRemote
    
    Parameters:
    subject - user that must have proper permissions
    fileBytes - the file bits that make up the entire bundle distribution file
    
    Returns:
    the persisted BundleVersion with a lot of the internal relationships filled in to help the caller understand all that this method did. Bundle files specifically are returned.
    
    Throws:
    
    Exception
  - createInitialBundleVersionViaByteArray
```
public org.rhq.core.domain.bundle.BundleVersion createInitialBundleVersionViaByteArray(org.rhq.core.domain.auth.Subject subject,
                                                                              int[] bundleGroupIds,
                                                                              byte[] fileBytes)
                                                                                throws Exception
```
    Description copied from interface: BundleManagerRemote
    Like #createBundleVersionViaByteArray except this method will assume this is a new bundle and is responsible for creating the bundle as well as the bundle version. The caller can indicate which bundle groups the new bundle should be assigned to. If bundleGroupIds is null, then the new bundle will not be associated with any bundle group - this is only allowed if the caller has the permission Global.VIEW_BUNDLES.
```
 Required Permissions: Either:
 - Global.CREATE_BUNDLES and Global.VIEW_BUNDLES
 - Global.CREATE_BUNDLES and BundleGroup.VIEW_BUNDLES_IN_GROUP for bundle group BG
 - BundleGroup.CREATE_BUNDLES_IN_GROUP for bundle group BG
 
```
    Specified by:
    
    createInitialBundleVersionViaByteArray in interface BundleManagerRemote
    
    Parameters:
    subject - user that must have proper permissions
    bundleGroupIds - identifies the bundle groups that the new bundle will be associated with; null or zero length to leave unassigned.
    fileBytes - the file bits that make up the entire bundle distribution file
    
    Returns:
    the persisted BundleVersion with a lot of the internal relationships filled in to help the caller understand all that this method did. Bundle files specifically are returned.
    
    Throws:
    
    Exception
  - createBundleVersionViaURL
```
public org.rhq.core.domain.bundle.BundleVersion createBundleVersionViaURL(org.rhq.core.domain.auth.Subject subject,
                                                                 String distributionFileUrl)
                                                                   throws Exception
```
    Description copied from interface: BundleManagerRemote
    Creates a bundle version based on a Bundle Distribution file. Typically a zip file, the bundle distribution contains the recipe for a supported bundle type, along with 0, 1 or more bundle files that will be associated with the bundle version. The recipe specifies the bundle name, version, version name and version description. If this is the initial version for the named bundle the bundle will be implicitly created. The bundle type is discovered by inspecting the distribution file.
    
    Note, if the file is local it is more efficient to use BundleManagerRemote.createBundleVersionViaFile(Subject,File).
    If this bundle version is the initial version of a new bundle that needs to be created, the subject must have Global.VIEW_BUNDLES because the new bundle will not be associated with any bundle group.
```
 Required Permissions: Either:
 - Global.CREATE_BUNDLES and Global.VIEW_BUNDLES
 - Global.CREATE_BUNDLES and BundleGroup.VIEW_BUNDLES_IN_GROUP for bundle group BG and the relevant bundle is assigned to BG
 - BundleGroup.CREATE_BUNDLES_IN_GROUP for bundle group BG and the relevant bundle is assigned to BG
 
```
    Specified by:
    
    createBundleVersionViaURL in interface BundleManagerRemote
    
    Parameters:
    subject - user that must have proper permissions
    distributionFileUrl - a URL String to the Bundle Distribution file. It must be live, resolvable and read accessible by the RHQ server process.
    
    Returns:
    the persisted BundleVersion with a lot of the internal relationships filled in to help the caller understand all that this method did. Bundle files specifically are returned.
    
    Throws:
    
    Exception
  - createBundleVersionViaURL
```
public org.rhq.core.domain.bundle.BundleVersion createBundleVersionViaURL(org.rhq.core.domain.auth.Subject subject,
                                                                 String distributionFileUrl,
                                                                 String username,
                                                                 String password)
                                                                   throws Exception
```
    Description copied from interface: BundleManagerRemote
    A version of the BundleManagerRemote.createBundleVersionViaURL(org.rhq.core.domain.auth.Subject, String) that accepts a username and password for basic authentication on the HTTP URLs.
    If this bundle version is the initial version of a new bundle that needs to be created, the subject must have Global.VIEW_BUNDLES because the new bundle will not be associated with any bundle group.
```
 Required Permissions: Either:
 - Global.CREATE_BUNDLES and Global.VIEW_BUNDLES
 - Global.CREATE_BUNDLES and BundleGroup.VIEW_BUNDLES_IN_GROUP for bundle group BG and the relevant bundle is assigned to BG
 - BundleGroup.CREATE_BUNDLES_IN_GROUP for bundle group BG and the relevant bundle is assigned to BG
 
```
    Specified by:
    
    createBundleVersionViaURL in interface BundleManagerRemote
    
    Parameters:
    subject - user that must have proper permissions
    
    Returns:
    the persisted BundleVersion with a lot of the internal relationships filled in to help the caller understand all that this method did. Bundle files specifically are returned.
    
    Throws:
    
    Exception
    See Also:
    BundleManagerRemote.createBundleVersionViaURL(org.rhq.core.domain.auth.Subject, String)
  - createInitialBundleVersionViaURL
```
public org.rhq.core.domain.bundle.BundleVersion createInitialBundleVersionViaURL(org.rhq.core.domain.auth.Subject subject,
                                                                        int[] bundleGroupIds,
                                                                        String distributionFileUrl)
                                                                          throws Exception
```
    Description copied from interface: BundleManagerRemote
    Like #createBundleVersionViaURL except this method will assume this is a new bundle and is responsible for creating the bundle as well as the bundle version. The caller can indicate which bundle groups the new bundle should be assigned to. If bundleGroupIds is null, then the new bundle will not be associated with any bundle group - this is only allowed if the caller has the permission Global.VIEW_BUNDLES.
```
 Required Permissions: Either:
 - Global.CREATE_BUNDLES and Global.VIEW_BUNDLES
 - Global.CREATE_BUNDLES and BundleGroup.VIEW_BUNDLES_IN_GROUP for bundle group BG
 - BundleGroup.CREATE_BUNDLES_IN_GROUP for bundle group BG
 
```
    Specified by:
    
    createInitialBundleVersionViaURL in interface BundleManagerRemote
    
    Parameters:
    subject - user that must have proper permissions
    bundleGroupIds - identifies the bundle groups that the new bundle will be associated with; null or zero length to leave unassigned.
    distributionFileUrl - a URL String to the Bundle Distribution file. It must be live, resolvable and read accessible by the RHQ server process.
    
    Returns:
    the persisted BundleVersion with a lot of the internal relationships filled in to help the caller understand all that this method did. Bundle files specifically are returned.
    
    Throws:
    
    Exception
  - createInitialBundleVersionViaURL
```
public org.rhq.core.domain.bundle.BundleVersion createInitialBundleVersionViaURL(org.rhq.core.domain.auth.Subject subject,
                                                                        int[] bundleGroupIds,
                                                                        String distributionFileUrl,
                                                                        String username,
                                                                        String password)
                                                                          throws Exception
```
    Description copied from interface: BundleManagerRemote
    Like #createBundleVersionViaURL except this method will assume this is a new bundle and is responsible for creating the bundle as well as the bundle version. The caller can indicate which bundle groups the new bundle should be assigned to. If bundleGroupIds is null, then the new bundle will not be associated with any bundle group - this is only allowed if the caller has the permission Global.VIEW_BUNDLES.
```
 Required Permissions: Either:
 - Global.CREATE_BUNDLES and Global.VIEW_BUNDLES
 - Global.CREATE_BUNDLES and BundleGroup.VIEW_BUNDLES_IN_GROUP for bundle group BG
 - BundleGroup.CREATE_BUNDLES_IN_GROUP for bundle group BG
 
```
    Specified by:
    
    createInitialBundleVersionViaURL in interface BundleManagerRemote
    
    Parameters:
    subject - user that must have proper permissions
    bundleGroupIds - identifies the bundle groups that the new bundle will be associated with; null or zero length to leave unassigned.
    
    Returns:
    the persisted BundleVersion with a lot of the internal relationships filled in to help the caller understand all that this method did. Bundle files specifically are returned.
    
    Throws:
    
    Exception
    See Also:
    BundleManagerRemote.createBundleVersionViaURL(org.rhq.core.domain.auth.Subject, String)
  - createBundleVersionViaURLImpl
```
public org.rhq.core.domain.bundle.BundleVersion createBundleVersionViaURLImpl(org.rhq.core.domain.auth.Subject subject,
                                                                     String distributionFileUrl,
                                                                     String username,
                                                                     String password,
                                                                     boolean mustBeInitialVersion,
                                                                     int[] initialBundleGroupIds)
                                                                       throws Exception
```
    Throws:
    
    Exception
  - createOrStoreBundleVersionViaURL
```
public org.rhq.core.domain.bundle.BundleVersion createOrStoreBundleVersionViaURL(org.rhq.core.domain.auth.Subject subject,
                                                                        String distributionFileUrl,
                                                                        String username,
                                                                        String password)
                                                                          throws Exception
```
    Description copied from interface: BundleManagerLocal
    
    Like BundleManagerRemote.createBundleVersionViaURL(Subject, String, String, String) with one additional feature. This method exists solely to support the GUI's wizard workflow which always first tries to create a bundle version for an existing bundle, because it does not know whether this is an initial bundle version (only the server can figure that out after it cracks open the bundle distribution, parses the recipe, and looks for the bundle). If this is an initialBundleVersion this method does two things. First, it stores the distribution file as a temp file, this is done to avoid having to upload the file a second time. Second, it throws IllegalStateException with special message text, a token that can be sent back to BundleManagerLocal.createInitialBundleVersionViaToken(Subject, int[], String).
    
    Specified by:
    
    createOrStoreBundleVersionViaURL in interface BundleManagerLocal
    
    Throws:
    
    Exception
  - addBundleFile
```
public org.rhq.core.domain.bundle.BundleFile addBundleFile(org.rhq.core.domain.auth.Subject subject,
                                                  int bundleVersionId,
                                                  String name,
                                                  String version,
                                                  org.rhq.core.domain.content.Architecture architecture,
                                                  InputStream fileStream)
                                                    throws Exception
```
    Description copied from interface: BundleManagerRemote
    Adds a BundleFile to the BundleVersion and implicitly creates the backing PackageVersion. If the PackageVersion already exists use BundleManagerRemote.addBundleFileViaPackageVersion(Subject, int, String, int)
```
 Required Permissions: Either:
 - Global.CREATE_BUNDLES and Global.VIEW_BUNDLES
 - Global.CREATE_BUNDLES and BundleGroup.VIEW_BUNDLES_IN_GROUP for bundle group BG and the relevant bundle is assigned to BG
 - BundleGroup.CREATE_BUNDLES_IN_GROUP for bundle group BG and the relevant bundle is assigned to BG
 
```
    Specified by:
    
    addBundleFile in interface BundleManagerRemote
    
    Parameters:
    subject - user that must have proper permissions
    bundleVersionId - id of the BundleVersion incorporating this BundleFile
    name - name of the BundleFile (and the resulting Package)
    version - version of the backing package
    architecture - architecture appropriate for the backing package. Defaults to noarch (i.e. any architecture).
    fileStream - the file bits
    
    Returns:
    the new BundleFile
    
    Throws:
    
    Exception
  - addBundleFileViaByteArray
```
public org.rhq.core.domain.bundle.BundleFile addBundleFileViaByteArray(org.rhq.core.domain.auth.Subject subject,
                                                              int bundleVersionId,
                                                              String name,
                                                              String version,
                                                              org.rhq.core.domain.content.Architecture architecture,
                                                              byte[] fileBytes)
                                                                throws Exception
```
    Description copied from interface: BundleManagerRemote
    A convenience method taking a byte array as opposed to a stream for the file bits. WARNING: obviously, this requires the entire bundle file to have been loaded fully in memory. For very large files, this could cause OutOfMemoryErrors.
```
 Required Permissions: Either:
 - Global.CREATE_BUNDLES and Global.VIEW_BUNDLES
 - Global.CREATE_BUNDLES and BundleGroup.VIEW_BUNDLES_IN_GROUP for bundle group BG and the relevant bundle is assigned to BG
 - BundleGroup.CREATE_BUNDLES_IN_GROUP for bundle group BG and the relevant bundle is assigned to BG
 
```
    Specified by:
    
    addBundleFileViaByteArray in interface BundleManagerRemote
    
    Parameters:
    subject - user that must have proper permissions
    bundleVersionId - id of the BundleVersion incorporating this BundleFile
    name - name of the BundleFile (and the resulting Package)
    version - version of the backing package
    architecture - architecture appropriate for the backing package. Defaults to noarch (i.e. any architecture).
    
    Returns:
    the new BundleFile
    
    Throws:
    
    Exception
    See Also:
    #addBundleFile(Subject, int, String, String, Architecture, InputStream)}
  - addBundleFileViaURL
```
public org.rhq.core.domain.bundle.BundleFile addBundleFileViaURL(org.rhq.core.domain.auth.Subject subject,
                                                        int bundleVersionId,
                                                        String name,
                                                        String version,
                                                        org.rhq.core.domain.content.Architecture architecture,
                                                        String bundleFileUrl)
                                                          throws Exception
```
    Description copied from interface: BundleManagerRemote
    A convenience method taking a URL String whose content will be streamed to the server and used for the file bits.
```
 Required Permissions: Either:
 - Global.CREATE_BUNDLES and Global.VIEW_BUNDLES
 - Global.CREATE_BUNDLES and BundleGroup.VIEW_BUNDLES_IN_GROUP for bundle group BG and the relevant bundle is assigned to BG
 - BundleGroup.CREATE_BUNDLES_IN_GROUP for bundle group BG and the relevant bundle is assigned to BG
 
```
    Specified by:
    
    addBundleFileViaURL in interface BundleManagerRemote
    
    Parameters:
    subject - user that must have proper permissions
    bundleVersionId - id of the BundleVersion incorporating this BundleFile
    name - name of the BundleFile (and the resulting Package)
    version - version of the backing package
    architecture - architecture appropriate for the backing package. Defaults to noarch (i.e. any architecture).
    
    Returns:
    the new BundleFile
    
    Throws:
    
    Exception
    See Also:
    BundleManagerRemote.addBundleFile(Subject, int, String, String, Architecture, InputStream)
  - addBundleFileViaURL
```
public org.rhq.core.domain.bundle.BundleFile addBundleFileViaURL(org.rhq.core.domain.auth.Subject subject,
                                                        int bundleVersionId,
                                                        String name,
                                                        String version,
                                                        org.rhq.core.domain.content.Architecture architecture,
                                                        String bundleFileUrl,
                                                        String userName,
                                                        String password)
                                                          throws Exception
```
    Description copied from interface: BundleManagerRemote
    A variant of BundleManagerRemote.addBundleFileViaURL(Subject, int, String, String, Architecture, String) supporting the HTTP basic authentication.
```
 Required Permissions: Either:
 - Global.CREATE_BUNDLES and Global.VIEW_BUNDLES
 - Global.CREATE_BUNDLES and BundleGroup.VIEW_BUNDLES_IN_GROUP for bundle group BG and the relevant bundle is assigned to BG
 - BundleGroup.CREATE_BUNDLES_IN_GROUP for bundle group BG and the relevant bundle is assigned to BG
 
```
    Specified by:
    
    addBundleFileViaURL in interface BundleManagerRemote
    
    Parameters:
    subject - user that must have proper permissions
    bundleVersionId - id of the BundleVersion incorporating this BundleFile
    name - name of the BundleFile (and the resulting Package)
    version - version of the backing package
    architecture - architecture appropriate for the backing package. Defaults to noarch (i.e. any architecture).
    
    Returns:
    the new BundleFile
    
    Throws:
    
    Exception
    See Also:
    BundleManagerRemote.addBundleFileViaURL(Subject, int, String, String, Architecture, String)
  - addBundleFileViaPackageVersion
```
public org.rhq.core.domain.bundle.BundleFile addBundleFileViaPackageVersion(org.rhq.core.domain.auth.Subject subject,
                                                                   int bundleVersionId,
                                                                   String name,
                                                                   int packageVersionId)
                                                                     throws Exception
```
    Description copied from interface: BundleManagerRemote
    A convenience method taking an existing PackageVersion as opposed to a stream for the file bits.
```
 Required Permissions: Either:
 - Global.CREATE_BUNDLES and Global.VIEW_BUNDLES
 - Global.CREATE_BUNDLES and BundleGroup.VIEW_BUNDLES_IN_GROUP for bundle group BG and the relevant bundle is assigned to BG
 - BundleGroup.CREATE_BUNDLES_IN_GROUP for bundle group BG and the relevant bundle is assigned to BG
 
```
    Specified by:
    
    addBundleFileViaPackageVersion in interface BundleManagerRemote
    
    Parameters:
    subject - user that must have proper permissions
    bundleVersionId - id of the BundleVersion incorporating this BundleFile
    name - name of the BundleFile (and the resulting Package)
    
    Returns:
    the new BundleFile
    
    Throws:
    
    Exception
    See Also:
    #addBundleFile(Subject, int, String, String, Architecture, InputStream)}
  - purgeBundleDestination
```
public void purgeBundleDestination(org.rhq.core.domain.auth.Subject subject,
                          int bundleDestinationId)
                            throws Exception
```
    Description copied from interface: BundleManagerRemote
    Purges the destination's live deployment content from the remote platforms.
```
 Required Permissions: Either:
 - Global.DEPLOY_BUNDLES and a view of the relevant bundle and a view of the relevant resource group (may involve multiple roles)
 - Resource.DEPLOY_BUNDLES_TO_GROUP and a view of the relevant bundle and a view of the relevant resource group (may involve multiple roles)
 
```
    Specified by:
    
    purgeBundleDestination in interface BundleManagerRemote
    
    Parameters:
    subject - user that must have proper permissions
    bundleDestinationId - the ID of the destination that is to be purged of bundle content
    
    Throws:
    
    Exception
  - _finalizePurge
```
public void _finalizePurge(org.rhq.core.domain.auth.Subject subject,
                  org.rhq.core.domain.bundle.BundleDeployment bundleDeployment,
                  Map<org.rhq.core.domain.bundle.BundleResourceDeployment,String> failedToPurge)
                    throws Exception
```
    Description copied from interface: BundleManagerLocal
    
    Internal use only
    When BundleManagerRemote.purgeBundleDestination(Subject, int) is done, it calls this so the purge can be finalized. This is required because this method is called with a transactional context, as opposed to the main purge method.
    This method performs NO AUTHZ!
    
    Specified by:
    
    _finalizePurge in interface BundleManagerLocal
    
    Throws:
    
    Exception
  - scheduleBundleDeployment
```
public org.rhq.core.domain.bundle.BundleDeployment scheduleBundleDeployment(org.rhq.core.domain.auth.Subject subject,
                                                                   int bundleDeploymentId,
                                                                   boolean isCleanDeployment)
                                                                     throws Exception
```
    Description copied from interface: BundleManagerRemote
    Deploy the bundle to the destination, as described in the provided deployment. Deployment is asynchronous so return of this method does not indicate individual resource deployments are complete. The returned BundleDeployment can be used to track the history of the individual deployments.
    
    TODO: Add the scheduling capability, currently it's Immediate.
```
 Required Permissions: Either:
 - Global.DEPLOY_BUNDLES and a view of the relevant bundle and a view of the relevant resource group (may involve multiple roles)
 - Resource.DEPLOY_BUNDLES_TO_GROUP and a view of the relevant bundle and a view of the relevant resource group (may involve multiple roles)
 
```
    Specified by:
    
    scheduleBundleDeployment in interface BundleManagerRemote
    
    Parameters:
    subject - user that must have proper permissions
    bundleDeploymentId - the BundleDeployment being used to guide the deployments
    isCleanDeployment - if true perform a wipe of the deploy directory prior to the deployment. If false perform as an upgrade to the existing deployment, if any.
    
    Returns:
    the BundleDeployment record, updated with status and (resource) deployments.
    
    Throws:
    
    Exception
  - scheduleRevertBundleDeployment
```
public org.rhq.core.domain.bundle.BundleDeployment scheduleRevertBundleDeployment(org.rhq.core.domain.auth.Subject subject,
                                                                         int bundleDestinationId,
                                                                         String deploymentDescription,
                                                                         boolean isCleanDeployment)
                                                                           throws Exception
```
    Description copied from interface: BundleManagerRemote
    
    For the specified destination, revert from the current live deployment to the deployment it had replaced. A revert first rolls back to the previous deployment (bundle version and configuration) and then rolls forward by replacing changed files that had been backed up during the most recent (live) deployment. The returned BundleDeployment represents the new live deployment and can be used to track the history of the individual revert deployments. Note that bundle deployment names are generated by this call. This provides useful, uniform naming for display. An optional, custom description can be added.
    
    TODO: Add the scheduling capability, currently it's Immediate. Required Permissions: Either: - Global.DEPLOY_BUNDLES and a view of the relevant bundle and a view of the relevant resource group (may involve multiple roles) - Resource.DEPLOY_BUNDLES_TO_GROUP and a view of the relevant bundle and a view of the relevant resource group (may involve multiple roles)
    
    Specified by:
    
    scheduleRevertBundleDeployment in interface BundleManagerRemote
    
    Parameters:
    subject - user that must have proper permissions
    bundleDestinationId - the destination on which the revert should be applied
    deploymentDescription - an optional longer description describing this deployment. If null defaults to the description of the previous deployment.
    isCleanDeployment - if true perform a wipe of the deploy directory prior to the revert deployment. Backed up files will still be applied. If false perform as an upgrade to the existing deployment.
    
    Returns:
    the BundleDeployment record, updated with status and (resource) deployments.
    
    Throws:
    
    Exception
  - scheduleBundleDeploymentInNewTransaction
```
public org.rhq.core.domain.bundle.BundleDeployment scheduleBundleDeploymentInNewTransaction(org.rhq.core.domain.auth.Subject subject,
                                                                                   int bundleDeploymentId,
                                                                                   boolean isCleanDeployment,
                                                                                   boolean isRevert,
                                                                                   Integer revertedDeploymentReplacedDeployment)
                                                                                     throws Exception
```
    Description copied from interface: BundleManagerLocal
    
    Internal use only. Exists for transaction boundary reasons only.
    This method performs NO AUTHZ!
    
    Specified by:
    
    scheduleBundleDeploymentInNewTransaction in interface BundleManagerLocal
    
    Throws:
    
    Exception
  - getScheduleRequest
```
public BundleScheduleRequest getScheduleRequest(org.rhq.core.domain.auth.Subject subject,
                                       int resourceDeploymentId,
                                       boolean isCleanDeployment,
                                       boolean isRevert)
                                         throws Exception
```
    Description copied from interface: BundleManagerLocal
    
    Internal use only. A special case method to build the pojo that can be sent to the agent to schedule the deployment request. Uses NOT_SUPPORTED transaction attribute to avoid having the cleaned pojo affect the persistence context.
    This method performs NO AUTHZ!
    
    Specified by:
    
    getScheduleRequest in interface BundleManagerLocal
    
    Throws:
    
    Exception
  - createBundleResourceDeploymentInNewTrans
```
public org.rhq.core.domain.bundle.BundleResourceDeployment createBundleResourceDeploymentInNewTrans(org.rhq.core.domain.auth.Subject subject,
                                                                                           int bundleDeploymentId,
                                                                                           int resourceId)
                                                                                             throws Exception
```
    Description copied from interface: BundleManagerLocal
    
    This is typically not called directly, typically scheduleBundleResourceDeployment() is called externally. This executes in a New Transaction and supports scheduleBundleResourceDeployment.
    This method performs NO AUTHZ!
    
    Specified by:
    
    createBundleResourceDeploymentInNewTrans in interface BundleManagerLocal
    
    Throws:
    
    Exception
  - setBundleResourceDeploymentStatusInNewTransaction
```
public org.rhq.core.domain.bundle.BundleResourceDeployment setBundleResourceDeploymentStatusInNewTransaction(org.rhq.core.domain.auth.Subject subject,
                                                                                                    int resourceDeploymentId,
                                                                                                    org.rhq.core.domain.bundle.BundleDeploymentStatus status)
                                                                                                      throws Exception
```
    Description copied from interface: BundleManagerLocal
    
    Internal use only. Called internally to set deployment status. Typically to a completion status when deployment ends. Exists for transaction boundary reasons only.
    This method performs NO AUTHZ!
    
    Specified by:
    
    setBundleResourceDeploymentStatusInNewTransaction in interface BundleManagerLocal
    
    resourceDeploymentId - id of the resource deployment appending the history record
    
    Returns:
    the updated BundleResourceDeployment
    
    Throws:
    
    Exception
  - determineBundleDeploymentStatus
```
public org.rhq.core.domain.bundle.BundleDeploymentStatus determineBundleDeploymentStatus(int bundleDeploymentId)
```
    Description copied from interface: BundleManagerLocal
    
    Determines (and updates) the deployment status of the provided bundle deployment based on the deployment statuses of the underlying resource deployments.
    
    Specified by:
    
    determineBundleDeploymentStatus in interface BundleManagerLocal
    
    Parameters:
    bundleDeploymentId - the id of the bundle deployment to check
    
    Returns:
    the determined bundle deployment status
  - getBundleVersionFilenames
```
public Set<String> getBundleVersionFilenames(org.rhq.core.domain.auth.Subject subject,
                                    int bundleVersionId,
                                    boolean withoutBundleFileOnly)
                                      throws Exception
```
    Description copied from interface: BundleManagerRemote
    Determine the files required for a BundleVersion and return all of the filenames or optionally, just those that lack BundleFiles for the BundleVersion. The recipe may be parsed as part of this call. This is needed as part of the bundle creation workflow, hence why creation permissions are needed.
```
 Required Permissions: Either:
 - Global.CREATE_BUNDLES and Global.VIEW_BUNDLES
 - Global.CREATE_BUNDLES and BundleGroup.VIEW_BUNDLES_IN_GROUP for bundle group BG and the relevant bundle is assigned to BG
 - BundleGroup.CREATE_BUNDLES_IN_GROUP for bundle group BG and the relevant bundle is assigned to BG
 
```
    Specified by:
    
    getBundleVersionFilenames in interface BundleManagerRemote
    
    Parameters:
    subject - user that must have proper permissions
    bundleVersionId - the BundleVersion being queried
    withoutBundleFileOnly - if true omit any filenames that already have a corresponding BundleFile for the BundleVersion.
    
    Returns:
    The List of filenames.
    
    Throws:
    
    Exception
  - getAllBundleVersionFilenames
```
public HashMap<String,Boolean> getAllBundleVersionFilenames(org.rhq.core.domain.auth.Subject subject,
                                                   int bundleVersionId)
                                                     throws Exception
```
    Description copied from interface: BundleManagerLocal
    
    Used by GUI
    Required Permissions: Either: - Global.CREATE_BUNDLES and Global.VIEW_BUNDLES - Global.CREATE_BUNDLES and BundleGroup.VIEW_BUNDLES_IN_GROUP for bundle group BG and the relevant bundle is assigned to BG - BundleGroup.CREATE_BUNDLES_IN_GROUP for bundle group BG and the relevant bundle is assigned to BG
    
    Specified by:
    
    getAllBundleVersionFilenames in interface BundleManagerLocal
    
    Returns:
    Map, filename to foundInBundleVersion
    
    Throws:
    
    Exception
  - getAllBundleTypes
```
public List<org.rhq.core.domain.bundle.BundleType> getAllBundleTypes(org.rhq.core.domain.auth.Subject subject)
```
    Specified by:
    
    getAllBundleTypes in interface BundleManagerRemote
    
    Returns:
    not null
  - getBundleType
```
public org.rhq.core.domain.bundle.BundleType getBundleType(org.rhq.core.domain.auth.Subject subject,
                                                  String bundleTypeName)
```
    Specified by:
    
    getBundleType in interface BundleManagerRemote
    
    bundleTypeName - must exist
    
    Returns:
    the bundle type
  - findBundleDeploymentsByCriteria
```
public org.rhq.core.domain.util.PageList<org.rhq.core.domain.bundle.BundleDeployment> findBundleDeploymentsByCriteria(org.rhq.core.domain.auth.Subject subject,
                                                                                                             org.rhq.core.domain.criteria.BundleDeploymentCriteria criteria)
```
    Description copied from interface: BundleManagerRemote
    
    Return the BundleDeployments narrowed by the supplied Criteria. The results are implicitly narrowed to those for bundles and destination groups viewable by the subject.
    
    Specified by:
    
    findBundleDeploymentsByCriteria in interface BundleManagerRemote
    
    Returns:
    not null
  - findBundleDestinationsByCriteria
```
public org.rhq.core.domain.util.PageList<org.rhq.core.domain.bundle.BundleDestination> findBundleDestinationsByCriteria(org.rhq.core.domain.auth.Subject subject,
                                                                                                               org.rhq.core.domain.criteria.BundleDestinationCriteria criteria)
```
    Description copied from interface: BundleManagerRemote
    
    Return the BundleDestinations narrowed by the supplied Criteria. The results are implicitly narrowed to those with destination resource groups viewable by the subject.
    
    Specified by:
    
    findBundleDestinationsByCriteria in interface BundleManagerRemote
    
    Returns:
    not null
  - findBundleResourceDeploymentsByCriteria
```
public org.rhq.core.domain.util.PageList<org.rhq.core.domain.bundle.BundleResourceDeployment> findBundleResourceDeploymentsByCriteria(org.rhq.core.domain.auth.Subject subject,
                                                                                                                             org.rhq.core.domain.criteria.BundleResourceDeploymentCriteria criteria)
```
    Description copied from interface: BundleManagerRemote
    
    Note that this can involves permissions on bundles and resources. Results will always be narrowed to the bundles viewable by subject. If optionally requesting the relevant Resources via BundleResourceDeploymentCriteria.fetchResources(true) the results will be further narrowed to the viewable resources.
    
    Specified by:
    
    findBundleResourceDeploymentsByCriteria in interface BundleManagerRemote
    
    Returns:
    not null
  - findBundleVersionsByCriteria
```
public org.rhq.core.domain.util.PageList<org.rhq.core.domain.bundle.BundleVersion> findBundleVersionsByCriteria(org.rhq.core.domain.auth.Subject subject,
                                                                                                       org.rhq.core.domain.criteria.BundleVersionCriteria criteria)
```
    Specified by:
    
    findBundleVersionsByCriteria in interface BundleManagerRemote
    
    Returns:
    not null
  - findBundleFilesByCriteria
```
public org.rhq.core.domain.util.PageList<org.rhq.core.domain.bundle.BundleFile> findBundleFilesByCriteria(org.rhq.core.domain.auth.Subject subject,
                                                                                                 org.rhq.core.domain.criteria.BundleFileCriteria criteria)
```
    Specified by:
    
    findBundleFilesByCriteria in interface BundleManagerRemote
    
    Returns:
    not null
  - findBundlesByCriteria
```
public org.rhq.core.domain.util.PageList<org.rhq.core.domain.bundle.Bundle> findBundlesByCriteria(org.rhq.core.domain.auth.Subject subject,
                                                                                         org.rhq.core.domain.criteria.BundleCriteria criteria)
```
    Description copied from interface: BundleManagerRemote
    
    Return the Bundles narrowed by the supplied Criteria. The results are implicitly narrowed to those bundles viewable by the subject.
    
    Specified by:
    
    findBundlesByCriteria in interface BundleManagerRemote
    
    Returns:
    not null
  - findBundlesWithLatestVersionCompositesByCriteria
```
public org.rhq.core.domain.util.PageList<org.rhq.core.domain.bundle.composite.BundleWithLatestVersionComposite> findBundlesWithLatestVersionCompositesByCriteria(org.rhq.core.domain.auth.Subject subject,
                                                                                                                                                        org.rhq.core.domain.criteria.BundleCriteria criteria)
```
    Specified by:
    
    findBundlesWithLatestVersionCompositesByCriteria in interface BundleManagerRemote
    
    Returns:
    not null
  - deleteBundles
```
public void deleteBundles(org.rhq.core.domain.auth.Subject subject,
                 int[] bundleIds)
                   throws Exception
```
    Description copied from interface: BundleManagerRemote
    Remove everything associated with the Bundles with the exception of files laid down by related deployments. Deployed files are left as is on the deployment platforms but the bundle mechanism will no longer track the deployment of all bundles that have been deleted. The bundles that are deleted will be removed from all bundle groups that it was a member of.
```
 Required Permissions: Either:
 - Global.DELETE_BUNDLES and Global.VIEW_BUNDLES
 - Global.DELETE_BUNDLES and BundleGroup.VIEW_BUNDLES_IN_GROUP for bundle group BG and the relevant bundle is assigned to BG
 - BundleGroup.DELETE_BUNDLES_FROM_GROUP for bundle group BG and the relevant bundle is assigned to BG
 
```
    Specified by:
    
    deleteBundles in interface BundleManagerRemote
    
    Parameters:
    subject - user that must have proper permissions
    bundleIds - IDs of all bundles to be deleted
    
    Throws:
    
    Exception - if any part of the removal fails.
  - deleteBundle
```
public void deleteBundle(org.rhq.core.domain.auth.Subject subject,
                int bundleId)
                  throws Exception
```
    Description copied from interface: BundleManagerRemote
    Remove everything associated with the Bundle with the exception of files laid down by related deployments. Deployed files are left as is on the deployment platforms but the bundle mechanism will no longer track the deployment. The bundles that are deleted will be removed from all bundle groups that it was a member of.
```
 Required Permissions: Either:
 - Global.DELETE_BUNDLES and Global.VIEW_BUNDLES
 - Global.DELETE_BUNDLES and BundleGroup.VIEW_BUNDLES_IN_GROUP for bundle group BG and the relevant bundle is assigned to BG
 - BundleGroup.DELETE_BUNDLES_FROM_GROUP for bundle group BG and the relevant bundle is assigned to BG
 
```
    Specified by:
    
    deleteBundle in interface BundleManagerRemote
    
    Parameters:
    subject - user that must have proper permissions
    bundleId - the id of the bundle to remove
    
    Throws:
    
    Exception - if any part of the removal fails.
  - deleteBundleDeployment
```
public void deleteBundleDeployment(org.rhq.core.domain.auth.Subject subject,
                          int bundleDeploymentId)
                            throws Exception
```
    Description copied from interface: BundleManagerLocal
    Used by GUI. The deployment must be PENDING or in a completed state.
```
 Required Permissions: Either:
 - Global.DEPLOY_BUNDLES and a view of the relevant bundle and a view of the relevant resource group (may involve multiple roles)
 - Resource.DEPLOY_BUNDLES_TO_GROUP and a view of the relevant bundle and a view of the relevant resource group (may involve multiple roles)
 
```
    Specified by:
    
    deleteBundleDeployment in interface BundleManagerLocal
    
    Throws:
    
    Exception - if any part of the removal fails.
  - deleteBundleDestination
```
public void deleteBundleDestination(org.rhq.core.domain.auth.Subject subject,
                           int destinationId)
                             throws Exception
```
    Description copied from interface: BundleManagerLocal
    Used by GUI. This is a simple attempt at delete, typically used for removing a poorly defined destination. It will fail if any actual deployments are referring to the destination.
```
 Required Permissions: Either:
 - Global.DEPLOY_BUNDLES and a view of the relevant bundle and a view of the relevant resource group (may involve multiple roles)
 - Resource.DEPLOY_BUNDLES_TO_GROUP and a view of the relevant bundle and a view of the relevant resource group (may involve multiple roles)
 
```
    Specified by:
    
    deleteBundleDestination in interface BundleManagerLocal
    
    Throws:
    
    Exception - if any part of the removal fails.
  - deleteBundleVersion
```
public void deleteBundleVersion(org.rhq.core.domain.auth.Subject subject,
                       int bundleVersionId,
                       boolean deleteBundleIfEmpty)
                         throws Exception
```
    Description copied from interface: BundleManagerRemote
    Remove everything associated with the BundleVersion with the exception of files laid down by related deployments. Deployed files are left as is on the deployment platforms but the bundle mechanism will no longer track the deployment. The deleted bundle version will no longer exist in any bundle group.
```
 Required Permissions: Either:
 - Global.DELETE_BUNDLES and Global.VIEW_BUNDLES
 - Global.DELETE_BUNDLES and BundleGroup.VIEW_BUNDLES_IN_GROUP for bundle group BG and the relevant bundle is assigned to BG
 - BundleGroup.DELETE_BUNDLES_FROM_GROUP for bundle group BG and the relevant bundle is assigned to BG
 
```
    Specified by:
    
    deleteBundleVersion in interface BundleManagerRemote
    
    Parameters:
    subject - user that must have proper permissions
    bundleVersionId - the id of the bundle version to remove
    deleteBundleIfEmpty - if true and if this method deletes the last bundle version for its bundle, then that bundle entity itself will be completely purged
    
    Throws:
    
    Exception - if any part of the removal fails.
  - assignBundlesToBundleGroups
```
public void assignBundlesToBundleGroups(org.rhq.core.domain.auth.Subject subject,
                               int[] bundleGroupIds,
                               int[] bundleIds)
```
    Description copied from interface: BundleManagerRemote
    Assign the specified bundles to the specified bundle groups. This adds bundles that were not previously assigned. Others are ignored.
```
 Requires VIEW permission for the relevant bundle and one of:
 - Global.MANAGE_BUNDLE_GROUPS
 - Global.CREATE_BUNDLE
 - BundleGroup.ASSIGN_BUNDLES_TO_GROUP for the relevant bundle group
 - BundleGroup.CREATE_BUNDLES_IN_GROUP for the relevant bundle group
 
```
    Specified by:
    
    assignBundlesToBundleGroups in interface BundleManagerRemote
  - createBundleGroup
```
public org.rhq.core.domain.bundle.BundleGroup createBundleGroup(org.rhq.core.domain.auth.Subject subject,
                                                       org.rhq.core.domain.bundle.BundleGroup bundleGroup)
                                                         throws Exception
```
    Description copied from interface: BundleManagerRemote
    Create a new bundle group. Bundles, if specified will be set as the initial bundles in the group.
```
 Require Permissions:
 - Global.MANAGE_BUNDLE_GROUPS
 
```
    Specified by:
    
    createBundleGroup in interface BundleManagerRemote
    
    Parameters:
    subject - user that must have proper permissions
    bundleGroup - the new bundle group name the unique bundle group name
    
    Returns:
    the persisted BundleGroup
    
    Throws:
    
    Exception
  - deleteBundleGroups
```
public void deleteBundleGroups(org.rhq.core.domain.auth.Subject subject,
                      int[] bundleGroupIds)
                        throws Exception
```
    Description copied from interface: BundleManagerRemote
    Delete a bundle group. Any currently assigned bundles will be removed but are not deleted.
```
 Required Permissions:
 - Global.MANAGE_BUNDLE_GROUPS
 
```
    Specified by:
    
    deleteBundleGroups in interface BundleManagerRemote
    
    Parameters:
    subject - user that must have proper permissions
    bundleGroupIds - the bundle group id
    
    Throws:
    
    Exception
  - findBundleGroupsByCriteria
```
public org.rhq.core.domain.util.PageList<org.rhq.core.domain.bundle.BundleGroup> findBundleGroupsByCriteria(org.rhq.core.domain.auth.Subject subject,
                                                                                                   org.rhq.core.domain.criteria.BundleGroupCriteria criteria)
```
    Description copied from interface: BundleManagerRemote
    
    Return the BundleGroups narrowed by the supplied Criteria. The results are implicitly narrowed to those bundle groups viewable by the subject.
    
    Specified by:
    
    findBundleGroupsByCriteria in interface BundleManagerRemote
    
    Returns:
    not null
  - unassignBundlesFromBundleGroups
```
public void unassignBundlesFromBundleGroups(org.rhq.core.domain.auth.Subject subject,
                                   int[] bundleGroupIds,
                                   int[] bundleIds)
```
    Description copied from interface: BundleManagerRemote
    Unassign the specified bundles from the specified bundle groups. This removes bundles that were previously assigned. Others are ignored.
```
 Requires VIEW permission for the relevant bundles and one of:
 - Global.MANAGE_BUNDLE_GROUPS
 - Global.DELETE_BUNDLE
 - BundleGroup.UNASSIGN_BUNDLES_FROM_GROUP for the relevant bundle group
 - BundleGroup.DELETE_BUNDLES_FROM_GROUP for the relevant bundle group
 
```
    Specified by:
    
    unassignBundlesFromBundleGroups in interface BundleManagerRemote
  - updateBundleGroup
```
public org.rhq.core.domain.bundle.BundleGroup updateBundleGroup(org.rhq.core.domain.auth.Subject subject,
                                                       org.rhq.core.domain.bundle.BundleGroup bundleGroup)
                                                         throws Exception
```
    Description copied from interface: BundleManagerRemote
    Updates an existing bundle group. The set of bundles will be updated if non-null.
```
 Require Permissions:
 - Global.MANAGE_BUNDLE_GROUPS
 
```
    Specified by:
    
    updateBundleGroup in interface BundleManagerRemote
    
    Parameters:
    subject - user that must have proper permissions
    bundleGroup - the updated bundle group
    
    Returns:
    the updated BundleGroup
    
    Throws:
    
    Exception
  - createInitialBundleVersionViaToken
```
public org.rhq.core.domain.bundle.BundleVersion createInitialBundleVersionViaToken(org.rhq.core.domain.auth.Subject subject,
                                                                          int[] bundleGroupIds,
                                                                          String token)
                                                                            throws Exception
```
    Description copied from interface: BundleManagerLocal
    This method exists solely to support the GUI's wizard workflow which always first tries to create a bundle version for an existing bundle, because it does not know whether this is an initial bundle version (only the server can figure that out after it cracks open the bundle distribution, parses the recipe, and looks for the bundle). It works in conjunction with BundleManagerLocal.createOrStoreBundleVersionViaFile(Subject, File) or BundleManagerLocal.createOrStoreBundleVersionViaURL(Subject, String, String, String).
    This method will use the supplied token to access the distribution file. It assumes this is a new bundle and is responsible for creating the bundle as well as the bundle version. The caller can indicate which bundle groups the new bundle should be assigned to. If bundleGroupId is null, then the new bundle will not be associated with any bundle group - this is only allowed if the caller has the permission Global.VIEW_BUNDLES.
```
 Required Permissions: Either:
 - Global.CREATE_BUNDLES and Global.VIEW_BUNDLES
 - Global.CREATE_BUNDLES and BundleGroup.VIEW_BUNDLES_IN_GROUP for bundle group BG
 - BundleGroup.CREATE_BUNDLES_IN_GROUP for bundle group BG
 
```
    Specified by:
    
    createInitialBundleVersionViaToken in interface BundleManagerLocal
    
    Parameters:
    subject - user that must have proper permissions
    bundleGroupIds - identifies the bundle groups that the new bundle will be associated with; null or zero length to leave unassigned.
    token - the token used to identify the distribution file stashed as a temp file.
    
    Returns:
    the persisted BundleVersion with a lot of the internal relationships filled in to help the caller understand all that this method did.
    
    Throws:
    
    Exception
  - getAssignableBundleGroups
```
public org.rhq.core.domain.bundle.composite.BundleGroupAssignmentComposite getAssignableBundleGroups(org.rhq.core.domain.auth.Subject subject,
                                                                                            org.rhq.core.domain.auth.Subject assigningSubject,
                                                                                            int bundleId)
                                                                                              throws Exception
```
    Description copied from interface: BundleManagerLocal
    
    For the calling subject determines which bundle groups to which the user can assign the bundle. The composite includes a Map indicating the assignable BundleGroups and which are currently assigned. It also indicates whether the bundle can be left unassigned. When querying for new bundles the bundleId should be set to 0.
    
    Specified by:
    
    getAssignableBundleGroups in interface BundleManagerLocal
    
    Returns:
    
    Throws:
    
    Exception

Class BundleManagerBean

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

BundleManagerBean

Method Detail

getResourceTypeBundleConfiguration

addBundleResourceDeploymentHistoryInNewTrans

getBundleResourceDeploymentHistories

createBundle

createBundleDeploymentInNewTrans

createBundleDeployment

createBundleDestination

getBundleDeploymentName

createBundleType

createBundleAndBundleVersion

createBundleVersion

createBundleVersionInternal

createBundleVersionViaRecipe

createInitialBundleVersionViaRecipe

createBundleVersionViaFile

createBundleVersionViaContentHandle

createOrStoreBundleVersionViaFile

createInitialBundleVersionViaFile

createInitialBundleVersionViaContentHandle

createBundleVersionViaByteArray

createInitialBundleVersionViaByteArray

createBundleVersionViaURL

createBundleVersionViaURL

createInitialBundleVersionViaURL

createInitialBundleVersionViaURL

createBundleVersionViaURLImpl

createOrStoreBundleVersionViaURL

addBundleFile

addBundleFileViaByteArray

addBundleFileViaURL

addBundleFileViaURL

addBundleFileViaPackageVersion

purgeBundleDestination

_finalizePurge

scheduleBundleDeployment

scheduleRevertBundleDeployment

scheduleBundleDeploymentInNewTransaction

getScheduleRequest

createBundleResourceDeploymentInNewTrans

setBundleResourceDeploymentStatusInNewTransaction

determineBundleDeploymentStatus

getBundleVersionFilenames

getAllBundleVersionFilenames

getAllBundleTypes

getBundleType

findBundleDeploymentsByCriteria

findBundleDestinationsByCriteria

findBundleResourceDeploymentsByCriteria

findBundleVersionsByCriteria

findBundleFilesByCriteria

findBundlesByCriteria

findBundlesWithLatestVersionCompositesByCriteria

deleteBundles

deleteBundle

deleteBundleDeployment

deleteBundleDestination

deleteBundleVersion

assignBundlesToBundleGroups

createBundleGroup

deleteBundleGroups

findBundleGroupsByCriteria

unassignBundlesFromBundleGroups

updateBundleGroup

createInitialBundleVersionViaToken

getAssignableBundleGroups