A few more @seancribbs-inspired changes

- Add `setup_test` command to run `create_bucket_types` and `setup_security`
- Add _create_credentials to RiakClient
- Only store credentials in the RiakClient

Author: Brett Hazen

commands.py

@@ -2,7 +2,8 @@
 distutils commands for riak-python-client
 """
 
-__all__ = ['create_bucket_types', 'setup_security', 'preconfig_security']
+__all__ = ['create_bucket_types', 'setup_security', 'preconfig_security',
+           'setup_tests']
 
 from distutils import log
 from distutils.core import Command
@@ -206,13 +207,16 @@ class setup_security(Command):
 
     def initialize_options(self):
         self.riak_admin = None
-        # Default values:
-        self.username = 'testuser'
-        self.password = 'testpassword'
+        self.username = None
+        self.password = None
 
     def finalize_options(self):
         if self.riak_admin is None:
             raise DistutilsOptionError("riak-admin option not set")
+        if self.username is None:
+            self.username = 'testuser'
+        if self.password is None:
+            self.password = 'testpassword'
 
     def run(self):
         if self._check_available():
@@ -386,3 +390,39 @@ def _backup_file(self, name):
             shutil.copyfile(name, backup)
         else:
             log.info("Cannot backup missing file {!r}".format(name))
+
+
+class setup_tests(Command):
+    """
+    Sets up security configuration.
+
+    * Run setup_security and create_bucket_types
+    """
+
+    description = "create bucket types and security settings for testing"
+
+    user_options = create_bucket_types.user_options + setup_security.user_options
+
+    def initialize_options(self):
+        self.riak_admin = None
+        self.username = None
+        self.password = None
+        pass
+
+    def finalize_options(self):
+        bucket = self.distribution.get_command_obj('create_bucket_types')
+        bucket.riak_admin = self.riak_admin
+        security = self.distribution.get_command_obj('setup_security')
+        security.riak_admin = self.riak_admin
+        security.username = self.username
+        security.password = self.password
+        pass
+
+    def run(self):
+        # Run all relevant sub-commands.
+        for cmd_name in self.get_sub_commands():
+            self.run_command(cmd_name)
+
+    sub_commands = [('create_bucket_types', None),
+                    ('setup_security', None)
+                    ]

riak/client/__init__.py

@@ -34,6 +34,7 @@
 from riak.search import RiakSearch
 from riak.transports.http import RiakHttpPool
 from riak.transports.pbc import RiakPbcPool
+from riak.security import SecurityCreds
 from riak.util import deprecated
 from riak.util import deprecateQuorumAccessors
 from riak.util import lazy_property
@@ -100,7 +101,7 @@ def __init__(self, protocol='http', transport_options={}, nodes=None,
 
         self.protocol = protocol or 'http'
         self.resolver = default_resolver
-        self.credentials = credentials
+        self._credentials = self._create_credentials(credentials)
         self._http_pool = RiakHttpPool(self, **transport_options)
         self._pb_pool = RiakPbcPool(self, **transport_options)
 
@@ -317,6 +318,20 @@ def _create_node(self, n):
             raise TypeError("%s is not a valid node configuration"
                             % repr(n))
 
+    def _create_credentials(self, n):
+        """
+        Create security credentials, if necessary.
+        """
+        if not n:
+            return n
+        elif isinstance(n, SecurityCreds):
+            return n
+        elif isinstance(n, dict):
+            return SecurityCreds(**n)
+        else:
+            raise TypeError("%s is not a valid security configuration"
+                            % repr(n))
+
     def _choose_node(self, nodes=None):
         """
         Chooses a random node from the list of nodes in the client,

riak/transports/http/__init__.py

@@ -50,8 +50,7 @@ def __init__(self, client, **options):
             self.connection_class = httplib.HTTPSConnection
         else:
             self.connection_class = NoNagleHTTPConnection
-        # TODO: Rationalize protocol and security credentials
-        if self.client.credentials:
+        if self.client._credentials:
             self.connection_class = RiakHTTPSConnection
 
         super(RiakHttpPool, self).__init__()

riak/transports/http/connection.py

@@ -35,9 +35,9 @@ def _request(self, method, uri, headers={}, body='', stream=False):
         headers.setdefault('Accept',
                            'multipart/mixed, application/json, */*;q=0.5')
 
