D-Net

package eu.dnetlib.data.mdstore.modular.mongodb;

import java.util.Collections;

import java.util.Date;

import java.util.List;

import java.util.Set;

import org.apache.commons.lang.StringUtils;

import org.apache.commons.logging.Log;

import org.apache.commons.logging.LogFactory;

import org.joda.time.DateTime;

import org.joda.time.Days;

import org.springframework.beans.factory.annotation.Required;

import com.google.common.collect.Lists;

import com.mongodb.BasicDBList;

import com.mongodb.BasicDBObject;

import com.mongodb.DB;

import com.mongodb.DBCollection;

import com.mongodb.DBCursor;

import com.mongodb.DBObject;

import com.mongodb.QueryBuilder;

import com.mongodb.WriteConcern;

import eu.dnetlib.data.mdstore.MDStoreServiceException;

import eu.dnetlib.data.mdstore.modular.connector.MDStore;

import eu.dnetlib.data.mdstore.modular.connector.MDStoreExpiredInfo;

import eu.dnetlib.data.mdstore.modular.connector.MDStoreManagerInfo;

import eu.dnetlib.data.mdstore.modular.connector.MDStoreTransactionInfo;

import eu.dnetlib.data.mdstore.modular.connector.MDStoreTransactionManager;

import eu.dnetlib.data.mdstore.modular.mongodb.utils.MDStoreUtils;

/**

 * The Class MDStoreTransactionManager.

 */

public class MDStoreTransactionManagerImpl implements MDStoreTransactionManager {

	/** The Constant log. */

	private static final Log log = LogFactory.getLog(MDStoreTransactionManagerImpl.class);

	/**

	 * The table name.

	 */

	private static String TABLE_NAME = "metadataManager";

	/** The max number of concurrent transactions per mdstore. */

	private int maxTransactions = 1;

	/**

	 * The db.

	 */

	private DB db;

	/**

	 * The manager table.

	 */

	private DBCollection managerTable;

	/** The expired days. */

	private int expiredDays;

	/**

	 * Bootstrap manager.

	 */

	private void bootstrapManager() {

		log.debug("Bootstrap Manager start");

		final DBCollection metadataColl = db.getCollection("metadata");

		final DBCursor values = metadataColl.find();

		this.setManagerTable(db.getCollection(TABLE_NAME));

		while (values.hasNext()) {

			final DBObject object = values.next();

			final String id = (String) object.get("mdId");

			String newId = null;

			if (id.contains("_")) {

				newId = StringUtils.substringBefore(id, "_");

			}

			final BasicDBObject input = new BasicDBObject();

			input.put("mdId", id);

			input.put("currentId", newId);

			input.put("expiring", new String[] {});

			input.put("transactions", new String[] {});

			getManagerTable().insert(input);

			log.debug(String.format("Added %s to Metadata Manager data structure", id));

		}

		final BasicDBObject ensureIndex = new BasicDBObject();

		ensureIndex.put("mdId", 1);

		log.debug("Create index in MetadaManager ");

		this.getManagerTable().createIndex(ensureIndex);

	}

	/**

	 * Verify consistency.

	 *

	 * @throws MDStoreServiceException

	 *             the MD store service exception

	 */

	@Override

	public void verifyConsistency() throws MDStoreServiceException {

		if (this.getManagerTable() == null) {

			if (!db.collectionExists(TABLE_NAME)) {

				bootstrapManager();

				if (this.getManagerTable() == null) { throw new MDStoreServiceException("Something bad happen, unable to create managerTable"); }

			} else {

				this.setManagerTable(db.getCollection(TABLE_NAME));

			}

		}

	}

	/**

	 * {@inheritDoc}

	 *

	 * @see eu.dnetlib.data.mdstore.modular.connector.MDStoreTransactionManager#createMDStore(java.lang.String)

	 */

	@Override

	public void createMDStore(final String mdId) throws MDStoreServiceException {

		log.debug("Creating new mdstore");

		verifyConsistency();

		String newId = mdId;

		if (mdId.contains("_")) {

			newId = StringUtils.substringBefore(mdId, "_");

		}

		final BasicDBObject instance = new BasicDBObject();

		instance.put("mdId", mdId);

		instance.put("currentId", newId);

		instance.put("expiring", new String[] {});

		getManagerTable().insert(instance);

		this.getManagerTable().save(instance);

	}

