private void assertVersion1(ResourceType resourceType) {
PropertyGroupDefinition group;
PropertyDefinition prop;
ProcessScan processScan;
OperationDefinition op;
MeasurementDefinition metric;
EventDefinition event;
DriftDefinitionTemplate drift;
BaseDirectory driftBasedir;
ResourceTypeBundleConfiguration bundle;
BundleDestinationBaseDirectory bundleBasedir;
assert resourceType.getChildSubCategories().size() == 1;
assert resourceType.getChildSubCategories().get(0).getName().equals(SUBCAT);
assert resourceType.getChildSubCategories().get(0).getDisplayName().equals(SUBCAT_DISPLAYNAME);
assert resourceType.getPluginConfigurationDefinition().getGroupDefinitions().size() == 1;
group = resourceType.getPluginConfigurationDefinition().getGroupDefinitions().get(0);
assert group.getName().equals(PC_GROUP);
assert group.isDefaultHidden() == PC_GROUP_HIDDEN;
prop = resourceType.getPluginConfigurationDefinition().get(PC_PROP);
assert prop != null;
assert prop.getName().equals(PC_PROP);
assert prop.isRequired() == PC_PROP_REQUIRED;
assert prop.getPropertyGroupDefinition().getName().equals(PC_GROUP);
assert resourceType.getProcessScans().size() == 1;
processScan = resourceType.getProcessScans().iterator().next();
assert processScan.getName().equals(PROCESS_SCAN_NAME);
assert processScan.getQuery().equals(PROCESS_SCAN_QUERY);
assert resourceType.getOperationDefinitions().size() == 1;
op = resourceType.getOperationDefinitions().iterator().next();
assert op.getName().equals(OP_NAME);
assert op.getTimeout().intValue() == OP_TIMEOUT;
assert op.getDescription().equals(OP_DESC);
assert resourceType.getMetricDefinitions().size() == 2; // include built-in Availability metric
metric = resourceType.getMetricDefinitions().iterator().next();
assert metric.getName().equals(METRIC_PROP);
assert metric.getDefaultInterval() == METRIC_DEFAULT_INTERVAL;
assert resourceType.getEventDefinitions().size() == 1;
event = resourceType.getEventDefinitions().iterator().next();
assert event.getName().equals(EVENT_NAME);
assert event.getDescription().equals(EVENT_DESC);
assert resourceType.getResourceConfigurationDefinition().getGroupDefinitions().size() == 0;
prop = resourceType.getResourceConfigurationDefinition().get(RC_PROP);
assert prop != null;
assert prop.getName().equals(RC_PROP);
assert prop.isRequired() == RC_PROP_REQUIRED;
assert resourceType.getDriftDefinitionTemplates().size() == 1;
drift = resourceType.getDriftDefinitionTemplates().iterator().next();
assert drift.getTemplateDefinition().getName().equals(DRIFT_DEF_NAME);
driftBasedir = drift.getTemplateDefinition().getBasedir();
assert driftBasedir.getValueContext().equals(DRIFT_DEF_BASEDIR_CONTEXT);
assert driftBasedir.getValueName().equals(DRIFT_DEF_BASEDIR_VALUE);
bundle = resourceType.getResourceTypeBundleConfiguration();
assert bundle.getBundleDestinationBaseDirectories().size() == 1;
bundleBasedir = bundle.getBundleDestinationBaseDirectories().iterator().next();
assert bundleBasedir.getName().equals(BUNDLE_TARGET_NAME);
assert bundleBasedir.getValueContext().equals(BUNDLE_BASEDIR_CONTEXT);
assert bundleBasedir.getValueName().equals(BUNDLE_BASEDIR_VALUE);
}
private void assertVersion2(ResourceType resourceType) {
PropertyDefinition prop;
Set<String> seen =
new HashSet<String>(2); // we use to this remember names of the things that we've seen
assert resourceType.getChildSubCategories().size() == 1;
assert resourceType.getChildSubCategories().get(0).getName().equals(SUBCAT);
assert resourceType.getChildSubCategories().get(0).getDisplayName().equals(SUBCAT_DISPLAYNAME);
seen.clear();
ConfigurationDefinition pcDef = resourceType.getPluginConfigurationDefinition();
assert pcDef.getGroupDefinitions().size() == 2;
for (PropertyGroupDefinition group : pcDef.getGroupDefinitions()) {
seen.add(group.getName());
if (group.getName().equals(CHANGED_PC_GROUP)) {
assert group.isDefaultHidden() == CHANGED_PC_GROUP_HIDDEN;
} else if (group.getName().equals(NEW_PC_GROUP)) {
assert group.isDefaultHidden() == NEW_PC_GROUP_HIDDEN;
} else {
assert false : "Unexpected group [" + group.getName() + "]:" + group;
}
}
if (seen.size() != 2) {
assert false : "did not see what we expected to see: " + seen;
}
prop = pcDef.get(CHANGED_PC_PROP);
assert prop != null;
assert prop.getName().equals(CHANGED_PC_PROP);
assert prop.isRequired() == CHANGED_PC_PROP_REQUIRED;
assert prop.getPropertyGroupDefinition().getName().equals(CHANGED_PC_GROUP);
prop = pcDef.get(NEW_PC_PROP);
assert prop != null;
assert prop.getName().equals(NEW_PC_PROP);
assert prop.isRequired() == NEW_PC_PROP_REQUIRED;
assert prop.getPropertyGroupDefinition().getName().equals(NEW_PC_GROUP);
seen.clear();
assert resourceType.getProcessScans().size() == 2;
for (ProcessScan processScan : resourceType.getProcessScans()) {
seen.add(processScan.getName());
if (processScan.getName().equals(CHANGED_PROCESS_SCAN_NAME)) {
assert processScan.getQuery().equals(CHANGED_PROCESS_SCAN_QUERY);
} else if (processScan.getName().equals(NEW_PROCESS_SCAN_NAME)) {
assert processScan.getQuery().equals(NEW_PROCESS_SCAN_QUERY);
} else {
assert false : "Unexpected process scan[" + processScan.getName() + "]:" + processScan;
}
}
if (seen.size() != 2) {
assert false : "did not see what we expected to see: " + seen;
}
seen.clear();
assert resourceType.getOperationDefinitions().size() == 2;
for (OperationDefinition op : resourceType.getOperationDefinitions()) {
seen.add(op.getName());
if (op.getName().equals(CHANGED_OP_NAME)) {
assert op.getTimeout().intValue() == CHANGED_OP_TIMEOUT;
assert op.getDescription().equals(CHANGED_OP_DESC);
} else if (op.getName().equals(NEW_OP_NAME)) {
assert op.getTimeout().intValue() == NEW_OP_TIMEOUT;
assert op.getDescription().equals(NEW_OP_DESC);
} else {
assert false : "Unexpected operation [" + op.getName() + "]:" + op;
}
}
if (seen.size() != 2) {
assert false : "did not see what we expected to see: " + seen;
}
seen.clear();
assert resourceType.getMetricDefinitions().size() == 3; // include built-in Availability metric
for (MeasurementDefinition metric : resourceType.getMetricDefinitions()) {
if (metric.getName().equals(MeasurementDefinition.AVAILABILITY_NAME)) {
// expected, ignore
continue;
}
seen.add(metric.getName());
if (metric.getName().equals(CHANGED_METRIC_PROP)) {
// even though our _v2 plugin set this to something different, our upgrade doesn't change it
// because
// we don't want to overwrite changes a user possibly made to the defaut interval (aka
// metric template)
assert metric.getDefaultInterval() == METRIC_DEFAULT_INTERVAL;
} else if (metric.getName().equals(NEW_METRIC_PROP)) {
assert metric.getDefaultInterval() == NEW_METRIC_DEFAULT_INTERVAL;
} else {
assert false : "Unexpected metric [" + metric.getName() + "]:" + metric;
}
}
if (seen.size() != 2) {
assert false : "did not see what we expected to see: " + seen;
}
seen.clear();
assert resourceType.getEventDefinitions().size() == 2;
for (EventDefinition event : resourceType.getEventDefinitions()) {
seen.add(event.getName());
if (event.getName().equals(CHANGED_EVENT_NAME)) {
assert event.getDescription().equals(CHANGED_EVENT_DESC);
} else if (event.getName().equals(NEW_EVENT_NAME)) {
assert event.getDescription().equals(NEW_EVENT_DESC);
} else {
assert false : "Unexpected event [" + event.getName() + "]:" + event;
}
}
if (seen.size() != 2) {
assert false : "did not see what we expected to see: " + seen;
}
assert resourceType.getResourceConfigurationDefinition().getGroupDefinitions().size() == 0;
prop = resourceType.getResourceConfigurationDefinition().get(CHANGED_RC_PROP);
assert prop != null;
assert prop.getName().equals(CHANGED_RC_PROP);
assert prop.isRequired() == CHANGED_RC_PROP_REQUIRED;
prop = resourceType.getResourceConfigurationDefinition().get(NEW_RC_PROP);
assert prop != null;
assert prop.getName().equals(NEW_RC_PROP);
assert prop.isRequired() == NEW_RC_PROP_REQUIRED;
seen.clear();
assert resourceType.getDriftDefinitionTemplates().size() == 2;
for (DriftDefinitionTemplate drift : resourceType.getDriftDefinitionTemplates()) {
DriftDefinition def = drift.getTemplateDefinition();
seen.add(def.getName());
if (def.getName().equals(CHANGED_DRIFT_DEF_NAME)) {
BaseDirectory driftBasedir = def.getBasedir();
assert driftBasedir.getValueContext().equals(CHANGED_DRIFT_DEF_BASEDIR_CONTEXT);
assert driftBasedir.getValueName().equals(CHANGED_DRIFT_DEF_BASEDIR_VALUE);
} else if (def.getName().equals(NEW_DRIFT_DEF_NAME)) {
BaseDirectory driftBasedir = def.getBasedir();
assert driftBasedir.getValueContext().equals(NEW_DRIFT_DEF_BASEDIR_CONTEXT);
assert driftBasedir.getValueName().equals(NEW_DRIFT_DEF_BASEDIR_VALUE);
} else {
assert false : "Unexpected drift def [" + def.getName() + "]:" + def;
}
}
if (seen.size() != 2) {
assert false : "did not see what we expected to see: " + seen;
}
seen.clear();
ResourceTypeBundleConfiguration bundle = resourceType.getResourceTypeBundleConfiguration();
assert bundle.getBundleDestinationBaseDirectories().size() == 2;
for (BundleDestinationBaseDirectory bundleBasedir :
bundle.getBundleDestinationBaseDirectories()) {
seen.add(bundleBasedir.getName());
if (bundleBasedir.getName().equals(CHANGED_BUNDLE_TARGET_NAME)) {
assert bundleBasedir.getValueContext().equals(CHANGED_BUNDLE_BASEDIR_CONTEXT);
assert bundleBasedir.getValueName().equals(CHANGED_BUNDLE_BASEDIR_VALUE);
} else if (bundleBasedir.getName().equals(NEW_BUNDLE_TARGET_NAME)) {
assert bundleBasedir.getValueContext().equals(NEW_BUNDLE_BASEDIR_CONTEXT);
assert bundleBasedir.getValueName().equals(NEW_BUNDLE_BASEDIR_VALUE);
} else {
assert false
: "Unexpected bundle basedir [" + bundleBasedir.getName() + "]:" + bundleBasedir;
}
}
if (seen.size() != 2) {
assert false : "did not see what we expected to see: " + seen;
}
}
/**
* 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;
}
