tools/ExperimentSynchronizer/src/gov/anl/dm/esafsync/serviceconn/NoOpTrustManager.java

+package gov.anl.dm.esafsync.serviceconn;
+
+
+import java.security.cert.X509Certificate;
+import javax.net.ssl.X509TrustManager;
+
+/**
+ * Dummy trust manager class.
+ *
+ * A trivial implementation of <code>X509TrustManager</code> that doesn't
+ * actually check the validity of a certificate. This allows us to make SSL
+ * connections to internal servers without requiring the installation and
+ * maintenance of certificates in the client keystore.
+ *
+ * @see NoServerVerificationSSLSocketFactory
+ */
+public class NoOpTrustManager implements X509TrustManager {
+
+    @Override
+    public void checkClientTrusted(X509Certificate[] cert, String authType) {
+    }
+
+    @Override
+    public void checkServerTrusted(X509Certificate[] cert, String authType) {
+    }
+
+    @Override
+    public X509Certificate[] getAcceptedIssuers() {
+        return new X509Certificate[0];
+    }
+}

tools/ExperimentSynchronizer/src/gov/anl/dm/esafsync/serviceconn/NoServerVerificationSSLSocketFactory.java

+package gov.anl.dm.esafsync.serviceconn;
+
+import java.io.IOException;
+import java.net.InetAddress;
+import java.net.Socket;
+import java.security.KeyManagementException;
+import java.security.NoSuchAlgorithmException;
+import javax.net.SocketFactory;
+import javax.net.ssl.SSLContext;
+import javax.net.ssl.SSLSocketFactory;
+import javax.net.ssl.TrustManager;
+
+/**
+ * SSL socket factory that does not verify server credentials.
+ *
+ * A minor extension of <code>SSLSocketFactory</code> that installs a dummy
+ * trust manager. This allows creation of SSL sockets that don't verify the
+ * server certificates.
+ *
+ * @see NoOpTrustManager
+ */
+public class NoServerVerificationSSLSocketFactory extends SSLSocketFactory {
+
+    private SSLSocketFactory factory;
+
+    /**
+     * Default constructor.
+     */
+    public NoServerVerificationSSLSocketFactory() {
+        try {
+            TrustManager tm = new NoOpTrustManager();
+            SSLContext sslcontext = SSLContext.getInstance("TLS");
+            sslcontext.init(null, // No KeyManager required
+                    new TrustManager[]{tm},
+                    new java.security.SecureRandom());
+
+            factory = (SSLSocketFactory) sslcontext.getSocketFactory();
+        } catch (KeyManagementException | NoSuchAlgorithmException ex) {
+            ex.printStackTrace();
+        }
+    }
+
+    /**
+     * Get default (no server verification) socket factory.
+     *
+     * @return socket factory
+     */
+    public static SocketFactory getDefault() {
+        return new NoServerVerificationSSLSocketFactory();
+    }
+
+    /**
+     * Create SSL socket layered over an existing socket connected to the named
+     * host, at a given port.
+     *
+     * @param socket existing socket
+     * @param host
+     * @param port
+     * @param autoClose
+     * @return created socket
+     * @throws IOException in case of IO errors
+     */
+    @Override
+    public Socket createSocket(Socket socket, String host, int port, boolean autoClose)
+            throws IOException {
+        return factory.createSocket(socket, host, port, autoClose);
+    }
+
+    /**
+     * Create a socket and connect it to the specified remote address/port, and
+     * bind it to the specified local address/port.
+     *
+     * @param address server network address
+     * @param port server port
+     * @param localAddress client network address
+     * @param localPort client port
+     * @return created socket
+     * @throws IOException in case of IO errors
+     */
+    @Override
+    public Socket createSocket(InetAddress address, int port, InetAddress localAddress, int localPort)
+            throws IOException {
+        return factory.createSocket(address, port, localAddress, localPort);
+    }
+
+    /**
+     * Create a socket and connect it to the specified remote address/port.
+     *
+     * @param address server network address
+     * @param port server port
+     * @return created socket
+     * @throws IOException in case of IO errors
+     */
+    @Override
+    public Socket createSocket(InetAddress address, int port) throws IOException {
+        return factory.createSocket(address, port);
+    }
+
+    /**
+     * Create a socket and connect it to the specified remote host/port, and
+     * bind it to the specified local address/port.
+     *
+     * @param host server host
+     * @param port server port
+     * @param localAddress client network address
+     * @param localPort client port
+     * @return created socket
+     * @throws IOException in case of IO errors
+     */
+    @Override
+    public Socket createSocket(String host, int port, InetAddress localAddress, int localPort)
+            throws IOException {
+        return factory.createSocket(host, port, localAddress, localPort);
+    }
+
+    /**
+     * Create a socket and connect it to the specified remote host/port, and
+     * bind it to the specified local address/port.
+     *
+     * @param host server host
+     * @param port server port
+     * @return created socket
+     * @throws IOException in case of IO errors
+     */
+    @Override
+    public Socket createSocket(String host, int port) throws IOException {
+        return factory.createSocket(host, port);
+    }
+
+    /**
+     * Get default cipher suites from socket factory.
+     *
+     * @return list of default ciphers
+     */
+    @Override
+    public String[] getDefaultCipherSuites() {
+        return factory.getSupportedCipherSuites();
+    }
+
+    /**
+     * Get supported cipher suites from socket factory.
+     *
+     * @return list of supported ciphers
+     */
+    @Override
+    public String[] getSupportedCipherSuites() {
+        return factory.getSupportedCipherSuites();
+    }
+
+}

