ruper2/src/java/core/org/krysalis/ruper2/protocols package.html,NONE,1.1 VirtualResourceLocator.java,NONE,1.1 ProtocolOperationsProvider.java,NONE,1.1 ProtocolOperationsManager.java,NONE,1.1 DefaultProtocolOperationsManager.java,NONE,1.1 Protocol.java,NONE,1.1

[email protected] Mon, 29 Sep 2003 11:09:25 -0700
Newsgroups	gmane.comp.krysalis.metamorphosis.cvs
Message-ID	<[email protected]>
Update of /cvsroot/metamorphosis/ruper2/src/java/core/org/krysalis/ruper2/protocols
In directory sc8-pr-cvs1:/tmp/cvs-serv30481/src/java/core/org/krysalis/ruper2/protocols

Added Files:
	package.html VirtualResourceLocator.java 
	ProtocolOperationsProvider.java ProtocolOperationsManager.java 
	DefaultProtocolOperationsManager.java Protocol.java 
Log Message:
Avoid clash with existing Ruper...

--- NEW FILE: package.html ---
<body>
<p>Ruper File Handling 'Sub-System'<br>
	Re-usable components for downloading, copying, extracting...</p>
</body>
--- NEW FILE: VirtualResourceLocator.java ---
/*
 * Created on Aug 23, 2003
 *
 */
package org.krysalis.ruper2.protocols;

import java.io.File;
import java.net.MalformedURLException;
import java.net.URL;
import java.util.StringTokenizer;

import org.krysalis.ruper2.util.RuperConstants;

/**
 * @author arb_jack
 * 
 * This class exists for two reasons:
 * 
 * 1) So we can separate ourselves from VFS FileObjects (yet still
 * leverage VFS and benefit from it's manage protocols.)
 * 
 * 2) because java.net.URL won't allow protocols that java.net 
 * can't process. A shame. Not sure if the Java URI class is better 
 * about this, but we want to be compatible over older JDKs and also
 * this is an L not an I. 
 * 
 */
public class VirtualResourceLocator {

	public static final String VRL_CLASSNAME = VirtualResourceLocator.class.getName();
	
	private String m_url = null;

	// Parsed out..
	private String m_protocol = null;

	public VirtualResourceLocator(String url) {
		parseString(url);
	}

	public VirtualResourceLocator(VirtualResourceLocator context, String url) {
		// :TODO: Basic right now, just concatenates		
		parseString(context + "/" + url);
	}

	public VirtualResourceLocator(URL url) {
		parseString(url.toExternalForm());
	}

	public VirtualResourceLocator(File file) {
		parseString(createURLForFile(file));
	}

	private void parseString(String url) {
		m_url = url;

		// Extract Protocol
		int colonPosn = url.indexOf(':');
		if (-1 != colonPosn)
			m_protocol = url.substring(0, colonPosn);
		else
			m_protocol = Protocol.HTTP_PROTOCOL;
	}

	private String createURLForFile(File file) {
		StringBuffer url = new StringBuffer("file://");
		String path = file.getAbsolutePath();
		for (StringTokenizer tokens = new StringTokenizer(path, "\\");
			tokens.hasMoreTokens();
			) {

			url.append(tokens.nextToken());

			if (tokens.hasMoreTokens())
				url.append('/');
		}

		return url.toString();
	}
	/**
	 * May not be possible for all VirtualResourceLocators
	 * 
	 * @return
	 * @throws MalformedURLException
	 */
	public URL getResourceLocator() throws MalformedURLException {
		return new URL(m_url);
	}

	public String getProtocol() {
		return m_protocol;
	}

	public String toString() {
		return toExternalForm();
	}

	public String toExternalForm() {
		return m_url;
	}

    public boolean equals(Object obj) {
        boolean isEqual = false;
        if( obj instanceof VirtualResourceLocator ) {
            VirtualResourceLocator rhs = (VirtualResourceLocator) obj;
            if( m_protocol.equals( rhs.m_protocol ) &&
                    m_url.equals( rhs.m_url ) ) {
                isEqual = true;
            }
        }
        return isEqual;
    }

