add: checking for the freshness of a cached response

publicarray · publicarray · commit f620a149c0a5 · 2016-10-17T21:54:53.000+10:00
diff --git a/HttpRequest.java b/HttpRequest.java
@@ -1,6 +1,7 @@
 import java.io.*;
 import java.net.*;
 import java.util.*;
+import java.text.SimpleDateFormat;
 
 public class HttpRequest {
     /** Help variables */
@@ -65,6 +66,51 @@ public HttpRequest(BufferedReader from) {
         System.out.println("Host to contact is: " + host + " at port " + port);
     }
 
+    // constructor
+    public HttpRequest(String method, String url, String version, String headers, String host, int port) {
+        this.method = method;
+        this.URL = url;
+        this.version = version;
+        this.headers = headers;
+        this.host = host;
+        this.port = port;
+        this.error = 0;
+    }
+
+    // copy constructor
+    public HttpRequest(HttpRequest other) {
+        this.method = other.method;
+        this.URL = other.URL;
+        this.version = other.version;
+        this.headers = other.headers;
+        this.host = other.host;
+        this.port = other.port;
+        this.error = other.error;
+    }
+
+    public HttpResponse askServerIfvalid(Date lastModified, String etag) {
+        if (lastModified == null || etag == null || etag.isEmpty()) {
+            return null;
+        }
+
+        // User-Agent: SSProxyCache/1 (https://github.com/publicarray/SSProxyCache)
+        // headers = "User-Agent: SSProxyCache/1.0\r\n";
+        headers = "";
+
+        if (!etag.isEmpty()) {
+            // If-None-Match: "07bb743de42c7918a1a47fd61c6aa9c7:1469533683"\r\n
+            headers += "If-None-Match: " + etag + CRLF;
+        } if (lastModified != null) {
+            // If-Modified-Since: Thu, 13 Oct 2016 00:36:43 GMT\r\n
+            SimpleDateFormat dateFormat = new SimpleDateFormat ("E, dd MMM yyyy HH:mm:ss z");
+            dateFormat.setTimeZone(TimeZone.getTimeZone("GMT"));
+            headers += "If-Modified-Since: " + dateFormat.format(lastModified) + CRLF;
+        }
+
+        headers += "Host: " + host + CRLF;
+        return send();
+    }
+
     public int getError() {
         return error;
     }
@@ -74,11 +120,19 @@ public String getHost() {
         return host;
     }
 
+    public void setHost(String host) {
+        this.host = host;
+    }
+
     /** Return port for server */
     public int getPort() {
         return port;
     }
 
+    public void setPort(int port) {
+        this.port = port;
+    }
+
     /** Return URL to connect to */
     public String getURL() {
         return URL;
diff --git a/HttpResponse.java b/HttpResponse.java
@@ -19,7 +19,6 @@ public class HttpResponse {
     Date lastModified;
     Date expires;
     String etag;
-
     /* Body of reply */
     ByteArrayOutputStream body = new ByteArrayOutputStream();
 
@@ -105,6 +104,21 @@ else if (line.toLowerCase(Locale.ROOT).startsWith("last-modified")) {
                 body.write(buf, 0, res);
                 bytesRead += res;
             }
+
+
+            // http://codereview.stackexchange.com/questions/49746/implement-http-server-with-persistent-connection
+
+            // http://stackoverflow.com/questions/3870847/how-to-convert-the-datainputstream-to-the-string-in-java
+            //http://stackoverflow.com/questions/13115857/http-socket-programming-java
+            //
+            //http://stackoverflow.com/questions/7696358/server-socket-file-transfer
+            //http://stackoverflow.com/questions/13555668/java-send-file-using-sockets
+            // http://stackoverflow.com/questions/10475898/receive-byte-using-bytearrayinputstream-from-a-socket
+            // http://stackoverflow.com/questions/9520911/java-sending-and-receiving-file-byte-over-sockets
+            // http://stackoverflow.com/questions/1176135/java-socket-send-receive-byte-array
+            // http://stackoverflow.com/questions/8274966/reading-a-byte-array-from-socket
+            // TSL -> http://stackoverflow.com/questions/18787419/ssl-socket-connection#18790838
+
         } catch (IOException e) {
             // error = 500;
             System.out.println("Error reading response body: " + e);
@@ -155,6 +169,19 @@ public HttpResponse(int statusCode) {
         body.write(bodyStr.getBytes(), 0, bodyStr.length());
     }
 
+    // copy constructor
+    public HttpResponse (HttpResponse other) {
+        this.version = other.version;
+        this.status = other.status;
+        this.statusMessage = other.statusMessage;
+        this.statusLine = other.statusLine;
+        this.headers = other.headers;
+        this.lastModified = other.lastModified;
+        this.expires = other.expires;
+        this.etag = other.etag;
+        this.body = other.body;
+    }
+
     public HttpResponse setStaus(int status) {
         this.status = status;
         return this;
@@ -204,6 +231,7 @@ public Socket send(Socket host) {
     private Date toDate(String dateStr, String format) {
         try {
             SimpleDateFormat inFormat = new SimpleDateFormat(format);
+            inFormat.setTimeZone(TimeZone.getTimeZone("GMT"));
             return inFormat.parse(dateStr);
         } catch (ParseException e) {
             System.out.println("Parse date error: " + e + " -- at position:" + e.getErrorOffset());
@@ -216,15 +244,12 @@ private Date toDate(String dateStr) {
         return toDate(dateStr, format);
     }
 
-    // check if response is still valid
-    public boolean isValid() {
-        Date now = new Date(); // get current date time
+    // check if response is still valid using the (now old) expires header
+    public boolean isExpired() {
         if (lastModified != null && expires != null) {
+            Date now = new Date(); // get current date time
+            return !(now.after(lastModified) && now.before(expires)); // no web request is needed
         }
-
-        // System.out.println(now.toString() + ", " + lastModified.toString() + ", " + expires.toString());
-        // TODO: etag
-        // TODO: last modified
-        return true; // assume as valid for now.
+        return true;
     }
 }
diff --git a/ProxyCache.java b/ProxyCache.java
@@ -44,6 +44,7 @@ public static void handle(Socket client) {
         /* Read request */
         try {
             BufferedReader fromClient = new BufferedReader(new InputStreamReader(client.getInputStream()));
+            System.out.println("\n**** New Request ****");
             request = new HttpRequest(fromClient);
             System.out.println("---> Request --->\n" + request.toString()); // Debug
         } catch (IOException e) {
@@ -52,19 +53,17 @@ public static void handle(Socket client) {
         }
 
         if (request.method.equals("GET")) { // Only GET requests are cached
-            // create key
-            String key = request.getURL();
             // Check if key is in cache
-            if ((response = cache.get(key)) != null && response.isValid()) { // get item from cache if the cache is still fresh
+            if ((response = cache.get(request.getURL())) != null) {// && response.isValid()) { // get item from cache if the cache is still fresh
                 // response is set and valid
-                System.out.println("Retrieved " + key);
-                System.out.println("Is valid? " + response.isValid());
+                // System.out.println("Retrieved " + request.getURL());
+                // System.out.println("Is valid? " + cache.isValid(request));
             } else { // handle requests
                     /* Send request to server */
                     response = request.send();
 
                     /* Read response and forward it to client */
-                    cache.put(key, response);// Save response to cache
+                    cache.put(request.getURL(), response);// Save response to cache
             }
 
             System.out.println("<--- Response <--- \n" + response.toString()); // Debug
@@ -83,7 +82,7 @@ public static void handle(Socket client) {
         // http://stackoverflow.com/questions/16358589/implementing-a-simple-https-proxy-application-with-java
         // http://stackoverflow.com/questions/18273703/tunneling-two-socket-client-in-java#18274109
         else if (request.method.equals("CONNECT")) {
-            System.out.println("CONNECT found! Tunnelling connection.");
+            System.out.println("CONNECT found! Tunnelling HTTPS connection.");
             InputStream fromClient;
             OutputStream toServer;
             try {
@@ -102,8 +101,8 @@ else if (request.method.equals("CONNECT")) {
             }
 
             try {
-                client.setSoTimeout(5000);
-                server.setSoTimeout(5000);
+                client.setSoTimeout(3000);
+                server.setSoTimeout(3000);
                 byte[] buffer = new byte[2048];
                 int rc = 0;
 
diff --git a/SCache.java b/SCache.java
@@ -2,24 +2,135 @@
 import java.net.*;
 import java.util.*;
 import java.util.HashMap;
+import java.text.SimpleDateFormat;
 
 public class SCache {
     private Map<String, HttpResponse> cacheStore;
+    HttpRequest request;
 
     public SCache() {
         // synchronised HasMap prevents data corruption when reading while writing the Map
         cacheStore = Collections.synchronizedMap(new HashMap<String, HttpResponse>());
+        request = new HttpRequest("GET", "", "HTTP/1.1", "", "", 0);
     }
 
     // add value to HashMap
     public HttpResponse put(String key, HttpResponse value) {
-        System.out.println("Saved " + key + " to cache.");
+        System.out.println("SCACHE: Saved " + key + " to cache.");
         return cacheStore.put(key, value);
     }
 
     // retrieve value from HashMap
     public HttpResponse get(String key) {
-        System.out.println("looking for " + key + " in cache.");
-        return cacheStore.get(key);
+        System.out.println("SCACHE: looking for " + key + " in cache.");
+        HttpResponse value = cacheStore.get(key);
+        if (value == null) {
+            System.out.println("SCACHE: " + key + " not found in cache.");
+            return null;
+        }
+        System.out.println("SCACHE: retrieved " + key + " from cache.");
+
+        boolean valid = isValid(key, value);
+        System.out.println("SCACHE: Is key valid? " + valid);
+        if (!valid) { // get the new value if there is a new one
+            value = cacheStore.get(key);
+        }
+        return value;
+    }
+
+    // check if response is still valid
+    public boolean isValid(String requestURL, HttpResponse response) {
+        if (!response.isExpired()) {
+            System.out.println("SCACHE: response has not expired");
+            return true;
+        }
+
+        // HttpRequest check = new HttpRequest(request); // deep copy
+        request.setHost(getHost(requestURL));
+        request.setPort(getPort(requestURL));
+        request.URL = getLocation(requestURL);
+
+        HttpResponse newResponse = request.askServerIfvalid(response.lastModified, response.etag); // ask severer
+        if (newResponse == null) { // if error
+            return true; // Todo: for debugging
+        }
+        // HttpResponse r = new HttpRequest(request, response.lastModified, response.etag).send(); // ask server
+        if (newResponse.status == 304) { // Not modified, so still valid
+            System.out.println("SCACHE: 304 Not modified");
+            return true;
+        } else { // 200 OK and other responses
+            System.out.println("SCACHE: response was modified. Updating Cache.");
+            put(requestURL, newResponse); // save the new response
+            return false;
+        }
+
+        // return false;
+    }
+
+    public static String getHost(String url) {
+        if (url == null || url.length() <= 0) {
+            return "";
+        }
+
+        int start = url.indexOf("//");
+        if (start == -1) {
+            return "";
+        }
+        start += 2;
+
+        int end = url.indexOf('/', start);
+        if (end == -1) {
+            return "";
+        }
+
+        return url.substring(start, end);
+    }
+
+    public static int getPort(String url) {
+        if (url == null || url.length() <= 0) {
+            return 80;
+        }
+
+        int start = url.indexOf("//");
+        if (start == -1) {
+            return 80;
+        }
+
+        start += 2;
+
+        int end = url.indexOf('/', start);
+        if (end == -1) {
+            return 80;
+        }
+
+        int port = url.indexOf(':', start);
+        if (port == -1) {
+            return 80;
+        }
+
+        if (port < end) {
+            end = port;
+        }
+
+        return Integer.parseInt(url.substring(port, end));
+    }
+
+    public static String getLocation(String url) {
+        if (url == null || url.length() <= 0) {
+            return "";
+        }
+
+        int start = url.indexOf("//");
+        if (start == -1) {
+            return "";
+        }
+        start += 2;
+
+        int end = url.indexOf('/', start);
+        if (end == -1) {
+            return "";
+        }
+
+        return url.substring(end);
     }
 }
