Metacat

    public String lookupNodeBaseUrl(String nodeId) throws ServiceFailure, NotImplemented {

    	try {

		} catch (Exception e) {

			// TODO Auto-generated catch block

			e.printStackTrace();

      guid.setValue("testGet." + System.currentTimeMillis());

      InputStream object = new ByteArrayInputStream("test".getBytes("UTF-8"));

      SystemMetadata sysmeta = createSystemMetadata(guid, session.getSubject(), object);

      // go back to beginning of original stream

      object.reset();

      // check

      guid.setValue("testGetSystemMetadata." + System.currentTimeMillis());

      InputStream object = new ByteArrayInputStream("test".getBytes("UTF-8"));

      SystemMetadata sysmeta = createSystemMetadata(guid, session.getSubject(), object);

      assertEquals(newsysmeta.getIdentifier().getValue(), sysmeta.getIdentifier().getValue());

    } catch (UnsupportedEncodingException e) {

      guid.setValue("testCreate." + System.currentTimeMillis());

      InputStream object = new ByteArrayInputStream("test".getBytes("UTF-8"));

      SystemMetadata sysmeta = createSystemMetadata(guid, session.getSubject(), object);

      assertEquals(guid.getValue(), pid.getValue());

    } catch (UnsupportedEncodingException e) {

      e.printStackTrace();

      guid.setValue("testDelete." + System.currentTimeMillis());

      InputStream object = new ByteArrayInputStream("test".getBytes("UTF-8"));

      SystemMetadata sysmeta = createSystemMetadata(guid, session.getSubject(), object);

      assertEquals(pid.getValue(), deletedPid.getValue());

    } catch (UnsupportedEncodingException e) {

      Identifier newPid = new Identifier();

      newPid.setValue("testUpdate." + System.currentTimeMillis());

      Identifier pid = 

      SystemMetadata newSysMeta = createSystemMetadata(newPid, session.getSubject(), object);

      // do the update

      Identifier updatedPid = 

      // get the updated system metadata

      SystemMetadata updatedSysMeta = 

      assertEquals(updatedPid.getValue(), newPid.getValue());

//      assertTrue(updatedSysMeta.getObsolete(0).getValue().equals(pid.getValue()));

        InputStream object = new ByteArrayInputStream("test".getBytes("UTF-8"));

        SystemMetadata sysmeta = createSystemMetadata(guid, session.getSubject(), object);

        // save locally

        // get our node reference (attempting to replicate with self)

        // attempt to replicate with ourselves -- this should fail!

      boolean result = false;

      try {

      } catch (Exception inu) {

        // we are expecting this to fail since we already have the doc

        result = true;

      guid.setValue("testGetSystemMetadata." + System.currentTimeMillis());

      InputStream object = new ByteArrayInputStream("test".getBytes("UTF-8"));

      SystemMetadata sysmeta = createSystemMetadata(guid, session.getSubject(), object);

      assertEquals(describeResponse.getDataONE_Checksum().getValue(), sysmeta.getChecksum().getValue());

      assertEquals(describeResponse.getDataONE_ObjectFormatIdentifier(), sysmeta.getFmtid());

      guid.setValue("testGetChecksum." + System.currentTimeMillis());

      InputStream object = new ByteArrayInputStream("test".getBytes("UTF-8"));

      SystemMetadata sysmeta = createSystemMetadata(guid, session.getSubject(), object);

      assertEquals(checksum.getValue(), sysmeta.getChecksum().getValue());

    } catch (UnsupportedEncodingException e) {

        testCreate();

        // now check that we have at least one

        ObjectList objectList = 

              objectFormatId, replicaStatus, start, count);

        assertNotNull(objectList);

        assertTrue(objectList.getCount() == count);

  public void testGetCapabilities() {

      printTestHeader("testGetCapabilities");

    try {

      assertNotNull(node);

      // TODO: should probably test other parts of the node information

    } catch (Exception e) {

        Date startTime = sdf.parse("2010-01-01");

        Date endTime = new Date();

      MonitorList monitorList = 

            session, 

            startTime, 

            endTime, 

  public void testPing() {

    try {

      assertTrue(pingable);

    } catch (NotImplemented e) {

        pid.setValue("testSynchronizationFailed." + System.currentTimeMillis());

        InputStream object = new ByteArrayInputStream("test".getBytes("UTF-8"));

        SystemMetadata sysmeta = createSystemMetadata(pid, session.getSubject(), object);

        assertEquals(retPid.getValue(), pid.getValue());

        // pretend the sync failed

      SynchronizationFailed syncFailed = 

        new SynchronizationFailed("0000", "Testing Synch Failure");

      syncFailed.setPid(pid.getValue());

    } catch (Exception e) {

      e.printStackTrace();

        fail("Unexpected error: " + e.getMessage());

    int count = 1;

    try {

        event, start, count);

      assertNotNull(log);      

      InputStream object = new ByteArrayInputStream("test".getBytes("UTF-8"));

      SystemMetadata sysmeta = createSystemMetadata(guid, session.getSubject(), object);

      Identifier pid = 

      // set the access

      AccessPolicy accessPolicy = new AccessPolicy();

      AccessRule allow = new AccessRule();

      accessPolicy.addAllow(allow);

      accessWasSet = 

      assertTrue(accessWasSet);

      // test that it is enforced

      session.setSubject(publicSubject);

      assertTrue(isAuthorized);

    } catch (UnsupportedEncodingException e) {

      InputStream object = new ByteArrayInputStream("test".getBytes("UTF-8"));

      SystemMetadata sysmeta = createSystemMetadata(guid, session.getSubject(), object);

      Identifier pid = 

      boolean isAuthorized = 

      assertEquals(isAuthorized, true);

    } catch (UnsupportedEncodingException e) {

import java.text.SimpleDateFormat;

import java.util.Date;

import junit.framework.Test;

import junit.framework.TestSuite;

import org.apache.commons.io.IOUtils;

import org.dataone.service.util.Constants;

import org.dataone.service.exceptions.InsufficientResources;

import org.dataone.service.exceptions.InvalidRequest;

			guid.setValue("testRegisterSystemMetadata." + System.currentTimeMillis());

			InputStream object = new ByteArrayInputStream("test".getBytes("UTF-8"));

			SystemMetadata sysmeta = createSystemMetadata(guid, session.getSubject(), object);

			assertEquals(guid.getValue(), retGuid.getValue());

			return retGuid;

        } catch(Exception e) {

			guid.setValue("testGetSystemMetadata." + System.currentTimeMillis());

			InputStream object = new ByteArrayInputStream("test".getBytes("UTF-8"));

			SystemMetadata sysmeta = createSystemMetadata(guid, session.getSubject(), object);

			assertEquals(guid.getValue(), retGuid.getValue());

			// get it

			// check it

			assertEquals(sysmeta.getIdentifier().getValue(), retSysmeta.getIdentifier().getValue());

        } catch(Exception e) {

		    int start = 0;

		    int count = 1;

		    	event, start, count);

		    assertNotNull(log);

		    assertTrue(log.getCount() == count);

			guid.setValue("testCreate." + System.currentTimeMillis());

			InputStream object = new ByteArrayInputStream("test".getBytes("UTF-8"));

			SystemMetadata sysmeta = createSystemMetadata(guid, session.getSubject(), object);

			assertEquals(guid, pid);

        } catch(Exception e) {

        	e.printStackTrace();

			guid.setValue("testGet." + System.currentTimeMillis());

			InputStream object = new ByteArrayInputStream("test".getBytes("UTF-8"));

			SystemMetadata sysmeta = createSystemMetadata(guid, session.getSubject(), object);

			assertEquals(guid.getValue(), pid.getValue());

			// get it

			// check it

			object.reset();

			assertTrue(IOUtils.contentEquals(object, retObject));

			describePid.setValue("describePid." + System.currentTimeMillis());

			sysmeta.setObsoletes(describePid);

			// save it

			assertEquals(guid.getValue(), retGuid.getValue());

			// save the other

			InputStream object2 = new ByteArrayInputStream("test".getBytes("UTF-8"));

			SystemMetadata describeSysmeta = createSystemMetadata(describePid, session.getSubject(), object2);

			assertEquals(describePid.getValue(), retDescribePid.getValue());

			// check it

			assertTrue(result);

        } catch(Exception e) {

        	e.printStackTrace();

			InputStream object = new ByteArrayInputStream("test".getBytes("UTF-8"));

			SystemMetadata sysmeta = createSystemMetadata(guid, session.getSubject(), object);

			// save it

			assertEquals(guid.getValue(), retGuid.getValue());

			// check it

			assertEquals(sysmeta.getChecksum().getValue(), checksum.getValue());

        } catch(Exception e) {

            fail("Unexpected error: " + e.getMessage());

	    printTestHeader("testListNodes");

	    try {

        } catch(NotImplemented e) {

        	// expecting not implemented

            assertTrue(true);

			Identifier guid = new Identifier();

			guid.setValue("testReserveIdentifier." + System.currentTimeMillis());

			// reserve it

			assertTrue(result);

	    } catch(NotImplemented ni) {

        	// this is not implemented in Metacat

			SystemMetadata sysmeta = createSystemMetadata(guid, session.getSubject(), object);

			// save it

			assertEquals(guid.getValue(), retGuid.getValue());

			// search for it

			// check it

			assertNotNull(objectList);

			boolean result = false;

			InputStream object = new ByteArrayInputStream("test".getBytes("UTF-8"));

			SystemMetadata sysmeta = createSystemMetadata(guid, session.getSubject(), object);

			// save it

			assertEquals(guid.getValue(), retGuid.getValue());

			Subject rightsHolder = new Subject();

			rightsHolder.setValue("newUser");

			// set it

			assertEquals(guid, retPid);

			// get it

			assertNotNull(sysmeta);

			// check it

			assertEquals(rightsHolder.getValue(), sysmeta.getRightsHolder().getValue());

			InputStream object = new ByteArrayInputStream("test".getBytes("UTF-8"));

			SystemMetadata sysmeta = createSystemMetadata(guid, session.getSubject(), object);

			// save it

			assertEquals(guid.getValue(), retGuid.getValue());

			AccessPolicy accessPolicy = new AccessPolicy();

			AccessRule accessRule = new AccessRule();

			accessRule.addSubject(publicSubject);

			accessPolicy.addAllow(accessRule);

			// set it

			assertTrue(result);

			// check it

			assertTrue(result);

        } catch(Exception e) {

            fail("Unexpected error: " + e.getMessage());

			InputStream object = new ByteArrayInputStream("test".getBytes("UTF-8"));

			SystemMetadata sysmeta = createSystemMetadata(guid, session.getSubject(), object);

			// save it

			assertEquals(guid.getValue(), retGuid.getValue());

			// check it

			Subject publicSubject = new Subject();

			publicSubject.setValue(Constants.SUBJECT_PUBLIC);

			session.setSubject(publicSubject);

			// public read

			assertTrue(result);

			// not public write

			try {

				result = false;

				fail("Public WRITE should be denied");

			} catch (NotAuthorized nae) {

				result = true;

			InputStream object = new ByteArrayInputStream("test".getBytes("UTF-8"));

			SystemMetadata sysmeta = createSystemMetadata(guid, session.getSubject(), object);

			// save it

			assertEquals(guid.getValue(), retGuid.getValue());

			ReplicationPolicy policy = new ReplicationPolicy();

			node.setValue("testNode");

			policy.addPreferredMemberNode(node );

			// set it

			assertTrue(result);

			// get it

			assertNotNull(sysmeta);

			// check it

			assertEquals(policy.getPreferredMemberNode(0).getValue(), sysmeta.getReplicationPolicy().getPreferredMemberNode(0).getValue());

			replica.setReplicaVerified(new Date());

			sysmeta.addReplica(replica );

			// save it

			assertEquals(guid.getValue(), retGuid.getValue());

			// set it

			ReplicationStatus status = ReplicationStatus.COMPLETED;

			assertTrue(result);

			// get it

			assertNotNull(sysmeta);

			// check it

			assertEquals(status, sysmeta.getReplica(0).getReplicationStatus());

  	ObjectFormatList objectFormatList;

  	try {

	  	assertTrue(objectFormatList.getTotal() >= formatsCount);

  	} catch (InvalidRequest e) {

    try {

			String result = 

	  	System.out.println("Expected result: " + knownFormat);

	  	System.out.println("Found    result: " + result);

	  	assertTrue(result.equals(knownFormat));

  	try {

	    ObjectFormat objectFormat = 

  	} catch (Exception e) {

import java.security.NoSuchAlgorithmException;

import java.util.Date;

import org.dataone.client.ObjectFormatCache;

import org.dataone.service.util.Constants;

import org.dataone.service.util.TypeMarshaller;

 */

public class D1NodeServiceTest extends MCTestCase {   

    * constructor for the test

    */

    public D1NodeServiceTest(String name) {

        super(name);

    }

    /**

import java.io.ByteArrayInputStream;

import java.io.InputStream;

import junit.framework.Test;

import junit.framework.TestSuite;

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

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

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

		}

	}

    /**

    * constructor for the test

    */

    public HazelcastServiceTest(String name) {

        super(name);

    }

    /**

			systemMetadataMap.put(guid, sysmeta);

			// get it from the store

			assertNotNull(sysmetaFromStore);

		} catch (Exception e) {

     */

    public void testLog()

    {

        assertTrue(1 == 1);

    }

CREATE TABLE access_log (

  entryid       NUMBER(20),     -- the identifier for the log event

  ip_address    VARCHAR2(512),  -- the ip address inititiating the event

  principal     VARCHAR2(512),  -- the user initiiating the event

  docid         VARCHAR2(250),	-- the document id #

  event         VARCHAR2(512),  -- the code symbolizing the event type

*/

ALTER TABLE xml_access ADD COLUMN guid text;

/*

 * Register the DataONE schemas

 */

CREATE TABLE access_log (

  entryid       INT8 default nextval ('access_log_id_seq'), -- the identifier for the log event

  ip_address    VARCHAR(512),   -- the ip address inititiating the event

  docid         VARCHAR(250),	-- the document id #

  event         VARCHAR(512),   -- the code symbolizing the event type

  date_logged   TIMESTAMP,      -- the datetime on which the event occurred

*/

ALTER TABLE xml_access ADD COLUMN guid VARCHAR2(2000);

/*

 * add the nodedatadate column to xml_nodes 

 * TODO: load the data into it (java?)

ALTER TABLE xml_path_index ADD COLUMN nodedatadate TIMESTAMP;

CREATE INDEX xml_path_index_idx4 ON xml_path_index (nodedatadate);

/*

 * Register the DataONE schemas

 */

 */

public class EventLogData {

	private String ipAddress;

	private String principal;

	private String docid;

	private String event;

	 * @param revision the revision of the document to which the event applies

	 * @param event the string code for the event

	 */

		this.ipAddress = ipAddress;

		this.principal = principal;

		this.docid = docid;

	public void setPrincipal(String principal) {

		this.principal = principal;

	}

}

		} catch (Exception e) {

			logMetacat.warn("No permission specified");

		}

		response.setStatus(200);

		response.setContentType("text/xml");

		return result;

			throw new ServiceFailure("2161", e.getMessage());

		}

    }

        if (pathInfo.toLowerCase().equals("ping")) {

            logMetacat.debug("processing ping request");

            return result;

        } else if (pathInfo.toLowerCase().equals("status")) {

                event = Event.convert(eventName);

            }

            OutputStream out = response.getOutputStream();

            response.setStatus(200);

        }

        logMetacat.debug("getting checksum for object " + pid + " with algorithm " + checksumAlgorithm);

        logMetacat.debug("got checksum " + c.getValue());

        response.setStatus(200);

        logMetacat.debug("serializing response");

        logMetacat.debug("sourceNode: " + sn);

        NodeReference sourceNode = TypeMarshaller.unmarshalTypeFromStream(NodeReference.class, new ByteArrayInputStream(sn.getBytes("UTF-8")));

        response.setStatus(200);

    private void node() 

        throws JiBXException, IOException, NotImplemented, NotAuthorized, ServiceFailure, InvalidRequest {

        response.setContentType("text/xml");

        response.setStatus(200);

        Identifier id = new Identifier();

        id.setValue(pid);

        //response.addHeader("pid", pid);

        response.addHeader("DataONE-Checksum", dr.getDataONE_Checksum().getAlgorithm() + "," + dr.getDataONE_Checksum().getValue());

        response.addHeader("Content-Length", dr.getContent_Length() + "");

		}

        logMetacat.debug("calling getLogRecords");

        OutputStream out = response.getOutputStream();

        response.setStatus(200);

            Identifier id = new Identifier();

            id.setValue(pid);

            //set the content type

            if (sm.getFmtid().getValue().trim().equals(

                response.setHeader("Content-Disposition", "inline; filename=" + id.getValue() + ".xml");

            }

            out = response.getOutputStream();  

            IOUtils.copyLarge(data, out);

            }

            ObjectList ol = 

               fmtid, replicaStatus, start, count);

            out = response.getOutputStream();  

        Identifier id = new Identifier();

        id.setValue(pid);

        response.setContentType("text/xml");

        response.setStatus(200);

            Identifier id = new Identifier();

            id.setValue(pid);

            logMetacat.debug("creating object with pid " + pid);

            TypeMarshaller.marshalTypeToOutputStream(rId, out);

        } else if (action.equals(FUNCTION_NAME_UPDATE)) {

            // get the systemmetadata object

            SystemMetadata smd = TypeMarshaller.unmarshalTypeFromStream(SystemMetadata.class, sysmeta);

            TypeMarshaller.marshalTypeToOutputStream(rId, out);

        } else {

            throw new InvalidRequest("1000", "Operation must be create or update.");

        id.setValue(pid);

        logMetacat.debug("Calling delete");

        TypeMarshaller.marshalTypeToOutputStream(id, out);

    }    

        id.setValue(pid);

        AccessPolicy accessPolicy = collectAccessPolicy();

    }

    	Identifier guidid = new Identifier();

        guidid.setValue(guid);

        logMetacat.debug("getting checksum for object " + guid);

        logMetacat.debug("got checksum " + c.getValue());

        response.setStatus(200);

        logMetacat.debug("serializing response");

		}

        logMetacat.debug("calling getLogRecords");

        OutputStream out = response.getOutputStream();

        response.setStatus(200);

        Identifier id = new Identifier();

        id.setValue(guid);

        //set the content type

        if(sm.getFmtid().getValue().trim().equals(

            response.setHeader("Content-Disposition", "inline; filename=" + id.getValue() + ".xml");

        }

        OutputStream out = response.getOutputStream();

        response.setStatus(200);

        Identifier id = new Identifier();

        id.setValue(guid);

        response.setContentType("text/xml");

        response.setStatus(200);

            Identifier id = new Identifier();

            id.setValue(pid);

            logMetacat.debug("creating object with pid " + id.getValue());

            OutputStream out = response.getOutputStream();

            response.setStatus(200);

	private void listFormats() throws InvalidRequest, ServiceFailure, NotFound, InsufficientResources, NotImplemented, IOException, JiBXException {

      logMetacat.debug("Entering listFormats()");

      // get the response output stream

      OutputStream out = response.getOutputStream();

      response.setStatus(200);

      fmtid.setValue(fmtidStr);

	  // get the specified object format

      OutputStream out = response.getOutputStream();

      response.setStatus(200);

			logMetacat.warn("pid not specified");

		} 

		// call the implementation

		OutputStream out = response.getOutputStream();

		response.setStatus(200);

		response.setContentType("text/xml");

    private void resolve(String id) throws InvalidRequest, InvalidToken, ServiceFailure, NotAuthorized, NotFound, NotImplemented, IOException, JiBXException {

		Identifier pid = new Identifier();

		pid.setValue(id);

	    OutputStream out = response.getOutputStream();

		response.setStatus(200);

		response.setContentType("text/xml");

		} catch (Exception e) {

			logMetacat.warn("pidOfObject not specified");

		}

		response.setStatus(200);

		response.setContentType("text/xml");

		return result;

		pid.setValue(id);

		String subjectStr = params.get("subject")[0];

		Subject subject = TypeMarshaller.unmarshalTypeFromStream(Subject.class, new ByteArrayInputStream(subjectStr.getBytes("UTF-8")));

		OutputStream out = response.getOutputStream();

		response.setStatus(200);

		response.setContentType("text/xml");

		Identifier pid = new Identifier();

		pid.setValue(id);

		String permission = params.get("action")[0];

		response.setStatus(200);

		response.setContentType("text/xml");

		return result;

		Identifier guid = new Identifier();

		guid.setValue(pid);

		logMetacat.debug("registering system metadata with pid " + guid.getValue());

		response.setStatus(200);

		response.setContentType("text/xml");

        id.setValue(pid);

        AccessPolicy accessPolicy = collectAccessPolicy();

    }

		}

    	// expecting to throw NotImplemented

    }

}

			} else if (action.equals("insert") || action.equals("update")) {

				PrintWriter out = response.getWriter();

				if ((userName != null) && !userName.equals("public")) {

							groupNames);

				} else {

					response.setContentType("text/xml");

     * that initiated the event.

     * 

     * @param ipAddress the internet protocol address for the event

	 * @param principal the principal for the event (a username, etc)

	 * @param docid the identifier of the document to which the event applies

	 * @param event the string code for the event

     */

        insertLogEntry(logData);

    }

    private void insertLogEntry(EventLogData logData)

    {

        String insertString = "insert into access_log"

                + "event, date_logged) "

                + "values ("

                + "'" + logData.getIpAddress() + "', " 

                + "'" + logData.getPrincipal() + "', "

                + "'" + logData.getDocid() + "', "

                + "'" + logData.getEvent() + "', "

    {

        StringBuffer resultDoc = new StringBuffer();

        StringBuffer query = new StringBuffer();

            + "event, date_logged from access_log");

//                        + ""

//                        + "event, date_logged) " + "values (" + "'"

                		generateXmlRecord(

                				rs.getString(1), //id

                				anonymous ? "" : rs.getString(2), //ip

                                rs.getString(5), 

            }

            resultDoc.append("</log>");

            stmt.close();

     * 

     * @param entryId the identifier of the log entry

     * @param ipAddress the internet protocol address for the event

	 * @param principal the principal for the event (a username, etc)

	 * @param docid the identifier of the document to which the event applies

	 * @param event the string code for the event

     * @param dateLogged the date on which the event occurred

     * @return String containing the formatted XML

     */

            String principal, String docid, String event, Timestamp dateLogged)

    {

        StringBuffer rec = new StringBuffer();

        rec.append("<logEntry>");

        rec.append(generateXmlElement("entryid", entryId));

        rec.append(generateXmlElement("ipAddress", ipAddress));

        rec.append(generateXmlElement("principal", principal));

        rec.append(generateXmlElement("docid", docid));

        rec.append(generateXmlElement("event", event));

            }

            out.close();

                    inlineDataId, "readinlinedata");

        } catch (Exception e) {

            try {

                        if (zip) {

                            addDocToZip(request, docid, providedFileName, zout, user, groups);

                        } else {

                                    user, groups, withInlineData, params);

                        }

                    	if (out == null) {

                    		out = response.getOutputStream();

                    	}

                                user, groups, withInlineData, params);

                    }

                }

      try {

        DocumentImpl.delete(docid, user, groups, null); // null: don't notify server

                user, docid, "delete");

        response.setContentType("text/xml");

        out.println(this.PROLOG);

    }

    /** read metadata or data from Metacat

     * @throws PropertyNotFoundException 

     * @throws ParseLSIDException 

     * @throws InsufficientKarmaException 

     */

            HttpServletResponse response, OutputStream out, String docid, String qformat,

            String user, String[] groups, boolean withInlineData, 

            Hashtable<String, String[]> params) throws ClassNotFoundException, 

                }

            }

        } catch (PropertyNotFoundException except) {

            throw except;

        }

                    zout.write(bytestring, 0, bytestring.length);

                    zout.closeEntry();

                }

                        docid, "read");

            } catch (Exception except) {

                throw except;

    /**

     * Handle the database putdocument request and write an XML document to the

     * database connection

     */

            HttpServletResponse response, PrintWriter out, Hashtable<String, String[]> params,

            String user, String[] groups) {

        Logger logMetacat = Logger.getLogger(MetacatHandler.class);

                		          "writing with null acnumber");

                  newdocid = documentWrapper.write(dbConn, doctext[0], pub, dtd,

                          doAction, null, user, groups);

              } else {

                  newdocid = documentWrapper.write(dbConn, doctext[0], pub, dtd,

                          doAction, accNumber, user, groups);

              }

                doctextArr[0] = doctext;

                params.put("doctext", doctextArr);

                //call the insert routine

                          params, username, groupnames);

              }

              catch(Exception e)

                            throw ee;

                        }

                                username, docid, "upload");

                        // Force replication this data file

                        // To data file, "insert" and update is same