	/**

	 * {@inheritDoc}

	 *

	 * @see eu.dnetlib.data.mdstore.modular.connector.MDStoreTransactionManager#dropMDStore(java.lang.String)

	 */

	@Override

	public void dropMDStore(final String mdId) throws MDStoreServiceException {

		verifyConsistency();

		log.debug("Droping MDStore: " + mdId);

		final BasicDBObject query = new BasicDBObject();

		query.put("mdId", mdId);

		final DBCursor cursor = this.getManagerTable().find(query);

		if (cursor.hasNext() == false) { return; }

		final DBObject item = cursor.next();

		garbage();

		final String collectionName = (String) item.get("currentId");

		this.db.getCollection(collectionName).drop();

		this.db.getCollection("discarded-" + collectionName).drop();

		this.getManagerTable().remove(query);

	}

	/**

	 * {@inheritDoc}

	 *

	 * @see eu.dnetlib.data.mdstore.modular.connector.MDStoreTransactionManager#getMDStoreCollection(java.lang.String)

	 */

	@Override

	public String getMDStoreCollection(final String mdId) throws MDStoreServiceException {

		verifyConsistency();

		final BasicDBObject query = new BasicDBObject();

		query.put("mdId", mdId);

		final DBCursor cursor = this.getManagerTable().find(query);

		if (cursor.hasNext() == false) {

			log.error("Error, unable to find Mdstore with Id " + mdId);

			throw new MDStoreServiceException("Error, unable to find Mdstore with Id " + mdId);

		}

		return (String) cursor.next().get("currentId");

	}

	/**

	 * {@inheritDoc}

	 *

	 * @see eu.dnetlib.data.mdstore.modular.connector.MDStoreTransactionManager#startTransaction(java.lang.String, boolean)

	 */

	@Override

	public String startTransaction(final String mdId, final boolean refresh) throws MDStoreServiceException {

		verifyConsistency();

		log.info("Start transaction for metadata store " + mdId);

		final BasicDBObject query = new BasicDBObject();

		query.put("mdId", mdId);

		final DBCursor cursor = this.getManagerTable().find(query);

		if (cursor.hasNext() == false) { throw new MDStoreServiceException("Error, unable to find Mdstore with Id " + mdId); }

		String idCreation = StringUtils.substringBefore(mdId, "_");

		idCreation = idCreation + "::" + System.currentTimeMillis();

		final DBObject object = cursor.next();

		BasicDBList values;

		if (object.containsField("transactions")) {

			values = (BasicDBList) object.get("transactions");

			if (values.size() > getMaxTransactions()) { throw new MDStoreServiceException("Cannot create more than " + getMaxTransactions()

					+ " transactions, found: " + values.size() + ", mdId:" + mdId); }

		} else {

			values = new BasicDBList();

			object.put("transactions", values);

		}

		final BasicDBObject transactionMetadata = new BasicDBObject();

		transactionMetadata.put("id", idCreation.toString());

		transactionMetadata.put("refresh", refresh);

		transactionMetadata.put("date", new Date());

		values.add(transactionMetadata);

		this.getManagerTable().save(object);

		return idCreation.toString();

	}

	/**

	 * {@inheritDoc}

	 *

	 * @see eu.dnetlib.data.mdstore.modular.connector.MDStoreTransactionManager#commit(java.lang.String, java.lang.String,

	 *      eu.dnetlib.data.mdstore.modular.connector.MDStore)

	 */

	@Override

	public boolean commit(final String transactionId, final String mdstoreId, final MDStore current) throws MDStoreServiceException {

		verifyConsistency();

		final BasicDBObject query = new BasicDBObject();

		query.put("mdId", mdstoreId);

		final DBCursor cursor = this.getManagerTable().find(query);

		if (cursor.hasNext() == false) { throw new MDStoreServiceException("Error, unable to find Mdstore with Id " + mdstoreId); }

		final DBObject object = cursor.next();

		final BasicDBList transactions = (BasicDBList) object.get("transactions");

		final DBObject transaction = findTransaction(transactions, transactionId);

		if (transaction == null) { throw new MDStoreServiceException("Error, unable to find transaction with Id " + transactionId); }

		final boolean refresh = (Boolean) transaction.get("refresh");

		transactions.remove(transaction);

		final String oldId = (String) object.get("currentId");

		if (refresh) {

			object.put("currentId", transactionId);

			final BasicDBList stillUsed = (BasicDBList) object.get("expiring");

			if (stillUsed.size() == 0) {

				db.getCollection(oldId).drop();

				db.getCollection("discarded-" + oldId).drop();

			}

			log.debug("Replaced collection ");

		} else {

			log.debug("commit incremental ");

			updateIncremental(transactionId, oldId);

			db.getCollection(transactionId).drop();

			db.getCollection("discarded-" + transactionId).drop();

		}

		this.managerTable.save(object);

		log.info("Committed transaction for metadata store " + mdstoreId);

		return true;

	}

