/*
* RHQ Management Platform
* Copyright (C) 2005-2014 Red Hat, Inc.
* All rights reserved.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation version 2 of the License.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software Foundation, Inc.,
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
*/
package org.rhq.plugins.database;
import static org.testng.AssertJUnit.assertEquals;
import static org.testng.AssertJUnit.assertNotNull;
import static org.testng.AssertJUnit.assertTrue;
import static org.testng.AssertJUnit.fail;
import java.io.File;
import java.io.InputStream;
import java.net.URL;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
import javax.xml.bind.JAXBElement;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.testng.annotations.AfterSuite;
import org.testng.annotations.AfterTest;
import org.testng.annotations.BeforeClass;
import org.testng.annotations.BeforeSuite;
import org.rhq.core.clientapi.agent.metadata.PluginMetadataManager;
import org.rhq.core.clientapi.descriptor.AgentPluginDescriptorUtil;
import org.rhq.core.clientapi.descriptor.configuration.ConfigurationProperty;
import org.rhq.core.clientapi.descriptor.plugin.MetricDescriptor;
import org.rhq.core.clientapi.descriptor.plugin.PluginDescriptor;
import org.rhq.core.clientapi.descriptor.plugin.ResourceDescriptor;
import org.rhq.core.clientapi.descriptor.plugin.ServerDescriptor;
import org.rhq.core.clientapi.descriptor.plugin.ServiceDescriptor;
import org.rhq.core.domain.configuration.Configuration;
import org.rhq.core.domain.configuration.PropertySimple;
import org.rhq.core.domain.measurement.AvailabilityType;
import org.rhq.core.domain.measurement.MeasurementDataNumeric;
import org.rhq.core.domain.measurement.MeasurementDataTrait;
import org.rhq.core.domain.measurement.MeasurementDefinition;
import org.rhq.core.domain.measurement.MeasurementReport;
import org.rhq.core.domain.measurement.MeasurementSchedule;
import org.rhq.core.domain.measurement.MeasurementScheduleRequest;
import org.rhq.core.domain.resource.ProcessScan;
import org.rhq.core.domain.resource.Resource;
import org.rhq.core.domain.resource.ResourceType;
import org.rhq.core.pc.PluginContainer;
import org.rhq.core.pc.PluginContainerConfiguration;
import org.rhq.core.pc.availability.AvailabilityContextImpl;
import org.rhq.core.pc.content.ContentContextImpl;
import org.rhq.core.pc.event.EventContextImpl;
import org.rhq.core.pc.event.EventManager;
import org.rhq.core.pc.inventory.InventoryContextImpl;
import org.rhq.core.pc.inventory.ResourceContainer;
import org.rhq.core.pc.operation.OperationContextImpl;
import org.rhq.core.pluginapi.availability.AvailabilityContext;
import org.rhq.core.pluginapi.configuration.ConfigurationFacet;
import org.rhq.core.pluginapi.content.ContentContext;
import org.rhq.core.pluginapi.event.EventContext;
import org.rhq.core.pluginapi.inventory.DiscoveredResourceDetails;
import org.rhq.core.pluginapi.inventory.InventoryContext;
import org.rhq.core.pluginapi.inventory.PluginContainerDeployment;
import org.rhq.core.pluginapi.inventory.ProcessScanResult;
import org.rhq.core.pluginapi.inventory.ResourceComponent;
import org.rhq.core.pluginapi.inventory.ResourceContext;
import org.rhq.core.pluginapi.inventory.ResourceDiscoveryComponent;
import org.rhq.core.pluginapi.inventory.ResourceDiscoveryContext;
import org.rhq.core.pluginapi.measurement.MeasurementFacet;
import org.rhq.core.pluginapi.operation.OperationContext;
import org.rhq.core.system.ProcessInfo;
import org.rhq.core.system.SystemInfo;
import org.rhq.core.system.SystemInfoFactory;
import org.rhq.core.system.pquery.ProcessInfoQuery;
/**
* Base class for RHQ Component Testing.
* Initializes a plugin configuration.
*
* Methods to override:
*
* {@link #setConfiguration(Configuration, ResourceType)}
*/
public abstract class ComponentTest {
/**
* Logging component.
*/
protected final Log log = LogFactory.getLog(getClass());
private static File temp = new File(System.getProperty("java.io.tmpdir"));
/**
* Associates a resource component with a resource.
*/
protected Map<ResourceComponent, Resource> components = new LinkedHashMap<ResourceComponent, Resource>();
/**
* Associates a name of a resource with a resource descriptor.
*/
protected Map<String, ResourceDescriptor> descriptors = new LinkedHashMap<String, ResourceDescriptor>();
/**
* Associates a name of a resource with a type.
* This is useful for manually adding resources.
*
* @see #manuallyAdd(ResourceType, Configuration)
*/
protected Map<String, ResourceType> resourceTypes = new LinkedHashMap<String, ResourceType>();
/**
* Event manager; used to obtain events.
*/
private EventManager eventManager;
private final PluginContainer pluginContainer = PluginContainer.getInstance();
private final SystemInfo systemInfo = SystemInfoFactory.createSystemInfo();
/**
* Scan all processes before starting; false will disable this feature.
* Disabling is suggested for running tests against a remote instance.
*/
private boolean processScan = true;
// TODO
private final PluginMetadataManager pmm = new PluginMetadataManager();
private final File temporaryDirectory = temp;
private final File dataDirectory = temp;
private final String pluginContainerName = "rhq";
private final OperationContext operationContext = new OperationContextImpl(0, null);
private final ContentContext contentContext = new ContentContextImpl(0, null);
private PluginContainerDeployment pluginContainerDeployment = null;
private Resource platform;
private ResourceContainer platformContainer;
private List<ProcessInfo> processInfo = Collections.emptyList();
private PluginDescriptor pluginDescriptor;
private AvailabilityContext availabilityContext;
private InventoryContext inventoryContext;
/**
* Constructs a new component test.
*/
protected ComponentTest() {
}
/**
* Initializes the plugin container.
* This is run before {@link #before()}.
*/
@BeforeSuite
protected void beforeSuite() {
// Speed up propagation of events by adjusting delay/period to 1 second
PluginContainerConfiguration pcc = new PluginContainerConfiguration();
pcc.setEventSenderInitialDelay(1);
pcc.setEventSenderPeriod(1);
pluginContainer.setConfiguration(pcc);
pluginContainer.initialize();
eventManager = pluginContainer.getEventManager();
platform = pluginContainer.getInventoryManager().getPlatform();
platformContainer = pluginContainer.getInventoryManager().getResourceContainer(platform);
if (platformContainer == null) {
platformContainer = new ResourceContainer(platform, getClass().getClassLoader());
}
}
/**
* Initializes all plugins defined in the system; using auto-discovery where possible.
* This is run once per test class.
*/
@BeforeClass
protected void before() throws Exception {
if (processScan) {
processInfo = getProcessInfos();
if (processInfo == null)
processInfo = Collections.emptyList();
log.debug("Process Info " + processInfo);
for (ProcessInfo i : processInfo) {
log.debug(i.getBaseName() + " " + Arrays.toString(i.getCommandLine()));
}
}
Enumeration<URL> e = getClass().getClassLoader().getResources("META-INF/rhq-plugin.xml");
List<URL> l = Collections.list(e);
Collections.sort(l, new Comparator<URL>() {
@Override
public int compare(URL u1, URL u2) {
return u2.toString().compareTo(u1.toString());
}
});
for (URL url : l) {
log.debug("parse " + url);
InputStream is = url.openStream();
PluginDescriptor pd = AgentPluginDescriptorUtil.parsePluginDescriptor(is);
processPluginDescriptor(pd);
log.debug("pmm names " + pmm.getPluginNames());
buildDesc(pd.getServers());
buildDesc(pd.getServices());
is.close();
}
}
@AfterSuite
protected void afterSuite() {
pluginContainer.shutdown();
}
/**
* Process a plugin descriptor.
*/
private void processPluginDescriptor(PluginDescriptor pd) throws Exception {
this.pluginDescriptor = pd;
Set<ResourceType> types = pmm.loadPlugin(pd);
mapResourceTypeNames(types);
log.info("Resource types: " + resourceTypes);
resources(types, platform, platformContainer.getResourceComponent(), platformContainer.getResourceContext());
log.info("ResourceComponent map: " + components);
}
private void mapResourceTypeNames(Set<ResourceType> types) {
for (ResourceType type : types) {
this.resourceTypes.put(type.getName(), type);
mapResourceTypeNames(type.getChildResourceTypes());
}
}
/**
* Manually create a component by name.
*/
public ResourceComponent manuallyAdd(String name) throws Exception {
ResourceType resourceType = resourceTypes.get(name);
if (resourceType == null)
throw new IllegalStateException("no type " + name);
Configuration configuration = resourceType.getPluginConfigurationDefinition().getDefaultTemplate().createConfiguration();
setConfiguration(configuration, resourceType);
return manuallyAdd(resourceType, configuration);
}
/**
* Manually create a component by resource type.
*/
public ResourceComponent manuallyAdd(ResourceType type, Configuration configuration) throws Exception {
return manuallyAdd(type, configuration, platformContainer.getResourceComponent());
}
/**
* Manually create a component by resource type, configuration, parent.
*/
public ResourceComponent manuallyAdd(ResourceType type, Configuration configuration, ResourceComponent parent) throws Exception {
DiscoveredResourceDetails drd = new DiscoveredResourceDetails(type,
"key", "name", "ver", "desc", configuration, (ProcessInfo) null);
ResourceDiscoveryComponent c = null;
return createChild(drd, platform, configuration, parent, c);
}
private ResourceComponent createChild(DiscoveredResourceDetails drd,
Resource resource,
Configuration configuration,
ResourceComponent parentComponent,
ResourceDiscoveryComponent rdc) throws Exception
{
ResourceType type = pmm.getType(drd.getResourceType());
Resource cresource = new Resource();
cresource.setResourceType(type);
cresource.setPluginConfiguration(configuration);
cresource.setResourceKey(drd.getResourceKey());
cresource.setParentResource(resource);
cresource.setName(drd.getResourceName());
cresource.setVersion(drd.getResourceVersion());
String rclassname = pmm.getComponentClass(type);
ResourceComponent component = (ResourceComponent) Class.forName(rclassname).newInstance();
availabilityContext = new AvailabilityContextImpl(cresource, pluginContainer.getInventoryManager());
inventoryContext = new InventoryContextImpl(cresource, pluginContainer.getInventoryManager());
EventContext eventContext = new EventContextImpl(resource, eventManager);
ResourceContext context = new ResourceContext(cresource, parentComponent,
null, rdc, systemInfo, temporaryDirectory, dataDirectory,
pluginContainerName, eventContext, operationContext, contentContext,
availabilityContext, inventoryContext, pluginContainerDeployment);
component.start(context);
components.put(component, cresource);
resources(type.getChildResourceTypes(), cresource, component, context);
return component;
}
private void resources(Set<ResourceType> types, Resource parent, ResourceComponent component, ResourceContext context) throws Exception {
for (ResourceType type : types) {
String s = pmm.getDiscoveryClass(type);
if (s == null) {
throw new NullPointerException("no discovery " + type);
}
ResourceDiscoveryComponent rdc = (ResourceDiscoveryComponent) Class.forName(s).newInstance();
log.debug("rdc=" + rdc);
ResourceDiscoveryContext resourceDiscoveryContext = new ResourceDiscoveryContext(type, component,
context, systemInfo,
performProcessScans(type), new ArrayList<Configuration>(),
pluginContainerName, pluginContainerDeployment);
Set<DiscoveredResourceDetails> drds = rdc.discoverResources(resourceDiscoveryContext);
for (DiscoveredResourceDetails drd : drds) {
log.debug("discovered " + drd);
ResourceType resourceType = drd.getResourceType();
setConfiguration(drd.getPluginConfiguration(), resourceType);
createChild(drd, parent, drd.getPluginConfiguration(), component, rdc);
}
if (drds.isEmpty()) {
log.warn("not discovered " + type);
context.getPluginConfiguration();
}
}
}
/**
* Called before the configuration is processed; override to set specific plugin parameters.
*/
protected void setConfiguration(Configuration configuration, ResourceType resourceType) {
}
/**
* Stops all components, stops the plugin container.
*/
@AfterTest
protected void after() throws Exception {
for (ResourceComponent c : components.keySet())
c.stop();
// PluginContainer.getInstance().shutdown();
}
/**
* Returns a measurement report.
*/
public MeasurementReport getMeasurementReport(ResourceComponent component) throws Exception {
Resource resource = this.components.get(component);
ResourceType type = resource.getResourceType();
MeasurementReport report = new MeasurementReport();
Set<MeasurementScheduleRequest> s = new HashSet<MeasurementScheduleRequest>();
for (MeasurementDefinition md : type.getMetricDefinitions())
s.add(new MeasurementScheduleRequest(new MeasurementSchedule(md, resource)));
((MeasurementFacet)component).getValues(report, s);
return report;
}
/**
* Returns the first resource component by resource name, then looks by matching resource type name,
* then asserts failure if not found.
*/
public ResourceComponent getComponent(String name) {
for (Map.Entry<ResourceComponent, Resource> c : components.entrySet())
if (c.getValue().getName().equals(name))
return c.getKey();
for (Map.Entry<ResourceComponent, Resource> c : components.entrySet())
if (c.getValue().getResourceType().getName().equals(name))
return c.getKey();
fail("component not found " + name + " in " + components.entrySet());
return null;
}
/**
* Returns a resource matching this component.
*/
public Resource getResource(ResourceComponent rc) {
Resource r = components.get(rc);
if (r == null)
throw new IllegalStateException();
return r;
}
/**
* Returns a resource matching this name.
*/
public Resource getResource(String name) {
return getResource(getComponent(name));
}
/**
* Builds a new configuration for a resource type.
*/
public Configuration getConfiguration(ResourceType resourceType) {
Configuration configuration = resourceType.getPluginConfigurationDefinition().getDefaultTemplate().createConfiguration();
setConfiguration(configuration, resourceType);
return configuration;
}
// ASSERT METHOD
/**
* From a measurement report, returns a measurement value, or asserts failure if no such value exists.
*/
public static Double getValue(MeasurementReport report, String name) {
for (MeasurementDataNumeric m: report.getNumericData()) {
if (m.getName().equals(name)) {
return m.getValue();
}
}
fail("report does not incude " + name + " report " + report.getNumericData());
return null;
}
/**
* Asserts the resource component is available.
*/
public static void assertUp(ResourceComponent component) {
assertEquals("up " + component, AvailabilityType.UP, component.getAvailability());
}
/**
* Asserts the resource component is unavailable.
*/
public static void assertDown(ResourceComponent component) {
assertEquals("down " + component, AvailabilityType.DOWN, component.getAvailability());
}
/**
* Sets a configuration option.
*/
public static void set(Configuration config, String name, String value) {
PropertySimple s = config.getSimple(name);
if (s == null) {
s = new PropertySimple(name, value);
config.put(s);
} else {
s.setStringValue(value);
}
}
private List<ProcessScanResult> performProcessScans(ResourceType serverType) {
List<ProcessScanResult> scanResults = new ArrayList<ProcessScanResult>();
Set<ProcessScan> processScans = serverType.getProcessScans();
log.debug("Executing process scans for server type " + serverType + "...");
ProcessInfoQuery piq = new ProcessInfoQuery(processInfo);
for (ProcessScan processScan : processScans) {
List<ProcessInfo> queryResults = piq.query(processScan.getQuery());
for (ProcessInfo autoDiscoveredProcess : queryResults) {
scanResults.add(new ProcessScanResult(processScan, autoDiscoveredProcess));
log.info("Process scan auto-detected new server resource: scan=[" + processScan
+ "], discovered-process=[" + autoDiscoveredProcess + "]");
}
}
return scanResults;
}
/**
* AutoDiscoveryExecutor method.
*/
private List<ProcessInfo> getProcessInfos() {
SystemInfo systemInfo = SystemInfoFactory.createSystemInfo();
log.debug("Retrieving process table...");
long startTime = System.currentTimeMillis();
List<ProcessInfo> processInfos = null;
try {
processInfos = systemInfo.getAllProcesses();
} catch (UnsupportedOperationException uoe) {
log.debug("Cannot perform process scan - not supported on this platform. (" + systemInfo.getClass() + ")");
}
long elapsedTime = System.currentTimeMillis() - startTime;
log.debug("Retrieval of process table took " + elapsedTime + " ms.");
return processInfos;
}
/**
* Returns the plugin descriptor.
*/
public PluginDescriptor getPluginDescriptor() {
return pluginDescriptor;
}
/**
* Returns the plugin descriptor.
*/
public ResourceDescriptor getResourceDescriptor(String name) {
ResourceDescriptor rd = descriptors.get(name);
if (rd == null)
throw new IllegalStateException("no descriptor " + name + " in " + descriptors.keySet());
return rd;
}
private void buildDesc(List<? extends ResourceDescriptor> l) {
for (ResourceDescriptor rd : l) {
descriptors.put(rd.getName(), rd);
if (rd instanceof ServerDescriptor) {
buildDesc(((ServerDescriptor)rd).getServers());
buildDesc(((ServerDescriptor)rd).getServices());
}
if (rd instanceof ServiceDescriptor) {
buildDesc(((ServiceDescriptor)rd).getServices());
buildDesc(((ServiceDescriptor)rd).getServices());
}
}
}
/**
* Asserts that all measurements in the report are present
* according to the resource descriptor.
*
* @see #getResourceDescriptor(String) for obtaining this.
* @param report
*/
public static void assertAll(MeasurementReport report, ResourceDescriptor l) {
HashMap<String, MetricDescriptor> map = new HashMap<String, MetricDescriptor>();
for (MetricDescriptor md : l.getMetric()) {
map.put(md.getProperty(), md);
}
for (MeasurementDataNumeric n : report.getNumericData()) {
map.remove(n.getName());
}
for (MeasurementDataTrait n : report.getTraitData()) {
map.remove(n.getName());
}
assertTrue("Measurements not found " + map.keySet(), map.isEmpty());
}
/**
* Returns the event manager.
*/
public EventManager getEventManager() {
return eventManager;
}
/**
* Set to false to avoid scanning local machine processes to speed up testing.
*/
public void setProcessScan(boolean processScan) {
this.processScan = processScan;
}
public void assertAll(ConfigurationFacet cf, ResourceDescriptor rd) throws Exception {
Configuration config = cf.loadResourceConfiguration();
List<JAXBElement<? extends ConfigurationProperty>> templates = rd.getResourceConfiguration().getConfigurationProperty();
for (JAXBElement<? extends ConfigurationProperty> template : templates) {
String name = template.getValue().getName();
// Property property = config.get(name);
assertNotNull("config contains " + name, config.get(name));
Object value = config.getSimpleValue(name, null);
assertNotNull("value for " + name, value);
log.debug("config found " + name + " value " + value );
}
}
}