DomainComponent.java
上传用户:xfwatch
上传日期:2020-12-14
资源大小:872k
文件大小:12k
源码类别:

中间件编程

开发平台:

Java

  1. /*
  2.  * RHQ Management Platform
  3.  * Copyright (C) 2005-2008 Red Hat, Inc.
  4.  * All rights reserved.
  5.  *
  6.  * This program is free software; you can redistribute it and/or modify
  7.  * it under the terms of the GNU General Public License as published by
  8.  * the Free Software Foundation version 2 of the License.
  9.  *
  10.  * This program is distributed in the hope that it will be useful,
  11.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  13.  * GNU General Public License for more details.
  14.  *
  15.  * You should have received a copy of the GNU General Public License
  16.  * along with this program; if not, write to the Free Software
  17.  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  18.  */
  19. package org.rhq.plugins.blacktie;
  20. import java.io.InputStream;
  21. import java.io.StringWriter;
  22. import java.util.List;
  23. import java.util.Properties;
  24. import java.util.Set;
  25. import javax.management.MBeanServerConnection;
  26. import javax.management.ObjectName;
  27. import javax.management.remote.JMXConnector;
  28. import javax.management.remote.JMXConnectorFactory;
  29. import javax.management.remote.JMXServiceURL;
  30. import javax.xml.transform.OutputKeys;
  31. import javax.xml.transform.Transformer;
  32. import javax.xml.transform.TransformerFactory;
  33. import javax.xml.transform.dom.DOMSource;
  34. import javax.xml.transform.stream.StreamResult;
  35. import org.apache.commons.logging.Log;
  36. import org.apache.commons.logging.LogFactory;
  37. import org.jboss.blacktie.jatmibroker.core.conf.XMLEnvHandler;
  38. import org.jboss.blacktie.jatmibroker.core.conf.XMLParser;
  39. import org.rhq.core.domain.configuration.Configuration;
  40. import org.rhq.core.domain.configuration.ConfigurationUpdateStatus;
  41. import org.rhq.core.domain.content.PackageType;
  42. import org.rhq.core.domain.content.transfer.DeployPackageStep;
  43. import org.rhq.core.domain.content.transfer.DeployPackagesResponse;
  44. import org.rhq.core.domain.content.transfer.RemovePackagesResponse;
  45. import org.rhq.core.domain.content.transfer.ResourcePackageDetails;
  46. import org.rhq.core.domain.measurement.AvailabilityType;
  47. import org.rhq.core.domain.measurement.MeasurementDataNumeric;
  48. import org.rhq.core.domain.measurement.MeasurementReport;
  49. import org.rhq.core.domain.measurement.MeasurementScheduleRequest;
  50. import org.rhq.core.pluginapi.configuration.ConfigurationFacet;
  51. import org.rhq.core.pluginapi.configuration.ConfigurationUpdateReport;
  52. import org.rhq.core.pluginapi.content.ContentFacet;
  53. import org.rhq.core.pluginapi.content.ContentServices;
  54. import org.rhq.core.pluginapi.inventory.CreateChildResourceFacet;
  55. import org.rhq.core.pluginapi.inventory.CreateResourceReport;
  56. import org.rhq.core.pluginapi.inventory.DeleteResourceFacet;
  57. import org.rhq.core.pluginapi.inventory.ResourceComponent;
  58. import org.rhq.core.pluginapi.inventory.ResourceContext;
  59. import org.rhq.core.pluginapi.measurement.MeasurementFacet;
  60. import org.rhq.core.pluginapi.operation.OperationFacet;
  61. import org.rhq.core.pluginapi.operation.OperationResult;
  62. import org.w3c.dom.Element;
  63. /**
  64.  * This can be the start of your own custom plugin's server component. Review
  65.  * the javadoc for {@link ResourceComponent} and all the facet interfaces to
  66.  * learn what you can do in your resource component. This component has a lot of
  67.  * methods in it because it implements all possible facets. If your resource
  68.  * does not support, for example, configuration, you can remove the
  69.  * {@link ConfigurationFacet} from the <code>implements</code> clause and remove
  70.  * all method implementations that that facet required.
  71.  * 
  72.  * <p>
  73.  * You should not only read the javadoc in each of this class' methods, but you
  74.  * should also read the javadocs linked by their "see" javadoc tags since those
  75.  * additional javadocs will contain a good deal of additional information you
  76.  * will need to know.
  77.  * </p>
  78.  * 
  79.  * @author John Mazzitelli
  80.  */
  81. public class DomainComponent implements ResourceComponent, MeasurementFacet,
  82. OperationFacet, ConfigurationFacet, ContentFacet, DeleteResourceFacet,
  83. CreateChildResourceFacet {
  84. private final Log log = LogFactory.getLog(DomainComponent.class);
  85. /**
  86.  * Represents the resource configuration of the custom product being
  87.  * managed.
  88.  */
  89. private Configuration resourceConfiguration;
  90. /**
  91.  * All AMPS plugins are stateful - this context contains information that
  92.  * your resource component can use when performing its processing.
  93.  */
  94. private ResourceContext resourceContext;
  95. private MBeanServerConnection beanServerConnection;
  96. private String domainName = null;
  97. private ObjectName blacktieAdmin = null;
  98. /**
  99.  * This is called when your component has been started with the given
  100.  * context. You normally initialize some internal state of your component as
  101.  * well as attempt to make a stateful connection to your managed resource.
  102.  * 
  103.  * @see ResourceComponent#start(ResourceContext)
  104.  */
  105. public void start(ResourceContext context) {
  106. resourceContext = context;
  107. try {
  108. Properties prop = new Properties();
  109. XMLEnvHandler handler = new XMLEnvHandler(prop);
  110. XMLParser xmlenv = new XMLParser(handler, "btconfig.xsd");
  111. xmlenv.parse("btconfig.xml");
  112. JMXServiceURL u = new JMXServiceURL((String) prop.get("JMXURL"));
  113. JMXConnector c = JMXConnectorFactory.connect(u);
  114. beanServerConnection = c.getMBeanServerConnection();
  115. domainName = context.getResourceKey();;
  116. blacktieAdmin = new ObjectName("jboss.blacktie:service=Admin");
  117. } catch (Exception e) {
  118. log.error("start domain " + domainName + " plugin error with " + e);
  119. }
  120. }
  121. /**
  122.  * This is called when the component is being stopped, usually due to the
  123.  * plugin container shutting down. You can perform some cleanup here; though
  124.  * normally not much needs to be done here.
  125.  * 
  126.  * @see ResourceComponent#stop()
  127.  */
  128. public void stop() {
  129. }
  130. /**
  131.  * All resource components must be able to tell the plugin container if the
  132.  * managed resource is available or not. This method is called by the plugin
  133.  * container when it needs to know if the managed resource is actually up
  134.  * and available.
  135.  * 
  136.  * @see ResourceComponent#getAvailability()
  137.  */
  138. public AvailabilityType getAvailability() {
  139. // TODO: here you normally make some type of connection attempt to the
  140. // managed resource
  141. // to determine if it is really up and running.
  142. AvailabilityType status = AvailabilityType.UP;
  143. try {
  144. Object obj = beanServerConnection.invoke(blacktieAdmin, "getDomainStatus", null, null);
  145. if((Boolean)obj) {
  146. status = AvailabilityType.DOWN;
  147. }
  148. } catch (Exception e) {
  149. log.warn("get domain status failed with " + e);
  150. status = AvailabilityType.DOWN;
  151. }
  152. return status;
  153. }
  154. /**
  155.  * The plugin container will call this method when your resource component
  156.  * has been scheduled to collect some measurements now. It is within this
  157.  * method that you actually talk to the managed resource and collect the
  158.  * measurement data that is has emitted.
  159.  * 
  160.  * @see MeasurementFacet#getValues(MeasurementReport, Set)
  161.  */
  162. public void getValues(MeasurementReport report,
  163. Set<MeasurementScheduleRequest> requests) {
  164. for (MeasurementScheduleRequest request : requests) {
  165. String name = request.getName();
  166. // TODO: based on the request information, you must collect the
  167. // requested measurement(s)
  168. // you can use the name of the measurement to determine what you
  169. // actually need to collect
  170. try {
  171. Number value = new Integer(1); // dummy measurement value - this
  172. // should come from the managed
  173. // resource
  174. report.addData(new MeasurementDataNumeric(request, value
  175. .doubleValue()));
  176. } catch (Exception e) {
  177. log.error("Failed to obtain measurement [" + name
  178. + "]. Cause: " + e);
  179. }
  180. }
  181. return;
  182. }
  183. /**
  184.  * The plugin container will call this method when it wants to invoke an
  185.  * operation on your managed resource. Your plugin will connect to the
  186.  * managed resource and invoke the analogous operation in your own custom
  187.  * way.
  188.  * 
  189.  * @see OperationFacet#invokeOperation(String, Configuration)
  190.  */
  191. public OperationResult invokeOperation(String name,
  192. Configuration configuration) {
  193. OperationResult result = new OperationResult();
  194. try {
  195. Object obj = beanServerConnection.invoke(blacktieAdmin, name, null, null);
  196. if(name.equals("getServersStatus")) {
  197. Element status = (Element)obj;
  198. // Set up the output transformer
  199. TransformerFactory transfac = TransformerFactory.newInstance();
  200. Transformer trans = transfac.newTransformer();
  201. trans.setOutputProperty(OutputKeys.OMIT_XML_DECLARATION, "yes");
  202. trans.setOutputProperty(OutputKeys.INDENT, "yes");
  203. StringWriter sw = new StringWriter();
  204. StreamResult sr = new StreamResult(sw);
  205. DOMSource source = new DOMSource(status);
  206. trans.transform(source, sr);
  207. result.setSimpleResult(sw.toString());
  208. } else {
  209. result.setSimpleResult(obj.toString());
  210. }
  211. } catch (Exception e) {
  212. result.setErrorMessage(e.toString());
  213. }
  214. return result;
  215. }
  216. /**
  217.  * The plugin container will call this method and it needs to obtain the
  218.  * current configuration of the managed resource. Your plugin will obtain
  219.  * the managed resource's configuration in your own custom way and populate
  220.  * the returned Configuration object with the managed resource's
  221.  * configuration property values.
  222.  * 
  223.  * @see ConfigurationFacet#loadResourceConfiguration()
  224.  */
  225. public Configuration loadResourceConfiguration() {
  226. // here we simulate the loading of the managed resource's configuration
  227. if (resourceConfiguration == null) {
  228. // for this example, we will create a simple dummy configuration to
  229. // start with.
  230. // note that it is empty, so we're assuming there are no required
  231. // configs in the plugin descriptor.
  232. resourceConfiguration = new Configuration();
  233. }
  234. Configuration config = resourceConfiguration;
  235. return config;
  236. }
  237. /**
  238.  * The plugin container will call this method when it has a new
  239.  * configuration for your managed resource. Your plugin will re-configure
  240.  * the managed resource in your own custom way, setting its configuration
  241.  * based on the new values of the given configuration.
  242.  * 
  243.  * @see ConfigurationFacet#updateResourceConfiguration(ConfigurationUpdateReport)
  244.  */
  245. public void updateResourceConfiguration(ConfigurationUpdateReport report) {
  246. // this simulates the plugin taking the new configuration and
  247. // reconfiguring the managed resource
  248. resourceConfiguration = report.getConfiguration().deepCopy();
  249. report.setStatus(ConfigurationUpdateStatus.SUCCESS);
  250. }
  251. /**
  252.  * When this is called, the plugin is responsible for scanning its managed
  253.  * resource and look for content that need to be managed for that resource.
  254.  * This method should only discover packages of the given package type.
  255.  * 
  256.  * @see ContentFacet#discoverDeployedPackages(PackageType)
  257.  */
  258. public Set<ResourcePackageDetails> discoverDeployedPackages(PackageType type) {
  259. return null;
  260. }
  261. /**
  262.  * The plugin container calls this method when new packages need to be
  263.  * deployed/installed on resources.
  264.  * 
  265.  * @see ContentFacet#deployPackages(Set, ContentServices)
  266.  */
  267. public DeployPackagesResponse deployPackages(
  268. Set<ResourcePackageDetails> packages,
  269. ContentServices contentServices) {
  270. return null;
  271. }
  272. /**
  273.  * When a remote client wants to see the actual data content for an
  274.  * installed package, this method will be called. This method must return a
  275.  * stream of data containing the full content of the package.
  276.  * 
  277.  * @see ContentFacet#retrievePackageBits(ResourcePackageDetails)
  278.  */
  279. public InputStream retrievePackageBits(ResourcePackageDetails packageDetails) {
  280. return null;
  281. }
  282. /**
  283.  * This is the method that is used when the component has to create the
  284.  * installation steps and their results.
  285.  * 
  286.  * @see ContentFacet#generateInstallationSteps(ResourcePackageDetails)
  287.  */
  288. public List<DeployPackageStep> generateInstallationSteps(
  289. ResourcePackageDetails packageDetails) {
  290. return null;
  291. }
  292. /**
  293.  * This is called when the actual content of packages should be deleted from
  294.  * the managed resource.
  295.  * 
  296.  * @see ContentFacet#removePackages(Set)
  297.  */
  298. public RemovePackagesResponse removePackages(
  299. Set<ResourcePackageDetails> packages) {
  300. return null;
  301. }
  302. /**
  303.  * When called, the plugin container is asking the plugin to create a new
  304.  * managed resource. The new resource's details need to be added to the
  305.  * given report.
  306.  * 
  307.  * @see CreateChildResourceFacet#createResource(CreateResourceReport)
  308.  */
  309. public CreateResourceReport createResource(CreateResourceReport report) {
  310. return null;
  311. }
  312. /**
  313.  * When called, the plugin container is asking the plugin to delete a
  314.  * managed resource.
  315.  * 
  316.  * @see DeleteResourceFacet#deleteResource()
  317.  */
  318. public void deleteResource() {
  319. }
  320. }