JMX plugin

Geändert am Mo, 9 Jan, 2023 um 3:27 NACHMITTAGS

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;
  }
}

War dieser Artikel hilfreich?