View Javadoc
   package org.jellyfish.implementation;
   
   import java.util.ArrayList;
   import java.util.Collection;
   import java.util.Iterator;
   
   import javax.jdo.Extent;
   import javax.jdo.PersistenceManagerFactory;
   import javax.jdo.Query;
  import javax.jdo.Transaction;
  import javax.naming.InvalidNameException;
  import javax.naming.NameNotFoundException;
  import javax.naming.NamingEnumeration;
  import javax.naming.NamingException;
  import javax.naming.directory.Attributes;
  import javax.naming.directory.DirContext;
  import javax.naming.directory.SearchResult;
  
  import org.apache.avalon.framework.logger.LogEnabled;
  import org.apache.avalon.framework.logger.Logger;
  import org.apache.avalon.framework.service.ServiceException;
  import org.apache.avalon.framework.service.ServiceManager;
  import org.apache.avalon.framework.service.Serviceable;
  import org.jellyfish.ConnectionManager;
  import org.jellyfish.DirectoryManager;
  import org.jellyfish.MappingManager;
  import org.jellyfish.ObjectMapNotFoundException;
  
  public class DirectoryManagerDefault
  	implements DirectoryManager, Serviceable, LogEnabled {
  	private static DirectoryManagerDefault instance;
  	private ServiceManager serviceManager;
  	private Logger logger;
  	private ConnectionManager connectionManager;
  	private MappingManager mappingManager;
  
  	public DirectoryManagerDefault() {
  	}
  
  	public void service(ServiceManager serviceManager)
  		throws ServiceException {
  		this.serviceManager = serviceManager;
  		try {
  			mappingManager =
  				(MappingManager) serviceManager.lookup(MappingManager.ROLE);
  			connectionManager =
  				(ConnectionManager) serviceManager.lookup(
  					ConnectionManager.ROLE);
  		} catch (ServiceException e) {
  			logger.fatalError(e.getMessage(), e);
  			throw new RuntimeException(e);
  		}
  	}
  
  	public void enableLogging(Logger logger) {
  		this.logger = logger;
  	}
  
  	public void store(Object object) {
  		DirContext dirContext = null;
  		String objectDn = null;
  		Attributes attributes = null;
  		try {
  			dirContext = connectionManager.getContext();
  			objectDn = mappingManager.getObjectDn(object);
  			attributes = mappingManager.mapToAttributes(object);
  			try {
  				dirContext.modifyAttributes(
  					objectDn,
  					DirContext.REPLACE_ATTRIBUTE,
  					attributes);
  			} catch (NameNotFoundException exception) {
  				createSubContext(dirContext, object, objectDn, attributes);
  			}
  		} catch (NamingException e) {
  			// LDAPd hack:
  			// look for NameNotFound here and createSubContext() if necessary
  			if (e.getMessage().indexOf("javax.naming.NameNotFoundException")
  				> 0) {
  				createSubContext(dirContext, object, objectDn, attributes);
  			} else {
  				logger.fatalError(e.toString());
  			}
  		}
  	}
  
  	private void createSubContext(
  		DirContext dirContext,
  		Object object,
  		String objectDn,
  		Attributes attributes) {
  		try {
  			attributes.put(
  				"objectclass",
  				mappingManager.getObjectMapping(object).getLdapName());
  			dirContext.createSubcontext(objectDn, attributes);
  		} catch (ObjectMapNotFoundException e) {
  			logger.fatalError(e.toString());
  		} catch (NamingException e) {
 			logger.fatalError(e.toString());
 		}
 	}
 
 	public Object lookup(Object object) {
 		try {
 			return mappingManager.mapFromAttributes(
 				connectionManager.getContext().getAttributes(
 					mappingManager.getObjectDn(object)));
 		} catch (NamingException e) {
 			logger.fatalError(e.toString());
 		}
 
 		return object;
 	}
 
 	public void delete(Object object) {
 		try {
 			connectionManager.getContext().destroySubcontext(
 				mappingManager.getObjectDn(object));
 		} catch (InvalidNameException exception) {
 			logger.debug("(This doesn't matter since it's for a delete): " + exception.getMessage());
 		} catch (NamingException e) {
 			logger.fatalError(e.toString());
 		}
 	}
 
 	public Collection search(Object object) {
 		Collection searchResults = new ArrayList();
 		try {
 			NamingEnumeration resultEnumeration =
 				connectionManager.getContext().search(
 					getParentDn(mappingManager.getObjectDn(object)),
 					mappingManager.mapToAttributes(object));
 			while (resultEnumeration.hasMore()) {
 				SearchResult searchResult =
 					(SearchResult) resultEnumeration.next();
 				searchResults.add(
 					mappingManager.mapFromAttributes(
 						searchResult.getAttributes()));
 			}
 		} catch (NamingException namingException) {
 			logger.fatalError(
 				"Exception while searching for ." + object,
 				namingException);
 		}
 		return searchResults;
 	}
 
 	private String getParentDn(String dn) {
 		if (dn != null && dn.trim().length() > 0) {
 			int firstComma = dn.indexOf(',');
 			dn = dn.substring(firstComma + 1);
 		}
 
 		return dn;
 	}
 
 	public boolean isClosed() {
 		throw new UnsupportedOperationException("Implement me.");
 	}
 
 	public void close() {
 		throw new UnsupportedOperationException("Implement me.");
 	}
 
 	public Transaction currentTransaction() {
 		throw new UnsupportedOperationException("Implement me.");
 	}
 
 	public void evict(Object arg0) {
 		throw new UnsupportedOperationException("Implement me.");
 	}
 
 	public void evictAll(Object[] arg0) {
 		throw new UnsupportedOperationException("Implement me.");
 	}
 
 	public void evictAll(Collection arg0) {
 		throw new UnsupportedOperationException("Implement me.");
 	}
 
 	public void evictAll() {
 		throw new UnsupportedOperationException("Implement me.");
 	}
 
 	public void refresh(Object arg0) {
 		throw new UnsupportedOperationException("Implement me.");
 	}
 
 	public void refreshAll(Object[] arg0) {
 		throw new UnsupportedOperationException("Implement me.");
 	}
 
 	public void refreshAll(Collection arg0) {
 		throw new UnsupportedOperationException("Implement me.");
 	}
 
 	public void refreshAll() {
 		throw new UnsupportedOperationException("Implement me.");
 	}
 
 	public Query newQuery() {
 		throw new UnsupportedOperationException("Implement me.");
 	}
 
 	public Query newQuery(Object arg0) {
 		throw new UnsupportedOperationException("Implement me.");
 	}
 
 	public Query newQuery(String arg0, Object arg1) {
 		throw new UnsupportedOperationException("Implement me.");
 	}
 
 	public Query newQuery(Class arg0) {
 		throw new UnsupportedOperationException("Implement me.");
 	}
 
 	public Query newQuery(Extent arg0) {
 		throw new UnsupportedOperationException("Implement me.");
 	}
 
 	public Query newQuery(Class arg0, Collection arg1) {
 		throw new UnsupportedOperationException("Implement me.");
 	}
 
 	public Query newQuery(Class arg0, String arg1) {
 		throw new UnsupportedOperationException("Implement me.");
 	}
 
 	public Query newQuery(Class arg0, Collection arg1, String arg2) {
 		throw new UnsupportedOperationException("Implement me.");
 	}
 
 	public Query newQuery(Extent arg0, String arg1) {
 		throw new UnsupportedOperationException("Implement me.");
 	}
 
 	public Extent getExtent(Class arg0, boolean arg1) {
 		throw new UnsupportedOperationException("Implement me.");
 	}
 
 	public Object getObjectById(Object arg0, boolean arg1) {
 		throw new UnsupportedOperationException("Implement me.");
 	}
 
 	public Object getObjectId(Object arg0) {
 		throw new UnsupportedOperationException("Implement me.");
 	}
 
 	public Object getTransactionalObjectId(Object arg0) {
 		throw new UnsupportedOperationException("Implement me.");
 	}
 
 	public Object newObjectIdInstance(Class arg0, String arg1) {
 		throw new UnsupportedOperationException("Implement me.");
 	}
 
 	public void makePersistent(Object object) {
 		store(object);
 	}
 
 	public void makePersistentAll(Object[] objects) {
 		for (int index = 0; index < objects.length; index++) {
 			makePersistent(objects[index]);
 		}
 	}
 
 	public void makePersistentAll(Collection objects) {
 		for (Iterator iterator = objects.iterator(); iterator.hasNext();) {
 			makePersistent(iterator.next());
 		}
 	}
 
 	public void deletePersistent(Object object) {
 		delete(object);
 	}
 
 	public void deletePersistentAll(Object[] objects) {
 		for (int index = 0; index < objects.length; index++) {
 			deletePersistent(objects[index]);
 		}
 	}
 
 	public void deletePersistentAll(Collection objects) {
 		for (Iterator iterator = objects.iterator(); iterator.hasNext();) {
 			deletePersistent(iterator.next());
 		}
 	}
 
 	public void makeTransient(Object arg0) {
 		throw new UnsupportedOperationException("Implement me.");
 	}
 
 	public void makeTransientAll(Object[] arg0) {
 		throw new UnsupportedOperationException("Implement me.");
 	}
 
 	public void makeTransientAll(Collection arg0) {
 		throw new UnsupportedOperationException("Implement me.");
 	}
 
 	public void makeTransactional(Object arg0) {
 		throw new UnsupportedOperationException("Implement me.");
 	}
 
 	public void makeTransactionalAll(Object[] arg0) {
 		throw new UnsupportedOperationException("Implement me.");
 	}
 
 	public void makeTransactionalAll(Collection arg0) {
 		throw new UnsupportedOperationException("Implement me.");
 	}
 
 	public void makeNontransactional(Object arg0) {
 		throw new UnsupportedOperationException("Implement me.");
 	}
 
 	public void makeNontransactionalAll(Object[] arg0) {
 		throw new UnsupportedOperationException("Implement me.");
 	}
 
 	public void makeNontransactionalAll(Collection arg0) {
 		throw new UnsupportedOperationException("Implement me.");
 	}
 
 	public void retrieve(Object arg0) {
 		throw new UnsupportedOperationException("Implement me.");
 	}
 
 	public void retrieveAll(Collection arg0) {
 		throw new UnsupportedOperationException("Implement me.");
 	}
 
 	public void retrieveAll(Object[] arg0) {
 		throw new UnsupportedOperationException("Implement me.");
 	}
 
 	public void setUserObject(Object arg0) {
 		throw new UnsupportedOperationException("Implement me.");
 	}
 
 	public Object getUserObject() {
 		throw new UnsupportedOperationException("Implement me.");
 	}
 
 	public PersistenceManagerFactory getPersistenceManagerFactory() {
 		throw new UnsupportedOperationException("Implement me.");
 	}
 
 	public Class getObjectIdClass(Class arg0) {
 		throw new UnsupportedOperationException("Implement me.");
 	}
 
 	public void setMultithreaded(boolean arg0) {
 		throw new UnsupportedOperationException("Implement me.");
 	}
 
 	public boolean getMultithreaded() {
 		throw new UnsupportedOperationException("Implement me.");
 	}
 
 	public void setIgnoreCache(boolean arg0) {
 		throw new UnsupportedOperationException("Implement me.");
 	}
 
 	public boolean getIgnoreCache() {
 		throw new UnsupportedOperationException("Implement me.");
 	}
 }