Metacat

package edu.ucsb.nceas.metacat.dataone;

/**

 *  '$RCSfile$'

 *    Purpose: A Class for upgrading the database to version 1.5

 *  Copyright: 2000 Regents of the University of California and the

 *             National Center for Ecological Analysis and Synthesis

 *    Authors: Peter Slaughter

 *

 * '$Revision$'

 * This program is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License as published by

 * the Free Software Foundation; either version 2 of the License, or

 * (at your option) any later version.

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

 */

import java.math.BigInteger;

import java.sql.SQLException;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.Date;

import java.util.HashMap;

import java.util.HashSet;

import java.util.List;

import java.util.Map;

import java.util.Set;

import java.util.concurrent.Executors;

import org.apache.log4j.Logger;

import org.dataone.client.CNode;

import org.dataone.client.D1Client;

import org.dataone.service.exceptions.InvalidRequest;

import org.dataone.service.exceptions.InvalidToken;

import org.dataone.service.exceptions.NotAuthorized;

import org.dataone.service.exceptions.NotFound;

import org.dataone.service.exceptions.NotImplemented;

import org.dataone.service.exceptions.ServiceFailure;

import org.dataone.service.exceptions.VersionMismatch;

import org.dataone.service.types.v1.AccessPolicy;

import org.dataone.service.types.v1.Identifier;

import org.dataone.service.types.v1.ObjectFormatIdentifier;

import org.dataone.service.types.v1.ObjectInfo;

import org.dataone.service.types.v1.ObjectList;

import org.dataone.service.types.v1.Permission;

import org.dataone.service.types.v1.Session;

import org.dataone.service.types.v1.Subject;

import org.dataone.service.types.v1.SystemMetadata;

import edu.ucsb.nceas.metacat.AccessionNumberException;

import edu.ucsb.nceas.metacat.IdentifierManager;

import edu.ucsb.nceas.metacat.McdbDocNotFoundException;

import edu.ucsb.nceas.metacat.shared.ServiceException;

import edu.ucsb.nceas.utilities.PropertyNotFoundException;

import edu.ucsb.nceas.utilities.SortedProperties;

public class SyncAccessPolicy {

	private static Logger logMetacat = Logger.getLogger(SyncAccessPolicy.class);

	 * Synchronize access policy (from system metadata) of d1 member node with

	 * the corresponding controlling node.

	 *

	 * @param objList

	 *            list of d1 objects to be synced

	 * @return syncedIds a list of pids that were synced with the CN

	 * @throws ServiceFailure

	 * @throws InvalidToken

	 * @throws NotAuthorized

	 * @throws NotFound

	 * @throws NotImplemented

	 * @throws McdbDocNotFoundException

	 * @throws InvalidRequest

	 * @throws VersionMismatch

	 * @throws SQLException

	 * @throws AccessionNumberException

	 * @throws NumberFormatException

	 */

			McdbDocNotFoundException, InvalidRequest, VersionMismatch,

			Exception {

		AccessPolicy cnAccessPolicy = null;

		AccessPolicy mnAccessPolicy = null;

		Session session = null;

		List<Identifier> syncedIds = new ArrayList<Identifier>();

		SystemMetadata cnSysMeta = null;

		SystemMetadata mnSysMeta = null;

			cn = D1Client.getCN();

					+ cn.getNodeId() + " with info: " + cn.toString());

					.error("Unable to get Coordinating node name for this MN");

			throw new AccessControlException(

					"Unable to get Coordinating node name for this MN");

			objInfo = objList.getObjectInfo(i);

			pid = objInfo.getIdentifier();

