Added connection pooling and test

- Added the responsive max pool setting
- Unit test added and passed

Author: Chris Park

rosette/api.py

@@ -482,8 +482,8 @@ def call(self, parameters):
                     'application/json')}
             request = requests.Request(
                 'POST', url, files=files, headers=headers)
-            prepared_request = request.prepare()
             session = requests.Session()
+            prepared_request = session.prepare_request(request)
             resp = session.send(prepared_request)
             rdata = resp.content
             response_headers = {"responseHeaders": dict(resp.headers)}
@@ -512,7 +512,6 @@ def __init__(
             user_key=None,
             service_url='https://api.rosette.com/rest/v1/',
             retries=5,
-            reuse_connection=True,
             refresh_duration=0.5,
             debug=False):
         """ Create an L{API} object.
@@ -534,22 +533,20 @@ def __init__(
             refresh_duration = 0
 
         self.num_retries = retries
-        self.reuse_connection = reuse_connection
         self.connection_refresh_duration = refresh_duration
-        self.http_connection = None
         self.options = {}
         self.customHeaders = {}
+        self.maxPoolSize = 1
+        self.session = requests.Session()
+
+    def _set_pool_size(self):
+        adapter = requests.adapters.HTTPAdapter(pool_maxsize=self.maxPoolSize)
+        if 'https:' in self.service_url:
+            self.session.mount('https://', adapter)
+        else:
+            self.session.mount('http://', adapter)
+
 
-    def _connect(self, parsedUrl):
-        """ Simple connection method
-        @param parsedUrl: The URL on which to process
-        """
-        if not self.reuse_connection or self.http_connection is None:
-            loc = parsedUrl.netloc
-            if parsedUrl.scheme == "https":
-                self.http_connection = httplib.HTTPSConnection(loc)
-            else:
-                self.http_connection = httplib.HTTPConnection(loc)
 
     def _make_request(self, op, url, data, headers):
         """
@@ -561,25 +558,28 @@ def _make_request(self, op, url, data, headers):
         @param headers: request headers
         """
         headers['User-Agent'] = "RosetteAPIPython/" + _BINDING_VERSION
-        parsedUrl = urlparse.urlparse(url)
-
-        self._connect(parsedUrl)
 
         message = None
         code = "unknownError"
         rdata = None
         response_headers = {}
 
         request = requests.Request(op, url, data=data, headers=headers)
-        prepared_request = request.prepare()
         session = requests.Session()
+        prepared_request = session.prepare_request(request)
 
         for i in range(self.num_retries + 1):
             try:
                 response = session.send(prepared_request)
                 status = response.status_code
                 rdata = response.content
-                response_headers = {"responseHeaders": dict(response.headers)}
+                dict_headers = dict(response.headers)
+                response_headers = {"responseHeaders": dict_headers}
+                if 'x-rosetteapi-concurrency' in dict_headers:
+                    if dict_headers['x-rosetteapi-concurrency'] != self.maxPoolSize:
+                        self.maxPoolSize = dict_headers['x-rosetteapi-concurrency']
+                        self._set_pool_size()
+
 
                 if status == 200:
                     return rdata, status, response_headers
@@ -598,6 +598,7 @@ def _make_request(self, op, url, data, headers):
                         else:
                             code = status
                         raise RosetteException(code, message, url)
+
                     except:
                         raise
             except requests.exceptions.RequestException as e:
@@ -606,9 +607,6 @@ def _make_request(self, op, url, data, headers):
                     "Unable to establish connection to the Rosette API server",
                     url)
 
-        if not self.reuse_connection:
-            self.http_connection.close()
-
         raise RosetteException(code, message, url)
 
     def _get_http(self, url, headers):
@@ -644,6 +642,12 @@ def _post_http(self, url, data, headers):
 
         return _ReturnObject(_my_loads(rdata, response_headers), status)
 
+    def getPoolSize(self):
+        """
+        Returns the maximum pool size, which is the returned x-rosetteapi-concurrency value
+        """
+        return int(self.maxPoolSize)
+
     def setOption(self, name, value):
         """
         Sets an option

tests/test_rosette_api.py

@@ -170,6 +170,24 @@ def test_for_409(api, json_409):
     httpretty.disable()
     httpretty.reset()
 
+# Test the maxPoolSize
+
+
+def test_the_max_pool_size(json_response, doc_params):
+    httpretty.enable()
+    httpretty.register_uri(httpretty.POST, "https://api.rosette.com/rest/v1/language",
+                           body=json_response, status=200, content_type="application/json",
+                           adding_headers={
+                               'x-rosetteapi-concurrency': 5
+                           })
+    api = API('bogus_key')
+    assert api.getPoolSize() == 1
+    result = api.language(doc_params)
+    assert result["name"] == "Rosette API"
+    assert api.getPoolSize() == 5
+    httpretty.disable()
+    httpretty.reset()
+
 # Test the language endpoint