Ejemplo n.º 1
0
 @Test
 public void testFullConfigpath() throws Exception {
   PropertiesManager localpm = Tools.makePm();
   JrdsDocument host = new JrdsDocument(Tools.dbuilder.newDocument());
   host.doRootElement("host", "name=name");
   ConfigObjectFactory conf = new ConfigObjectFactory(localpm, localpm.extensionClassLoader);
   conf.getNodeMap(ConfigType.HOSTS).put("name", host);
   Assert.assertNotNull(
       "Probedesc not build", conf.setHostMap(Tools.getSimpleTimerMap()).get("name"));
 }
Ejemplo n.º 2
0
  public HostInfo makeHost(JrdsDocument n)
      throws SecurityException, IllegalArgumentException, NoSuchMethodException,
          IllegalAccessException, InvocationTargetException, ClassNotFoundException {
    JrdsElement hostNode = n.getRootElement();
    String hostName = hostNode.getAttribute("name");
    String dnsHostname = hostNode.getAttribute("dnsName");
    if (hostName == null) {
      return null;
    }

    HostInfo host = null;
    if (dnsHostname != null) {
      host = new HostInfo(hostName, dnsHostname);
    } else {
      host = new HostInfo(hostName);
    }
    host.setHostDir(new File(pm.rrddir, host.getName()));

    String hidden = hostNode.getAttribute("hidden");
    host.setHidden(hidden != null && Boolean.parseBoolean(hidden));

    Map<String, Set<String>> collections = new HashMap<String, Set<String>>();

    parseFragment(hostNode, host, collections, null);

    return host;
  }
Ejemplo n.º 3
0
  @Test
  public void testNewProbe()
      throws InvocationTargetException, IllegalArgumentException, IllegalAccessException,
          IOException {
    PropertiesManager localpm = Tools.makePm();

    HostBuilder hb = new HostBuilder();
    // Generate a probe with a bean hostInfo with a default value of ${host}
    hb.setProbeFactory(
        new MokeProbeFactory() {
          @Override
          public Probe<?, ?> makeProbe(String type) {
            logger.trace(type);
            ProbeDesc pd = generateProbeDesc(type);
            try {
              pd.setProbeClass(MokeProbeBean.class);
            } catch (InvocationTargetException e1) {
              throw new RuntimeException(e1);
            }
            Probe<?, ?> p = new MokeProbeBean(pd);
            try {
              pd.addDefaultArg("hostInfo", "${host}");
            } catch (Exception e) {
              throw new RuntimeException(e.getMessage(), e);
            }
            return p;
          }
        });
    hb.setPm(localpm);
    hb.setTimers(Tools.getSimpleTimerMap());

    HostInfo host = new HostInfo("localhost");
    host.setHostDir(testFolder.getRoot());

    JrdsDocument probeNode = new JrdsDocument(Tools.dbuilder.newDocument());
    probeNode.doRootElement("probe", "type=probetype");

    Probe<?, ?> p = hb.makeProbe(probeNode.getRootElement(), host, null);
    Assert.assertEquals(
        "localhost", p.getPd().getBeanMap().get("hostInfo").getReadMethod().invoke(p));
    logger.trace(p.getName());
  }
Ejemplo n.º 4
0
  @Test
  public void testConnectionInfo() throws Exception {
    PropertiesManager pm = Tools.makePm();

    HostBuilder hb = new HostBuilder();
    hb.setPm(pm);
    hb.setClassLoader(this.getClass().getClassLoader());

    JrdsDocument cnxdoc = new JrdsDocument(Tools.dbuilder.newDocument());
    cnxdoc
        .doRootElement("host")
        .addElement("connection", "type=jrds.probe.JMXConnection")
        .addElement("attr", "name=port")
        .setTextContent("8999");
    for (ConnectionInfo ci : hb.makeConnexion(cnxdoc.getRootElement(), new HostInfo("localhost"))) {
      logger.trace(ci.getName());
      StarterNode sn = new StarterNode() {};
      ci.register(sn);
      JMXConnection cnx = sn.find(JMXConnection.class);
      Assert.assertEquals("Attributed not setted", new Integer(8999), cnx.getPort());
    }
  }
Ejemplo n.º 5
0
 public Filter makeFilter(JrdsDocument n)
     throws SecurityException, IllegalArgumentException, NoSuchMethodException,
         IllegalAccessException, InvocationTargetException, InstantiationException {
   JrdsElement root = n.getRootElement();
   JrdsElement name = root.getElementbyName("name");
   if (name == null) return null;
   FilterXml f = new FilterXml(name.getTextContent());
   setMethod(root.getChildElementsByName("path"), f, "addPath", String.class);
   setMethod(root.getChildElementsByName("tag"), f, "addTag", String.class);
   setMethod(root.getChildElementsByName("qualifiedname"), f, "addGraph", String.class);
   doACL(f, n, root);
   logger.trace(Util.delayedFormatString("Filter loaded: %s", f.getName()));
   return f;
 }
