/ - Diff - Java GSS CLI Client - Greek Research and Technology Network's projects

+        }
         private void processGSSCommands(String args[]) {
     	if (args.length == 0)
     	    return;
     	int statusCode = -1;
     	if (args[0].equals("get-token")) {
     	    if (!(args.length == 4)) {
-...
+    	}
     	GSSCmd cmd = (GSSCmd) GSSCmdFactory.getInstance().getGSSCmdInstance(args,
     		client, userInfo);
     	statusCode = cmd.execute();
     	System.out.println(HttpStatus.getStatusText(statusCode));
     //	for (int i = 1; i < args.length; i++) {
     //	    GetFileCmd cmd = GetFileCmd.getInstance(client,
     //		    userInfo,
     //		    new Date(),
     //		    args[i]);
     //	    statusCode = cmd.execute();
     //
     //	}
     	// The cmd may be null when the command line is wrong
     	if (cmd != null) {
     	    statusCode = cmd.execute();
     	    System.out.println(HttpStatus.getStatusText(statusCode));
+    	}
+        }
         private void processCmd(CommandLine line) {

     import org.apache.commons.httpclient.HttpClient;
     import org.apache.commons.io.filefilter.WildcardFileFilter;
     import org.apache.commons.logging.Log;
     import org.apache.commons.logging.LogFactory;
     public class GSSCmdFactory {
-...
         private static class PutFileCmdFactory extends GSSCmdFactory {
     	private static final PutFileCmdFactory INSTANCE =
     	    new PutFileCmdFactory();
     	private Log log;
     	private PutFileCmdFactory() {
     	    log = LogFactory.getLog(this.getClass());
+    	}
     	public static PutFileCmdFactory getInstance() {
-...
     		    if (name == null)
     			continue;
     		    File dir = file.getParentFile();
     		    if (dir == null)
     			continue;
     		    FileFilter filter = new WildcardFileFilter(name);
     		    File[] filteredFiles = dir.listFiles(filter);
     		    if (filteredFiles == null)
     			continue;
     		    for (File filteredFile : filteredFiles) {
     			cmd.add(new PutFileCmd(client, userInfo, new Date(),
     				args[args.length - 1],
-...
+    		    }
+    		}
+    	    }
     	    return cmd;
     	    if (cmd.isEmpty()) {
     		return null;
     	    } else {
     		return cmd;
+    	    }
+    	}
+        }
+     }

     package gssclient.commands;
     import java.util.ArrayList;
     import java.util.List;
     /**
      * Composite command, allowing multiple commands to be executed together.
      * The return value of the group of commands will be the return value
      * of the command that executed last.
+     *
      */
     public class CompositeCmd implements GSSCmd {
         // Collection of child commands
         private List<GSSCmd> childCommands = new ArrayList<GSSCmd>();
         public int execute() {
     	int returnVal = -1;
     	for (GSSCmd cmd : childCommands) {
     	    returnVal = cmd.execute();
+    	}
     	return returnVal;
+        }
         public void add(GSSCmd cmd) {
     	childCommands.add(cmd);
+        }
         public void remove(GSSCmd cmd) {
     	childCommands.remove(cmd);
+        }
         public boolean isEmpty() {
     	return childCommands.isEmpty();
+        }
+    }

     package gssclient.commands;
     /**
      * Interface for GSS commands. A command is something that can be executed,
      * and returns a value depending on the execution outcome.
      */
     public interface GSSCmd {
         public int execute();
+    }

     package gssclient.commands;
     import java.io.IOException;
     import java.util.Date;
     import gssclient.UserInfo;
     import gssclient.httpmethods.HeadMethodFactory;
     import gssclient.httpmethods.HttpMethodFactory;
     import org.apache.commons.httpclient.Header;
     import org.apache.commons.httpclient.HttpClient;
     import org.apache.commons.httpclient.HttpException;
     import org.apache.commons.httpclient.HttpStatus;
     import org.apache.commons.httpclient.methods.HeadMethod;
     import org.apache.commons.logging.Log;
     import org.apache.commons.logging.LogFactory;
     import org.json.JSONException;
     import org.json.JSONObject;
     /**
      * General utility classes for GSS.
+     *
      */
     public class GSSUtils {
         private static final Log log = LogFactory.getLog(GSSUtils.class);
         public static final String X_GSS_METADATA_HEADER = "X-GSS-Metadata";
         public static final String GSS_HOME = "pithos.grnet.gr";
         /** The version JSON tag distinguishes between files and directories. */
         private static final String VERSION_HEADER = "version";
         /** The file path separator in GSS. */
         public static final String GSS_FILEPATH_SEPARATOR = "/";
         private static final GSSUtils INSTANCE = new GSSUtils();
         private int statusCode;
         private GSSUtils() {
     	this.statusCode = -1;
+        }
         public static GSSUtils getInstance() {
     	return INSTANCE;
+        }
         public int getStatusCode() {
     	return this.statusCode;
+        }
         /**
          * Returns true if the specified path represents a directory on GSS.
+         *
          * @param client the HTTP client object that will be used to execute
          * the required methods.
          * @param date the date time stamp that will be used in the HTTP methods.
          * @param userInfo the user information object.
          * @param path The path we want to check.
          * @param scratch A scratch pad passed by the calling method which will be
          * filled in with the JSON object that came back from the GSS method call.
          * It can be null if we are not interested in something like that.
          * @return true if the specified path represents a directory on GSS.
          */
         public boolean isDir(HttpClient client, Date date, UserInfo userInfo,
     	    String path, Scratch<JSONObject> scratch){
     	boolean isDir = false;
     	HeadMethod headMethod = HeadMethodFactory.getInstance()
     		.generateMethod(HttpMethodFactory.Scheme.HTTP, GSS_HOME,
     			date, userInfo, path, null);
     	try {
     	    // Execute the method.
     	    log.debug("Start method execution " + headMethod.getName());
     	    this.statusCode = client.executeMethod(headMethod);
     	    log.debug("End method execution " + headMethod.getName()
     		    + " status code=" + this.statusCode);
     	    if (this.statusCode != HttpStatus.SC_OK)
     		return isDir;
     	    Header gssMetaDataHeader =
     		headMethod.getResponseHeader(X_GSS_METADATA_HEADER);
     	    JSONObject gssMetaData =
     		new JSONObject(gssMetaDataHeader.getValue());
     	    if (scratch != null)
     		scratch.setContents(gssMetaData);
     	    if (!gssMetaData.has(VERSION_HEADER)) {
     		isDir = true;
     	    } else {
     		isDir = false;
+    	    }
     	} catch (HttpException e) {
     	    System.err.println("Fatal protocol violation: " + e.getMessage());
     	    e.printStackTrace();
     	} catch (IOException e) {
     	    System.err.println("Fatal transport error: " + e.getMessage());
     	    e.printStackTrace();
     	} catch (JSONException jex) {
     	    System.err.println("Fatal JSON Exception: " + jex.getMessage());
     	} finally {
     	    // Release the connection.
     	    headMethod.releaseConnection();
+    	}
     	return isDir;
+        }
         /**
          * A helper class that contains arbitrary data. To be used so that calling
          * methods can pass a scratch pad where called methods can put in data
          * other than the return value.
+         *
          * @param <T> The type of content data
          */
         public static class Scratch<T> {
     	T contents;
     	void setContents(T scratch) {
     	    this.contents = scratch;
+    	}
     	T getContents() {
     	    return this.contents;
+    	}
+        }
+    }

b/java/gssclient/src/gssclient/commands/GetFileCmd.java
90	90	int statusCode = cmd.execute();
91	91	System.out.println(HttpStatus.getStatusText(statusCode));
92	92	}
	93
	94
93	95	}
94	96

     	this.username = username;
     	this.passwd = passwd;
