private BundleDestination getBundleDestination(
BundleVersion bundleVersion, String destinationName, ResourceGroup group, String deployDir)
throws Exception {
BundleDestinationCriteria criteria = new BundleDestinationCriteria();
criteria.addFilterBundleId(bundleVersion.getBundle().getId());
// criteria.addFilterBundleVersionId(bundleVersion.getId());
criteria.addFilterGroupId(group.getId());
PageList<BundleDestination> bundleDestinations =
bundleManager.findBundleDestinationsByCriteria(overlord, criteria);
if (bundleDestinations.isEmpty()) {
return bundleManager.createBundleDestination(
overlord,
bundleVersion.getBundle().getId(),
destinationName,
destinationName,
"Root File System",
deployDir,
group.getId());
}
for (BundleDestination destination : bundleDestinations) {
if (destination.getDeployDir().equals(deployDir)) {
return destination;
}
}
throw new RuntimeException(
"Unable to get bundle destination for [bundleId: "
+ bundleVersion.getBundle().getId()
+ ", bunldleVersionId: "
+ bundleVersion.getId()
+ ", destination: "
+ destinationName
+ ", deployDir: "
+ deployDir
+ "]");
}
/**
* Given a deployment, this examines the destination and the resource to determine where exactly
* the bundle distribution should be written.
*
* @param bundleResourceDeployment describes where the bundle should be or is deployed
* @return absolute directory location where the bundle should be deployed
*/
private File getAbsoluteDestinationDir(BundleResourceDeployment bundleResourceDeployment) {
BundleDestination dest = bundleResourceDeployment.getBundleDeployment().getDestination();
String destBaseDirName = dest.getDestinationBaseDirectoryName();
String relativeDeployDir = dest.getDeployDir();
// paranoia, if no deploy dir is given, as assume it will be directly under the base location
if (relativeDeployDir == null || relativeDeployDir.trim().length() == 0) {
relativeDeployDir = File.separator;
}
// get the resource entity stored in our local inventory
InventoryManager im = getInventoryManager();
Resource resource = bundleResourceDeployment.getResource();
ResourceContainer container = im.getResourceContainer(resource);
resource = container.getResource();
// find out the type of base location that is specified by the bundle destination
BundleDestinationBaseDirectory bundleDestBaseDir = null;
ResourceTypeBundleConfiguration rtbc =
resource.getResourceType().getResourceTypeBundleConfiguration();
if (rtbc == null) {
throw new IllegalArgumentException(
"The resource type doesn't support bundle deployments: " + resource);
}
for (BundleDestinationBaseDirectory bdbd : rtbc.getBundleDestinationBaseDirectories()) {
if (bdbd.getName().equals(destBaseDirName)) {
bundleDestBaseDir = bdbd;
break;
}
}
if (bundleDestBaseDir == null) {
throw new IllegalArgumentException(
"The resource type doesn't support bundle destination base location named ["
+ destBaseDirName
+ "]");
}
// based on the type of destination base location, determine the root base directory
String destBaseDirValueName =
bundleDestBaseDir.getValueName(); // the name we look up in the given context
String baseLocation;
switch (bundleDestBaseDir.getValueContext()) {
case fileSystem:
{
if (!new File(relativeDeployDir).isAbsolute()) {
// the deploy dir is not absolute; since we need to pin it to something, we assume the
// top root directory
// unless the descriptor told us to go somewhere else differently
baseLocation = destBaseDirValueName; // ultimately this came from the plugin descriptor
if (baseLocation == null || baseLocation.trim().length() == 0) {
baseLocation =
File
.separator; // paranoia, if the plugin descriptor didn't specify, assume the
// top root directory
}
} else {
baseLocation = null; // so the relativeDeployDir is processed as an absolute dir
}
break;
}
case pluginConfiguration:
{
baseLocation =
resource.getPluginConfiguration().getSimpleValue(destBaseDirValueName, null);
if (baseLocation == null) {
throw new IllegalArgumentException(
"Cannot determine the bundle base deployment location - "
+ "there is no plugin configuration setting for ["
+ destBaseDirValueName
+ "]");
}
break;
}
case resourceConfiguration:
{
baseLocation =
resource.getResourceConfiguration().getSimpleValue(destBaseDirValueName, null);
if (baseLocation == null) {
throw new IllegalArgumentException(
"Cannot determine the bundle base deployment location - "
+ "there is no resource configuration setting for ["
+ destBaseDirValueName
+ "]");
}
break;
}
case measurementTrait:
{
baseLocation = getMeasurementManager().getTraitValue(container, destBaseDirValueName);
if (baseLocation == null) {
throw new IllegalArgumentException(
"Cannot obtain trait ["
+ destBaseDirName
+ "] for resource ["
+ resource.getName()
+ "]");
}
break;
}
default:
{
throw new IllegalArgumentException(
"Unknown bundle destination location context: " + bundleDestBaseDir);
}
}
File destDir = new File(baseLocation, relativeDeployDir);
if (!destDir.isAbsolute()) {
throw new IllegalArgumentException(
"The base location path specified by ["
+ destBaseDirValueName
+ "] in the context ["
+ bundleDestBaseDir.getValueContext()
+ "] along with the destination directory of ["
+ relativeDeployDir
+ "] did not resolve to an absolute path ["
+ destDir.getPath()
+ "] so there is no way to know where to put the bundle.");
}
return destDir;
}