	public static VirtualResourceLocator getTestVRL() {
		return new VirtualResourceLocator(RuperConstants.RUPER_HOME);
	}
}

--- NEW FILE: ProtocolOperationsProvider.java ---
/*
 * Created on Aug 27, 2003
 *
 * To change the template for this generated file go to
 * Window&gt;Preferences&gt;Java&gt;Code Generation&gt;Code and Comments
 */
package org.krysalis.ruper2.protocols;

import java.util.List;

import org.krysalis.ruper2.impl.ResourceUpdaterContext;
import org.krysalis.ruper2.util.select.Selector;

/**
 * @author arb_jack
 */
public interface ProtocolOperationsProvider {

	//	Configuration...
	void init(ResourceUpdaterContext context) throws Exception ;
	List getSupportedSourceProtocols();
	List getSupportedDestinationProtocols();

	//	Work...
	boolean exists(VirtualResourceLocator container) throws Exception;
	List list(VirtualResourceLocator container) throws Exception;
	List list(VirtualResourceLocator container, Selector selector) throws Exception;
	void copy(VirtualResourceLocator from, VirtualResourceLocator to) throws Exception;
	void copy(VirtualResourceLocator from, VirtualResourceLocator to, Selector selector) throws Exception;
	
	// :TODO: delete/create
}

--- NEW FILE: ProtocolOperationsManager.java ---
/*
 * Created on Aug 27, 2003
 */
package org.krysalis.ruper2.protocols;

import java.io.File;
import java.io.PrintWriter;
import java.net.URL;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;

import org.krysalis.ruper2.RuperException;
import org.krysalis.ruper2.impl.ResourceUpdaterContext;
import org.krysalis.ruper2.log.Logger;
import org.krysalis.ruper2.protocols.select.DestinationProtocolProviderSelector;
import org.krysalis.ruper2.protocols.select
	.SourceDestinationProtocolProviderSelector;
import org.krysalis.ruper2.protocols.select.SourceProtocolProviderSelector;
import org.krysalis.ruper2.util.RuperConstants;
import org.krysalis.ruper2.util.chainprocess.HandlerManager;
import org.krysalis.ruper2.util.select.Selector;
import org.krysalis.ruper2.util.select.SelectorHandlerChain;
import org.krysalis.version.util.debug.DebugUtils;
import org.krysalis.version.util.debug.Dumpable;

/**
 * @author ajack
 */
