Datenschutzhinweis

 

Beim Laden dieses Inhalts werden Nutzungsinformationen an Vimeo übertragen und dort ggf. verarbeitet.

 

             

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?

Das ist großartig!

Vielen Dank für das Feedback

Leider konnten wir nicht helfen

Vielen Dank für das Feedback

Wie können wir diesen Artikel verbessern?

Wählen Sie wenigstens einen der Gründe aus
CAPTCHA-Verifikation ist erforderlich.

Feedback gesendet

Wir wissen Ihre Bemühungen zu schätzen und werden versuchen, den Artikel zu korrigieren