prepare 6.10.2 release (#131)

LaunchDarklyCI · web-flow · commit 874ea5480105 · 2019-10-30T16:52:34.000-07:00
diff --git a/.ldrelease/update-version.sh b/.ldrelease/update-version.sh
diff --git a/docs/api-main.rst b/docs/api-main.rst
@@ -6,35 +6,28 @@ ldclient module
 
 .. automodule:: ldclient
     :members: get,set_config,set_sdk_key
-    :show-inheritance:
 
 ldclient.client module
 ----------------------
 
 .. automodule:: ldclient.client
     :members: LDClient
-    :special-members: __init__
-    :show-inheritance:
 
 ldclient.config module
 ----------------------
 
 .. automodule:: ldclient.config
     :members:
-    :special-members: __init__
-    :show-inheritance:
 
 ldclient.flag module
 --------------------
 
 .. automodule:: ldclient.flag
     :members: EvaluationDetail
-    :special-members: __init__
-    :show-inheritance:
 
 ldclient.flags_state module
 ---------------------------
 
 .. automodule:: ldclient.flags_state
     :members:
-    :show-inheritance:
+    :exclude-members: __init__, add_flag
diff --git a/docs/conf.py b/docs/conf.py
@@ -167,8 +167,6 @@
 # -- Extension configuration -------------------------------------------------
 
 autodoc_default_options = {
-    'members': None,
-    'show-inheritance': None,
-    'special-members': None,
-    'undoc-members': None
+    'special-members': '__init__',
+    'undoc-members': False
 }
diff --git a/ldclient/event_processor.py b/ldclient/event_processor.py
@@ -211,7 +211,8 @@ class EventDispatcher(object):
     def __init__(self, inbox, config, http_client):
         self._inbox = inbox
         self._config = config
-        self._http = create_http_pool_manager(num_pools=1, verify_ssl=config.verify_ssl) if http_client is None else http_client
+        self._http = create_http_pool_manager(num_pools=1, verify_ssl=config.verify_ssl,
+            target_base_uri=config.events_uri) if http_client is None else http_client
         self._close_http = (http_client is None)  # so we know whether to close it later
         self._disabled = False
         self._outbox = EventBuffer(config.events_max_pending)
@@ -388,5 +389,5 @@ def _post_message_and_wait(self, type):
     def __enter__(self):
         return self
     
-    def __exit__(self, tyep, value, traceback):
+    def __exit__(self, type, value, traceback):
         self.stop()
diff --git a/ldclient/feature_requester.py b/ldclient/feature_requester.py
@@ -25,7 +25,7 @@
 class FeatureRequesterImpl(FeatureRequester):
     def __init__(self, config):
         self._cache = dict()
-        self._http = create_http_pool_manager(num_pools=1, verify_ssl=config.verify_ssl)
+        self._http = create_http_pool_manager(num_pools=1, verify_ssl=config.verify_ssl, target_base_uri=config.base_uri)
         self._config = config
 
     def get_all_data(self):
@@ -36,7 +36,7 @@ def get_all_data(self):
         }
 
     def get_one(self, kind, key):
-        return self._do_request(kind.request_api_path + '/' + key, False)
+        return self._do_request(self._config.base_uri + kind.request_api_path + '/' + key, False)
 
     def _do_request(self, uri, allow_cache):
         hdrs = _headers(self._config.sdk_key)
@@ -49,7 +49,7 @@ def _do_request(self, uri, allow_cache):
                                timeout=urllib3.Timeout(connect=self._config.connect_timeout, read=self._config.read_timeout),
                                retries=1)
         throw_if_unsuccessful_response(r)
-        if r.status == 304 and cache_entry is not None:
+        if r.status == 304 and allow_cache and cache_entry is not None:
             data = cache_entry.data
             etag = cache_entry.etag
             from_cache = True