					+ i);

				// Get sm, access policy for requested localId

				mnSysMeta = IdentifierManager.getInstance().getSystemMetadata(

						pid.getValue());

			} catch (McdbDocNotFoundException e) {

				logMetacat.error("Error syncing access policy of pid: "

						+ pid.getValue() + " pid not found: " + e.getMessage());

				logMetacat.error("Error syncing access policy of pid: "

				continue;

					.debug("Getting access policy for pid: " + pid.getValue());

			try {

				cnSysMeta = cn.getSystemMetadata(pid);

			} catch (Exception e) {

				logMetacat.error("Error getting system metadata for pid: "

						+ pid.getValue() + " from cn: " + e.getMessage());

					+ pid.getValue());

					+ pid.getValue());

				try {

					BigInteger serialVersion = cnSysMeta.getSerialVersion();

							.debug("Requesting CN to set access policy for pid: "

									+ pid.getValue()

									+ ", serial version: "

									+ serialVersion.toString());

					// Add this pid to the list of pids that were successfully

					// synced

					logMetacat

							.error("Error syncing CN with access policy of pid: "

									+ pid.getValue()

									+ " user not authorized: "

									+ na.getMessage());

					logMetacat

							.error("Error syncing CN with access policy of pid: "

									+ pid.getValue()

									+ " Service failure: "

									+ sf.getMessage());

					logMetacat.debug("Cause: " + sf.getCause());

							.error("Error syncing CN with access policy of pid: "

									+ pid.getValue() + e.getMessage());

				logMetacat.warn("Skipping pid: " + pid.getValue());

					+ pid.getValue());

		return syncedIds;

	}

	/**

	 * Convenience function that accepts a list of guids to sync

	 *

	 * @param guidsToSync

	 *            list of guids to have access policy synced for

	 * @return syncedPids - list of pids that were actually synced with the CN

	 * @throws NumberFormatException

	 * @throws ServiceFailure

	 * @throws InvalidToken

	 * @throws NotAuthorized

	 * @throws NotFound

	 * @throws NotImplemented

	 * @throws McdbDocNotFoundException

	 * @throws InvalidRequest

	 * @throws VersionMismatch

	 * @throws AccessionNumberException

	 * @throws SQLException

	 */

	public List<Identifier> sync(List<String> guidsToSync)

			throws NumberFormatException, ServiceFailure, InvalidToken,

			NotAuthorized, NotFound, NotImplemented, McdbDocNotFoundException,

			InvalidRequest, VersionMismatch, AccessionNumberException,

		ObjectList objList = new ObjectList();

		SystemMetadata sm = new SystemMetadata();

		int start = 0;

		objList.setStart(start);

		// Convert the guids to d1 objects, as this is what

		// IdentifierManager.getInstance().querySystemMetadata returns in

		// syncAll, and

		// what sync(ObjectList...) expects

		for (String guid : guidsToSync) {

			try {

				sm = IdentifierManager.getInstance().getSystemMetadata(guid);

				logMetacat.error("Error syncing access policy of pid: " + guid

				continue;

			ObjectInfo oi = new ObjectInfo();

			Identifier id = new Identifier();

			id.setValue(guid);

			oi.setIdentifier(id);

			oi.setDateSysMetadataModified(sm.getDateSysMetadataModified());

			oi.setChecksum(sm.getChecksum());

			oi.setFormatId(sm.getFormatId());

			oi.setSize(sm.getSize());

			objList.addObjectInfo(oi);

		}

		objList.setCount(count);

		objList.setTotal(total);

		syncedPids = sync(objList);

		return syncedPids;

	}

	 * For all guids for which current MN is authoritative, check that access

	 * policy is synced with CN.

	 *

	 * @return void

	 */

	public void syncAll() throws ServiceFailure, InvalidToken, NotAuthorized,

			NotFound, NotImplemented, McdbDocNotFoundException, InvalidRequest,

			VersionMismatch, NumberFormatException, AccessionNumberException,

			SQLException, PropertyNotFoundException, ServiceException,

			Exception {

		// Create a single thread to run the sync of all guids in

		ExecutorService executor = Executors.newSingleThreadExecutor();

		logMetacat.debug("syncAll starting thread");

		executor.execute(st);

		// Only one task will run on this thread

		executor.shutdown();

	}

	 * Perform syncAll in a single thread.

	 *

	 * @return void

	 */

	private class SyncTask implements Runnable {

		public void run() {

			// For the following query parameters - null indicates that the

			// query

			// will not be

			// constrained by the parameter.

			Date startTime = null;

			Date endTime = null;

			ObjectFormatIdentifier objectFormatId = null;

			Boolean replicaStatus = false; // return only pids for which this mn

											// is

			ObjectList objsToSync = null;

			Integer count = 0;

			Integer start = 0;

			Integer total = 0;

			List<Identifier> tmpIds = null;

			List<Identifier> syncedIds = new ArrayList<Identifier>();

			try {

				count = Integer.valueOf(PropertyService

						.getProperty("database.webResultsetSize"));

			} catch (NumberFormatException e1) {

				logMetacat

						.error("Error in  propery file for format of database.webResultsetSize, will use 1000");

				e1.printStackTrace();

				count = 1000;

			} catch (PropertyNotFoundException e1) {

				logMetacat

						.error("Error reading propery file for database.webResultsetSize, will use 1000");

				e1.printStackTrace();

				count = 1000;

			}

			// Get the total count of guids before we start syncing

			try {

				objsToSync = IdentifierManager.getInstance()

						.querySystemMetadata(startTime, endTime,

								objectFormatId, replicaStatus, start, count);

				logMetacat.debug("syncTask total # of guids: "

						+ objsToSync.getCount());

				logMetacat.error("Error syncing ids");

			}

			// value from the properties file,

			// so in this case use count returned from IdentiferManger for the

			// loop count/increment (loop will only execute once).

			if (objsToSync.getCount() < count)

				count = objsToSync.getCount();

			for (int i = 0; (i + count - 1) < total; i += count) {

					logMetacat.debug("syncTask # requested: " + count

							+ ", start: " + start + ", total: " + total

							+ ", count: " + objsToSync.getCount());

					tmpIds = sync(objsToSync);

					syncedIds.addAll(tmpIds);

					start += objsToSync.getCount();

						break;

							.getInstance()

							.querySystemMetadata(startTime, endTime,

									objectFormatId, replicaStatus, start, count);

				} catch (Exception e) {

					logMetacat.error("Error syncing ids");

					break;

				}

			}

			logMetacat

					.debug("syncTask thread completed. Number of guids synced: "

							+ syncedIds.size());

		}

	/**

	 * Compare two d1 system metadata access policies for equivalence.

	 *

	 * @param ap1

	 *            - first access policy in the comparison

	 * @param ap2

	 *            - second access policy in the comparison

	private boolean isEqual(AccessPolicy ap1, AccessPolicy ap2) {

		// i.e. Subject="slaughter", Permission="read,write,changePermission"

		List<org.dataone.service.types.v1.AccessRule> allowList1 = ap1

				.getAllowList();

		List<org.dataone.service.types.v1.AccessRule> allowList2 = ap2

				.getAllowList();

		HashMap<Subject, Set<Permission>> userPerms1 = new HashMap<Subject, Set<Permission>>();

		HashMap<Subject, Set<Permission>> userPerms2 = new HashMap<Subject, Set<Permission>>();

		// Load the permissions from the access rules into a hash of sets, i.e.,

		// so that we end up with this:

		// user1: read, write

		// user2: read

		// user3: read, write, change permissions

		// With the permissions in this structure, they can be easily compared

		Set<Permission> perms = null;

		// Process first access policy

			for (Subject s : accessRule.getSubjectList()) {

				if (userPerms1.containsKey(s)) {

					perms = userPerms1.get(s);

				} else {

					perms = new HashSet<Permission>();

				}

				for (Permission p : accessRule.getPermissionList()) {

					perms.add(p);

				}

		}

		// Process second access policy

		for (org.dataone.service.types.v1.AccessRule accessRule : allowList2) {

			for (Subject s : accessRule.getSubjectList()) {

				if (userPerms2.containsKey(s)) {

					perms = userPerms2.get(s);

				} else {

					perms = new HashSet<Permission>();

				}

				for (Permission p : accessRule.getPermissionList()) {

					perms.add(p);

				}

		}

		// rule.

			return false;

		// Now perform the comparison of each access rule of access policy 1 to

		// ap 2.

		// This test assumes that the mn perms are more complete than the cn

		// perms.

			// User name

			Subject s1 = entry.getKey();

			// Perms that the user holds

					.debug("Checking access policy of user: " + s1.getValue());

					logMetacat.debug("User access policies not equal");

				}

			} else {

			}

		}

		// All comparisons have been passed, so the two access policies are

		// equivalent

	}

	 * because pids cannot contain whitespace.

	 *

	 * @throws Exception

	 */

		// set up the properties based on the test/deployed configuration of the

		// workspace

				"test/test.properties");

				.getProperty("metacat.contextDir");

		SyncAccessPolicy syncAP = new SyncAccessPolicy();

		if (args.length > 0) {

			try {

						+ args.length + " pids");

						+ synchedPids.size() + " pids");

						"Error syncing pids, message: " + e.getMessage(), e);

			}

		}

	}

}