D-Net

package eu.dnetlib.validator.engine.persistance;

import java.io.Serializable;

import eu.dnetlib.validator.engine.Validator;

/**

 * A Registry used to store serializable objects.

 * Registries are used by {@link Validator} to store the objects they need to run.

 * @author Manos Karvounis

 *

 * @param <T>

 */

public abstract class Registry<T extends Serializable> {

	public final String name;

	public Registry(String name) {

		super();

		this.name = name;

	}

	public abstract T getObject(int id);

	public abstract void addObject(int id, T obj);

}

package eu.dnetlib.validator.engine.execution;

import java.util.Date;

import java.util.List;

/**

 * Represents a CompletedTask.

 * @author Manos Karvounis

 * @author Nikon Gasparis

 *

 */

public class CompletedTask {

	/**

	 * If the rule was applied successfully.

	 */

	public final boolean success;

	/**

	 * The id of the object on which the rule was applied.

	 */

	public final String valobjId;

	/**

	 * The id of the rule that was applied.

	 */

	public final int ruleId;

	/**

	 * The date the task started.

	 */

	public final Date started;

	/**

	 * The date the task finished.

	 */

	public final Date finished;

	/**

	 * The reasons why the rule failed to apply on the object.

	 */

	public final List<String> errors;

	/**

	 * Any exception that might have been raised while the rule was applied on the object.

	 */

	public final Exception exception;

	public CompletedTask(boolean success, String valobjId, int ruleId, Date started, Date finished, Exception exception, List<String> errors) {

		super();

		this.success = success;

		this.valobjId = valobjId;

		this.ruleId = ruleId;

		this.started = started;

		this.finished = finished;

		this.exception = exception;

		this.errors = errors;

	}

}

package eu.dnetlib.validator.engine.execution;

import java.util.List;

import java.util.Map;

/**

 * A Listener observing an executing job.

 * @author Manos Karvounis

 *

 */

public interface JobListener {

	/**

	 * <p>Indicates that some tasks of the submitted job have finished unsuccessfully because of an exception.</p>

	 * <p>There might be other tasks waiting to be executed.</p>

	 * @param tasks The tasks that finished.

	 * @param jobId The id of the job that defined the tasks.

	 * @param object 

	 * @param t The exception that was thrown.

	 */

	public void currentResults(List<CompletedTask> tasks, int jobId, Object record, Map<String, Object> recordContext, Throwable t);

	/**

	 * <p>Indicates that some tasks of the submitted job have finished.</p>

	 * <p>There might be other tasks waiting to be executed.</p>

	 * @param tasks The tasks that finished.

	 * @param jobId The id of the job that defined the tasks.

	 */

	public void currentResults(List<CompletedTask> tasks, int jobId, Object record, Map<String, Object> recordContext);

	/**

	 * Indicates that all tasks of a job have finished.

	 * @param jobId

	 */

	public void finished(int jobId, Map<String, Object> jobContext);

	/**

	 * Indicates that a job finished unsuccessfully because of an exception.

	 * @param jobId

	 * @param t

	 */

	public void failed(int jobId, Map<String, Object> jobContext, Throwable t);

}

package eu.dnetlib.validator.engine.execution;

import eu.dnetlib.validator.engine.data.Provider;

import eu.dnetlib.validator.engine.data.Rule;

/**

 * Represents an on which a {@link Rule} may be applied

 * @author Manos Karvounis

 * @see Provider

 */

public interface ValidationObject {

	public String getId();

	public String getStatus();

	public void setId(String id);

	public Object getContentAsObject();

}

package eu.dnetlib.validator.engine.execution;

import java.util.List;

import org.apache.log4j.Logger;

import eu.dnetlib.validator.engine.data.Rule;

import eu.dnetlib.validator.engine.data.RuleException;

/**

 * A Rule that is applied on a Validation Object.

 * @author manos

 * @author Nikon Gasparis

 *

 */

public class Task implements Runnable {

	public final ValidationObject valobj;

	public final Rule rule;

	private boolean success;

	private List<String> errors;

	private Exception exception = null;;

	public Task(ValidationObject valobj, Rule rule) {

		super();

		this.valobj = valobj;

		this.rule = rule;

	}