	/**

	 * Find transaction.

	 *

	 * @param transactions

	 *            the transactions

	 * @param transactionId

	 *            the transaction id

	 * @return the DB object

	 */

	private DBObject findTransaction(final BasicDBList transactions, final String transactionId) {

		if (transactions.size() == 0) { return null; }

		for (int i = 0; i < transactions.size(); i++) {

			final BasicDBObject transaction = (BasicDBObject) transactions.get(i);

			final String id = (String) transaction.get("id");

			if (transactionId.equals(id)) { return transaction; }

		}

		return null;

	}

	/**

	 * Gets the db.

	 *

	 * @return the db

	 */

	public DB getDb() {

		return db;

	}

	/**

	 * Sets the db.

	 *

	 * @param db

	 *            the db to set

	 */

	@Required

	public void setDb(final DB db) {

		this.db = db;

	}

	/**

	 * {@inheritDoc}

	 *

	 * @see eu.dnetlib.data.mdstore.modular.connector.MDStoreTransactionManager#readMdStore(java.lang.String)

	 */

	@Override

	public String readMdStore(final String mdStoreId) throws MDStoreServiceException {

		verifyConsistency();

		final BasicDBObject query = new BasicDBObject();

		query.put("mdId", mdStoreId);

		final DBCursor cursor = this.getManagerTable().find(query);

		if (cursor.hasNext() == false) { throw new MDStoreServiceException("Error, unable to find Mdstore with Id " + mdStoreId); }

		final DBObject object = cursor.next();

		final String currentId = (String) object.get("currentId");

		final BasicDBList values = (BasicDBList) object.get("expiring");

		updateMdstoreUsed(values, currentId);

		this.getManagerTable().save(object);

		return currentId;

	}

	/**

	 * Update mdstore used.

	 *

	 * @param values

	 *            the values

	 * @param mdId

	 *            the md id

	 */

	private void updateMdstoreUsed(final BasicDBList values, final String mdId) {

		if (values.size() > 0) {

			for (int i = 0; i < values.size(); i++) {

				final DBObject obj = (DBObject) values.get(i);

				final String id = (String) obj.get("id");

				if (mdId.equals(id)) {

					obj.put("lastRead", new Date());

					return;

				}

			}

		}

		final BasicDBObject readStore = new BasicDBObject();

		readStore.put("id", mdId);

		readStore.put("lastRead", new Date());

		values.add(readStore);

	}

	/**

	 * Gets the manager table.

	 *

	 * @return the managerTable

	 */

	public DBCollection getManagerTable() {

		return managerTable;

	}

	/**

	 * Sets the manager table.

	 *

	 * @param managerTable

	 *            the managerTable to set

	 */

	public void setManagerTable(final DBCollection managerTable) {

		this.managerTable = managerTable;

	}

	/*

	 * (non-Javadoc)

	 *

	 * @see eu.dnetlib.data.mdstore.modular.connector.MDStoreTransactionManager#getInfoForCurrentMdStore(java.lang.String)

	 */

	@Override