public class ProtocolOperationsManager
	extends HandlerManager
	implements Dumpable {
	private ResourceUpdaterContext m_context = null;
	private List m_providers = new ArrayList();

	private Map m_sourceProtocolMap = new HashMap();
	private Map m_destinationProtocolMap = new HashMap();

	ProtocolOperationsManager(ResourceUpdaterContext context) {
		m_context = context;
		configureSelectors();
	}

	private void configureSelectors() {

		// create the selector handler chain and 
		// add it to the list of handler chains
		SelectorHandlerChain selectors =
			new SelectorHandlerChain(RuperConstants.SELECTOR);
		// add the selectors chain to the handler manager
		this.addHandlerChain(selectors);
	}

	public void registerProvider(ProtocolOperationsProvider p)
		throws Exception {
		m_providers.add(p);
		p.init(m_context);

		registerIntoMap(
			m_sourceProtocolMap,
			p,
			p.getSupportedSourceProtocols().iterator());

		registerIntoMap(
			m_destinationProtocolMap,
			p,
			p.getSupportedDestinationProtocols().iterator());
	}

	private void registerIntoMap(
		Map map,
		ProtocolOperationsProvider p,
		Iterator i) {
		for (; i.hasNext();) {
			addProvider(map, (String) i.next(), p);
		}
	}

	public boolean hasProviders() {
		return !m_providers.isEmpty();
	}

	/**
	 * Resolve an address to a file (in this context, i.e. given cwd)
	 * if it is possible.
	 * 
	 * @param address
	 * @return File -- the local file equivalent
	 */
	public File toFile(VirtualResourceLocator address) {
		File local = null;

		// :TODO:

		return local;
	}

	/**
	 * Resolve an address to a URL -- if possible, and within this context 
	 *  
	 * @param address
	 * @return
	 */
	public URL toURL(VirtualResourceLocator address) {
		URL url = null;
		//:TODO:
		return url;
	}

	/**
	 * Copy the contents at address to another
	 * 
	 * @param from
	 * @param to
	 * @throws Exception
	 */
	public List performList(
		VirtualResourceLocator container,
		Selector selector)
		throws Exception {
		return performList(
			container,
			determineProviderFor(container),
			selector);
	}

	public List performList(
		VirtualResourceLocator container,
		ProtocolOperationsProvider provider,
		Selector selector)
		throws Exception {
		Logger.getLog().debug("Perform List " + container);
		return provider.list(container, selector);
	}

	/**
	 * Copy the contents at address to another
	 * 
	 * @param from
	 * @param to
	 * @throws Exception
	 */
	public boolean checkExists(VirtualResourceLocator container)
		throws Exception {

		Logger.getLog().debug("Check if resource provider exists " + container);
		return determineProviderFor(container).exists(container);
	}

	/**
	 * Copy the contents at address to another
	 * 
	 * @param from
	 * @param to
	 * @throws Exception
	 */
	public void performCopy(
		VirtualResourceLocator from,
		VirtualResourceLocator to,
		Selector selector)
		throws Exception {

		Logger.getLog().debug("Perform Copy " + from + " -> " + to);

		determineProviderFor(from, to).copy(from, to, selector);
	}

	ProtocolOperationsProvider determineProviderFor(
		VirtualResourceLocator source,
		VirtualResourceLocator destination)
		throws RuperException {
		// Locate a Provider that handles both address
		// types (e.g. protocols)

		List providers =
			determineSourceDestinationProviders(
				source.getProtocol(),
				destination.getProtocol());

		if (0 == providers.size())
			throw new RuperException(
				"No providers for protocols : "
					+ source.getProtocol()
					+ " and "
					+ destination.getProtocol());

		ProtocolOperationsProvider provider =
			(ProtocolOperationsProvider) providers.get(0);

		//
		// :TODO: Maybe filter/select by capabilities.
		//

		return provider;
	}

	ProtocolOperationsProvider determineProviderFor(VirtualResourceLocator source)
		throws RuperException {
		// Locate a Provider that handles both address
		// types (e.g. protocols)
		List providers = determineSourceProviders(source.getProtocol());

		if (null == providers)
			throw new RuperException(
				"No providers for protocol : " + source.getProtocol());

		ProtocolOperationsProvider provider =
			(ProtocolOperationsProvider) providers.get(0);

		//
		// :TODO: Maybe filter/select by capabilities.
		//

		return provider;
	}

	private List determineSourceProviders(String protocol)
		throws RuperException {
		List listOfProviders = null;
		// set the selector and then pass the providers through the process chain
		SourceProtocolProviderSelector sourceProtocolSelector =
			new SourceProtocolProviderSelector(protocol);

		return processProviderList(sourceProtocolSelector);
	}

	private List determineDestinationProviders(String protocol)
		throws RuperException {
		List listOfProviders = null;
		// set the selector and then pass the providers through the process chain
		DestinationProtocolProviderSelector destinationProtocolSelector =
			new DestinationProtocolProviderSelector(protocol);

		return processProviderList(destinationProtocolSelector);
	}

	private List determineSourceDestinationProviders(
		String srcProtocol,
		String destProtocol)
		throws RuperException {
		List listOfProviders = null;
		// set the selector and then pass the providers through the process chain
		SourceDestinationProtocolProviderSelector srcDestProtocolSelector =
			new SourceDestinationProtocolProviderSelector(
				srcProtocol,
				destProtocol);

		return processProviderList(srcDestProtocolSelector);
	}

	private List processProviderList(Selector selector) throws RuperException {

		List listOfProviders = null;
		List selectorList = new ArrayList();
		selectorList.add(selector);

		setHandlers(RuperConstants.SELECTOR, selectorList);

		listOfProviders = process(m_providers);
		return listOfProviders;
	}

	private void addProvider(
		Map map,
		String protocol,
		ProtocolOperationsProvider p) {
		List providers = (List) map.get(protocol);
		if (null == providers) {
			providers = new ArrayList();
			map.put(protocol, providers);
		}
		providers.add(p);
	}

	private List join(List list1, List list2) {
		List join = new ArrayList();

		for (Iterator i = list1.iterator(); i.hasNext();) {
			Object entity = i.next();

			if (list2.contains(entity))
				join.add(entity);
		}

		return join;
	}

	public void dump(PrintWriter out, int depth, boolean verbose) {
		String indent = DebugUtils.getIndent(depth);
		String indent1 = DebugUtils.getIndent(depth + 1);

		dumpRegistry(out, indent1, "Source Protocols", m_sourceProtocolMap);

		dumpRegistry(
			out,
			indent1,
			"Destination Protocols",
			m_destinationProtocolMap);
	}

	private void dumpRegistry(
		PrintWriter out,
		String indent,
		String title,
		Map map) {

		out.print(indent);
		out.println("Registry: " + title);

		for (Iterator i = map.keySet().iterator(); i.hasNext();) {
			Object key = i.next();
			List providers = (List) map.get(key);

			for (Iterator ii = providers.iterator(); ii.hasNext();) {
				ProtocolOperationsProvider p =
					(ProtocolOperationsProvider) ii.next();
				out.print(indent);
				out.print("Key: \'" + key + "\' -> ");
				out.println("Provider: " + p);
			}
		}
	}
}

