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

     package jgsscli.cli;
     import java.io.PrintWriter;
     import java.text.DecimalFormat;
     import java.util.Formatter;
     import java.util.List;
     import java.util.logging.ConsoleHandler;
     import java.util.logging.Logger;
     import jgsscli.commands.Event;
     import jgsscli.commands.GSSCmd;
     import jgsscli.commands.Observable;
     import jgsscli.commands.Observer;
     public class GSSClient {
     public class GSSClient implements Observer {
         private static final DecimalFormat FORMAT_TWO_DEC =
     	new DecimalFormat("#.##");
         private static final DecimalFormat FORMAT_ONE_DEC =
     	new DecimalFormat("#.#");
         private static final int TWO_TEN = 1024;
         private static final int MBYTE = TWO_TEN * TWO_TEN;
         private OverwritePrinter progressPrinter = new OverwritePrinter();
         private long transferred = 0;
         public GSSClient() { }
         private void processCmd(String args[]) {
-...
+    	}
     	for (GSSCmd command : commands) {
     	    if (command != null) {
     		command.addObserver(this);
     		command.execute();
     		PrintWriter out = new PrintWriter(System.out);
     		command.printOutput(out);
-...
+    	}
+        }
         public void update(Observable o, Event arg) {
     	Event.Type type = arg.getType();
     	switch (type) {
     	case TRANSFER:
     	    StringBuilder sb = new StringBuilder();
     	    Formatter formatter = new Formatter(sb);
     	    Event.TuplePayload payLoad = (Event.TuplePayload) arg.getPayLoad();
     	    transferred += (Integer) payLoad.getFirst();
     	    long size = (Long) payLoad.getSecond();
     	    float percent = (transferred / (float) size) * 100;
     	    formatter.format("%1$s (%2$.2f%%)",
     		    produceByteCount(transferred), percent);
     	    progressPrinter.print(sb.toString());
     	    break;
+    	}
+        }
         private String produceByteCount(long bytes) {
     	String byteCount;
     	if (bytes > TWO_TEN) {
     	    if (bytes > MBYTE) {
     		byteCount =
     		    FORMAT_ONE_DEC.format(bytes / (MBYTE)) + " Mb";
+    	    }
     	    else byteCount = FORMAT_TWO_DEC.format(bytes / TWO_TEN) + " Kb";
     	} else {
     	    byteCount = Long.toString(bytes);
+    	}
     	return byteCount;
+        }
         public static void main(String args[]) {
     	Logger logger = Logger.getLogger("org.xsocket");
     	//logger.setLevel(Level.FINE);
     	ConsoleHandler ch = new ConsoleHandler();
     	//ch.setLevel(Level.FINE);
     	logger.addHandler(ch);
     	GSSClient gssclient = new GSSClient();
     	gssclient.processCmd(args);
+        }
+        }
+    }

     package jgsscli.cli;
     import java.util.Arrays;
     /**
      * Class for printing output at a single line; each new output overwrites
      * the contents of the line. Can be used for progress lines etc.
      */
     public class OverwritePrinter {
         private String previousString = "";
         public OverwritePrinter() {
+        }
         public void print(String currentString) {
     	int prevLength = previousString.length();
     	char[] overwrite = new char[prevLength];
     	Arrays.fill(overwrite, '\b');
     	String outputString = new String(overwrite) + currentString;
     	System.out.print(outputString);
     	previousString = outputString;
+        }
+    }

     package jgsscli.commands;
     public class Event {
         public static enum Type { TRANSFER, FINISH };
         private Type type;
         private Object payLoad;
         public Event(Type type, Object payLoad) {
     	this.type = type;
     	this.payLoad = payLoad;
+        }
         public Type getType() {
     	return this.type;
+        }
         public void setPayLoad(Object payLoad) {
     	this.payLoad = payLoad;
+        }
         public Object getPayLoad() {
     	return payLoad;
+        }
         public static class TuplePayload {
     	private Object first;
     	private Object second;
     	public TuplePayload(Object first, Object second) {
     	    this.setFirst(first);
     	    this.setSecond(second);
+    	}
     	public Object getFirst() {
     	    return first;
+    	}
     	public void setFirst(Object first) {
     	    this.first = first;
+    	}
     	public Object getSecond() {
     	    return second;
+    	}
     	public void setSecond(Object second) {
     	    this.second = second;
+    	}
+        }
+    }

      * Interface for GSS commands. A command is something that can be executed,
      * and returns a value depending on the execution outcome.
      */
     public abstract class GSSCmd {
     public abstract class GSSCmd implements Observer, Observable {
         private UserInfo userInfo;
         private Date date;
-...
         private StatusCode statusCode;
         private HttpMethod request;
         private Log log;
         private Observable observableDelegate = new ObservableDelegate(this);
         public GSSCmd(UserInfo userInfo, Date date, String remotePath,
     	    String localPath) {
-...
         public void setLog(Log log) {
     	this.log = log;
+        }
         public void addObserver(Observer o) {
     	observableDelegate.addObserver(o);
+        }
         public int countObservers() {
     	return observableDelegate.countObservers();
+        }
         public void deleteObserver(Observer o) {
     	observableDelegate.deleteObserver(o);
+        }
         public void deleteObservers() {
     	observableDelegate.deleteObservers();
+        }
         public void notifyObservers(Event arg) {
     	observableDelegate.notifyObservers(arg);
+        }
         public void update(Observable o, Event arg) {
     	notifyObservers(arg);
+        }
+    }

     package jgsscli.commands;
     public interface Observable {
         void addObserver(Observer o);
         int countObservers();
         void deleteObserver(Observer o);
         void deleteObservers();
         void notifyObservers(Event arg);
+    }

     package jgsscli.commands;
     import java.util.HashSet;
     import java.util.Set;
     public class ObservableDelegate implements Observable {
         private Observable delegator;
         private Set<Observer> observers = new HashSet<Observer>();
         public ObservableDelegate(Observable delegator) {
     	this.delegator = delegator;
+        }
         public void addObserver(Observer o) {
     	observers.add(o);
+        }
         public int countObservers() {
     	return observers.size();
+        }
         public void deleteObserver(Observer o) {
     	observers.remove(o);
+        }
         public void deleteObservers() {
     	observers.clear();
+        }
         public void notifyObservers(Event arg) {
     	for (Observer o : observers) {
     	    o.update(delegator, arg);
+    	}
+        }
+    }

b/java/jgsscli/src/jgsscli/commands/Observer.java
	1	package jgsscli.commands;
	2
	3	public interface Observer {
	4	public void update(Observable o, Event arg);
	5	}

     package jgsscli.commands;
     import java.util.Arrays;
     /**
      * Class for printing output at a single line; each new output overwrites
      * the contents of the line. Can be used for progress lines etc.
      */
     public class OverwritePrinter {
         private String previousString = "";
         public OverwritePrinter() {
+        }
         public void print(String currentString) {
     	int prevLength = previousString.length();
     	char[] overwrite = new char[prevLength];
     	Arrays.fill(overwrite, '\b');
     	String outputString = new String(overwrite) + currentString;
     	System.out.print(outputString);
     	previousString = outputString;
+        }
+    }

     import java.io.File;
     import java.io.PrintWriter;
     import java.io.RandomAccessFile;
     import java.text.DecimalFormat;
     import java.util.Date;
     import java.util.Formatter;
     import jgsscli.cli.Messages;
     import jgsscli.cli.UserInfo;
-...
      * as the local file. If the target is null or an empty string it is assumed
      * to be the home directory of the user at GSS.
      */
     public class PutFileCmd extends GSSCmd implements ProgressListener {
     public class PutFileCmd extends GSSCmd {
         private OverwritePrinter progressPrinter;
         private long fileLength;
         public PutFileCmd(UserInfo userInfo, Date date, String remotePath,
-...
     	if (remotePath == null || remotePath.isEmpty()) {
     	    setRemotePath(GSSUtils.GSS_FILEPATH_SEPARATOR);
+    	}
     	this.progressPrinter = new OverwritePrinter();
+        }
         protected Method getMethod() {
-...
     		HttpMethodFactory.Scheme.HTTP,
     		GSSUtils.GSS_HOME,
     		getDate(), getUserInfo(), getRemotePath(), getLocalPath());
     	method.setProgressListener(this);
     	method.addObserver(this);
     	StatusCode statusCode = method.execute();
     	setStatusCode(statusCode);
     	return statusCode;
+        }
         public void update(Observable o, Event arg) {
     	int bytes = (Integer) arg.getPayLoad();
     	Event.TuplePayload payload =
     	    new Event.TuplePayload(bytes, this.fileLength);
     	Event newArg = new Event(Event.Type.TRANSFER, payload);
     	notifyObservers(newArg);
+        }
         public void printOutput(PrintWriter out) {
     	String message = getRemotePath() + " " + getStatusCode().code() + ": ";
     	Messages messages = Messages.getInstance();
-...
     	out.println(message);
+        }
         private String produceByteCount(long bytes) {
     	String byteCount;
     	DecimalFormat decFormatTwo = new DecimalFormat("#.##");
     	DecimalFormat decFormatOne = new DecimalFormat("#.#");
     	if (bytes > 1024) {
     	    if (bytes > 1024 * 1024) {
     		byteCount =
     		    decFormatOne.format(bytes / (1024.0 * 1024)) + " Mb";
+    	    }
     	    else byteCount = decFormatTwo.format(bytes / 1024.0) + " Kb";
     	} else {
     	    byteCount = Long.toString(bytes);
+    	}
     	return byteCount;
+        }
         public void transferred(long bytesTransferred) {
     	StringBuilder sb = new StringBuilder();
     	Formatter formatter = new Formatter(sb);
     	float percent = (bytesTransferred / (float) this.fileLength) * 100;
     	formatter.format("%1$s (%2$.2f%%)",
     		produceByteCount(bytesTransferred), percent);
     	progressPrinter.print(sb.toString());
+        }
         public static void main(String[] args)  {
     	Log log = LogFactory.getLog(PutFileCmd.class + "#Main");

     package jgsscli.httpmethods;
     import java.io.BufferedOutputStream;
     import java.io.IOException;
     import java.io.OutputStream;
     import jgsscli.commands.ProgressListener;
     import jgsscli.commands.Event;
     import jgsscli.commands.Observable;
     import jgsscli.commands.ObservableDelegate;
     import jgsscli.commands.Observer;
     import org.apache.http.HttpEntity;
     import org.apache.http.entity.HttpEntityWrapper;
     /**
+     *
      * Adapted from
      * http://stackoverflow.com/questions/254719/file-upload-with-java-with-progress-bar
      */
     public class CountingHttpEntity extends HttpEntityWrapper {
     public class CountingHttpEntity extends HttpEntityWrapper
     implements Observable, Observer {
         private ProgressListener listener;
         public CountingHttpEntity(HttpEntity wrapped, ProgressListener listener) {
         private Observable observableDelegate = new ObservableDelegate(this);
         public CountingHttpEntity(HttpEntity wrapped) {
     	super(wrapped);
     	this.listener = listener;
+        }
         public void writeTo(OutputStream outstream)
         throws IOException {
     	wrappedEntity.writeTo(new CountingOutputStream(outstream, listener));
     	CountingOutputStream countingOutStream =
     	    new CountingOutputStream(outstream);
     	countingOutStream.addObserver(this);
     	wrappedEntity.writeTo(countingOutStream);
+        }
         public static class CountingOutputStream extends BufferedOutputStream {
             private long transferred;
             private ProgressListener listener;
             public CountingOutputStream(final OutputStream out,
             	final ProgressListener listener) {
                 super(out);
                 this.listener = listener;
                 this.transferred = 0;
+            }
             public void write(byte[] b, int off, int len) throws IOException {
                 super.write(b, off, len);
                 this.transferred += len;
                 this.listener.transferred(this.transferred);
+            }
+        }
         public void addObserver(Observer o) {
     	observableDelegate.addObserver(o);
+        }
         public int countObservers() {
     	return observableDelegate.countObservers();
+        }
         public void deleteObserver(Observer o) {
     	observableDelegate.deleteObserver(o);
+        }
         public void deleteObservers() {
     	observableDelegate.deleteObservers();
+        }
         public void notifyObservers(Event arg) {
     	observableDelegate.notifyObservers(arg);
+        }
         public void update(Observable o, Event arg) {
     	notifyObservers(arg);
+        }
+    }

     package jgsscli.httpmethods;
     import java.io.BufferedOutputStream;
     import java.io.IOException;
     import java.io.OutputStream;
     import jgsscli.commands.Event;
     import jgsscli.commands.Observable;
     import jgsscli.commands.ObservableDelegate;
     import jgsscli.commands.Observer;
     public class CountingOutputStream extends BufferedOutputStream
     implements Observable {
         private long transferred;
         private Observable observableDelegate = new ObservableDelegate(this);
         public CountingOutputStream(final OutputStream out) {
     	super(out);
     	this.transferred = 0;
+        }
         public void write(byte[] b, int off, int len) throws IOException {
     	super.write(b, off, len);
     	this.transferred += len;
     	notifyObservers(new Event(Event.Type.TRANSFER, len));
+        }
         public void addObserver(Observer o) {
     	observableDelegate.addObserver(o);
+        }
         public int countObservers() {
     	return observableDelegate.countObservers();
+        }
         public void deleteObserver(Observer o) {
     	observableDelegate.deleteObserver(o);
+        }
         public void deleteObservers() {
     	observableDelegate.deleteObservers();
+        }
         public void notifyObservers(Event arg) {
     	observableDelegate.notifyObservers(arg);
+        }
         public void update(Observable o, Event arg) {
     	notifyObservers(arg);
+        }
+    }

     import java.io.File;
     import java.io.FileOutputStream;
     import jgsscli.commands.ProgressListener;
     import jgsscli.commands.Event;
     import jgsscli.commands.Observable;
     import jgsscli.commands.ObservableDelegate;
     import jgsscli.commands.Observer;
     import org.apache.http.HttpResponse;
     import org.apache.http.client.HttpClient;
-...
      * Class that encapsulates an HTTP method.
+     *
      */
     public abstract class HttpMethod {
     public abstract class HttpMethod implements Observable, Observer {
         public static enum Method {GET, HEAD, POST, PUT, DELETE};
-...
         private HttpRequestBase request;
         private HttpResponse response;
         private ProgressListener progressListener;
         private Log log;
         private Log log;
         private Observable observableDelegate = new ObservableDelegate(this);
         protected HttpMethod(Method method, String uri, String localPath) {
     	this.log = LogFactory.getLog(this.getClass());
-...
     	this.request = request;
+        }
         public void setProgressListener(ProgressListener progressListener) {
     	this.progressListener = progressListener;
+        }
         public ProgressListener getProgressListener() {
     	return progressListener;
+        }
         public void addHeader(String name, String value) {
     	this.request.addHeader(name, value);
+        }
-...
     	return sb.toString();
+        }
         public void addObserver(Observer o) {
     	observableDelegate.addObserver(o);
+        }
         public int countObservers() {
     	return observableDelegate.countObservers();
+        }
         public void deleteObserver(Observer o) {
     	observableDelegate.deleteObserver(o);
+        }
         public void deleteObservers() {
     	observableDelegate.deleteObservers();
+        }
         public void notifyObservers(Event arg) {
     	observableDelegate.notifyObservers(arg);
+        }
         public void update(Observable o, Event arg) {
     	notifyObservers(arg);
+        }
+    }

     import java.io.File;
     import jgsscli.commands.ProgressListener;
     import org.apache.http.HttpEntity;
     import org.apache.http.client.methods.HttpPut;
     import org.apache.http.entity.FileEntity;
-...
     	if (localPath != null) {
     	    File file = new File(localPath);
     	    HttpPut putRequest = new HttpPut(uri);
     	    FileEntity entity = new FileEntity(file, "binary/octet-stream");
     	    putRequest.setEntity(entity);
     	    FileEntity fileEntity =
     		new TurboFileEntity(file, "binary/octet-stream");
     	    CountingHttpEntity countingEntity =
     		new CountingHttpEntity(fileEntity);
     	    countingEntity.addObserver(this);
     	    putRequest.setEntity(countingEntity);
     	    setRequest(putRequest);
+    	}
+        }
         public void setProgressListener(ProgressListener listener) {
     	super.setProgressListener(listener);
     	HttpPut putRequest = (HttpPut) this.getRequest();
     	HttpEntity entity = putRequest.getEntity();
     	CountingHttpEntity countingEntity =
     	    new CountingHttpEntity(entity, listener);
     	putRequest.setEntity(countingEntity);
+        }
+    }

     package jgsscli.httpmethods;
     import java.io.File;
     import java.io.FileInputStream;
     import java.io.IOException;
     import java.io.InputStream;
     import java.io.OutputStream;
     import org.apache.http.entity.FileEntity;
     public class TurboFileEntity extends FileEntity {
         public TurboFileEntity(final File file, final String contentType) {
     	super(file, contentType);
+        }
         public void writeTo(final OutputStream outstream)
         throws IOException {
     	if (outstream == null) {
     	    throw new IllegalArgumentException("Output stream may not be null");
+    	}
     	InputStream instream = new FileInputStream(this .file);
     	try {
     	    byte[] tmp = new byte[4096 * 4096];
     	    int l;
     	    while ((l = instream.read(tmp)) != -1) {
     		outstream.write(tmp, 0, l);
+    	    }
     	    outstream.flush();
     	} finally {
     	    instream.close();
+    	}
+        }
+    }

Pithos_GSS » Java GSS CLI Client

Revision 76:b4fce4e13ec9