import java.util.List;

import java.util.Timer;

import org.apache.commons.io.IOUtils;

import org.apache.log4j.Logger;

import org.dataone.client.CNode;

import edu.ucsb.nceas.metacat.database.DBConnection;

import edu.ucsb.nceas.metacat.database.DBConnectionPool;

import edu.ucsb.nceas.metacat.properties.PropertyService;

import edu.ucsb.nceas.utilities.PropertyNotFoundException;

/**

 */

public class MNodeService extends D1NodeService implements MNAuthorization, MNCore, MNRead, MNReplication, MNStorage {

    /* the logger instance */

    private Logger logMetacat = null;

     * 

     * @return instance - the instance of MNodeService

     */

    }

    /**

     * Constructor, private for singleton access

     */

        logMetacat = Logger.getLogger(MNodeService.class);

    }

            try {

                // delete the document

                DocumentImpl.delete(localId, username, groupnames, null);

            } catch (McdbDocNotFoundException e) {

                throw new InvalidRequest("1322", "The provided identifier was invalid.");

            insertSystemMetadata(sysmeta);

            // log the update event

        } else {

            throw new NotAuthorized("1200", "The provided identity does not have " + "permission to UPDATE the object identified by " + pid.getValue()

            // Set the properties of the node based on configuration information and

            // calls to current status methods

            Node node = new Node();

            node.setDescription(nodeDesc);

            // set the node's health information

        	principal = session.getSubject().getValue();

        }

        try {

        } catch (Exception e) {

            throw new ServiceFailure("2161", "Could not log the error for: " + syncFailed.getPid());

		}

        if (session.getSubject() != null) {

            principal = session.getSubject().getValue();

        }

        return inputStream;

    }

