[GEOS-8096] Align JMS community plugin with the new REST API

src/community/jms-cluster/jms-geoserver/src/main/java/org/geoserver/cluster/impl/events/RestDispatcherCallback.java

@@ -5,61 +5,54 @@
  */
 package org.geoserver.cluster.impl.events;
 
-import java.util.Iterator;
-import java.util.List;
-
 import org.geoserver.rest.DispatcherCallback;
 import org.geotools.util.logging.Logging;
-import org.restlet.Restlet;
-import org.restlet.data.Parameter;
-import org.restlet.data.Request;
-import org.restlet.data.Response;
+
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+import java.util.AbstractMap.SimpleEntry;
+import java.util.Map;
+import java.util.logging.Level;
+import java.util.stream.Collectors;
 
 public class RestDispatcherCallback implements DispatcherCallback {
     final static java.util.logging.Logger LOGGER = Logging.getLogger(RestDispatcherCallback.class);
 
-    private static final ThreadLocal<List<Parameter>> parameters = new ThreadLocal<List<Parameter>>();
+    private static final ThreadLocal<Map<String, String>> parameters = new ThreadLocal<>();
 
-    public static List<Parameter> getParameters() {
+    public static Map<String, String> getParameters() {
         return parameters.get();
     }
 
     @Override
-    public void init(Request request, Response response) {
-
-        if (LOGGER.isLoggable(java.util.logging.Level.FINE)) {
-            final Iterator<Parameter> it = request.getResourceRef().getQueryAsForm().iterator();
-            while (it.hasNext()) {
-                Parameter p = it.next();
-                if (LOGGER.isLoggable(java.util.logging.Level.INFO)) {
-                    LOGGER.info("Registering incoming parameter: " + p.toString());
-                }
-            }
+    public void init(HttpServletRequest request, HttpServletResponse response) {
+        // get request parameters
+        Map<String, String> parameters = request.getParameterMap().entrySet().stream().map(entry -> {
+            String[] values = entry.getValue();
+            String value = values == null || values.length == 0 ? null : values[0];
+            return new SimpleEntry<>(entry.getKey(), value);
+        }).collect(Collectors.toMap(SimpleEntry::getKey, SimpleEntry::getValue));
+        // log request parameters
+        if (LOGGER.isLoggable(Level.FINE)) {
+            parameters.keySet().forEach(parameter ->
+                    LOGGER.info("Registering incoming parameter: " + parameter));
         }
-        parameters.set(request.getResourceRef().getQueryAsForm());
-
-        // check purge parameter to determine if the underlying file
-        // should be deleted
-        // boolean purge = (p != null) ? Boolean.parseBoolean(p) : false;
-        // catalog.getResourcePool().deleteStyle(s, purge);
-
-        // LOGGER.info( "DELETE style " + style);
-
+        // set local parameters
+        this.parameters.set(parameters);
     }
 
     @Override
-    public void dispatched(Request request, Response response, Restlet restlet) {
+    public void dispatched(HttpServletRequest request, HttpServletResponse response, Object handler) {
 
     }
 
     @Override
-    public void exception(Request request, Response response, Exception error) {
+    public void exception(HttpServletRequest request, HttpServletResponse response, Exception error) {
 
     }
 
     @Override
-    public void finished(Request request, Response response) {
+    public void finished(HttpServletRequest request, HttpServletResponse response) {
 
     }
-
 }

src/community/jms-cluster/jms-geoserver/src/main/java/org/geoserver/cluster/impl/rest/ClusterController.java

@@ -0,0 +1,137 @@
+/* (c) 2017 Open Source Geospatial Foundation - all rights reserved
+ * This code is licensed under the GPL 2.0 license, available at the root
+ * application directory.
+ */
+package org.geoserver.cluster.impl.rest;
+
+import freemarker.template.SimpleHash;
+import freemarker.template.Template;
+import org.geoserver.catalog.Catalog;
+import org.geoserver.cluster.configuration.BrokerConfiguration;
+import org.geoserver.cluster.configuration.ConnectionConfiguration;
+import org.geoserver.cluster.configuration.JMSConfiguration;
+import org.geoserver.cluster.configuration.ReadOnlyConfiguration;
+import org.geoserver.cluster.configuration.ToggleConfiguration;
+import org.geoserver.cluster.events.ToggleType;
+import org.geoserver.config.util.XStreamPersister;
+import org.geoserver.rest.ObjectToMapWrapper;
+import org.geoserver.rest.RestBaseController;
+import org.geoserver.rest.catalog.AbstractCatalogController;
+import org.geoserver.rest.converters.FreemarkerHTMLMessageConverter;
+import org.geoserver.rest.converters.XStreamMessageConverter;
+import org.geoserver.rest.util.MediaTypeExtensions;
+import org.geoserver.rest.wrapper.RestWrapper;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.core.MethodParameter;
+import org.springframework.http.HttpHeaders;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.MediaType;
+import org.springframework.http.ResponseEntity;
+import org.springframework.http.converter.HttpMessageConverter;
+import org.springframework.web.bind.annotation.ControllerAdvice;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.PostMapping;
+import org.springframework.web.bind.annotation.RequestBody;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RestController;
+import org.springframework.web.util.UriComponents;
+import org.springframework.web.util.UriComponentsBuilder;
+
+import java.io.IOException;
+import java.lang.reflect.Type;
+import java.util.Map;
+import java.util.Properties;
+
+@RestController
+@ControllerAdvice
+@RequestMapping(path = RestBaseController.ROOT_PATH + "/cluster")
+public class ClusterController extends AbstractCatalogController {
+
+    @Autowired
+    private Controller controller;
+
+    @Autowired
+    private JMSConfiguration config;
+
+    public ClusterController(Catalog catalog) {
+        super(catalog);
+    }
+
+    @GetMapping(produces = {
+            MediaType.APPLICATION_JSON_VALUE,
+            MediaType.APPLICATION_XML_VALUE,
+            MediaType.TEXT_HTML_VALUE})
+    public RestWrapper<Properties> getClusterConfiguration() {
+        return wrapObject(config.getConfigurations(), Properties.class);
+    }
+
+    @PostMapping(consumes = {
+            MediaType.APPLICATION_JSON_VALUE,
+            MediaTypeExtensions.TEXT_JSON_VALUE,
+            MediaType.APPLICATION_XML_VALUE,
+            MediaType.TEXT_XML_VALUE})
+    public ResponseEntity<String> postClusterConfiguration(
+            @RequestBody Properties props, UriComponentsBuilder builder) throws IOException {
+        for (Object key : props.keySet()) {
+            String k = key.toString();
+            final String value = props.get(key).toString();
+            // store config
+            config.putConfiguration(key.toString(), value);
+            final Object oldValue = config.getConfiguration(k);
+            if (props.get(k).equals(oldValue)) {
+                continue;
+            }
+            if (key.equals(ConnectionConfiguration.CONNECTION_KEY)) {
+                // CONNECTION
+                controller.connectClient(Boolean.getBoolean(value));
+            } else if (key.equals(ToggleConfiguration.TOGGLE_MASTER_KEY)) {
+                // toggle MASTER
+                controller.toggle(Boolean.getBoolean(value), ToggleType.MASTER);
+            } else if (key.equals(ToggleConfiguration.TOGGLE_SLAVE_KEY)) {
+                // toggle SLAVE
+                controller.toggle(Boolean.getBoolean(value), ToggleType.SLAVE);
+            } else if (key.equals(JMSConfiguration.INSTANCE_NAME_KEY)) {
+                // InstanceName
+                controller.setInstanceName(value);
+            } else if (key.equals(BrokerConfiguration.BROKER_URL_KEY)) {
+                // BROKER_URL
+                controller.setBrokerURL(value);
+            } else if (key.equals(ReadOnlyConfiguration.READ_ONLY_KEY)) {
+                // ReadOnly
+                controller.setReadOnly(Boolean.getBoolean(value));
+            } else if (key.equals(JMSConfiguration.GROUP_KEY)) {
+                // group
+                controller.setGroup(value);
+            }
+        }
+        // SAVE to disk
+        controller.save();
+        UriComponents uriComponents = builder.path("/cluster").build();
+        HttpHeaders headers = new HttpHeaders();
+        headers.setLocation(uriComponents.toUri());
+        return new ResponseEntity<>(props.toString(), headers, HttpStatus.CREATED);
+    }
+
+    @Override
+    public boolean supports(MethodParameter methodParameter, Type targetType,
+                            Class<? extends HttpMessageConverter<?>> converterType) {
+        return Properties.class.isAssignableFrom(methodParameter.getParameterType());
+    }
+
+    @Override
+    public void configureFreemarker(FreemarkerHTMLMessageConverter converter, Template template) {
+        template.setObjectWrapper(new ObjectToMapWrapper<Properties>(
+                Properties.class) {
+            @Override
+            protected void wrapInternal(Map properties, SimpleHash model,
+                                        Properties props) {
+                properties.putAll(props);
+            }
+        });
+    }
+
+    @Override
+    public void configurePersister(XStreamPersister persister, XStreamMessageConverter converter) {
+        persister.getXStream().allowTypes(new Class[]{Properties.class});
+    }
+}