tools/ExperimentSynchronizer/src/gov/anl/dm/esafsync/serviceconn/ServiceConnection.java

+package gov.anl.dm.esafsync.serviceconn;
+
+import java.io.BufferedReader;
+import java.io.DataOutputStream;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.UnsupportedEncodingException;
+import java.net.ConnectException;
+import java.net.MalformedURLException;
+import java.net.ProtocolException;
+import java.net.URL;
+import java.net.URLEncoder;
+// import java.util.Base64;
+import java.util.HashMap;
+import java.util.Map;
+import javax.xml.bind.DatatypeConverter;
+
+
+import javax.net.ssl.HttpsURLConnection;
+import javax.swing.JOptionPane;
+
+public class ServiceConnection {
+
+	class DmHttpHeaders {
+		static final String DM_SET_COOKIE_HEADER = "Set-Cookie";
+		final static String DM_SESSION_ROLE_HTTP_HEADER = "Dm-Session-Role";
+		final static String DM_STATUS_CODE_HTTP_HEADER = "Dm-Status-Code";
+		final static String DM_STATUS_MESSAGE_HTTP_HEADER = "Dm-Status-Message";
+		final static String DM_EXCEPTION_TYPE_HTTP_HEADER = "Dm-Exception-Type";
+	}
+
+	class DmHttpStatus {
+		static final int DM_HTTP_OK = 200;
+		static final int DM_HTTP_UNAUTHORIZED = 401;
+		static final int DM_HTTP_INTERNAL_ERROR = 500; 
+	}
+
+	class StorageServUrl {
+		static final String LOGIN_REQUEST = "/login";
+	}
+
+	class DmStatus {
+		static final int DM_OK = 0;
+		static final int DM_ERROR = 1;
+		static final int DM_INTERNAL_ERROR = 2;
+		static final int DM_COMMUNICATION_ERROR = 3; 
+		static final int DM_CONFIGURATION_ERROR = 4;
+		static final int DM_AUTHORIZATION_ERROR = 5;
+		static final int DM_AUTHENTICATION_ERROR = 6;
+		static final int DM_DB_ERROR = 7;
+		static final int DM_URL_ERROR = 8; 
+		static final int DM_TIMEOUT = 9;
+		static final int DM_INVALID_ARGUMENT = 10;
+		static final int DM_INVALID_REQUEST = 11;
+		static final int DM_INVALID_SESSION = 12;    
+		static final int DM_COMMAND_FAILED =13;
+		static final int DM_OBJECT_NOT_FOUND = 14;
+		static final int DM_OBJECT_ALREADY_EXISTS = 15;
+		static final int DM_INVALID_OBJECT_STATE = 16;
+	}
+	
+	class Keyword {
+		static final String USERNAME = "username";
+		static final String PASSWORD = "password";
+	}
+	
+	public class ServiceConnectionStatus {
+		public static final int SUCCESS = 0;
+		public static final int AUTHENTICATION_ERROR = -2;		
+		public static final int AUTHORIZATION_ERROR = -3;		
+		public static final int INVALID_OPERATION = -4;		
+		public static final int CONNECTION_ERROR = -5;		
+		public static final int PROTOCOL_ERROR = -6;		
+		public static final int ERROR = -1;		
+	}
+	
+	private final class Login {
+		private String username;
+		private String password;
+		
+		private Login(String username, String password) {
+			this.username = username;
+			this.password = password;
+		}
+		private void clear() {
+			this.username = null;
+			this.password = null;			
+		}
+		private int login() {
+			int result = ServiceConnection.this.login(username, password);
+			clear();
+			return result;
+		}
+	}
+	
+	static final String ESAF_EXPERIMENT_TYPE = "1";
+
+    protected URL serviceUrl;
+    private Session session = new Session();
+    private Login login;
+    private boolean initialized = false;
+
+    public final int init(String serviceUrl) {
+        if (serviceUrl == null) {
+        	JOptionPane.showMessageDialog(null,"service url is not specified.", "Error",JOptionPane.ERROR_MESSAGE);
+        	return ServiceConnectionStatus.ERROR;
+        }
+        try {
+            this.serviceUrl = new URL(serviceUrl);
+        } catch (MalformedURLException ex) {
+        	JOptionPane.showMessageDialog(null,"Malformed service url: " + serviceUrl, "Error",JOptionPane.ERROR_MESSAGE);
+        	JOptionPane.showMessageDialog(null, ex.getMessage());
+        	return ServiceConnectionStatus.ERROR;
+        }
+
+        String protocol = this.serviceUrl.getProtocol();
+        if (protocol == null) {
+        	JOptionPane.showMessageDialog(null,"Unsupported service protocol specified in " + serviceUrl, "Error",JOptionPane.ERROR_MESSAGE);
+        	return ServiceConnectionStatus.ERROR;
+        }
+        
+        HttpsURLConnection.setDefaultSSLSocketFactory(new NoServerVerificationSSLSocketFactory());
+        
+        initialized = true;
+        return ServiceConnectionStatus.SUCCESS;
+    }
+    
+    public boolean isInitialized() {
+    	return initialized;
+    }
+
+    public boolean isSessionValid() {
+    	return session.isValid();
+    }
+
+    private URL getServiceUrl() {
+        return serviceUrl;
+    }
+
+    private int checkHttpResponse(HttpsURLConnection connection)  {
+    	int code = 0;
+    	String exceptionType = connection.getHeaderField(DmHttpHeaders.DM_EXCEPTION_TYPE_HTTP_HEADER);
+        if (exceptionType != null) {
+            String statusMessage = connection.getHeaderField(DmHttpHeaders.DM_STATUS_MESSAGE_HTTP_HEADER);
+            String statusCode = connection.getHeaderField(DmHttpHeaders.DM_STATUS_CODE_HTTP_HEADER);
+            code = Integer.parseInt(statusCode);
+        	JOptionPane.showMessageDialog(null,exceptionType +" "+ code +" "+ statusMessage, "Error",JOptionPane.ERROR_MESSAGE);
+        }
+        switch (code) {
+        case DmStatus.DM_OK :
+        	return ServiceConnectionStatus.SUCCESS;
+        case DmStatus.DM_AUTHENTICATION_ERROR:
+        	return ServiceConnectionStatus.AUTHENTICATION_ERROR;
+        case DmStatus.DM_AUTHORIZATION_ERROR:
+        	return ServiceConnectionStatus.AUTHORIZATION_ERROR;
+        case DmStatus.DM_COMMUNICATION_ERROR:
+        case DmStatus.DM_CONFIGURATION_ERROR:
+        case DmStatus.DM_ERROR:
+        case DmStatus.DM_INVALID_SESSION:
+        case DmStatus.DM_TIMEOUT:
+        case DmStatus.DM_URL_ERROR:
+        	return ServiceConnectionStatus.ERROR;
+        	default:
+        		return ServiceConnectionStatus.INVALID_OPERATION;
+        }
+    }
+
+    private String getFullRequestUrl(String requestUrl) {
+        String url = serviceUrl + requestUrl;
+        return url;
+    }
+
+    private static String preparePostData(Map<String, String> data) {
+        try {
+            String postData = "";
+            String separator = "";
+            for (String key : data.keySet()) {
+                postData += separator + key + "=" + URLEncoder.encode(data.get(key), "UTF8");
+                separator = "&";
+            }
+            return postData;
+        } catch (UnsupportedEncodingException ex) {
+        	JOptionPane.showMessageDialog(null, ex.getMessage());
+            return null;
+        }
+    }
+
+    private void updateSessionCookie(HttpsURLConnection connection) {
+        String cookie = connection.getHeaderField(DmHttpHeaders.DM_SET_COOKIE_HEADER);
+        if (cookie != null) {
+            session.setCookie(cookie);
+        }
+        String sessionRole = connection.getHeaderField(DmHttpHeaders.DM_SESSION_ROLE_HTTP_HEADER);
+        if (sessionRole != null) {
+            session.setRole(Session.Role.fromString(sessionRole));
+        }
+    }
+
+    private static int sendPostData(Map<String, String> data, HttpsURLConnection connection) {
+        String postData = preparePostData(data);
+        try (DataOutputStream dos = new DataOutputStream(connection.getOutputStream())) {
+            dos.writeBytes(postData);
+            dos.flush();
+            return ServiceConnectionStatus.SUCCESS;
+        } catch (IOException ex) {
+        	ex.printStackTrace();
+        	JOptionPane.showMessageDialog(null, ex.getMessage());
+        	JOptionPane.showMessageDialog(null, "misconfigured service or closed ", "Error",JOptionPane.ERROR_MESSAGE);
+        	return ServiceConnectionStatus.CONNECTION_ERROR;
+        }
+    }
+
+    private static String readHttpResponse(HttpsURLConnection connection) {
+        try {
+            BufferedReader br = new BufferedReader(new InputStreamReader(
+                    (connection.getInputStream())));
+            StringBuilder sb = new StringBuilder();
+            String output;
+            while ((output = br.readLine()) != null) {
+                sb.append(output);
+                sb.append('\n');
+            }
+            return sb.toString();
+        } catch (IOException ex) {
+        	JOptionPane.showMessageDialog(null, ex.getMessage());
+            return null;
+        }
+    }
+
+    private static void setCookieRequestHeader(HttpsURLConnection connection, String sessionCookie) {
+        if (sessionCookie != null) {
+            connection.setRequestProperty("Cookie", sessionCookie);
+        }
+    }
+
+    private static int setPostRequestHeaders(HttpsURLConnection connection, String sessionCookie)  {
+        int resp = setPostRequestHeaders(connection);
+        if (resp != ServiceConnectionStatus.SUCCESS) {
+        	return resp;
+        }
+        setCookieRequestHeader(connection, sessionCookie);
+        return resp;
+    }
+
+     private static int setPostRequestHeaders(HttpsURLConnection connection)  {
+        try {
+            connection.setDoOutput(true);
+            connection.setRequestMethod("POST");
+            connection.setRequestProperty("Content-Type", "application/x-www-form-urlencoded");
+            return ServiceConnectionStatus.SUCCESS;
+        } catch (ProtocolException ex) {
+        	JOptionPane.showMessageDialog(null, ex.getMessage());
+            return ServiceConnectionStatus.PROTOCOL_ERROR;
+        }
+    }
+
+    protected int invokeSessionPostRequest(String requestUrl, Map<String, String> data) {
+        String urlString = getFullRequestUrl(requestUrl);
+        HttpsURLConnection connection = null;
+        try {
+            String sessionCookie = session.verifyCookie();
+            URL url = new URL(urlString);
+            connection = (HttpsURLConnection) url.openConnection();
+
+            int resp = setPostRequestHeaders(connection, sessionCookie);
+            if ( resp != ServiceConnectionStatus.SUCCESS) {
+            	return resp;
+            }
+            resp = sendPostData(data, connection);
+            if ( resp != ServiceConnectionStatus.SUCCESS) {
+            	return resp;
+            }
+            updateSessionCookie(connection);
+            resp = checkHttpResponse(connection);
+            readHttpResponse(connection);
+            return resp;
+        } catch (Exception ex) {
+            String errorMsg = "Cannot connect to " + getServiceUrl();
+        	JOptionPane.showMessageDialog(null,errorMsg, "Error",JOptionPane.ERROR_MESSAGE);
+            JOptionPane.showMessageDialog(null, ex.getMessage());
+            return ServiceConnectionStatus.ERROR;
+        } finally {
+            if (connection != null) {
+                connection.disconnect();
+            }
+        }
+    }
+
+    private static int setPutRequestHeaders(HttpsURLConnection connection, String sessionCookie) {
+    	int resp = setPutRequestHeaders(connection);
+        if ( resp != ServiceConnectionStatus.SUCCESS) {
+        	return resp;
+        }
+    	setCookieRequestHeader(connection, sessionCookie);
+    	return resp;
+    }
+
+    private static int setPutRequestHeaders(HttpsURLConnection connection) {
+    	try {
+    		connection.setDoOutput(true);
+    		connection.setRequestMethod("PUT");
+    		connection.setRequestProperty("Content-Type", "application/x-www-form-urlencoded");
+            return ServiceConnectionStatus.SUCCESS;
+    	} catch (ProtocolException ex) {
+    		JOptionPane.showMessageDialog(null, ex.getMessage());
+            return ServiceConnectionStatus.PROTOCOL_ERROR;
+    	}
+    }
+
+    protected int invokeSessionPutRequest(String requestUrl, Map<String, String> data) {
+        String urlString = getFullRequestUrl(requestUrl);
+        HttpsURLConnection connection = null;
+        try {
+            String sessionCookie = session.verifyCookie();
+            URL url = new URL(urlString);
+            connection = (HttpsURLConnection) url.openConnection();
+
+            int resp = setPutRequestHeaders(connection, sessionCookie);
+            if ( resp != ServiceConnectionStatus.SUCCESS) {
+            	return resp;
+            }
+            resp = sendPostData(data, connection);
+            if ( resp != ServiceConnectionStatus.SUCCESS) {
+            	return resp;
+            }
+            updateSessionCookie(connection);
+            resp = checkHttpResponse(connection);
+            readHttpResponse(connection);
+            return resp;
+        } catch (Exception ex) {
+            String errorMsg = "Cannot connect to " + getServiceUrl();
+        	JOptionPane.showMessageDialog(null,errorMsg, "Error",JOptionPane.ERROR_MESSAGE);
+            JOptionPane.showMessageDialog(null, ex.getMessage());
+            return ServiceConnectionStatus.ERROR;
+        } finally {
+            if (connection != null) {
+                connection.disconnect();
+            }
+        }
+    }
+
+//    // this method works with java 8 java.util.Base64
+//    protected String encode(String s) {
+//		byte[] encoded1 = Base64.getEncoder().encode(s.getBytes());
+//		String encoded2 = Base64.getEncoder().encodeToString(encoded1);
+//		return encoded2;    	
+//    }
+    
+    public static String encode(String input) {
+        try {
+            // Input is twice encoded in order to avoid issues like
+            // '+' being interpreted as space
+            if (input == null) {
+                return input;
+            }
+            String s1 = DatatypeConverter.printBase64Binary(input.getBytes());
+            String s2 = DatatypeConverter.printBase64Binary(s1.getBytes());
+            return s2;
+        } catch (Exception ex) {
+            ex.printStackTrace();
+            return null;
+        }
+    }
+
+//    public static String decode(String input) {
+//        try {
+//            // Input is twice encoded in order to avoid issues like
+//            // '+' being interpreted as space
+//            byte[] ba1 = DatatypeConverter.parseBase64Binary(input);
+//            byte[] ba2 = DatatypeConverter.parseBase64Binary(new String(ba1));
+//            return new String(ba2);
+//        } catch (Exception ex) {
+//            ex.printStackTrace();
+//            return null;
+//        }
+//    }
+//    private String verifySessionCookie()  {
+//        return session.verifyCookie();
+//    }
+//
+//    private static String getResponseHeaders(HttpsURLConnection connection) {
+//        String headerString = "";
+//        Map<String, List<String>> headerMap = connection.getHeaderFields();
+//        for (String key : headerMap.keySet()) {
+//            List<String> values = headerMap.get(key);
+//            headerString += key + ": " + values + "\n";
+//        }
+//        return headerString;
+//    }
+//
+//    private String invokeSessionGetRequest(String requestUrl) {
+//        String urlString = getFullRequestUrl(requestUrl);
+//        HttpsURLConnection connection = null;
+//        try {
+//            String sessionCookie = session.verifyCookie();
+//            URL url = new URL(urlString);
+//            connection = (HttpsURLConnection) url.openConnection();
+//
+//            setGetRequestHeaders(connection, sessionCookie);
+//            updateSessionCookie(connection);
+//            checkHttpResponse(connection);
+//            return readHttpResponse(connection);
+//        } catch (Exception ex) {
+//            String errorMsg = "Cannot connect to " + getServiceUrl();
+//        	JOptionPane.showMessageDialog(null,errorMsg, "Error",JOptionPane.ERROR_MESSAGE);
+//            JOptionPane.showMessageDialog(null, ex.getMessage());
+//            return null;
+//        } finally {
+//            if (connection != null) {
+//                connection.disconnect();
+//            }
+//        }
+//    }
+//
+//     private String invokeGetRequest(String requestUrl) {
+//        String urlString = getFullRequestUrl(requestUrl);
+//        HttpsURLConnection connection = null;
+//        try {
+//            URL url = new URL(urlString);
+//            connection = (HttpsURLConnection) url.openConnection();
+//            updateSessionCookie(connection);
+//            checkHttpResponse(connection);
+//            return readHttpResponse(connection);
+//        } catch (Exception ex) {
+//            String errorMsg = "Cannot connect to " + getServiceUrl();
+//        	JOptionPane.showMessageDialog(null,errorMsg, "Error",JOptionPane.ERROR_MESSAGE);
+//            JOptionPane.showMessageDialog(null, ex.getMessage());
+//            return null;
+//        } finally {
+//            if (connection != null) {
+//                connection.disconnect();
+//            }
+//        }
+//    }
+//
+//     private String invokeSessionDeleteRequest(String requestUrl) {
+//         String urlString = getFullRequestUrl(requestUrl);
+//         HttpsURLConnection connection = null;
+//         try {
+//             String sessionCookie = session.verifyCookie();
+//             URL url = new URL(urlString);
+//             connection = (HttpsURLConnection) url.openConnection();
+//
+//             setDeleteRequestHeaders(connection, sessionCookie);
+//             updateSessionCookie(connection);
+//             checkHttpResponse(connection);
+//             return readHttpResponse(connection);
+//         } catch (Exception ex) {
+//             String errorMsg = "Cannot connect to " + getServiceUrl();
+//         	JOptionPane.showMessageDialog(null,errorMsg, "Error",JOptionPane.ERROR_MESSAGE);
+//             JOptionPane.showMessageDialog(null, ex.getMessage());
+//             return null;
+//         } finally {
+//             if (connection != null) {
+//                 connection.disconnect();
+//             }
+//         }
+//     }
+//
+//    private static void setGetRequestHeaders(HttpsURLConnection connection, String sessionCookie) {
+//        setGetRequestHeaders(connection);
+//        setCookieRequestHeader(connection, sessionCookie);
+//    }
+//
+//     private static void setGetRequestHeaders(HttpsURLConnection connection) {
+//        try {
+//            connection.setRequestMethod("GET");
+//        } catch (ProtocolException ex) {
+//        	JOptionPane.showMessageDialog(null, ex.getMessage());
+//        }
+//    }
+//
+//    private static void setDeleteRequestHeaders(HttpsURLConnection connection, String sessionCookie) {
+//        setDeleteRequestHeaders(connection);
+//        setCookieRequestHeader(connection, sessionCookie);
+//    }
+//
+//    private static void setDeleteRequestHeaders(HttpsURLConnection connection) {
+//        try {
+//            connection.setRequestMethod("DELETE");
+//        } catch (ProtocolException ex) {
+//        	JOptionPane.showMessageDialog(null, ex.getMessage());
+//        }
+//    }
+//
+//
+//	private void getData(HttpsURLConnection connection) {
+//		BufferedReader in;
+//		try {
+//			in = new BufferedReader(
+//					new InputStreamReader(connection.getInputStream()));
+//		String inputLine;
+//		StringBuffer response = new StringBuffer();
+//
+//		while ((inputLine = in.readLine()) != null) {
+//			response.append(inputLine);
+//		}
+//		} catch (IOException e) {
+//			JOptionPane.showMessageDialog(null, e.getMessage());
+//		}
+//	}
+
+    public final void setLogin(String username, String password) {
+    	this.login = new Login(username, password);
+    }
+
+    public final int login() {
+    	return login.login();
+    }
+
+     public final int login(String username, String password) {
+        HttpsURLConnection connection = null;
+        try {
+            String urlString = getFullRequestUrl(StorageServUrl.LOGIN_REQUEST);
+            URL url = new URL(urlString);
+            connection = (HttpsURLConnection) url.openConnection();
+            setPostRequestHeaders(connection);
+             HashMap<String, String> loginData = new HashMap<>();
+            loginData.put(Keyword.USERNAME, username);
+            loginData.put(Keyword.PASSWORD, password);
+
+            int resp = sendPostData(loginData, connection);
+            if (resp != ServiceConnectionStatus.SUCCESS) {
+            	return resp;
+            }
+            resp = checkHttpResponse(connection);
+            if (resp != ServiceConnectionStatus.SUCCESS) {
+            	return resp;
+            }
+            session.setUsername(username);
+//            session.setId(sessionId);
+            updateSessionCookie(connection);
+            return ServiceConnectionStatus.SUCCESS;
+        } catch (ConnectException ex) {
+            String errorMsg = "Cannot connect to " + getServiceUrl();
+        	JOptionPane.showMessageDialog(null,errorMsg, "Error",JOptionPane.ERROR_MESSAGE);
+            return ServiceConnectionStatus.ERROR;
+        } catch (Exception ex) {
+        	ex.printStackTrace();
+        	JOptionPane.showMessageDialog(null, ex.getMessage());
+            return ServiceConnectionStatus.ERROR;
+        } finally {
+            if (connection != null) {
+                connection.disconnect();
+            }
+        }
+    }
+
+	public void close() {
+		session = null;		
+	}
+    
+}
+
+