-        if self._credentials:
-            self._security_auth_headers(self._credentials.username,
-                                        self._credentials.password,
+        if self._client._credentials:
+            self._security_auth_headers(self._client._credentials.username,
+                                        self._client._credentials.password,
                                         headers)
 
         try:
@@ -60,13 +60,13 @@ def _connect(self):
         """
         Use the appropriate connection class; optionally with security.
         """
-        if self._credentials:
+        if self._client._credentials:
             self._connection = self._connection_class(self._node.host,
-                                                      self._node.https_port,
-                                                      self._credentials)
+                                                      self._node.http_port,
+                                                      self._client._credentials)
         else:
             self._connection = self._connection_class(self._node.host,
-                                                      self._node.https_port)
+                                                      self._node.http_port)
         # Forces the population of stats and resources before any
         # other requests are made.
         self.server_version
@@ -83,7 +83,6 @@ def close(self):
     # These are set by the RiakHttpTransport initializer
     _connection_class = httplib.HTTPConnection
     _node = None
-    credentials = None
 
     def _security_auth_headers(self, username, password, headers):
         """

riak/transports/http/transport.py

@@ -58,8 +58,6 @@ def __init__(self, node=None,
         super(RiakHttpTransport, self).__init__()
 
         self._client = client
-        if self._client:
-            self._credentials = self._client.credentials
         self._node = node
         self._connection_class = connection_class
         self._client_id = client_id

riak/transports/pbc/connection.py

@@ -96,8 +96,8 @@ def _auth(self):
               auth request/response to prevent denial of service attacks
         """
         req = riak_pb.RpbAuthReq()
-        req.user = self._credentials.username
-        req.password = self._credentials.password
+        req.user = self._client._credentials.username
+        req.password = self._client._credentials.password
         msg_code, _ = self._non_connect_request(MSG_CODE_AUTH_REQ, req,
                                                 MSG_CODE_AUTH_RESP)
         if msg_code == MSG_CODE_AUTH_RESP:
@@ -112,9 +112,9 @@ def _ssl_handshake(self):
                      taken place with Riak
         returns True upon success, otherwise an exception is raised
         """
-        if self._credentials:
-            ssl_ctx = OpenSSL.SSL.Context(self._credentials.ssl_version)
-            cacert_file = self._credentials.cacert_file
+        if self._client._credentials:
+            ssl_ctx = OpenSSL.SSL.Context(self._client._credentials.ssl_version)
+            cacert_file = self._client._credentials.cacert_file
             try:
                 ssl_ctx.load_verify_locations(cacert_file)
                 # attempt to upgrade the socket to SSL
@@ -170,7 +170,7 @@ def _connect(self):
                                                         self._timeout)
             else:
                 self._socket = socket.create_connection(self._address)
-        if self._credentials and not self._secure_connection:
+        if self._client._credentials and not self._secure_connection:
             self._check_security()
 
     def close(self):

riak/transports/pbc/transport.py

@@ -91,8 +91,6 @@ def __init__(self,
         super(RiakPbcTransport, self).__init__()
 
         self._client = client
-        if self._client:
-            self._credentials = self._client.credentials
         self._node = node
         self._address = (node.host, node.pb_port)
         self._timeout = timeout

setup.py

@@ -3,7 +3,7 @@
 from setuptools import setup, find_packages
 from version import get_version
 from commands import create_bucket_types, setup_security, \
-    preconfig_security
+    preconfig_security, setup_tests
 
 install_requires = ["riak_pb >=2.0.0", "pyOpenSSL >= 0.14"]
 requires = ["riak_pb(>=2.0.0)", "pyOpenSSL(>=0.14)"]
@@ -31,7 +31,8 @@
     url='https://github.com/basho/riak-python-client',
     cmdclass={'create_bucket_types': create_bucket_types,
               'setup_security': setup_security,
-              'preconfig_security': preconfig_security},
+              'preconfig_security': preconfig_security,
+              'setup_tests': setup_tests},
     classifiers=['License :: OSI Approved :: Apache Software License',
                  'Intended Audience :: Developers',
                  'Operating System :: OS Independent',