	@Override

	public void run() {

		Logger log = Logger.getLogger(Task.class);

		try {

			this.success = rule.apply(valobj);

			this.setErrors(rule.getErrors());

		} catch (RuleException e) {

			log.error("Error applyling rule on task", e);

			this.exception = e;

		}

	}

	public boolean isSuccess() {

		return success;

	}

	public Exception getException() {

		return exception;

	}

	public List<String> getErrors() {

		return errors;

	}

	public void setErrors(List<String> errors) {

		this.errors = errors;

	}

}

package eu.dnetlib.validator.engine.execution;

import java.io.Serializable;

import java.util.HashSet;

import java.util.Properties;

import java.util.Set;

import eu.dnetlib.validator.engine.data.Rule;

/**

 * <p>

 * Represents a validation job. A validation job consists of a <i>single</i>

 * provider and a set of rules that will be applied on the validation objects

 * retrieved by the provider.

 * </p>

 * <p>

 * Please note that to execute a validation, you might need to submit multiple

 * jobs, containing various rules and providers.

 * </p>

 * 

 * @author Manos Karvounis

 * 

 */

public class Job implements Serializable {

	private static final long serialVersionUID = -8331921926659185511L;

	public final int providerId;

	public final Properties providerProps;

	public final Set<Rule> rules;

	public final int id;

	public Job(int id, int providerId, Set<Rule> rules, Properties providerProps) {

		super();

		this.id = id;

		this.providerId = providerId;

		this.rules = new HashSet<Rule>();

		this.rules.addAll(rules);

		this.providerProps = new Properties();

		this.providerProps.putAll(providerProps);

	}

}

package eu.dnetlib.validator.engine.execution;

import java.util.concurrent.ExecutionException;

import java.util.concurrent.Future;

import java.util.concurrent.TimeoutException;

public interface Executor {

	public Future<?> execute(TaskList ltasks) throws TimeoutException, ExecutionException;

}

package eu.dnetlib.validator.engine.execution;

import java.util.ArrayList;

import java.util.Date;

import java.util.List;

/**

 * A List of Tasks to be executed.

 * @author Manos Karvounis

 * @author Nikon Gasparis

 * @see Task

 */

public class TaskList implements Runnable {

	public final List<Task> tasks;

	private List<CompletedTask> ctasks;

	public TaskList(List<Task> tasks) {

		super();

		this.tasks = tasks;

		ctasks = new ArrayList<CompletedTask>();

	}

	@Override

	public void run() {

		for (Task task : tasks) {

			Date started = new Date();

			task.run();

			Date finished = new Date();

			CompletedTask ctask = new CompletedTask(task.isSuccess(), task.valobj.getId(), task.rule.getId(), started, finished, task.getException(), task.getErrors());

			ctasks.add(ctask);

		}

	}

	public List<CompletedTask> getCtasks() {

		return ctasks;

	}

}

package eu.dnetlib.validator.engine;

public class ValidatorException extends Exception {

	private static final long serialVersionUID = -5124043465552948242L;

	public ValidatorException() {

		super();

	}

	public ValidatorException(String message) {

		super(message);

	}

	public ValidatorException(String message, Throwable cause) {

		super(message, cause);

	}

	public ValidatorException(Throwable cause) {

		super(cause);

	}

}

package eu.dnetlib.validator.engine;

import java.io.Serializable;

import java.util.Map;

import java.util.Set;

import eu.dnetlib.validator.engine.data.Provider;

import eu.dnetlib.validator.engine.data.Rule;

import eu.dnetlib.validator.engine.execution.Job;

import eu.dnetlib.validator.engine.execution.JobListener;

/**

 * <p>

 * The front-end interface for a Validator.

 * </p>

 * <p>

 * A Validator receives Job execution requests and executes them.

 * </p>

 * <p>

 * It is very important that a Validator is Persistable, i.e., it can be stored

 * in permanent storage and may be retrieved later.

 * </p>

 * 

 * @author Manos Karvounis

 */

public interface Validator {