tools/ExperimentSynchronizer/src/gov/anl/dm/esafsync/serviceconn/Session.java

+package gov.anl.dm.esafsync.serviceconn;
+
+import java.io.Serializable;
+import java.net.HttpCookie;
+
+import javax.swing.JOptionPane;
+
+/**
+ * CDB session class, used for keeping all session-related information (session
+ * id, username, role, etc.).
+ */
+public class Session implements Serializable {
+
+	public enum Role {
+
+	    USER("User"),
+	    ADMIN("Administrator");
+
+	    private final String type;
+
+	    private Role(String type) {
+	        this.type = type;
+	    }
+
+	    @Override
+	    public String toString() {
+	        return type;
+	    }
+
+	    public static Role fromString(String type) {
+	        Role role = null;
+	        switch (type) {
+	            case "User":
+	                role = USER;
+	                break;
+	            case "Administrator":
+	                role = ADMIN;
+	                break;
+	        }
+	        return role;
+	    }
+	}
+
+    private static final long serialVersionUID = 1L;
+
+    private String id = null;
+    private String username = null;
+    private String cookie = null;
+    
+    private Role role = null;
+
+    public Session() {
+    }
+
+    public String getUsername() {
+        return username;
+    }
+
+    public void setUsername(String username) {
+        this.username = username;
+    }
+
+    public String getId() {
+        return id;
+    }
+
+    public void setId(String id) {
+        this.id = id;
+    }
+
+    public String getCookie() {
+        return cookie;
+    }
+
+    public void setCookie(String cookie) {
+        this.cookie = cookie;
+    }
+
+    public String verifyCookie() {
+        if (cookie == null) {
+        	JOptionPane.showMessageDialog(null, "Valid session has not been established.", "Info",JOptionPane.INFORMATION_MESSAGE);
+        } else {
+            HttpCookie httpCookie = HttpCookie.parse(cookie).get(0);
+            if (httpCookie.hasExpired()) {
+            	JOptionPane.showMessageDialog(null, "Session has expired.", "Info",JOptionPane.INFORMATION_MESSAGE);
+            }
+        }
+        return cookie;
+    }
+    
+    public boolean isValid() {
+        if (cookie == null) {
+        	return false;
+        } else {
+            HttpCookie httpCookie = HttpCookie.parse(cookie).get(0);
+            if (httpCookie.hasExpired()) {
+            	return false;
+            }
+        }
+        return true;    	
+    }
+
+    public Role getRole() {
+        return role;
+    }
+
+    public void setRole(Role role) {
+        this.role = role;
+    }
+
+    public boolean isAdminRole() {
+        if (role != null) {
+            return role.equals(Role.ADMIN);
+        }
+        return false;
+    }
+
+    public boolean isUserRole() {
+        if (role != null) {
+            return role.equals(Role.USER);
+        }
+        return false;
+    }
+
+    @Override
+    public String toString() {
+        String result = "{ ";
+        String delimiter = "";
+        if (username != null) {
+            result += "username :" + username;
+            delimiter = "; ";
+        }
+        if (id != null) {
+            result += delimiter + "id : " + id;
+            delimiter = "; ";
+        }
+        if (cookie != null) {
+            result += delimiter + "cookie : " + cookie;
+        }
+        result += " }";
+        return result;
+    }
+}
+

