#232 Restored admin username/password to ManageConfig and ManageClient

Author: rjrudin

src/main/java/com/marklogic/mgmt/AbstractManager.java

@@ -1,13 +1,29 @@
 package com.marklogic.mgmt;
 
 import com.marklogic.client.ext.helper.LoggingObject;
+import com.marklogic.mgmt.ManageClient;
+import com.marklogic.mgmt.PayloadParser;
 import org.springframework.http.ResponseEntity;
 import org.springframework.util.ClassUtils;
 
 public class AbstractManager extends LoggingObject {
 
     protected PayloadParser payloadParser = new PayloadParser();
 
+    /**
+     * Manager classes that need to connect to ML as a user with the admin role should override this to return true.
+     * The main use case for this is while an application may define a user with the manage-admin role that can be used
+     * for deploying most resources, that user must first be created. And thus, some user with at least the manage-admin
+     * and security roles must already exist and must be used to create that user. And while only the manage-admin and
+     * security roles are needed, in practice it's likely that this is an admin user. Finally, since that user may
+     * depend on app-specific roles and privileges, then those resources must be created first by the admin user too.
+     *
+     * @return
+     */
+    protected boolean useAdminUser() {
+        return false;
+    }
+
     /**
      * Assumes the resource name is based on the class name - e.g. RoleManager would have a resource name of "role".
      *
@@ -34,16 +50,18 @@ protected String getResourceId(String payload) {
     }
 
     protected ResponseEntity<String> putPayload(ManageClient client, String path, String payload) {
+        boolean useAdmin = useAdminUser();
         if (payloadParser.isJsonPayload(payload)) {
-            return client.putJson(path, payload);
+            return useAdmin ? client.putJsonAsAdmin(path, payload) : client.putJson(path, payload);
         }
-        return client.putXml(path, payload);
+        return useAdmin ? client.putXmlAsAdmin(path, payload) : client.putXml(path, payload);
     }
 
     protected ResponseEntity<String> postPayload(ManageClient client, String path, String payload) {
+        boolean useAdmin = useAdminUser();
         if (payloadParser.isJsonPayload(payload)) {
-            return client.postJson(path, payload);
+            return useAdmin ? client.postJsonAsAdmin(path, payload) : client.postJson(path, payload);
         }
-        return client.postXml(path, payload);
+        return useAdmin ? client.postXmlAsAdmin(path, payload) : client.postXml(path, payload);
     }
 }

src/main/java/com/marklogic/mgmt/DefaultManageConfigFactory.java

@@ -72,6 +72,26 @@ public ManageConfig newManageConfig() {
 	    	c.setCleanJsonPayloads(Boolean.parseBoolean(prop));
 	    }
 
+	    prop = getProperty("mlAdminUsername");
+	    if (prop != null) {
+		    logger.info("Manage admin username: " + prop);
+		    c.setAdminUsername(prop);
+	    } else if (mlUsername != null) {
+		    logger.info("Manage admin username: " + mlUsername);
+		    c.setAdminUsername(mlUsername);
+	    } else {
+		    c.setAdminUsername(c.getUsername());
+	    }
+
+	    prop = getProperty("mlAdminPassword");
+	    if (prop != null) {
+		    c.setAdminPassword(prop);
+	    } else if (mlPassword != null) {
+		    c.setAdminPassword(mlPassword);
+	    } else {
+		    c.setAdminPassword(c.getPassword());
+	    }
+
         return c;
     }
 

src/main/java/com/marklogic/mgmt/ManageClient.java

@@ -4,6 +4,7 @@
 import com.marklogic.client.ext.helper.LoggingObject;
 import com.marklogic.mgmt.util.ObjectMapperFactory;
 import com.marklogic.rest.util.Fragment;
+import com.marklogic.rest.util.RestConfig;
 import com.marklogic.rest.util.RestTemplateUtil;
 import org.jdom2.Namespace;
 import org.springframework.http.*;
@@ -23,8 +24,9 @@
  */
 public class ManageClient extends LoggingObject {
 
-    private ManageConfig manageConfig;
-    private RestTemplate restTemplate;
+	private ManageConfig manageConfig;
+	private RestTemplate restTemplate;
+	private RestTemplate adminRestTemplate;
 	private PayloadParser payloadParser;
 
     /**
@@ -44,6 +46,21 @@ public void initialize(ManageConfig config) {
             logger.info("Initializing ManageClient with manage config of: " + config);
         }
         this.restTemplate = RestTemplateUtil.newRestTemplate(config);
+
+        if (!config.getUsername().equals(config.getAdminUsername())) {
+	        if (logger.isInfoEnabled()) {
+		        logger.info("Initializing ManageClient with admin config, admin user: " + config.getAdminUsername());
+	        }
+
+	        RestConfig rc = new RestConfig(config.getHost(), config.getPort(), config.getAdminUsername(), config.getAdminPassword());
+	        rc.setScheme(config.getScheme());
+	        rc.setConfigureSimpleSsl(config.isConfigureSimpleSsl());
+	        rc.setHostnameVerifier(config.getHostnameVerifier());
+	        rc.setSslContext(config.getSslContext());
+	        this.adminRestTemplate = RestTemplateUtil.newRestTemplate(rc);
+        } else {
+            this.adminRestTemplate = restTemplate;
+        }
     }
 
 	/**
@@ -53,29 +70,61 @@ public void initialize(ManageConfig config) {
 	 * @param restTemplate
 	 */
 	public ManageClient(RestTemplate restTemplate) {
-		this.restTemplate = restTemplate;
+    	this(restTemplate, restTemplate);
+    }
+
+	/**
+	 * Use this when you want to provide your own RestTemplate as opposed to using the one that's constructed via a
+	 * ManageConfig instance.
+	 *
+	 * @param restTemplate
+	 * @param adminRestTemplate
+	 */
+	public ManageClient(RestTemplate restTemplate, RestTemplate adminRestTemplate) {
+    	this.restTemplate = restTemplate;
+    	this.adminRestTemplate = adminRestTemplate;
     }
 
     public ResponseEntity<String> putJson(String path, String json) {
         logRequest(path, "JSON", "PUT");
         return restTemplate.exchange(buildUri(path), HttpMethod.PUT, buildJsonEntity(json), String.class);
     }
 
+    public ResponseEntity<String> putJsonAsAdmin(String path, String json) {
+        logAdminRequest(path, "JSON", "PUT");
+        return adminRestTemplate.exchange(buildUri(path), HttpMethod.PUT, buildJsonEntity(json), String.class);
+    }
+
     public ResponseEntity<String> putXml(String path, String xml) {
         logRequest(path, "XML", "PUT");
         return restTemplate.exchange(buildUri(path), HttpMethod.PUT, buildXmlEntity(xml), String.class);
     }
 
+    public ResponseEntity<String> putXmlAsAdmin(String path, String xml) {
+        logAdminRequest(path, "XML", "PUT");
+        return adminRestTemplate.exchange(buildUri(path), HttpMethod.PUT, buildXmlEntity(xml), String.class);
+    }
+
     public ResponseEntity<String> postJson(String path, String json) {
         logRequest(path, "JSON", "POST");
         return restTemplate.exchange(buildUri(path), HttpMethod.POST, buildJsonEntity(json), String.class);
     }
 
+    public ResponseEntity<String> postJsonAsAdmin(String path, String json) {
+        logAdminRequest(path, "JSON", "POST");
+        return adminRestTemplate.exchange(buildUri(path), HttpMethod.POST, buildJsonEntity(json), String.class);
+    }
+
     public ResponseEntity<String> postXml(String path, String xml) {
         logRequest(path, "XML", "POST");
         return restTemplate.exchange(buildUri(path), HttpMethod.POST, buildXmlEntity(xml), String.class);
     }
 
+    public ResponseEntity<String> postXmlAsAdmin(String path, String xml) {
+        logAdminRequest(path, "XML", "POST");
+        return adminRestTemplate.exchange(buildUri(path), HttpMethod.POST, buildXmlEntity(xml), String.class);
+    }
+
     public ResponseEntity<String> postForm(String path, String... params) {
         logRequest(path, "form", "POST");
         HttpHeaders headers = new HttpHeaders();
@@ -102,6 +151,20 @@ public Fragment getXml(String path, String... namespacePrefixesAndUris) {
         return new Fragment(xml, list.toArray(new Namespace[] {}));
     }
 
+	public String getXmlStringAsAdmin(String path) {
+		logAdminRequest(path, "XML", "GET");
+		return getAdminRestTemplate().getForObject(buildUri(path), String.class);
+	}
+
+    public Fragment getXmlAsAdmin(String path, String... namespacePrefixesAndUris) {
+        String xml = getXmlStringAsAdmin(path);
+        List<Namespace> list = new ArrayList<Namespace>();
+        for (int i = 0; i < namespacePrefixesAndUris.length; i += 2) {
+            list.add(Namespace.getNamespace(namespacePrefixesAndUris[i], namespacePrefixesAndUris[i + 1]));
+        }
+        return new Fragment(xml, list.toArray(new Namespace[] {}));
+    }
+
     public String getJson(String path) {
         logRequest(path, "JSON", "GET");
         HttpHeaders headers = new HttpHeaders();
@@ -117,11 +180,24 @@ public String getJson(URI uri) {
         return getRestTemplate().exchange(uri, HttpMethod.GET, new HttpEntity<>(headers), String.class).getBody();
     }
 
+    public String getJsonAsAdmin(String path) {
+        logAdminRequest(path, "JSON", "GET");
+        HttpHeaders headers = new HttpHeaders();
+        headers.set("Accept", MediaType.APPLICATION_JSON_VALUE);
+        return getAdminRestTemplate().exchange(buildUri(path), HttpMethod.GET, new HttpEntity<>(headers), String.class)
+                .getBody();
+    }
+
     public void delete(String path) {
         logRequest(path, "", "DELETE");
         restTemplate.delete(buildUri(path));
     }
 
+    public void deleteAsAdmin(String path) {
+        logAdminRequest(path, "", "DELETE");
+        adminRestTemplate.delete(buildUri(path));
+    }
+
 	/**
 	 * Per #187 and version 3.1.0, when an HttpEntity is constructed with a JSON payload, this method will check to see
 	 * if it should "clean" the JSON via the Jackson library, which is primarily intended for removing comments from
@@ -187,11 +263,19 @@ public RestTemplate getRestTemplate() {
         return restTemplate;
     }
 
+    public RestTemplate getAdminRestTemplate() {
+        return adminRestTemplate;
+    }
+
     public ManageConfig getManageConfig() {
         return manageConfig;
     }
 
 	public void setRestTemplate(RestTemplate restTemplate) {
 		this.restTemplate = restTemplate;
 	}
+
+	public void setAdminRestTemplate(RestTemplate adminRestTemplate) {
+		this.adminRestTemplate = adminRestTemplate;
+	}
 }

src/main/java/com/marklogic/mgmt/ManageConfig.java

@@ -4,8 +4,9 @@
 
 /**
  * Defines the configuration data for talking to the Mgmt REST API. Also includes properties for the admin user, as this
- * user is typically needed for managing resources such as roles and users. If adminUsername and adminPassword are not
- * set, they default to the username/password attribute values.
+ * user is typically needed for creating an app-specific user (which may depend on app-specific roles and privileges)
+ * which is then used for deploying every other resources. If adminUsername and adminPassword are not set, they default
+ * to the username/password attribute values.
  */
 public class ManageConfig extends RestConfig {
 
@@ -16,6 +17,8 @@ public class ManageConfig extends RestConfig {
 	public static final String DEFAULT_USERNAME = "admin";
 	public static final String DEFAULT_PASSWORD = "admin";
 
+	private String adminUsername;
+	private String adminPassword;
 	private boolean cleanJsonPayloads = false;
 
 	public ManageConfig() {
@@ -28,12 +31,14 @@ public ManageConfig(String host, String password) {
 
 	public ManageConfig(String host, int port, String username, String password) {
 		super(host, port, username, password);
+		setAdminUsername(username);
+		setAdminPassword(password);
 	}
 
 	@Override
 	public String toString() {
-		return String.format("[ManageConfig host: %s, port: %d, username: %s]", getHost(),
-			getPort(), getUsername());
+		return String.format("[ManageConfig host: %s, port: %d, username: %s, admin username: %s]", getHost(),
+			getPort(), getUsername(), getAdminUsername());
 	}
 
 	public boolean isCleanJsonPayloads() {
@@ -43,4 +48,20 @@ public boolean isCleanJsonPayloads() {
 	public void setCleanJsonPayloads(boolean cleanJsonPayloads) {
 		this.cleanJsonPayloads = cleanJsonPayloads;
 	}
+
+	public String getAdminUsername() {
+		return adminUsername;
+	}
+
+	public void setAdminUsername(String adminUsername) {
+		this.adminUsername = adminUsername;
+	}
+
+	public String getAdminPassword() {
+		return adminPassword;
+	}
+
+	public void setAdminPassword(String adminPassword) {
+		this.adminPassword = adminPassword;
+	}
 }

src/main/java/com/marklogic/mgmt/api/API.java

@@ -87,10 +87,9 @@ public void connect(String host, ManageConfig mc) {
 		    logger.info("Connecting to host: " + host);
 	    }
 	    SimplePropertySource sps = new SimplePropertySource("mlHost", host, "mlManageUsername", mc.getUsername(),
-		    "mlManagePassword", mc.getPassword(),
-		    "mlManageSimpleSsl", mc.isConfigureSimpleSsl() + "",
-		    "mlManageScheme", mc.getScheme(),
-		    "mlManagePort", mc.getPort() + "");
+		    "mlManagePassword", mc.getPassword(), "mlManageSimpleSsl", mc.isConfigureSimpleSsl() + "",
+		    "mlManageScheme", mc.getScheme(), "mlManagePort", mc.getPort() + "",
+		    "mlAdminUsername", mc.getAdminUsername(), "mlAdminPassword", mc.getAdminPassword());
 	    this.manageClient = new ManageClient(new DefaultManageConfigFactory(sps).newManageConfig());
 	    if (logger.isInfoEnabled()) {
 		    logger.info("Connected to host: " + host);
@@ -105,19 +104,34 @@ public void connect(String host, ManageConfig mc) {
      * @param password
      */
     public void connect(String host, String username, String password) {
-	    ManageConfig mc = new ManageConfig();
-	    mc.setHost(host);
-	    mc.setUsername(username);
-	    mc.setPassword(password);
-	    connect(host, mc);
+	    connect(host, username, password, username, password);
     }
 
-    /**
-     * Constructs a new ClientHelper, using newClient().
-     *
-     * @return
-     */
-    public ClientHelper clientHelper() {
+	/**
+	 * Connect to a (presumably) different MarkLogic Management API.
+	 *
+	 * @param host
+	 * @param username
+	 * @param password
+	 * @param adminUsername
+	 * @param adminPassword
+	 */
+	public void connect(String host, String username, String password, String adminUsername, String adminPassword) {
+		ManageConfig mc = new ManageConfig();
+		mc.setHost(host);
+		mc.setUsername(username);
+		mc.setPassword(password);
+		mc.setAdminUsername(adminUsername);
+		mc.setAdminPassword(adminPassword);
+		connect(host, mc);
+	}
+
+	/**
+	 * Constructs a new ClientHelper, using newClient().
+	 *
+	 * @return
+	 */
+	public ClientHelper clientHelper() {
         return new ClientHelper(newClient());
     }