	public MDStoreManagerInfo getInfoForCurrentMdStore(final String mdStoreId) throws MDStoreServiceException {

		verifyConsistency();

		final BasicDBObject query = new BasicDBObject();

		query.put("mdId", mdStoreId);

		final DBCursor cursor = this.getManagerTable().find(query);

		if (cursor.hasNext() == false) { throw new MDStoreServiceException("Error, unable to find Mdstore with Id " + mdStoreId); }

		final DBObject object = cursor.next();

		final MDStoreManagerInfo result = new MDStoreManagerInfo();

		result.setCurrentId((String) object.get("currentId"));

		result.setMdId((String) object.get("mdId"));

		final BasicDBList values = (BasicDBList) object.get("expiring");

		for (int i = 0; i < values.size(); i++) {

			final MDStoreExpiredInfo stillused = new MDStoreExpiredInfo();

			final DBObject value = (DBObject) values.get(i);

			stillused.setId((String) value.get("id"));

			stillused.setLastRead((Date) value.get("lastRead"));

			result.addExpiredItem(stillused);

		}

		final BasicDBList transactions = (BasicDBList) object.get("transactions");

		if (transactions != null) {

			for (int i = 0; i < transactions.size(); i++) {

				final MDStoreTransactionInfo transaction = new MDStoreTransactionInfo();

				final DBObject value = (DBObject) transactions.get(i);

				final String transactionId = (String) value.get("id");

				transaction.setId(transactionId);

				transaction.setDate((Date) value.get("date"));

				transaction.setRefresh((Boolean) value.get("refresh"));

				transaction.setSize(db.getCollection(transactionId).count());

				result.addTransactionInfo(transaction);

			}

		}

		return result;

	}

	/*

	 * (non-Javadoc)

	 *

	 * @see eu.dnetlib.data.mdstore.modular.connector.MDStoreTransactionManager#dropUsed(java.lang.String, java.lang.String)

	 */

	@Override

	public Boolean dropUsed(final String mdId, final String idToDrop) throws MDStoreServiceException {

		verifyConsistency();

		final BasicDBObject query = new BasicDBObject();

		query.put("mdId", mdId);

		final DBCursor cursor = this.getManagerTable().find(query);

		if (cursor.hasNext() == false) { throw new MDStoreServiceException("Error, unable to find Mdstore with Id " + mdId); }

		final DBObject object = cursor.next();

		final BasicDBList values = (BasicDBList) object.get("expiring");

		for (int i = 0; i < values.size(); i++) {

			final DBObject value = (DBObject) values.get(i);

			final String currentUsedId = (String) value.get("id");

			if (currentUsedId.equals(idToDrop)) {

				db.getCollection(idToDrop).drop();

				db.getCollection("discarded-" + idToDrop).drop();

				values.remove(value);

				this.managerTable.save(object);

				return true;

			}

		}

		throw new MDStoreServiceException("Error, unable to drop old collection " + idToDrop);

	}

	/*

	 * (non-Javadoc)

	 *

	 * @see eu.dnetlib.data.mdstore.modular.connector.MDStoreTransactionManager#garbage()

	 */

	@Override

	public void garbage() throws MDStoreServiceException {

		verifyConsistency();

		log.info("Start garbage collection of MdStore");

		final DBCursor cursor = this.managerTable.find();

		int totalDeleted = 0;

		while (cursor.hasNext()) {

			final DBObject currentObject = cursor.next();

			if (log.isDebugEnabled()) {

				log.debug("start to check id: " + (String) currentObject.get("currentId"));

			}

			garbageExpiring(currentObject, (String) currentObject.get("currentId"));

			garbageTransactions(currentObject, (String) currentObject.get("currentId"));

			this.managerTable.save(currentObject);

		}

		// DELETING Collection that are not in the metadataManager table

		Set<String> collections = this.db.getCollectionNames();

		for (String collection : collections) {

			if (collection.length() > 30 && collection.contains("discarded-") == false) {

				final DBObject item = getMetadataObjectForCollections(collection);

				if (shouldDelete(collection, item)) {

					if (log.isDebugEnabled()) {

						log.debug("delete collection: " + collection + " from mongo");

					}

					db.getCollection(collection).drop();

					db.getCollection("discarded-" + collection).drop();

					if (log.isDebugEnabled()) {

						log.debug("delete collection: discarded-" + collection + " from mongo");

					}

				}

			}

		}

		log.info("Complete garbage collection of MdStore, total store deleted: " + totalDeleted);

	}

	private DBObject getMetadataObjectForCollections(final String collectionName) {

		if (collectionName == null) { return null; }

		final String postfix = "_TURTdG9yZURTUmVzb3VyY2VzL01EU3RvcmVEU1Jlc291cmNlVHlwZQ==";

		final String tmp = collectionName.contains("discarded-") == true ? StringUtils.substringAfter(collectionName, "discarded-") : collectionName;

		final String collectionNameCleaned = StringUtils.substringBefore(tmp, "::") + postfix;

		DBObject query = QueryBuilder.start("mdId").is(collectionNameCleaned).get();

		return this.managerTable.findOne(query);

	}