tools/ExperimentSynchronizer/src/gov/anl/dm/esafsync/serviceconn/StorageServiceConnection.java

+package gov.anl.dm.esafsync.serviceconn;
+
+import java.util.HashMap;
+import java.util.Map;
+
+import javax.swing.JOptionPane;
+
+public class StorageServiceConnection extends ServiceConnection{
+
+	class Keyword {
+		static final String EXPERIMENT_NAME = "name";
+		static final String EXPERIMENT_DESCRIPTION = "description";
+		static final String EXPERIMENT_TYPE_ID = "experimentTypeId";
+		static final String EXPERIMENT_START_DATE = "startDate";
+		static final String EXPERIMENT_END_DATE = "endDate";
+	}
+
+	class StorageServUrl {
+		static final String EXPERIMENT = "/experiments";
+		static final String EXPERIMENT_USER = "/usersByExperiment";
+		static final String START_EXPERIMENT = "/experiments/start";
+	}
+
+	public int addExperiment(String name, String description, String startDate, String endDate) {
+		Map<String, String> data = new HashMap<>();
+    	if (name == null) {
+    		JOptionPane.showMessageDialog(null, "The experiment name is null", "Error",JOptionPane.ERROR_MESSAGE);
+    		return ServiceConnection.ServiceConnectionStatus.ERROR;
+    	} else {
+    		data.put(Keyword.EXPERIMENT_NAME, encode(name));
+    	}
+    	if (description != null) {
+    		data.put(Keyword.EXPERIMENT_DESCRIPTION, encode(description));
+    	}
+    	if (startDate != null) {
+    		data.put(Keyword.EXPERIMENT_START_DATE, encode(startDate));
+    	}
+    	if (endDate != null) {
+    		data.put(Keyword.EXPERIMENT_END_DATE, encode(endDate));
+    	}
+		data.put(Keyword.EXPERIMENT_TYPE_ID, ESAF_EXPERIMENT_TYPE);
+		return invokeSessionPostRequest(StorageServUrl.EXPERIMENT, data);    	
+    }
+
+    public int addExperimentUser(String userName, String experimentName, String role) {
+		Map<String, String> data = new HashMap<>();
+		return invokeSessionPostRequest(StorageServUrl.EXPERIMENT_USER + "/" + userName + "/" + experimentName + "/" + role, data);
+    }
+
+    public int startExperiment(String name) {
+		Map<String, String> data = new HashMap<>();
+    	if (name == null) {
+    		JOptionPane.showMessageDialog(null, "The experiment name is null", "Error",JOptionPane.ERROR_MESSAGE);
+    		return ServiceConnection.ServiceConnectionStatus.ERROR;
+    	} else {
+    		data.put(Keyword.EXPERIMENT_NAME, encode(name));
+    	}
+		return invokeSessionPutRequest(StorageServUrl.START_EXPERIMENT, data);
+    }
+}
+
+

tools/make/RULES_DM

+all:
+	for d in $(SUBDIRS); do $(MAKE) -C $$d $(ARCH); done
+
+dist:
+	for d in $(SUBDIRS); do $(MAKE) -C $$d $(ARCH); done
+
+clean:
+	for d in $(SUBDIRS); do $(MAKE) -C $$d clean; done
+
+distclean:
+	for d in $(SUBDIRS); do $(MAKE) -C $$d distclean; done
+	for d in $(SUBDIRS); do rm -f `find $$d -name 'RELEASE.local'`; done
+
+tidy: distclean
+