private void setAttributes(
JrdsElement probeNode, Object o, Map<String, PropertyDescriptor> beans, Object... context)
throws IllegalArgumentException, InvocationTargetException {
// Resolve the beans
for (JrdsElement attrNode : probeNode.getChildElementsByName("attr")) {
String name = attrNode.getAttribute("name");
PropertyDescriptor bean = beans.get(name);
if (bean == null) {
logger.error("Unknonw bean " + name);
continue;
}
String textValue = Util.parseTemplate(attrNode.getTextContent(), context);
logger.trace(Util.delayedFormatString("Fond attribute %s with value %s", name, textValue));
try {
Constructor<?> c = bean.getPropertyType().getConstructor(String.class);
Object value = c.newInstance(textValue);
bean.getWriteMethod().invoke(o, value);
} catch (IllegalArgumentException e) {
throw new InvocationTargetException(e, HostBuilder.class.getName());
} catch (SecurityException e) {
throw new InvocationTargetException(e, HostBuilder.class.getName());
} catch (InstantiationException e) {
throw new InvocationTargetException(e, HostBuilder.class.getName());
} catch (IllegalAccessException e) {
throw new InvocationTargetException(e, HostBuilder.class.getName());
} catch (InvocationTargetException e) {
throw new InvocationTargetException(e, HostBuilder.class.getName());
} catch (NoSuchMethodException e) {
throw new InvocationTargetException(e, HostBuilder.class.getName());
}
}
}
public LinkedList<String> getTree(GraphNode graph, String tabname) {
List<?> elementsTree = trees.get(tabname);
LinkedList<String> tree = new LinkedList<String>();
if (elementsTree == null) return tree;
for (Object o : elementsTree) {
if (o instanceof String) {
String pathElem =
jrds.Util.parseTemplate((String) o, graph.getProbe(), this, graph.getProbe().getHost());
tree.add(pathElem);
} else if (o instanceof PathElement) tree.add(((PathElement) o).resolve(graph));
}
return tree;
}
/**
* Enumerate the connections found in an XML node
*
* @param domNode a node to parse
* @param host
* @return
*/
Set<ConnectionInfo> makeConnexion(JrdsElement domNode, Object parent) {
Set<ConnectionInfo> connectionSet = new HashSet<ConnectionInfo>();
// Check for the old SNMP connection node
ConnectionInfo cnxSnmp = parseSnmp(domNode);
if (cnxSnmp != null) connectionSet.add(cnxSnmp);
for (JrdsElement cnxNode : domNode.getChildElementsByName("connection")) {
String type = cnxNode.getAttribute("type");
if (type == null) {
logger.error("No type declared for a connection");
continue;
}
String name = cnxNode.getAttribute("name");
try {
// Load the class for the connection
@SuppressWarnings("unchecked")
Class<? extends Connection<?>> connectionClass =
(Class<? extends Connection<?>>) classLoader.loadClass(type);
// Build the arguments vector for the connection
List<Object> args = ArgFactory.makeArgs(cnxNode);
// Resolve the bean for the connection
Map<String, String> attrs = new HashMap<String, String>();
for (JrdsElement attrNode : cnxNode.getChildElementsByName("attr")) {
String attrName = attrNode.getAttribute("name");
String textValue = Util.parseTemplate(attrNode.getTextContent(), parent);
attrs.put(attrName, textValue);
}
ConnectionInfo cnx = new ConnectionInfo(connectionClass, name, args, attrs);
connectionSet.add(cnx);
logger.debug(Util.delayedFormatString("Added connection %s to node %s", cnx, parent));
} catch (NoClassDefFoundError ex) {
logger.warn("Connection class not found: " + type + ": " + ex);
} catch (ClassCastException ex) {
logger.warn(type + " is not a connection");
} catch (LinkageError ex) {
logger.warn(
"Incompatible code version during connection creation of type " + type + ": " + ex, ex);
} catch (Exception ex) {
logger.warn("Error during connection creation of type " + type + ": " + ex, ex);
}
}
return connectionSet;
}
public Probe<?, ?> makeProbe(JrdsElement probeNode, HostInfo host, Map<String, String> properties)
throws InvocationTargetException {
Probe<?, ?> p = null;
String type = probeNode.attrMap().get("type");
List<Map<String, Object>> dsList = doDsList(type, probeNode.getElementbyName("dslist"));
if (dsList.size() > 0) {
logger.trace(
Util.delayedFormatString("Data source replaced for %s/%s: %s", host, type, dsList));
ProbeDesc oldpd = pf.getProbeDesc(type);
try {
ProbeDesc pd = (ProbeDesc) oldpd.clone();
pd.replaceDs(dsList);
p = pf.makeProbe(pd);
} catch (CloneNotSupportedException e) {
}
} else {
p = pf.makeProbe(type);
}
if (p == null) return null;
p.readProperties(pm);
String timerName = probeNode.getAttribute("timer");
if (timerName == null) timerName = Timer.DEFAULTNAME;
Timer timer = timers.get(timerName);
if (timer == null) {
logger.error("Invalid timer '" + timerName + "' for probe " + host.getName() + "/" + type);
return null;
} else {
logger.trace(Util.delayedFormatString("probe %s/%s will use timer %s", host, type, timer));
}
p.setStep(timer.getStep());
p.setTimeout(timer.getTimeout());
// The label is set
String label = probeNode.getAttribute("label");
if (label != null && !"".equals(label)) {
logger.trace(Util.delayedFormatString("Adding label %s to %s", label, p));
p.setLabel(jrds.Util.parseTemplate(label, host, properties));
;
}
// The host is set
HostStarter shost = timer.getHost(host);
p.setHost(shost);
ProbeDesc pd = p.getPd();
List<Object> args = ArgFactory.makeArgs(probeNode, host, properties);
// Prepare the probe with the default beans values
Map<String, String> defaultBeans = pd.getDefaultArgs();
if (defaultBeans != null) {
for (Map.Entry<String, String> e : defaultBeans.entrySet()) {
try {
String beanName = e.getKey();
String beanValue = e.getValue();
PropertyDescriptor bean = pd.getBeanMap().get(beanName);
Object value;
// If the last argument is a list, give it to the template parser
Object lastArgs = args.isEmpty() ? null : args.get(args.size() - 1);
if (lastArgs instanceof List) {
value =
ArgFactory.ConstructFromString(
bean.getPropertyType(), Util.parseTemplate(beanValue, host, lastArgs));
} else {
value =
ArgFactory.ConstructFromString(
bean.getPropertyType(), jrds.Util.parseTemplate(beanValue, host));
}
logger.trace(
jrds.Util.delayedFormatString(
"Adding bean %s=%s (%s) to default args", beanName, value, value.getClass()));
bean.getWriteMethod().invoke(p, value);
} catch (Exception ex) {
throw new RuntimeException("Invalid default bean " + e.getKey(), ex);
}
}
}
// Resolve the beans
try {
setAttributes(probeNode, p, pd.getBeanMap(), host);
} catch (IllegalArgumentException e) {
logger.error(String.format("Can't configure %s for %s: %s", pd.getName(), host, e));
return null;
}
if (!pf.configure(p, args)) {
logger.error(p + " configuration failed");
return null;
}
// A connected probe, register the needed connection
// It can be defined within the node, referenced by it's name, or it's implied name
if (p instanceof ConnectedProbe) {
String connectionName = null;
ConnectedProbe cp = (ConnectedProbe) p;
// Register the connections defined within the probe
for (ConnectionInfo ci : makeConnexion(probeNode, p)) {
ci.register(p);
}
String connexionName = probeNode.getAttribute("connection");
if (connexionName != null && !"".equals(connexionName)) {
logger.trace(Util.delayedFormatString("Adding connection %s to %s", connexionName, p));
connectionName = jrds.Util.parseTemplate(connexionName, host);
cp.setConnectionName(connectionName);
} else {
connectionName = cp.getConnectionName();
}
// If the connection is not already registred, try looking for it
// And register it with the host
if (p.find(connectionName) == null) {
if (logger.isTraceEnabled())
logger.trace(
Util.delayedFormatString(
"Looking for connection %s in %s", connectionName, host.getConnections()));
ConnectionInfo ci = host.getConnection(connectionName);
if (ci != null) ci.register(shost);
else {
logger.error(
Util.delayedFormatString(
"Failed to find a connection %s for a probe %s", connectionName, cp));
return null;
}
}
}
// A passive probe, perhaps a specific listener is defined
if (p instanceof PassiveProbe) {
PassiveProbe<?> pp = (PassiveProbe<?>) p;
String listenerName = probeNode.getAttribute("listener");
if (listenerName != null && !listenerName.trim().isEmpty()) {
Listener<?, ?> l = listeners.get(listenerName);
if (l != null) {
pp.setListener(l);
} else {
logger.error(
Util.delayedFormatString("Listener name not found for %s: %s", pp, listenerName));
}
}
}
shost.addProbe(p);
return p;
}