	private boolean shouldDelete(final String collectionName, final DBObject metadataManagerInstance) {

		String currentId = (String) metadataManagerInstance.get("currentId");

		if (collectionName.equals(currentId)) { return false; }

		BasicDBList expiringList = (BasicDBList) metadataManagerInstance.get("expiring");

		if (findInList(expiringList, collectionName, "id") == true) { return false; }

		BasicDBList transactionsList = (BasicDBList) metadataManagerInstance.get("transactions");

		if (findInList(transactionsList, collectionName, "id") == true) { return false; }

		return true;

	}

	private boolean findInList(final BasicDBList list, final String object, final String tagname) {

		if (list == null) { return false; }

		for (int i = 0; i < list.size(); i++) {

			DBObject currentObject = (DBObject) list.get(i);

			final String id = (String) currentObject.get(tagname);

			if (id.equals(object)) { return true; }

		}

		return false;

	}

	/**

	 * Delete.

	 *

	 * @param list

	 *            the list

	 * @param toRemove

	 *            the to remove

	 */

	private void delete(final BasicDBList list, final List<DBObject> toRemove) {

		for (final DBObject obj : toRemove) {

			if (log.isDebugEnabled()) {

				log.debug("deleting " + obj);

			}

			list.remove(obj);

		}

	}

	/**

	 * Garbage transactions.

	 *

	 * @param currentObject

	 *            the current object

	 * @param currentId

	 *            the current id

	 */

	private void garbageTransactions(final DBObject currentObject, final String currentId) {

		if (log.isDebugEnabled()) {

			log.debug("Start garbage transactions ");

		}

		final BasicDBList expiring = (BasicDBList) currentObject.get("transactions");

		if (expiring == null || expiring.size() <= getMaxTransactions()) { return; }

		List<DBObject> expiringList = Lists.newArrayList();

		for (int i = 0; i < expiring.size(); i++) {

			final DBObject cobj = (DBObject) expiring.get(i);

			if (cobj != null) {

				expiringList.add((DBObject) expiring.get(i));

			}

		}

		Collections.sort(expiringList, MDStoreUtils.getComparatorOnDate());

		List<DBObject> toRemove = Lists.newArrayList();

		int i = 0;

		// We should remove the k item less recent

		// where k = numberOftotalTransaction - maxNumberOfTransaction

		// k = numberOfItemToRemove

		while (expiringList.size() - toRemove.size() > getMaxTransactions() || i < expiringList.size()) {

			DBObject currentObj = expiringList.get(i++);

			String objectId = (String) currentObj.get("id");

			if (!objectId.equals(currentId)) {

				if (log.isDebugEnabled()) {

					log.debug("delete collection: " + objectId + " from mongo");

				}

				db.getCollection(objectId).drop();

				db.getCollection("discarded-" + objectId).drop();

				if (log.isDebugEnabled()) {

					log.debug("delete collection: discarded-" + objectId + " from mongo");

				}

				toRemove.add(currentObj);

			} else {

				if (log.isDebugEnabled()) {

					log.debug("Cannot remove transaction " + objectId + " because is the currentId: " + currentId);

				}

			}

		}

		delete(expiring, toRemove);

		log.info("Deleted " + toRemove.size() + " transactions, mdStore Id:" + currentObject.get("mdId"));

	}

	/**

	 * Garbage expiring.

	 *

	 * @param currentObject

	 *            the current object

	 * @param currentId

	 *            the current id

	 */

	private void garbageExpiring(final DBObject currentObject, final String currentId) {

		if (log.isDebugEnabled()) {

			log.debug("Start to search expiring mdstores for id: " + currentObject.get("mdId"));

		}

		final BasicDBList expiring = (BasicDBList) currentObject.get("expiring");

		final List<DBObject> toRemove = Lists.newArrayList();

		if (log.isDebugEnabled()) {

			if (expiring == null) {

				log.debug("expiring list is null");

			} else {

				log.debug("expiring list size is :" + expiring.size());

			}

		}

		if (expiring == null || expiring.size() == 0) {

			log.info("Deleted  0  expired  collections, mdStore Id:" + currentObject.get("mdId"));

			return;

		}

		for (int i = 0; i < expiring.size(); i++) {

			final DBObject currentExpiredStore = (DBObject) expiring.get(i);

			final String currentUsedId = (String) currentExpiredStore.get("id");

			final Days d = getExpiringDays(currentExpiredStore, "lastRead");

			if (log.isDebugEnabled()) {

				log.debug("the store :" + currentId + " expired since " + d.getDays() + "days ");

			}

			// DELETE the collection where the last time they was read

			// is more than 3 days ago

			if (d.getDays() > getExpiredDays()) {

				if (currentUsedId.equals(currentId) == false) {

					db.getCollection(currentUsedId).drop();

					db.getCollection("discarded-" + currentUsedId).drop();

					log.debug("deleted collection " + currentUsedId);

				}

				toRemove.add(currentExpiredStore);

			}

		}

		delete(expiring, toRemove);

		log.info("Deleted expired " + toRemove.size() + "collections, mdStore Id:" + currentObject.get("mdId"));

	}