import java.util.List;

import java.util.Set;

import org.apache.log4j.Logger;

import org.dataone.client.CNode;

import org.dataone.client.D1Client;

public class CNodeService extends D1NodeService implements CNAuthorization,

    CNCore, CNRead, CNReplication {

  /* the logger instance */

  private Logger logMetacat = null;

  /**

   * singleton accessor

   */

  }

  /**

   * Constructor, private for singleton access

   */

    logMetacat = Logger.getLogger(CNodeService.class);

  }

        }

        logMetacat.debug("Returning from registerSystemMetadata");

        return guid;

  }

    	}

        logMetacat.debug("Returning from updateSystemMetadata");

        return true;

  }

import java.util.Timer;

import java.util.Vector;

import org.apache.commons.io.IOUtils;

import org.apache.log4j.Logger;

import org.dataone.client.ObjectFormatCache;

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

  /* reference to the metacat handler */

  protected MetacatHandler handler;

   * 

   * @param metacatUrl - the URL of the metacat service, including the ending /d1

   */

  /**

   * Adds a new object to the Node, where the object is either a data 

      String entryId = getLogEntryField("entryid", entry);

      String ipAddress = getLogEntryField("ipAddress", entry);

      String principal = getLogEntryField("principal", entry);

      String docid = getLogEntryField("docid", entry);

      String eventS = getLogEntryField("event", entry);

      String dateLogged = getLogEntryField("dateLogged", entry);

      Subject princ = new Subject();

      princ.setValue(principal);

      le.setSubject(princ);

      // event filtering?

      if (event == null) {

    if (session != null && session.getSubject() != null) {

    	principal = session.getSubject().getValue();

    }

    return inputStream;

  }

    // do the insert or update action

    handler = new MetacatHandler(new Timer());

                        null, params, username, groupnames);

    if(result.indexOf("<error>") != -1) {

          }
   
           logMetacat.debug("Logging the creation event.");
-          EventLog.getInstance().log(metacatUrl, username, localId, "create");
+          EventLog.getInstance().log(request.getRemoteAddr(), request.getHeader("User-Agent"), username, localId, "create");
   
           // Schedule replication for this data file
           logMetacat.debug("Scheduling replication.");
Index: src/edu/ucsb/nceas/metacat/admin/PropertiesAdmin.java

        CNode cn;

        try {

            logMetacat.debug("Get the Node description.");

            logMetacat.debug("Setting client certificate location.");

            String certificatePath = PropertyService.getProperty("dataone.certpath");

            if (!certificatePath.endsWith(File.separator)) {

          REVINSERTNUMBER++;

      }

      String ip = getIpFromURL(u);

    }//try

            REVINSERTNUMBER++;

        }

        String ip = getIpFromURL(u);

      }//if

      else

         logReplication.info("ReplicationHandler.handleDeleteSingleDocument - Doc " + docId + " deleted");

         URL u = new URL("https://"+notifyServer);

         String ip = getIpFromURL(u);

      }

    }//try

							+ guid);

			String ip = getIpFromURL(sysMetaUrl);

		} catch (Exception e) {

			logMetacat.error("ReplicationHandler.handleSystemMetadata - "