JMX plugin

Inhalt [ Verbergen ]

IPluginMonitor

IPluginMonitor

Verwendungsmöglichkeiten

Das Plugin dient zum Zustands-Monitoring bei selbst erstellten Plugins oder prüfen von Verfügbarkeiten angebundener Drittsysteme per JMX-Schnittstelle.

Methodesignaturen

String check()

Diese Methode wird bei jedem Aktualisieren der Anzeige des Monitors aufgerufen. Im Fall einer erfolgreichen Prüfung ist die Konstante IPluginMonitor.CHECK_SUCCESS zurückzuliefern.
Für den Fehlerfall bestehen folgende Möglichkeiten:

Es kann eine Java-Exception geworfen werden.
Es kann eine Fehlernachricht zurückgegeben werden. Diese wird in der Monitoring-MBean dargestellt. Die Zeichenkette kann selbst definiert sein, oder es kann die Konstante IPluginMonitor.CHECK_ERROR verwendet werden. In jeden Fall muss der Wert der zurückgelieferten Zeichenkette ungleich dem Wert der Konstante IPluginMonitor.CHECK_SUCCESS sein.

Beispiel-Implementierungen

Beispiel 1: Der nachfolgende Quellcode zeigt ein Beispiel, wo auf die Verfügbarkeit eines Drittsystems geprüft wird.

import java.net.HttpURLConnection;
import java.net.URL;

import de.xima.fc.plugin.interfaces.monitoring.IPluginMonitor;

public class MyMonitor implements IPluginMonitor {

@Override
public String check() {
   try {
      URL url = new URL("http://example.com");
      HttpURLConnection urlConnection = null;
      urlConnection = (HttpURLConnection)url.openConnection();
      urlConnection.setConnectTimeout(1000);
      urlConnection.setReadTimeout(1000);
      urlConnection.connect();
     if (HttpURLConnection.HTTP_OK != urlConnection.getResponseCode()) {
       return urlConnection.getResponseMessage();
     }
     return IPluginMonitor.CHECK_SUCCESS;
   }
   catch (Exception e) {
     return IPluginMonitor.CHECK_ERROR;
   }
}
}

Beispiel 2: Abfrage Fehlerstatus eines Statusverarbeitungs-Plugins

import org.apache.commons.lang3.StringUtils;

import de.xima.fc.plugin.interfaces.monitoring.IPluginMonitor;
import de.xima.foobar.plugin.MyTestPlugin;

public class MyMonitor implements IPluginMonitor {

@Override
public String check() throws Exception {
    String state = MyTestPlugin.getMonitoringState();
   if (StringUtils.isBlank(state) || StringUtils.equalsIgnoreCase(IPluginMonitor.CHECK_SUCCESS, state)) {
     return IPluginMonitor.CHECK_SUCCESS;
   } else {
     return state;
   }
}
}

import java.util.ArrayList;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;

import org.apache.commons.lang3.StringUtils;

import de.xima.fc.bl.fdv.processing.result.ProcessingResultMultiValue;
import de.xima.fc.interfaces.plugin.param.workflow.IPluginProcessingParams;
import de.xima.fc.interfaces.plugin.retval.workflow.IPluginProcessingRetVal;
import de.xima.fc.plugin.config.IPluginConfigParam;
import de.xima.fc.plugin.config.IPluginConfigParam.EPluginParamBehavior;
import de.xima.fc.plugin.config.IPluginConfigParamList;
import de.xima.fc.plugin.exception.FCPluginException;
import de.xima.fc.plugin.interfaces.monitoring.IPluginMonitor;
import de.xima.fc.plugin.interfaces.workflow.IPluginProcessing;
import de.xima.fc.plugin.models.config.PluginConfigGroupItem;
import de.xima.fc.plugin.models.config.PluginConfigParam;

@SuppressWarnings("serial")
public class MyTestPlugin implements IPluginProcessing, IPluginConfigParamList {

private static final String PARAM_IN_1 = "InputParameter_1";
private static final String PARAM_OUT = "OutputParameter";

private static String monitoringState;

public String getName() {
   return "MyPlugin";
}

public void initPlugin() throws FCPluginException { }

public static String getMonitoringState() {
   return monitoringState;
}

@Override
public IPluginProcessingRetVal execute(IPluginProcessingParams processingParams) throws FCPluginException {
   // read input values
   Map<String, String> pluginParams = processingParams.getParams();
    String param1 = pluginParams.get(PARAM_IN_1);

   // check and write state for monitoring
   if (StringUtils.isBlank(param1)) {
      monitoringState = "Param1 is empty!";
   } else {
      monitoringState = IPluginMonitor.CHECK_SUCCESS;
   }
   // plugin processing
   // .... do something

   // write return values
   String resultValue = "AnyResultValue";
   return new ProcessingResultMultiValue(createResult(resultValue), true);
}

@Override
public String getDescription() {
   return "The plugin makes something important...";
}

@Override
public Map<String, IPluginConfigParam> getConfigParameter() {
    Map<String, IPluginConfigParam> map = new LinkedHashMap<>();
    map.put("input", new PluginConfigGroupItem("base data:"));
    map.put(PARAM_IN_1, new PluginConfigParam(PARAM_IN_1, "This is a mandatory parameter!", true, EPluginParamBehavior.IN));
    map.put("output", new PluginConfigGroupItem("output data:"));
    map.put(PARAM_OUT, new PluginConfigParam(PARAM_OUT, null, false, EPluginParamBehavior.OUT));
   return map;
}

private List<Map<String, String>> createResult(String result) {
    List<Map<String, String>> resultList = new ArrayList<Map<String, String>>();
    Map<String, String> resultMap = new HashMap<String, String>();
    resultMap.put(PARAM_OUT, result);
    resultList.add(resultMap);
   return resultList;
}
}