	/**

	 * Gets the expiring days.

	 *

	 * @param value

	 *            the value

	 * @param paramName

	 *            the param name

	 * @return the expiring days

	 */

	private Days getExpiringDays(final DBObject value, final String paramName) {

		final Date lastRead = (Date) value.get(paramName);

		final DateTime last = new DateTime(lastRead);

		final DateTime today = new DateTime();

		final Days d = Days.daysBetween(last, today);

		return d;

	}

	/**

	 * Gets the expired days.

	 *

	 * @return the expiredDays

	 */

	public int getExpiredDays() {

		if (this.expiredDays == 0) { return 3; }

		return expiredDays;

	}

	/**

	 * Sets the expired days.

	 *

	 * @param expiredDays

	 *            the expiredDays to set

	 */

	public void setExpiredDays(final int expiredDays) {

		this.expiredDays = expiredDays;

	}

	/**

	 * Update incremental.

	 *

	 * @param transactionId

	 *            the transaction id

	 * @param currentId

	 *            the current id

	 */

	private void updateIncremental(final String transactionId, final String currentId) {

		final DBCollection transaction = db.getCollection(transactionId);

		final DBCollection mdstore = db.getCollection(currentId);

		final DBCursor cursor = transaction.find();

		if (!cursor.hasNext()) { return; }

		DBObject currentObj = cursor.next();

		while (cursor.hasNext()) {

			BasicDBObject newObj = new BasicDBObject();

			final String id = (String) currentObj.get("id");

			final String body = (String) currentObj.get("body");

			newObj.put("id", id);

			newObj.put("body", body);

			if (id != null && !id.isEmpty()) {

				mdstore.update(new BasicDBObject("id", id), newObj, true, false, WriteConcern.ACKNOWLEDGED);

			}

			currentObj = cursor.next();

		}

		mdstore.getDB().command("{fsync:1}");

	}

	/*

	 * (non-Javadoc)

	 *

	 * @see eu.dnetlib.data.mdstore.modular.connector.MDStoreTransactionManager#dropTransaction(java.lang.String, java.lang.String)

	 */

	@Override

	public Boolean dropTransaction(final String mdId, final String idToDrop) throws MDStoreServiceException {

		verifyConsistency();

		final BasicDBObject query = new BasicDBObject();

		query.put("mdId", mdId);

		final DBCursor cursor = this.getManagerTable().find(query);

		if (cursor.hasNext() == false) { throw new MDStoreServiceException("Error, unable to find Mdstore with Id " + mdId); }

		final DBObject object = cursor.next();

		final BasicDBList values = (BasicDBList) object.get("transactions");

		for (int i = 0; i < values.size(); i++) {

			final DBObject value = (DBObject) values.get(i);

			final String currentUsedId = (String) value.get("id");

			if (currentUsedId.equals(idToDrop)) {

				db.getCollection(idToDrop).drop();

				db.getCollection("discarded-" + idToDrop).drop();

				values.remove(value);

				this.managerTable.save(object);

				return true;

			}

		}

		throw new MDStoreServiceException("Error, unable to drop old collection " + idToDrop);

	}

	/**

	 * Gets the max transactions.

	 *

	 * @return the maxTransactions

	 */

	public int getMaxTransactions() {

		return maxTransactions;

	}

	/**

	 * Sets the max transactions.

	 *

	 * @param maxTransactions

	 *            the maxTransactions to set

	 */

	public void setMaxTransactions(final int maxTransactions) {

		this.maxTransactions = maxTransactions;

	}

}