/ - Diff - Metacat - Ecoinformatics Redmine

« Previous | Next »

Revision 5914

Added by ben leinfelder over 13 years ago

remove httpclient 3.1 and custom-built httpclient.jar
rework MetacatClient (and other classes) to use httpclient 4
updated build to not create httpclient.jar
encoding tests now pass.

     import java.util.TimeZone;
     import java.util.Vector;
     import org.apache.commons.httpclient.HttpClient;
     import org.apache.http.client.HttpClient;
     import org.apache.http.impl.client.DefaultHttpClient;
     import edu.ucsb.nceas.metacat.database.DBConnection;
     import edu.ucsb.nceas.metacat.database.DBConnectionPool;
-...
     		DBConnectionPool.returnDBConnection(dbconn, serialNumber);
+    	}
     	protected static void httpPost(String url, HashMap<String,String> paramMap)  throws IOException {
     	protected static void httpPost(String url, HashMap<String,String> paramMap) throws Exception {
     		debug("Posting to: " + url);
     		if (httpClient == null) {
     			httpClient = new HttpClient();
     			httpClient = new DefaultHttpClient();
+    		}
     		String postResponse = RequestUtil.post(httpClient, url, paramMap);
     		debug("Post response: " + postResponse);

src/edu/ucsb/nceas/metacat/restservice/ResourceHandler.java
38	38	import java.text.SimpleDateFormat;
39	39
40	40
41		import org.apache.commons.httpclient.util.DateParser;
42	41	import org.apache.commons.io.IOUtils;
43	42	import org.apache.log4j.Logger;
44	43	import org.apache.maven.artifact.ant.shaded.IOUtil;

                     prop.put("returnfield", returnFld);
+                }
                 response = metacatClient.sendData(prop, null, null, 0);
                 response = metacatClient.sendParameters(prop);
                 if (response != null) {
                     buffy = new BufferedReader(new InputStreamReader(response));
                     result = XMLUtilities.getXMLReaderAsDOMDocument(buffy);

     package edu.ucsb.nceas.metacat.util;
     import java.io.InputStream;
     import java.io.InputStreamReader;
     import java.io.IOException;
     import java.io.BufferedReader;
-...
     import java.net.MalformedURLException;
     import java.net.URL;
     import java.net.URLConnection;
     import java.util.ArrayList;
     import java.util.Enumeration;
     import java.util.HashMap;
     import java.util.Hashtable;
     import java.util.Iterator;
     import java.util.List;
     import java.util.Set;
     import java.util.Vector;
-...
     import javax.servlet.http.HttpServletResponse;
     import javax.servlet.http.HttpSession;
     import org.apache.commons.httpclient.HttpClient;
     import org.apache.commons.httpclient.HttpException;
     import org.apache.commons.httpclient.methods.PostMethod;
     import org.apache.commons.io.IOUtils;
     import org.apache.http.HttpException;
     import org.apache.http.HttpResponse;
     import org.apache.http.HttpVersion;
     import org.apache.http.NameValuePair;
     import org.apache.http.client.HttpClient;
     import org.apache.http.client.entity.UrlEncodedFormEntity;
     import org.apache.http.client.methods.HttpPost;
     import org.apache.http.impl.client.DefaultHttpClient;
     import org.apache.http.message.BasicNameValuePair;
     import org.apache.http.params.CoreProtocolPNames;
     import org.apache.log4j.Logger;
     import edu.ucsb.nceas.metacat.properties.PropertyService;
-...
     public class RequestUtil {
     	private static Logger logMetacat = Logger.getLogger(RequestUtil.class);
     	private static String encoding = "UTF-8";
     	/**
     	 * private constructor - all methods are static so there is no
-...
     	 *            map of parameters to add to the post
     	 * @returns a string holding the response body
     	 */
     	public static String post(HttpClient httpClient, String url,
     	public static String post(HttpClient httpclient, String url,
     			HashMap<String, String> paramMap) throws IOException, HttpException {
     		PostMethod method = new PostMethod(url);
     		// Configure the form parameters
     		if (paramMap != null) {
     			Set<String> paramNames = paramMap.keySet();
     			for (String paramName : paramNames) {
     				method.addParameter(paramName, paramMap.get(paramName));
+    			}
+    		}
     		// Execute the POST method
     		int statusCode = httpClient.executeMethod(method);
     		if (statusCode != -1) {
     			String contents = method.getResponseBodyAsString();
     			method.releaseConnection();
     			return (contents);
+    		}
             httpclient.getParams().setParameter(
             		CoreProtocolPNames.PROTOCOL_VERSION,
             	    HttpVersion.HTTP_1_1);
         	httpclient.getParams().setParameter(
         			CoreProtocolPNames.HTTP_CONTENT_CHARSET,
         			encoding );
             HttpPost post = new HttpPost(url);
             //set the params
             List<NameValuePair> nameValuePairs = new ArrayList<NameValuePair>();
             Iterator<String> keys = paramMap.keySet().iterator();
             while (keys.hasNext()) {
             	String key = keys.next();
             	String value = paramMap.get(key);
             	NameValuePair nvp = new BasicNameValuePair(key, value);
             	nameValuePairs.add(nvp);
+            }
             post.setEntity(new UrlEncodedFormEntity(nameValuePairs, encoding));
             //post.setHeader("Cookie", "JSESSIONID="+ sessionId);
             HttpResponse httpResponse = httpclient.execute(post);
             if (httpResponse.getStatusLine().getStatusCode() != -1) {
                 InputStream result = httpResponse.getEntity().getContent();
                 String contents = IOUtils.toString(result, encoding);
                 return contents;
+            }
     		return null;
+    	}

     import java.io.IOException;
     import java.io.StringWriter;
     import java.io.Reader;
     import java.net.URL;
     import java.nio.charset.Charset;
     import java.util.ArrayList;
     import java.util.Enumeration;
     import java.util.List;
     import java.util.Properties;
     import java.util.Vector;
     import javax.servlet.http.HttpServletRequest;
     import org.apache.commons.io.IOUtils;
     import org.apache.http.HttpResponse;
     import org.apache.http.HttpVersion;
     import org.apache.http.NameValuePair;
     import org.apache.http.client.HttpClient;
     import org.apache.http.client.entity.UrlEncodedFormEntity;
     import org.apache.http.client.methods.HttpPost;
     import org.apache.http.entity.mime.HttpMultipartMode;
     import org.apache.http.entity.mime.MultipartEntity;
     import org.apache.http.entity.mime.content.FileBody;
     import org.apache.http.entity.mime.content.InputStreamBody;
     import org.apache.http.entity.mime.content.StringBody;
     import org.apache.http.impl.client.DefaultHttpClient;
     import org.apache.http.message.BasicNameValuePair;
     import org.apache.http.params.CoreProtocolPNames;
     import org.apache.http.util.EntityUtils;
     import org.w3c.dom.Node;
     import org.w3c.dom.NodeList;
     import edu.ucsb.nceas.utilities.HttpMessage;
     import edu.ucsb.nceas.utilities.IOUtil;
     import edu.ucsb.nceas.utilities.XMLUtilities;
     import java.io.File;
-...
         /** The session identifier for the session */
         private String sessionId;
         /** The default character encoding, can be changed by client */
         private String encoding = "UTF-8";
         public static void main(String[] args) {
         	try {
         		Metacat mc =
-...
             String response = null;
             try {
                 response = sendDataForString(prop, null, null, 0);
             	InputStream result = sendParameters(prop);
                 response = IOUtils.toString(result, encoding);
             } catch (Exception e) {
                 throw new MetacatInaccessibleException(e.getMessage());
+            }
-...
             String response = null;
             try {
                 response = sendDataForString(prop, null, null, 0);
             	InputStream result = sendParameters(prop);
                 response = IOUtils.toString(result, encoding);
             } catch (Exception e) {
                 throw new MetacatInaccessibleException(e.getMessage());
+            }
-...
             String response = null;
             try {
                 response = sendDataForString(prop, null, null, 0);
             	InputStream result = sendParameters(prop);
                 response = IOUtils.toString(result, encoding);
             } catch (Exception e) {
                 throw new MetacatInaccessibleException(e.getMessage());
+            }
-...
             String response = null;
             try {
                 response = sendDataForString(prop, null, null, 0);
             	InputStream result = sendParameters(prop);
                 response = IOUtils.toString(result, encoding);
             } catch (Exception e) {
                 throw new MetacatInaccessibleException(e.getMessage());
+            }
-...
             String response = null;
             try {
                 response = sendDataForString(prop, null, null, 0);
             	InputStream result = sendParameters(prop);
                 response = IOUtils.toString(result, encoding);
             } catch (Exception e) {
                 throw new MetacatInaccessibleException(e.getMessage());
+            }
-...
             prop.put("docid", docid);
             InputStream response = null;
             try {
                 response = sendData(prop, null, null, 0);
                 response = sendParameters(prop);
             } catch (Exception e) {
                 throw new MetacatInaccessibleException(e.getMessage());
+            }
-...
             InputStream response = null;
             try {
                 response = sendData(prop, null, null, 0);
                 response = sendParameters(prop);
             } catch (Exception e) {
                 throw new MetacatInaccessibleException(e.getMessage());
+            }
-...
             InputStream response = null;
             try {
                 response = sendData(prop, null, null, 0);
                 response = sendParameters(prop);
             } catch (Exception e) {
                 throw new MetacatInaccessibleException(e.getMessage());
+            }
-...
         	throws InsufficientKarmaException, MetacatException, IOException,
                 MetacatInaccessibleException {
             Reader reader = null;
             String doctext = null;
             String schematext = null;
             try {
-...
                 prop.put("dtdtext", schematext);
+            }
             if (sessionId != null) {
                 prop.put("sessionid", sessionId);
+            }
     //        if (sessionId != null) {
     //            prop.put("sessionid", sessionId);
     //        }
             String response = null;
             try {
                 response = sendDataForString(prop, null, null, 0);
             	InputStream result = sendParameters(prop);
                 response = IOUtils.toString(result, encoding);
             } catch (Exception e) {
                 throw new MetacatInaccessibleException(e.getMessage());
+            }
-...
         public String update(String docid, Reader xmlDocument, Reader schema)
         throws InsufficientKarmaException, MetacatException, IOException,
                 MetacatInaccessibleException {
             Reader reader = null;
             String doctext = null;
             String schematext = null;
             try {
-...
             String response = null;
             try {
                 response = sendDataForString(prop, null, null, 0);
             	InputStream result = sendParameters(prop);
                 response = IOUtils.toString(result, encoding);
             } catch (Exception e) {
                 throw new MetacatInaccessibleException(e.getMessage());
+            }
-...
         throws InsufficientKarmaException, MetacatException, IOException,
                 MetacatInaccessibleException {
             URL url = new URL(metacatUrl.trim());
             HttpMessage msg = new HttpMessage(url);
         	HttpClient httpclient = new DefaultHttpClient();
             httpclient.getParams().setParameter(
             		CoreProtocolPNames.PROTOCOL_VERSION,
             	    HttpVersion.HTTP_1_1);
         	httpclient.getParams().setParameter(
         			CoreProtocolPNames.HTTP_CONTENT_CHARSET,
         			encoding);
         	HttpPost post = new HttpPost(metacatUrl);
         	MultipartEntity entity = new MultipartEntity(HttpMultipartMode.BROWSER_COMPATIBLE);
         	// For File parameters
         	entity.addPart("datafile", new FileBody(file));
             //set up properties
             Properties arg = new Properties();
             arg.put("action", "upload");
             arg.put("docid", docid);
             Properties prop = new Properties();
             prop.put("action", "upload");
             prop.put("docid", docid);
             Properties filenames = new Properties();
             String filename = file.getAbsolutePath();
             filenames.put("datafile", filename);
             // For usual String parameters
             Enumeration<Object> keys = prop.keys();
             while (keys.hasMoreElements()) {
             	String key = (String) keys.nextElement();
             	String value = prop.getProperty(key);
             	entity.addPart(key, new StringBody(value, Charset.forName(encoding)));
+            }
             post.setHeader("Cookie", "JSESSIONID="+ this.sessionId);
             post.setEntity(entity);
             String response = null;
             try {
                 response = sendDataForString(arg, filenames, null, 0);
             	response = EntityUtils.toString(httpclient.execute(post).getEntity(), encoding);
             	httpclient.getConnectionManager().shutdown();
             } catch (Exception e) {
                 throw new MetacatInaccessibleException(e.getMessage());
+            }
-...
                 throws InsufficientKarmaException, MetacatException, IOException,
                 MetacatInaccessibleException {
             URL url = new URL(metacatUrl.trim());
             HttpMessage msg = new HttpMessage(url);
         	HttpClient httpclient = new DefaultHttpClient();
             httpclient.getParams().setParameter(
             		CoreProtocolPNames.PROTOCOL_VERSION,
             	    HttpVersion.HTTP_1_1);
         	httpclient.getParams().setParameter(
         			CoreProtocolPNames.HTTP_CONTENT_CHARSET,
         			encoding);
         	HttpPost post = new HttpPost(metacatUrl);
         	MultipartEntity entity = new MultipartEntity(HttpMultipartMode.BROWSER_COMPATIBLE);
         	// For File parameters
         	InputStreamBody content = new InputStreamKnownSizeBody(fileData, filename, size);
         	entity.addPart("datafile", content);
             //set up properties
             Properties arg = new Properties();
             arg.put("action", "upload");
             arg.put("docid", docid);
             Properties prop = new Properties();
             prop.put("action", "upload");
             prop.put("docid", docid);
             Properties filenames = new Properties();
             filenames.put("datafile", filename);
             // For usual String parameters
             Enumeration<Object> keys = prop.keys();
             while (keys.hasMoreElements()) {
             	String key = (String) keys.nextElement();
             	String value = prop.getProperty(key);
             	entity.addPart(key, new StringBody(value, Charset.forName(encoding)));
+            }
             post.setHeader("Cookie", "JSESSIONID="+ this.sessionId);
             post.setEntity(entity);
             String response = null;
             try {
                 response = sendDataForString(arg, filenames, fileData, size);
             	response = EntityUtils.toString(httpclient.execute(post).getEntity(), encoding);
             	httpclient.getConnectionManager().shutdown();
             } catch (Exception e) {
                 throw new MetacatInaccessibleException(e.getMessage());
+            }
-...
             String response = null;
             try {
                 response = sendDataForString(prop, null, null, 0);
             	InputStream result = sendParameters(prop);
                 response = IOUtils.toString(result, encoding);
             } catch (Exception e) {
                 throw new MetacatInaccessibleException(e.getMessage());
+            }
-...
             String response = null;
             try {
                 response = sendDataForString(prop, null, null, 0);
             	InputStream result = sendParameters(prop);
                 response = IOUtils.toString(result, encoding);
             } catch (Exception e) {
                 throw new MetacatInaccessibleException(e.getMessage());
+            }
-...
             String response = null;
             try {
                 response = sendDataForString(prop, null, null, 0);
             	InputStream result = sendParameters(prop);
                 response = IOUtils.toString(result, encoding);
             } catch (Exception e) {
                 throw new MetacatInaccessibleException(e.getMessage());
+            }
-...
             String response = null;
             try {
                 response = sendDataForString(prop, null, null, 0);
             	InputStream result = sendParameters(prop);
                 response = IOUtils.toString(result, encoding);
             } catch (Exception e) {
                 throw new MetacatInaccessibleException(e.getMessage());
+            }
-...
             String response = null;
             try {
                 response = sendDataForString(prop, null, null, 0);
             	InputStream result = sendParameters(prop);
                 response = IOUtils.toString(result, encoding);
                 //parseRevisionResponse will return null if there is an
                 //error that it can't handle
                 String revStr = parserRevisionResponse(response);
-...
             String response = null;
             try {
                 response = sendDataForString(prop, null, null, 0);
             	InputStream result = sendParameters(prop);
                 response = IOUtils.toString(result, encoding);
                 // Check for an error condition
                 if (response.indexOf("<error>") != -1) {
                     throw new MetacatException(response);
-...
             String response = null;
             try {
                 response = sendDataForString(prop, null, null, 0);
             	InputStream result = sendParameters(prop);
                 response = IOUtils.toString(result, encoding);
                 // Check for an error condition
                 if (response.indexOf("<error>") != -1) {
                     throw new MetacatException(response);
-...
             String response = null;
             try {
                 response = sendDataForString(prop, null, null, 0);
             	InputStream result = sendParameters(prop);
                 response = IOUtils.toString(result, encoding);
                 // Check for an error condition
                 if (response.indexOf("<error>") != -1) {
                     throw new MetacatException(response);
                 } else {
                     Reader responseReader = new StringReader(response);
                     StringBuffer sb = new StringBuffer();
                     char[] c = new char[1024];
                     int numread = responseReader.read(c, 0, 1024);
                     while(numread != -1) {
                         sb.append(new String(c, 0, numread));
                         numread = responseReader.read(c, 0, 1024);
+                    }
                     String responseStr = sb.toString();
                     if(responseStr.indexOf("true") != -1) {
                     if (response.indexOf("true") != -1) {
                         return true;
+                    }
                     return false;
-...
          *      value = param name
          * @throws java.lang.Exception thrown
          */
         synchronized public InputStream sendParameters(Properties args) throws Exception {
             InputStream                     result = null;
             URL                             url;
             HttpMessage                     httpMsg;
             url = new URL(metacatUrl);
             httpMsg = new HttpMessage(url);
             httpMsg.setCookie("JSESSIONID="+this.sessionId);
             result = httpMsg.sendPostParameters(args);
             return(result);
+        }
         /************************************************************************
          * PRIVATE METHODS
          ************************************************************************/
         /**
          * Send a request to metacat.
+         *
          * @param prop the properties to be URL encoded and sent
          * @param filename  the properties to be sent to Metacat
          *                  in case of upload, otherwise null
          * @param fileData  the inputStream for the file data to be sent to Metacat
          *                  in case of upload, otherwise null
          * @param size      the size of the data being sent to Metacat
          *                  in case of upload, otherwise 0
          */
         synchronized private InputStream sendDataOnce(Properties args,
                 Properties filename,
                 InputStream fileData,
                 int size)
                 throws Exception {
             InputStream returnStream = null;
             URL url = new URL(metacatUrl);
             HttpMessage msg = new HttpMessage(url);
             msg.setCookie("JSESSIONID="+this.sessionId);
             if (filename == null){
                 returnStream = msg.sendPostData(args);
             } else if (fileData == null){
                 returnStream = msg.sendPostData(args, filename);
             } else if (size > 0) {
                 returnStream = msg.sendPostData(args, filename, fileData, size);
             } else {
                 throw new MetacatException("Invalid size specified for " +
                         "the input stream being passed");
+            }
             return returnStream;
+        }
         /**
          * Send a request to Metacat
+         *
          * @param args  the properties to be sent to Metacat
          * @param filename  the properties to be sent to Metacat
          *                  in case of upload, otherwise null
          * @param fileData  the inputStream for the file data to be sent to Metacat
          *                  in case of upload, otherwise null
          * @param size      the size of the data being sent to Metacat
          *                  in case of upload, otherwise 0
          * @return      InputStream as returned by Metacat
          */
         synchronized public InputStream sendData(Properties args,
                 Properties filename,
                 InputStream fileData,
                 int size)
                 throws Exception {
             InputStream returnStream = null;
             /*
                 Note:  The reason that there are three try statements all executing
                 the same code is that there is a problem with the initial connection
                 using the HTTPClient protocol handler.  These try statements make
                 sure that a connection is made because it gives each connection a
 nd and 3rd chance to work before throwing an error.
                 THIS IS A TOTAL HACK.  THIS NEEDS TO BE LOOKED INTO AFTER THE BETA1
                 RELEASE OF MORPHO!!!  cwb (7/24/01)
              */
         synchronized public InputStream sendParameters(Properties prop) throws Exception {
             InputStream result = null;
             try {
                 return sendDataOnce(args, filename, fileData, size);
             } catch (Exception e) {
                 try {
                     return sendDataOnce(args, filename, fileData, size);
                 } catch (Exception e2) {
                     try {
                         return sendDataOnce(args, filename, fileData, size);
                     } catch (Exception e3) {
                         System.err.println(
                                 "Failed to send data to metacat 3 times: " + e3.getMessage());
                         System.err.println("metacaturl: " + metacatUrl);
                         throw e3;
+                    }
             	HttpClient httpclient = new DefaultHttpClient();
                 httpclient.getParams().setParameter(
                 		CoreProtocolPNames.PROTOCOL_VERSION,
                 	    HttpVersion.HTTP_1_1);
             	httpclient.getParams().setParameter(
             			CoreProtocolPNames.HTTP_CONTENT_CHARSET,
             			encoding);
                 HttpPost post = new HttpPost(metacatUrl);
                 //set the params
                 List<NameValuePair> nameValuePairs = new ArrayList<NameValuePair>();
                 Enumeration<Object> keys = prop.keys();
                 while (keys.hasMoreElements()) {
                 	String key = (String) keys.nextElement();
                 	String value = prop.getProperty(key);
                 	NameValuePair nvp = new BasicNameValuePair(key, value);
                 	nameValuePairs.add(nvp);
+                }
+            }
+        }
         /**
          * Send a request to Metacat
+         *
          * @param args      the properties to be sent to Metacat
          * @param filename  the properties to be sent to Metacat
          *                  in case of upload, otherwise null
          * @param fileData  the inputStream for the file data to be sent to Metacat
          *                  in case of upload, otherwise null
          * @param size      the size of the data being sent to Metacat
          *                  in case of upload, otherwise 0
          * @return          a string as returned by Metacat
          */
         synchronized private String sendDataForString(Properties args,
                 Properties filename,
                 InputStream fileData,
                 int size)
                 throws Exception {
             String response = null;
             try {
                 InputStreamReader returnStream =
                         new InputStreamReader(sendData(args, filename,
                         fileData, size));
                 StringWriter sw = new StringWriter();
                 int len;
                 char[] characters = new char[512];
                 while ((len = returnStream.read(characters, 0, 512)) != -1) {
                     sw.write(characters, 0, len);
+                }
                 returnStream.close();
                 response = sw.toString();
                 sw.close();
                 post.setEntity(new UrlEncodedFormEntity(nameValuePairs, encoding));
                 post.setHeader("Cookie", "JSESSIONID="+ this.sessionId);
                 HttpResponse httpResponse = httpclient.execute(post);
                 result = httpResponse.getEntity().getContent();
                 //httpclient.getConnectionManager().shutdown();
             } catch (Exception e) {
                 throw e;
                 throw new MetacatInaccessibleException(e.getMessage());
+            }
             return response;
             return result;
+        }
         /*
-...
+            }
             return(result);
+        }
     	public String getEncoding() {
     		return encoding;
+    	}
     	public void setEncoding(String encoding) {
     		this.encoding = encoding;
+    	}
+    }
     class InputStreamKnownSizeBody extends InputStreamBody {
     	private int length;
     	public InputStreamKnownSizeBody(
     			final InputStream in,
     			final String filename,
     			final int length) {
     		super(in, filename);
     		this.length = length;
+    	}
     	@Override
     	public long getContentLength() {
     		return this.length;
+    	}
+    }

          * @throws MetacatException when an error occurs
          */
         public boolean isRegistered(String docid) throws MetacatException;
         /**
          * Returns the character encoding used used when communicating with Metacat.
          * @return character encoding name
          */
         public String getEncoding();
         /**
          * Returns the character encoding used used when communicating with Metacat.
          * @param encoding The encoding (i.e. "UTF-8")
          */
         public void setEncoding(String encoding);
+    }

     		<condition property="utilities.required">
     			<or>
     				<not>
     					<available file="lib/httpclient.jar" />
     				</not>
     				<not>
     					<available file="lib/utilities.jar" />
     				</not>
     				<not>
-...
     		if="utilities.required">
     		<ant dir="${utilitiesdir}" target="clean" inheritAll="false" />
     		<ant dir="${utilitiesdir}" target="jar" inheritAll="false" />
     		<copy file="${utilitiesdir}/lib/httpclient.jar" todir="lib" />
     		<copy file="${utilitiesdir}/build/utilities.jar" todir="lib" />
     	</target>
-...
     		<!-- use the ant "junit" task to run JUnit tests. -->
     		<junit printsummary="yes" haltonfailure="no" fork="yes"
     			haltonerror="no" showoutput="yes">
     			<!--<jvmarg value="-Djava.protocol.handler.pkgs=HTTPClient"/>-->
     			<jvmarg value="-Dfile.encoding=UTF-8"/>
     			<classpath>
     				<path refid="test.classpath" />
-...
     		</junit>
     	</target>
     	<target name="gethttpclient" depends="prepare"
     		description="checks out and compiles morpho httpclient code">
     		<!--mkdir dir="${morphosourcedir}" -->
     		<cvs cvsRoot="${cvsroot}" package="morpho" dest="." />
     		<ant dir="${morphosourcedir}" inheritAll="false" target="jar" />
     	</target>
     	<!-- run this target, we need to check out a another morpho souce dir was checked out. -->
     	<target name="nettest" depends="install"
     		description="compiles and runs the metacatnettest code">
-...
     	<target name="localclean" depends="clean"
     		description="deletes even jars that depend on external sources such as stylesheets and jars">
     		<delete file="lib/httpclient.jar" />
     		<delete file="lib/utilities.jar" />
     	</target>
-...
     		<!--<include name="GenCastor.class" />-->
     	</patternset>
     	<patternset id="lib.jars">
     		<include name="httpclient.jar" />
     		<include name="log4j-1.2.12.jar" />
     		<include name="utilities.jar" />
     		<include name="xerces*.jar" />

Also available in: Unified diff

Project

General

Profile

Metacat

Revision 5914

Added by ben leinfelder over 13 years ago