Changeset 8928

Timestamp:

2005-01-24T16:13:34+13:00 (19 years ago)

Author:

sjboddie

Message:

Altered phind so it works correctly over an https connection
(DataInputStream.available() seems always to return 0 for https connections
under Sun java, though it works ok with Microsoft's VM).

Location:

trunk/gsdl/src/java/org/nzdl/gsdl/Phind

Files:

• Makefile (modified) (1 diff)
• Phind.java (modified) (6 diffs)

trunk/gsdl/src/java/org/nzdl/gsdl/Phind/Makefile

@@ -16 +16 @@
 
 %.class : %.java
-    javac -d . -classpath ../../../.. $<
+    javac -target 1.1 -d . -classpath ../../../.. $<

trunk/gsdl/src/java/org/nzdl/gsdl/Phind/Phind.java

@@ -87 +87 @@
 
 import java.net.URL;
+import java.net.URLConnection;
 import java.io.DataInputStream;
+import java.io.InputStream;
 
 import java.net.Socket;
@@ -207 +209 @@
     mode = initMode;
     
+        System.out.println("Java vendor: " + System.getProperty("java.vendor"));
+        System.out.println("Java version: " + System.getProperty("java.version"));
+
     // Read applet parameters
     getParameters();
@@ -473 +478 @@
     try {
         URL phindcgi = new URL(query);
-        DataInputStream in = new DataInputStream(phindcgi.openStream());
+            //            DataInputStream in = new DataInputStream(phindcgi.openStream());
+
+            URLConnection conn = phindcgi.openConnection();
+            DataInputStream in = new DataInputStream(conn.getInputStream());
+
         byte[] buffer;
         int availableBytes = 0;
 
+        
         while (!area.finished) {
+        // Lovely old method, which would work just fine if Sun supported their own API and made
+        // in.available() work.
+
+        /*
         availableBytes = in.available();
         if (availableBytes == 0) {
@@ -489 +503 @@
              *  DLConsulting 12-07-2004
              *  Start...
-             */
+             
+                    System.err.println("No bytes available");
             if(time >= timeout) {
             throw new InterruptedIOException(
@@ -503 +518 @@
             }
             time++;
-            /** ...End */
+            /** ...End 
         } else {
+                    System.err.println("Preparing to read " + availableBytes + " bytes");
             buffer = new byte[availableBytes];
             in.read(buffer);
+                    System.err.println("Done reading");
             area.parseBytes(buffer);
         }
-        }
+        */
+
+        // New - and hopefully safer - method.
+
+        // Create a new SafeReader, and then wait while it reads
+        // we can watch for timeouts as necessary
+        int timeout = 0;
+        SafeReader reader = new SafeReader(in);
+        reader.start();
+        while(!reader.isComplete()) {
+            // Wait timeout time.
+            try {
+            Thread.sleep(1000);
+            }
+            catch(InterruptedException exception) {
+            System.err.println("test.init(): Unexpected InterruptedException. Non-fatal.");
+            exception.printStackTrace();
+            }
+            // Then see if the readers read anything
+            if(reader.poll() == 0) {
+            timeout++;
+            // Have we reached timeout?
+            if(timeout > reader.getTimeout()) {
+                // Nothing been read. Kill the reader
+                reader.interrupt();
+                // And throw a hissy fit
+                throw new InterruptedIOException("No data recieved in " + reader.getTimeout() + 
+                                 " seconds. Connection timed-out.");
+            }
+            // Otherwise, wait a little longer.
+            }
+            // Otherwise we can continue waiting and polling
+        }
+        // Process the buffer
+        System.err.println("Done reading");
+        area.parseBytes(reader.getBuffer());
+            }
         
         in.close();
@@ -954 +1007 @@
     }
 
-
-
-
-
+    public class SafeReader 
+    extends Thread {
+    // Has the reader finished reading?
+    private boolean complete;
+    // The buffer in where the data read is stored
+    private byte[] buffer;
+    // The stream this reader reads from
+    private DataInputStream in;
+    // If the bytes_read hasn't changed in this time, then stop this thread
+    // and timeout
+    private int timeout; 
+    // The current buffer size
+    private int buffer_current_size;
+    // The maximum buffer size
+    private int buffer_max_size;
+    // The number of bytes read through this reader since the last poll
+    private int bytes_read;
+
+    /** Default constructor 
+     *  @param in the DataInputStream to read from
+     */
+    public SafeReader(DataInputStream in) {
+        complete = false;
+        buffer_current_size = 0;
+        buffer_max_size = 16;
+        buffer = new byte[buffer_max_size]; // Default size
+        timeout = 60; // Sixty seconds
+        bytes_read = 0;
+        
+        this.in = in;
+    }
+
+    /** Construct a new SafeReader
+     *  @param in the DataInputStream to read from
+     *  @param timeout how long this thread should wait when reading data
+     */
+    public SafeReader(DataInputStream in, int timeout) {
+        this(in);
+        this.timeout = timeout;
+    }
+
+    /** Retrieve the current buffer
+     *  @return a byte[] buffer trimmed to the appropriate size
+     */
+    public byte[] getBuffer() {
+        byte[] final_buffer = new byte[buffer_current_size];
+        System.arraycopy(buffer, 0, final_buffer, 0, buffer_current_size);
+        return final_buffer;
+    }
+
+    /** Retrieve the current timeout
+     *  @return the timeout as an int
+     */
+    public int getTimeout() {
+        return timeout;
+    }
+
+    /** See whether the reader has finished reading
+     *  @return true if the read is complete (-1 bytes read!) or false otherwise
+     */
+    public synchronized boolean isComplete() {
+        return complete;
+    }
+
+    /** Poll the reader to determine if it has read any bytes recently
+     *  @return the number of bytes read
+     */
+    public long poll() {
+        // Maybe should test if complete - but its only one second right?
+        long result = bytes_read;
+        bytes_read = 0;
+        return result;
+    }
+
+    /** Try to read bytes from the input stream. Note the caller is responsible for closing the datainputstream
+     */
+    public void run() {
+        try {
+        int i = 0;
+        byte[] read_buffer = new byte[8];
+        while ((i = in.read(read_buffer)) != -1) {
+            // Check our storage buffer is big enough
+            if(buffer_max_size - (buffer_current_size + i) <= 0) {
+            // Double the size
+            buffer_max_size = 2 * buffer_max_size;
+            byte[] new_buffer = new byte[buffer_max_size];
+            System.arraycopy(buffer, 0, new_buffer, 0, buffer_current_size);
+            buffer = new_buffer;
+            }
+            // Then copy in the read buffer
+            System.arraycopy(read_buffer, 0, buffer, buffer_current_size, i);
+            buffer_current_size += i;
+            bytes_read += i;
+        }
+        setComplete(true);
+        }
+        catch(IOException exception) {
+        System.err.println("SafeReader.run(): Unexpected IOException. Fatal.");
+        exception.printStackTrace();
+        }
+    }
+
+    /** Set the complete boolean to the desired state, synchronized to avoid race with isComplete()
+     *  @param value the desired state
+     */
+    private synchronized void setComplete(boolean value) {
+        complete = value;
+    }
+    }
 }