Wiki-Quellcode von JMX plugin

Zeige letzte Bearbeiter
1 {{content/}}
2
3 == IPluginMonitor ==
4
5 === Verwendungsmöglichkeiten ===
6
7 Das Plugin dient zum Zustands-Monitoring bei selbst erstellten Plugins oder prüfen von Verfügbarkeiten angebundener Drittsysteme per JMX-Schnittstelle.
8
9 === Methodesignaturen ===
10
11 {{panel title="{{code language='java'~}~}String check(){{/code~}~}" triggerable="true" fullwidth="true"}}
12 Diese Methode wird bei jedem Aktualisieren der Anzeige des Monitors aufgerufen.
13 Im Fall einer erfolgreichen Prüfung ist die Konstante //IPluginMonitor.CHECK_SUCCESS// zurückzuliefern.<br>
14 Für den Fehlerfall bestehen folgende Möglichkeiten:
15 * Es kann eine Java-Exception geworfen werden.
16 * Es kann eine Fehlernachricht zurückgegeben werden. Diese wird in der Monitoring-MBean dargestellt. Die
17 Zeichenkette kann selbst definiert sein, oder es kann die Konstante //IPluginMonitor.CHECK_ERROR//
18 verwendet werden. In jeden Fall muss der Wert der zurückgelieferten Zeichenkette ungleich dem Wert der Konstante
19 //IPluginMonitor.CHECK_SUCCESS// sein.
20 {{/panel}}
21
22 === Beispiel-Implementierungen ===
23
24 Beispiel 1: Der nachfolgende Quellcode zeigt ein Beispiel, wo auf die Verfügbarkeit eines Drittsystems geprüft wird.
25
26 {{code language="java"}}
27
28 import java.net.HttpURLConnection;
29 import java.net.URL;
30
31 import de.xima.fc.plugin.interfaces.monitoring.IPluginMonitor;
32
33 public class MyMonitor implements IPluginMonitor {
34
35 @Override
36 public String check() {
37 try {
38 URL url = new URL("http://example.com");
39 HttpURLConnection urlConnection = null;
40 urlConnection = (HttpURLConnection)url.openConnection();
41 urlConnection.setConnectTimeout(1000);
42 urlConnection.setReadTimeout(1000);
43 urlConnection.connect();
44 if (HttpURLConnection.HTTP_OK != urlConnection.getResponseCode()) {
45 return urlConnection.getResponseMessage();
46 }
47 return IPluginMonitor.CHECK_SUCCESS;
48 }
49 catch (Exception e) {
50 return IPluginMonitor.CHECK_ERROR;
51 }
52 }
53 }
54 {{/code}}
55
56 Beispiel 2: Abfrage Fehlerstatus eines Statusverarbeitungs-Plugins
57
58 {{code language="java"}}
59 import org.apache.commons.lang3.StringUtils;
60
61 import de.xima.fc.plugin.interfaces.monitoring.IPluginMonitor;
62 import de.xima.foobar.plugin.MyTestPlugin;
63
64 public class MyMonitor implements IPluginMonitor {
65
66 @Override
67 public String check() throws Exception {
68 String state = MyTestPlugin.getMonitoringState();
69 if (StringUtils.isBlank(state) || StringUtils.equalsIgnoreCase(IPluginMonitor.CHECK_SUCCESS, state)) {
70 return IPluginMonitor.CHECK_SUCCESS;
71 } else {
72 return state;
73 }
74 }
75 }
76 {{/code}}
77
78 {{code language="java"}}
79 import java.util.ArrayList;
80 import java.util.HashMap;
81 import java.util.LinkedHashMap;
82 import java.util.List;
83 import java.util.Map;
84
85 import org.apache.commons.lang3.StringUtils;
86
87 import de.xima.fc.bl.fdv.processing.result.ProcessingResultMultiValue;
88 import de.xima.fc.interfaces.plugin.param.workflow.IPluginProcessingParams;
89 import de.xima.fc.interfaces.plugin.retval.workflow.IPluginProcessingRetVal;
90 import de.xima.fc.plugin.config.IPluginConfigParam;
91 import de.xima.fc.plugin.config.IPluginConfigParam.EPluginParamBehavior;
92 import de.xima.fc.plugin.config.IPluginConfigParamList;
93 import de.xima.fc.plugin.exception.FCPluginException;
94 import de.xima.fc.plugin.interfaces.monitoring.IPluginMonitor;
95 import de.xima.fc.plugin.interfaces.workflow.IPluginProcessing;
96 import de.xima.fc.plugin.models.config.PluginConfigGroupItem;
97 import de.xima.fc.plugin.models.config.PluginConfigParam;
98
99
100 @SuppressWarnings("serial")
101 public class MyTestPlugin implements IPluginProcessing, IPluginConfigParamList {
102
103 private static final String PARAM_IN_1 = "InputParameter_1";
104 private static final String PARAM_OUT = "OutputParameter";
105
106 private static String monitoringState;
107
108 public String getName() {
109 return "MyPlugin";
110 }
111
112 public void initPlugin() throws FCPluginException { }
113
114 public static String getMonitoringState() {
115 return monitoringState;
116 }
117
118 @Override
119 public IPluginProcessingRetVal execute(IPluginProcessingParams processingParams) throws FCPluginException {
120 // read input values
121 Map<String, String> pluginParams = processingParams.getParams();
122 String param1 = pluginParams.get(PARAM_IN_1);
123
124 // check and write state for monitoring
125 if (StringUtils.isBlank(param1)) {
126 monitoringState = "Param1 is empty!";
127 } else {
128 monitoringState = IPluginMonitor.CHECK_SUCCESS;
129 }
130 // plugin processing
131 // .... do something
132
133 // write return values
134 String resultValue = "AnyResultValue";
135 return new ProcessingResultMultiValue(createResult(resultValue), true);
136 }
137
138 @Override
139 public String getDescription() {
140 return "The plugin makes something important...";
141 }
142
143 @Override
144 public Map<String, IPluginConfigParam> getConfigParameter() {
145 Map<String, IPluginConfigParam> map = new LinkedHashMap<>();
146 map.put("input", new PluginConfigGroupItem("base data:"));
147 map.put(PARAM_IN_1, new PluginConfigParam(PARAM_IN_1, "This is a mandatory parameter!", true, EPluginParamBehavior.IN));
148 map.put("output", new PluginConfigGroupItem("output data:"));
149 map.put(PARAM_OUT, new PluginConfigParam(PARAM_OUT, null, false, EPluginParamBehavior.OUT));
150 return map;
151 }
152
153 private List<Map<String, String>> createResult(String result) {
154 List<Map<String, String>> resultList = new ArrayList<Map<String, String>>();
155 Map<String, String> resultMap = new HashMap<String, String>();
156 resultMap.put(PARAM_OUT, result);
157 resultList.add(resultMap);
158 return resultList;
159 }
160 }
161 {{/code}}