protected void setResource(HttpServletRequest request, boolean config) throws Exception {
try {
Subject subject = WebUtility.getSubject(request);
Integer resourceTypeId =
WebUtility.getOptionalIntRequestParameter(
request, ParamConstants.RESOURCE_TYPE_ID_PARAM, -1);
int groupId = WebUtility.getOptionalIntRequestParameter(request, AttrConstants.GROUP_ID, -1);
int parent = WebUtility.getOptionalIntRequestParameter(request, "parent", -1);
String[] r = request.getParameterValues("r");
String[] resourceIds = request.getParameterValues("resourceIds");
// TODO rewrite the selection using WebUtility.getMetricsDisplayMode()
if ((resourceTypeId > 0) && (parent > 0)) // autogroup
{
ResourceTypeManagerLocal resourceTypeManager = LookupUtil.getResourceTypeManager();
ResourceType resourceType =
resourceTypeManager.getResourceTypeById(subject, resourceTypeId);
request.setAttribute(AttrConstants.RESOURCE_TYPE_ATTR, resourceType);
request.setAttribute(AttrConstants.TITLE_PARAM_ATTR, resourceType.getName());
request.setAttribute("parent", parent);
request.setAttribute(ParamConstants.RESOURCE_TYPE_ID_PARAM, resourceTypeId);
if (log.isDebugEnabled()) {
log.debug("Autogroup p=" + parent + ", ct=" + resourceTypeId);
}
} else if (groupId > 0) // compat (or mixed) group
{
ResourceGroupManagerLocal resourceGroupManager = LookupUtil.getResourceGroupManager();
ResourceGroup group = resourceGroupManager.getResourceGroupById(subject, groupId, null);
request.setAttribute(AttrConstants.GROUP_ID, groupId);
request.setAttribute(AttrConstants.TITLE_PARAM_ATTR, group.getName());
// TODO more ?
} else if ((resourceTypeId > 0) && (parent == -1)) // MeasurementDefinition
{
ResourceTypeManagerLocal resourceTypeManager = LookupUtil.getResourceTypeManager();
ResourceType resourceType =
resourceTypeManager.getResourceTypeById(subject, resourceTypeId);
request.setAttribute(AttrConstants.RESOURCE_TYPE_ATTR, resourceType);
request.setAttribute(ParamConstants.RESOURCE_TYPE_ID_PARAM, resourceTypeId);
} else if ((r != null) && (r.length > 0)) // multiple scathered resources
{
log.trace("Multiple resources not handled yet"); // TODO what do we do here?
} else if ((resourceIds != null) && (resourceIds.length > 0)) {
log.trace("Multiple resources not yet handled"); // TODO what to we do here?
} else // single resource
{
Integer resourceId =
WebUtility.getRequiredIntRequestParameter(request, ParamConstants.RESOURCE_ID_PARAM);
ResourceManagerLocal resourceManager = LookupUtil.getResourceManager();
Resource resource = resourceManager.getResourceById(subject, resourceId);
ResourceUIBean resourceUIBean = new ResourceUIBean(resource, subject);
request.setAttribute(AttrConstants.RESOURCE_ATTR, resource);
request.setAttribute(AttrConstants.RESOURCE_ID_ATTR, resourceId);
request.setAttribute(AttrConstants.TITLE_PARAM_ATTR, resource.getName());
request.setAttribute(
AttrConstants.PERFORMANCE_SUPPORTED_ATTR, resourceUIBean.getFacets().isCallTime());
}
} catch (ResourceNotFoundException e) {
RequestUtils.setError(request, MessageConstants.ERR_RESOURCE_NOT_FOUND);
}
}
private void checkChildPlugin() throws Exception {
// load the child type and test to make sure it has been updated to what we expect
ResourceType resourceType = loadResourceTypeFully(TYPE_NAME_CHILD, PLUGIN_NAME_CHILD);
assert resourceType.getName().equals(TYPE_NAME_CHILD);
assert resourceType.getPlugin().equals(PLUGIN_NAME_CHILD);
assertVersion2(resourceType);
}
private void setTitle(HttpServletRequest request, Portal portal, String titleName)
throws Exception {
Resource resource = RequestUtils.getResource(request);
ResourceGroup group = RequestUtils.getResourceGroupIfExists(request);
ResourceType type;
if (resource != null) {
// resource alert definition
type = resource.getResourceType();
} else if (group != null) {
// group alert definition
type = group.getResourceType();
} else {
// template alert definition
type = RequestUtils.getResourceType(request);
}
ResourceCategory category = type.getCategory();
titleName = StringUtil.replace(titleName, "platform", category.toString().toLowerCase());
portal.setName(titleName);
// if there's an alert definition available, set our second
// title parameter to its name
try {
AlertDefinition alertDef = AlertDefUtil.getAlertDefinition(request);
request.setAttribute(Constants.TITLE_PARAM2_ATTR, alertDef.getName());
} catch (ParameterNotFoundException e) {
// it's okay
log.trace("couldn't find alert definition: " + e.getMessage());
}
}
private void registerChildPluginV1() throws Exception {
// register the plugin, load the new type and test to make sure its what we expect
createPlugin("child-plugin.jar", "1.0", "child_plugin_v1.xml");
ResourceType resourceType = loadResourceTypeFully(TYPE_NAME_CHILD, PLUGIN_NAME_CHILD);
assert resourceType.getName().equals(TYPE_NAME_CHILD);
assert resourceType.getPlugin().equals(PLUGIN_NAME_CHILD);
assertVersion1(resourceType);
}
private void registerParentPluginV2() throws Exception {
// register the plugin, load the new type and test to make sure its what we expect
createPlugin("parent-plugin.jar", "2.0", "parent_plugin_v2.xml");
ResourceType resourceType = loadResourceTypeFully(TYPE_NAME_PARENT, PLUGIN_NAME_PARENT);
assert resourceType.getName().equals(TYPE_NAME_PARENT);
assert resourceType.getPlugin().equals(PLUGIN_NAME_PARENT);
assertVersion2(resourceType);
}
private ResourceType getResourceType(ResourceType typeToGet) {
for (ResourceType type : metadataManager.getAllTypes()) {
if (type.equals(typeToGet)) {
return type;
}
}
return null;
}
private static Configuration getDefaultPluginConfiguration(ResourceType resourceType) {
Configuration defaultPluginConfig;
if (DEFAULT_PLUGIN_CONFIG_CACHE.containsKey(resourceType.getName()))
defaultPluginConfig = DEFAULT_PLUGIN_CONFIG_CACHE.get(resourceType.getName());
else {
defaultPluginConfig = ResourceTypeUtils.getDefaultPluginConfiguration(resourceType);
DEFAULT_PLUGIN_CONFIG_CACHE.put(resourceType.getName(), defaultPluginConfig);
}
return defaultPluginConfig;
}
private static Set<ResourceType> getCreatableChildTypes(ResourceType type) {
Set<ResourceType> results = new TreeSet<ResourceType>();
Set<ResourceType> childTypes = type.getChildResourceTypes();
for (ResourceType childType : childTypes) {
if (childType.isCreatable()) {
results.add(childType);
}
}
return results;
}
private static Integer[] getSingletonChildTypes(ResourceType type) {
Set<Integer> results = new TreeSet<Integer>();
Set<ResourceType> childTypes = type.getChildResourceTypes();
for (ResourceType childType : childTypes) {
if (childType.isSingleton()) {
results.add(childType.getId());
}
}
return results.toArray(new Integer[results.size()]);
}
private ResourceType createResourceType() throws Exception {
ResourceType resourceType =
new ResourceType("RHQ Storage Node", "RHQStorage", ResourceCategory.SERVER, null);
ConfigurationDefinition pluginConfigurationDefinition =
new ConfigurationDefinition("config", null);
pluginConfigurationDefinition.put(
new PropertyDefinitionSimple("host", null, true, PropertySimpleType.STRING));
resourceType.setPluginConfigurationDefinition(pluginConfigurationDefinition);
getEntityManager().persist(resourceType);
return resourceType;
}
private void outputType(ResourceType type, int depth) {
StringBuilder line = new StringBuilder();
for (int i = 0; i < depth; i++) {
line.append(" ");
}
line.append("+ ");
line.append(type.toString());
System.out.println(line.toString());
for (ResourceType child : type.getChildResourceTypes()) {
outputType(child, depth + 1);
}
}
private Resource createNewResource() throws Exception {
getTransactionManager().begin();
Resource resource;
try {
try {
ResourceType resourceType =
new ResourceType(
"plat" + System.currentTimeMillis(), "test", ResourceCategory.PLATFORM, null);
DriftDefinitionTemplate template = new DriftDefinitionTemplate();
template.setName("test-template");
DriftDefinition templateDef = new DriftDefinition(new Configuration());
templateDef.setName("test-template-def");
template.setTemplateDefinition(templateDef);
template.setUserDefined(true);
resourceType.addDriftDefinitionTemplate(template);
em.persist(resourceType);
Agent agent = new Agent("testagent", "testaddress", 1, "", "testtoken");
em.persist(agent);
em.flush();
DriftDefinition test1Def = new DriftDefinition(new Configuration());
test1Def.setName("test-1");
DriftDefinition test2Def = new DriftDefinition(new Configuration());
test2Def.setName("test-2");
resource = new Resource("reskey" + System.currentTimeMillis(), "resname", resourceType);
resource.setUuid("" + new Random().nextInt());
resource.setAgent(agent);
resource.setInventoryStatus(InventoryStatus.COMMITTED);
resource.addDriftDefinition(test1Def);
resource.addDriftDefinition(test2Def);
em.persist(resource);
} catch (Exception e) {
System.out.println("CANNOT PREPARE TEST: " + e);
getTransactionManager().rollback();
throw e;
}
em.flush();
getTransactionManager().commit();
} finally {
}
return resource;
}
protected DiscoveredResourceDetails createResourceDetails(
ResourceDiscoveryContext<T> discoveryContext, Configuration pluginConfig) {
ResourceType resourceType = discoveryContext.getResourceType();
String resourceKey = composeResourceKey(pluginConfig);
DiscoveredResourceDetails resource =
new DiscoveredResourceDetails(
resourceType,
resourceKey,
resourceType.getName(),
null,
resourceType.getDescription(),
pluginConfig,
null);
return resource;
}
public static void convertConfigurationToManagedProperties(
Map<String, ManagedProperty> managedProperties,
Configuration configuration,
ResourceType resourceType,
Map<String, PropertySimple> customProps) {
ConfigurationDefinition configDefinition = resourceType.getResourceConfigurationDefinition();
Set<String> missingManagedPropertyNames = new HashSet<String>();
for (Property property : configuration.getProperties()) {
String propertyName = property.getName();
ManagedProperty managedProperty = managedProperties.get(propertyName);
PropertyDefinition propertyDefinition = configDefinition.get(propertyName);
if (managedProperty == null) {
// NOTE: We expect the Profile Service to always return templates that contain *all*
// ManagedProperties
// that are defined for the ComponentType, so this is considered an error. We could
// build a
// ManagedProperty from scratch based on only a PropertyDefinition anyway, since a
// propDef could
// map to multiple different types of MetaValues (e.g. a PropertyList could
// potentially map to
// either an ArrayValue or a CollectionValue).
missingManagedPropertyNames.add(propertyName);
} else {
populateManagedPropertyFromProperty(
property, propertyDefinition, managedProperty, customProps.get(propertyName));
}
if (!missingManagedPropertyNames.isEmpty())
throw new IllegalStateException(
"***** The following properties are defined in this plugin's "
+ "descriptor but have no corresponding ManagedProperties: "
+ missingManagedPropertyNames);
}
return;
}
protected static Configuration getDefaultPluginConfiguration(ResourceType resourceType) {
ConfigurationTemplate pluginConfigDefaultTemplate =
resourceType.getPluginConfigurationDefinition().getDefaultTemplate();
return (pluginConfigDefaultTemplate != null)
? pluginConfigDefaultTemplate.createConfiguration()
: new Configuration();
}
/**
* Makes this resource type a child of the given parent resource type.
*
* @param parentResourceType
*/
public void addParentResourceType(ResourceType parentResourceType) {
if (parentResourceType.childResourceTypes == null
|| parentResourceType.childResourceTypes.equals(Collections.emptySet())) {
parentResourceType.childResourceTypes = new HashSet<ResourceType>(1);
}
parentResourceType.childResourceTypes.add(this);
this.parentResourceTypes.add(parentResourceType);
}
@Override
protected String getIcon(Record record, boolean defaultState) {
if (record instanceof TreeNode) {
// boolean open = getTree().isOpen((TreeNode) record);
if (record instanceof ResourceTypePluginTreeDataSource.ResourceTypeTreeNode) {
ResourceType resourceType =
((ResourceTypePluginTreeDataSource.ResourceTypeTreeNode) record).getResourceType();
return ImageManager.getResourceIcon(resourceType.getCategory());
} else if (record instanceof ResourceTypePluginTreeDataSource.PluginTreeNode) {
return "types/plugin_16.png";
}
}
return null;
}
@Override
public int hashCode() {
int result;
result = (resourceType != null) ? resourceType.hashCode() : 0;
result = 31 * result + ((name != null) ? name.hashCode() : 0);
result = 31 * result + id;
return result;
}
/**
* Returns an instantiated and loaded versions store access point.
*
* @return will not be <code>null</code>
*/
private org.rhq.core.pluginapi.content.version.PackageVersions loadPackageVersions() {
if (this.versions == null) {
ResourceType resourceType = resourceContext.getResourceType();
String pluginName = resourceType.getPlugin();
File dataDirectoryFile = resourceContext.getDataDirectory();
dataDirectoryFile.mkdirs();
String dataDirectory = dataDirectoryFile.getAbsolutePath();
log.trace(
"Creating application versions store with plugin name [" //$NON-NLS-1$
+ pluginName
+ "] and data directory ["
+ dataDirectory //$NON-NLS-1$
+ "]"); //$NON-NLS-1$
this.versions = new PackageVersions(pluginName, dataDirectory);
this.versions.loadFromDisk();
}
return this.versions;
}
@Override
public ResourceGroupComposite copyValues(Record from) {
Integer idAttrib = from.getAttributeAsInt("id");
String nameAttrib = from.getAttribute(NAME.propertyName());
String descriptionAttrib = from.getAttribute(DESCRIPTION.propertyName());
String typeNameAttrib = from.getAttribute(TYPE.propertyName());
ResourceGroup rg = new ResourceGroup(nameAttrib);
rg.setId(idAttrib);
rg.setDescription(descriptionAttrib);
if (typeNameAttrib != null) {
ResourceType rt = new ResourceType();
rt.setName(typeNameAttrib);
String pluginNameAttrib = from.getAttribute(PLUGIN.propertyName());
rt.setPlugin(pluginNameAttrib);
rg.setResourceType(rt);
}
Long explicitCount = Long.valueOf(from.getAttribute("explicitCount"));
Long explicitDown = Long.valueOf(from.getAttribute("explicitDown"));
Long explicitUnknown = Long.valueOf(from.getAttribute("explicitUnknown"));
Long explicitDisabled = Long.valueOf(from.getAttribute("explicitDisabled"));
Long implicitCount = Long.valueOf(from.getAttribute("implicitCount"));
Long implicitDown = Long.valueOf(from.getAttribute("implicitDown"));
Long implicitUnknown = Long.valueOf(from.getAttribute("implicitUnknown"));
Long implicitDisabled = Long.valueOf(from.getAttribute("implicitDisabled"));
ResourceGroupComposite composite =
new ResourceGroupComposite(
explicitCount,
explicitDown,
explicitUnknown,
explicitDisabled,
implicitCount,
implicitDown,
implicitUnknown,
implicitDisabled,
rg);
return composite;
}
private void removeExistingSingletons(
List<Resource> singletonChildren, Map<String, ResourceType> displayNameMap) {
List<String> existingSingletons = new ArrayList<String>();
Set<String> displayNames = displayNameMap.keySet();
for (final String displayName : displayNames) {
final ResourceType type = displayNameMap.get(displayName);
boolean exists = false;
if (type.isSingleton()) {
for (Resource child : singletonChildren) {
exists = child.getResourceType().equals(displayNameMap.get(displayName));
if (exists) {
existingSingletons.add(displayName);
break;
}
}
}
}
for (String existing : existingSingletons) {
displayNameMap.remove(existing);
}
}
public static KnownDeploymentTypes getDeploymentType(@NotNull ResourceType resourceType) {
String resourceTypeName = resourceType.getName();
if (DEPLOYMENT_TYPE_CACHE.containsKey(resourceTypeName))
return DEPLOYMENT_TYPE_CACHE.get(resourceTypeName);
Configuration defaultPluginConfig = getDefaultPluginConfiguration(resourceType);
String typeName =
defaultPluginConfig.getSimpleValue(
AbstractManagedDeploymentComponent.DEPLOYMENT_TYPE_NAME_PROPERTY, null);
if (typeName == null || typeName.equals(""))
throw new IllegalStateException(
"Required plugin configuration property '"
+ ManagedComponentComponent.Config.COMPONENT_TYPE
+ "' is not defined in default template.");
KnownDeploymentTypes deploymentType = KnownDeploymentTypes.valueOf(typeName);
DEPLOYMENT_TYPE_CACHE.put(resourceTypeName, deploymentType);
return deploymentType;
}
@Override
protected void setConfiguration(Configuration configuration, ResourceType resourceType) {
if (resourceType.getName().equals(ORACLE_SERVER)) {
log.info(configuration.getProperties());
Pattern p = Pattern.compile("jdbc:.*:@(.*):(\\d+):(\\w++)");
String url = System.getProperty("oracle.url");
if (url == null) throw new IllegalStateException("oracle.url system property not set");
Matcher matcher = p.matcher(url);
if (!matcher.matches())
throw new IllegalStateException("Cannot match " + p.pattern() + " against " + url);
configuration.getSimple("host").setStringValue(matcher.group(1));
configuration.getSimple("port").setIntegerValue(Integer.parseInt(matcher.group(2)));
configuration.getSimple("sid").setStringValue(matcher.group(3));
username = System.getProperty("oracle.username");
String password = System.getProperty("oracle.password");
configuration.getSimple("principal").setStringValue(username);
configuration.getSimple("credentials").setStringValue(password);
}
}
public ResourceType(
String name, String plugin, ResourceCategory category, ResourceType parentResourceType) {
if (name == null) {
throw new IllegalArgumentException("name==null");
}
if (plugin == null) {
throw new IllegalArgumentException("plugin==null");
}
// Initialize empty ordered lists...
this.childResourceTypes = null;
this.parentResourceTypes = new HashSet<ResourceType>(1);
this.metricDefinitions = new LinkedHashSet<MeasurementDefinition>();
this.name = name;
this.category = category;
this.plugin = plugin;
this.mtime = this.ctime = System.currentTimeMillis();
if (parentResourceType != null) {
parentResourceType.addChildResourceType(this);
}
}
@Override
public boolean equals(Object obj) {
if (this == obj) return true;
if (obj == null || !(obj instanceof EventDefinition)) return false;
EventDefinition that = (EventDefinition) obj;
if ((resourceType != null)
? (!resourceType.equals(that.resourceType))
: (that.resourceType != null)) {
return false;
}
if ((name != null ? (!name.equals(that.name)) : (that.name != null))) {
return false;
}
if (id != 0 && that.id != 0 && id != that.id) {
return false;
}
return true;
}
public static ComponentType getComponentType(@NotNull ResourceType resourceType) {
String resourceTypeName = resourceType.getName();
if (COMPONENT_TYPE_CACHE.containsKey(resourceTypeName))
return COMPONENT_TYPE_CACHE.get(resourceTypeName);
Configuration defaultPluginConfig = getDefaultPluginConfiguration(resourceType);
String type =
defaultPluginConfig.getSimpleValue(ManagedComponentComponent.Config.COMPONENT_TYPE, null);
if (type == null || type.equals(""))
throw new IllegalStateException(
"Required plugin configuration property '"
+ ManagedComponentComponent.Config.COMPONENT_TYPE
+ "' is not defined in default template.");
String subtype =
defaultPluginConfig.getSimpleValue(
ManagedComponentComponent.Config.COMPONENT_SUBTYPE, null);
if (subtype == null || subtype.equals(""))
throw new IllegalStateException(
"Required plugin configuration property '"
+ ManagedComponentComponent.Config.COMPONENT_SUBTYPE
+ "' is not defined in default template.");
ComponentType componentType = new ComponentType(type, subtype);
COMPONENT_TYPE_CACHE.put(resourceTypeName, componentType);
return componentType;
}
private static Map<String, ResourceType> getDisplayNames(Set<ResourceType> types) {
Set<String> allNames = new HashSet<String>();
Set<String> repeatedNames = new HashSet<String>();
for (ResourceType type : types) {
String typeName = type.getName();
if (allNames.contains(typeName)) {
repeatedNames.add(typeName);
} else {
allNames.add(typeName);
}
}
Map<String, ResourceType> results = new TreeMap<String, ResourceType>();
for (ResourceType type : types) {
String displayName = type.getName();
if (repeatedNames.contains(type.getName())) {
displayName += " (" + type.getPlugin() + " plugin)";
}
results.put(displayName, type);
}
return results;
}
@AfterMethod
public void tearDownAfterMethod() throws Exception {
try {
TransactionManager tx = getTransactionManager();
tx.begin();
EntityManager entityManager = getEntityManager();
Query query;
ContentSourceManagerLocal contentSourceManagerLocal = LookupUtil.getContentSourceManager();
RepoManagerLocal repoManager = LookupUtil.getRepoManagerLocal();
DistributionManagerLocal distroManager = LookupUtil.getDistributionManagerLocal();
SubjectManagerLocal subjectManager = LookupUtil.getSubjectManager();
Subject overlord = subjectManager.getOverlord();
// Delete all distributions
distroManager.deleteDistributionMappingsForRepo(overlord, repoToSync.getId());
for (String distroLabel : TestContentProvider.DISTRIBUTIONS.keySet()) {
Distribution distro = distroManager.getDistributionByLabel(distroLabel);
if (distro != null) {
// Delete the files
query = entityManager.createNamedQuery(DistributionFile.DELETE_BY_DIST_ID);
query.setParameter("distId", distro.getId());
query.executeUpdate();
// Delete the actual distro
distroManager.deleteDistributionByDistId(overlord, distro.getId());
}
}
// Delete all package version <-> content source mappings
for (ContentSource source : repoContentSources) {
contentSourceManagerLocal.deleteContentSource(overlord, source.getId());
}
repoContentSources.clear();
// Delete the repo
repoManager.deleteRepo(overlord, repoToSync.getId());
// Delete any packages that were created
for (ContentProviderPackageDetails details : TestContentProvider.PACKAGES.values()) {
String packageName = details.getContentProviderPackageDetailsKey().getName();
query = entityManager.createNamedQuery(Package.QUERY_FIND_BY_NAME_PKG_TYPE_ID);
query.setParameter("name", packageName);
query.setParameter("packageTypeId", packageType.getId());
Package p = (Package) query.getSingleResult();
entityManager.remove(p);
}
// Delete the package type
packageType = entityManager.find(PackageType.class, packageType.getId());
entityManager.remove(packageType);
resourceType = entityManager.find(ResourceType.class, resourceType.getId());
entityManager.remove(resourceType);
// Delete the content source type
contentSourceType = entityManager.find(ContentSourceType.class, contentSourceType.getId());
entityManager.remove(contentSourceType);
tx.commit();
// Cleanup providers between tests
contentProvider1.reset();
contentProvider2.reset();
} finally {
// Plugin service teardown
unprepareServerPluginService();
unprepareScheduler();
}
}
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;
}
}
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);
}
