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; }
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); }
@SuppressWarnings({"rawtypes", "unchecked"}) @Test public void loadResourceConfigurationWithType() throws Exception { // tell the method story as it happens: mock or create dependencies and configure // those dependencies to get the method under test to completion. ResourceContext mockResourceContext = mock(ResourceContext.class); ResourceType mockResourceType = mock(ResourceType.class); when(mockResourceContext.getResourceType()).thenReturn(mockResourceType); ConfigurationDefinition mockConfigurationDefinition = mock(ConfigurationDefinition.class); when(mockResourceType.getResourceConfigurationDefinition()) .thenReturn(mockConfigurationDefinition); ConfigurationTemplate mockConfigurationTemplate = mock(ConfigurationTemplate.class); when(mockConfigurationDefinition.getDefaultTemplate()).thenReturn(mockConfigurationTemplate); Configuration mockConfiguration = mock(Configuration.class); when(mockConfigurationTemplate.getConfiguration()).thenReturn(mockConfiguration); Property mockProperty = mock(Property.class); when(mockConfiguration.get(eq("__type"))).thenReturn(mockProperty); Map<String, PropertyDefinition> mockMap = (Map<String, PropertyDefinition>) mock(Map.class); when(mockConfigurationDefinition.getPropertyDefinitions()).thenReturn(mockMap); ConfigurationLoadDelegate mockConfigurationLoadDelegate = mock(ConfigurationLoadDelegate.class); PowerMockito.whenNew(ConfigurationLoadDelegate.class) .withParameterTypes(ConfigurationDefinition.class, ASConnection.class, Address.class) .withArguments( any(ConfigurationDefinition.class), any(ASConnection.class), any(Address.class)) .thenReturn(mockConfigurationLoadDelegate); when(mockConfigurationLoadDelegate.loadResourceConfiguration()).thenReturn(mockConfiguration); PropertySimple pathPropertySimple = new PropertySimple("path", "abc=def,xyz=test1"); when(mockConfiguration.get(eq("path"))).thenReturn(pathPropertySimple); when(mockResourceContext.getPluginConfiguration()).thenReturn(mockConfiguration); ASConnection mockASConnection = mock(ASConnection.class); PropertySimple typePropertySimple = new PropertySimple("__type", "xyz"); PowerMockito.whenNew(PropertySimple.class) .withParameterTypes(String.class, Object.class) .withArguments(eq("__type"), eq("xyz")) .thenReturn(typePropertySimple); // create object to test and inject required dependencies TemplatedComponent objectUnderTest = new TemplatedComponent(); objectUnderTest.context = mockResourceContext; objectUnderTest.testConnection = mockASConnection; // run code under test Configuration result = objectUnderTest.loadResourceConfiguration(); // verify the results (Assert and mock verification) Assert.assertEquals(result, mockConfiguration); verify(mockMap, times(1)).remove(eq("__type")); verify(mockConfiguration, times(1)).get(eq("__type")); verify(mockConfiguration, never()).get(eq("__name")); verify(mockConfiguration, times(1)).get(eq("path")); verify(mockConfiguration, times(1)).put(eq(typePropertySimple)); PowerMockito.verifyNew(PropertySimple.class).withArguments(eq("__type"), eq("xyz")); PowerMockito.verifyNew(ConfigurationLoadDelegate.class) .withArguments( any(ConfigurationDefinition.class), eq(mockASConnection), any(Address.class)); }
@SuppressWarnings({"rawtypes", "unchecked"}) @Test public void updateResourceConfigurationWithName() throws Exception { // tell the method story as it happens: mock or create dependencies and configure // those dependencies to get the method under test to completion. ResourceContext mockResourceContext = mock(ResourceContext.class); ResourceType mockResourceType = mock(ResourceType.class); when(mockResourceContext.getResourceType()).thenReturn(mockResourceType); ConfigurationDefinition mockConfigurationDefinition = mock(ConfigurationDefinition.class); when(mockResourceType.getResourceConfigurationDefinition()) .thenReturn(mockConfigurationDefinition); ConfigurationDefinition mockConfigurationDefinitionCopy = mock(ConfigurationDefinition.class); when(mockConfigurationDefinition.copy()).thenReturn(mockConfigurationDefinitionCopy); ConfigurationTemplate mockConfigurationTemplate = mock(ConfigurationTemplate.class); when(mockConfigurationDefinitionCopy.getDefaultTemplate()) .thenReturn(mockConfigurationTemplate); Configuration mockConfiguration = mock(Configuration.class); when(mockConfigurationTemplate.getConfiguration()).thenReturn(mockConfiguration); Property mockProperty = mock(Property.class); when(mockConfiguration.get(eq("__type"))).thenReturn(null); when(mockConfiguration.get(eq("__name"))).thenReturn(mockProperty); Map<String, PropertyDefinition> mockMap = (Map<String, PropertyDefinition>) mock(Map.class); when(mockConfigurationDefinitionCopy.getPropertyDefinitions()).thenReturn(mockMap); ConfigurationUpdateReport mockReport = mock(ConfigurationUpdateReport.class); when(mockReport.getConfiguration()).thenReturn(mockConfiguration); ConfigurationWriteDelegate mockConfigurationWriteDelegate = mock(ConfigurationWriteDelegate.class); PowerMockito.whenNew(ConfigurationWriteDelegate.class) .withParameterTypes(ConfigurationDefinition.class, ASConnection.class, Address.class) .withArguments( any(ConfigurationDefinition.class), any(ASConnection.class), any(Address.class)) .thenReturn(mockConfigurationWriteDelegate); ASConnection mockASConnection = mock(ASConnection.class); when(mockASConnection.execute(any(ReadResource.class))).thenReturn(new Result()); // create object to test and inject required dependencies TemplatedComponent objectUnderTest = new TemplatedComponent(); objectUnderTest.context = mockResourceContext; objectUnderTest.testConnection = mockASConnection; // run code under test objectUnderTest.updateResourceConfiguration(mockReport); // verify the results (Assert and mock verification) verify(mockMap, times(1)).remove(eq("__name")); verify(mockConfiguration, times(1)).get(eq("__type")); verify(mockConfiguration, times(1)).get(eq("__name")); verify(mockConfiguration, times(1)).remove(eq("__name")); PowerMockito.verifyNew(ConfigurationWriteDelegate.class) .withArguments( any(ConfigurationDefinition.class), eq(mockASConnection), any(Address.class)); }
public static Configuration convertManagedObjectToConfiguration( Map<String, ManagedProperty> managedProperties, Map<String, PropertySimple> customProps, ResourceType resourceType) { Configuration config = new Configuration(); ConfigurationDefinition configDef = resourceType.getResourceConfigurationDefinition(); Map<String, PropertyDefinition> propDefs = configDef.getPropertyDefinitions(); Set<String> propNames = managedProperties.keySet(); for (String propName : propNames) { PropertyDefinition propertyDefinition = propDefs.get(propName); ManagedProperty managedProperty = managedProperties.get(propName); if (propertyDefinition == null) { if (!managedProperty.hasViewUse(ViewUse.STATISTIC)) LOG.debug( resourceType + " does not define a property corresponding to ManagedProperty '" + propName + "'."); continue; } if (managedProperty == null) { // This should never happen, but don't let it blow us up. LOG.error( "ManagedProperty '" + propName + "' has a null value in the ManagedProperties Map."); continue; } MetaValue metaValue = managedProperty.getValue(); if (managedProperty.isRemoved() || metaValue == null) { // Don't even add a Property to the Configuration if the ManagedProperty is flagged as // removed or has a // null value. continue; } PropertySimple customProp = customProps.get(propName); PropertyAdapter propertyAdapter = PropertyAdapterFactory.getCustomPropertyAdapter(customProp); if (propertyAdapter == null) { propertyAdapter = PropertyAdapterFactory.getPropertyAdapter(metaValue); } if (propertyAdapter == null) { LOG.error( "Unable to find a PropertyAdapter for ManagedProperty '" + propName + "' with MetaType [" + metaValue.getMetaType() + "] for ResourceType '" + resourceType.getName() + "'."); continue; } Property property; try { property = propertyAdapter.convertToProperty(metaValue, propertyDefinition); } catch (RuntimeException e) { throw new RuntimeException( "Failed to convert managed property " + managedProperty + " to RHQ property of type " + propertyDefinition + ".", e); } config.put(property); } return config; }
public void checkConfigurations(Resource resource, boolean checkChildren) { ResourceContainer resourceContainer = this.inventoryManager.getResourceContainer(resource); ConfigurationFacet resourceComponent = null; ResourceType resourceType = resource.getResourceType(); if (resourceContainer != null && resourceContainer.getAvailability() != null && resourceContainer.getAvailability().getAvailabilityType() == AvailabilityType.UP) { try { resourceComponent = resourceContainer.createResourceComponentProxy( ConfigurationFacet.class, FacetLockType.NONE, CONFIGURATION_CHECK_TIMEOUT, true, false); } catch (PluginContainerException e) { // Expecting when the resource does not support configuration management } if (resourceComponent != null) { // Only report availability for committed resources; don't bother with new, ignored or // deleted resources. if (resource.getInventoryStatus() == InventoryStatus.COMMITTED && resourceType.getResourceConfigurationDefinition() != null) { if (log.isErrorEnabled()) log.debug("Checking for updated resource configuration on: " + resource); ConfigurationUpdateRequest request = new ConfigurationUpdateRequest( 0, resource.getResourceConfiguration(), resource.getId()); try { Configuration liveConfiguration = resourceComponent.loadResourceConfiguration(); if (liveConfiguration != null) { ConfigurationDefinition configurationDefinition = resourceType.getResourceConfigurationDefinition(); // Normalize and validate the config. ConfigurationUtility.normalizeConfiguration( liveConfiguration, configurationDefinition); List<String> errorMessages = ConfigurationUtility.validateConfiguration( liveConfiguration, configurationDefinition); for (String errorMessage : errorMessages) { log.warn( "Plugin Error: Invalid " + resourceType.getName() + " resource configuration returned by " + resourceType.getPlugin() + " plugin - " + errorMessage); } Configuration original = resource.getResourceConfiguration(); if (!liveConfiguration.equals(original)) { log.info("New configuration version detected on resource: " + resource); this.configurationServerService.persistUpdatedResourceConfiguration( resource.getId(), liveConfiguration); resource.setResourceConfiguration(liveConfiguration); } } } catch (Throwable t) { log.warn("Unable to check for updated configuration", t); } } } if (checkChildren) { // Avoid concurrent mod exceptions during potentially long duration issues Set<Resource> childSet = new HashSet<Resource>(resource.getChildResources()); for (Resource child : childSet) { try { checkConfigurations(child, true); } catch (Exception e) { e.printStackTrace(); } } } } }
@Override public void updateResourceConfiguration( final ConfigurationUpdateReport configurationUpdateReport) { ResourceType resourceType = context.getResourceType(); ConfigurationDefinition configDef = resourceType.getResourceConfigurationDefinition(); Configuration newConfig = configurationUpdateReport.getConfiguration(); // remove special property being possibly sent from server in case EAP requires reload/restart newConfig.remove("__OOB"); // 1. First of all, read the current configuration ConfigurationLoadDelegate readDelegate = new ConfigurationLoadDelegate(configDef, getASConnection(), address, includeRuntime); Configuration currentConfig; try { currentConfig = readDelegate.loadResourceConfiguration(); } catch (Exception e) { getLog().error("Could not read current configuration before update", e); configurationUpdateReport.setStatus(FAILURE); configurationUpdateReport.setErrorMessage( "Could not read current configuration before update: " + ThrowableUtil.getRootMessage(e)); return; } // 2. We will wrap all property-simple and connection properties changes in a composite // operation CompositeOperation updateOperation = new CompositeOperation(); // 3. Capture property-simple changes Map<String, PropertySimple> newConfigSimpleProperties = newConfig.getSimpleProperties(); Map<String, PropertySimple> currentConfigSimpleProperties = currentConfig.getSimpleProperties(); Set<String> allSimplePropertyNames = new HashSet<String>( newConfigSimpleProperties.size() + currentConfigSimpleProperties.size()); allSimplePropertyNames.addAll(newConfigSimpleProperties.keySet()); allSimplePropertyNames.addAll(currentConfigSimpleProperties.keySet()); // Read-only allSimplePropertyNames.remove(ENABLED_ATTRIBUTE); for (String simplePropertyName : allSimplePropertyNames) { PropertySimple newConfigPropertySimple = newConfigSimpleProperties.get(simplePropertyName); String newConfigPropertySimpleValue = newConfigPropertySimple == null ? null : newConfigPropertySimple.getStringValue(); PropertySimple currentConfigPropertySimple = currentConfigSimpleProperties.get(simplePropertyName); String currentConfigPropertySimpleValue = currentConfigPropertySimple == null ? null : currentConfigPropertySimple.getStringValue(); boolean canUnset = !UNSET_FORBIDDEN_ATTRIBUTES.contains(simplePropertyName); if (newConfigPropertySimpleValue == null) { if (currentConfigPropertySimpleValue != null) { String val; if (canUnset) { val = null; } else { val = configDef.getPropertyDefinitionSimple(simplePropertyName).getDefaultValue(); } updateOperation.addStep(new WriteAttribute(getAddress(), simplePropertyName, val)); } } else if (!newConfigPropertySimpleValue.equals(currentConfigPropertySimpleValue)) { updateOperation.addStep( new WriteAttribute(getAddress(), simplePropertyName, newConfigPropertySimpleValue)); } } // 4. Capture connection property changes String connPropAttributeNameOnServer, connPropPluginConfigPropertyName, keyName; if (isXADatasourceResource(resourceType)) { connPropAttributeNameOnServer = "xa-datasource-properties"; connPropPluginConfigPropertyName = XA_DATASOURCE_PROPERTIES_ATTRIBUTE; keyName = "key"; } else { connPropAttributeNameOnServer = "connection-properties"; connPropPluginConfigPropertyName = CONNECTION_PROPERTIES_ATTRIBUTE; keyName = "pname"; } Map<String, String> newConfigConnectionProperties = getConnectionPropertiesAsMap(newConfig.getList(connPropPluginConfigPropertyName), keyName); Map<String, String> currentConfigConnectionProperties = getConnectionPropertiesAsMap( currentConfig.getList(connPropPluginConfigPropertyName), keyName); Set<String> allConnectionPropertyNames = new HashSet<String>( newConfigConnectionProperties.size() + currentConfigConnectionProperties.size()); allConnectionPropertyNames.addAll(newConfigConnectionProperties.keySet()); allConnectionPropertyNames.addAll(currentConfigConnectionProperties.keySet()); for (String connectionPropertyName : allConnectionPropertyNames) { Address propertyAddress = new Address(getAddress()); propertyAddress.add(connPropAttributeNameOnServer, connectionPropertyName); String newConfigConnectionPropertyValue = newConfigConnectionProperties.get(connectionPropertyName); String currentConfigConnectionPropertyValue = currentConfigConnectionProperties.get(connectionPropertyName); if (newConfigConnectionPropertyValue == null) { updateOperation.addStep(new Operation("remove", propertyAddress)); } else if (currentConfigConnectionPropertyValue == null) { Operation addOperation = new Operation("add", propertyAddress); addOperation.addAdditionalProperty("value", newConfigConnectionPropertyValue); updateOperation.addStep(addOperation); } else if (!newConfigConnectionPropertyValue.equals(currentConfigConnectionPropertyValue)) { updateOperation.addStep(new Operation("remove", propertyAddress)); Operation addOperation = new Operation("add", propertyAddress); addOperation.addAdditionalProperty("value", newConfigConnectionPropertyValue); updateOperation.addStep(addOperation); } } // 5. Update config if needed if (updateOperation.numberOfSteps() > 0) { Result res = getASConnection().execute(updateOperation); if (res.isSuccess()) { configurationUpdateReport.setStatus(SUCCESS); } else { configurationUpdateReport.setStatus(FAILURE); configurationUpdateReport.setErrorMessage(res.getFailureDescription()); } } else { configurationUpdateReport.setStatus(NOCHANGE); } }