Metacat

   * @throws NotImplemented

   * @throws InvalidRequest

   */

  public Identifier delete(Session session, Identifier pid) 

    throws InvalidToken, ServiceFailure, NotAuthorized, NotFound, 

    NotImplemented, InvalidRequest {

   * @throws InvalidSystemMetadata

   * @throws InvalidRequest

   */

  public Identifier update(Session session, Identifier pid, InputStream object,

    Identifier newPid, SystemMetadata sysmeta) 

    throws InvalidToken, ServiceFailure, NotAuthorized, IdentifierNotUnique, 

   * @throws InsufficientResources

   * @throws InvalidRequest

   */

  public boolean replicate(Session session, SystemMetadata sysmeta, 

    NodeReference sourceNode)

    throws NotImplemented, ServiceFailure, NotAuthorized, InvalidRequest,

   * @throws NotImplemented

   * @throws InvalidRequest

   */

  public DescribeResponse describe(Session session, Identifier pid)

    throws InvalidToken, ServiceFailure, NotAuthorized, NotFound,

    NotImplemented, InvalidRequest {

   * @throws InvalidRequest

   * @throws NotImplemented

   */

  public Checksum getChecksum(Session session, Identifier pid, String algorithm)

    throws InvalidToken, ServiceFailure, NotAuthorized, NotFound,

    InvalidRequest, NotImplemented {

   * @throws InvalidRequest

   * @throws NotImplemented

   */

  public ObjectList listObjects(Session session, Date startTime, Date endTime,

    ObjectFormatIdentifier objectFormatId, Boolean replicaStatus, Integer start, Integer count)

    throws NotAuthorized, InvalidRequest, NotImplemented, ServiceFailure,

   * @throws InvalidRequest

   * @throws NotImplemented

   */

  public Node getCapabilities() throws NotImplemented, NotAuthorized,

      ServiceFailure, InvalidRequest {

   * @throws InvalidRequest

   * @throws NotImplemented

   */

  public MonitorList getOperationStatistics(Session session, Date startTime,

  		Date endTime, Subject requestor, Event event, ObjectFormatIdentifier formatId) 

    throws NotImplemented, ServiceFailure, NotAuthorized, InvalidRequest, 

   * @throws InvalidRequest

   * @throws NotImplemented

   */

  public boolean ping() 

    throws NotImplemented, ServiceFailure, NotAuthorized, InvalidRequest, 

    InsufficientResources, UnsupportedType {

   * @throws InvalidRequest

   * @throws NotImplemented

   */

  public void synchronizationFailed(Session session, SynchronizationFailed syncFailed)

      throws NotImplemented, ServiceFailure, NotAuthorized, InvalidRequest {

  }

  /**

   */

  public InputStream getReplica(Session session, Identifier pid)

    throws InvalidRequest, InvalidToken, NotAuthorized, NotImplemented,

    ServiceFailure, NotFound {

   * @throws InvalidRequest

   * 

   */

  public boolean setReplicationPolicy(Session session, Identifier pid,

    ReplicationPolicy policy) 

    throws NotImplemented, NotFound, NotAuthorized, ServiceFailure, InvalidRequest, InvalidToken {

   * @throws NotFound

   * 

   */

  public boolean setReplicationStatus(Session session, Identifier pid,

    NodeReference targetNode, ReplicationStatus status) 

    throws ServiceFailure, NotImplemented, InvalidToken, NotAuthorized, 

   * @throws InvalidRequest

   * @throws NotImplemented

   */

  public boolean assertRelation(Session session, Identifier pidOfSubject, 

    String relationship, Identifier pidOfObject) 

    throws InvalidToken, ServiceFailure, NotAuthorized, NotFound, 

   * @throws InvalidRequest

   * @throws NotImplemented

   */

  public Checksum getChecksum(Session session, Identifier pid)

    throws InvalidToken, ServiceFailure, NotAuthorized, NotFound, 

    InvalidRequest, NotImplemented {

   * @throws NotFound

   * @throws NotImplemented

   */

  public ObjectLocationList resolve(Session session, Identifier pid)

    throws InvalidRequest, InvalidToken, ServiceFailure, NotAuthorized,

    NotFound, NotImplemented {

   * @throws InvalidRequest

   * @throws NotImplemented

   */

  public ObjectList search(Session session, String queryType, String query)

    throws InvalidToken, ServiceFailure, NotAuthorized, InvalidRequest,

    NotImplemented {

   * @throws InsufficientResources

   * @throws NotImplemented

   */

  public ObjectFormat getFormat(ObjectFormatIdentifier fmtid)

    throws InvalidRequest, ServiceFailure, NotFound, InsufficientResources,

    NotImplemented {

   * @throws NotFound

   * @throws InsufficientResources

   */

  public ObjectFormatList listFormats() 

    throws InvalidRequest, ServiceFailure, NotFound, InsufficientResources, 

    NotImplemented {

   * @throws ServiceFailure

   * @throws NotImplemented

   */

  public NodeList listNodes() 

    throws NotImplemented, ServiceFailure {

   * @throws InvalidRequest

   * @throws InvalidSystemMetadata

   */

  public Identifier registerSystemMetadata(Session session, Identifier guid,

    SystemMetadata sysmeta) 

    throws NotImplemented, NotAuthorized, ServiceFailure, InvalidRequest, 

   * @throws InvalidSystemMetadata

   * @throws NotFound

   */

  public boolean updateSystemMetadata(Session session, Identifier guid,

    SystemMetadata sysmeta) 

    throws NotImplemented, NotAuthorized, ServiceFailure, InvalidRequest, 

   * @throws IdentifierNotUnique

   * @throws NotImplemented

   */

  public boolean reserveIdentifier(Session session, Identifier pid)

  throws InvalidToken, ServiceFailure,

        NotAuthorized, IdentifierNotUnique, NotImplemented, InvalidRequest {

    throw new NotImplemented("4191", "reserveIdentifier not implemented on this node");

  }

  public Identifier generateIdentifier(Session session, String scheme, String fragment)

  throws InvalidToken, ServiceFailure,

        NotAuthorized, NotImplemented, InvalidRequest {

   * @throws NotImplemented

   */

  public boolean hasReservation(Session session, Identifier pid) 

      throws InvalidToken, ServiceFailure, NotFound, NotAuthorized, IdentifierNotUnique, 

      NotImplemented, InvalidRequest {

   * @throws NotImplemented

   * @throws InvalidRequest

   */  

  public Identifier setOwner(Session session, Identifier pid, Subject userId)

    throws InvalidToken, ServiceFailure, NotFound, NotAuthorized,

    NotImplemented, InvalidRequest {

   * @throws InvalidRequest

   * @throws NotFound

   */

  public boolean isNodeAuthorized(Session originatingNodeSession, 

    Subject targetNodeSubject, Identifier pid, Permission replicatePermission) 

    throws NotImplemented, NotAuthorized, InvalidToken, ServiceFailure, 

  /**

   * Listen for new Hazelcast member events

   */

  public void instanceCreated(InstanceEvent event) {

    logMetacat.info("New Hazelcast instance created: " +

      event.getInstance().getId() + ", " +

  }

  public void instanceDestroyed(InstanceEvent event) {

    logMetacat.info("Hazelcast instance removed: " +

        event.getInstance().getId() + ", " +

  /**

   * Refresh the Hazelcast service by restarting it

   */

  protected void doRefresh() throws ServiceException {

    // TODO: verify that the correct config file is still used

	 * 

	 * @param event - The EntryEvent that occurred

	 */

	public void entryAdded(EntryEvent<Identifier, SystemMetadata> event) {

		// handle as update - that method will create if necessary

		entryUpdated(event);

	 * 

	 * @param event - The EntryEvent that occurred

	 */

	public void entryEvicted(EntryEvent<Identifier, SystemMetadata> event) {

	  // nothing to do, entries are still in the backing store

	 * 

	 * @param event - The EntryEvent that occurred

	 */

	public void entryRemoved(EntryEvent<Identifier, SystemMetadata> event) {

	  // we don't remove objects

	 * 

	 * @param event - The EntryEvent that occurred

	 */

	public void entryUpdated(EntryEvent<Identifier, SystemMetadata> event) {

			logMetacat.debug("Entry added/updated to System Metadata map: " + event.getKey().getValue());

package edu.ucsb.nceas.metacat.dataone.hazelcast;

import java.util.Collection;

import java.util.Hashtable;

import java.util.Map;

import java.util.Set;

	 *  document on the local filesystem.  Returns null if it can't 

	 *  create the path. 

	 */

	public String load(String key) 

	{

	 *  mappings for all Identifiers in the parameters.  Any Identifier not found

	 *  is not included in the resulting map.

	 */

	public Map<String, String> loadAll(Collection<String> identifiers) {

	 * (Hazelcast allows avoiding pre-loading by returning NULL, so will

	 * do this to avoid pre-loading a very long list unnecessarily)

	 */

	public Set<String> loadAllKeys() 

	{

		return null;

 */

public class SystemMetadataMap implements MapStore<Identifier, SystemMetadata>, MapLoader<Identifier, SystemMetadata> {

	public void delete(Identifier arg0) {

		// we do not delete system metadata

	}

	public void deleteAll(Collection<Identifier> arg0) {

		// we do not delete system metadata	

	}

	public void store(Identifier pid, SystemMetadata sm) {

		try {

			//System.out.println("Storing System Metadata to store: " + pid.getValue());

		}

	}

	public void storeAll(Map<Identifier, SystemMetadata> map) {

		for (Identifier key: map.keySet()) {

			store(key, map.get(key));

		}

	}

	public SystemMetadata load(Identifier pid) {

		SystemMetadata sm = null;

		try {

		return sm;

	}

	public Map<Identifier, SystemMetadata> loadAll(Collection<Identifier> keys) {

		Map<Identifier, SystemMetadata> map = new HashMap<Identifier, SystemMetadata>();

		for (Identifier key: keys) {

		return map;

	}

	public Set<Identifier> loadAllKeys() {

		Set<Identifier> pids = new HashSet<Identifier>();

		try {