bindings/java/org/collectd/java/GenericJMXConfValue.java

   1 /**
   2  * collectd - bindings/java/org/collectd/java/GenericJMXConfValue.java
   3  * Copyright (C) 2009       Florian octo Forster
   4  *
   5  * Permission is hereby granted, free of charge, to any person obtaining a
   6  * copy of this software and associated documentation files (the "Software"),
   7  * to deal in the Software without restriction, including without limitation
   8  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
   9  * and/or sell copies of the Software, and to permit persons to whom the
  10  * Software is furnished to do so, subject to the following conditions:
  11  *
  12  * The above copyright notice and this permission notice shall be included in
  13  * all copies or substantial portions of the Software.
  14  *
  15  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  16  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  17  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  18  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  19  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
  20  * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
  21  * DEALINGS IN THE SOFTWARE.
  22  *
  23  * Authors:
  24  *   Florian octo Forster <octo at collectd.org>
  25  */
  26
  27 package org.collectd.java;
  28
  29 import java.util.Arrays;
  30 import java.util.List;
  31 import java.util.Set;
  32 import java.util.Iterator;
  33 import java.util.ArrayList;
  34
  35 import java.math.BigDecimal;
  36 import java.math.BigInteger;
  37
  38 import javax.management.MBeanServerConnection;
  39 import javax.management.ObjectName;
  40 import javax.management.openmbean.OpenType;
  41 import javax.management.openmbean.CompositeData;
  42 import javax.management.openmbean.InvalidKeyException;
  43
  44 import org.collectd.api.Collectd;
  45 import org.collectd.api.DataSet;
  46 import org.collectd.api.DataSource;
  47 import org.collectd.api.ValueList;
  48 import org.collectd.api.PluginData;
  49 import org.collectd.api.OConfigValue;
  50 import org.collectd.api.OConfigItem;
  51
  52 /**
  53  * Representation of a &lt;value&nbsp;/&gt; block and query functionality.
  54  *
  55  * This class represents a &lt;value&nbsp;/&gt; block in the configuration. As
  56  * such, the constructor takes an {@link org.collectd.api.OConfigValue} to
  57  * construct an object of this class.
  58  *
  59  * The object can then be asked to query data from JMX and dispatch it to
  60  * collectd.
  61  *
  62  * @see GenericJMXConfMBean
  63  */
  64 class GenericJMXConfValue
  65 {
  66   private String _ds_name;
  67   private DataSet _ds;
  68   private List<String> _attributes;
  69   private String _instance_prefix;
  70   private List<String> _instance_from;
  71   private boolean _is_table;
  72
  73   /**
  74    * Converts a generic (OpenType) object to a number.
  75    *
  76    * Returns null if a conversion is not possible or not implemented.
  77    */
  78   private Number genericObjectToNumber (Object obj, int ds_type) /* {{{ */
  79   {
  80     if (obj instanceof String)
  81     {
  82       String str = (String) obj;
  83
  84       try
  85       {
  86         if (ds_type == DataSource.TYPE_GAUGE)
  87           return (new Double (str));
  88         else
  89           return (new Long (str));
  90       }
  91       catch (NumberFormatException e)
  92       {
  93         return (null);
  94       }
  95     }
  96     else if (obj instanceof Byte)
  97     {
  98       return (new Byte ((Byte) obj));
  99     }
 100     else if (obj instanceof Short)
 101     {
 102       return (new Short ((Short) obj));
 103     }
 104     else if (obj instanceof Integer)
 105     {
 106       return (new Integer ((Integer) obj));
 107     }
 108     else if (obj instanceof Long)
 109     {
 110       return (new Long ((Long) obj));
 111     }
 112     else if (obj instanceof Float)
 113     {
 114       return (new Float ((Float) obj));
 115     }
 116     else if (obj instanceof Double)
 117     {
 118       return (new Double ((Double) obj));
 119     }
 120     else if (obj instanceof BigDecimal)
 121     {
 122       return (BigDecimal.ZERO.add ((BigDecimal) obj));
 123     }
 124     else if (obj instanceof BigInteger)
 125     {
 126       return (BigInteger.ZERO.add ((BigInteger) obj));
 127     }
 128
 129     return (null);
 130   } /* }}} Number genericObjectToNumber */
 131
 132   /**
 133    * Converts a generic list to a list of numbers.
 134    *
 135    * Returns null if one or more objects could not be converted.
 136    */
 137   private List<Number> genericListToNumber (List<Object> objects) /* {{{ */
 138   {
 139     List<Number> ret = new ArrayList<Number> ();
 140     List<DataSource> dsrc = this._ds.getDataSources ();
 141
 142     assert (objects.size () == dsrc.size ());
 143
 144     for (int i = 0; i < objects.size (); i++)
 145     {
 146       Number n;
 147
 148       n = genericObjectToNumber (objects.get (i), dsrc.get (i).getType ());
 149       if (n == null)
 150         return (null);
 151       ret.add (n);
 152     }
 153
 154     return (ret);
 155   } /* }}} List<Number> genericListToNumber */
 156
 157   /**
 158    * Converts a list of CompositeData to a list of numbers.
 159    *
 160    * From each <em>CompositeData </em> the key <em>key</em> is received and all
 161    * those values are converted to a number. If one of the
 162    * <em>CompositeData</em> doesn't have the specified key or one returned
 163    * object cannot converted to a number then the function will return null.
 164    */
 165   private List<Number> genericCompositeToNumber (List<CompositeData> cdlist, /* {{{ */
 166       String key)
 167   {
 168     List<Object> objects = new ArrayList<Object> ();
 169
 170     for (int i = 0; i < cdlist.size (); i++)
 171     {
 172       CompositeData cd;
 173       Object value;
 174
 175       cd = cdlist.get (i);
 176       try
 177       {
 178         value = cd.get (key);
 179       }
 180       catch (InvalidKeyException e)
 181       {
 182         return (null);
 183       }
 184       objects.add (value);
 185     }
 186
 187     return (genericListToNumber (objects));
 188   } /* }}} List<Number> genericCompositeToNumber */
 189
 190   private void submitTable (List<Object> objects, ValueList vl, /* {{{ */
 191       String instancePrefix)
 192   {
 193     List<CompositeData> cdlist;
 194     Set<String> keySet = null;
 195     Iterator<String> keyIter;
 196
 197     cdlist = new ArrayList<CompositeData> ();
 198     for (int i = 0; i < objects.size (); i++)
 199     {
 200       Object obj;
 201
 202       obj = objects.get (i);
 203       if (obj instanceof CompositeData)
 204       {
 205         CompositeData cd;
 206
 207         cd = (CompositeData) obj;
 208
 209         if (i == 0)
 210           keySet = cd.getCompositeType ().keySet ();
 211
 212         cdlist.add (cd);
 213       }
 214       else
 215       {
 216         Collectd.logError ("GenericJMXConfValue: At least one of the "
 217             + "attributes was not of type `CompositeData', as required "
 218             + "when table is set to `true'.");
 219         return;
 220       }
 221     }
 222
 223     assert (keySet != null);
 224
 225     keyIter = keySet.iterator ();
 226     while (keyIter.hasNext ())
 227     {
 228       String key;
 229       List<Number> values;
 230
 231       key = keyIter.next ();
 232       values = genericCompositeToNumber (cdlist, key);
 233       if (values == null)
 234       {
 235         Collectd.logError ("GenericJMXConfValue: Cannot build a list of "
 236             + "numbers for key " + key + ". Most likely not all attributes "
 237             + "have this key.");
 238         continue;
 239       }
 240
 241       if (instancePrefix == null)
 242         vl.setTypeInstance (key);
 243       else
 244         vl.setTypeInstance (instancePrefix + key);
 245       vl.setValues (values);
 246
 247       Collectd.dispatchValues (vl);
 248     }
 249   } /* }}} void submitTable */
 250
 251   private void submitScalar (List<Object> objects, ValueList vl, /* {{{ */
 252       String instancePrefix)
 253   {
 254     List<Number> values;
 255
 256     values = genericListToNumber (objects);
 257     if (values == null)
 258     {
 259       Collectd.logError ("GenericJMXConfValue: Cannot convert list of "
 260           + "objects to numbers.");
 261       return;
 262     }
 263
 264     if (instancePrefix == null)
 265       vl.setTypeInstance ("");
 266     else
 267       vl.setTypeInstance (instancePrefix);
 268     vl.setValues (values);
 269
 270     Collectd.dispatchValues (vl);
 271   } /* }}} void submitScalar */
 272
 273   private Object queryAttributeRecursive (CompositeData parent, /* {{{ */
 274       List<String> attrName)
 275   {
 276     String key;
 277     Object value;
 278
 279     key = attrName.remove (0);
 280
 281     try
 282     {
 283       value = parent.get (key);
 284     }
 285     catch (InvalidKeyException e)
 286     {
 287       return (null);
 288     }
 289
 290     if (attrName.size () == 0)
 291     {
 292       return (value);
 293     }
 294     else
 295     {
 296       if (value instanceof CompositeData)
 297         return (queryAttributeRecursive ((CompositeData) value, attrName));
 298       else
 299         return (null);
 300     }
 301   } /* }}} queryAttributeRecursive */
 302
 303   private Object queryAttribute (MBeanServerConnection conn, /* {{{ */
 304       ObjectName objName, String attrName)
 305   {
 306     List<String> attrNameList;
 307     String key;
 308     Object value;
 309     String[] attrNameArray;
 310
 311     attrNameList = new ArrayList<String> ();
 312
 313     attrNameArray = attrName.split ("\\.");
 314     key = attrNameArray[0];
 315     for (int i = 1; i < attrNameArray.length; i++)
 316       attrNameList.add (attrNameArray[i]);
 317
 318     try
 319     {
 320       try
 321       {
 322         value = conn.getAttribute (objName, key);
 323       }
 324       catch (javax.management.AttributeNotFoundException e)
 325       {
 326         value = conn.invoke (objName, key, /* args = */ null, /* types = */ null);
 327       }
 328     }
 329     catch (Exception e)
 330     {
 331       Collectd.logError ("GenericJMXConfValue.query: getAttribute failed: "
 332           + e);
 333       return (null);
 334     }
 335
 336     if (attrNameList.size () == 0)
 337     {
 338       return (value);
 339     }
 340     else
 341     {
 342       if (value instanceof CompositeData)
 343         return (queryAttributeRecursive((CompositeData) value, attrNameList));
 344       else if (value instanceof OpenType)
 345       {
 346         OpenType ot = (OpenType) value;
 347         Collectd.logNotice ("GenericJMXConfValue: Handling of OpenType \""
 348             + ot.getTypeName () + "\" is not yet implemented.");
 349         return (null);
 350       }
 351       else
 352       {
 353         Collectd.logError ("GenericJMXConfValue: Received object of "
 354             + "unknown class.");
 355         return (null);
 356       }
 357     }
 358   } /* }}} Object queryAttribute */
 359
 360   private String join (String separator, List<String> list) /* {{{ */
 361   {
 362     StringBuffer sb;
 363
 364     sb = new StringBuffer ();
 365
 366     for (int i = 0; i < list.size (); i++)
 367     {
 368       if (i > 0)
 369         sb.append ("-");
 370       sb.append (list.get (i));
 371     }
 372
 373     return (sb.toString ());
 374   } /* }}} String join */
 375
 376   private String getConfigString (OConfigItem ci) /* {{{ */
 377   {
 378     List<OConfigValue> values;
 379     OConfigValue v;
 380
 381     values = ci.getValues ();
 382     if (values.size () != 1)
 383     {
 384       Collectd.logError ("GenericJMXConfValue: The " + ci.getKey ()
 385           + " configuration option needs exactly one string argument.");
 386       return (null);
 387     }
 388
 389     v = values.get (0);
 390     if (v.getType () != OConfigValue.OCONFIG_TYPE_STRING)
 391     {
 392       Collectd.logError ("GenericJMXConfValue: The " + ci.getKey ()
 393           + " configuration option needs exactly one string argument.");
 394       return (null);
 395     }
 396
 397     return (v.getString ());
 398   } /* }}} String getConfigString */
 399
 400   private Boolean getConfigBoolean (OConfigItem ci) /* {{{ */
 401   {
 402     List<OConfigValue> values;
 403     OConfigValue v;
 404     Boolean b;
 405
 406     values = ci.getValues ();
 407     if (values.size () != 1)
 408     {
 409       Collectd.logError ("GenericJMXConfValue: The " + ci.getKey ()
 410           + " configuration option needs exactly one boolean argument.");
 411       return (null);
 412     }
 413
 414     v = values.get (0);
 415     if (v.getType () != OConfigValue.OCONFIG_TYPE_BOOLEAN)
 416     {
 417       Collectd.logError ("GenericJMXConfValue: The " + ci.getKey ()
 418           + " configuration option needs exactly one boolean argument.");
 419       return (null);
 420     }
 421
 422     return (new Boolean (v.getBoolean ()));
 423   } /* }}} String getConfigBoolean */
 424
 425   /**
 426    * Constructs a new value with the configured properties.
 427    */
 428   public GenericJMXConfValue (OConfigItem ci) /* {{{ */
 429     throws IllegalArgumentException
 430   {
 431     List<OConfigItem> children;
 432     Iterator<OConfigItem> iter;
 433
 434     this._ds_name = null;
 435     this._ds = null;
 436     this._attributes = new ArrayList<String> ();
 437     this._instance_prefix = null;
 438     this._instance_from = new ArrayList<String> ();
 439     this._is_table = false;
 440
 441     /*
 442      * <Value>
 443      *   Type "memory"
 444      *   Table true|false
 445      *   Attribute "HeapMemoryUsage"
 446      *   Attribute "..."
 447      *   :
 448      *   # Type instance:
 449      *   InstancePrefix "heap-"
 450      * </Value>
 451      */
 452     children = ci.getChildren ();
 453     iter = children.iterator ();
 454     while (iter.hasNext ())
 455     {
 456       OConfigItem child = iter.next ();
 457
 458       if (child.getKey ().equalsIgnoreCase ("Type"))
 459       {
 460         String tmp = getConfigString (child);
 461         if (tmp != null)
 462           this._ds_name = tmp;
 463       }
 464       else if (child.getKey ().equalsIgnoreCase ("Table"))
 465       {
 466         Boolean tmp = getConfigBoolean (child);
 467         if (tmp != null)
 468           this._is_table = tmp.booleanValue ();
 469       }
 470       else if (child.getKey ().equalsIgnoreCase ("Attribute"))
 471       {
 472         String tmp = getConfigString (child);
 473         if (tmp != null)
 474           this._attributes.add (tmp);
 475       }
 476       else if (child.getKey ().equalsIgnoreCase ("InstancePrefix"))
 477       {
 478         String tmp = getConfigString (child);
 479         if (tmp != null)
 480           this._instance_prefix = tmp;
 481       }
 482       else if (child.getKey ().equalsIgnoreCase ("InstanceFrom"))
 483       {
 484         String tmp = getConfigString (child);
 485         if (tmp != null)
 486           this._instance_from.add (tmp);
 487       }
 488       else
 489         throw (new IllegalArgumentException ("Unknown option: "
 490               + child.getKey ()));
 491     }
 492
 493     if (this._ds_name == null)
 494       throw (new IllegalArgumentException ("No data set was defined."));
 495     else if (this._attributes.size () == 0)
 496       throw (new IllegalArgumentException ("No attribute was defined."));
 497   } /* }}} GenericJMXConfValue (OConfigItem ci) */
 498
 499   /**
 500    * Query values via JMX according to the object's configuration and dispatch
 501    * them to collectd.
 502    *
 503    * @param conn    Connection to the MBeanServer.
 504    * @param objName Object name of the MBean to query.
 505    * @param pd      Preset naming components. The members host, plugin and
 506    *                plugin instance will be used.
 507    */
 508   public void query (MBeanServerConnection conn, ObjectName objName, /* {{{ */
 509       PluginData pd)
 510   {
 511     ValueList vl;
 512     List<DataSource> dsrc;
 513     List<Object> values;
 514     List<String> instanceList;
 515     String instancePrefix;
 516
 517     if (this._ds == null)
 518     {
 519       this._ds = Collectd.getDS (this._ds_name);
 520       if (this._ds == null)
 521       {
 522         Collectd.logError ("GenericJMXConfValue: Unknown type: "
 523             + this._ds_name);
 524         return;
 525       }
 526     }
 527
 528     dsrc = this._ds.getDataSources ();
 529     if (dsrc.size () != this._attributes.size ())
 530     {
 531       Collectd.logError ("GenericJMXConfValue.query: The data set "
 532           + this._ds_name + " has " + this._ds.getDataSources ().size ()
 533           + " data sources, but there were " + this._attributes.size ()
 534           + " attributes configured. This doesn't match!");
 535       this._ds = null;
 536       return;
 537     }
 538
 539     vl = new ValueList (pd);
 540     vl.setType (this._ds_name);
 541
 542     /*
 543      * Build the instnace prefix from the fixed string prefix and the
 544      * properties of the objName.
 545      */
 546     instanceList = new ArrayList<String> ();
 547     for (int i = 0; i < this._instance_from.size (); i++)
 548     {
 549       String propertyName;
 550       String propertyValue;
 551
 552       propertyName = this._instance_from.get (i);
 553       propertyValue = objName.getKeyProperty (propertyName);
 554       if (propertyValue == null)
 555       {
 556         Collectd.logError ("GenericJMXConfMBean: "
 557             + "No such property in object name: " + propertyName);
 558       }
 559       else
 560       {
 561         instanceList.add (propertyValue);
 562       }
 563     }
 564
 565     if (this._instance_prefix != null)
 566       instancePrefix = new String (this._instance_prefix
 567           + join ("-", instanceList));
 568     else
 569       instancePrefix = join ("-", instanceList);
 570
 571     /*
 572      * Build a list of `Object's which is then passed to `submitTable' and
 573      * `submitScalar'.
 574      */
 575     values = new ArrayList<Object> ();
 576     assert (dsrc.size () == this._attributes.size ());
 577     for (int i = 0; i < this._attributes.size (); i++)
 578     {
 579       Object v;
 580
 581       v = queryAttribute (conn, objName, this._attributes.get (i));
 582       if (v == null)
 583       {
 584         Collectd.logError ("GenericJMXConfValue.query: "
 585             + "Querying attribute " + this._attributes.get (i) + " failed.");
 586         return;
 587       }
 588
 589       values.add (v);
 590     }
 591
 592     if (this._is_table)
 593       submitTable (values, vl, instancePrefix);
 594     else
 595       submitScalar (values, vl, instancePrefix);
 596   } /* }}} void query */
 597 } /* class GenericJMXConfValue */
 598
 599 /* vim: set sw=2 sts=2 et fdm=marker : */