+        }
         public int execute() {
     	int statusCode = HttpStatus.SC_OK;
     	NaiveTrustProvider.setAlwaysTrust(Boolean.TRUE);

     import gssclient.ShibAuthException;
     import gssclient.UserInfo;
     import gssclient.httpmethods.GetMethodFactory;
     import gssclient.httpmethods.HeadMethodFactory;
     import gssclient.httpmethods.HttpMethodFactory;
     import java.io.IOException;
     import java.util.Date;
     import org.apache.commons.httpclient.Header;
     import org.apache.commons.httpclient.HttpClient;
     import org.apache.commons.httpclient.HttpException;
     import org.apache.commons.httpclient.HttpStatus;
     import org.apache.commons.httpclient.methods.GetMethod;
     import org.apache.commons.httpclient.methods.HeadMethod;
     import org.apache.commons.logging.Log;
     import org.apache.commons.logging.LogFactory;
     import org.json.JSONException;
     import org.json.JSONObject;
     public class ListPropertiesCmd implements GSSCmd {
-...
         private String path;
         private String localPath;
         private Log log;
         private static final String X_GSS_METADATA_HEADER = "X-GSS-Metadata";
         JSONObject gssMetaData;
         public ListPropertiesCmd(HttpClient client, UserInfo userInfo, Date date,
     	    String path, String localPath) {
     	this.client = client;
-...
     	this.path = path;
+        }
         public JSONObject getGSSMetaData() {
     	return this.gssMetaData;
+        }
         public int execute() {
     	int statusCode = -1;
     	HeadMethod headMethod = HeadMethodFactory.getInstance()
     		.generateMethod(HttpMethodFactory.Scheme.HTTP,
     		"pithos.grnet.gr",
     		date, userInfo, path, localPath);
     	JSONObject gssMetaData = null;
     	GetMethod getMethod = null;
     	try {
     	    // Execute the method.
     	    log.debug("Start method execution " + headMethod.getName());
     	    statusCode = client.executeMethod(headMethod);
     	    log.debug("End method execution " + headMethod.getName());
     	    if (statusCode != HttpStatus.SC_OK)
     		return statusCode;
     	    // Read the response headers first, to determine if we
     	    // are dealing with a file or a directory.
     	    Header gssMetaDataHeader =
     		headMethod.getResponseHeader(X_GSS_METADATA_HEADER);
     		gssMetaData = new JSONObject(gssMetaDataHeader.getValue());
     		if (!gssMetaData.has("version")) { // Dir
     		    GetMethod getMethod = GetMethodFactory.getInstance()
     	    GSSUtils.Scratch<JSONObject> scratch =
     		new GSSUtils.Scratch<JSONObject>();
     	    GSSUtils utils = GSSUtils.getInstance();
     	    if (!utils.isDir(client, date, userInfo, path, scratch)) {
     		statusCode = utils.getStatusCode();
     		this.gssMetaData = scratch.getContents();
     	    } else {
     		getMethod = GetMethodFactory.getInstance()
     		    	.generateMethod(HttpMethodFactory.Scheme.HTTP,
     				"pithos.grnet.gr",
     				GSSUtils.GSS_HOME,
     				date, userInfo, path, localPath);
     		    log.debug("Start method execution " + getMethod.getName());
     		    statusCode = client.executeMethod(getMethod);
     		    log.debug("End method execution " + getMethod.getName());
     		    if (statusCode != HttpStatus.SC_OK)
     			return statusCode;
     		    gssMetaData =
     			new JSONObject(getMethod.getResponseBodyAsString());
     		log.debug("Start method execution " + getMethod.getName());
     		statusCode = client.executeMethod(getMethod);
     		log.debug("End method execution " + getMethod.getName());
     		if (statusCode != HttpStatus.SC_OK) {
     		    return statusCode;
     		} else {
     		    this.gssMetaData =
     			new JSONObject(getMethod.getResponseHeader(GSSUtils.X_GSS_METADATA_HEADER));
+    		}
+    	    }
     	} catch (HttpException e) {
     	    System.err.println("Fatal protocol violation: " + e.getMessage());
     	    e.printStackTrace();
     	} catch (IOException e) {
     	    System.err.println("Fatal transport error: " + e.getMessage());
     	    e.printStackTrace();
     	} catch (JSONException jex) {
     	    System.err.println("Fatal JSON Exception: " + jex.getMessage());
     	} finally {
     	    // Release the connection.
     	    headMethod.releaseConnection();
     	    // Release the connections.
     	    if (getMethod != null)
     		getMethod.releaseConnection();
+    	}
     	System.out.println(gssMetaData);
     	return statusCode;
+        }
-...
             HttpClient client = new HttpClient();
     	ListPropertiesCmd cmd = new ListPropertiesCmd(client, userInfo,
     		new Date(), "test.txt", null);
     	ListPropertiesCmd cmd =
     	    new ListPropertiesCmd(client, userInfo, new Date(),
     		    "test.txt", null);
     	int statusCode = cmd.execute();
     	System.out.println(HttpStatus.getStatusText(statusCode));
     	System.out.println(cmd.getGSSMetaData());
     	cmd.setPath("");
     	statusCode = cmd.execute();
     	System.out.println(HttpStatus.getStatusText(statusCode));
     	System.out.println(cmd.getGSSMetaData());
+        }
+    }

     import org.apache.commons.logging.Log;
     import org.apache.commons.logging.LogFactory;
     /**
      * Command to put (upload) files to GSS. Creates the necessary REST call and
      * executes it.
+     *
      * The target can be a fully specified filename, or a directory. When it is a
      * directory, the file is uploaded in the target directory with the same name
      * as the local file.
      */
     public class PutFileCmd implements GSSCmd {
         private HttpClient client;
-...
         public int execute() {
     	int statusCode = -1;
     	GSSUtils utils = GSSUtils.getInstance();
     	if (utils.isDir(client, date, userInfo, path, null)) {
     	    File localFile = new File(localPath);
     	    path = path
     	    	+ (path.endsWith(GSSUtils.GSS_FILEPATH_SEPARATOR)
     	    		? ""
     	    		: GSSUtils.GSS_FILEPATH_SEPARATOR)
     	    	+ localFile.getName();
+    	}
     	PutMethod method = PutMethodFactory.getInstance()
     		.generateMethod(HttpMethodFactory.Scheme.HTTP,
     			"pithos.grnet.gr",
     			GSSUtils.GSS_HOME,
     			date, userInfo, path, localPath);
     	log.debug("PUT from=" + localPath + " to=" + path);

     package gssclient.httpmethods;
     import gssclient.UserInfo;
     import gssclient.commands.GSSUtils;
     import java.io.UnsupportedEncodingException;
     import java.net.URLEncoder;
-...
     public abstract class HttpMethodFactory {
         public static enum Scheme { HTTP, HTTPS };
         public static final String HOST = "http://pithos.grnet.gr";
         public static final String HOST = "http://" + GSSUtils.GSS_HOME;
         public static final String REST_PREFIX = "/pithos/rest";
         public static final String PATH_PREFIX = HOST + REST_PREFIX;
         private static final String HMAC_SHA1 = "HmacSHA1";

Pithos_GSS » Java GSS CLI Client

Revision 40:362278eba9aa