add a create/update/changeId/delete posthook (#193)

pom.xml

@@ -72,6 +72,7 @@
 		<staging.dir>${project.build.directory}/staging</staging.dir>
 		<jmockit-version>1.5</jmockit-version>
 		<graalvm.version>22.3.1</graalvm.version>
+		<jackson.version>2.9.6</jackson.version>
 		<compiler.dir>${project.build.directory}/compiler</compiler.dir>
 	</properties>
 
@@ -872,6 +873,11 @@
 			<artifactId>xml-apis</artifactId>
 			<version>1.4.01</version>
 		</dependency>
+		<dependency>
+			<groupId>com.fasterxml.jackson.core</groupId>
+			<artifactId>jackson-databind</artifactId>
+			<version>${jackson.version}</version>
+		</dependency>
 	</dependencies>
 
 	<distributionManagement>

src/main/java/org/lsc/Hooks.java

@@ -0,0 +1,171 @@
+/*
+ ****************************************************************************
+ * Ldap Synchronization Connector provides tools to synchronize
+ * electronic identities from a list of data sources including
+ * any database with a JDBC connector, another LDAP directory,
+ * flat files...
+ *
+ *                  ==LICENSE NOTICE==
+ *
+ * Copyright (c) 2008 - 2011 LSC Project
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+
+ *    * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the LSC Project nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
+ * IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
+ * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
+ * PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
+ * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+ * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ *                  ==LICENSE NOTICE==
+ *
+ *               (c) 2008 - 2011 LSC Project
+ ****************************************************************************
+ */
+package org.lsc;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import java.lang.ProcessBuilder;
+import java.io.OutputStream;
+import java.io.IOException;
+import java.util.Optional;
+import org.lsc.utils.output.LdifLayout;
+import org.lsc.beans.syncoptions.ISyncOptions.OutputFormat;
+import com.fasterxml.jackson.databind.ObjectMapper; // For encoding object to JSON
+import com.fasterxml.jackson.databind.ObjectWriter;
+
+
+/**
+ * This object is managing posthook scripts
+ */
+public class Hooks {
+
+	static final Logger LOGGER = LoggerFactory.getLogger(Hooks.class);
+
+	private static final ObjectMapper Mapper = new ObjectMapper();
+	/**
+	 * Method calling a postSyncHook if necessary
+	 *
+	 * return nothing
+	 */
+	public final void postSyncHook(final Optional<String> hook, final OutputFormat outputFormat, final LscModifications lm) {
+
+		if( hook != null && hook.isPresent() )
+		{
+			switch (lm.getOperation()) {
+				case CREATE_OBJECT:
+					callHook("create", hook.get(), lm.getMainIdentifier(), outputFormat, lm);
+					break;
+
+				case UPDATE_OBJECT:
+					callHook("update", hook.get(), lm.getMainIdentifier(), outputFormat, lm);
+					break;
+
+				case CHANGE_ID:
+					callHook("changeId", hook.get(), lm.getMainIdentifier(), outputFormat, lm);
+					break;
+
+				case DELETE_OBJECT:
+					callHook("delete", hook.get(), lm.getMainIdentifier(), outputFormat, lm);
+					break;
+
+				default:
+					LOGGER.info("Error: unknown operation for posthook {}", hook);
+			}
+		}
+	}
+
+	public final static void callHook(	String operationType,
+						String hook,
+						String identifier,
+						OutputFormat outputFormat,
+						LscModifications lm) {
+
+		LOGGER.info("Calling {} posthook {} with format {} for {}",
+				operationType,
+				hook,
+				outputFormat.toString(),
+				identifier);
+
+		String modifications = null;
+		// Compute modifications only in a create / update / changeid operation
+		if( ! operationType.equals("delete") )
+			{
+			if( outputFormat == OutputFormat.JSON ) {
+				modifications = getJsonModifications(lm);
+			}
+			else {
+				modifications = LdifLayout.format(lm);
+			}
+		}
+
+		try {
+			if( modifications != null ) {
+				Process p = new ProcessBuilder(
+					hook,
+					identifier,
+					operationType)
+				.start();
+
+				// sends ldif modifications to stdin of hook script
+				OutputStream stdin = p.getOutputStream();
+				stdin.write(modifications.getBytes());
+				stdin.write("\n".getBytes());
+				stdin.flush();
+				stdin.close();
+			}
+			else {
+				Process p = new ProcessBuilder(
+					hook,
+					identifier,
+					operationType)
+				.start();
+			}
+		}
+		catch(IOException e) {
+			LOGGER.error("Error while calling {} posthook {} with format {} for {}",
+					operationType,
+					hook,
+					outputFormat.toString(),
+					identifier);
+			LOGGER.error("posthook error: ", e);
+		}
+	}
+
+	/**
+	* Method computing modifications as json
+	*
+	* @return modifications in a json String
+	*/
+	public final static String getJsonModifications(final LscModifications lm) {
+		ObjectWriter ow = Mapper.writer().withDefaultPrettyPrinter();
+		String json = "";
+		try {
+			json = ow.writeValueAsString(lm.getLscAttributeModifications());
+		}
+		catch(Exception e) {
+			LOGGER.error("Error while encoding LSC modifications to json");
+			LOGGER.error("encoding error: ", e);
+		}
+		return json;
+	}
+
+}

src/main/java/org/lsc/beans/syncoptions/ForceSyncOptions.java

@@ -47,6 +47,7 @@
 
 import java.util.List;
 import java.util.Set;
+import java.util.Optional;
 
 import org.lsc.LscModificationType;
 import org.lsc.configuration.PolicyType;
@@ -128,6 +129,30 @@ public String getCondition(LscModificationType operation) {
 		return DEFAULT_CONDITION;
 	}
 
+	public OutputFormat getPostHookOutputFormat() {
+		return OutputFormat.LDIF;
+	}
+
+	public Optional<String> getCreatePostHook() {
+		return Optional.ofNullable(null);
+	}
+
+	public Optional<String> getDeletePostHook() {
+		return Optional.ofNullable(null);
+	}
+
+	public Optional<String> getUpdatePostHook() {
+		return Optional.ofNullable(null);
+	}
+
+	public Optional<String> getChangeIdPostHook() {
+		return Optional.ofNullable(null);
+	}
+
+	public Optional<String> getPostHook(LscModificationType operation) {
+		return Optional.ofNullable(null);
+	}
+
 	public String getDn() {
 		return null;//((Ldap)task.getDestinationService()).getDn();
 	}

src/main/java/org/lsc/beans/syncoptions/ISyncOptions.java

@@ -47,6 +47,7 @@
 
 import java.util.List;
 import java.util.Set;
+import java.util.Optional;
 
 import org.lsc.LscModificationType;
 import org.lsc.configuration.PolicyType;
@@ -60,6 +61,9 @@ public interface ISyncOptions {
 
 	/** default condition if none is given */
 	public static final String DEFAULT_CONDITION = "true";
+
+	/** list of output formats */
+	public enum OutputFormat { LDIF, JSON };
 
 	/**
 	 * Initialize the synchronization options policy.
@@ -153,6 +157,44 @@ public interface ISyncOptions {
 
 	String getCondition(LscModificationType operation);
 
+	/**
+	 * Returns the posthook output format
+	 *
+	 * @return the posthook output format (default = OutputFormat.LDIF)
+	 */
+	OutputFormat getPostHookOutputFormat();
+
+	/**
+	 * Returns the posthook for a creation
+	 *
+	 * @return the posthook or "" if none is specified (default)
+	 */
+	Optional<String> getCreatePostHook();
+
+	/**
+	 * Returns the posthook for an update
+	 *
+	 * @return the posthook or "" if none is specified (default)
+	 */
+	Optional<String> getUpdatePostHook();
+
+	/**
+	 * Returns the posthook for a delete
+	 *
+	 * @return the posthook or "" if none is specified (default)
+	 */
+	Optional<String> getDeletePostHook();
+
+	/**
+	 * Returns the posthook for a id change
+	 *
+	 * @return the posthook or "" if none is specified (default)
+	 */
+	Optional<String> getChangeIdPostHook();
+
+
+	Optional<String> getPostHook(LscModificationType operation);
+
 	/**
 	 * Return the expression used to infer the new object DN
 	 * @return the new object dn pattern

src/main/java/org/lsc/beans/syncoptions/PropertiesBasedSyncOptions.java

@@ -49,6 +49,7 @@
 import java.util.HashSet;
 import java.util.List;
 import java.util.Set;
+import java.util.Optional;
 
 import org.lsc.LscModificationType;
 import org.lsc.configuration.DatasetType;
@@ -196,6 +197,58 @@ public String getCondition(LscModificationType operation) {
 		}
 		return result;
 	}
+
+	public OutputFormat getPostHookOutputFormat() {
+		// default: returns LDIF format
+		if (conf.getHooks() == null || conf.getHooks().getOutputFormat() == null) {
+			return OutputFormat.LDIF;
+		}
+		switch(conf.getHooks().getOutputFormat()){
+			case "json":
+				return OutputFormat.JSON;
+			default:
+				return OutputFormat.LDIF;
+		}
+	}
+
+	public Optional<String> getCreatePostHook() {
+		Optional<String> hook = Optional.ofNullable(conf.getHooks().getCreatePostHook()).filter(s -> !s.isEmpty());
+		return hook;
+	}
+
+	public Optional<String> getDeletePostHook() {
+		Optional<String> hook = Optional.ofNullable(conf.getHooks().getDeletePostHook()).filter(s -> !s.isEmpty());
+		return hook;
+	}
+
+	public Optional<String> getUpdatePostHook() {
+		Optional<String> hook = Optional.ofNullable(conf.getHooks().getUpdatePostHook()).filter(s -> !s.isEmpty());
+		return hook;
+	}
+
+	public Optional<String> getChangeIdPostHook() {
+		Optional<String> hook = Optional.ofNullable(conf.getHooks().getChangeIdPostHook()).filter(s -> !s.isEmpty());
+		return hook;
+	}
+
+	public Optional<String> getPostHook(LscModificationType operation) {
+		Optional<String> result = Optional.ofNullable(null);
+		switch (operation) {
+			case CREATE_OBJECT:
+				result = this.getCreatePostHook();
+				break;
+			case UPDATE_OBJECT:
+				result = this.getUpdatePostHook();
+				break;
+			case DELETE_OBJECT:
+				result = this.getDeletePostHook();
+				break;
+			case CHANGE_ID:
+				result = this.getChangeIdPostHook();
+				break;
+		}
+		return result;
+	}
 
 	public String getDelimiter(String name) {
         DatasetType dataset = LscConfiguration.getDataset(conf, name);

src/main/java/org/lsc/configuration/.gitignore

@@ -4,6 +4,7 @@
 /AuditType.java
 /AuditsType.java
 /ConditionsType.java
+/HooksType.java
 /ConnectionType.java
 /ConnectionsType.java
 /CsvAuditType.java

src/main/java/org/lsc/runnable/CleanEntryRunner.java

@@ -6,6 +6,7 @@
 import java.util.List;
 import java.util.Map;
 import java.util.Map.Entry;
+import java.util.Optional;
 
 import javax.naming.CommunicationException;
 
@@ -23,6 +24,8 @@
 import org.lsc.utils.ScriptingEvaluator;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
+import org.lsc.Hooks;
+import org.lsc.beans.syncoptions.ISyncOptions.OutputFormat;
 
 /**
  * @author sfroger
@@ -108,6 +111,11 @@ public void run() {
 				// if we got here, we have a modification to apply - let's
 				// do it!
 				if (task.getDestinationService().apply(lm)) {
+					// Retrieve posthook for the current operation
+					Optional<String> hook = syncOptions.getDeletePostHook();
+					OutputFormat outputFormat = syncOptions.getPostHookOutputFormat();
+					Hooks hookObject = new Hooks();
+					hookObject.postSyncHook(hook, outputFormat, lm);
 					counter.incrementCountCompleted();
 					abstractSynchronize.logAction(lm, id, task.getName());
 				} else {