	/**

	 * Used to store an object to a Registry. Usually these objects are the

	 * rules and providers that are contained in the validator.

	 * 

	 * @param <T>

	 *            The serializable object to be added in the registry.

	 * @param objid

	 *            A unique id for the object.

	 * @param obj

	 *            The object itself.

	 * @param registryName

	 *            The name of the registry. The registry must have been already

	 *            added to the Validator.

	 * @see Provider

	 * @see Rule

	 * @see Validator#addRegistry(String)

	 */

	public <T extends Serializable> void addToRegistry(int objid, T obj,

			String registryName);

	/**

	 * Retrieves a previously stored object from a Registry.

	 * 

	 * @param objid

	 *            The id of the object, as specified when the object was stored

	 *            using

	 *            {@link Validator#addToRegistry(int, Serializable, String)}

	 * @param registryName

	 *            The name of the registry

	 * @return The object

	 * @see Validator#addToRegistry(int, Serializable, String)

	 */

	public Serializable getFromRegistry(int objid, String registryName)

			throws ValidatorException;

	/**

	 * Adds a new registry to the Validator. The registries are used to store

	 * objects the validator needs. Usually they are rules and providers.

	 * 

	 * @param <T>

	 *            The type of objects that the registry will contain.

	 * @param name

	 *            A unique name for the registry.

	 * @see Validator#addToRegistry(int, Serializable, String)

	 */

	public <T extends Serializable> void addRegistry(String name);

	/**

	 * Submit a new validation job to be executed at some time. The submission

	 * must not be blocking. The external application is notified on the

	 * execution progress by registering a listener.

	 * 

	 * @param job

	 * @param workers

	 * @param listener

	 */

	public void submitJob(Job job, int workers, JobListener... listeners)

			throws ValidatorException;

	/**

	 * Submit a new validation job to be executed at some time. The submission

	 * must not be blocking. The external application is notified on the

	 * execution progress by registering a listener.

	 * 

	 * @param job

	 * @param workers

	 * @param listener

	 */

	public void submitJobForCris(Job job,

			Map<String, Set<Rule>> rulesPerEntity,

			Map<String, Set<Rule>> entityChosenRulesMapReferential,

			JobListener... listeners) throws ValidatorException;

	/**

	 * Shuts down the validator. All resources held by the validator are

	 * released. 

	 * 

	 * @throws ValidatorException

	 */

	public void shutdown() throws ValidatorException;

	/**

	 * Starts the validator. This method must be invoked before any other method

	 * is invoked.

	 * @throws ValidatorException

	 */

	public void start() throws ValidatorException;

}

package eu.dnetlib.validator.engine.data;

import eu.dnetlib.validator.engine.ValidatorException;

public class RuleException extends ValidatorException {

	private static final long serialVersionUID = 7060357707549236243L;

	public RuleException() {

		super();

	}

	public RuleException(String msg) {

		super(msg);

	}

}

package eu.dnetlib.validator.engine.data;

import java.io.IOException;

import java.io.ObjectInputStream;

import java.io.Serializable;

import java.util.Properties;

import org.apache.log4j.Logger;

/**

 * An object identified by a unique id and parametrized by Properties.

 * 

 * @author Manos Karvounis

 * @see Rule

 * @see Provider

 */

public class ConfigurableObject implements Serializable {

	protected transient Logger log = Logger.getLogger(ConfigurableObject.class);

	private static final long serialVersionUID = -1573173142135631726L;

	protected Properties pros;

	private int id;

	public ConfigurableObject(Properties pros, int id) {

		super();

//		log.debug("Creating a configurable object with id " + id + " and props " + pros);

		log.debug("Creating a configurable object with id " + id);

		this.pros = pros;

		this.id = id;

	}

	public Properties getConfiguration() {

		return this.pros;

	}

	public int getId() {

		return this.id;

	}

	private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException {

		in.defaultReadObject();

		log = Logger.getLogger(ConfigurableObject.class);

	}

}

package eu.dnetlib.validator.engine.data;

import java.util.ArrayList;

import java.util.List;

import java.util.Properties;

import eu.dnetlib.validator.engine.execution.ValidationObject;

/**

 * A rule is applied on a Validation Object retrieved by a {@link Provider}

 * @author Manos Karvounis

 * @author Nikon Gasparis

 *

 */

