Metacat

import java.util.ArrayList;

import java.util.List;

import java.util.Vector;

import edu.ucsb.nceas.metacat.client.MetacatAuthException;

import edu.ucsb.nceas.metacat.dataone.CNodeService;

import edu.ucsb.nceas.metacat.dataone.MNodeService;

import edu.ucsb.nceas.metacat.util.DocumentUtil;

	private CNode cn = null;

		metacatConnectionNeeded = true;

		super.setUp();

		/*

		 * Determine the CN for the current host. This test must be run on a

		 * registered MN.

		 */

			cn = D1Client.getCN();

		} catch (ServiceFailure sf) {

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

			fail();

		suite.addTest(new SyncAccessPolicyTest(

				"testSyncEML201OnlineDataAccessPolicy"));

	 * 

		Subject subject = new Subject();

		subject.setValue(anotheruser);

		session.setSubject(subject);

		return session;

	/**

	 * This test checks that access policy of a pid is synced with the CN after

	 * the docid is manually changed using the Metacat api (setaccess).

	 */

		debug("\nStarting sync access policy test");

		debug("Logging in with user: " + anotheruser + ", password: " + anotherpassword);

			debug("Checking for new pid on CN...");

					cnSysMeta = CNodeService.getInstance(request)

							.getSystemMetadata(pid);

					+ pid.getValue() + ", username: " + username

					+ " read, allow, allowFirst");

			m.logout();

			response = m.login(anotheruser, anotherpassword);

			/* Update the docid access policy with Metacat api */

				response = m.setAccess(localId, username,

						AccessControlInterface.READSTRING,

						AccessControlInterface.ALLOW,

						AccessControlInterface.ALLOWFIRST);

			/* Reread SM from MN, CN */

				mnSysMeta = MNodeService.getInstance(request)

						.getSystemMetadata(pid);

				debug("Got SM from MN");

				debug("Error getting system metadata for new pid: "

						+ pid.getValue() + ". Message: " + e.getMessage());

				fail();

			}

			// Get the test document from the CN 

			try {

				cnSysMeta = CNodeService.getInstance(request)

						.getSystemMetadata(pid);

				debug("Got SM from CN");

			} catch (Exception e) {

			/* Check if the access policy was updated on the MN */

			mnAccessPolicy = mnSysMeta.getAccessPolicy();

			found = false;

			List<Subject> subjectList = null;

			List<AccessRule> accessRules = mnAccessPolicy.getAllowList();

			debug("Checking that access policy was added to MN");

//

//			for (AccessRule ar : accessRules) {

//				subjectList = ar.getSubjectList();

//				for (Subject sj : subjectList) {

//					debug("Checking subject: " + sj.getValue());

//					if (sj.getValue().contains(anotheruser)) {

//						debug("user " + anotheruser + " found");

//						found = true;

//					}

//					debug("Foo");

//				}

//			}

//

//			assertTrue(found);

			Boolean apEqual = new Boolean(syncAP.isEqual(mnAccessPolicy,

					cnAccessPolicy));

			debug("Are access policies equal?: " + apEqual.toString());

			deleteDocumentId(localId, SUCCESS, true);

			debug("Error running syncAP test: " + e.getMessage());

			fail();

	/*

	 * This test checks that the access policy of an online data object

	 * (described in EML 2.0.1 <online> section) is properly synced with the CN

	 * when the access policy is changed by modifying the access policy in the

	 * <additionalMetadata> section of the parent document.

	 */

	public void testSyncEML201OnlineDataAccessPolicy() {

		String newdocid = null;

		String onlineDocid;

		String onlinetestdatafile2 = "test/onlineDataFile2";

		SystemMetadata mnSysMeta = null;

		SystemMetadata cnSysMeta = null;

		try {

			debug("\nRunning: testSyncEML201OnlineDataAccessPolicy");

			String emlVersion = EML2_0_1;

			debug("logging in as: username=" + username + " password="

					+ password);

			m.login(username, password);

			/* Create a data object */

			onlineDocid = generateDocumentId();

			uploadDocumentId(onlineDocid + ".1", onlinetestdatafile2, SUCCESS,

					false);

			debug("Inserted new data object with localid: " + onlineDocid

					+ ".1");

			String accessRule1 = generateOneAccessRule("public", true, true,

					false, false, false);

			Vector<String> accessRules = new Vector<String>();

			accessRules.add(accessRule1);

			String accessDoc = getAccessBlock(accessRules, ALLOWFIRST);

			testdocument = getTestEmlDoc("Testing insert", emlVersion,

					testEmlInlineBlock1, null, "ecogrid://knb/" + onlineDocid

							+ ".1", null, accessDoc, null, null, null, null);

			/* Insert the eml document that describes the data object */

			newdocid = generateDocumentId();

			insertDocumentId(newdocid + ".1", testdocument, SUCCESS, false);

			debug("Inserted document with localId: " + newdocid + ".1");

			/*

			 * Determine the D1 pid for the data object so that we can query the

			 * CN for it.

			 */

			String docidWithoutRev = DocumentUtil.getSmartDocId(onlineDocid

					+ ".1");

			int rev = IdentifierManager.getInstance().getLatestRevForLocalId(

					onlineDocid + ".1");

			String guid = IdentifierManager.getInstance().getGUID(

					docidWithoutRev, rev);

			Identifier pid = new Identifier();

			pid.setValue(guid);

			/*

			 * Wait for the cn to harvest metadata for the data object. We are

			 * testing that an update of access rules in the parent eml document

			 * for the enclosed online data object will trigger metacat (via

			 * SyncAccessPolicy) to update the access policy on the CN, so the

			 * data object has to be present on the CN before we continue.

			 */

			debug("Checking for new data object pid " + pid.getValue()

					+ " on CN...");

			boolean found = false;

			int attempts = 0;

			for (int i = 0; i < 6; i++) {

				attempts = i;

				Thread.sleep(1000 * 60);

				// Get sm for data object pid from the CN

				try {

					cnSysMeta = cn.getSystemMetadata(pid);

				} catch (Exception e) {

					debug("Error getting system metadata for pid: "

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

					debug("Will request pid from CN again...");

					continue;

				}

				found = true;

				debug("Data object pid " + pid.getValue()

						+ " has been read from CN.");

				break;

			}

			if (!found) {

				fail("Error, cannot read system metadata for pid: " + pid

						+ " after " + attempts + " attempts");

			}

			// update the document access control for online data

			accessRule1 = generateOneAccessRule("public", true, true, false,

					false, false);

			String accessRule2 = generateOneAccessRule(anotheruser, true, true,

					false, false, false);

			accessRules = new Vector<String>();

			accessRules.add(accessRule1);

			accessRules.add(accessRule2);

			String accessData = getAccessBlock(accessRules, ALLOWFIRST);

			testdocument = getTestEmlDoc("Testing insert", emlVersion,

					testEmlInlineBlock1, null, "ecogrid://knb/" + onlineDocid

							+ ".1", null, accessDoc, null, null, accessData,

					null);

			/*

			 * Updating the parent document should trigger metacat to update the

			 * access policy on the CN (via EML 201 parser and

			 * SyncAccessPolicy).

			 */

			updateDocumentId(newdocid + ".2", testdocument, SUCCESS, false);

			/* Get MN access policy for data object */

			try {

				// Get sm, access policy for requested localId

				mnSysMeta = IdentifierManager.getInstance().getSystemMetadata(

						pid.getValue());

			} catch (Exception e) {

				debug("Error getting system metadata for new pid: "

						+ pid.getValue() + ". Message: " + e.getMessage());

				fail();

			}

			/* Get CN access policy for data object */

			try {

				cnSysMeta = cn.getSystemMetadata(pid);

			} catch (Exception e) {

				debug("Error getting system metadata for pid: "

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

				fail();

			}

			/* Compare MN and CN access policies */

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

			AccessPolicy mnAccessPolicy = mnSysMeta.getAccessPolicy();

			AccessPolicy cnAccessPolicy = cnSysMeta.getAccessPolicy();

			debug("Diffing access policies (MN,CN) for pid: " + pid.getValue());

			SyncAccessPolicy syncAP = new SyncAccessPolicy();

			debug("Comparing access policies...");

			Boolean apEqual = new Boolean(syncAP.isEqual(mnAccessPolicy,

					cnAccessPolicy));

			debug("Are access policies equal?: " + apEqual.toString());

			assert (apEqual == true);

			/* Delete the document */

			deleteDocumentId(newdocid + ".2", SUCCESS, true);

			deleteDocumentId(onlineDocid + ".1", SUCCESS, true);

			// logout

			debug("logging out");

			m.logout();

		} catch (MetacatAuthException mae) {

			fail("Authorization failed:\n" + mae.getMessage());

		} catch (MetacatInaccessibleException mie) {

			fail("Metacat Inaccessible:\n" + mie.getMessage());

		} catch (Exception e) {

			fail("General exception:\n" + e.getMessage());

		}

		debug("Done running testSyncEML201OnlineDataAccessPolicy");

	}