Ejemplo n.º 6
0
  private void parseFragment(
      JrdsElement fragment,
      HostInfo host,
      Map<String, Set<String>> collections,
      Map<String, String> properties)
      throws IllegalArgumentException, SecurityException, IllegalAccessException,
          InvocationTargetException, NoSuchMethodException {

    // Find the connection for this host
    // Will the registered latter, in the starter node, one for each timer
    for (ConnectionInfo cnx : makeConnexion(fragment, host)) {
      host.addConnection(cnx);
    }

    for (JrdsElement tagElem : fragment.getChildElementsByName("tag")) {
      try {
        logger.trace(Util.delayedFormatString("adding tag %s to %s", tagElem, host));
        setMethod(tagElem, host, "addTag");
      } catch (InstantiationException e) {
      }
    }

    for (JrdsElement collectionNode : fragment.getChildElementsByName("collection")) {
      String name = collectionNode.getAttribute("name");
      Set<String> set = new HashSet<String>();
      for (JrdsElement e : collectionNode.getChildElementsByName("element")) {
        set.add(e.getTextContent());
      }
      collections.put(name, set);
    }

    for (JrdsElement macroNode : fragment.getChildElementsByName("macro")) {
      String name = macroNode.getAttribute("name");
      Macro m = macrosMap.get(name);
      logger.trace(Util.delayedFormatString("Adding macro %s: %s", name, m));
      if (m != null) {
        Map<String, String> macroProps = makeProperties(macroNode);
        Map<String, String> newProps =
            new HashMap<String, String>(
                (properties != null ? properties.size() : 0) + macroProps.size());
        if (properties != null) newProps.putAll(properties);
        newProps.putAll(macroProps);
        JrdsDocument hostdoc = (JrdsDocument) fragment.getOwnerDocument();
        // Make a copy of the document fragment
        JrdsNode newDf = JrdsNode.build(hostdoc.importNode(m.getDf(), true));
        JrdsElement macrodef = JrdsNode.build(newDf.getFirstChild());
        parseFragment(macrodef, host, collections, newProps);
      } else {
        logger.error("Unknown macro:" + name);
      }
    }

    for (JrdsElement forNode : fragment.getChildElementsByName("for")) {
      Map<String, String> forattr = forNode.attrMap();
      String iterprop = forattr.get("var");
      Collection<String> set = null;
      String name = forNode.attrMap().get("collection");
      if (name != null) set = collections.get(name);
      else if (forattr.containsKey("min")
          && forattr.containsKey("max")
          && forattr.containsKey("step")) {
        int min = Util.parseStringNumber(forattr.get("min"), Integer.MAX_VALUE);
        int max = Util.parseStringNumber(forattr.get("max"), Integer.MIN_VALUE);
        int step = Util.parseStringNumber(forattr.get("step"), Integer.MIN_VALUE);
        if (min > max || step <= 0) {
          logger.error("invalid range from " + min + " to " + max + " with step " + step);
          break;
        }
        set = new ArrayList<String>((max - min) / step + 1);
        for (int i = min; i <= max; i += step) {
          set.add(Integer.toString(i));
        }
      }

      if (set != null) {
        logger.trace(Util.delayedFormatString("for using %s", set));

        for (String i : set) {
          Map<String, String> temp;
          if (properties != null) {
            temp = new HashMap<String, String>(properties.size() + 1);
            temp.putAll(properties);
            temp.put(iterprop, i);
          } else {
            temp = Collections.singletonMap(iterprop, i);
          }
          parseFragment(forNode, host, collections, temp);
        }
      } else {
        logger.error("Invalid host configuration, collection " + name + " not found");
      }
    }

    for (JrdsElement probeNode : fragment.getChildElements()) {
      if (!"probe".equals(probeNode.getNodeName()) && !"rrd".equals(probeNode.getNodeName()))
        continue;
      try {
        makeProbe(probeNode, host, properties);
      } catch (Exception e) {
        logger.error("Probe creation failed for host " + host.getName() + ": ");
        ByteArrayOutputStream buffer = new ByteArrayOutputStream();
        e.printStackTrace(new PrintStream(buffer));
        logger.error(buffer);
      }
    }
  }