--- NEW FILE: DefaultProtocolOperationsManager.java ---
/*
 * Created on Aug 27, 2003
 */
package org.krysalis.ruper2.protocols;

import org.krysalis.ruper2.RuperRuntimeException;
import org.krysalis.ruper2.impl.ResourceUpdaterContext;
import org.krysalis.version.util.debug.DebugUtils;
import org.krysalis.version.util.envsafe.RelativelySafe;

/**
 * @author ajack
 */
public class DefaultProtocolOperationsManager
	extends ProtocolOperationsManager {

	private final static String VFS_PROVIDER =
		"org.krysalis.ruper2.protocols.impl.VfsProtocolOperationsProvider";
	private final static String URL_PROVIDER =
		"org.krysalis.ruper2.protocols.impl.BasicProtocolOperationsProvider";

	/**
	 * @param context
	 */
	public DefaultProtocolOperationsManager(ResourceUpdaterContext context) {
		super(context);

		//
		// Shoot for VFS, but fallback to basic URL
		//
		try {
			ProtocolOperationsProvider provider =
				(ProtocolOperationsProvider) RelativelySafe.attemptLoad(
					VFS_PROVIDER,
					URL_PROVIDER);

			registerProvider(provider);
		}
		catch (Exception ve) {
			throw new RuperRuntimeException(
				"No *Working* Protocol Operation Providers Detected",
				ve);
		}
	}

	public static void main(String args[]) {
		ProtocolOperationsManager pom =
			new DefaultProtocolOperationsManager(
				ResourceUpdaterContext.getTestContext());

		DebugUtils.dump(pom);
	}
}

--- NEW FILE: Protocol.java ---
/*
 * Created on Aug 28, 2003
 */
package org.krysalis.ruper2.protocols;

/**
 * @author ajack
 */
public class Protocol {

	public final static String HTTP_PROTOCOL = "http";
	public final static String FILE_PROTOCOL = "file";

}




-------------------------------------------------------
This sf.net email is sponsored by:ThinkGeek
Welcome to geek heaven.
http://thinkgeek.com/sf