Session refactor (#6)

* Thread safety refactor of http session management.

Make session management explicitly managed by callers to `access_url`.
This enables each caller to protect the session from threading issues
in a way that best matches their particular model.  For Snowflakerestful
this is managed as a pool of sessions;  For chunk_downloader I will
implement something similar that provides for good reuse and cleanup
of each session while achieving as much connection pooling as can be
done safely.

* Session consolidation

Fairly large refactor in the spirit of consolidating HTTP call-patterns
and configuration.

Changed `SnowflakeRestful.access_url` from a staticmethod to a regular
instance method, reborn as a `fetch`.  The name change helps distinguish
the type of activity being performed, but is otherwise cosmetic.

Requests session pooling is manged in one place by the SnowflakeRestful
instance regardless of the type of HTTP activity.  This provides the best
session reuse possible with consistent thread safety characteristics.
Note that the `requests.Session` objects are created outside their final
execution thread, but they are never used by more than one request thread
at a time.

Other changes:
 - Moved network.py logger instance to module level.
 - DRY optimizations for _get_request, _post_request, etc. Namely
   consolidation of proxy and timeout settings.
 - Default `fetch`'s keyword arg `token` to `network.NOTOKEN`.
     I believe this is semantically acceptable (or desirable) but
     should be reviewed.
 - Renamed `chunk_downloader`'s `_get_request` to `_fetch_chunk` to
   more aptly associate it with `SnowflakeRestful.fetch()`.
 - Renamed `request_thread` function to `request_exec` as it is not
   always a thread target.

Author: mayfield

chunk_downloader.py

@@ -11,8 +11,6 @@
 
 from .errorcode import (ER_NO_ADDITIONAL_CHUNK, ER_CHUNK_DOWNLOAD_FAILED)
 from .errors import (Error, OperationalError)
-from .network import (SnowflakeRestful, NO_TOKEN, MAX_CONNECTION_POOL)
-from .ssl_wrap_socket import (set_proxies)
 
 DEFAULT_REQUEST_TIMEOUT = 3600
 DEFAULT_CLIENT_RESULT_PREFETCH_SLOTS = 2
@@ -126,9 +124,7 @@ def _download_chunk(self, idx):
 
             logger.debug(u"started getting the result set %s: %s",
                          idx + 1, self._chunks[idx].url)
-            result_data = self._get_request(
-                self._chunks[idx].url,
-                headers, max_connection_pool=self._effective_threads)
+            result_data = self._fetch_chunk(self._chunks[idx].url, headers)
             logger.debug(u"finished getting the result set %s: %s",
                          idx + 1, self._chunks[idx].url)
 
@@ -255,35 +251,15 @@ def __del__(self):
             # ignore all errors in the destructor
             pass
 
-    def _get_request(
-            self, url, headers,
-            is_raw_binary_iterator=True,
-            max_connection_pool=MAX_CONNECTION_POOL):
+    def _fetch_chunk(self, url, headers):
         """
-        GET request for Large Result set chunkloader
+        Fetch the chunk from S3.
         """
-        # sharing the proxy and certificate
-        proxies = set_proxies(
-            self._connection.rest._proxy_host,
-            self._connection.rest._proxy_port,
-            self._connection.rest._proxy_user,
-            self._connection.rest._proxy_password)
-
-        logger.debug(u'proxies=%s, url=%s', proxies, url)
-
-        return SnowflakeRestful.access_url(
-            self._connection,
-            self,
-            u'get',
-            full_url=url,
-            headers=headers,
-            data=None,
-            proxies=proxies,
-            timeout=(self._connection._connect_timeout,
-                     self._connection._connect_timeout,
-                     DEFAULT_REQUEST_TIMEOUT),
-            token=NO_TOKEN,
-            is_raw_binary=True,
-            is_raw_binary_iterator=is_raw_binary_iterator,
-            max_connection_pool=max_connection_pool,
+        timeouts = (
+            self._connection._connect_timeout,
+            self._connection._connect_timeout,
+            DEFAULT_REQUEST_TIMEOUT
+        )
+        return self._connection.rest.fetch(u'get', url, headers,
+            timeouts=timeouts, is_raw_binary=True, is_raw_binary_iterator=True,
             use_ijson=self._use_ijson)

connection.py

@@ -35,6 +35,7 @@
 import logging
 from logging import getLogger
 
+
 # default configs
 DEFAULT_CONFIGURATION = {
     u'dsn': None,  # standard
@@ -72,7 +73,6 @@
     u'session_parameters': None,  # snowflake internal
     u'autocommit': None,  # snowflake
     u'numpy': False,  # snowflake
-    u'max_connection_pool': network.MAX_CONNECTION_POOL,  # snowflake internal
     u'ocsp_response_cache_filename': None,  # snowflake internal
     u'converter_class': SnowflakeConverter,  # snowflake internal
     u'chunk_downloader_class': SnowflakeChunkDownloader,  # snowflake internal
@@ -428,7 +428,6 @@ def __open_connection(self, mfa_callback, password_callback):
             connect_timeout=self._connect_timeout,
             request_timeout=self._request_timeout,
             injectClientPause=self._injectClientPause,
-            max_connection_pool=self._max_connection_pool,
             connection=self)
         self.logger.debug(u'REST API object was created: %s:%s, proxy=%s:%s, '
                           u'proxy_user=%s',