public MockInventoryManager() { super(pcConfig, null, pluginManager, new EventManager(pcConfig)); platformType = new ResourceType( "platformResourceTypeName", "pluginName", ResourceCategory.PLATFORM, null); bundleHandlerType = new ResourceType("bhRTypeName", "pluginName", ResourceCategory.SERVER, platformType); serverTypeFS = new ResourceType( "typeName-fileSystem", "pluginName", ResourceCategory.SERVER, platformType); serverTypePC = new ResourceType( "typeName-plugConfig", "pluginName", ResourceCategory.SERVER, platformType); serverTypeRC = new ResourceType( "typeName-reSconfig", "pluginName", ResourceCategory.SERVER, platformType); serverTypeMT = new ResourceType("typeName-trait", "pluginName", ResourceCategory.SERVER, platformType); int id = 1; platform = new Resource("platformKey", "platformName", platformType); platform.setId(id++); bundleHandler = new Resource("bhKey", "bhName", bundleHandlerType); bundleHandler.setId(id++); bundleHandler.setParentResource(platform); bundleHandler.setUuid(UUID.randomUUID().toString()); serverFS = new Resource("serverKey-fileSystem", "serverName-fileSystem", serverTypeFS); serverFS.setId(id++); serverFS.setParentResource(platform); serverPC = new Resource("serverKey-plugConfig", "serverName-plugConfig", serverTypePC); serverPC.setId(id++); serverPC.setParentResource(platform); serverRC = new Resource("serverKey-resConfig", "serverName-resConfig", serverTypeRC); serverRC.setId(id++); serverRC.setParentResource(platform); serverMT = new Resource("serverKey-traitConfig", "serverName-traitConfig", serverTypeMT); serverMT.setId(id++); serverMT.setParentResource(platform); typeResourceMap.put(platformType, platform); typeResourceMap.put(bundleHandlerType, bundleHandler); typeResourceMap.put(serverTypeFS, serverFS); typeResourceMap.put(serverTypePC, serverPC); typeResourceMap.put(serverTypeRC, serverRC); typeResourceMap.put(serverTypeMT, serverMT); ResourceContainer platformContainer = new ResourceContainer(platform, null); ResourceContainer bundleHandlerContainer = new ResourceContainer(bundleHandler, null); ResourceContainer serverContainerFS = new ResourceContainer(serverFS, null); ResourceContainer serverContainerPC = new ResourceContainer(serverPC, null); ResourceContainer serverContainerRC = new ResourceContainer(serverRC, null); ResourceContainer serverContainerMT = new ResourceContainer(serverMT, null); idResourceContainerMap.put(platform.getId(), platformContainer); idResourceContainerMap.put(bundleHandler.getId(), bundleHandlerContainer); idResourceContainerMap.put(serverFS.getId(), serverContainerFS); idResourceContainerMap.put(serverPC.getId(), serverContainerPC); idResourceContainerMap.put(serverRC.getId(), serverContainerRC); idResourceContainerMap.put(serverMT.getId(), serverContainerMT); bundleHandlerContainer.setResourceContext(new MockResourceContext(bundleHandler)); // each different resource type that supports bundle deployments needs to define its // bundle configuration to denote where the base directory location is found. // Today we support four ways: via plugin config property, resource config property, // measurement trait value, or strictly on the root file system (using no resource specific // value) ResourceTypeBundleConfiguration rtbc = new ResourceTypeBundleConfiguration(new Configuration()); rtbc.addBundleDestinationBaseDirectory( BUNDLE_CONFIG_NAME_FS, Context.fileSystem.name(), BUNDLE_CONFIG_CONTEXT_VALUE_FS, null); serverTypeFS.setResourceTypeBundleConfiguration(rtbc); rtbc = new ResourceTypeBundleConfiguration(new Configuration()); rtbc.addBundleDestinationBaseDirectory( BUNDLE_CONFIG_NAME_PC, Context.pluginConfiguration.name(), BUNDLE_CONFIG_CONTEXT_VALUE_PC, null); serverTypePC.setResourceTypeBundleConfiguration(rtbc); rtbc = new ResourceTypeBundleConfiguration(new Configuration()); rtbc.addBundleDestinationBaseDirectory( BUNDLE_CONFIG_NAME_RC, Context.resourceConfiguration.name(), BUNDLE_CONFIG_CONTEXT_VALUE_RC, null); serverTypeRC.setResourceTypeBundleConfiguration(rtbc); rtbc = new ResourceTypeBundleConfiguration(new Configuration()); rtbc.addBundleDestinationBaseDirectory( BUNDLE_CONFIG_NAME_MT, Context.measurementTrait.name(), BUNDLE_CONFIG_CONTEXT_VALUE_MT, null); serverTypeMT.setResourceTypeBundleConfiguration(rtbc); // each different resource needs to specify where exactly it wants the bundles deployed // using the different contexts that are supported. Configuration pluginConfiguration = new Configuration(); pluginConfiguration.put( new PropertySimple(BUNDLE_CONFIG_CONTEXT_VALUE_PC, BUNDLE_CONFIG_LOCATION_PC)); serverPC.setPluginConfiguration(pluginConfiguration); Configuration resourceConfiguration = new Configuration(); resourceConfiguration.put( new PropertySimple(BUNDLE_CONFIG_CONTEXT_VALUE_RC, BUNDLE_CONFIG_LOCATION_RC)); serverRC.setResourceConfiguration(resourceConfiguration); MeasurementDefinition definition = new MeasurementDefinition(serverTypeMT, BUNDLE_CONFIG_CONTEXT_VALUE_MT); definition.setDataType(DataType.TRAIT); definition.setId(123); MeasurementSchedule schedule = new MeasurementSchedule(definition, serverMT); schedule.setId(123123); MeasurementScheduleRequest scheduleRequest = new MeasurementScheduleRequest(schedule); Set<MeasurementScheduleRequest> schedules = new HashSet<MeasurementScheduleRequest>(1); schedules.add(scheduleRequest); serverContainerMT.setMeasurementSchedule(schedules); }
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(); } } } } }