[OpenSRF-GIT] OpenSRF branch master updated. 80f437bb57d56f8cefcf590d2bf906be79a629f7
Evergreen Git
git at git.evergreen-ils.org
Tue May 1 21:33:19 EDT 2012
This is an automated email from the git hooks/post-receive script. It was
generated because a ref change was pushed to the repository containing
the project "OpenSRF".
The branch, master has been updated
via 80f437bb57d56f8cefcf590d2bf906be79a629f7 (commit)
via b4c8d84b00e23084a0ea47c0d9b00ac291efb047 (commit)
via 1a12279baf16fa32e931d932a7043396217288f1 (commit)
via 022c83e8b00220349a64a8fdae6d39cc161ad9e2 (commit)
from 5c46ee1a9ff240ccc2b23b18551b57c777b06c8a (commit)
Those revisions listed above that are new to this repository have
not appeared on any other notification email; so we list those
revisions in full, below.
- Log -----------------------------------------------------------------
commit 80f437bb57d56f8cefcf590d2bf906be79a629f7
Author: Dan Scott <dan at coffeecode.net>
Date: Tue May 1 21:31:38 2012 -0400
Change Java deps.sh to include . in CLASSPATH
Following the directions given by running deps.sh was a little bit
frustrating; we need to work in some documentation on how to use the
Java bits of OpenSRF - and perhaps look at a more standard option like
maven for dependencies.
Signed-off-by: Dan Scott <dan at coffeecode.net>
diff --git a/src/java/deps.sh b/src/java/deps.sh
index c6302ca..17becce 100755
--- a/src/java/deps.sh
+++ b/src/java/deps.sh
@@ -33,5 +33,5 @@ fi
echo ""
echo "To compile OpenSRF java:"
echo ""
-echo "CLASSPATH=deps/$MEMCACHE:deps/$JSON_JAR javac org/opensrf/*.java org/opensrf/net/xmpp/*.java org/opensrf/util/*.java org/opensrf/test/*.java"
+echo "CLASSPATH=deps/$MEMCACHE:deps/$JSON_JAR:. javac org/opensrf/*.java org/opensrf/net/xmpp/*.java org/opensrf/util/*.java org/opensrf/test/*.java"
echo ""
commit b4c8d84b00e23084a0ea47c0d9b00ac291efb047
Author: Bill Erickson <berick at esilibrary.com>
Date: Fri Mar 16 09:56:13 2012 -0400
Java Gateway interface improved exception handling
Handle any exceptions that should not reasonably occur in normal
operation under the covers. Bubble the rest up. Update test code with
examples.
Signed-off-by: Bill Erickson <berick at esilibrary.com>
Signed-off-by: Dan Scott <dscott at laurentian.ca>
diff --git a/src/java/org/opensrf/net/http/GatewayRequest.java b/src/java/org/opensrf/net/http/GatewayRequest.java
index 00631bf..696d8d4 100644
--- a/src/java/org/opensrf/net/http/GatewayRequest.java
+++ b/src/java/org/opensrf/net/http/GatewayRequest.java
@@ -28,74 +28,75 @@ public class GatewayRequest extends HttpRequest {
readComplete = false;
}
- public GatewayRequest send() {
- try {
-
- String postData = compilePostData(service, method);
+ public GatewayRequest send() throws java.io.IOException {
+ String postData = compilePostData(service, method);
- urlConn = (HttpURLConnection) httpConn.url.openConnection();
- urlConn.setRequestProperty("Content-Type", "application/x-www-form-urlencoded");
- urlConn.setDoInput(true);
- urlConn.setDoOutput(true);
+ urlConn = (HttpURLConnection) httpConn.url.openConnection();
+ urlConn.setRequestProperty("Content-Type", "application/x-www-form-urlencoded");
+ urlConn.setDoInput(true);
+ urlConn.setDoOutput(true);
- OutputStreamWriter wr = new OutputStreamWriter(urlConn.getOutputStream());
- wr.write(postData);
- wr.flush();
- wr.close();
-
- } catch (java.io.IOException ex) {
- failed = true;
- failure = ex;
- }
+ OutputStreamWriter wr = new OutputStreamWriter(urlConn.getOutputStream());
+ wr.write(postData);
+ wr.flush();
+ wr.close();
return this;
}
- public Object recv() {
+ public Object recv() throws java.io.IOException {
- if (readComplete)
- return nextResponse();
+ if (!readComplete) {
+ readResponses();
+ readComplete = true;
+ }
- try {
+ Object response = nextResponse();
+ if (response == null)
+ complete = true;
+
+ return response;
+ }
+
+ /**
+ * Reads responses from network and populdates responseList.
+ */
+ private void readResponses() throws java.io.IOException {
- InputStream netStream = new BufferedInputStream(urlConn.getInputStream());
- StringBuffer readBuf = new StringBuffer();
+ InputStream netStream = new BufferedInputStream(urlConn.getInputStream());
+ StringBuffer readBuf = new StringBuffer();
- int bytesRead = 0;
- byte[] buffer = new byte[1024];
+ int bytesRead = 0;
+ byte[] buffer = new byte[1024];
- while ((bytesRead = netStream.read(buffer)) != -1) {
- readBuf.append(new String(buffer, 0, bytesRead));
- }
-
- netStream.close();
- urlConn = null;
+ while ((bytesRead = netStream.read(buffer)) != -1)
+ readBuf.append(new String(buffer, 0, bytesRead));
+
+ netStream.close();
+ urlConn = null;
- Map<String,?> result = null;
+ // parse the JSON response
+ Map<String,?> result = null;
- try {
- result = (Map<String, ?>) new JSONReader(readBuf.toString()).readObject();
- } catch (org.opensrf.util.JSONException ex) {
- ex.printStackTrace();
- return null;
- }
+ try {
+ result = (Map<String, ?>) new JSONReader(readBuf.toString()).readObject();
- String status = result.get("status").toString();
- if (!"200".equals(status)) {
- failed = true;
- // failure = <some new exception>
- }
+ } catch (org.opensrf.util.JSONException ex) {
+ // if this happens, something is wrong
+ Logger.error("Gateway returned bad data " + ex.getStackTrace());
+ return;
+ }
- // gateway always returns a wrapper array with the full results set
- responseList = (List) result.get("payload");
+ // extract the gateway status value
+ String status = result.get("status").toString();
- } catch (java.io.IOException ex) {
- failed = true;
- failure = ex;
+ if (!"200".equals(status)) {
+ return;
+ // throw some new exception
}
- readComplete = true;
- return nextResponse();
+ // gateway always returns a wrapper array with the full results set
+ responseList = (List) result.get("payload");
}
private String compilePostData(String service, Method method) {
@@ -116,10 +117,15 @@ public class GatewayRequest extends HttpRequest {
}
try {
+
// not using URLEncoder because it replaces ' ' with '+'.
uri = new URI("http", "", null, postData.toString(), null);
+
} catch (java.net.URISyntaxException ex) {
- ex.printStackTrace();
+
+ // if this happens, something is wrong
+ Logger.error("Error compiling POST data " + ex.getStackTrace());
+ return null;
}
return uri.getRawQuery();
diff --git a/src/java/org/opensrf/net/http/HttpConnection.java b/src/java/org/opensrf/net/http/HttpConnection.java
index 32fdebc..c40b9f9 100644
--- a/src/java/org/opensrf/net/http/HttpConnection.java
+++ b/src/java/org/opensrf/net/http/HttpConnection.java
@@ -29,12 +29,17 @@ public class HttpConnection {
url = new URL(fullUrl);
}
+ /**
+ * Maximun number of threads allowed to communicate with the server.
+ */
public int getMaxThreads() {
return maxThreads;
}
/**
- * Set the maximum number of actively communicating threads allowed
+ * Set the maximum number of actively communicating (async) threads allowed.
+ *
+ * This has no effect on synchronous communication.
*/
public void setMaxThreads(int max) {
maxThreads = max;
@@ -66,19 +71,22 @@ public class HttpConnection {
//thread if necessary, then pass the result to the handler
Runnable r = new Runnable() {
public void run() {
-
Object response;
- request.send();
- while ((response = request.recv()) != null) {
- if (request.handler != null)
+ try {
+ request.send();
+ while ((response = request.recv()) != null)
request.handler.onResponse(request, response);
- }
- if (request.handler != null)
request.handler.onComplete(request);
- activeThreads--;
+ } catch (Exception ex) {
+ request.handler.onError(request, ex);
+
+ } finally {
+ // server communication has completed
+ activeThreads--;
+ }
if (activeThreads < maxThreads) {
try {
diff --git a/src/java/org/opensrf/net/http/HttpRequest.java b/src/java/org/opensrf/net/http/HttpRequest.java
index d91a127..8a4a39f 100644
--- a/src/java/org/opensrf/net/http/HttpRequest.java
+++ b/src/java/org/opensrf/net/http/HttpRequest.java
@@ -8,23 +8,41 @@ import java.net.HttpURLConnection;
public abstract class HttpRequest {
+ /** OpenSRF service. */
protected String service;
+ /** OpenSRF method. */
protected Method method;
+ /** Connection to server. */
protected HttpURLConnection urlConn;
+ /** Connection manager. */
protected HttpConnection httpConn;
- protected HttpRequestHandler handler;
+
+ /**
+ * List of responses.
+ *
+ * Responses are not kept after being passed to onResponse .
+ */
protected List<Object> responseList;
- protected Exception failure;
- protected boolean failed;
+
+ /** True if all responses data has been read and delivered */
protected boolean complete;
+ // use a no-op handler by default
+ protected HttpRequestHandler handler = new HttpRequestHandler() {};
+
public HttpRequest() {
- failed = false;
complete = false;
handler = null;
urlConn = null;
}
+ /**
+ * Constructor.
+ *
+ * @param conn Connection
+ * @param service The OpenSRF service.
+ * @param method The method to send to the server.
+ */
public HttpRequest(HttpConnection conn, String service, Method method) {
this();
this.httpConn = conn;
@@ -32,8 +50,14 @@ public abstract class HttpRequest {
this.method = method;
}
+ /**
+ * Send a request asynchronously (via threads).
+ *
+ * @param handler Manages responses
+ */
public void sendAsync(final HttpRequestHandler handler) {
- this.handler = handler;
+ if (handler != null)
+ this.handler = handler;
httpConn.manageAsyncRequest(this);
}
@@ -48,19 +72,24 @@ public abstract class HttpRequest {
}
protected Object nextResponse() {
- if (complete || failed) return null;
+ if (complete || responseList == null)
+ return null;
if (responseList.size() > 0)
return responseList.remove(0);
return null;
}
- public Exception getFailure() {
- return failure;
- }
-
- public abstract HttpRequest send();
+ /**
+ * Send a request to the server.
+ */
+ public abstract GatewayRequest send() throws java.io.IOException;
- public abstract Object recv();
+ /**
+ * Receive one response from the server.
+ *
+ * @return The response object
+ */
+ public abstract Object recv() throws java.io.IOException;
}
diff --git a/src/java/org/opensrf/net/http/HttpRequestHandler.java b/src/java/org/opensrf/net/http/HttpRequestHandler.java
index 9c0f9e5..c30a4f6 100644
--- a/src/java/org/opensrf/net/http/HttpRequestHandler.java
+++ b/src/java/org/opensrf/net/http/HttpRequestHandler.java
@@ -1,5 +1,6 @@
package org.opensrf.net.http;
+import org.opensrf.util.*;
import java.util.List;
/*
@@ -9,8 +10,6 @@ public abstract class HttpRequestHandler {
/**
* Called when all responses have been received.
- *
- * If discardResponses() returns true, will be passed null.
*/
public void onComplete(HttpRequest request) {
}
@@ -22,4 +21,8 @@ public abstract class HttpRequestHandler {
*/
public void onResponse(HttpRequest request, Object response) {
}
+
+ public void onError(HttpRequest request, Exception ex) {
+ Logger.error("HttpRequest Error: " + ex.getStackTrace());
+ }
}
diff --git a/src/java/org/opensrf/test/TestGateway.java b/src/java/org/opensrf/test/TestGateway.java
index 967e929..1ac6d90 100644
--- a/src/java/org/opensrf/test/TestGateway.java
+++ b/src/java/org/opensrf/test/TestGateway.java
@@ -10,47 +10,67 @@ import java.util.Arrays;
public class TestGateway {
- public static void main(String[] args) throws java.net.MalformedURLException {
+ public static void main(String[] args) {
if (args.length == 0) {
System.err.println("Please provide a gateway URL: e.g. http://example.org/osrf-gateway-v1");
return;
}
- // configure the connection
- HttpConnection conn = new HttpConnection(args[0]);
+ try {
- Method method = new Method("opensrf.system.echo");
- method.addParam("Hello, Gateway");
- method.addParam(new Integer(12345));
- method.addParam(new Boolean(true));
- method.addParam(Arrays.asList(8,6,7,5,3,0,9));
+ // configure the connection
+ HttpConnection conn = new HttpConnection(args[0]);
- // sync test
- HttpRequest req = new GatewayRequest(conn, "opensrf.math", method).send();
- Object resp;
- while ( (resp = req.recv()) != null) {
- System.out.println("Sync Response: " + resp);
- }
+ Method method = new Method("opensrf.system.echo");
+ method.addParam("Hello, Gateway");
+ method.addParam(new Integer(12345));
+ method.addParam(new Boolean(true));
+ method.addParam(Arrays.asList(8,6,7,5,3,0,9));
- // exceptions are captured instead of thrown,
- // primarily to better support async requests
- if (req.failed()) {
- req.getFailure().printStackTrace();
- return;
- }
+ // sync test
+ HttpRequest req = new GatewayRequest(conn, "opensrf.math", method).send();
+ Object resp;
+ while ( (resp = req.recv()) != null) {
+ System.out.println("Sync Response: " + resp);
+ }
+
+ // async test
+ for (int i = 0; i < 10; i++) {
+ final int ii = i; // required for nested class
+ HttpRequest req2 = new GatewayRequest(conn, "opensrf.math", method);
+
+ req2.sendAsync(
+ new HttpRequestHandler() {
- // async test
- for (int i = 0; i < 10; i++) {
- final int ii = i; // required for nested class
- HttpRequest req2 = new GatewayRequest(conn, "opensrf.math", method);
- req2.sendAsync(
- new HttpRequestHandler() {
- public void onResponse(HttpRequest req, Object resp) {
- System.out.println("Async Response: " + ii + " : " + resp);
+ // called once per response
+ public void onResponse(HttpRequest req, Object resp) {
+ System.out.println("Async Response: " + ii + " : " + resp);
+ }
+
+ // called after all responses have been received
+ // used primarily when you don't know how many responses will be returned
+ public void onComplete(HttpRequest req) {
+ System.out.println("Async Request complete : " + ii);
+ }
+
+ // ruh-roh
+ public void onError(HttpRequest req, Exception ex) {
+ if (ex instanceof java.io.IOException)
+ System.err.println("Trouble communicating with gateway server!");
+ ex.printStackTrace();
+ }
}
- }
- );
+ );
+ }
+
+ } catch (java.net.MalformedURLException ex) {
+ System.err.println("Malformed Gateway URL! " + args[0]);
+ ex.printStackTrace();
+
+ } catch (java.io.IOException ex) {
+ System.err.println("Trouble communicating with gateway server!");
+ ex.printStackTrace();
}
}
}
commit 1a12279baf16fa32e931d932a7043396217288f1
Author: Bill Erickson <berick at esilibrary.com>
Date: Thu Mar 15 17:26:16 2012 -0400
Java gateway interface test class
Signed-off-by: Bill Erickson <berick at esilibrary.com>
Signed-off-by: Dan Scott <dscott at laurentian.ca>
diff --git a/src/java/org/opensrf/test/TestGateway.java b/src/java/org/opensrf/test/TestGateway.java
new file mode 100644
index 0000000..967e929
--- /dev/null
+++ b/src/java/org/opensrf/test/TestGateway.java
@@ -0,0 +1,58 @@
+package org.opensrf.test;
+
+import org.opensrf.*;
+import org.opensrf.util.*;
+import org.opensrf.net.http.*;
+
+import java.net.URL;
+import java.util.List;
+import java.util.Arrays;
+
+public class TestGateway {
+
+ public static void main(String[] args) throws java.net.MalformedURLException {
+
+ if (args.length == 0) {
+ System.err.println("Please provide a gateway URL: e.g. http://example.org/osrf-gateway-v1");
+ return;
+ }
+
+ // configure the connection
+ HttpConnection conn = new HttpConnection(args[0]);
+
+ Method method = new Method("opensrf.system.echo");
+ method.addParam("Hello, Gateway");
+ method.addParam(new Integer(12345));
+ method.addParam(new Boolean(true));
+ method.addParam(Arrays.asList(8,6,7,5,3,0,9));
+
+ // sync test
+ HttpRequest req = new GatewayRequest(conn, "opensrf.math", method).send();
+ Object resp;
+ while ( (resp = req.recv()) != null) {
+ System.out.println("Sync Response: " + resp);
+ }
+
+ // exceptions are captured instead of thrown,
+ // primarily to better support async requests
+ if (req.failed()) {
+ req.getFailure().printStackTrace();
+ return;
+ }
+
+ // async test
+ for (int i = 0; i < 10; i++) {
+ final int ii = i; // required for nested class
+ HttpRequest req2 = new GatewayRequest(conn, "opensrf.math", method);
+ req2.sendAsync(
+ new HttpRequestHandler() {
+ public void onResponse(HttpRequest req, Object resp) {
+ System.out.println("Async Response: " + ii + " : " + resp);
+ }
+ }
+ );
+ }
+ }
+}
+
+
commit 022c83e8b00220349a64a8fdae6d39cc161ad9e2
Author: Bill Erickson <berick at esilibrary.com>
Date: Mon Feb 27 18:05:07 2012 -0500
Java HTTP gateway interface
Supports sync and async requests. Async requests support onResponse,
onComplete, and onError handlers.
Supports a max-threads value to limit the number of activately
communicating threads over any connection. When max-threads is reached,
requests are queued and delivered as soon as there is room.
Note that since this is talking to the OpenSRF gateway and not the
translater, responses are simply collected and passed one at a time to
onResponse. They are not streamed. The goal of supporting onResponse
is to provide the same client API for both the gateway and translator.
Signed-off-by: Bill Erickson <berick at esilibrary.com>
Signed-off-by: Dan Scott <dscott at laurentian.ca>
diff --git a/src/java/org/opensrf/net/http/GatewayRequest.java b/src/java/org/opensrf/net/http/GatewayRequest.java
new file mode 100644
index 0000000..00631bf
--- /dev/null
+++ b/src/java/org/opensrf/net/http/GatewayRequest.java
@@ -0,0 +1,129 @@
+package org.opensrf.net.http;
+
+import org.opensrf.*;
+import org.opensrf.util.*;
+
+import java.io.IOException;
+import java.io.BufferedInputStream;
+import java.io.OutputStreamWriter;
+import java.io.InputStream;
+import java.io.IOException;
+import java.net.URL;
+import java.net.URI;
+import java.net.HttpURLConnection;
+import java.lang.StringBuffer;
+import java.util.List;
+import java.util.Iterator;
+import java.util.Map;
+import java.util.HashMap;
+import java.util.Queue;
+import java.util.concurrent.ConcurrentLinkedQueue;
+
+public class GatewayRequest extends HttpRequest {
+
+ private boolean readComplete;
+
+ public GatewayRequest(HttpConnection conn, String service, Method method) {
+ super(conn, service, method);
+ readComplete = false;
+ }
+
+ public GatewayRequest send() {
+ try {
+
+ String postData = compilePostData(service, method);
+
+ urlConn = (HttpURLConnection) httpConn.url.openConnection();
+ urlConn.setRequestProperty("Content-Type", "application/x-www-form-urlencoded");
+ urlConn.setDoInput(true);
+ urlConn.setDoOutput(true);
+
+ OutputStreamWriter wr = new OutputStreamWriter(urlConn.getOutputStream());
+ wr.write(postData);
+ wr.flush();
+ wr.close();
+
+ } catch (java.io.IOException ex) {
+ failed = true;
+ failure = ex;
+ }
+
+ return this;
+ }
+
+ public Object recv() {
+
+ if (readComplete)
+ return nextResponse();
+
+ try {
+
+ InputStream netStream = new BufferedInputStream(urlConn.getInputStream());
+ StringBuffer readBuf = new StringBuffer();
+
+ int bytesRead = 0;
+ byte[] buffer = new byte[1024];
+
+ while ((bytesRead = netStream.read(buffer)) != -1) {
+ readBuf.append(new String(buffer, 0, bytesRead));
+ }
+
+ netStream.close();
+ urlConn = null;
+
+ Map<String,?> result = null;
+
+ try {
+ result = (Map<String, ?>) new JSONReader(readBuf.toString()).readObject();
+ } catch (org.opensrf.util.JSONException ex) {
+ ex.printStackTrace();
+ return null;
+ }
+
+ String status = result.get("status").toString();
+ if (!"200".equals(status)) {
+ failed = true;
+ // failure = <some new exception>
+ }
+
+ // gateway always returns a wrapper array with the full results set
+ responseList = (List) result.get("payload");
+
+ } catch (java.io.IOException ex) {
+ failed = true;
+ failure = ex;
+ }
+
+ readComplete = true;
+ return nextResponse();
+ }
+
+ private String compilePostData(String service, Method method) {
+ URI uri = null;
+ StringBuffer postData = new StringBuffer();
+
+ postData.append("service=");
+ postData.append(service);
+ postData.append("&method=");
+ postData.append(method.getName());
+
+ List params = method.getParams();
+ Iterator itr = params.iterator();
+
+ while (itr.hasNext()) {
+ postData.append("¶m=");
+ postData.append(new JSONWriter(itr.next()).write());
+ }
+
+ try {
+ // not using URLEncoder because it replaces ' ' with '+'.
+ uri = new URI("http", "", null, postData.toString(), null);
+ } catch (java.net.URISyntaxException ex) {
+ ex.printStackTrace();
+ }
+
+ return uri.getRawQuery();
+ }
+}
+
+
diff --git a/src/java/org/opensrf/net/http/HttpConnection.java b/src/java/org/opensrf/net/http/HttpConnection.java
new file mode 100644
index 0000000..32fdebc
--- /dev/null
+++ b/src/java/org/opensrf/net/http/HttpConnection.java
@@ -0,0 +1,97 @@
+package org.opensrf.net.http;
+
+import java.net.URL;
+import java.net.MalformedURLException;
+import java.util.Queue;
+import java.util.concurrent.ConcurrentLinkedQueue;
+import org.opensrf.*;
+import org.opensrf.util.*;
+
+
+/**
+ * Manages connection parameters and thread limiting for opensrf json gateway connections.
+ */
+
+public class HttpConnection {
+
+ /** Compiled URL object */
+ protected URL url;
+ /** Number of threads currently communicating with the server */
+ protected int activeThreads;
+ /** Queue of pending async requests */
+ protected Queue<HttpRequest> pendingThreadQueue;
+ /** maximum number of actively communicating threads allowed */
+ protected int maxThreads = 10;
+
+ public HttpConnection(String fullUrl) throws java.net.MalformedURLException {
+ activeThreads = 0;
+ pendingThreadQueue = new ConcurrentLinkedQueue();
+ url = new URL(fullUrl);
+ }
+
+ public int getMaxThreads() {
+ return maxThreads;
+ }
+
+ /**
+ * Set the maximum number of actively communicating threads allowed
+ */
+ public void setMaxThreads(int max) {
+ maxThreads = max;
+ }
+
+ /**
+ * Launches or queues an asynchronous request.
+ *
+ * If the maximum active thread count has not been reached,
+ * start a new thread and use it to send and receive the request.
+ * The response is passed to the request's HttpRequestHandler
+ * onComplete(). After complete, if the number of active threads
+ * is still lower than the max, one request will be pulled (if
+ * present) from the async queue and fired.
+ *
+ * If there are too many active threads, the main request is
+ * pushed onto the async queue for later processing
+ */
+ protected void manageAsyncRequest(final HttpRequest request) {
+
+ if (activeThreads >= maxThreads) {
+ pendingThreadQueue.offer(request);
+ return;
+ }
+
+ activeThreads++;
+
+ //Send the request receive the response, fire off the next
+ //thread if necessary, then pass the result to the handler
+ Runnable r = new Runnable() {
+ public void run() {
+
+ Object response;
+ request.send();
+
+ while ((response = request.recv()) != null) {
+ if (request.handler != null)
+ request.handler.onResponse(request, response);
+ }
+
+ if (request.handler != null)
+ request.handler.onComplete(request);
+
+ activeThreads--;
+
+ if (activeThreads < maxThreads) {
+ try {
+ manageAsyncRequest(pendingThreadQueue.remove());
+ } catch (java.util.NoSuchElementException ex) {
+ // may have been gobbled by another thread
+ }
+ }
+ }
+ };
+
+ new Thread(r).start();
+ }
+}
+
+
diff --git a/src/java/org/opensrf/net/http/HttpRequest.java b/src/java/org/opensrf/net/http/HttpRequest.java
new file mode 100644
index 0000000..d91a127
--- /dev/null
+++ b/src/java/org/opensrf/net/http/HttpRequest.java
@@ -0,0 +1,66 @@
+package org.opensrf.net.http;
+import org.opensrf.*;
+import org.opensrf.util.*;
+
+import java.util.List;
+import java.util.LinkedList;
+import java.net.HttpURLConnection;
+
+public abstract class HttpRequest {
+
+ protected String service;
+ protected Method method;
+ protected HttpURLConnection urlConn;
+ protected HttpConnection httpConn;
+ protected HttpRequestHandler handler;
+ protected List<Object> responseList;
+ protected Exception failure;
+ protected boolean failed;
+ protected boolean complete;
+
+ public HttpRequest() {
+ failed = false;
+ complete = false;
+ handler = null;
+ urlConn = null;
+ }
+
+ public HttpRequest(HttpConnection conn, String service, Method method) {
+ this();
+ this.httpConn = conn;
+ this.service = service;
+ this.method = method;
+ }
+
+ public void sendAsync(final HttpRequestHandler handler) {
+ this.handler = handler;
+ httpConn.manageAsyncRequest(this);
+ }
+
+ protected void pushResponse(Object response) {
+ if (responseList == null)
+ responseList = new LinkedList<Object>();
+ responseList.add(response);
+ }
+
+ protected List responses() {
+ return responseList;
+ }
+
+ protected Object nextResponse() {
+ if (complete || failed) return null;
+ if (responseList.size() > 0)
+ return responseList.remove(0);
+ return null;
+ }
+
+ public Exception getFailure() {
+ return failure;
+ }
+
+ public abstract HttpRequest send();
+
+ public abstract Object recv();
+}
+
+
diff --git a/src/java/org/opensrf/net/http/HttpRequestHandler.java b/src/java/org/opensrf/net/http/HttpRequestHandler.java
new file mode 100644
index 0000000..9c0f9e5
--- /dev/null
+++ b/src/java/org/opensrf/net/http/HttpRequestHandler.java
@@ -0,0 +1,25 @@
+package org.opensrf.net.http;
+
+import java.util.List;
+
+/*
+ * Handler for async gateway responses.
+ */
+public abstract class HttpRequestHandler {
+
+ /**
+ * Called when all responses have been received.
+ *
+ * If discardResponses() returns true, will be passed null.
+ */
+ public void onComplete(HttpRequest request) {
+ }
+
+ /**
+ * Called with each response received from the server.
+ *
+ * @param payload the value returned from the server.
+ */
+ public void onResponse(HttpRequest request, Object response) {
+ }
+}
-----------------------------------------------------------------------
Summary of changes:
src/java/deps.sh | 2 +-
src/java/org/opensrf/net/http/GatewayRequest.java | 135 ++++++++++++++++++++
src/java/org/opensrf/net/http/HttpConnection.java | 105 +++++++++++++++
src/java/org/opensrf/net/http/HttpRequest.java | 95 ++++++++++++++
.../org/opensrf/net/http/HttpRequestHandler.java | 28 ++++
src/java/org/opensrf/test/TestGateway.java | 78 +++++++++++
6 files changed, 442 insertions(+), 1 deletions(-)
create mode 100644 src/java/org/opensrf/net/http/GatewayRequest.java
create mode 100644 src/java/org/opensrf/net/http/HttpConnection.java
create mode 100644 src/java/org/opensrf/net/http/HttpRequest.java
create mode 100644 src/java/org/opensrf/net/http/HttpRequestHandler.java
create mode 100644 src/java/org/opensrf/test/TestGateway.java
hooks/post-receive
--
OpenSRF
More information about the opensrf-commits
mailing list