diff --git a/ldclient/sse_client.py b/ldclient/sse_client.py
@@ -32,7 +32,7 @@ def __init__(self, url, last_id=None, retry=3000, connect_timeout=10, read_timeo
         self._chunk_size = chunk_size
 
         # Optional support for passing in an HTTP client
-        self.http = create_http_pool_manager(num_pools=1, verify_ssl=verify_ssl)
+        self.http = create_http_pool_manager(num_pools=1, verify_ssl=verify_ssl, target_base_uri=url)
 
         # Any extra kwargs will be fed into the request call later.
         self.requests_kwargs = kwargs
diff --git a/ldclient/streaming.py b/ldclient/streaming.py
@@ -154,3 +154,10 @@ def _parse_path(path):
             if path.startswith(kind.stream_api_path):
                 return ParsedPath(kind = kind, key = path[len(kind.stream_api_path):])
         return None
+
+    # magic methods for "with" statement (used in testing)
+    def __enter__(self):
+        return self
+    
+    def __exit__(self, type, value, traceback):
+        self.stop()
diff --git a/ldclient/util.py b/ldclient/util.py
@@ -5,6 +5,7 @@
 
 import certifi
 import logging
+from os import environ
 import six
 import sys
 import urllib3
@@ -84,15 +85,37 @@ def status(self):
         return self._status
 
 
-def create_http_pool_manager(num_pools=1, verify_ssl=False):
+def create_http_pool_manager(num_pools=1, verify_ssl=False, target_base_uri=None):
+    proxy_url = _get_proxy_url(target_base_uri)
+
     if not verify_ssl:
-        return urllib3.PoolManager(num_pools=num_pools)
-    return urllib3.PoolManager(
-        num_pools=num_pools,
-        cert_reqs='CERT_REQUIRED',
-        ca_certs=certifi.where()
+        if proxy_url is None:
+            return urllib3.PoolManager(num_pools=num_pools)
+        else:
+            return urllib3.ProxyManager(proxy_url, num_pools=num_pools)
+    
+    if proxy_url is None:
+        return urllib3.PoolManager(
+            num_pools=num_pools,
+            cert_reqs='CERT_REQUIRED',
+            ca_certs=certifi.where()
+            )
+    else:
+        return urllib3.ProxyManager(
+            proxy_url,
+            num_pools=num_pools,
+            cert_reqs='CERT_REQUIRED',
+            ca_certs=certifi.where()
         )
 
+def _get_proxy_url(target_base_uri):
+    if target_base_uri is None:
+        return None
+    is_https = target_base_uri.startswith('https:')
+    if is_https:
+        return environ.get('https_proxy')
+    return environ.get('http_proxy')
+
 
 def throw_if_unsuccessful_response(resp):
     if resp.status >= 400:
diff --git a/scripts/release.sh b/scripts/release.sh
@@ -13,14 +13,9 @@ echo "Starting python-server-sdk release."
 
 VERSION=$1
 
-#Update version in ldclient/version.py
+# Update version in ldclient/version.py - setup.py references this constant
 echo "VERSION = \"${VERSION}\"" > ldclient/version.py
 
-# Update version in setup.py
-SETUP_PY_TEMP=./setup.py.tmp
-sed "s/ldclient_version=.*/ldclient_version='${VERSION}'/g" setup.py > ${SETUP_PY_TEMP}
-mv ${SETUP_PY_TEMP} setup.py
-
 # Prepare distribution
 python setup.py sdist
 
diff --git a/setup.py b/setup.py
@@ -3,15 +3,19 @@
 import sys
 import uuid
 
-
+# Get VERSION constant from ldclient.version - we can't simply import that module because
+# ldclient/__init__.py imports all kinds of stuff that requires dependencies we may not have
+# loaded yet. Based on https://packaging.python.org/guides/single-sourcing-package-version/
+version_module_globals = {}
+with open('./ldclient/version.py') as f:
+    exec(f.read(), version_module_globals)
+ldclient_version = version_module_globals['VERSION']
+    
 def parse_requirements(filename):
     """ load requirements from a pip requirements file """
     lineiter = (line.strip() for line in open(filename))
     return [line for line in lineiter if line and not line.startswith("#")]
 
-
-ldclient_version='6.10.1'
-
 # parse_requirements() returns generator of pip.req.InstallRequirement objects
 install_reqs = parse_requirements('requirements.txt')
 test_reqs = parse_requirements('test-requirements.txt')
diff --git a/testing/http_util.py b/testing/http_util.py
@@ -0,0 +1,92 @@
+import json
+from six import iteritems
+from six.moves import BaseHTTPServer, queue
+import socket
+from threading import Thread
+
+def get_available_port():
+    s = socket.socket(socket.AF_INET, type = socket.SOCK_STREAM)
+    s.bind(('localhost', 0))
+    _, port = s.getsockname()
+    s.close()
+    return port
+
+def start_server():
+    sw = MockServerWrapper(get_available_port())
+    sw.start()
+    return sw
+
+class MockServerWrapper(Thread):
+    def __init__(self, port):
+        Thread.__init__(self)
+        self.port = port
+        self.uri = 'http://localhost:%d' % port
+        self.server = BaseHTTPServer.HTTPServer(('localhost', port), MockServerRequestHandler)
+        self.server.server_wrapper = self
+        self.matchers = {}
+        self.requests = queue.Queue()
+    
+    def close(self):
+        self.server.shutdown()
+        self.server.server_close()
+    
+    def run(self):
+        self.server.serve_forever()
+    
+    def setup_response(self, uri_path, status, body = None, headers = None):
+        self.matchers[uri_path] = MockServerResponse(status, body, headers)
+
+    def setup_json_response(self, uri_path, data, headers = None):
+        final_headers = {} if headers is None else headers.copy()
+        final_headers['Content-Type'] = 'application/json'
+        return self.setup_response(uri_path, 200, json.dumps(data), headers)
+
+    def await_request(self):
+        return self.requests.get()
+    
+    def require_request(self):
+        return self.requests.get(block=False)
+    
+    # enter/exit magic methods allow server to be auto-closed by "with" statement
+    def __enter__(self):
+        return self
+
+    def __exit__(self, type, value, traceback):
+        self.close()
+
+class MockServerRequestHandler(BaseHTTPServer.BaseHTTPRequestHandler):
+    def do_CONNECT(self):
+        self._do_request()
+
+    def do_GET(self):
+        self._do_request()
+
+    def do_POST(self):
+        self._do_request()
+
+    def _do_request(self):
+        server_wrapper = self.server.server_wrapper
+        server_wrapper.requests.put(MockServerRequest(self.command, self.path, self.headers))
+        if self.path in server_wrapper.matchers:
+            resp = server_wrapper.matchers[self.path]
+            self.send_response(resp.status)
+            if resp.headers is not None:
+                for key, value in iteritems(resp.headers):
+                    self.send_header(key, value)
+            self.end_headers()
+            if resp.body is not None:
+                self.wfile.write(resp.body.encode('UTF-8'))
+        else:
+            self.send_error(404)
+
+class MockServerRequest(object):
+    def __init__(self, method, path, headers):
+        self.method = method
+        self.path = path
+        self.headers = headers
+
+class MockServerResponse(object):
+    def __init__(self, status, body, headers):
+        self.status = status
+        self.body = body
+        self.headers = headers
diff --git a/testing/test_event_processor.py b/testing/test_event_processor.py
diff --git a/testing/test_feature_requester.py b/testing/test_feature_requester.py
diff --git a/testing/test_streaming.py b/testing/test_streaming.py