public abstract class Rule extends ConfigurableObject {

	private static final long serialVersionUID = 5118099751892948569L;

	private Provider provider;

	private String valObjId;

	private List<String> errors;

	public Rule(Properties pros, int id) {

		super(pros, id);

		setErrors(new ArrayList<String>());

	}

	/**

	 * @param obj

	 * @return True if the rule was successful, otherwise false

	 * @throws RuleException If an exception was raised during the application of the rule.

	 */

	public abstract boolean apply(ValidationObject obj) throws RuleException;

	public Provider getProvider() {

		return provider;

	}

	public void setProvider(Provider provider) {

		this.provider = provider;

	}

	public String getValObjId() {

		return valObjId;

	}

	public void setValObjId(String valObjId) {

		this.valObjId = valObjId;

	}

	public List<String> getErrors() {

		return errors;

	}

	public void setErrors(List<String> errors) {

		this.errors = errors;

	}

}

package eu.dnetlib.validator.engine.data;

import eu.dnetlib.validator.engine.ValidatorException;

public class DataException extends ValidatorException {

	private static final long serialVersionUID = -4341747976225287737L;

	public DataException() {

		super();

	}

	public DataException(String msg) {

		super(msg);

	}

}

package eu.dnetlib.validator.engine.data;

public interface ResultSet<T> {

	/**

	 * The first call on next() must position the cursor to the first object.

	 * @return

	 * @throws DataException

	 */

	public boolean next() throws DataException;

	public T get() throws DataException;

	public String getError();

}

package eu.dnetlib.validator.engine.data;

import java.util.Properties;

import org.apache.log4j.Logger;

import eu.dnetlib.validator.engine.ValidatorException;

import eu.dnetlib.validator.engine.execution.ValidationObject;

/**

 * A Provider is used to retrieve Validation Objects on which rules are applied.

 * Certain rules may only work with certain kinds of providers.

 * 

 * @author manos

 * @see Rule

 */

public abstract class Provider extends ConfigurableObject {

	private static final long serialVersionUID = -5297066032993163543L;

	public Provider(Integer id) {

		super(null, id);

	}

	public void setConfiguration(Properties pros) {

		Logger log = Logger.getLogger(Provider.class);

		log.debug("Setting properties of provider type "+this.getId()+" to "+this.pros);

		this.pros = pros;

	}

	/**

	 * Retrieves the Validation Objects.

	 * 

	 * @return The validation objects.

	 * @throws ProviderException

	 */

	public abstract ResultSet<ValidationObject> getValidationObjects() throws ProviderException;

	/**

	 * Retrieves the Validation Objects given an entity name.

	 * 

	 * @param valObjId

	 * 

	 * @return The validation objects.

	 * @throws ProviderException

	 */

	public abstract ResultSet<ValidationObject> getValidationObjects(String entity) throws ProviderException;

	/**

	 * <p>

	 * Retrieves the ids of the Validation Objects.

	 * </p>

	 * <p>

	 * The Validation Objects themselves might be retrieved by

	 * {@link Provider#getValidationObject(String)}.

	 * </p>

	 * <p>

	 * Not all providers need to support such a method.

	 * </p>

	 * 

	 * @return The ids of the validation objects

	 * @throws ProviderException

	 * @throws UnsupportedOperationException

	 *             If the provider does not support this method.

	 */

	public abstract ResultSet<String> getValidationObjectIds() throws ProviderException, UnsupportedOperationException;

	/**

	 * Retrieves a validation object given its id. Not all providers need to

	 * support such a method.

	 * 

	 * @param valObjId

	 *            The id of the object.

	 * @return The object itself.

	 * @throws ProviderException

	 * @throws UnsupportedOperationException

	 *             UnsupportedOperationException

	 */

	public abstract ValidationObject getValidationObject(String valObjId) throws ProviderException, UnsupportedOperationException;

	public class ProviderException extends ValidatorException {

		private static final long serialVersionUID = 5574587409338211253L;

		public ProviderException() {

			super();

		}

		public ProviderException(String msg) {

			super(msg);

		}

	}

}