Kolab Groupware OBS

We truncated the diff of some files because they were too big. If you want to see the full diff for every file, click here.

Changes of Revision 2

python-riak.spec Changed

riak-2.1.0.tar.gz/RELEASE_NOTES.md Deleted

@@ -1,241 +0,0 @@
-# Riak Python Client Release Notes
-
-## 2.1.0 Feature Release - 2014-09-03
-
-Release 2.1.0 features support for Riak 2.0 capabilities including:
-
-* Bucket Types
-* Riak Data Types (CRDTs)
-* Search 2.0 (codename Yokozuna)
-* Security: SSL/TLS, Authentication, and Authorization
-
-As a result of the new security features, the package now depends on
-[pyOpenSSL](http://pypi.python.org/pypi/pyOpenSSL) and will warn if
-your version of OpenSSL is too old.
-
-This release also includes many bugfixes and enhancements, most
-notably:
-
-* The default protocol is now 'pbc', not 'http'.
-* When used correctly, streaming requests no longer result in leaks
-  from the connection pool.
-* The size of the multiget worker pool can be set when initializing
-  the client.
-* Secondary index queries can now iterate over all pages in a query.
-* The number of times a request is retried after network failure is
-  now configurable.
-* The additional request options `basic_quorum` and `notfound_ok` are
-  now supported.
-
-## 2.0.3 Patch Release - 2014-03-06
-
-Release 2.0.3 includes support for 1.4.4's 2I regexp feature and fixes
-a few bugs:
-
-* Docs generation now uses the version from the top-level package.
-* Some internal uses of the deprecated RiakClient.solr were removed.
-* More errors will be caught and propagated properly from multiget
-  requests, preventing deadlocks on the caller side.
-
-## 2.0.2 Patch release - 2013-11-18
-
-Release 2.0.2 includes support for the 1.4.1+ "timeout" option on
-secondary index queries.
-
-## 2.0.1 Patch release - 2013-08-28
-
-Release 2.0.1 includes a minor compatibility fix for Python 2.6 and an
-updated README.
-
-## 2.0.0 Feature Release - 2013-07-30
-
-Release 2.0 is the culmination of many months of rearchitecting the
-client. Highlights:
-
-* Automatic connection to multiple nodes, with request retries,
-  through a thread-safe connection pool.
-* All Riak 1.3 and 1.4 features, including bucket properties,
-  paginating and streaming secondary indexes, CRDT counters,
-  client-specified timeouts, and more.
-* Cleaner, more Pythonic access to RiakObject and RiakBucket
-  attributes, favoring properties over methods where possible.
-* Simpler representations of links (3-tuples) and index entries
-  (2-tuples).
-* Streaming requests (keys, buckets, MapReduce, 2i) are now exposed as
-  iterators.
-* Feature detection prevents sending requests to hosts that can't
-  handle them.
-* Better handling of siblings -- you don't have to request them
-  individually anymore -- and registrable resolver functions.
-* A new `multiget` operation that fetches a collection of keys using
-  a pool background threads.
-* A more resilient, repeatable test suite that generates buckets and
-  key names that are essentially random.
-* Last but not least, a brand new, more detailed documentation site!
-
-Other features:
-
-* Added an encoder/decoder pair to support `text/plain`.
-* The Travis CI build will now install the latest Riak to run the
-  suite against.
-
-Other bugfixes:
-
-* The `charset` metadata can now be received via the `Content-Type`
-  header on HTTP.
-* Objects with empty keys and buckets with empty names cannot be
-  created or accessed, as they are unaddressable over HTTP.
-* Performance and compatibility of `TestServer` was improved.
-* Non-ASCII request bodies are better supported on HTTP.
-* Enabling and disabling search indexing on a bucket now uses the
-  `search` bucket property.
-
-## 1.5.2 Patch Release - 2013-01-31
-
-Release 1.5.2 fixes some bugs and adds HTTPS/SSL support.
-
-* Added support for HTTPS.
-* Fixed writing of the `app.config` for the `TestServer`.
-* Reorganized the tests into multiple files and cases.
-* Some methods on `RiakObject` were made private where appropriate.
-* The version comparison used in feature detection was loosened to
-  support pre-release versions of Riak.
-* Prevent fetching the `protobuf` package from Google Code.
-* Prefer `simplejson` over `json` when present.
-
-## 1.5.1 Patch Release - 2012-10-24
-
-Release 1.5.1 fixes one bug and some documentation errors.
-
-* Fix bug where `http_status` is used instead of `http_code`.
-* Fix documentation of `RiakMapReduce.index` method.
-* Fix documentation of `RiakClient.__init__` method.
-
-## 1.5.0 Feature Release - 2012-08-29
-
-Release 1.5.0 is a feature release that supports Riak 1.2.
-
-Noteworthy features:
-
-* Riak 1.2 features are now supported, including Search and 2I queries
-  over Protocol Buffers transport. The Protocol Buffers message
-  definitions now exist as a separate package, available on
-  [PyPi](http://pypi.python.org/pypi/riak_pb/1.2.0).
-
-  **NOTE:** The return value of search queries over HTTP and MapReduce
-  were changed to be compatible with the results returned from the
-  Protocol Buffers interface.
-* The client will use a version-based feature detection scheme to
-  enable or disable various features, including the new Riak 1.2
-  features. This enables compatibility with older nodes during a
-  rolling upgrade, or usage of the newer client with older clusters.
-
-Noteworthy bugfixes:
-
-* The code formatting and style was adjusted to fit PEP8 standards.
-* All classes in the package are now "new-style".
-* The PW accessor methods on RiakClient now get and set the right
-  instance variable.
-* Various fixes were made to the TestServer and it will throw an
-  exception when it fails to start.
-
-## 1.4.1 Patch Release - 2012-06-19
-
-Noteworthy features:
-
-* New Riak objects support Riak-created random keys
-
-Noteworthy bugfixes:
-
-* Map Reduce queries now use "application/json" as the Content-Type
-
-## 1.4.0 Feature Release - 2012-03-30
-
-Release 1.4.0 is a feature release comprising over 117 individual
-commits.
-
-Noteworthy features:
-
-* Python 2.6 and 2.7 are supported. On 2.6, the unittest2 package is
-  required to run the test suite.
-* Google's official protobuf package (2.4.1 or later) is now a
-  dependency. The package from downloads.basho.com/support is no
-  longer necessary.
-* Travis-CI is enabled on the client. Go to
-  http://travis-ci.org/basho/riak-python-client for build status.
-* Riak 1.0+ features, namely secondary indexes and primary quora
-  (PR/PW), are supported.
-* `if_none_match` is a valid request option when storing objects, and
-  will prevent the write when set to `True` if the key already exists.
-* Links can be set wholesale using the `set_links()` method.
-* Transport-specific options can be passed through when creating a
-  `Client` object.
-* A connection manager was added that will (when manipulated manually)
-  allow connections to multiple Riak nodes. This will be fully
-  integrated in a future release.
-
-Noteworthy bugfixes:
-
-* Links now use the proper URL-encoding in HTTP headers, preventing
-  problems with explosion from multiple encoding passes.
-* Many fixes were applied to make the Protocol Buffers transport more
-  stable.
-* `RiakObject.get_content_type()` will behave properly when content
-  type is not set.
-* Deprecated transport classes were removed since their functionality
-  had folded into the primary transports.
-* A temporary fix was made for unicode bucket/key names which raises
-  an error when they are used and cannot be coerced to ASCII.
-* The Erlang sources/beams for the TestServer are now included in the
-  package.
-* MapReduce failures will now produce a more useful error message and
-  be handled properly when no results are returned.
-
-There are lots of other great fixes from our wonderful
-community. [Check them out!](https://github.com/basho/riak-python-client/compare/1.3.0...1.4.0)
-
-## 1.3.0 Feature Release - 2011-08-04
-
-Release 1.3.0 is a feature release bringing a slew of updates.

riak-2.1.0.tar.gz/THANKS Deleted

riak-2.1.0.tar.gz/riak/client/multiget.py Deleted

@@ -1,236 +0,0 @@
-"""
-Copyright 2013 Basho Technologies, Inc.
-
-This file is provided to you under the Apache License,
-Version 2.0 (the "License"); you may not use this file
-except in compliance with the License.  You may obtain
-a copy of the License at
-
-http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing,
-software distributed under the License is distributed on an
-"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-KIND, either express or implied.  See the License for the
-specific language governing permissions and limitations
-under the License.
-"""
-
-from collections import namedtuple
-from Queue import Queue
-from threading import Thread, Lock, Event
-from multiprocessing import cpu_count
-
-__all__ = ['multiget', 'MultiGetPool']
-
-
-try:
-    #: The default size of the worker pool, either based on the number
-    #: of CPUS or defaulting to 6
-    POOL_SIZE = cpu_count()
-except NotImplementedError:
-    # Make an educated guess
-    POOL_SIZE = 6
-
-#: A :class:`namedtuple` for tasks that are fed to workers in the
-#: multiget pool.
-Task = namedtuple('Task', ['client', 'outq', 'bucket_type', 'bucket', 'key',
-                           'options'])
-
-
-class MultiGetPool(object):
-    """
-    Encapsulates a pool of fetcher threads. These threads can be used
-    across many multi-get requests.
-    """
-
-    def __init__(self, size=POOL_SIZE):
-        """
-        :param size: the desired size of the worker pool
-        :type size: int
-        """
-
-        self._inq = Queue()
-        self._size = size
-        self._started = Event()
-        self._stop = Event()
-        self._lock = Lock()
-        self._workers = []
-
-    def enq(self, task):
-        """
-        Enqueues a fetch task to the pool of workers. This will raise
-        a RuntimeError if the pool is stopped or in the process of
-        stopping.
-
-        :param task: the Task object
-        :type task: Task
-        """
-        if not self._stop.is_set():
-            self._inq.put(task)
-        else:
-            raise RuntimeError("Attempted to enqueue a fetch operation while "
-                               "multi-get pool was shutdown!")
-
-    def start(self):
-        """
-        Starts the worker threads if they are not already started.
-        This method is thread-safe and will be called automatically
-        when executing a MultiGet operation.
-        """
-        # Check whether we are already started, skip if we are.
-        if not self._started.is_set():
-            # If we are not started, try to capture the lock.
-            if self._lock.acquire(False):
-                # If we got the lock, go ahead and start the worker
-                # threads, set the started flag, and release the lock.
-                for i in range(self._size):
-                    name = "riak.client.multiget-worker-{0}".format(i)
-                    worker = Thread(target=self._fetcher, name=name)
-                    worker.daemon = True
-                    worker.start()
-                    self._workers.append(worker)
-                self._started.set()
-                self._lock.release()
-            else:
-                # We didn't get the lock, so someone else is already
-                # starting the worker threads. Wait until they have
-                # signaled that the threads are started.
-                self._started.wait()
-
-    def stop(self):
-        """
-        Signals the worker threads to exit and waits on them.
-        """
-        self._stop.set()
-        for worker in self._workers:
-            worker.join()
-
-    def stopped(self):
-        """
-        Detects whether this pool has been stopped.
-        """
-        return self._stop.is_set()
-
-    def __del__(self):
-        # Ensure that all work in the queue is processed before
-        # shutting down.
-        self.stop()
-
-    def _fetcher(self):
-        """
-        The body of the multi-get worker. Loops until
-        :meth:`_should_quit` returns ``True``, taking tasks off the
-        input queue, fetching the object, and putting them on the
-        output queue.
-        """
-        while not self._should_quit():
-            task = self._inq.get()
-            try:
-                btype = task.client.bucket_type(task.bucket_type)
-                obj = btype.bucket(task.bucket).get(task.key, **task.options)
-                task.outq.put(obj)
-            except KeyboardInterrupt:
-                raise
-            except Exception as err:
-                task.outq.put((task.bucket_type, task.bucket, task.key, err), )
-            finally:
-                self._inq.task_done()
-
-    def _should_quit(self):
-        """
-        Worker threads should exit when the stop flag is set and the
-        input queue is empty. Once the stop flag is set, new enqueues
-        are disallowed, meaning that the workers can safely drain the
-        queue before exiting.
-
-        :rtype: bool
-        """
-        return self.stopped() and self._inq.empty()
-
-
-#: The default pool is automatically created and stored in this constant.
-RIAK_MULTIGET_POOL = MultiGetPool()
-
-
-def multiget(client, keys, **options):
-    """Executes a parallel-fetch across multiple threads. Returns a list
-    containing :class:`~riak.riak_object.RiakObject` or
-    :class:`~riak.datatypes.Datatype` instances, or 4-tuples of
-    bucket-type, bucket, key, and the exception raised.
-
-    If a ``pool`` option is included, the request will use the given worker
-    pool and not the default :data:`RIAK_MULTIGET_POOL`. This option will
-    be passed by the client if the ``multiget_pool_size`` option was set on
-    client initialization.
-
-    :param client: the client to use
-    :type client: :class:`~riak.client.RiakClient`
-    :param keys: the keys to fetch in parallel
-    :type keys: list of three-tuples -- bucket_type/bucket/key
-    :param options: request options to
-        :meth:`RiakBucket.get <riak.bucket.RiakBucket.get>`
-    :type options: dict
-    :rtype: list
-
-    """
-    outq = Queue()
-
-    if 'pool' in options:
-        pool = options['pool']
-        del options['pool']
-    else:
-        pool = RIAK_MULTIGET_POOL
-
-    pool.start()
-    for bucket_type, bucket, key in keys:
-        task = Task(client, outq, bucket_type, bucket, key, options)
-        pool.enq(task)
-
-    results = []
-    for _ in range(len(keys)):
-        if pool.stopped():
-            raise RuntimeError("Multi-get operation interrupted by pool "
-                               "stopping!")
-        results.append(outq.get())
-        outq.task_done()
-
-    return results
-

riak-2.1.0.tar.gz/riak/tests/test_all.py Deleted

@@ -1,399 +0,0 @@
-# -*- coding: utf-8 -*-
-import random
-import platform
-from threading import Thread
-from Queue import Queue
-
-if platform.python_version() < '2.7':
-    unittest = __import__('unittest2')
-else:
-    import unittest
-
-from riak import RiakError
-from riak.client import RiakClient
-from riak.riak_object import RiakObject
-
-from riak.tests.test_yokozuna import YZSearchTests
-from riak.tests.test_search import SearchTests, \
-    EnableSearchTests, SolrSearchTests
-from riak.tests.test_mapreduce import MapReduceAliasTests, \
-    ErlangMapReduceTests, JSMapReduceTests, LinkTests, MapReduceStreamTests
-from riak.tests.test_kv import BasicKVTests, KVFileTests, \
-    BucketPropsTest, CounterTests
-from riak.tests.test_2i import TwoITests
-from riak.tests.test_btypes import BucketTypeTests
-from riak.tests.test_security import SecurityTests
-from riak.tests.test_datatypes import DatatypeIntegrationTests
-
-from riak.tests import HOST, PB_HOST, PB_PORT, HTTP_HOST, HTTP_PORT, \
-    HAVE_PROTO, DUMMY_HTTP_PORT, DUMMY_PB_PORT, \
-    SKIP_SEARCH, RUN_YZ, SECURITY_CREDS, SKIP_POOL
-
-testrun_search_bucket = None
-testrun_props_bucket = None
-testrun_sibs_bucket = None
-testrun_yz = {'btype': None, 'bucket': None, 'index': None}
-testrun_yz_index = {'btype': None, 'bucket': None, 'index': None}
-testrun_yz_mr = {'btype': None, 'bucket': None, 'index': None}
-
-
-def setUpModule():
-    global testrun_search_bucket, testrun_props_bucket, \
-        testrun_sibs_bucket, testrun_yz, testrun_yz_index, testrun_yz_mr
-
-    c = RiakClient(host=PB_HOST, http_port=HTTP_PORT,
-                   pb_port=PB_PORT, credentials=SECURITY_CREDS)
-
-    testrun_props_bucket = 'propsbucket'
-    testrun_sibs_bucket = 'sibsbucket'
-    c.bucket(testrun_sibs_bucket).allow_mult = True
-
-    if (not SKIP_SEARCH and not RUN_YZ):
-        testrun_search_bucket = 'searchbucket'
-        b = c.bucket(testrun_search_bucket)
-        b.enable_search()
-
-    if RUN_YZ:
-        # YZ index on bucket of the same name
-        testrun_yz = {'btype': None, 'bucket': 'yzbucket',
-                      'index': 'yzbucket'}
-        # YZ index on bucket of a different name
-        testrun_yz_index = {'btype': None, 'bucket': 'yzindexbucket',
-                            'index': 'yzindex'}
-        # Add bucket and type for Search 2.0 -> MapReduce
-        testrun_yz_mr = {'btype': 'pytest-mr', 'bucket': 'mrbucket',
-                         'index': 'mrbucket'}
-
-        for yz in (testrun_yz, testrun_yz_index, testrun_yz_mr):
-            c.create_search_index(yz['index'])
-            if yz['btype'] is not None:
-                t = c.bucket_type(yz['btype'])
-                b = t.bucket(yz['bucket'])
-            else:
-                b = c.bucket(yz['bucket'])
-            # Keep trying to set search bucket property until it succeeds
-            index_set = False
-            while not index_set:
-                try:
-                    b.set_property('search_index', yz['index'])
-                    index_set = True
-                except RiakError:
-                    pass
-
-
-def tearDownModule():
-    global testrun_search_bucket, testrun_props_bucket, \
-        testrun_sibs_bucket, testrun_yz_bucket
-
-    c = RiakClient(host=HTTP_HOST, http_port=HTTP_PORT,
-                   pb_port=PB_PORT, credentials=SECURITY_CREDS)
-
-    c.bucket(testrun_sibs_bucket).clear_properties()
-    c.bucket(testrun_props_bucket).clear_properties()
-
-    if not SKIP_SEARCH and not RUN_YZ:
-        b = c.bucket(testrun_search_bucket)
-        b.clear_properties()
-
-    if RUN_YZ:
-        for yz in (testrun_yz, testrun_yz_index, testrun_yz_mr):
-            if yz['btype'] is not None:
-                t = c.bucket_type(yz['btype'])
-                b = t.bucket(yz['bucket'])
-            else:
-                b = c.bucket(yz['bucket'])
-            b.set_property('search_index', '_dont_index_')
-            c.delete_search_index(yz['index'])
-            for keys in b.stream_keys():
-                for key in keys:
-                    b.delete(key)
-
-
-class BaseTestCase(object):
-
-    host = None
-    pb_port = None
-    http_port = None
-    credentials = None
-
-    @staticmethod
-    def randint():
-        return random.randint(1, 999999)
-
-    @staticmethod
-    def randname(length=12):
-        out = ''
-        for i in range(length):
-            out += chr(random.randint(ord('a'), ord('z')))
-        return out
-
-    def create_client(self, host=None, http_port=None, pb_port=None,
-                      protocol=None, credentials=None,
-                      **client_args):
-        host = host or self.host or HOST
-        http_port = http_port or self.http_port or HTTP_PORT
-        pb_port = pb_port or self.pb_port or PB_PORT
-        protocol = protocol or self.protocol
-        credentials = credentials or SECURITY_CREDS
-        return RiakClient(protocol=protocol,
-                          host=host,
-                          http_port=http_port,
-                          credentials=credentials,
-                          pb_port=pb_port, **client_args)
-
-    def setUp(self):
-        self.bucket_name = self.randname()
-        self.key_name = self.randname()
-        self.search_bucket = testrun_search_bucket
-        self.sibs_bucket = testrun_sibs_bucket
-        self.props_bucket = testrun_props_bucket
-        self.yz = testrun_yz
-        self.yz_index = testrun_yz_index
-        self.yz_mr = testrun_yz_mr
-        self.credentials = SECURITY_CREDS
-
-        self.client = self.create_client()
-
-
-class ClientTests(object):
-    def test_request_retries(self):
-        # We guess at some ports that will be unused by Riak or
-        # anything else.
-        client = self.create_client(http_port=DUMMY_HTTP_PORT,
-                                    pb_port=DUMMY_PB_PORT)
-
-        # If retries are exhausted, the final result should also be an
-        # error.
-        self.assertRaises(IOError, client.ping)
-
-    def test_request_retries_configurable(self):
-        # We guess at some ports that will be unused by Riak or
-        # anything else.
-        client = self.create_client(http_port=DUMMY_HTTP_PORT,
-                                    pb_port=DUMMY_PB_PORT)
-
-        # Change the retry count
-        client.retries = 10
-        self.assertEqual(10, client.retries)
-
-        # The retry count should be a thread local
-        retries = Queue()
-
-        def _target():
-            retries.put(client.retries)
-            retries.join()
-
-        th = Thread(target=_target)
-        th.start()
-        self.assertEqual(3, retries.get(block=True))
-        retries.task_done()
-        th.join()
-
-        # Modify the retries in a with statement
-        with client.retry_count(5):
-            self.assertEqual(5, client.retries)
-            self.assertRaises(IOError, client.ping)
-
-    def test_timeout_validation(self):
-        bucket = self.client.bucket(self.bucket_name)
-        key = self.key_name

riak-2.1.0.tar.gz/riak/transports/http/codec.py Deleted

@@ -1,313 +0,0 @@
-"""
-Copyright 2012 Basho Technologies, Inc.
-Copyright 2010 Rusty Klophaus <rusty@basho.com>
-Copyright 2010 Justin Sheehy <justin@basho.com>
-Copyright 2009 Jay Baird <jay@mochimedia.com>
-
-This file is provided to you under the Apache License,
-Version 2.0 (the "License"); you may not use this file
-except in compliance with the License.  You may obtain
-a copy of the License at
-
-  http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing,
-software distributed under the License is distributed on an
-"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-KIND, either express or implied.  See the License for the
-specific language governing permissions and limitations
-under the License.
-"""
-
-# subtract length of "Link: " header string and newline
-MAX_LINK_HEADER_SIZE = 8192 - 8
-
-
-import re
-import csv
-import urllib
-from cgi import parse_header
-from email import message_from_string
-from rfc822 import parsedate_tz, mktime_tz
-from xml.etree import ElementTree
-from riak import RiakError
-from riak.content import RiakContent
-from riak.riak_object import VClock
-from riak.multidict import MultiDict
-from riak.transports.http.search import XMLSearchResult
-from riak.util import decode_index_value
-
-
-class RiakHttpCodec(object):
-    """
-    Methods for HTTP transport that marshals and unmarshals HTTP
-    messages.
-    """
-
-    def _parse_body(self, robj, response, expected_statuses):
-        """
-        Parse the body of an object response and populate the object.
-        """
-        # If no response given, then return.
-        if response is None:
-            return None
-
-        status, headers, data = response
-
-        # Check if the server is down(status==0)
-        if not status:
-            m = 'Could not contact Riak Server: http://{0}:{1}!'.format(
-                self._node.host, self._node.http_port)
-            raise RiakError(m)
-
-        # Make sure expected code came back
-        self.check_http_code(status, expected_statuses)
-
-        if 'x-riak-vclock' in headers:
-            robj.vclock = VClock(headers['x-riak-vclock'], 'base64')
-
-        # If 404(Not Found), then clear the object.
-        if status == 404:
-            robj.siblings = []
-            return None
-        # If 201 Created, we need to extract the location and set the
-        # key on the object.
-        elif status == 201:
-            robj.key = headers['location'].strip().split('/')[-1]
-        # If 300(Siblings), apply the siblings to the object
-        elif status == 300:
-            ctype, params = parse_header(headers['content-type'])
-            if ctype == 'multipart/mixed':
-                boundary = re.compile('\r?\n--%s(?:--)?\r?\n' %
-                                      re.escape(params['boundary']))
-                parts = [message_from_string(p)
-                         for p in re.split(boundary, data)[1:-1]]
-                robj.siblings = [self._parse_sibling(RiakContent(robj),
-                                                     part.items(),
-                                                     part.get_payload())
-                                 for part in parts]
-
-                # Invoke sibling-resolution logic
-                if robj.resolver is not None:
-                    robj.resolver(robj)
-
-                return robj
-            else:
-                raise Exception('unexpected sibling response format: {0}'.
-                                format(ctype))
-
-        robj.siblings = [self._parse_sibling(RiakContent(robj),
-                                             headers.items(), data)]
-
-        return robj
-
-    def _parse_sibling(self, sibling, headers, data):
-        """
-        Parses a single sibling out of a response.
-        """
-
-        sibling.exists = True
-
-        # Parse the headers...
-        for header, value in headers:
-            header = header.lower()
-            if header == 'content-type':
-                sibling.content_type, sibling.charset = \
-                    self._parse_content_type(value)
-            elif header == 'etag':
-                sibling.etag = value
-            elif header == 'link':
-                sibling.links = self._parse_links(value)
-            elif header == 'last-modified':
-                sibling.last_modified = mktime_tz(parsedate_tz(value))
-            elif header.startswith('x-riak-meta-'):
-                metakey = header.replace('x-riak-meta-', '')
-                sibling.usermeta[metakey] = value
-            elif header.startswith('x-riak-index-'):
-                field = header.replace('x-riak-index-', '')
-                reader = csv.reader([value], skipinitialspace=True)
-                for line in reader:
-                    for token in line:
-                        token = decode_index_value(field, token)
-                        sibling.add_index(field, token)
-            elif header == 'x-riak-deleted':
-                sibling.exists = False
-
-        sibling.encoded_data = data
-
-        return sibling
-
-    def _to_link_header(self, link):
-        """
-        Convert the link tuple to a link header string. Used internally.
-        """
-        try:
-            bucket, key, tag = link
-        except ValueError:
-            raise RiakError("Invalid link tuple %s" % link)
-        tag = tag if tag is not None else bucket
-        url = self.object_path(bucket, key)
-        header = '<%s>; riaktag="%s"' % (url, tag)
-        return header
-
-    def _parse_links(self, linkHeaders):
-        links = []
-        oldform = "</([^/]+)/([^/]+)/([^/]+)>; ?riaktag=\"([^\"]+)\""
-        newform = "</(buckets)/([^/]+)/keys/([^/]+)>; ?riaktag=\"([^\"]+)\""
-        for linkHeader in linkHeaders.strip().split(','):
-            linkHeader = linkHeader.strip()
-            matches = (re.match(oldform, linkHeader) or
-                       re.match(newform, linkHeader))
-            if matches is not None:
-                link = (urllib.unquote_plus(matches.group(2)),
-                        urllib.unquote_plus(matches.group(3)),
-                        urllib.unquote_plus(matches.group(4)))
-                links.append(link)
-        return links
-
-    def _add_links_for_riak_object(self, robject, headers):
-        links = robject.links
-        if links:
-            current_header = ''
-            for link in links:
-                header = self._to_link_header(link)
-                if len(current_header + header) > MAX_LINK_HEADER_SIZE:
-                    headers.add('Link', current_header)
-                    current_header = ''
-
-                if current_header != '':
-                    header = ', ' + header
-                current_header += header
-
-            headers.add('Link', current_header)
-
-        return headers
-
-    def _build_put_headers(self, robj, if_none_match=False):
-        """Build the headers for a POST/PUT request."""
-
-        # Construct the headers...
-        if robj.charset is not None:
-            content_type = ('%s; charset="%s"' %
-                            (robj.content_type, robj.charset))
-        else:
-            content_type = robj.content_type
-
-        headers = MultiDict({'Content-Type': content_type,
-                             'X-Riak-ClientId': self._client_id})
-
-        # Add the vclock if it exists...

riak-2.1.0.tar.gz/riak/transports/pbc Deleted

riak-2.1.0.tar.gz/riak/transports/pbc/__init__.py Deleted

@@ -1,74 +0,0 @@
-"""
-Copyright 2012 Basho Technologies, Inc.
-Copyright 2010 Rusty Klophaus <rusty@basho.com>
-Copyright 2010 Justin Sheehy <justin@basho.com>
-Copyright 2009 Jay Baird <jay@mochimedia.com>
-
-This file is provided to you under the Apache License,
-Version 2.0 (the "License"); you may not use this file
-except in compliance with the License.  You may obtain
-a copy of the License at
-
-http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing,
-software distributed under the License is distributed on an
-"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-KIND, either express or implied.  See the License for the
-specific language governing permissions and limitations
-under the License.
-"""
-
-import errno
-import socket
-from riak.transports.pool import Pool
-from riak.transports.pbc.transport import RiakPbcTransport
-
-
-class RiakPbcPool(Pool):
-    """
-    A resource pool of PBC transports.
-    """
-    def __init__(self, client, **options):
-        super(RiakPbcPool, self).__init__()
-        self._client = client
-        self._options = options
-
-    def create_resource(self):
-        node = self._client._choose_node()
-        return RiakPbcTransport(node=node,
-                                client=self._client,
-                                **self._options)
-
-    def destroy_resource(self, pbc):
-        pbc.close()
-
-# These are a specific set of socket errors
-# that could be raised on send/recv that indicate
-# that the socket is closed or reset, and is not
-# usable. On seeing any of these errors, the socket
-# should be closed, and the connection re-established.
-CONN_CLOSED_ERRORS = (
-    errno.EHOSTUNREACH,
-    errno.ECONNRESET,
-    errno.ECONNREFUSED,
-    errno.ECONNABORTED,
-    errno.ETIMEDOUT,
-    errno.EBADF,
-    errno.EPIPE
-)
-
-
-def is_retryable(err):
-    """
-    Determines if the given exception is something that is
-    network/socket-related and should thus cause the PBC connection to
-    close and the operation retried on another node.
-
-    :rtype: boolean
-    """
-    if isinstance(err, socket.error):
-        code = err.args[0]
-        return code in CONN_CLOSED_ERRORS
-    else:
-        return False

riak-2.1.0.tar.gz/riak/transports/pbc/codec.py Deleted

@@ -1,603 +0,0 @@
-"""
-Copyright 2012 Basho Technologies, Inc.
-
-This file is provided to you under the Apache License,
-Version 2.0 (the "License"); you may not use this file
-except in compliance with the License.  You may obtain
-a copy of the License at
-
-  http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing,
-software distributed under the License is distributed on an
-"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-KIND, either express or implied.  See the License for the
-specific language governing permissions and limitations
-under the License.
-"""
-import riak_pb
-from riak import RiakError
-from riak.content import RiakContent
-from riak.util import decode_index_value
-from riak.multidict import MultiDict
-
-
-def _invert(d):
-    out = {}
-    for key in d:
-        value = d[key]
-        out[value] = key
-    return out
-
-REPL_TO_PY = {riak_pb.RpbBucketProps.FALSE: False,
-              riak_pb.RpbBucketProps.TRUE: True,
-              riak_pb.RpbBucketProps.REALTIME: 'realtime',
-              riak_pb.RpbBucketProps.FULLSYNC: 'fullsync'}
-
-REPL_TO_PB = _invert(REPL_TO_PY)
-
-RIAKC_RW_ONE = 4294967294
-RIAKC_RW_QUORUM = 4294967293
-RIAKC_RW_ALL = 4294967292
-RIAKC_RW_DEFAULT = 4294967291
-
-QUORUM_TO_PB = {'default': RIAKC_RW_DEFAULT,
-                'all': RIAKC_RW_ALL,
-                'quorum': RIAKC_RW_QUORUM,
-                'one': RIAKC_RW_ONE}
-
-QUORUM_TO_PY = _invert(QUORUM_TO_PB)
-
-NORMAL_PROPS = ['n_val', 'allow_mult', 'last_write_wins', 'old_vclock',
-                'young_vclock', 'big_vclock', 'small_vclock', 'basic_quorum',
-                'notfound_ok', 'search', 'backend', 'search_index', 'datatype']
-COMMIT_HOOK_PROPS = ['precommit', 'postcommit']
-MODFUN_PROPS = ['chash_keyfun', 'linkfun']
-QUORUM_PROPS = ['r', 'pr', 'w', 'pw', 'dw', 'rw']
-
-MAP_FIELD_TYPES = {
-    riak_pb.MapField.COUNTER: 'counter',
-    riak_pb.MapField.SET: 'set',
-    riak_pb.MapField.REGISTER: 'register',
-    riak_pb.MapField.FLAG: 'flag',
-    riak_pb.MapField.MAP: 'map',
-    'counter': riak_pb.MapField.COUNTER,
-    'set': riak_pb.MapField.SET,
-    'register': riak_pb.MapField.REGISTER,
-    'flag': riak_pb.MapField.FLAG,
-    'map': riak_pb.MapField.MAP
-}
-
-DT_FETCH_TYPES = {
-    riak_pb.DtFetchResp.COUNTER: 'counter',
-    riak_pb.DtFetchResp.SET: 'set',
-    riak_pb.DtFetchResp.MAP: 'map'
-}
-
-
-class RiakPbcCodec(object):
-    """
-    Protobuffs Encoding and decoding methods for RiakPbcTransport.
-    """
-
-    def __init__(self, **unused_args):
-        if riak_pb is None:
-            raise NotImplementedError("this transport is not available")
-        super(RiakPbcCodec, self).__init__(**unused_args)
-
-    def _encode_quorum(self, rw):
-        """
-        Converts a symbolic quorum value into its on-the-wire
-        equivalent.
-
-        :param rw: the quorum
-        :type rw: string, integer
-        :rtype: integer
-        """
-        if rw in QUORUM_TO_PB:
-            return QUORUM_TO_PB[rw]
-        elif type(rw) is int and rw >= 0:
-            return rw
-        else:
-            return None
-
-    def _decode_quorum(self, rw):
-        """
-        Converts a protobuf quorum value to a symbolic value if
-        necessary.
-
-        :param rw: the quorum
-        :type rw: int
-        :rtype int or string
-        """
-        if rw in QUORUM_TO_PY:
-            return QUORUM_TO_PY[rw]
-        else:
-            return rw
-
-    def _decode_contents(self, contents, obj):
-        """
-        Decodes the list of siblings from the protobuf representation
-        into the object.
-
-        :param contents: a list of RpbContent messages
-        :type contents: list
-        :param obj: a RiakObject
-        :type obj: RiakObject
-        :rtype RiakObject
-        """
-        obj.siblings = [self._decode_content(c, RiakContent(obj))
-                        for c in contents]
-        # Invoke sibling-resolution logic
-        if len(obj.siblings) > 1 and obj.resolver is not None:
-            obj.resolver(obj)
-        return obj
-
-    def _decode_content(self, rpb_content, sibling):
-        """
-        Decodes a single sibling from the protobuf representation into
-        a RiakObject.
-
-        :param rpb_content: a single RpbContent message
-        :type rpb_content: riak_pb.RpbContent
-        :param sibling: a RiakContent sibling container
-        :type sibling: RiakContent
-        :rtype: RiakContent
-        """
-
-        if rpb_content.HasField("deleted") and rpb_content.deleted:
-            sibling.exists = False
-        else:
-            sibling.exists = True
-        if rpb_content.HasField("content_type"):
-            sibling.content_type = rpb_content.content_type
-        if rpb_content.HasField("charset"):
-            sibling.charset = rpb_content.charset
-        if rpb_content.HasField("content_encoding"):
-            sibling.content_encoding = rpb_content.content_encoding
-        if rpb_content.HasField("vtag"):
-            sibling.etag = rpb_content.vtag
-
-        sibling.links = [self._decode_link(link)
-                         for link in rpb_content.links]
-        if rpb_content.HasField("last_mod"):
-            sibling.last_modified = float(rpb_content.last_mod)
-            if rpb_content.HasField("last_mod_usecs"):
-                sibling.last_modified += rpb_content.last_mod_usecs / 1000000.0
-
-        sibling.usermeta = dict([(usermd.key, usermd.value)
-                                 for usermd in rpb_content.usermeta])
-        sibling.indexes = set([(index.key,
-                                decode_index_value(index.key, index.value))
-                               for index in rpb_content.indexes])
-
-        sibling.encoded_data = rpb_content.value
-
-        return sibling
-
-    def _encode_content(self, robj, rpb_content):
-        """
-        Fills an RpbContent message with the appropriate data and
-        metadata from a RiakObject.
-
-        :param robj: a RiakObject
-        :type robj: RiakObject
-        :param rpb_content: the protobuf message to fill
-        :type rpb_content: riak_pb.RpbContent
-        """
-        if robj.content_type:
-            rpb_content.content_type = robj.content_type
-        if robj.charset:
-            rpb_content.charset = robj.charset
-        if robj.content_encoding:
-            rpb_content.content_encoding = robj.content_encoding
-        for uk in robj.usermeta:
-            pair = rpb_content.usermeta.add()
-            pair.key = uk
-            pair.value = robj.usermeta[uk]
-        for link in robj.links:
-            pb_link = rpb_content.links.add()

riak-2.1.0.tar.gz/riak/transports/pbc/connection.py Deleted

@@ -1,209 +0,0 @@
-"""
-Copyright 2012 Basho Technologies, Inc.
-
-This file is provided to you under the Apache License,
-Version 2.0 (the "License"); you may not use this file
-except in compliance with the License.  You may obtain
-a copy of the License at
-
-  http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing,
-software distributed under the License is distributed on an
-"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-KIND, either express or implied.  See the License for the
-specific language governing permissions and limitations
-under the License.
-"""
-
-import socket
-import struct
-import riak_pb
-from riak.security import SecurityError
-from riak.transports.security import configure_context
-from riak import RiakError
-from riak_pb.messages import (
-    MESSAGE_CLASSES,
-    MSG_CODE_ERROR_RESP,
-    MSG_CODE_START_TLS,
-    MSG_CODE_AUTH_REQ,
-    MSG_CODE_AUTH_RESP
-)
-from OpenSSL.SSL import Context, Connection
-
-
-class RiakPbcConnection(object):
-    """
-    Connection-related methods for RiakPbcTransport.
-    """
-
-    def _encode_msg(self, msg_code, msg=None):
-        if msg is None:
-            return struct.pack("!iB", 1, msg_code)
-        msgstr = msg.SerializeToString()
-        slen = len(msgstr)
-        hdr = struct.pack("!iB", 1 + slen, msg_code)
-        return hdr + msgstr
-
-    def _request(self, msg_code, msg=None, expect=None):
-        self._send_msg(msg_code, msg)
-        return self._recv_msg(expect)
-
-    def _non_connect_request(self, msg_code, msg=None, expect=None):
-        """
-        Similar to self._request, but doesn't try to initiate a connection,
-        thus preventing an infinite loop.
-        """
-        self._non_connect_send_msg(msg_code, msg)
-        return self._recv_msg(expect)
-
-    def _non_connect_send_msg(self, msg_code, msg):
-        """
-        Similar to self._send, but doesn't try to initiate a connection,
-        thus preventing an infinite loop.
-        """
-        self._socket.send(self._encode_msg(msg_code, msg))
-
-    def _send_msg(self, msg_code, msg):
-        self._connect()
-        self._non_connect_send_msg(msg_code, msg)
-
-    def _init_security(self):
-        """
-        Initialize a secure connection to the server.
-        """
-        if not self._starttls():
-            raise SecurityError("Could not start TLS connection")
-        # _ssh_handshake() will throw an exception upon failure
-        self._ssl_handshake()
-        if not self._auth():
-            raise SecurityError("Could not authorize connection")
-
-    def _starttls(self):
-        """
-        Exchange a STARTTLS message with Riak to initiate secure communications
-        return True is Riak responds with a STARTTLS response, False otherwise
-        """
-        msg_code, _ = self._non_connect_request(MSG_CODE_START_TLS)
-        if msg_code == MSG_CODE_START_TLS:
-            return True
-        else:
-            return False
-
-    def _auth(self):
-        """
-        Perform an authorization request against Riak
-        returns True upon success, False otherwise
-        Note: Riak will sleep for a short period of time upon a failed
-              auth request/response to prevent denial of service attacks
-        """
-        req = riak_pb.RpbAuthReq()
-        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:
-            return True
-        else:
-            return False
-
-    def _ssl_handshake(self):
-        """
-        Perform an SSL handshake w/ the server.
-        Precondition: a successful STARTTLS exchange has
-                     taken place with Riak
-        returns True upon success, otherwise an exception is raised
-        """
-        if self._client._credentials:
-            ssl_ctx = \
-                Context(self._client._credentials.ssl_version)
-            try:
-                configure_context(ssl_ctx, self._client._credentials)
-                # attempt to upgrade the socket to SSL
-                ssl_socket = Connection(ssl_ctx, self._socket)
-                ssl_socket.set_connect_state()
-                ssl_socket.do_handshake()
-                # ssl handshake successful
-                self._socket = ssl_socket
-
-                self._client._credentials._check_revoked_cert(ssl_socket)
-
-                return True
-            except Exception as e:
-                # fail if *any* exceptions are thrown during SSL handshake
-                raise SecurityError(e.message)
-
-    def _recv_msg(self, expect=None):
-        self._recv_pkt()
-        msg_code, = struct.unpack("B", self._inbuf[:1])
-        if msg_code is MSG_CODE_ERROR_RESP:
-            err = self._parse_msg(msg_code, self._inbuf[1:])
-            raise RiakError(err.errmsg)
-        elif msg_code in MESSAGE_CLASSES:
-            msg = self._parse_msg(msg_code, self._inbuf[1:])
-        else:
-            raise Exception("unknown msg code %s" % msg_code)
-
-        if expect and msg_code != expect:
-            raise RiakError("unexpected protocol buffer message code: %d, %r"
-                            % (msg_code, msg))
-        return msg_code, msg
-
-    def _recv_pkt(self):
-        nmsglen = self._socket.recv(4)
-        while len(nmsglen) < 4:
-            x = self._socket.recv(4 - len(nmsglen))
-            if not x:
-                break
-            nmsglen += x
-        if len(nmsglen) != 4:
-            raise RiakError(
-                "Socket returned short packet length %d - expected 4"
-                % len(nmsglen))
-        msglen, = struct.unpack('!i', nmsglen)
-        self._inbuf_len = msglen
-        self._inbuf = ''
-        while len(self._inbuf) < msglen:
-            want_len = min(8192, msglen - len(self._inbuf))
-            recv_buf = self._socket.recv(want_len)
-            if not recv_buf:
-                break
-            self._inbuf += recv_buf
-        if len(self._inbuf) != self._inbuf_len:
-            raise RiakError("Socket returned short packet %d - expected %d"
-                            % (len(self._inbuf), self._inbuf_len))
-
-    def _connect(self):
-        if not self._socket:
-            if self._timeout:
-                self._socket = socket.create_connection(self._address,
-                                                        self._timeout)
-            else:
-                self._socket = socket.create_connection(self._address)
-            if self._client._credentials:
-                self._init_security()
-
-    def close(self):
-        """
-        Closes the underlying socket of the PB connection.
-        """
-        if self._socket:
-            self._socket.close()
-            del self._socket
-
-    def _parse_msg(self, code, packet):
-        try:
-            pbclass = MESSAGE_CLASSES[code]
-        except KeyError:
-            pbclass = None
-

riak-2.1.0.tar.gz/riak/transports/pbc/stream.py Deleted

@@ -1,158 +0,0 @@
-"""
-Copyright 2012 Basho Technologies, Inc.
-
-This file is provided to you under the Apache License,
-Version 2.0 (the "License"); you may not use this file
-except in compliance with the License.  You may obtain
-a copy of the License at
-
-  http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing,
-software distributed under the License is distributed on an
-"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-KIND, either express or implied.  See the License for the
-specific language governing permissions and limitations
-under the License.
-"""
-
-
-import json
-from riak_pb.messages import (
-    MSG_CODE_LIST_KEYS_RESP,
-    MSG_CODE_MAP_RED_RESP,
-    MSG_CODE_LIST_BUCKETS_RESP,
-    MSG_CODE_INDEX_RESP
-)
-from riak.util import decode_index_value
-from riak.client.index_page import CONTINUATION
-
-
-class RiakPbcStream(object):
-    """
-    Used internally by RiakPbcTransport to implement streaming
-    operations. Implements the iterator interface.
-    """
-
-    _expect = None
-
-    def __init__(self, transport):
-        self.finished = False
-        self.transport = transport
-        self.resource = None
-
-    def __iter__(self):
-        return self
-
-    def next(self):
-        if self.finished:
-            raise StopIteration
-
-        try:
-            msg_code, resp = self.transport._recv_msg(expect=self._expect)
-        except:
-            self.finished = True
-            raise
-
-        if(self._is_done(resp)):
-            self.finished = True
-
-        return resp
-
-    def _is_done(self, response):
-        # This could break if new messages don't name the field the
-        # same thing.
-        return response.done
-
-    def attach(self, resource):
-        self.resource = resource
-
-    def close(self):
-        # We have to drain the socket to make sure that we don't get
-        # weird responses when some other request comes after a
-        # failed/prematurely-terminated one.
-        try:
-            while self.next():
-                pass
-        except StopIteration:
-            pass
-        self.resource.release()
-
-
-class RiakPbcKeyStream(RiakPbcStream):
-    """
-    Used internally by RiakPbcTransport to implement key-list streams.
-    """
-
-    _expect = MSG_CODE_LIST_KEYS_RESP
-
-    def next(self):
-        response = super(RiakPbcKeyStream, self).next()
-
-        if response.done and len(response.keys) is 0:
-            raise StopIteration
-
-        return response.keys
-
-
-class RiakPbcMapredStream(RiakPbcStream):
-    """
-    Used internally by RiakPbcTransport to implement MapReduce
-    streams.
-    """
-
-    _expect = MSG_CODE_MAP_RED_RESP
-
-    def next(self):
-        response = super(RiakPbcMapredStream, self).next()
-
-        if response.done and not response.HasField('response'):
-            raise StopIteration
-
-        return response.phase, json.loads(response.response)
-
-
-class RiakPbcBucketStream(RiakPbcStream):
-    """
-    Used internally by RiakPbcTransport to implement key-list streams.
-    """
-
-    _expect = MSG_CODE_LIST_BUCKETS_RESP
-
-    def next(self):
-        response = super(RiakPbcBucketStream, self).next()
-
-        if response.done and len(response.buckets) is 0:
-            raise StopIteration
-
-        return response.buckets
-
-
-class RiakPbcIndexStream(RiakPbcStream):
-    """
-    Used internally by RiakPbcTransport to implement Secondary Index
-    streams.
-    """
-
-    _expect = MSG_CODE_INDEX_RESP
-
-    def __init__(self, transport, index, return_terms=False):
-        super(RiakPbcIndexStream, self).__init__(transport)
-        self.index = index
-        self.return_terms = return_terms
-
-    def next(self):
-        response = super(RiakPbcIndexStream, self).next()
-
-        if response.done and not (response.keys or
-                                  response.results or
-                                  response.continuation):
-            raise StopIteration
-
-        if self.return_terms and response.results:
-            return [(decode_index_value(self.index, r.key), r.value)
-                    for r in response.results]
-        elif response.keys:
-            return response.keys[:]
-        elif response.continuation:
-            return CONTINUATION(response.continuation)

riak-2.1.0.tar.gz/riak/transports/pbc/transport.py Deleted

@@ -1,689 +0,0 @@
-"""
-Copyright 2012 Basho Technologies, Inc.
-Copyright 2010 Rusty Klophaus <rusty@basho.com>
-Copyright 2010 Justin Sheehy <justin@basho.com>
-Copyright 2009 Jay Baird <jay@mochimedia.com>
-
-This file is provided to you under the Apache License,
-Version 2.0 (the "License"); you may not use this file
-except in compliance with the License.  You may obtain
-a copy of the License at
-
-http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing,
-software distributed under the License is distributed on an
-"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-KIND, either express or implied.  See the License for the
-specific language governing permissions and limitations
-under the License.
-"""
-
-import riak_pb
-from riak import RiakError
-from riak.transports.transport import RiakTransport
-from riak.riak_object import VClock
-from riak.util import decode_index_value
-from connection import RiakPbcConnection
-from stream import (RiakPbcKeyStream, RiakPbcMapredStream, RiakPbcBucketStream,
-                    RiakPbcIndexStream)
-from codec import RiakPbcCodec
-
-from riak_pb.messages import (
-    MSG_CODE_PING_REQ,
-    MSG_CODE_PING_RESP,
-    MSG_CODE_GET_CLIENT_ID_REQ,
-    MSG_CODE_GET_CLIENT_ID_RESP,
-    MSG_CODE_SET_CLIENT_ID_REQ,
-    MSG_CODE_SET_CLIENT_ID_RESP,
-    MSG_CODE_GET_SERVER_INFO_REQ,
-    MSG_CODE_GET_SERVER_INFO_RESP,
-    MSG_CODE_GET_REQ,
-    MSG_CODE_GET_RESP,
-    MSG_CODE_PUT_REQ,
-    MSG_CODE_PUT_RESP,
-    MSG_CODE_DEL_REQ,
-    MSG_CODE_DEL_RESP,
-    MSG_CODE_LIST_BUCKETS_REQ,
-    MSG_CODE_LIST_BUCKETS_RESP,
-    MSG_CODE_LIST_KEYS_REQ,
-    MSG_CODE_GET_BUCKET_REQ,
-    MSG_CODE_GET_BUCKET_RESP,
-    MSG_CODE_SET_BUCKET_REQ,
-    MSG_CODE_SET_BUCKET_RESP,
-    MSG_CODE_GET_BUCKET_TYPE_REQ,
-    MSG_CODE_SET_BUCKET_TYPE_REQ,
-    MSG_CODE_MAP_RED_REQ,
-    MSG_CODE_INDEX_REQ,
-    MSG_CODE_INDEX_RESP,
-    MSG_CODE_SEARCH_QUERY_REQ,
-    MSG_CODE_SEARCH_QUERY_RESP,
-    MSG_CODE_RESET_BUCKET_REQ,
-    MSG_CODE_RESET_BUCKET_RESP,
-    MSG_CODE_COUNTER_UPDATE_REQ,
-    MSG_CODE_COUNTER_UPDATE_RESP,
-    MSG_CODE_COUNTER_GET_REQ,
-    MSG_CODE_COUNTER_GET_RESP,
-    MSG_CODE_YOKOZUNA_INDEX_GET_REQ,
-    MSG_CODE_YOKOZUNA_INDEX_GET_RESP,
-    MSG_CODE_YOKOZUNA_INDEX_PUT_REQ,
-    MSG_CODE_YOKOZUNA_INDEX_DELETE_REQ,
-    MSG_CODE_YOKOZUNA_SCHEMA_GET_REQ,
-    MSG_CODE_YOKOZUNA_SCHEMA_GET_RESP,
-    MSG_CODE_YOKOZUNA_SCHEMA_PUT_REQ,
-    MSG_CODE_DT_FETCH_REQ,
-    MSG_CODE_DT_FETCH_RESP,
-    MSG_CODE_DT_UPDATE_REQ,
-    MSG_CODE_DT_UPDATE_RESP
-)
-
-
-class RiakPbcTransport(RiakTransport, RiakPbcConnection, RiakPbcCodec):
-    """
-    The RiakPbcTransport object holds a connection to the protocol
-    buffers interface on the riak server.
-    """
-
-    def __init__(self,
-                 node=None,
-                 client=None,
-                 timeout=None,
-                 *unused_options):
-        """
-        Construct a new RiakPbcTransport object.
-        """
-        super(RiakPbcTransport, self).__init__()
-
-        self._client = client
-        self._node = node
-        self._address = (node.host, node.pb_port)
-        self._timeout = timeout
-        self._socket = None
-
-    # FeatureDetection API
-    def _server_version(self):
-        return self.get_server_info()['server_version']
-
-    def ping(self):
-        """
-        Ping the remote server
-        """
-
-        msg_code, msg = self._request(MSG_CODE_PING_REQ)
-        if msg_code == MSG_CODE_PING_RESP:
-            return True
-        else:
-            return False
-
-    def get_server_info(self):
-        """
-        Get information about the server
-        """
-        msg_code, resp = self._request(MSG_CODE_GET_SERVER_INFO_REQ,
-                                       expect=MSG_CODE_GET_SERVER_INFO_RESP)
-        return {'node': resp.node, 'server_version': resp.server_version}
-
-    def _get_client_id(self):
-        msg_code, resp = self._request(MSG_CODE_GET_CLIENT_ID_REQ,
-                                       expect=MSG_CODE_GET_CLIENT_ID_RESP)
-        return resp.client_id
-
-    def _set_client_id(self, client_id):
-        req = riak_pb.RpbSetClientIdReq()
-        req.client_id = client_id
-
-        msg_code, resp = self._request(MSG_CODE_SET_CLIENT_ID_REQ, req,
-                                       MSG_CODE_SET_CLIENT_ID_RESP)
-
-        self._client_id = client_id
-
-    client_id = property(_get_client_id, _set_client_id,
-                         doc="""the client ID for this connection""")
-
-    def get(self, robj, r=None, pr=None, timeout=None, basic_quorum=None,
-            notfound_ok=None):
-        """
-        Serialize get request and deserialize response
-        """
-        bucket = robj.bucket
-
-        req = riak_pb.RpbGetReq()
-        if r:
-            req.r = self._encode_quorum(r)
-        if self.quorum_controls():
-            if pr:
-                req.pr = self._encode_quorum(pr)
-            if basic_quorum is not None:
-                req.basic_quorum = basic_quorum
-            if notfound_ok is not None:
-                req.notfound_ok = notfound_ok
-        if self.client_timeouts() and timeout:
-            req.timeout = timeout
-        if self.tombstone_vclocks():
-            req.deletedvclock = True
-
-        req.bucket = bucket.name
-        self._add_bucket_type(req, bucket.bucket_type)
-
-        req.key = robj.key
-
-        msg_code, resp = self._request(MSG_CODE_GET_REQ, req,
-                                       MSG_CODE_GET_RESP)
-
-        if resp is not None:
-            if resp.HasField('vclock'):
-                robj.vclock = VClock(resp.vclock, 'binary')
-            # We should do this even if there are no contents, i.e.
-            # the object is tombstoned
-            self._decode_contents(resp.content, robj)
-        else:
-            # "not found" returns an empty message,
-            # so let's make sure to clear the siblings
-            robj.siblings = []
-
-        return robj
-
-    def put(self, robj, w=None, dw=None, pw=None, return_body=True,
-            if_none_match=False, timeout=None):
-        bucket = robj.bucket
-
-        req = riak_pb.RpbPutReq()
-        if w:
-            req.w = self._encode_quorum(w)
-        if dw:
-            req.dw = self._encode_quorum(dw)
-        if self.quorum_controls() and pw:
-            req.pw = self._encode_quorum(pw)
-
-        if return_body:
-            req.return_body = 1

riak-2.1.0.tar.gz/MANIFEST.in -> riak-2.5.4.tar.gz/MANIFEST.in Changed

riak-2.1.0.tar.gz/PKG-INFO -> riak-2.5.4.tar.gz/PKG-INFO Changed

@@ -1,16 +1,279 @@
 Metadata-Version: 1.1
 Name: riak
-Version: 2.1.0
+Version: 2.5.4
 Summary: Python client for Riak
 Home-page: https://github.com/basho/riak-python-client
 Author: Basho Technologies
 Author-email: clients@basho.com
 License: Apache 2
-Description: UNKNOWN
+Description: Python Client for Riak
+        ======================
+        
+        Build Status
+        ============
+        
+        |Build Status|
+        
+        Documentation
+        =============
+        
+        `Documentation for the Riak Python Client
+        Library <http://basho.github.io/riak-python-client/index.html>`__ is
+        available
+        `here <http://basho.github.io/riak-python-client/index.html>`__.
+        
+        Documentation for Riak is available
+        `here <http://docs.basho.com/riak/latest>`__.
+        
+        Repository Cloning
+        ==================
+        
+        *NOTE*: please clone this repository using the ``--recursive`` argument
+        to ``git clone`` or follow the clone with
+        ``git submodule update --init``. This repository uses two submodules.
+        
+        Install
+        =======
+        
+        The recommended versions of Python for use with this client are Python
+        ``2.7.8`` (or greater, ``2.7.11`` as of ``2016-06-21``), ``3.3.x``,
+        ``3.4.x`` and ``3.5.x``. The latest version from each series should be
+        preferred. Older versions of the Python ``2.7.X`` and ``3.X`` series
+        should be used with caution as they are not covered by integration
+        tests.
+        
+        Riak TS (Timeseries)
+        ====================
+        
+        You must use version ``2.7.11``, ``3.4.4`` or ``3.5.1`` (or greater
+        within a version series). Otherwise you will be affected by `this Python
+        bug <https://bugs.python.org/issue23517>`__.
+        
+        From Source
+        -----------
+        
+        .. code:: sh
+        
+            python setup.py install
+        
+        There are additional dependencies on Python packages ``setuptools`` and
+        ``protobuf``.
+        
+        From PyPI
+        ---------
+        
+        Official packages are signed and published to
+        `PyPI <https://pypi.python.org/pypi/riak>`__.
+        
+        To install from `PyPI <https://pypi.python.org/pypi/riak>`__ directly
+        you can use ``pip``.
+        
+        .. code:: sh
+        
+            pip install riak
+        
+        Testing
+        =======
+        
+        To setup the default test configuration build a test Riak node (from a
+        ``riak`` directory)
+        
+        .. code:: sh
+        
+            make rel
+        
+        See `Basic Cluster
+        Setup <http://docs.basho.com/riak/latest/ops/building/basic-cluster-setup/>`__
+        for more details.
+        
+        For all of the simple default values, set the ``RIAK_DIR`` environment
+        variable to the root of your Riak installation. Then from the
+        ``riak-python-client`` directory
+        
+        .. code:: sh
+        
+            make -C buildbot preconfigure
+        
+        Start your Riak node with ``riak start`` from the the Riak directory,
+        then
+        
+        .. code:: sh
+        
+            make -C buildbot configure
+            make -C buildbot test
+        
+        That will run the test suite twice: once with security enabled and once
+        without.
+        
+        Connections to Riak in Tests
+        ----------------------------
+        
+        If your Riak server isn't running on localhost or you have built a Riak
+        devrel from source, use the environment variables ``RIAK_TEST_HOST``,
+        ``RIAK_TEST_HTTP_PORT`` and ``RIAK_TEST_PB_PORT`` to specify where to
+        find the Riak server. ``RIAK_TEST_PROTOCOL`` to specify which protocol
+        to test. Can be either ``pbc`` or ``http``.
+        
+        Some of the connection tests need port numbers that are NOT in use. If
+        ports 1023 and 1022 are in use on your test system, set the environment
+        variables ``DUMMY_HTTP_PORT`` and ``DUMMY_PB_PORT`` to unused port
+        numbers.
+        
+        Testing Search
+        --------------
+        
+        If you don't have `Riak
+        Search <http://docs.basho.com/riak/latest/dev/using/search/>`__ enabled,
+        you can set the ``RUN_SEARCH`` environment variable to 0 skip those
+        tests.
+        
+        If you don't have `Search 2.0 <https://github.com/basho/yokozuna>`__
+        enabled, you can set the ``RUN_YZ`` environment variable to 0 to skip
+        those tests.
+        
+        Testing Bucket Types (Riak 2+)
+        ------------------------------
+        
+        To test bucket-types, you must run the ``create_bucket_types`` setup
+        command, which will create the bucket-types used in testing, or create
+        them manually yourself. It can be run like so (substituting ``$RIAK``
+        with the root of your Riak install)
+        
+        .. code:: sh
+        
+            ./setup.py create_bucket_types --riak-admin=$RIAK/bin/riak-admin
+        
+        You may alternately add these lines to ``setup.cfg``
+        
+        .. code:: ini
+        
+            [create_bucket_types]
+            riak-admin=/Users/sean/dev/riak/rel/riak/bin/riak-admin
+        
+        To skip the bucket-type tests, set the ``RUN_BTYPES`` environment
+        variable to ``0``.
+        
+        Testing Data Types (Riak 2+)
+        ----------------------------
+        
+        To test data types, you must set up bucket types (see above.)
+        
+        To skip the data type tests, set the ``RUN_DATATYPES`` environment
+        variable to ``0``.
+        
+        Testing Timeseries (Riak 2.1+)
+        ------------------------------
+        
+        To test timeseries data, you must run the ``setup_timeseries`` command,
+        which will create the bucket-types used in testing, or create them
+        manually yourself. It can be run like so (substituting ``$RIAK`` with
+        the root of your Riak install)
+        
+        .. code:: sh
+        
+            ./setup.py setup_timeseries --riak-admin=$RIAK/bin/riak-admin
+        
+        You may alternately add these lines to ``setup.cfg``
+        
+        .. code:: sh
+        
+            [setup_timeseries]
+            riak-admin=/Users/sean/dev/riak/rel/riak/bin/riak-admin
+        
+        To enable the timeseries tests, set the ``RUN_TIMESERIES`` environment
+        variable to ``1``.
+        
+        Testing Secondary Indexes
+        -------------------------
+        
+        To test `Secondary
+        Indexes <http://docs.basho.com/riak/latest/dev/using/2i/>`__, the
+        ``RUN_INDEXES`` environment variable must be set to 1 (or 0 to skip
+        them.)
+        
+        Testing Security (Riak 2+)
+        --------------------------
+        
+        Ensure that the hostname ``riak-test`` resolves to your Riak host (most

riak-2.5.4.tar.gz/README.md Added

@@ -0,0 +1,204 @@
+Python Client for Riak
+======================
+
+Build Status
+============
+
+[![Build Status](https://travis-ci.org/basho/riak-python-client.svg?branch=master)](https://travis-ci.org/basho/riak-python-client)
+
+Documentation
+=============
+
+[Documentation for the Riak Python Client Library](http://basho.github.io/riak-python-client/index.html) is available [here](http://basho.github.io/riak-python-client/index.html).
+
+Documentation for Riak is available [here](http://docs.basho.com/riak/latest).
+
+Repository Cloning
+==================
+
+*NOTE*: please clone this repository using the `--recursive` argument to `git clone` or follow the clone with `git submodule update --init`. This repository uses two submodules.
+
+Install
+=======
+
+The recommended versions of Python for use with this client are Python `2.7.8` (or greater, `2.7.11` as of `2016-06-21`), `3.3.x`, `3.4.x` and `3.5.x`. The latest version from each series should be preferred. Older versions of the Python `2.7.X` and `3.X` series should be used with caution as they are not covered by integration tests.
+
+Riak TS (Timeseries)
+===================
+
+You must use version `2.7.11`, `3.4.4` or `3.5.1` (or greater within a version series). Otherwise you will be affected by [this Python bug](https://bugs.python.org/issue23517).
+
+From Source
+-----------
+
+```sh
+python setup.py install
+```
+
+There are additional dependencies on Python packages `setuptools` and `protobuf`.
+
+From PyPI
+---------
+
+Official packages are signed and published to [PyPI](https://pypi.python.org/pypi/riak).
+
+To install from [PyPI](https://pypi.python.org/pypi/riak) directly you can use `pip`. 
+
+```sh
+pip install riak
+```
+
+Testing
+=======
+
+To setup the default test configuration build a test Riak node (from a `riak` directory)
+
+```sh
+make rel
+```
+
+See [Basic Cluster Setup](http://docs.basho.com/riak/latest/ops/building/basic-cluster-setup/) for more details.
+
+For all of the simple default values, set the `RIAK_DIR` environment variable to the root of your Riak installation. Then from the `riak-python-client` directory 
+
+```sh
+make -C buildbot preconfigure
+```
+
+Start your Riak node with `riak start` from the the Riak directory, then 
+
+```sh
+make -C buildbot configure
+make -C buildbot test
+```
+
+That will run the test suite twice: once with security enabled and once without.
+
+Connections to Riak in Tests
+----------------------------
+
+If your Riak server isn't running on localhost or you have built a Riak devrel from source, use the environment variables `RIAK_TEST_HOST`, `RIAK_TEST_HTTP_PORT` and `RIAK_TEST_PB_PORT` to specify where to find the Riak server.  `RIAK_TEST_PROTOCOL` to specify which protocol to test. Can be either `pbc` or `http`.
+
+Some of the connection tests need port numbers that are NOT in use. If ports 1023 and 1022 are in use on your test system, set the environment variables `DUMMY_HTTP_PORT` and `DUMMY_PB_PORT` to unused port numbers.
+
+Testing Search
+--------------
+
+If you don't have [Riak Search](http://docs.basho.com/riak/latest/dev/using/search/) enabled, you can set the `RUN_SEARCH` environment variable to 0 skip those tests.
+
+If you don't have [Search 2.0](https://github.com/basho/yokozuna) enabled, you can set the `RUN_YZ` environment variable to 0 to skip those tests.
+
+Testing Bucket Types (Riak 2+)
+------------------------------
+
+To test bucket-types, you must run the `create_bucket_types` setup command, which will create the bucket-types used in testing, or create them manually yourself. It can be run like so (substituting `$RIAK` with the root of your Riak install)
+
+```sh
+./setup.py create_bucket_types --riak-admin=$RIAK/bin/riak-admin
+```
+
+You may alternately add these lines to `setup.cfg`
+
+```ini
+[create_bucket_types]
+riak-admin=/Users/sean/dev/riak/rel/riak/bin/riak-admin
+```
+
+To skip the bucket-type tests, set the `RUN_BTYPES` environment variable to `0`.
+
+Testing Data Types (Riak 2+)
+----------------------------
+
+To test data types, you must set up bucket types (see above.)
+
+To skip the data type tests, set the `RUN_DATATYPES` environment variable to `0`.
+
+Testing Timeseries (Riak 2.1+)
+------------------------------
+
+To test timeseries data, you must run the `setup_timeseries` command, which will create the bucket-types used in testing, or create them manually yourself. It can be run like so (substituting `$RIAK` with the root of your Riak install)
+
+```sh
+./setup.py setup_timeseries --riak-admin=$RIAK/bin/riak-admin
+```
+
+You may alternately add these lines to `setup.cfg`
+
+```sh
+[setup_timeseries]
+riak-admin=/Users/sean/dev/riak/rel/riak/bin/riak-admin
+```
+
+To enable the timeseries tests, set the `RUN_TIMESERIES` environment variable to `1`.
+
+Testing Secondary Indexes
+-------------------------
+
+To test [Secondary Indexes](http://docs.basho.com/riak/latest/dev/using/2i/), the `RUN_INDEXES` environment variable must be set to 1 (or 0 to skip them.)
+
+Testing Security (Riak 2+)
+--------------------------
+
+Ensure that the hostname `riak-test` resolves to your Riak host (most likely `localhost`). This is so the SSL host verification can succeed.
+
+By default [Security](http://docs.basho.com/riak/latest/ops/running/authz/) is not enabled on Riak. Once `security = on` is configured in the `riak.conf` file it can be enabled with `riak-admin`.
+
+To run the tests
+
+```sh
+RUN_SECURITY=1 RIAK_TEST_HTTP_PORT=18098 python setup.py test
+```
+
+Contributors
+--------------------------
+
+* Andrew Thompson
+* Andy Gross
+* Armon Dadgar
+* Brett Hazen
+* Brett Hoerner
+* Brian Roach
+* Bryan Fink
+* Daniel Lindsley
+* Daniel Néri
+* Daniel Reverri
+* [Dan Root](https://github.com/daroot)
+* [David Basden](https://github.com/dbasden)
+* David Koblas
+* Dmitry Rozhkov
+* Eric Florenzano
+* Eric Moritz
+* Filip de Waard
+* Gilles Devaux
+* Greg Nelson
+* Gregory Burd
+* Greg Stein
+* Ian Plosker
+* Jayson Baird
+* Jeffrey Massung
+* Jon Meredith
+* Josip Lisec
+* Justin Sheehy
+* Kevin Smith
+* [Luke Bakken](https://github.com/lukebakken)
+* Mark Erdmann
+* Mark Phillips
+* Mathias Meyer
+* Matt Heitzenroder
+* [Matt Lohier](https://github.com/aquam8)
+* Mikhail Sobolev
+* Reid Draper
+* Russell Brown
+* Rusty Klophaus
+* Rusty Klophaus
+* Scott Lystig Fritchie
+* Sean Cribbs
+* Shuhao Wu
+* Silas Sewell
+* Socrates Lee
+* Soren Hansen

riak-2.1.0.tar.gz/README.rst -> riak-2.5.4.tar.gz/README.rst Changed

@@ -1,128 +1,125 @@
-======================
 Python Client for Riak
 ======================
 
+Build Status
+============
+
+|Build Status|
+
 Documentation
 =============
 
-`Documentation for the Riak Python Client Library
-<http://basho.github.io/riak-python-client/index.html>`_ is available
-here. The documentation source is found in `docs/ subdirectory
-<https://github.com/basho/riak-python-client/tree/master/docs>`_ and
-can be built with `Sphinx <http://sphinx.pocoo.org/>`_.
+`Documentation for the Riak Python Client
+Library <http://basho.github.io/riak-python-client/index.html>`__ is
+available
+`here <http://basho.github.io/riak-python-client/index.html>`__.
 
-Documentation for Riak is available at http://docs.basho.com/riak/latest
-
-Install
-=======
+Documentation for Riak is available
+`here <http://docs.basho.com/riak/latest>`__.
 
-The recommended version of Python for use with this client is Python
-2.7. From the Riak Python Client root directory, execute::
+Repository Cloning
+==================
 
-    python setup.py install
+*NOTE*: please clone this repository using the ``--recursive`` argument
+to ``git clone`` or follow the clone with
+``git submodule update --init``. This repository uses two submodules.
 
-There is an additional dependency on the Python package `setuptools`.
+Install
+=======
 
-Official packages are signed and published to `PyPI
-<https://pypi.python.org/pypi/riak>`_.
+The recommended versions of Python for use with this client are Python
+``2.7.8`` (or greater, ``2.7.11`` as of ``2016-06-21``), ``3.3.x``,
+``3.4.x`` and ``3.5.x``. The latest version from each series should be
+preferred. Older versions of the Python ``2.7.X`` and ``3.X`` series
+should be used with caution as they are not covered by integration
+tests.
 
+Riak TS (Timeseries)
+====================
 
-Testing
-=======
+You must use version ``2.7.11``, ``3.4.4`` or ``3.5.1`` (or greater
+within a version series). Otherwise you will be affected by `this Python
+bug <https://bugs.python.org/issue23517>`__.
 
-To setup the default test configuration build a test Riak node (from
-a ``riak`` directory)::
+From Source
+-----------
 
-   make rel
+.. code:: sh
 
-See `Basic Cluster Setup
-<http://docs.basho.com/riak/2.0.0/ops/building/basic-cluster-setup/>`_
-for more details.
+    python setup.py install
 
-For all of the simple default values, set the ``RIAK_DIR`` environment
-variable to the root of your Riak installation.  Then from the
-``riak-python-client`` directory ::
+There are additional dependencies on Python packages ``setuptools`` and
+``protobuf``.
 
-   cd buildbot
-   make preconfigure
+From PyPI
+---------
 
-Start your Riak node with ``riak start`` from the the Riak directory,
-then back in ``buildbot`` type::
+Official packages are signed and published to
+`PyPI <https://pypi.python.org/pypi/riak>`__.
 
-   make configure
-   make test
+To install from `PyPI <https://pypi.python.org/pypi/riak>`__ directly
+you can use ``pip``.
 
-That will run the test suite twice: once with security enabled and once
-without.
+.. code:: sh
 
-Testing Options
----------------
+    pip install riak
 
-If you wish to change the default options you can run the setup by hand.
-First configure the test node by adjusting the ``riak.conf``
-settings, where ``RIAK_DIR`` is the path to the top your
-Riak installation::
+Testing
+=======
 
-   python setup.py preconfigure --riak-conf=$RIAK_DIR/etc/riak.conf
+To setup the default test configuration build a test Riak node (from a
+``riak`` directory)
 
-Optionally the hostname and port numbers can be changed, too, via these
-arguments:
+.. code:: sh
 
-    - ``--host=`` IP of host running Riak (default is ``localhost``)
-    - ``--pb-port=`` protocol buffers port number (default is ``8087``)
-    - ``--http-port=`` http port number (default is ``8098``)
-    - ``--https-port=`` https port number (default is ``8099``)
+    make rel
 
-You may alternately add these lines to ``setup.cfg``::
+See `Basic Cluster
+Setup <http://docs.basho.com/riak/latest/ops/building/basic-cluster-setup/>`__
+for more details.
 
-    [preconfigure]
-    riak-conf=/Users/sean/dev/riak/rel/riak/etc/riak.conf
-    host=localhost
-    pb-port=8087
-    http-port=8098
-    https-port=8099
+For all of the simple default values, set the ``RIAK_DIR`` environment
+variable to the root of your Riak installation. Then from the
+``riak-python-client`` directory
 
-Next start the test node.  Once it is running, a test configuration is
-installed which includes security test users and bucket types::
+.. code:: sh
 
-    python setup.py configure --riak-admin=$RIAK_DIR/bin/riak-admin
+    make -C buildbot preconfigure
 
-Optionally these configuration settings can be changed, too:
+Start your Riak node with ``riak start`` from the the Riak directory,
+then
 
-   - ``--username=`` test user account (default is ``testuser``)
-   - ``--password=`` password for test user account (default is
-     ``testpassword``)
-   - ``--certuser=`` secruity test user account (default is ``certuser``)
-   - ``--certpass=`` password for security test user account (default is
-     ``certpass``)
+.. code:: sh
 
-Similarly ``setup.cfg`` may be modified instead.  To run the tests against a
-Riak server (with configured TCP port configuration) on localhost, execute::
+    make -C buildbot configure
+    make -C buildbot test
 
-    python setup.py test
+That will run the test suite twice: once with security enabled and once
+without.
 
 Connections to Riak in Tests
 ----------------------------
 
-If your Riak server isn't running on localhost or you have built a
-Riak devrel from source, use the environment variables
-``RIAK_TEST_HOST``, ``RIAK_TEST_HTTP_PORT`` and
-``RIAK_TEST_PB_PORT`` to specify where to find the Riak server.
+If your Riak server isn't running on localhost or you have built a Riak
+devrel from source, use the environment variables ``RIAK_TEST_HOST``,
+``RIAK_TEST_HTTP_PORT`` and ``RIAK_TEST_PB_PORT`` to specify where to
+find the Riak server. ``RIAK_TEST_PROTOCOL`` to specify which protocol
+to test. Can be either ``pbc`` or ``http``.
 
 Some of the connection tests need port numbers that are NOT in use. If
-ports 1023 and 1022 are in use on your test system, set the
-environment variables ``DUMMY_HTTP_PORT`` and ``DUMMY_PB_PORT`` to
-unused port numbers.
+ports 1023 and 1022 are in use on your test system, set the environment
+variables ``DUMMY_HTTP_PORT`` and ``DUMMY_PB_PORT`` to unused port
+numbers.
 
 Testing Search
 --------------
 
-If you don't have `Riak Search
-<http://docs.basho.com/riak/latest/dev/using/search/>`_ enabled, you
-can set the ``SKIP_SEARCH`` environment variable to 1 skip those
+If you don't have `Riak
+Search <http://docs.basho.com/riak/latest/dev/using/search/>`__ enabled,
+you can set the ``RUN_SEARCH`` environment variable to 0 skip those
 tests.

riak-2.5.4.tar.gz/RELNOTES.md Added

@@ -0,0 +1,328 @@
+# Riak Python Client Release Notes
+
+## [2.5.4 Release](https://github.com/basho/riak-python-client/issues?q=milestone%3Ariak-python-client-2.5.4)
+
+ * [When converting `datetime` objects to send to Riak TS, `tzinfo` will be used if present](https://github.com/basho/riak-python-client/pull/486)
+ * [Workaround for incorrect version returned by Riak TS OSS](https://github.com/basho/riak-python-client/pull/472)
+
+## [2.5.3 Release](https://github.com/basho/riak-python-client/issues?q=milestone%3Ariak-python-client-2.5.3)
+
+ * [Bug fix for raising `BadResource`](https://github.com/basho/riak-python-client/pull/481)
+
+## [2.5.2 Release](https://github.com/basho/riak-python-client/issues?q=milestone%3Ariak-python-client-2.5.2)
+
+* *NOTE*: for Riak TS data, automatic conversion from epoch values *to* Python `datetime` objects has been removed. If you would like to have automatic conversion, use `RiakClient(transport_options={'ts_convert_timestamp': True})`
+* Miscellaneous fixes for term-to-binary encoding of messages for Riak TS.
+* [Ensure `six` is not required during installation](https://github.com/basho/riak-python-client/pull/459)
+
+## [2.5.0 Release - Deprecated](https://github.com/basho/riak-python-client/issues?q=milestone%3Ariak-python-client-2.5.0)
+
+* *NOTE*: due to the `basho-erlastic` dependency, this version will not install correctly. Please use `2.5.2`.
+* *NOTE*: for Riak TS data, automatic conversion from epoch values *to* Python `datetime` objects has been removed. If you would like to have automatic conversion, use `RiakClient(transport_options={'ts_convert_timestamp': True})`
+* [Socket Enhancements](https://github.com/basho/riak-python-client/pull/453) - Resolves [#399](https://github.com/basho/riak-python-client/issues/399)
+* [Add multi-put](https://github.com/basho/riak-python-client/pull/452)
+* [Add support for term-to-binary encoding](https://github.com/basho/riak-python-client/pull/448) *Note:* This requires at least version `1.3.0` of Riak TS.
+
+## 2.4.2 Patch Release - 2016-02-20
+
+* [Fix SSL host name](https://github.com/basho/riak-python-client/pull/436)
+* [Use `riak-client-tools`](https://github.com/basho/riak-python-client/issues/434)
+
+## 2.4.1 Patch Release - 2016-02-03
+
+* [Riak TS: Millisecond precision](https://github.com/basho/riak-python-client/issues/430)
+* [Fix release process](https://github.com/basho/riak-python-client/issues/429)
+
+## 2.4.0 Feature Release - 2016-01-13
+
+This release enhances Riak Time Series functionality.
+
+* [Encapsulate table description](https://github.com/basho/riak-python-client/pull/422)
+
+## 2.3.0 Feature Release - 2015-12-14
+
+Release 2.3.0 features support for new
+[time series](https://github.com/basho/riak-python-client/pull/416)
+functionality.
+
+This is release retires support for Python 2.6.x but adds support for
+Python 3.5.x.
+
+There are also many bugfixes and new enhancements:
+
+* [The `riak_pb` module is now integrated into the Python Client]
+  (https://github.com/basho/riak-python-client/pull/418)
+* [Support for Preflists and Write-Once bucket types]
+  (https://github.com/basho/riak-python-client/pull/414)
+* [Support Riak 2.1.1]
+  (https://github.com/basho/riak-python-client/pull/407)
+* [Native SSL support for Python 2.7.9+]
+  (https://github.com/basho/riak-python-client/pull/397)
+
+
+## 2.2.0 Feature Release - 2014-12-18
+
+Release 2.2.0 features support for
+[Python 3](https://github.com/basho/riak-python-client/pull/379),
+specifically 3.3 and 3.4.  This version uses the native SSL security instead
+of [pyOpenSSL](http://pypi.python.org/pypi/pyOpenSSL) which is required
+for the Python 2 series.
+
+This release also includes many bugfixes and enhancements, most
+notably:
+
+* [Fixed an issue with the implementation of `Mapping.__iter__`]
+  (https://github.com/basho/riak-python-client/pull/367)
+* [Test client certificate generation updated]
+  (https://github.com/basho/riak-python-client/pull/373)
+* [Protocol Buffers had a socket.send issue]
+  (https://github.com/basho/riak-python-client/pull/382)
+* [Support for bucket types in Map/Reduce jobs added]
+  (https://github.com/basho/riak-python-client/pull/385)
+* [Race condition in `RiakBucket` creation fixed]
+  (https://github.com/basho/riak-python-client/pull/386)
+* [Data Types can now be deleted]
+  (https://github.com/basho/riak-python-client/pull/387)
+* [2i Range Queries with a zero end index now work]
+  (https://github.com/basho/riak-python-client/pull/388)
+
+
+## 2.1.0 Feature Release - 2014-09-03
+
+Release 2.1.0 features support for Riak 2.0 capabilities including:
+
+* Bucket Types
+* Riak Data Types (CRDTs)
+* Search 2.0 (codename Yokozuna)
+* Security: SSL/TLS, Authentication, and Authorization
+
+As a result of the new security features, the package now depends on
+[pyOpenSSL](http://pypi.python.org/pypi/pyOpenSSL) and will warn if
+your version of OpenSSL is too old.
+
+This release also includes many bugfixes and enhancements, most
+notably:
+
+* The default protocol is now 'pbc', not 'http'.
+* When used correctly, streaming requests no longer result in leaks
+  from the connection pool.
+* The size of the multiget worker pool can be set when initializing
+  the client.
+* Secondary index queries can now iterate over all pages in a query.
+* The number of times a request is retried after network failure is
+  now configurable.
+* The additional request options `basic_quorum` and `notfound_ok` are
+  now supported.
+
+## 2.0.3 Patch Release - 2014-03-06
+
+Release 2.0.3 includes support for 1.4.4's 2I regexp feature and fixes
+a few bugs:
+
+* Docs generation now uses the version from the top-level package.
+* Some internal uses of the deprecated RiakClient.solr were removed.
+* More errors will be caught and propagated properly from multiget
+  requests, preventing deadlocks on the caller side.
+
+## 2.0.2 Patch release - 2013-11-18
+
+Release 2.0.2 includes support for the 1.4.1+ "timeout" option on
+secondary index queries.
+
+## 2.0.1 Patch release - 2013-08-28
+
+Release 2.0.1 includes a minor compatibility fix for Python 2.6 and an
+updated README.
+
+## 2.0.0 Feature Release - 2013-07-30
+
+Release 2.0 is the culmination of many months of rearchitecting the
+client. Highlights:
+
+* Automatic connection to multiple nodes, with request retries,
+  through a thread-safe connection pool.
+* All Riak 1.3 and 1.4 features, including bucket properties,
+  paginating and streaming secondary indexes, CRDT counters,
+  client-specified timeouts, and more.
+* Cleaner, more Pythonic access to RiakObject and RiakBucket
+  attributes, favoring properties over methods where possible.
+* Simpler representations of links (3-tuples) and index entries
+  (2-tuples).
+* Streaming requests (keys, buckets, MapReduce, 2i) are now exposed as
+  iterators.
+* Feature detection prevents sending requests to hosts that can't
+  handle them.
+* Better handling of siblings -- you don't have to request them
+  individually anymore -- and registrable resolver functions.
+* A new `multiget` operation that fetches a collection of keys using
+  a pool background threads.
+* A more resilient, repeatable test suite that generates buckets and
+  key names that are essentially random.
+* Last but not least, a brand new, more detailed documentation site!
+
+Other features:
+
+* Added an encoder/decoder pair to support `text/plain`.
+* The Travis CI build will now install the latest Riak to run the
+  suite against.
+
+Other bugfixes:
+
+* The `charset` metadata can now be received via the `Content-Type`
+  header on HTTP.
+* Objects with empty keys and buckets with empty names cannot be
+  created or accessed, as they are unaddressable over HTTP.
+* Performance and compatibility of `TestServer` was improved.
+* Non-ASCII request bodies are better supported on HTTP.
+* Enabling and disabling search indexing on a bucket now uses the
+  `search` bucket property.
+
+## 1.5.2 Patch Release - 2013-01-31
+
+Release 1.5.2 fixes some bugs and adds HTTPS/SSL support.
+
+* Added support for HTTPS.
+* Fixed writing of the `app.config` for the `TestServer`.
+* Reorganized the tests into multiple files and cases.
+* Some methods on `RiakObject` were made private where appropriate.
+* The version comparison used in feature detection was loosened to
+  support pre-release versions of Riak.
+* Prevent fetching the `protobuf` package from Google Code.
+* Prefer `simplejson` over `json` when present.
+
+## 1.5.1 Patch Release - 2012-10-24
+
+Release 1.5.1 fixes one bug and some documentation errors.
+
+* Fix bug where `http_status` is used instead of `http_code`.
+* Fix documentation of `RiakMapReduce.index` method.
+* Fix documentation of `RiakClient.__init__` method.

riak-2.1.0.tar.gz/commands.py -> riak-2.5.4.tar.gz/commands.py Changed

@@ -1,18 +1,16 @@
-"""
-distutils commands for riak-python-client
-"""
-
-__all__ = ['create_bucket_types', 'setup_security', 'enable_security',
-           'disable_security', 'preconfigure', 'configure']
+import csv
+import os
+import os.path
+import re
 
-from distutils import log
 from distutils.core import Command
 from distutils.errors import DistutilsOptionError
+from distutils.file_util import write_file
+from distutils import log
 from subprocess import Popen, PIPE
-from string import Template
-import shutil
-import re
-import os.path
+
+
+__all__ = ['build_messages', 'setup_timeseries']
 
 
 # Exception classes used by this module.
@@ -73,33 +71,7 @@
     import json
 
 
-class create_bucket_types(Command):
-    """
-    Creates bucket-types appropriate for testing. By default this will create:
-
-    * `pytest-maps` with ``{"datatype":"map"}``
-    * `pytest-sets` with ``{"datatype":"set"}``
-    * `pytest-counters` with ``{"datatype":"counter"}``
-    * `pytest-consistent` with ``{"consistent":true}``
-    * `pytest-mr`
-    * `pytest` with ``{"allow_mult":false}``
-    """
-
-    description = "create bucket-types used in integration tests"
-
-    user_options = [
-        ('riak-admin=', None, 'path to the riak-admin script')
-    ]
-
-    _props = {
-        'pytest-maps': {'datatype': 'map'},
-        'pytest-sets': {'datatype': 'set'},
-        'pytest-counters': {'datatype': 'counter'},
-        'pytest-consistent': {'consistent': True},
-        'pytest-mr': {},
-        'pytest': {'allow_mult': False}
-    }
-
+class bucket_type_commands:
     def initialize_options(self):
         self.riak_admin = None
 
@@ -136,8 +108,8 @@
         except CalledProcessError as e:
             status = e.output
 
-        exists = ('not an existing bucket type' not in status)
-        active = ('is active' in status)
+        exists = ('not an existing bucket type' not in status.decode('ascii'))
+        active = ('is active' in status.decode('ascii'))
 
         if exists or active:
             log.info("Updating {0} bucket-type with props {1}"
@@ -146,8 +118,6 @@
                                      json.dumps({'props': props},
                                                 separators=(',', ':')))
         else:
-            print name
-            print props
             log.info("Creating {0} bucket-type with props {1}"
                      .format(repr(name), repr(props)))
             self.check_btype_command("create", name,
@@ -171,298 +141,250 @@
         return cmd
 
 
-class security_commands(object):
-    def check_security_command(self, *args):
-        cmd = self._security_command(*args)
-        return self.check_output(cmd)
-
-    def run_security_command(self, *args):
-        self.spawn(self._security_command(*args))
-
-    def _security_command(self, *args):
-        cmd = [self.riak_admin, "security"]
-        if isinstance(args, tuple):
-            for elem in args:
-                cmd.extend(elem)
-        else:
-            cmd.extend(args)
-        return cmd
-
-    def check_output(self, *args, **kwargs):
-        if self.dry_run:
-            log.info(' '.join(args))
-            return bytearray()
-        else:
-            return check_output(*args, **kwargs)
-
-
-class setup_security(Command, security_commands):
+class setup_timeseries(bucket_type_commands, Command):
     """
-    Sets up security for testing. By default this will create:
-
-    * User `testuser` with password `testpassword`
-    * User `certuser` with password `certpass`
-    * Two security sources
-    * Permissions on
-        * riak_kv.get
-        * riak_kv.put
-        * riak_kv.delete
-        * riak_kv.index
-        * riak_kv.list_keys
-        * riak_kv.list_buckets
-        * riak_kv.mapreduce
-        * riak_core.get_bucket
-        * riak_core.set_bucket
-        * riak_core.get_bucket_type
-        * riak_core.set_bucket_type
-        * search.admin
-        * search.query
+    Creates bucket-types appropriate for timeseries.
     """
 
-    description = "create security settings used in integration tests"
+    description = "create bucket-types used in timeseries tests"
 
     user_options = [
-        ('riak-admin=', None, 'path to the riak-admin script'),
-        ('username=', None, 'test user account'),
-        ('password=', None, 'password for test user account'),
-        ('certuser=', None, 'certificate test user account'),
-        ('certpass=', None, 'password for certificate test user account')
-    ]
-
-    _commands = [
-        "add-user $USERNAME password=$PASSWORD",
-        "add-source $USERNAME 127.0.0.1/32 password",
-        "add-user $CERTUSER password=$CERTPASS",
-        "add-source $CERTUSER 127.0.0.1/32 certificate"
+        ('riak-admin=', None, 'path to the riak-admin script')
     ]
 
-    _grants = {
-        "riak_kv.get": ["any"],
-        "riak_kv.put": ["any"],
-        "riak_kv.delete": ["any"],
-        "riak_kv.index": ["any"],
-        "riak_kv.list_keys": ["any"],
-        "riak_kv.list_buckets": ["any"],
-        "riak_kv.mapreduce": ["any"],
-        "riak_core.get_bucket": ["any"],
-        "riak_core.set_bucket": ["any"],
-        "riak_core.get_bucket_type": ["any"],
-        "riak_core.set_bucket_type": ["any"],
-        "search.admin": ["index", "schema"],
-        "search.query": ["index", "schema"]
+    _props = {
+        'GeoCheckin': {
+            'n_val': 3,
+            'table_def': '''
+                CREATE TABLE GeoCheckin (
+                    geohash varchar not null,
+                    user varchar not null,
+                    time timestamp not null,
+                    weather varchar not null,
+                    temperature double,
+                    PRIMARY KEY(
+                        (geohash, user, quantum(time, 15, m)),
+                        geohash, user, time
+                    )
+                )'''
+        }
     }
 
-    def initialize_options(self):
-        self.riak_admin = None
-        self.username = None
-        self.password = None
-        self.certuser = None
-        self.certpass = 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'

riak-2.1.0.tar.gz/docs/advanced.rst -> riak-2.5.4.tar.gz/docs/advanced.rst Changed

riak-2.1.0.tar.gz/docs/client.rst -> riak-2.5.4.tar.gz/docs/client.rst Changed

riak-2.1.0.tar.gz/docs/datatypes.rst -> riak-2.5.4.tar.gz/docs/datatypes.rst Changed

riak-2.1.0.tar.gz/docs/query.rst -> riak-2.5.4.tar.gz/docs/query.rst Changed

@@ -43,7 +43,7 @@
 
     for keys in bucket.stream_index("bmonth_int", 1):
         # keys is a list of matching keys
-        print keys
+        print(keys)
 
 Both the regular :meth:`~riak.bucket.RiakBucket.get_index` method and
 the :meth:`~riak.bucket.RiakBucket.stream_index` method allow you to
@@ -369,15 +369,15 @@
                             "scoville_high_i": 350000}).store()
     results = bucket.search("name_s:/c.*/", index='jalapeno')
     # Yields single document 'chipotle'
-    print results['docs'][0]['name_s']
+    print(results['docs'][0]['name_s'])
     results = bucket.search("scoville_high_i:[20000 TO 500000]")
     # Yields two documents
     for result in results['docs']:
-        print result['name_s']
+        print(result['name_s'])
     results = bucket.search('name_s:*', index='jalapeno', 
                             sort="scoville_low_i desc")
     # Yields all documents, sorted in descending order. We take the top one
-    print "The hottest pepper is {0}".format(results['docs'][0]['name_s'])
+    print("The hottest pepper is {0}".format(results['docs'][0]['name_s']))
 
 The results returned by :meth:`~riak.bucket.RiakBucket.search` is a dictionary
 with lots of search metadata like the number of results, the maxium

riak-2.1.0.tar.gz/riak.egg-info/PKG-INFO -> riak-2.5.4.tar.gz/riak.egg-info/PKG-INFO Changed

riak-2.1.0.tar.gz/riak.egg-info/SOURCES.txt -> riak-2.5.4.tar.gz/riak.egg-info/SOURCES.txt Changed

@@ -1,8 +1,8 @@
 LICENSE
 MANIFEST.in
+README.md
 README.rst
-RELEASE_NOTES.md
-THANKS
+RELNOTES.md
 commands.py
 setup.cfg
 setup.py
@@ -26,9 +26,13 @@
 riak/multidict.py
 riak/node.py
 riak/resolver.py
+riak/riak_error.py
 riak/riak_object.py
 riak/security.py
+riak/table.py
 riak/test_server.py
+riak/ts_object.py
+riak/tz.py
 riak/util.py
 riak.egg-info/PKG-INFO
 riak.egg-info/SOURCES.txt
@@ -38,9 +42,14 @@
 riak.egg-info/zip-safe
 riak/client/__init__.py
 riak/client/index_page.py
-riak/client/multiget.py
+riak/client/multi.py
 riak/client/operations.py
 riak/client/transport.py
+riak/codecs/__init__.py
+riak/codecs/http.py
+riak/codecs/pbuf.py
+riak/codecs/ttb.py
+riak/codecs/util.py
 riak/datatypes/__init__.py
 riak/datatypes/counter.py
 riak/datatypes/datatype.py
@@ -49,18 +58,30 @@
 riak/datatypes/map.py
 riak/datatypes/register.py
 riak/datatypes/set.py
+riak/datatypes/types.py
 riak/erl_src/riak_kv_test_backend.beam
 riak/erl_src/riak_kv_test_backend.erl
 riak/erl_src/riak_search_test_backend.beam
 riak/erl_src/riak_search_test_backend.erl
+riak/pb/__init__.py
+riak/pb/messages.py
+riak/pb/riak_dt_pb2.py
+riak/pb/riak_kv_pb2.py
+riak/pb/riak_pb2.py
+riak/pb/riak_search_pb2.py
+riak/pb/riak_ts_pb2.py
+riak/pb/riak_yokozuna_pb2.py
 riak/tests/__init__.py
+riak/tests/base.py
+riak/tests/comparison.py
 riak/tests/pool-grinder.py
 riak/tests/suite.py
 riak/tests/test_2i.py
-riak/tests/test_all.py
 riak/tests/test_btypes.py
+riak/tests/test_client.py
 riak/tests/test_comparison.py
 riak/tests/test_datatypes.py
+riak/tests/test_datetime.py
 riak/tests/test_feature_detection.py
 riak/tests/test_filters.py
 riak/tests/test_kv.py
@@ -69,21 +90,23 @@
 riak/tests/test_search.py
 riak/tests/test_security.py
 riak/tests/test_server_test.py
+riak/tests/test_timeseries_pbuf.py
+riak/tests/test_timeseries_ttb.py
+riak/tests/test_util.py
 riak/tests/test_yokozuna.py
+riak/tests/yz_setup.py
 riak/transports/__init__.py
 riak/transports/feature_detect.py
 riak/transports/pool.py
 riak/transports/security.py
 riak/transports/transport.py
 riak/transports/http/__init__.py
-riak/transports/http/codec.py
 riak/transports/http/connection.py
 riak/transports/http/resources.py
 riak/transports/http/search.py
 riak/transports/http/stream.py
 riak/transports/http/transport.py
-riak/transports/pbc/__init__.py
-riak/transports/pbc/codec.py
-riak/transports/pbc/connection.py
-riak/transports/pbc/stream.py
-riak/transports/pbc/transport.py
\ No newline at end of file
+riak/transports/tcp/__init__.py
+riak/transports/tcp/connection.py
+riak/transports/tcp/stream.py
+riak/transports/tcp/transport.py
\ No newline at end of file

riak-2.1.0.tar.gz/riak.egg-info/requires.txt -> riak-2.5.4.tar.gz/riak.egg-info/requires.txt Changed

riak-2.1.0.tar.gz/riak/__init__.py -> riak-2.5.4.tar.gz/riak/__init__.py Changed

@@ -1,66 +1,23 @@
 """
-Copyright 2010 Rusty Klophaus <rusty@basho.com>
-Copyright 2010 Justin Sheehy <justin@basho.com>
-Copyright 2009 Jay Baird <jay@mochimedia.com>
-
-This file is provided to you under the Apache License,
-Version 2.0 (the "License"); you may not use this file
-except in compliance with the License.  You may obtain
-a copy of the License at
-
-  http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing,
-software distributed under the License is distributed on an
-"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-KIND, either express or implied.  See the License for the
-specific language governing permissions and limitations
-under the License.
----
 The Riak API for Python allows you to connect to a Riak instance,
 create, modify, and delete Riak objects, add and remove links from
 Riak objects, run Javascript (and Erlang) based Map/Reduce
 operations, and run Linkwalking operations.
-
-See the unit_tests.py file for example usage.
-
-@author Rusty Klophaus (@rklophaus) (rusty@basho.com)
-@author Andy Gross (@argv0) (andy@basho.com)
-@author Jon Meredith (@jmeredith) (jmeredith@basho.com)
-@author Jay Baird (@skatterbean) (jay@mochimedia.com)
 """
 
-__all__ = ['RiakBucket', 'BucketType', 'RiakNode', 'RiakObject', 'RiakClient',
-           'RiakMapReduce', 'RiakKeyFilter', 'RiakLink', 'RiakError',
-           'ConflictError', 'ONE', 'ALL', 'QUORUM', 'key_filter']
-
-
-class RiakError(Exception):
-    """
-    Base class for exceptions generated in the Riak API.
-    """
-    def __init__(self, value):
-        self.value = value
-
-    def __str__(self):
-        return repr(self.value)
-
-
-class ConflictError(RiakError):
-    """
-    Raised when an operation is attempted on a
-    :class:`~riak.riak_object.RiakObject` that has more than one
-    sibling.
-    """
-    def __init__(self, message="Object in conflict"):
-        super(ConflictError, self).__init__(message)
+from riak.riak_error import RiakError, ConflictError
+from riak.client import RiakClient
+from riak.bucket import RiakBucket, BucketType
+from riak.table import Table
+from riak.node import RiakNode
+from riak.riak_object import RiakObject
+from riak.mapreduce import RiakKeyFilter, RiakMapReduce, RiakLink
 
 
-from client import RiakClient
-from bucket import RiakBucket, BucketType
-from node import RiakNode
-from riak_object import RiakObject
-from mapreduce import RiakKeyFilter, RiakMapReduce, RiakLink
+__all__ = ['RiakBucket', 'Table', 'BucketType', 'RiakNode',
+           'RiakObject', 'RiakClient', 'RiakMapReduce', 'RiakKeyFilter',
+           'RiakLink', 'RiakError', 'ConflictError',
+           'ONE', 'ALL', 'QUORUM', 'key_filter']
 
 ONE = "one"
 ALL = "all"

riak-2.1.0.tar.gz/riak/benchmark.py -> riak-2.5.4.tar.gz/riak/benchmark.py Changed

@@ -1,23 +1,9 @@
-"""
-Copyright 2013 Basho Technologies, Inc.
-
-This file is provided to you under the Apache License,
-Version 2.0 (the "License"); you may not use this file
-except in compliance with the License.  You may obtain
-a copy of the License at
-
-http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing,
-software distributed under the License is distributed on an
-"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-KIND, either express or implied.  See the License for the
-specific language governing permissions and limitations
-under the License.
-"""
+from __future__ import print_function
 
 import os
 import gc
+import sys
+import traceback
 
 __all__ = ['measure', 'measure_with_rehearsal']
 
@@ -104,13 +90,17 @@
         else:
             if self.rehearse:
                 gc.collect()
-                print ("-" * 59)
-                print
+                print("-" * 59)
+                print()
             print_header()
 
         self.count -= 1
         return self
 
+    def __next__(self):
+        # Python 3.x Version
+        return self.next()
+
     def report(self, name):
         """
         Returns a report for the current step of the benchmark.
@@ -124,22 +114,25 @@
     Prints the header for the rehearsal phase of a benchmark.
     """
     print
-    print "Rehearsal -------------------------------------------------"
+    print("Rehearsal -------------------------------------------------")
 
 
 def print_report(label, user, system, real):
     """
     Prints the report of one step of a benchmark.
     """
-    print "{:<12s} {:12f} {:12f} ( {:12f} )".format(label, user, system, real)
+    print("{:<12s} {:12f} {:12f} ( {:12f} )".format(label,
+                                                    user,
+                                                    system,
+                                                    real))
 
 
 def print_header():
     """
     Prints the header for the normal phase of a benchmark.
     """
-    print "{:<12s} {:<12s} {:<12s} ( {:<12s} )"\
-        .format('', 'user', 'system', 'real')
+    print("{:<12s} {:<12s} {:<12s} ( {:<12s} )"
+          .format('', 'user', 'system', 'real'))
 
 
 class BenchmarkReport(object):
@@ -164,5 +157,7 @@
         elif exc_type is KeyboardInterrupt:
             return False
         else:
-            print "EXCEPTION! %r" % ((exc_type, exc_val, exc_tb),)
-        return True
+            msg = "EXCEPTION! type: %r val: %r" % (exc_type, exc_val)
+            print(msg, file=sys.stderr)
+            traceback.print_tb(exc_tb)
+        return True if exc_type is None else False

riak-2.1.0.tar.gz/riak/bucket.py -> riak-2.5.4.tar.gz/riak/bucket.py Changed

@@ -17,8 +17,10 @@
 specific language governing permissions and limitations
 under the License.
 """
+from six import string_types, PY2
 import mimetypes
 from riak.util import lazy_property
+from riak.datatypes import TYPES
 
 
 def bucket_property(name, doc=None):
@@ -50,13 +52,15 @@
         :param bucket_type: The parent bucket type of this bucket
         :type bucket_type: :class:`BucketType`
         """
-        try:
-            if isinstance(name, basestring):
+
+        if not isinstance(name, string_types):
+            raise TypeError('Bucket name must be a string')
+
+        if PY2:
+            try:
                 name = name.encode('ascii')
-            else:
-                raise TypeError('Bucket name must be a string')
-        except UnicodeError:
-            raise TypeError('Unicode bucket names are not supported.')
+            except UnicodeError:
+                raise TypeError('Unicode bucket names are not supported.')
 
         if not isinstance(bucket_type, BucketType):
             raise TypeError('Parent bucket type must be a BucketType instance')
@@ -170,14 +174,16 @@
                 :class:`~riak.datatypes.Datatype`
 
         """
+        from riak import RiakObject
         if self.bucket_type.datatype:
             return TYPES[self.bucket_type.datatype](bucket=self, key=key)
 
-        try:
-            if isinstance(data, basestring):
-                data = data.encode('ascii')
-        except UnicodeError:
-            raise TypeError('Unicode data values are not supported.')
+        if PY2:
+            try:
+                if isinstance(data, string_types):
+                    data = data.encode('ascii')
+            except UnicodeError:
+                raise TypeError('Unicode data values are not supported.')
 
         obj = RiakObject(self._client, self, key)
         obj.content_type = content_type
@@ -190,7 +196,7 @@
     def get(self, key, r=None, pr=None, timeout=None, include_context=None,
             basic_quorum=None, notfound_ok=None):
         """
-        Retrieve an :class:`~riak.riak_object.RiakObject` or
+        Retrieve a :class:`~riak.riak_object.RiakObject` or
         :class:`~riak.datatypes.Datatype`, based on the presence and value
         of the :attr:`datatype <BucketType.datatype>` bucket property.
 
@@ -214,6 +220,7 @@
            :class:`~riak.datatypes.Datatype`
 
         """
+        from riak import RiakObject
         if self.bucket_type.datatype:
             return self._client.fetch_datatype(self, key, r=r, pr=pr,
                                                timeout=timeout,
@@ -403,7 +410,9 @@
         :type filename: string
         :rtype: :class:`RiakObject <riak.riak_object.RiakObject>`
         """
-        binary_data = open(filename, "rb").read()
+        binary_data = None
+        with open(filename, 'rb') as f:
+            binary_data = f.read()
         mimetype, encoding = mimetypes.guess_type(filename)
         if encoding:
             binary_data = bytearray(binary_data, encoding)
@@ -411,7 +420,12 @@
             binary_data = bytearray(binary_data)
         if not mimetype:
             mimetype = 'application/octet-stream'
-        return self.new(key, encoded_data=binary_data, content_type=mimetype)
+        if PY2:
+            return self.new(key, encoded_data=binary_data,
+                            content_type=mimetype)
+        else:
+            return self.new(key, encoded_data=bytes(binary_data),
+                            content_type=mimetype)
 
     def search_enabled(self):
         """
@@ -574,6 +588,16 @@
 
     increment_counter = update_counter
 
+    def get_preflist(self, key):
+        """
+        Retrieve the preflist associated with a given bucket/key
+
+        :param key: Name of the key.
+        :type key: string
+        :rtype: list of dict()
+        """
+        return self._client.get_preflist(self, key)
+
     def __str__(self):
         if self.bucket_type.is_default():
             return '<RiakBucket {0!r}>'.format(self.name)
@@ -728,7 +752,3 @@
             return hash(self) != hash(other)
         else:
             return True
-
-
-from riak_object import RiakObject
-from riak.datatypes import TYPES

riak-2.1.0.tar.gz/riak/client/__init__.py -> riak-2.5.4.tar.gz/riak/client/__init__.py Changed

@@ -1,48 +1,61 @@
-"""
-Copyright 2011 Basho Technologies, Inc.
-Copyright 2010 Rusty Klophaus <rusty@basho.com>
-Copyright 2010 Justin Sheehy <justin@basho.com>
-Copyright 2009 Jay Baird <jay@mochimedia.com>
-
-This file is provided to you under the Apache License,
-Version 2.0 (the "License"); you may not use this file
-except in compliance with the License.  You may obtain
-a copy of the License at
-
-  http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing,
-software distributed under the License is distributed on an
-"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-KIND, either express or implied.  See the License for the
-specific language governing permissions and limitations
-under the License.
-"""
-
 try:
     import simplejson as json
 except ImportError:
     import json
 
 import random
+
 from weakref import WeakValueDictionary
 from riak.client.operations import RiakClientOperations
 from riak.node import RiakNode
 from riak.bucket import RiakBucket, BucketType
 from riak.mapreduce import RiakMapReduceChain
 from riak.resolver import default_resolver
-from riak.transports.http import RiakHttpPool
-from riak.transports.pbc import RiakPbcPool
+from riak.table import Table
+from riak.transports.http import HttpPool
+from riak.transports.tcp import TcpPool
 from riak.security import SecurityCreds
-from riak.util import lazy_property
+from riak.util import lazy_property, bytes_to_str, str_to_bytes
+from six import string_types, PY2
+from riak.client.multi import MultiGetPool, MultiPutPool
 
 
 def default_encoder(obj):
     """
     Default encoder for JSON datatypes, which returns UTF-8 encoded
-    json instead of the default bloated \uXXXX escaped ASCII strings.
+    json instead of the default bloated backslash u XXXX escaped ASCII strings.
     """
-    return json.dumps(obj, ensure_ascii=False).encode("utf-8")
+    if isinstance(obj, bytes):
+        return json.dumps(bytes_to_str(obj),
+                          ensure_ascii=False).encode("utf-8")
+    else:
+        return json.dumps(obj, ensure_ascii=False).encode("utf-8")
+
+
+def binary_json_encoder(obj):
+    """
+    Default encoder for JSON datatypes, which returns UTF-8 encoded
+    json instead of the default bloated backslash u XXXX escaped ASCII strings.
+    """
+    if isinstance(obj, bytes):
+        return json.dumps(bytes_to_str(obj),
+                          ensure_ascii=False).encode("utf-8")
+    else:
+        return json.dumps(obj, ensure_ascii=False).encode("utf-8")
+
+
+def binary_json_decoder(obj):
+    """
+    Default decoder from JSON datatypes.
+    """
+    return json.loads(bytes_to_str(obj))
+
+
+def binary_encoder_decoder(obj):
+    """
+    Assumes value is already in binary format, so passes unchanged.
+    """
+    return obj
 
 
 class RiakClient(RiakMapReduceChain, RiakClientOperations):
@@ -55,8 +68,10 @@
     #: The supported protocols
     PROTOCOLS = ['http', 'pbc']
 
-    def __init__(self, protocol='pbc', transport_options={}, nodes=None,
-                 credentials=None, multiget_pool_size=None, **unused_args):
+    def __init__(self, protocol='pbc', transport_options={},
+                 nodes=None, credentials=None,
+                 multiget_pool_size=None, multiput_pool_size=None,
+                 **kwargs):
         """
         Construct a new ``RiakClient`` object.
 
@@ -75,29 +90,45 @@
            :meth:`multiget` operations. Defaults to a factor of the number of
            CPUs in the system
         :type multiget_pool_size: int
+        :param multiput_pool_size: the number of threads to use in
+           :meth:`multiput` operations. Defaults to a factor of the number of
+           CPUs in the system
+        :type multiput_pool_size: int
         """
-        unused_args = unused_args.copy()
+        kwargs = kwargs.copy()
 
         if nodes is None:
-            self.nodes = [self._create_node(unused_args), ]
+            self.nodes = [self._create_node(kwargs), ]
         else:
             self.nodes = [self._create_node(n) for n in nodes]
 
         self._multiget_pool_size = multiget_pool_size
+        self._multiput_pool_size = multiput_pool_size
         self.protocol = protocol or 'pbc'
         self._resolver = None
         self._credentials = self._create_credentials(credentials)
-        self._http_pool = RiakHttpPool(self, **transport_options)
-        self._pb_pool = RiakPbcPool(self, **transport_options)
-
-        self._encoders = {'application/json': default_encoder,
-                          'text/json': default_encoder,
-                          'text/plain': str}
-        self._decoders = {'application/json': json.loads,
-                          'text/json': json.loads,
-                          'text/plain': str}
+        self._http_pool = HttpPool(self, **transport_options)
+        self._tcp_pool = TcpPool(self, **transport_options)
+
+        if PY2:
+            self._encoders = {'application/json': default_encoder,
+                              'text/json': default_encoder,
+                              'text/plain': str}
+            self._decoders = {'application/json': json.loads,
+                              'text/json': json.loads,
+                              'text/plain': str}
+        else:
+            self._encoders = {'application/json': binary_json_encoder,
+                              'text/json': binary_json_encoder,
+                              'text/plain': str_to_bytes,
+                              'binary/octet-stream': binary_encoder_decoder}
+            self._decoders = {'application/json': binary_json_decoder,
+                              'text/json': binary_json_decoder,
+                              'text/plain': bytes_to_str,
+                              'binary/octet-stream': binary_encoder_decoder}
         self._buckets = WeakValueDictionary()
         self._bucket_types = WeakValueDictionary()
+        self._tables = WeakValueDictionary()
 
     def _get_protocol(self):
         return self._protocol
@@ -144,7 +175,7 @@
     def _set_client_id(self, client_id):
         for http in self._http_pool:
             http.client_id = client_id
-        for pb in self._pb_pool:
+        for pb in self._tcp_pool:
             pb.client_id = client_id
 
     client_id = property(_get_client_id, _set_client_id,
@@ -167,7 +198,7 @@
         :param content_type: the requested media type
         :type content_type: str
         :param encoder: an encoding function, takes a single object
-            argument and returns a string
+            argument and returns encoded data
         :type encoder: function
         """
         self._encoders[content_type] = encoder
@@ -188,7 +219,7 @@
 
         :param content_type: the requested media type
         :type content_type: str
-        :param decoder: a decoding function, takes a string and
+        :param decoder: a decoding function, takes encoded data and
             returns a Python type
         :type decoder: function
         """
@@ -217,21 +248,17 @@
         :rtype: :class:`RiakBucket <riak.bucket.RiakBucket>`
 
         """
-        if not isinstance(name, basestring):
+        if not isinstance(name, string_types):
             raise TypeError('Bucket name must be a string')
 
-        if isinstance(bucket_type, basestring):
+        if isinstance(bucket_type, string_types):
             bucket_type = self.bucket_type(bucket_type)
         elif not isinstance(bucket_type, BucketType):
             raise TypeError('bucket_type must be a string '
                             'or riak.bucket.BucketType')

riak-2.5.4.tar.gz/riak/client/multi.py Added

@@ -0,0 +1,281 @@
+from __future__ import print_function
+from collections import namedtuple
+from threading import Thread, Lock, Event
+from multiprocessing import cpu_count
+from six import PY2
+
+from riak.riak_object import RiakObject
+from riak.ts_object import TsObject
+
+if PY2:
+    from Queue import Queue
+else:
+    from queue import Queue
+
+__all__ = ['multiget', 'multiput', 'MultiGetPool', 'MultiPutPool']
+
+
+try:
+    #: The default size of the worker pool, either based on the number
+    #: of CPUS or defaulting to 6
+    POOL_SIZE = cpu_count()
+except NotImplementedError:
+    # Make an educated guess
+    POOL_SIZE = 6
+
+#: A :class:`namedtuple` for tasks that are fed to workers in the
+#: multi get pool.
+Task = namedtuple('Task',
+                  ['client', 'outq', 'bucket_type', 'bucket', 'key',
+                   'object', 'options'])
+
+
+#: A :class:`namedtuple` for tasks that are fed to workers in the
+#: multi put pool.
+PutTask = namedtuple('PutTask',
+                     ['client', 'outq', 'object', 'options'])
+
+
+class MultiPool(object):
+    """
+    Encapsulates a pool of threads. These threads can be used
+    across many multi requests.
+    """
+
+    def __init__(self, size=POOL_SIZE, name='unknown'):
+        """
+        :param size: the desired size of the worker pool
+        :type size: int
+        """
+
+        self._inq = Queue()
+        self._size = size
+        self._name = name
+        self._started = Event()
+        self._stop = Event()
+        self._lock = Lock()
+        self._workers = []
+
+    def enq(self, task):
+        """
+        Enqueues a fetch task to the pool of workers. This will raise
+        a RuntimeError if the pool is stopped or in the process of
+        stopping.
+
+        :param task: the Task object
+        :type task: Task or PutTask
+        """
+        if not self._stop.is_set():
+            self._inq.put(task)
+        else:
+            raise RuntimeError("Attempted to enqueue an operation while "
+                               "multi pool was shutdown!")
+
+    def start(self):
+        """
+        Starts the worker threads if they are not already started.
+        This method is thread-safe and will be called automatically
+        when executing an operation.
+        """
+        # Check whether we are already started, skip if we are.
+        if not self._started.is_set():
+            # If we are not started, try to capture the lock.
+            if self._lock.acquire(False):
+                # If we got the lock, go ahead and start the worker
+                # threads, set the started flag, and release the lock.
+                for i in range(self._size):
+                    name = "riak.client.multi-worker-{0}-{1}".format(
+                            self._name, i)
+                    worker = Thread(target=self._worker_method, name=name)
+                    worker.daemon = True
+                    worker.start()
+                    self._workers.append(worker)
+                self._started.set()
+                self._lock.release()
+            else:
+                # We didn't get the lock, so someone else is already
+                # starting the worker threads. Wait until they have
+                # signaled that the threads are started.
+                self._started.wait()
+
+    def stop(self):
+        """
+        Signals the worker threads to exit and waits on them.
+        """
+        self._stop.set()
+        for worker in self._workers:
+            worker.join()
+
+    def stopped(self):
+        """
+        Detects whether this pool has been stopped.
+        """
+        return self._stop.is_set()
+
+    def __del__(self):
+        # Ensure that all work in the queue is processed before
+        # shutting down.
+        self.stop()
+
+    def _worker_method(self):
+        raise NotImplementedError
+
+    def _should_quit(self):
+        """
+        Worker threads should exit when the stop flag is set and the
+        input queue is empty. Once the stop flag is set, new enqueues
+        are disallowed, meaning that the workers can safely drain the
+        queue before exiting.
+
+        :rtype: bool
+        """
+        return self.stopped() and self._inq.empty()
+
+
+class MultiGetPool(MultiPool):
+    def __init__(self, size=POOL_SIZE):
+        super(MultiGetPool, self).__init__(size=size, name='get')
+
+    def _worker_method(self):
+        """
+        The body of the multi-get worker. Loops until
+        :meth:`_should_quit` returns ``True``, taking tasks off the
+        input queue, fetching the object, and putting them on the
+        output queue.
+        """
+        while not self._should_quit():
+            task = self._inq.get()
+            try:
+                btype = task.client.bucket_type(task.bucket_type)
+                obj = btype.bucket(task.bucket).get(task.key, **task.options)
+                task.outq.put(obj)
+            except KeyboardInterrupt:
+                raise
+            except Exception as err:
+                errdata = (task.bucket_type, task.bucket, task.key, err)
+                task.outq.put(errdata)
+            finally:
+                self._inq.task_done()
+
+
+class MultiPutPool(MultiPool):
+    def __init__(self, size=POOL_SIZE):
+        super(MultiPutPool, self).__init__(size=size, name='put')
+
+    def _worker_method(self):
+        """
+        The body of the multi-put worker. Loops until
+        :meth:`_should_quit` returns ``True``, taking tasks off the
+        input queue, storing the object, and putting the result on
+        the output queue.
+        """
+        while not self._should_quit():
+            task = self._inq.get()
+            try:
+                obj = task.object
+                if isinstance(obj, RiakObject):
+                    rv = task.client.put(obj, **task.options)
+                elif isinstance(obj, TsObject):
+                    rv = task.client.ts_put(obj, **task.options)
+                else:
+                    raise ValueError('unknown obj type: %s'.format(type(obj)))
+                task.outq.put(rv)
+            except KeyboardInterrupt:
+                raise
+            except Exception as err:
+                errdata = (task.object, err)
+                task.outq.put(errdata)
+            finally:
+                self._inq.task_done()
+
+
+RIAK_MULTIGET_POOL = MultiGetPool()
+RIAK_MULTIPUT_POOL = MultiPutPool()
+
+
+def multiget(client, keys, **options):
+    """Executes a parallel-fetch across multiple threads. Returns a list
+    containing :class:`~riak.riak_object.RiakObject` or
+    :class:`~riak.datatypes.Datatype` instances, or 4-tuples of

riak-2.1.0.tar.gz/riak/client/operations.py -> riak-2.5.4.tar.gz/riak/client/operations.py Changed

@@ -1,25 +1,12 @@
-"""
-Copyright 2012 Basho Technologies, Inc.
-
-This file is provided to you under the Apache License,
-Version 2.0 (the "License"); you may not use this file
-except in compliance with the License.  You may obtain
-a copy of the License at
-
-http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing,
-software distributed under the License is distributed on an
-"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-KIND, either express or implied.  See the License for the
-specific language governing permissions and limitations
-under the License.
-"""
-
-from transport import RiakClientTransport, retryable, retryableHttpOnly
-from multiget import multiget
-from index_page import IndexPage
+import riak.client.multi
+
+from riak.client.transport import RiakClientTransport, \
+    retryable, retryableHttpOnly
+from riak.client.index_page import IndexPage
 from riak.datatypes import TYPES
+from riak.table import Table
+from riak.util import bytes_to_str
+from six import string_types, PY2
 
 
 class RiakClientOperations(RiakClientTransport):
@@ -55,11 +42,11 @@
         """
         _validate_timeout(timeout)
         if bucket_type:
-            bucketfn = lambda name: bucket_type.bucket(name)
+            bucketfn = self._bucket_type_bucket_builder
         else:
-            bucketfn = lambda name: self.bucket(name)
+            bucketfn = self._default_type_bucket_builder
 
-        return [bucketfn(name) for name in
+        return [bucketfn(bytes_to_str(name), bucket_type) for name in
                 transport.get_buckets(bucket_type=bucket_type,
                                       timeout=timeout)]
 
@@ -100,9 +87,9 @@
         """
         _validate_timeout(timeout)
         if bucket_type:
-            bucketfn = lambda name: bucket_type.bucket(name)
+            bucketfn = self._bucket_type_bucket_builder
         else:
-            bucketfn = lambda name: self.bucket(name)
+            bucketfn = self._default_type_bucket_builder
 
         resource = self._acquire()
         transport = resource.object
@@ -111,7 +98,8 @@
         stream.attach(resource)
         try:
             for bucket_list in stream:
-                bucket_list = [bucketfn(name) for name in bucket_list]
+                bucket_list = [bucketfn(bytes_to_str(name), bucket_type)
+                               for name in bucket_list]
                 if len(bucket_list) > 0:
                     yield bucket_list
         finally:
@@ -507,7 +495,10 @@
         try:
             for keylist in stream:
                 if len(keylist) > 0:
-                    yield keylist
+                    if PY2:
+                        yield keylist
+                    else:
+                        yield [bytes_to_str(item) for item in keylist]
         finally:
             stream.close()
 
@@ -547,6 +538,146 @@
                              timeout=timeout)
 
     @retryable
+    def ts_describe(self, transport, table):
+        """
+        ts_describe(table)
+
+        Retrieve a time series table description from the Riak cluster.
+
+        .. note:: This request is automatically retried :attr:`retries`
+           times if it fails due to network error.
+
+        :param table: The timeseries table.
+        :type table: string or :class:`Table <riak.table.Table>`
+        :rtype: :class:`TsObject <riak.ts_object.TsObject>`
+        """
+        t = table
+        if isinstance(t, string_types):
+            t = Table(self, table)
+        return transport.ts_describe(t)
+
+    @retryable
+    def ts_get(self, transport, table, key):
+        """
+        ts_get(table, key)
+
+        Retrieve timeseries value by key
+
+        .. note:: This request is automatically retried :attr:`retries`
+           times if it fails due to network error.
+
+        :param table: The timeseries table.
+        :type table: string or :class:`Table <riak.table.Table>`
+        :param key: The timeseries value's key.
+        :type key: list
+        :rtype: :class:`TsObject <riak.ts_object.TsObject>`
+        """
+        t = table
+        if isinstance(t, string_types):
+            t = Table(self, table)
+        return transport.ts_get(t, key)
+
+    @retryable
+    def ts_put(self, transport, tsobj):
+        """
+        ts_put(tsobj)
+
+        Stores time series data in the Riak cluster.
+
+        .. note:: This request is automatically retried :attr:`retries`
+           times if it fails due to network error.
+
+        :param tsobj: the time series object to store
+        :type tsobj: RiakTsObject
+        :rtype: boolean
+        """
+        return transport.ts_put(tsobj)
+
+    @retryable
+    def ts_delete(self, transport, table, key):
+        """
+        ts_delete(table, key)
+
+        Delete timeseries value by key
+
+        .. note:: This request is automatically retried :attr:`retries`
+           times if it fails due to network error.
+
+        :param table: The timeseries table.
+        :type table: string or :class:`Table <riak.table.Table>`
+        :param key: The timeseries value's key.
+        :type key: list or dict
+        :rtype: boolean
+        """
+        t = table
+        if isinstance(t, string_types):
+            t = Table(self, table)
+        return transport.ts_delete(t, key)
+
+    @retryable
+    def ts_query(self, transport, table, query, interpolations=None):
+        """
+        ts_query(table, query, interpolations=None)
+
+        Queries time series data in the Riak cluster.
+
+        .. note:: This request is automatically retried :attr:`retries`
+           times if it fails due to network error.
+
+        :param table: The timeseries table.
+        :type table: string or :class:`Table <riak.table.Table>`
+        :param query: The timeseries query.
+        :type query: string
+        :rtype: :class:`TsObject <riak.ts_object.TsObject>`
+        """
+        t = table
+        if isinstance(t, string_types):
+            t = Table(self, table)
+        return transport.ts_query(t, query, interpolations)
+
+    def ts_stream_keys(self, table, timeout=None):
+        """
+        Lists all keys in a time series table via a stream. This is a
+        generator method which should be iterated over.
+
+        The caller should explicitly close the returned iterator,
+        either using :func:`contextlib.closing` or calling ``close()``
+        explicitly. Consuming the entire iterator will also close the
+        stream. If it does not, the associated connection might
+        not be returned to the pool. Example::
+
+            from contextlib import closing
+
+            # Using contextlib.closing
+            with closing(client.ts_stream_keys(mytable)) as keys:
+                for key_list in keys:

riak-2.1.0.tar.gz/riak/client/transport.py -> riak-2.5.4.tar.gz/riak/client/transport.py Changed

@@ -1,26 +1,13 @@
-"""
-Copyright 2012 Basho Technologies, Inc.
-
-This file is provided to you under the Apache License,
-Version 2.0 (the "License"); you may not use this file
-except in compliance with the License.  You may obtain
-a copy of the License at
-
-http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing,
-software distributed under the License is distributed on an
-"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-KIND, either express or implied.  See the License for the
-specific language governing permissions and limitations
-under the License.
-"""
 from contextlib import contextmanager
 from riak.transports.pool import BadResource
-from riak.transports.pbc import is_retryable as is_pbc_retryable
+from riak.transports.tcp import is_retryable as is_tcp_retryable
 from riak.transports.http import is_retryable as is_http_retryable
 import threading
-import httplib
+from six import PY2
+if PY2:
+    from httplib import HTTPException
+else:
+    from http.client import HTTPException
 
 #: The default (global) number of times to retry requests that are
 #: retryable. This can be modified locally, per-thread, via the
@@ -45,7 +32,7 @@
     # These will be set or redefined by the RiakClient initializer
     protocol = 'pbc'
     _http_pool = None
-    _pb_pool = None
+    _tcp_pool = None
     _locals = _client_locals()
 
     def _get_retry_count(self):
@@ -132,7 +119,7 @@
                 with pool.transaction(_filter=_skip_bad_nodes) as transport:
                     try:
                         return fn(transport)
-                    except (IOError, httplib.HTTPException) as e:
+                    except (IOError, HTTPException) as e:
                         if _is_retryable(e):
                             transport._node.error_rate.incr(1)
                             skip_nodes.append(transport._node)
@@ -159,8 +146,8 @@
             protocol = self.protocol
         if protocol == 'http':
             pool = self._http_pool
-        elif protocol == 'pbc':
-            pool = self._pb_pool
+        elif protocol == 'tcp' or protocol == 'pbc':
+            pool = self._tcp_pool
         else:
             raise ValueError("invalid protocol %s" % protocol)
         return pool
@@ -175,7 +162,7 @@
     :type error: Exception
     :rtype: boolean
     """
-    return is_pbc_retryable(error) or is_http_retryable(error)
+    return is_tcp_retryable(error) or is_http_retryable(error)
 
 
 def retryable(fn, protocol=None):

riak-2.5.4.tar.gz/riak/codecs Added

riak-2.5.4.tar.gz/riak/codecs/__init__.py Added

@@ -0,0 +1,29 @@
+import collections
+
+import riak.pb.messages
+
+from riak import RiakError
+from riak.codecs.util import parse_pbuf_msg
+from riak.util import bytes_to_str
+
+Msg = collections.namedtuple('Msg',
+                             ['msg_code', 'data', 'resp_code'],
+                             verbose=False)
+
+
+class Codec(object):
+    def parse_msg(self):
+        raise NotImplementedError('parse_msg not implemented')
+
+    def maybe_incorrect_code(self, resp_code, expect=None):
+        if expect and resp_code != expect:
+            raise RiakError("unexpected message code: %d, expected %d"
+                            % (resp_code, expect))
+
+    def maybe_riak_error(self, msg_code, data=None):
+        if msg_code == riak.pb.messages.MSG_CODE_ERROR_RESP:
+            if data is None:
+                raise RiakError('no error provided!')
+            else:
+                err = parse_pbuf_msg(msg_code, data)
+                raise RiakError(bytes_to_str(err.errmsg))

riak-2.5.4.tar.gz/riak/codecs/http.py Added

@@ -0,0 +1,301 @@
+import re
+import csv
+
+from six import PY2, PY3
+from cgi import parse_header
+from email import message_from_string
+from email.utils import parsedate_tz, mktime_tz
+from xml.etree import ElementTree
+from riak import RiakError
+from riak.content import RiakContent
+from riak.riak_object import VClock
+from riak.multidict import MultiDict
+from riak.transports.http.search import XMLSearchResult
+from riak.util import decode_index_value, bytes_to_str
+
+if PY2:
+    from urllib import unquote_plus
+else:
+    from urllib.parse import unquote_plus
+
+
+# subtract length of "Link: " header string and newline
+MAX_LINK_HEADER_SIZE = 8192 - 8
+
+
+class HttpCodec(object):
+    """
+    Methods for HTTP transport that marshals and unmarshals HTTP
+    messages.
+    """
+
+    def _parse_body(self, robj, response, expected_statuses):
+        """
+        Parse the body of an object response and populate the object.
+        """
+        # If no response given, then return.
+        if response is None:
+            return None
+
+        status, headers, data = response
+
+        # Check if the server is down(status==0)
+        if not status:
+            m = 'Could not contact Riak Server: http://{0}:{1}!'.format(
+                self._node.host, self._node.http_port)
+            raise RiakError(m)
+
+        # Make sure expected code came back
+        self.check_http_code(status, expected_statuses)
+
+        if 'x-riak-vclock' in headers:
+            robj.vclock = VClock(headers['x-riak-vclock'], 'base64')
+
+        # If 404(Not Found), then clear the object.
+        if status == 404:
+            robj.siblings = []
+            return None
+        # If 201 Created, we need to extract the location and set the
+        # key on the object.
+        elif status == 201:
+            robj.key = headers['location'].strip().split('/')[-1]
+        # If 300(Siblings), apply the siblings to the object
+        elif status == 300:
+            ctype, params = parse_header(headers['content-type'])
+            if ctype == 'multipart/mixed':
+                if PY3:
+                    data = bytes_to_str(data)
+                boundary = re.compile('\r?\n--%s(?:--)?\r?\n' %
+                                      re.escape(params['boundary']))
+                parts = [message_from_string(p)
+                         for p in re.split(boundary, data)[1:-1]]
+                robj.siblings = [self._parse_sibling(RiakContent(robj),
+                                                     part.items(),
+                                                     part.get_payload())
+                                 for part in parts]
+
+                # Invoke sibling-resolution logic
+                if robj.resolver is not None:
+                    robj.resolver(robj)
+
+                return robj
+            else:
+                raise Exception('unexpected sibling response format: {0}'.
+                                format(ctype))
+
+        robj.siblings = [self._parse_sibling(RiakContent(robj),
+                                             headers.items(),
+                                             data)]
+
+        return robj
+
+    def _parse_sibling(self, sibling, headers, data):
+        """
+        Parses a single sibling out of a response.
+        """
+
+        sibling.exists = True
+
+        # Parse the headers...
+        for header, value in headers:
+            header = header.lower()
+            if header == 'content-type':
+                sibling.content_type, sibling.charset = \
+                    self._parse_content_type(value)
+            elif header == 'etag':
+                sibling.etag = value
+            elif header == 'link':
+                sibling.links = self._parse_links(value)
+            elif header == 'last-modified':
+                sibling.last_modified = mktime_tz(parsedate_tz(value))
+            elif header.startswith('x-riak-meta-'):
+                metakey = header.replace('x-riak-meta-', '')
+                sibling.usermeta[metakey] = value
+            elif header.startswith('x-riak-index-'):
+                field = header.replace('x-riak-index-', '')
+                reader = csv.reader([value], skipinitialspace=True)
+                for line in reader:
+                    for token in line:
+                        token = decode_index_value(field, token)
+                        sibling.add_index(field, token)
+            elif header == 'x-riak-deleted':
+                sibling.exists = False
+
+        sibling.encoded_data = data
+
+        return sibling
+
+    def _to_link_header(self, link):
+        """
+        Convert the link tuple to a link header string. Used internally.
+        """
+        try:
+            bucket, key, tag = link
+        except ValueError:
+            raise RiakError("Invalid link tuple %s" % link)
+        tag = tag if tag is not None else bucket
+        url = self.object_path(bucket, key)
+        header = '<%s>; riaktag="%s"' % (url, tag)
+        return header
+
+    def _parse_links(self, linkHeaders):
+        links = []
+        oldform = "</([^/]+)/([^/]+)/([^/]+)>; ?riaktag=\"([^\"]+)\""
+        newform = "</(buckets)/([^/]+)/keys/([^/]+)>; ?riaktag=\"([^\"]+)\""
+        for linkHeader in linkHeaders.strip().split(','):
+            linkHeader = linkHeader.strip()
+            matches = (re.match(oldform, linkHeader) or
+                       re.match(newform, linkHeader))
+            if matches is not None:
+                link = (unquote_plus(matches.group(2)),
+                        unquote_plus(matches.group(3)),
+                        unquote_plus(matches.group(4)))
+                links.append(link)
+        return links
+
+    def _add_links_for_riak_object(self, robject, headers):
+        links = robject.links
+        if links:
+            current_header = ''
+            for link in links:
+                header = self._to_link_header(link)
+                if len(current_header + header) > MAX_LINK_HEADER_SIZE:
+                    headers.add('Link', current_header)
+                    current_header = ''
+
+                if current_header != '':
+                    header = ', ' + header
+                current_header += header
+
+            headers.add('Link', current_header)
+
+        return headers
+
+    def _build_put_headers(self, robj, if_none_match=False):
+        """Build the headers for a POST/PUT request."""
+
+        # Construct the headers...
+        if robj.charset is not None:
+            content_type = ('%s; charset="%s"' %
+                            (robj.content_type, robj.charset))
+        else:
+            content_type = robj.content_type
+
+        headers = MultiDict({'Content-Type': content_type,
+                             'X-Riak-ClientId': self._client_id})
+
+        # Add the vclock if it exists...
+        if robj.vclock is not None:
+            headers['X-Riak-Vclock'] = robj.vclock.encode('base64')
+
+        # Create the header from metadata
+        self._add_links_for_riak_object(robj, headers)
+
+        for key in robj.usermeta.keys():
+            headers['X-Riak-Meta-%s' % key] = robj.usermeta[key]
+
+        for field, value in robj.indexes:
+            key = 'X-Riak-Index-%s' % field
+            if key in headers:

riak-2.5.4.tar.gz/riak/codecs/pbuf.py Added

@@ -0,0 +1,1236 @@
+import datetime
+import six
+
+import riak.pb.messages
+import riak.pb.riak_pb2
+import riak.pb.riak_dt_pb2
+import riak.pb.riak_kv_pb2
+import riak.pb.riak_ts_pb2
+
+from riak import RiakError
+from riak.codecs import Codec, Msg
+from riak.codecs.util import parse_pbuf_msg
+from riak.content import RiakContent
+from riak.pb.riak_ts_pb2 import TsColumnType
+from riak.riak_object import VClock
+from riak.ts_object import TsColumns
+from riak.util import decode_index_value, str_to_bytes, bytes_to_str, \
+    unix_time_millis, datetime_from_unix_time_millis
+from riak.multidict import MultiDict
+
+
+def _invert(d):
+    out = {}
+    for key in d:
+        value = d[key]
+        out[value] = key
+    return out
+
+REPL_TO_PY = {
+    riak.pb.riak_pb2.RpbBucketProps.FALSE: False,
+    riak.pb.riak_pb2.RpbBucketProps.TRUE: True,
+    riak.pb.riak_pb2.RpbBucketProps.REALTIME: 'realtime',
+    riak.pb.riak_pb2.RpbBucketProps.FULLSYNC: 'fullsync'
+}
+
+REPL_TO_PB = _invert(REPL_TO_PY)
+
+RIAKC_RW_ONE = 4294967294
+RIAKC_RW_QUORUM = 4294967293
+RIAKC_RW_ALL = 4294967292
+RIAKC_RW_DEFAULT = 4294967291
+
+QUORUM_TO_PB = {'default': RIAKC_RW_DEFAULT,
+                'all': RIAKC_RW_ALL,
+                'quorum': RIAKC_RW_QUORUM,
+                'one': RIAKC_RW_ONE}
+
+QUORUM_TO_PY = _invert(QUORUM_TO_PB)
+
+NORMAL_PROPS = ['n_val', 'allow_mult', 'last_write_wins', 'old_vclock',
+                'young_vclock', 'big_vclock', 'small_vclock', 'basic_quorum',
+                'notfound_ok', 'search', 'backend', 'search_index', 'datatype',
+                'write_once']
+COMMIT_HOOK_PROPS = ['precommit', 'postcommit']
+MODFUN_PROPS = ['chash_keyfun', 'linkfun']
+QUORUM_PROPS = ['r', 'pr', 'w', 'pw', 'dw', 'rw']
+
+MAP_FIELD_TYPES = {
+    riak.pb.riak_dt_pb2.MapField.COUNTER: 'counter',
+    riak.pb.riak_dt_pb2.MapField.SET: 'set',
+    riak.pb.riak_dt_pb2.MapField.REGISTER: 'register',
+    riak.pb.riak_dt_pb2.MapField.FLAG: 'flag',
+    riak.pb.riak_dt_pb2.MapField.MAP: 'map',
+    'counter': riak.pb.riak_dt_pb2.MapField.COUNTER,
+    'set': riak.pb.riak_dt_pb2.MapField.SET,
+    'register': riak.pb.riak_dt_pb2.MapField.REGISTER,
+    'flag': riak.pb.riak_dt_pb2.MapField.FLAG,
+    'map': riak.pb.riak_dt_pb2.MapField.MAP
+}
+
+DT_FETCH_TYPES = {
+    riak.pb.riak_dt_pb2.DtFetchResp.COUNTER: 'counter',
+    riak.pb.riak_dt_pb2.DtFetchResp.SET: 'set',
+    riak.pb.riak_dt_pb2.DtFetchResp.MAP: 'map'
+}
+
+
+class PbufCodec(Codec):
+    '''
+    Protobuffs Encoding and decoding methods for TcpTransport.
+    '''
+
+    def __init__(self,
+                 client_timeouts=False, quorum_controls=False,
+                 tombstone_vclocks=False, bucket_types=False):
+        if riak.pb is None:
+            raise NotImplementedError("this codec is not available")
+        self._client_timeouts = client_timeouts
+        self._quorum_controls = quorum_controls
+        self._tombstone_vclocks = tombstone_vclocks
+        self._bucket_types = bucket_types
+
+    def parse_msg(self, msg_code, data):
+        return parse_pbuf_msg(msg_code, data)
+
+    def encode_auth(self, username, password):
+        req = riak.pb.riak_pb2.RpbAuthReq()
+        req.user = str_to_bytes(username)
+        req.password = str_to_bytes(password)
+        mc = riak.pb.messages.MSG_CODE_AUTH_REQ
+        rc = riak.pb.messages.MSG_CODE_AUTH_RESP
+        return Msg(mc, req.SerializeToString(), rc)
+
+    def encode_ping(self):
+        return Msg(riak.pb.messages.MSG_CODE_PING_REQ, None,
+                   riak.pb.messages.MSG_CODE_PING_RESP)
+
+    def encode_quorum(self, rw):
+        """
+        Converts a symbolic quorum value into its on-the-wire
+        equivalent.
+
+        :param rw: the quorum
+        :type rw: string, integer
+        :rtype: integer
+        """
+        if rw in QUORUM_TO_PB:
+            return QUORUM_TO_PB[rw]
+        elif type(rw) is int and rw >= 0:
+            return rw
+        else:
+            return None
+
+    def decode_quorum(self, rw):
+        """
+        Converts a protobuf quorum value to a symbolic value if
+        necessary.
+
+        :param rw: the quorum
+        :type rw: int
+        :rtype int or string
+        """
+        if rw in QUORUM_TO_PY:
+            return QUORUM_TO_PY[rw]
+        else:
+            return rw
+
+    def decode_contents(self, contents, obj):
+        """
+        Decodes the list of siblings from the protobuf representation
+        into the object.
+
+        :param contents: a list of RpbContent messages
+        :type contents: list
+        :param obj: a RiakObject
+        :type obj: RiakObject
+        :rtype RiakObject
+        """
+        obj.siblings = [self.decode_content(c, RiakContent(obj))
+                        for c in contents]
+        # Invoke sibling-resolution logic
+        if len(obj.siblings) > 1 and obj.resolver is not None:
+            obj.resolver(obj)
+        return obj
+
+    def decode_content(self, rpb_content, sibling):
+        """
+        Decodes a single sibling from the protobuf representation into
+        a RiakObject.
+
+        :param rpb_content: a single RpbContent message
+        :type rpb_content: riak.pb.riak_pb2.RpbContent
+        :param sibling: a RiakContent sibling container
+        :type sibling: RiakContent
+        :rtype: RiakContent
+        """
+
+        if rpb_content.HasField("deleted") and rpb_content.deleted:
+            sibling.exists = False
+        else:
+            sibling.exists = True
+        if rpb_content.HasField("content_type"):
+            sibling.content_type = bytes_to_str(rpb_content.content_type)
+        if rpb_content.HasField("charset"):
+            sibling.charset = bytes_to_str(rpb_content.charset)
+        if rpb_content.HasField("content_encoding"):
+            sibling.content_encoding = \
+                bytes_to_str(rpb_content.content_encoding)
+        if rpb_content.HasField("vtag"):
+            sibling.etag = bytes_to_str(rpb_content.vtag)
+
+        sibling.links = [self.decode_link(link)
+                         for link in rpb_content.links]
+        if rpb_content.HasField("last_mod"):
+            sibling.last_modified = float(rpb_content.last_mod)
+            if rpb_content.HasField("last_mod_usecs"):
+                sibling.last_modified += rpb_content.last_mod_usecs / 1000000.0
+
+        sibling.usermeta = dict([(bytes_to_str(usermd.key),
+                                  bytes_to_str(usermd.value))
+                                 for usermd in rpb_content.usermeta])
+        sibling.indexes = set([(bytes_to_str(index.key),
+                                decode_index_value(index.key, index.value))
+                               for index in rpb_content.indexes])
+        sibling.encoded_data = rpb_content.value
+
+        return sibling
+
+    def encode_content(self, robj, rpb_content):

riak-2.5.4.tar.gz/riak/codecs/ttb.py Added

@@ -0,0 +1,214 @@
+import datetime
+import six
+
+from erlastic import encode, decode
+from erlastic.types import Atom
+
+from riak import RiakError
+from riak.codecs import Codec, Msg
+from riak.pb.messages import MSG_CODE_TS_TTB_MSG
+from riak.ts_object import TsColumns
+from riak.util import bytes_to_str, unix_time_millis, \
+    datetime_from_unix_time_millis
+
+udef_a = Atom('undefined')
+
+rpberrorresp_a = Atom('rpberrorresp')
+tsgetreq_a = Atom('tsgetreq')
+tsgetresp_a = Atom('tsgetresp')
+tsqueryreq_a = Atom('tsqueryreq')
+tsqueryresp_a = Atom('tsqueryresp')
+tsinterpolation_a = Atom('tsinterpolation')
+tsputreq_a = Atom('tsputreq')
+tsputresp_a = Atom('tsputresp')
+tsdelreq_a = Atom('tsdelreq')
+timestamp_a = Atom('timestamp')
+
+
+class TtbCodec(Codec):
+    '''
+    Erlang term-to-binary Encoding and decoding methods for TcpTransport
+    '''
+
+    def __init__(self, **unused_args):
+        super(TtbCodec, self).__init__(**unused_args)
+
+    def parse_msg(self, msg_code, data):
+        if msg_code != MSG_CODE_TS_TTB_MSG:
+            raise RiakError("TTB can't parse code: {}".format(msg_code))
+        if len(data) > 0:
+            decoded = decode(data)
+            self.maybe_err_ttb(decoded)
+            return decoded
+        else:
+            return None
+
+    def maybe_err_ttb(self, err_ttb):
+        resp_a = err_ttb[0]
+        if resp_a == rpberrorresp_a:
+            errmsg = err_ttb[1]
+            # errcode = err_ttb[2]
+            raise RiakError(bytes_to_str(errmsg))
+
+    def encode_to_ts_cell(self, cell):
+        if cell is None:
+            return []
+        else:
+            if isinstance(cell, datetime.datetime):
+                ts = unix_time_millis(cell)
+                # logging.debug('encoded datetime %s as %s', cell, ts)
+                return ts
+            elif isinstance(cell, bool):
+                return cell
+            elif isinstance(cell, six.text_type) or \
+                    isinstance(cell, six.binary_type) or \
+                    isinstance(cell, six.string_types):
+                return cell
+            elif (isinstance(cell, six.integer_types)):
+                return cell
+            elif isinstance(cell, float):
+                return cell
+            else:
+                t = type(cell)
+                raise RiakError("can't serialize type '{}', value '{}'"
+                                .format(t, cell))
+
+    def encode_timeseries_keyreq(self, table, key, is_delete=False):
+        key_vals = None
+        if isinstance(key, list):
+            key_vals = key
+        else:
+            raise ValueError("key must be a list")
+
+        mc = MSG_CODE_TS_TTB_MSG
+        rc = MSG_CODE_TS_TTB_MSG
+        req_atom = tsgetreq_a
+        if is_delete:
+            req_atom = tsdelreq_a
+
+        # TODO FUTURE add timeout as last param
+        req = req_atom, table.name, \
+            [self.encode_to_ts_cell(k) for k in key_vals], udef_a
+        return Msg(mc, encode(req), rc)
+
+    def validate_timeseries_put_resp(self, resp_code, resp):
+        if resp is None and resp_code == MSG_CODE_TS_TTB_MSG:
+            return True
+        if resp is not None:
+            return True
+        else:
+            raise RiakError("missing response object")
+
+    def encode_timeseries_put(self, tsobj):
+        '''
+        Returns an Erlang-TTB encoded tuple with the appropriate data and
+        metadata from a TsObject.
+
+        :param tsobj: a TsObject
+        :type tsobj: TsObject
+        :rtype: term-to-binary encoded object
+        '''
+        if tsobj.columns:
+            raise NotImplementedError('columns are not used')
+
+        if tsobj.rows and isinstance(tsobj.rows, list):
+            req_rows = []
+            for row in tsobj.rows:
+                req_r = []
+                for cell in row:
+                    req_r.append(self.encode_to_ts_cell(cell))
+                req_rows.append(tuple(req_r))
+            req = tsputreq_a, tsobj.table.name, [], req_rows
+            mc = MSG_CODE_TS_TTB_MSG
+            rc = MSG_CODE_TS_TTB_MSG
+            return Msg(mc, encode(req), rc)
+        else:
+            raise RiakError("TsObject requires a list of rows")
+
+    def encode_timeseries_query(self, table, query, interpolations=None):
+        q = query
+        if '{table}' in q:
+            q = q.format(table=table.name)
+        tsi = tsinterpolation_a, q, []
+        req = tsqueryreq_a, tsi, False, udef_a
+        mc = MSG_CODE_TS_TTB_MSG
+        rc = MSG_CODE_TS_TTB_MSG
+        return Msg(mc, encode(req), rc)
+
+    def decode_timeseries(self, resp_ttb, tsobj,
+                          convert_timestamp=False):
+        """
+        Fills an TsObject with the appropriate data and
+        metadata from a TTB-encoded TsGetResp / TsQueryResp.
+
+        :param resp_ttb: the decoded TTB data
+        :type resp_ttb: TTB-encoded tsqueryrsp or tsgetresp
+        :param tsobj: a TsObject
+        :type tsobj: TsObject
+        :param convert_timestamp: Convert timestamps to datetime objects
+        :type tsobj: boolean
+        """
+        if resp_ttb is None:
+            return tsobj
+
+        self.maybe_err_ttb(resp_ttb)
+
+        # NB: some queries return a BARE 'tsqueryresp' atom
+        # catch that here:
+        if resp_ttb == tsqueryresp_a:
+            return tsobj
+
+        # The response atom is the first element in the response tuple
+        resp_a = resp_ttb[0]
+        if resp_a == tsputresp_a:
+            return
+        elif resp_a == tsgetresp_a or resp_a == tsqueryresp_a:
+            resp_data = resp_ttb[1]
+            if len(resp_data) == 0:
+                return
+            elif len(resp_data) == 3:
+                resp_colnames = resp_data[0]
+                resp_coltypes = resp_data[1]
+                tsobj.columns = self.decode_timeseries_cols(
+                        resp_colnames, resp_coltypes)
+                resp_rows = resp_data[2]
+                tsobj.rows = []
+                for resp_row in resp_rows:
+                    tsobj.rows.append(
+                        self.decode_timeseries_row(resp_row, resp_coltypes,
+                                                   convert_timestamp))
+            else:
+                raise RiakError(
+                    "Expected 3-tuple in response, got: {}".format(resp_data))
+        else:
+            raise RiakError("Unknown TTB response type: {}".format(resp_a))
+
+    def decode_timeseries_cols(self, cnames, ctypes):
+        cnames = [bytes_to_str(cname) for cname in cnames]
+        ctypes = [str(ctype) for ctype in ctypes]
+        return TsColumns(cnames, ctypes)
+
+    def decode_timeseries_row(self, tsrow, tsct, convert_timestamp=False):
+        """
+        Decodes a TTB-encoded TsRow into a list
+
+        :param tsrow: the TTB decoded TsRow to decode.
+        :type tsrow: TTB dncoded row
+        :param tsct: the TTB decoded column types (atoms).
+        :type tsct: list
+        :param convert_timestamp: Convert timestamps to datetime objects

riak-2.5.4.tar.gz/riak/codecs/util.py Added

riak-2.1.0.tar.gz/riak/content.py -> riak-2.5.4.tar.gz/riak/content.py Changed

riak-2.1.0.tar.gz/riak/datatypes/__init__.py -> riak-2.5.4.tar.gz/riak/datatypes/__init__.py Changed

riak-2.1.0.tar.gz/riak/datatypes/counter.py -> riak-2.5.4.tar.gz/riak/datatypes/counter.py Changed

@@ -1,4 +1,23 @@
+"""
+Copyright 2015 Basho Technologies, Inc.
+
+This file is provided to you under the Apache License,
+Version 2.0 (the "License"); you may not use this file
+except in compliance with the License.  You may obtain
+a copy of the License at
+
+  http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing,
+software distributed under the License is distributed on an
+"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+KIND, either express or implied.  See the License for the
+specific language governing permissions and limitations
+under the License.
+"""
+
 from riak.datatypes.datatype import Datatype
+from riak.datatypes import TYPES
 
 
 class Counter(Datatype):
@@ -54,8 +73,7 @@
 
     def _check_type(self, new_value):
         return (isinstance(new_value, int) or
-                isinstance(new_value, long))
+                isinstance(new_value, long))  # noqa
 
 
-from riak.datatypes import TYPES
 TYPES['counter'] = Counter

riak-2.1.0.tar.gz/riak/datatypes/datatype.py -> riak-2.5.4.tar.gz/riak/datatypes/datatype.py Changed

@@ -1,4 +1,24 @@
+"""
+Copyright 2015 Basho Technologies, Inc.
+
+This file is provided to you under the Apache License,
+Version 2.0 (the "License"); you may not use this file
+except in compliance with the License.  You may obtain
+a copy of the License at
+
+  http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing,
+software distributed under the License is distributed on an
+"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+KIND, either express or implied.  See the License for the
+specific language governing permissions and limitations
+under the License.
+"""
+
+
 from .errors import ContextRequired
+from . import TYPES
 
 
 class Datatype(object):
@@ -104,6 +124,17 @@
         self._set_value(value)
         return self
 
+    def delete(self, **params):
+        """
+        Deletes the datatype from Riak. See :meth:`RiakClient.delete()
+        <riak.client.RiakClient.delete>` for options.
+        """
+        self.clear()
+        self._context = None
+        self._set_value(self._default_value())
+        self.bucket._client.delete(self, **params)
+        return self
+
     def update(self, **params):
         """
         Sends locally staged mutations to Riak.
@@ -201,5 +232,3 @@
         """
         if not self._context:
             raise ContextRequired()
-
-from . import TYPES

riak-2.1.0.tar.gz/riak/datatypes/errors.py -> riak-2.5.4.tar.gz/riak/datatypes/errors.py Changed

riak-2.1.0.tar.gz/riak/datatypes/flag.py -> riak-2.5.4.tar.gz/riak/datatypes/flag.py Changed

riak-2.1.0.tar.gz/riak/datatypes/map.py -> riak-2.5.4.tar.gz/riak/datatypes/map.py Changed

@@ -1,6 +1,25 @@
+"""
+Copyright 2015 Basho Technologies, Inc.
+
+This file is provided to you under the Apache License,
+Version 2.0 (the "License"); you may not use this file
+except in compliance with the License.  You may obtain
+a copy of the License at
+
+  http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing,
+software distributed under the License is distributed on an
+"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+KIND, either express or implied.  See the License for the
+specific language governing permissions and limitations
+under the License.
+"""
+
 from collections import Mapping
 from riak.util import lazy_property
 from .datatype import Datatype
+from riak.datatypes import TYPES
 
 
 class TypedMapView(Mapping):
@@ -33,7 +52,7 @@
         for key in self.map.value:
             name, datatype = key
             if datatype == self.datatype:
-                yield self.map[key]
+                yield name
 
     def __len__(self):
         """
@@ -238,13 +257,15 @@
         """
         Whether the map has staged local modifications.
         """
-        is_modified = lambda x: x.modified
-        values_modified = [is_modified(self._value[v]) for v in self._value]
-        modified = (any(values_modified) or self._removes or self._updates)
-        if modified:
+        if self._removes:
             return True
-        else:
-            return False
+        for v in self._value:
+            if self._value[v].modified:
+                return True
+        for v in self._updates:
+            if self._updates[v].modified:
+                return True
+        return False
 
     def to_op(self):
         """
@@ -282,5 +303,4 @@
                 yield ('update', key, d[key].to_op())
 
 
-from riak.datatypes import TYPES
 TYPES['map'] = Map

riak-2.1.0.tar.gz/riak/datatypes/register.py -> riak-2.5.4.tar.gz/riak/datatypes/register.py Changed

@@ -1,5 +1,25 @@
+"""
+Copyright 2015 Basho Technologies, Inc.
+
+This file is provided to you under the Apache License,
+Version 2.0 (the "License"); you may not use this file
+except in compliance with the License.  You may obtain
+a copy of the License at
+
+  http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing,
+software distributed under the License is distributed on an
+"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+KIND, either express or implied.  See the License for the
+specific language governing permissions and limitations
+under the License.
+"""
+
 from collections import Sized
 from riak.datatypes.datatype import Datatype
+from six import string_types
+from riak.datatypes import TYPES
 
 
 class Register(Sized, Datatype):
@@ -57,8 +77,7 @@
         return len(self.value)
 
     def _check_type(self, new_value):
-        return isinstance(new_value, basestring)
+        return isinstance(new_value, string_types)
 
 
-from riak.datatypes import TYPES
 TYPES['register'] = Register

riak-2.1.0.tar.gz/riak/datatypes/set.py -> riak-2.5.4.tar.gz/riak/datatypes/set.py Changed

@@ -1,5 +1,25 @@
+"""
+Copyright 2015 Basho Technologies, Inc.
+
+This file is provided to you under the Apache License,
+Version 2.0 (the "License"); you may not use this file
+except in compliance with the License.  You may obtain
+a copy of the License at
+
+  http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing,
+software distributed under the License is distributed on an
+"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+KIND, either express or implied.  See the License for the
+specific language governing permissions and limitations
+under the License.
+"""
+
 import collections
 from .datatype import Datatype
+from six import string_types
+from riak.datatypes import TYPES
 
 __all__ = ['Set']
 
@@ -102,15 +122,14 @@
         if not isinstance(new_value, collections.Iterable):
             return False
         for element in new_value:
-            if not isinstance(element, basestring):
+            if not isinstance(element, string_types):
                 return False
         return True
 
 
 def _check_element(element):
-    if not isinstance(element, basestring):
+    if not isinstance(element, string_types):
         raise TypeError("Set elements can only be strings")
 
 
-from riak.datatypes import TYPES
 TYPES['set'] = Set

riak-2.5.4.tar.gz/riak/datatypes/types.py Added

riak-2.1.0.tar.gz/riak/mapreduce.py -> riak-2.5.4.tar.gz/riak/mapreduce.py Changed

@@ -18,8 +18,12 @@
 under the License.
 """
 
+from __future__ import print_function
 from collections import Iterable, namedtuple
 from riak import RiakError
+from six import string_types, PY2
+from riak.bucket import RiakBucket
+
 
 #: Links are just bucket/key/tag tuples, this class provides a
 #: backwards-compatible format: ``RiakLink(bucket, key, tag)``
@@ -46,7 +50,7 @@
         self._key_filters = []
         self._input_mode = None
 
-    def add(self, arg1, arg2=None, arg3=None):
+    def add(self, arg1, arg2=None, arg3=None, bucket_type=None):
         """
         Add inputs to a map/reduce operation. This method takes three
         different forms, depending on the provided inputs. You can
@@ -60,15 +64,18 @@
         :type arg2: string, list, None
         :param arg3: key data for this input (must be convertible to JSON)
         :type arg3: string, list, dict, None
+        :param bucket_type: Optional name of a bucket type
+        :type bucket_type: string, None
         :rtype: :class:`RiakMapReduce`
         """
+        from riak.riak_object import RiakObject
         if (arg2 is None) and (arg3 is None):
             if isinstance(arg1, RiakObject):
                 return self.add_object(arg1)
             else:
-                return self.add_bucket(arg1)
+                return self.add_bucket(arg1, bucket_type)
         else:
-            return self.add_bucket_key_data(arg1, arg2, arg3)
+            return self.add_bucket_key_data(arg1, arg2, arg3, bucket_type)
 
     def add_object(self, obj):
         """
@@ -80,7 +87,7 @@
         """
         return self.add_bucket_key_data(obj._bucket._name, obj._key, None)
 
-    def add_bucket_key_data(self, bucket, key, data):
+    def add_bucket_key_data(self, bucket, key, data, bucket_type=None):
         """
         Adds a bucket/key/keydata triple to the inputs.
 
@@ -90,6 +97,8 @@
         :type key: string
         :param data: the key-specific data
         :type data: string, list, dict, None
+        :param bucket_type: Optional name of a bucket type
+        :type bucket_type: string, None
         :rtype: :class:`RiakMapReduce`
         """
         if self._input_mode == 'bucket':
@@ -98,23 +107,41 @@
             raise ValueError('Already added a query, can\'t add an object.')
         else:
             if isinstance(key, Iterable) and \
-                    not isinstance(key, basestring):
-                for k in key:
-                    self._inputs.append([bucket, k, data])
+                    not isinstance(key, string_types):
+                if bucket_type is not None:
+                    for k in key:
+                        self._inputs.append([bucket, k, data, bucket_type])
+                else:
+                    for k in key:
+                        self._inputs.append([bucket, k, data])
             else:
-                self._inputs.append([bucket, key, data])
+                if bucket_type is not None:
+                    self._inputs.append([bucket, key, data, bucket_type])
+                else:
+                    self._inputs.append([bucket, key, data])
             return self
 
-    def add_bucket(self, bucket):
+    def add_bucket(self, bucket, bucket_type=None):
         """
         Adds all keys in a bucket to the inputs.
 
         :param bucket: the bucket
         :type bucket: string
+        :param bucket_type: Optional name of a bucket type
+        :type bucket_type: string, None
         :rtype: :class:`RiakMapReduce`
         """
         self._input_mode = 'bucket'
-        self._inputs = bucket
+        if isinstance(bucket, RiakBucket):
+            if bucket.bucket_type.is_default():
+                self._inputs = {'bucket': bucket.name}
+            else:
+                self._inputs = {'bucket': [bucket.bucket_type.name,
+                                           bucket.name]}
+        elif bucket_type is not None and bucket_type != "default":
+            self._inputs = {'bucket': [bucket_type, bucket]}
+        else:
+            self._inputs = {'bucket': bucket}
         return self
 
     def add_key_filters(self, key_filters):
@@ -162,7 +189,7 @@
                         'query': query}
         return self
 
-    def index(self, bucket, index, startkey, endkey=None):
+    def index(self, bucket, index, startkey, endkey=None, bucket_type=None):
         """
         Begin a map/reduce operation using a Secondary Index
         query.
@@ -176,6 +203,8 @@
         :type startkey: string, integer
         :param endkey: The end key of index range (if doing a range query)
         :type endkey: string, integer, None
+        :param bucket_type: Optional name of a bucket type
+        :type bucket_type: string, None
         :rtype: :class:`RiakMapReduce`
         """
         self._input_mode = 'query'
@@ -189,6 +218,8 @@
                             'index': index,
                             'start': startkey,
                             'end': endkey}
+        if bucket_type is not None:
+            self._inputs['bucket'] = [bucket_type, bucket]
         return self
 
     def link(self, bucket='_', tag='_', keep=False):
@@ -291,8 +322,8 @@
             raise e
 
         # If the last phase is NOT a link phase, then return the result.
-        if not (link_results_flag
-                or isinstance(self._phases[-1], RiakLinkPhase)):
+        if not (link_results_flag or
+                isinstance(self._phases[-1], RiakLinkPhase)):
             return result
 
         # If there are no results, then return an empty list.
@@ -345,16 +376,14 @@
                 keep_flag = True
             query.append(phase.to_array())
 
-        if (len(self._key_filters) > 0):
-            bucket_name = None
-            if (type(self._inputs) == str):
-                bucket_name = self._inputs
-            elif (type(self._inputs) == RiakBucket):
-                bucket_name = self._inputs.name
-
-            if (bucket_name is not None):
-                self._inputs = {'bucket':       bucket_name,
-                                'key_filters':  self._key_filters}
+        # Is this a bucket-only input? If so, we need to switch
+        # to be a string or array, i.e., no keyword (to keep Riak happy)
+        # Also add the key filter, if necessary
+        if isinstance(self._inputs, dict) and len(self._inputs) == 1:
+            if len(self._key_filters) > 0:
+                self._inputs['key_filters'] = self._key_filters
+            else:
+                self._inputs = self._inputs['bucket']
 
         return query, link_results_flag
 
@@ -526,7 +555,7 @@
         :type arg: string, dict, list
         """
         try:
-            if isinstance(function, basestring):
+            if isinstance(function, string_types) and PY2:
                 function = function.encode('ascii')
         except UnicodeError:
             raise TypeError('Unicode encoded functions are not supported.')
@@ -552,7 +581,7 @@
             if isinstance(self._function, list):
                 stepdef['bucket'] = self._function[0]
                 stepdef['key'] = self._function[1]
-            elif isinstance(self._function, str):
+            elif isinstance(self._function, string_types):
                 if ("{" in self._function):
                     stepdef['source'] = self._function
                 else:
@@ -562,7 +591,8 @@
             stepdef['module'] = self._function[0]
             stepdef['function'] = self._function[1]
 
-        elif (self._language == 'erlang' and isinstance(self._function, str)):
+        elif (self._language == 'erlang' and
+              isinstance(self._function, string_types)):
             stepdef['source'] = self._function
 
         return {self._type: stepdef}

riak-2.1.0.tar.gz/riak/multidict.py -> riak-2.5.4.tar.gz/riak/multidict.py Changed

riak-2.1.0.tar.gz/riak/node.py -> riak-2.5.4.tar.gz/riak/node.py Changed

riak-2.5.4.tar.gz/riak/pb Added

riak-2.5.4.tar.gz/riak/pb/__init__.py Added

riak-2.5.4.tar.gz/riak/pb/messages.py Added

@@ -0,0 +1,173 @@
+# This is a generated file. DO NOT EDIT.
+
+"""
+Constants and mappings between Riak protocol codes and messages.
+"""
+
+import riak.pb.riak_dt_pb2
+import riak.pb.riak_kv_pb2
+import riak.pb.riak_pb2
+import riak.pb.riak_search_pb2
+import riak.pb.riak_ts_pb2
+import riak.pb.riak_yokozuna_pb2
+
+# Protocol codes
+MSG_CODE_ERROR_RESP = 0
+MSG_CODE_PING_REQ = 1
+MSG_CODE_PING_RESP = 2
+MSG_CODE_GET_CLIENT_ID_REQ = 3
+MSG_CODE_GET_CLIENT_ID_RESP = 4
+MSG_CODE_SET_CLIENT_ID_REQ = 5
+MSG_CODE_SET_CLIENT_ID_RESP = 6
+MSG_CODE_GET_SERVER_INFO_REQ = 7
+MSG_CODE_GET_SERVER_INFO_RESP = 8
+MSG_CODE_GET_REQ = 9
+MSG_CODE_GET_RESP = 10
+MSG_CODE_PUT_REQ = 11
+MSG_CODE_PUT_RESP = 12
+MSG_CODE_DEL_REQ = 13
+MSG_CODE_DEL_RESP = 14
+MSG_CODE_LIST_BUCKETS_REQ = 15
+MSG_CODE_LIST_BUCKETS_RESP = 16
+MSG_CODE_LIST_KEYS_REQ = 17
+MSG_CODE_LIST_KEYS_RESP = 18
+MSG_CODE_GET_BUCKET_REQ = 19
+MSG_CODE_GET_BUCKET_RESP = 20
+MSG_CODE_SET_BUCKET_REQ = 21
+MSG_CODE_SET_BUCKET_RESP = 22
+MSG_CODE_MAP_RED_REQ = 23
+MSG_CODE_MAP_RED_RESP = 24
+MSG_CODE_INDEX_REQ = 25
+MSG_CODE_INDEX_RESP = 26
+MSG_CODE_SEARCH_QUERY_REQ = 27
+MSG_CODE_SEARCH_QUERY_RESP = 28
+MSG_CODE_RESET_BUCKET_REQ = 29
+MSG_CODE_RESET_BUCKET_RESP = 30
+MSG_CODE_GET_BUCKET_TYPE_REQ = 31
+MSG_CODE_SET_BUCKET_TYPE_REQ = 32
+MSG_CODE_GET_BUCKET_KEY_PREFLIST_REQ = 33
+MSG_CODE_GET_BUCKET_KEY_PREFLIST_RESP = 34
+MSG_CODE_CS_BUCKET_REQ = 40
+MSG_CODE_CS_BUCKET_RESP = 41
+MSG_CODE_INDEX_BODY_RESP = 42
+MSG_CODE_COUNTER_UPDATE_REQ = 50
+MSG_CODE_COUNTER_UPDATE_RESP = 51
+MSG_CODE_COUNTER_GET_REQ = 52
+MSG_CODE_COUNTER_GET_RESP = 53
+MSG_CODE_YOKOZUNA_INDEX_GET_REQ = 54
+MSG_CODE_YOKOZUNA_INDEX_GET_RESP = 55
+MSG_CODE_YOKOZUNA_INDEX_PUT_REQ = 56
+MSG_CODE_YOKOZUNA_INDEX_DELETE_REQ = 57
+MSG_CODE_YOKOZUNA_SCHEMA_GET_REQ = 58
+MSG_CODE_YOKOZUNA_SCHEMA_GET_RESP = 59
+MSG_CODE_YOKOZUNA_SCHEMA_PUT_REQ = 60
+MSG_CODE_COVERAGE_REQ = 70
+MSG_CODE_COVERAGE_RESP = 71
+MSG_CODE_DT_FETCH_REQ = 80
+MSG_CODE_DT_FETCH_RESP = 81
+MSG_CODE_DT_UPDATE_REQ = 82
+MSG_CODE_DT_UPDATE_RESP = 83
+MSG_CODE_TS_QUERY_REQ = 90
+MSG_CODE_TS_QUERY_RESP = 91
+MSG_CODE_TS_PUT_REQ = 92
+MSG_CODE_TS_PUT_RESP = 93
+MSG_CODE_TS_DEL_REQ = 94
+MSG_CODE_TS_DEL_RESP = 95
+MSG_CODE_TS_GET_REQ = 96
+MSG_CODE_TS_GET_RESP = 97
+MSG_CODE_TS_LIST_KEYS_REQ = 98
+MSG_CODE_TS_LIST_KEYS_RESP = 99
+MSG_CODE_TS_COVERAGE_REQ = 100
+MSG_CODE_TS_COVERAGE_RESP = 101
+MSG_CODE_TS_COVERAGE_ENTRY = 102
+MSG_CODE_TS_RANGE = 103
+MSG_CODE_TS_TTB_MSG = 104
+MSG_CODE_AUTH_REQ = 253
+MSG_CODE_AUTH_RESP = 254
+MSG_CODE_START_TLS = 255
+
+# Mapping from code to protobuf class
+MESSAGE_CLASSES = {
+    MSG_CODE_ERROR_RESP: riak.pb.riak_pb2.RpbErrorResp,
+    MSG_CODE_PING_REQ: None,
+    MSG_CODE_PING_RESP: None,
+    MSG_CODE_GET_CLIENT_ID_REQ: None,
+    MSG_CODE_GET_CLIENT_ID_RESP: riak.pb.riak_kv_pb2.RpbGetClientIdResp,
+    MSG_CODE_SET_CLIENT_ID_REQ: riak.pb.riak_kv_pb2.RpbSetClientIdReq,
+    MSG_CODE_SET_CLIENT_ID_RESP: None,
+    MSG_CODE_GET_SERVER_INFO_REQ: None,
+    MSG_CODE_GET_SERVER_INFO_RESP: riak.pb.riak_pb2.RpbGetServerInfoResp,
+    MSG_CODE_GET_REQ: riak.pb.riak_kv_pb2.RpbGetReq,
+    MSG_CODE_GET_RESP: riak.pb.riak_kv_pb2.RpbGetResp,
+    MSG_CODE_PUT_REQ: riak.pb.riak_kv_pb2.RpbPutReq,
+    MSG_CODE_PUT_RESP: riak.pb.riak_kv_pb2.RpbPutResp,
+    MSG_CODE_DEL_REQ: riak.pb.riak_kv_pb2.RpbDelReq,
+    MSG_CODE_DEL_RESP: None,
+    MSG_CODE_LIST_BUCKETS_REQ: riak.pb.riak_kv_pb2.RpbListBucketsReq,
+    MSG_CODE_LIST_BUCKETS_RESP: riak.pb.riak_kv_pb2.RpbListBucketsResp,
+    MSG_CODE_LIST_KEYS_REQ: riak.pb.riak_kv_pb2.RpbListKeysReq,
+    MSG_CODE_LIST_KEYS_RESP: riak.pb.riak_kv_pb2.RpbListKeysResp,
+    MSG_CODE_GET_BUCKET_REQ: riak.pb.riak_pb2.RpbGetBucketReq,
+    MSG_CODE_GET_BUCKET_RESP: riak.pb.riak_pb2.RpbGetBucketResp,
+    MSG_CODE_SET_BUCKET_REQ: riak.pb.riak_pb2.RpbSetBucketReq,
+    MSG_CODE_SET_BUCKET_RESP: None,
+    MSG_CODE_MAP_RED_REQ: riak.pb.riak_kv_pb2.RpbMapRedReq,
+    MSG_CODE_MAP_RED_RESP: riak.pb.riak_kv_pb2.RpbMapRedResp,
+    MSG_CODE_INDEX_REQ: riak.pb.riak_kv_pb2.RpbIndexReq,
+    MSG_CODE_INDEX_RESP: riak.pb.riak_kv_pb2.RpbIndexResp,
+    MSG_CODE_SEARCH_QUERY_REQ: riak.pb.riak_search_pb2.RpbSearchQueryReq,
+    MSG_CODE_SEARCH_QUERY_RESP: riak.pb.riak_search_pb2.RpbSearchQueryResp,
+    MSG_CODE_RESET_BUCKET_REQ: riak.pb.riak_pb2.RpbResetBucketReq,
+    MSG_CODE_RESET_BUCKET_RESP: None,
+    MSG_CODE_GET_BUCKET_TYPE_REQ: riak.pb.riak_pb2.RpbGetBucketTypeReq,
+    MSG_CODE_SET_BUCKET_TYPE_REQ: riak.pb.riak_pb2.RpbSetBucketTypeReq,
+    MSG_CODE_GET_BUCKET_KEY_PREFLIST_REQ:
+    riak.pb.riak_kv_pb2.RpbGetBucketKeyPreflistReq,
+    MSG_CODE_GET_BUCKET_KEY_PREFLIST_RESP:
+    riak.pb.riak_kv_pb2.RpbGetBucketKeyPreflistResp,
+    MSG_CODE_CS_BUCKET_REQ: riak.pb.riak_kv_pb2.RpbCSBucketReq,
+    MSG_CODE_CS_BUCKET_RESP: riak.pb.riak_kv_pb2.RpbCSBucketResp,
+    MSG_CODE_INDEX_BODY_RESP: riak.pb.riak_kv_pb2.RpbIndexBodyResp,
+    MSG_CODE_COUNTER_UPDATE_REQ: riak.pb.riak_kv_pb2.RpbCounterUpdateReq,
+    MSG_CODE_COUNTER_UPDATE_RESP: riak.pb.riak_kv_pb2.RpbCounterUpdateResp,
+    MSG_CODE_COUNTER_GET_REQ: riak.pb.riak_kv_pb2.RpbCounterGetReq,
+    MSG_CODE_COUNTER_GET_RESP: riak.pb.riak_kv_pb2.RpbCounterGetResp,
+    MSG_CODE_YOKOZUNA_INDEX_GET_REQ:
+    riak.pb.riak_yokozuna_pb2.RpbYokozunaIndexGetReq,
+    MSG_CODE_YOKOZUNA_INDEX_GET_RESP:
+    riak.pb.riak_yokozuna_pb2.RpbYokozunaIndexGetResp,
+    MSG_CODE_YOKOZUNA_INDEX_PUT_REQ:
+    riak.pb.riak_yokozuna_pb2.RpbYokozunaIndexPutReq,
+    MSG_CODE_YOKOZUNA_INDEX_DELETE_REQ:
+    riak.pb.riak_yokozuna_pb2.RpbYokozunaIndexDeleteReq,
+    MSG_CODE_YOKOZUNA_SCHEMA_GET_REQ:
+    riak.pb.riak_yokozuna_pb2.RpbYokozunaSchemaGetReq,
+    MSG_CODE_YOKOZUNA_SCHEMA_GET_RESP:
+    riak.pb.riak_yokozuna_pb2.RpbYokozunaSchemaGetResp,
+    MSG_CODE_YOKOZUNA_SCHEMA_PUT_REQ:
+    riak.pb.riak_yokozuna_pb2.RpbYokozunaSchemaPutReq,
+    MSG_CODE_COVERAGE_REQ: riak.pb.riak_kv_pb2.RpbCoverageReq,
+    MSG_CODE_COVERAGE_RESP: riak.pb.riak_kv_pb2.RpbCoverageResp,
+    MSG_CODE_DT_FETCH_REQ: riak.pb.riak_dt_pb2.DtFetchReq,
+    MSG_CODE_DT_FETCH_RESP: riak.pb.riak_dt_pb2.DtFetchResp,
+    MSG_CODE_DT_UPDATE_REQ: riak.pb.riak_dt_pb2.DtUpdateReq,
+    MSG_CODE_DT_UPDATE_RESP: riak.pb.riak_dt_pb2.DtUpdateResp,
+    MSG_CODE_TS_QUERY_REQ: riak.pb.riak_ts_pb2.TsQueryReq,
+    MSG_CODE_TS_QUERY_RESP: riak.pb.riak_ts_pb2.TsQueryResp,
+    MSG_CODE_TS_PUT_REQ: riak.pb.riak_ts_pb2.TsPutReq,
+    MSG_CODE_TS_PUT_RESP: riak.pb.riak_ts_pb2.TsPutResp,
+    MSG_CODE_TS_DEL_REQ: riak.pb.riak_ts_pb2.TsDelReq,
+    MSG_CODE_TS_DEL_RESP: riak.pb.riak_ts_pb2.TsDelResp,
+    MSG_CODE_TS_GET_REQ: riak.pb.riak_ts_pb2.TsGetReq,
+    MSG_CODE_TS_GET_RESP: riak.pb.riak_ts_pb2.TsGetResp,
+    MSG_CODE_TS_LIST_KEYS_REQ: riak.pb.riak_ts_pb2.TsListKeysReq,
+    MSG_CODE_TS_LIST_KEYS_RESP: riak.pb.riak_ts_pb2.TsListKeysResp,
+    MSG_CODE_TS_COVERAGE_REQ: riak.pb.riak_ts_pb2.TsCoverageReq,
+    MSG_CODE_TS_COVERAGE_RESP: riak.pb.riak_ts_pb2.TsCoverageResp,
+    MSG_CODE_TS_COVERAGE_ENTRY: riak.pb.riak_ts_pb2.TsCoverageEntry,
+    MSG_CODE_TS_RANGE: riak.pb.riak_ts_pb2.TsRange,
+    MSG_CODE_TS_TTB_MSG: None,
+    MSG_CODE_AUTH_REQ: riak.pb.riak_pb2.RpbAuthReq,
+    MSG_CODE_AUTH_RESP: None,
+    MSG_CODE_START_TLS: None
+}

riak-2.5.4.tar.gz/riak/pb/riak_dt_pb2.py Added

@@ -0,0 +1,863 @@
+from six import *
+# Generated by the protocol buffer compiler.  DO NOT EDIT!
+# source: riak_dt.proto
+
+from google.protobuf import descriptor as _descriptor
+from google.protobuf import message as _message
+from google.protobuf import reflection as _reflection
+from google.protobuf import descriptor_pb2
+# @@protoc_insertion_point(imports)
+
+
+
+
+DESCRIPTOR = _descriptor.FileDescriptor(
+  name='riak_dt.proto',
+  package='',
+  serialized_pb='\n\rriak_dt.proto\"\x85\x01\n\x08MapField\x12\x0c\n\x04name\x18\x01 \x02(\x0c\x12$\n\x04type\x18\x02 \x02(\x0e\x32\x16.MapField.MapFieldType\"E\n\x0cMapFieldType\x12\x0b\n\x07\x43OUNTER\x10\x01\x12\x07\n\x03SET\x10\x02\x12\x0c\n\x08REGISTER\x10\x03\x12\x08\n\x04\x46LAG\x10\x04\x12\x07\n\x03MAP\x10\x05\"\x98\x01\n\x08MapEntry\x12\x18\n\x05\x66ield\x18\x01 \x02(\x0b\x32\t.MapField\x12\x15\n\rcounter_value\x18\x02 \x01(\x12\x12\x11\n\tset_value\x18\x03 \x03(\x0c\x12\x16\n\x0eregister_value\x18\x04 \x01(\x0c\x12\x12\n\nflag_value\x18\x05 \x01(\x08\x12\x1c\n\tmap_value\x18\x06 \x03(\x0b\x32\t.MapEntry\"\xcf\x01\n\nDtFetchReq\x12\x0e\n\x06\x62ucket\x18\x01 \x02(\x0c\x12\x0b\n\x03key\x18\x02 \x02(\x0c\x12\x0c\n\x04type\x18\x03 \x02(\x0c\x12\t\n\x01r\x18\x04 \x01(\r\x12\n\n\x02pr\x18\x05 \x01(\r\x12\x14\n\x0c\x62\x61sic_quorum\x18\x06 \x01(\x08\x12\x13\n\x0bnotfound_ok\x18\x07 \x01(\x08\x12\x0f\n\x07timeout\x18\x08 \x01(\r\x12\x15\n\rsloppy_quorum\x18\t \x01(\x08\x12\r\n\x05n_val\x18\n \x01(\r\x12\x1d\n\x0finclude_context\x18\x0b \x01(\x08:\x04true\"Q\n\x07\x44tValue\x12\x15\n\rcounter_value\x18\x01 \x01(\x12\x12\x11\n\tset_value\x18\x02 \x03(\x0c\x12\x1c\n\tmap_value\x18\x03 \x03(\x0b\x32\t.MapEntry\"\x87\x01\n\x0b\x44tFetchResp\x12\x0f\n\x07\x63ontext\x18\x01 \x01(\x0c\x12#\n\x04type\x18\x02 \x02(\x0e\x32\x15.DtFetchResp.DataType\x12\x17\n\x05value\x18\x03 \x01(\x0b\x32\x08.DtValue\")\n\x08\x44\x61taType\x12\x0b\n\x07\x43OUNTER\x10\x01\x12\x07\n\x03SET\x10\x02\x12\x07\n\x03MAP\x10\x03\"\x1e\n\tCounterOp\x12\x11\n\tincrement\x18\x01 \x01(\x12\"&\n\x05SetOp\x12\x0c\n\x04\x61\x64\x64s\x18\x01 \x03(\x0c\x12\x0f\n\x07removes\x18\x02 \x03(\x0c\"\xd1\x01\n\tMapUpdate\x12\x18\n\x05\x66ield\x18\x01 \x02(\x0b\x32\t.MapField\x12\x1e\n\ncounter_op\x18\x02 \x01(\x0b\x32\n.CounterOp\x12\x16\n\x06set_op\x18\x03 \x01(\x0b\x32\x06.SetOp\x12\x13\n\x0bregister_op\x18\x04 \x01(\x0c\x12\"\n\x07\x66lag_op\x18\x05 \x01(\x0e\x32\x11.MapUpdate.FlagOp\x12\x16\n\x06map_op\x18\x06 \x01(\x0b\x32\x06.MapOp\"!\n\x06\x46lagOp\x12\n\n\x06\x45NABLE\x10\x01\x12\x0b\n\x07\x44ISABLE\x10\x02\"@\n\x05MapOp\x12\x1a\n\x07removes\x18\x01 \x03(\x0b\x32\t.MapField\x12\x1b\n\x07updates\x18\x02 \x03(\x0b\x32\n.MapUpdate\"V\n\x04\x44tOp\x12\x1e\n\ncounter_op\x18\x01 \x01(\x0b\x32\n.CounterOp\x12\x16\n\x06set_op\x18\x02 \x01(\x0b\x32\x06.SetOp\x12\x16\n\x06map_op\x18\x03 \x01(\x0b\x32\x06.MapOp\"\xf1\x01\n\x0b\x44tUpdateReq\x12\x0e\n\x06\x62ucket\x18\x01 \x02(\x0c\x12\x0b\n\x03key\x18\x02 \x01(\x0c\x12\x0c\n\x04type\x18\x03 \x02(\x0c\x12\x0f\n\x07\x63ontext\x18\x04 \x01(\x0c\x12\x11\n\x02op\x18\x05 \x02(\x0b\x32\x05.DtOp\x12\t\n\x01w\x18\x06 \x01(\r\x12\n\n\x02\x64w\x18\x07 \x01(\r\x12\n\n\x02pw\x18\x08 \x01(\r\x12\x1a\n\x0breturn_body\x18\t \x01(\x08:\x05\x66\x61lse\x12\x0f\n\x07timeout\x18\n \x01(\r\x12\x15\n\rsloppy_quorum\x18\x0b \x01(\x08\x12\r\n\x05n_val\x18\x0c \x01(\r\x12\x1d\n\x0finclude_context\x18\r \x01(\x08:\x04true\"t\n\x0c\x44tUpdateResp\x12\x0b\n\x03key\x18\x01 \x01(\x0c\x12\x0f\n\x07\x63ontext\x18\x02 \x01(\x0c\x12\x15\n\rcounter_value\x18\x03 \x01(\x12\x12\x11\n\tset_value\x18\x04 \x03(\x0c\x12\x1c\n\tmap_value\x18\x05 \x03(\x0b\x32\t.MapEntryB#\n\x17\x63om.basho.riak.protobufB\x08RiakDtPB')
+
+
+
+_MAPFIELD_MAPFIELDTYPE = _descriptor.EnumDescriptor(
+  name='MapFieldType',
+  full_name='MapField.MapFieldType',
+  filename=None,
+  file=DESCRIPTOR,
+  values=[
+    _descriptor.EnumValueDescriptor(
+      name='COUNTER', index=0, number=1,
+      options=None,
+      type=None),
+    _descriptor.EnumValueDescriptor(
+      name='SET', index=1, number=2,
+      options=None,
+      type=None),
+    _descriptor.EnumValueDescriptor(
+      name='REGISTER', index=2, number=3,
+      options=None,
+      type=None),
+    _descriptor.EnumValueDescriptor(
+      name='FLAG', index=3, number=4,
+      options=None,
+      type=None),
+    _descriptor.EnumValueDescriptor(
+      name='MAP', index=4, number=5,
+      options=None,
+      type=None),
+  ],
+  containing_type=None,
+  options=None,
+  serialized_start=82,
+  serialized_end=151,
+)
+
+_DTFETCHRESP_DATATYPE = _descriptor.EnumDescriptor(
+  name='DataType',
+  full_name='DtFetchResp.DataType',
+  filename=None,
+  file=DESCRIPTOR,
+  values=[
+    _descriptor.EnumValueDescriptor(
+      name='COUNTER', index=0, number=1,
+      options=None,
+      type=None),
+    _descriptor.EnumValueDescriptor(
+      name='SET', index=1, number=2,
+      options=None,
+      type=None),
+    _descriptor.EnumValueDescriptor(
+      name='MAP', index=2, number=3,
+      options=None,
+      type=None),
+  ],
+  containing_type=None,
+  options=None,
+  serialized_start=696,
+  serialized_end=737,
+)
+
+_MAPUPDATE_FLAGOP = _descriptor.EnumDescriptor(
+  name='FlagOp',
+  full_name='MapUpdate.FlagOp',
+  filename=None,
+  file=DESCRIPTOR,
+  values=[
+    _descriptor.EnumValueDescriptor(
+      name='ENABLE', index=0, number=1,
+      options=None,
+      type=None),
+    _descriptor.EnumValueDescriptor(
+      name='DISABLE', index=1, number=2,
+      options=None,
+      type=None),
+  ],
+  containing_type=None,
+  options=None,
+  serialized_start=988,
+  serialized_end=1021,
+)
+
+
+_MAPFIELD = _descriptor.Descriptor(
+  name='MapField',
+  full_name='MapField',
+  filename=None,
+  file=DESCRIPTOR,
+  containing_type=None,
+  fields=[
+    _descriptor.FieldDescriptor(
+      name='name', full_name='MapField.name', index=0,
+      number=1, type=12, cpp_type=9, label=2,
+      has_default_value=False, default_value="",
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='type', full_name='MapField.type', index=1,
+      number=2, type=14, cpp_type=8, label=2,
+      has_default_value=False, default_value=1,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+  ],
+  extensions=[
+  ],
+  nested_types=[],
+  enum_types=[
+    _MAPFIELD_MAPFIELDTYPE,
+  ],
+  options=None,
+  is_extendable=False,
+  extension_ranges=[],
+  serialized_start=18,
+  serialized_end=151,
+)
+
+
+_MAPENTRY = _descriptor.Descriptor(
+  name='MapEntry',
+  full_name='MapEntry',
+  filename=None,
+  file=DESCRIPTOR,
+  containing_type=None,
+  fields=[
+    _descriptor.FieldDescriptor(
+      name='field', full_name='MapEntry.field', index=0,
+      number=1, type=11, cpp_type=10, label=2,
+      has_default_value=False, default_value=None,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='counter_value', full_name='MapEntry.counter_value', index=1,
+      number=2, type=18, cpp_type=2, label=1,
+      has_default_value=False, default_value=0,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='set_value', full_name='MapEntry.set_value', index=2,
+      number=3, type=12, cpp_type=9, label=3,
+      has_default_value=False, default_value=[],
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='register_value', full_name='MapEntry.register_value', index=3,
+      number=4, type=12, cpp_type=9, label=1,
+      has_default_value=False, default_value="",
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='flag_value', full_name='MapEntry.flag_value', index=4,
+      number=5, type=8, cpp_type=7, label=1,
+      has_default_value=False, default_value=False,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='map_value', full_name='MapEntry.map_value', index=5,
+      number=6, type=11, cpp_type=10, label=3,
+      has_default_value=False, default_value=[],
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+  ],
+  extensions=[
+  ],
+  nested_types=[],
+  enum_types=[
+  ],
+  options=None,
+  is_extendable=False,
+  extension_ranges=[],
+  serialized_start=154,
+  serialized_end=306,
+)
+
+

riak-2.5.4.tar.gz/riak/pb/riak_kv_pb2.py Added

@@ -0,0 +1,1973 @@
+from six import *
+# Generated by the protocol buffer compiler.  DO NOT EDIT!
+# source: riak_kv.proto
+
+from google.protobuf import descriptor as _descriptor
+from google.protobuf import message as _message
+from google.protobuf import reflection as _reflection
+from google.protobuf import descriptor_pb2
+# @@protoc_insertion_point(imports)
+
+
+import riak.pb.riak_pb2
+
+
+DESCRIPTOR = _descriptor.FileDescriptor(
+  name='riak_kv.proto',
+  package='',
+  serialized_pb='\n\rriak_kv.proto\x1a\nriak.proto\"\'\n\x12RpbGetClientIdResp\x12\x11\n\tclient_id\x18\x01 \x02(\x0c\"&\n\x11RpbSetClientIdReq\x12\x11\n\tclient_id\x18\x01 \x02(\x0c\"\xe9\x01\n\tRpbGetReq\x12\x0e\n\x06\x62ucket\x18\x01 \x02(\x0c\x12\x0b\n\x03key\x18\x02 \x02(\x0c\x12\t\n\x01r\x18\x03 \x01(\r\x12\n\n\x02pr\x18\x04 \x01(\r\x12\x14\n\x0c\x62\x61sic_quorum\x18\x05 \x01(\x08\x12\x13\n\x0bnotfound_ok\x18\x06 \x01(\x08\x12\x13\n\x0bif_modified\x18\x07 \x01(\x0c\x12\x0c\n\x04head\x18\x08 \x01(\x08\x12\x15\n\rdeletedvclock\x18\t \x01(\x08\x12\x0f\n\x07timeout\x18\n \x01(\r\x12\x15\n\rsloppy_quorum\x18\x0b \x01(\x08\x12\r\n\x05n_val\x18\x0c \x01(\r\x12\x0c\n\x04type\x18\r \x01(\x0c\"M\n\nRpbGetResp\x12\x1c\n\x07\x63ontent\x18\x01 \x03(\x0b\x32\x0b.RpbContent\x12\x0e\n\x06vclock\x18\x02 \x01(\x0c\x12\x11\n\tunchanged\x18\x03 \x01(\x08\"\xa6\x02\n\tRpbPutReq\x12\x0e\n\x06\x62ucket\x18\x01 \x02(\x0c\x12\x0b\n\x03key\x18\x02 \x01(\x0c\x12\x0e\n\x06vclock\x18\x03 \x01(\x0c\x12\x1c\n\x07\x63ontent\x18\x04 \x02(\x0b\x32\x0b.RpbContent\x12\t\n\x01w\x18\x05 \x01(\r\x12\n\n\x02\x64w\x18\x06 \x01(\r\x12\x13\n\x0breturn_body\x18\x07 \x01(\x08\x12\n\n\x02pw\x18\x08 \x01(\r\x12\x17\n\x0fif_not_modified\x18\t \x01(\x08\x12\x15\n\rif_none_match\x18\n \x01(\x08\x12\x13\n\x0breturn_head\x18\x0b \x01(\x08\x12\x0f\n\x07timeout\x18\x0c \x01(\r\x12\x0c\n\x04\x61sis\x18\r \x01(\x08\x12\x15\n\rsloppy_quorum\x18\x0e \x01(\x08\x12\r\n\x05n_val\x18\x0f \x01(\r\x12\x0c\n\x04type\x18\x10 \x01(\x0c\"G\n\nRpbPutResp\x12\x1c\n\x07\x63ontent\x18\x01 \x03(\x0b\x32\x0b.RpbContent\x12\x0e\n\x06vclock\x18\x02 \x01(\x0c\x12\x0b\n\x03key\x18\x03 \x01(\x0c\"\xc3\x01\n\tRpbDelReq\x12\x0e\n\x06\x62ucket\x18\x01 \x02(\x0c\x12\x0b\n\x03key\x18\x02 \x02(\x0c\x12\n\n\x02rw\x18\x03 \x01(\r\x12\x0e\n\x06vclock\x18\x04 \x01(\x0c\x12\t\n\x01r\x18\x05 \x01(\r\x12\t\n\x01w\x18\x06 \x01(\r\x12\n\n\x02pr\x18\x07 \x01(\r\x12\n\n\x02pw\x18\x08 \x01(\r\x12\n\n\x02\x64w\x18\t \x01(\r\x12\x0f\n\x07timeout\x18\n \x01(\r\x12\x15\n\rsloppy_quorum\x18\x0b \x01(\x08\x12\r\n\x05n_val\x18\x0c \x01(\r\x12\x0c\n\x04type\x18\r \x01(\x0c\"B\n\x11RpbListBucketsReq\x12\x0f\n\x07timeout\x18\x01 \x01(\r\x12\x0e\n\x06stream\x18\x02 \x01(\x08\x12\x0c\n\x04type\x18\x03 \x01(\x0c\"3\n\x12RpbListBucketsResp\x12\x0f\n\x07\x62uckets\x18\x01 \x03(\x0c\x12\x0c\n\x04\x64one\x18\x02 \x01(\x08\"?\n\x0eRpbListKeysReq\x12\x0e\n\x06\x62ucket\x18\x01 \x02(\x0c\x12\x0f\n\x07timeout\x18\x02 \x01(\r\x12\x0c\n\x04type\x18\x03 \x01(\x0c\"-\n\x0fRpbListKeysResp\x12\x0c\n\x04keys\x18\x01 \x03(\x0c\x12\x0c\n\x04\x64one\x18\x02 \x01(\x08\"5\n\x0cRpbMapRedReq\x12\x0f\n\x07request\x18\x01 \x02(\x0c\x12\x14\n\x0c\x63ontent_type\x18\x02 \x02(\x0c\">\n\rRpbMapRedResp\x12\r\n\x05phase\x18\x01 \x01(\r\x12\x10\n\x08response\x18\x02 \x01(\x0c\x12\x0c\n\x04\x64one\x18\x03 \x01(\x08\"\xf9\x02\n\x0bRpbIndexReq\x12\x0e\n\x06\x62ucket\x18\x01 \x02(\x0c\x12\r\n\x05index\x18\x02 \x02(\x0c\x12*\n\x05qtype\x18\x03 \x02(\x0e\x32\x1b.RpbIndexReq.IndexQueryType\x12\x0b\n\x03key\x18\x04 \x01(\x0c\x12\x11\n\trange_min\x18\x05 \x01(\x0c\x12\x11\n\trange_max\x18\x06 \x01(\x0c\x12\x14\n\x0creturn_terms\x18\x07 \x01(\x08\x12\x0e\n\x06stream\x18\x08 \x01(\x08\x12\x13\n\x0bmax_results\x18\t \x01(\r\x12\x14\n\x0c\x63ontinuation\x18\n \x01(\x0c\x12\x0f\n\x07timeout\x18\x0b \x01(\r\x12\x0c\n\x04type\x18\x0c \x01(\x0c\x12\x12\n\nterm_regex\x18\r \x01(\x0c\x12\x17\n\x0fpagination_sort\x18\x0e \x01(\x08\x12\x15\n\rcover_context\x18\x0f \x01(\x0c\x12\x13\n\x0breturn_body\x18\x10 \x01(\x08\"#\n\x0eIndexQueryType\x12\x06\n\x02\x65q\x10\x00\x12\t\n\x05range\x10\x01\"[\n\x0cRpbIndexResp\x12\x0c\n\x04keys\x18\x01 \x03(\x0c\x12\x19\n\x07results\x18\x02 \x03(\x0b\x32\x08.RpbPair\x12\x14\n\x0c\x63ontinuation\x18\x03 \x01(\x0c\x12\x0c\n\x04\x64one\x18\x04 \x01(\x08\"X\n\x10RpbIndexBodyResp\x12 \n\x07objects\x18\x01 \x03(\x0b\x32\x0f.RpbIndexObject\x12\x14\n\x0c\x63ontinuation\x18\x02 \x01(\x0c\x12\x0c\n\x04\x64one\x18\x03 \x01(\x08\"\xd8\x01\n\x0eRpbCSBucketReq\x12\x0e\n\x06\x62ucket\x18\x01 \x02(\x0c\x12\x11\n\tstart_key\x18\x02 \x02(\x0c\x12\x0f\n\x07\x65nd_key\x18\x03 \x01(\x0c\x12\x18\n\nstart_incl\x18\x04 \x01(\x08:\x04true\x12\x17\n\x08\x65nd_incl\x18\x05 \x01(\x08:\x05\x66\x61lse\x12\x14\n\x0c\x63ontinuation\x18\x06 \x01(\x0c\x12\x13\n\x0bmax_results\x18\x07 \x01(\r\x12\x0f\n\x07timeout\x18\x08 \x01(\r\x12\x0c\n\x04type\x18\t \x01(\x0c\x12\x15\n\rcover_context\x18\n \x01(\x0c\"W\n\x0fRpbCSBucketResp\x12 \n\x07objects\x18\x01 \x03(\x0b\x32\x0f.RpbIndexObject\x12\x14\n\x0c\x63ontinuation\x18\x02 \x01(\x0c\x12\x0c\n\x04\x64one\x18\x03 \x01(\x08\":\n\x0eRpbIndexObject\x12\x0b\n\x03key\x18\x01 \x02(\x0c\x12\x1b\n\x06object\x18\x02 \x02(\x0b\x32\x0b.RpbGetResp\"\xf5\x01\n\nRpbContent\x12\r\n\x05value\x18\x01 \x02(\x0c\x12\x14\n\x0c\x63ontent_type\x18\x02 \x01(\x0c\x12\x0f\n\x07\x63harset\x18\x03 \x01(\x0c\x12\x18\n\x10\x63ontent_encoding\x18\x04 \x01(\x0c\x12\x0c\n\x04vtag\x18\x05 \x01(\x0c\x12\x17\n\x05links\x18\x06 \x03(\x0b\x32\x08.RpbLink\x12\x10\n\x08last_mod\x18\x07 \x01(\r\x12\x16\n\x0elast_mod_usecs\x18\x08 \x01(\r\x12\x1a\n\x08usermeta\x18\t \x03(\x0b\x32\x08.RpbPair\x12\x19\n\x07indexes\x18\n \x03(\x0b\x32\x08.RpbPair\x12\x0f\n\x07\x64\x65leted\x18\x0b \x01(\x08\"3\n\x07RpbLink\x12\x0e\n\x06\x62ucket\x18\x01 \x01(\x0c\x12\x0b\n\x03key\x18\x02 \x01(\x0c\x12\x0b\n\x03tag\x18\x03 \x01(\x0c\"z\n\x13RpbCounterUpdateReq\x12\x0e\n\x06\x62ucket\x18\x01 \x02(\x0c\x12\x0b\n\x03key\x18\x02 \x02(\x0c\x12\x0e\n\x06\x61mount\x18\x03 \x02(\x12\x12\t\n\x01w\x18\x04 \x01(\r\x12\n\n\x02\x64w\x18\x05 \x01(\r\x12\n\n\x02pw\x18\x06 \x01(\r\x12\x13\n\x0breturnvalue\x18\x07 \x01(\x08\"%\n\x14RpbCounterUpdateResp\x12\r\n\x05value\x18\x01 \x01(\x12\"q\n\x10RpbCounterGetReq\x12\x0e\n\x06\x62ucket\x18\x01 \x02(\x0c\x12\x0b\n\x03key\x18\x02 \x02(\x0c\x12\t\n\x01r\x18\x03 \x01(\r\x12\n\n\x02pr\x18\x04 \x01(\r\x12\x14\n\x0c\x62\x61sic_quorum\x18\x05 \x01(\x08\x12\x13\n\x0bnotfound_ok\x18\x06 \x01(\x08\"\"\n\x11RpbCounterGetResp\x12\r\n\x05value\x18\x01 \x01(\x12\"G\n\x1aRpbGetBucketKeyPreflistReq\x12\x0e\n\x06\x62ucket\x18\x01 \x02(\x0c\x12\x0b\n\x03key\x18\x02 \x02(\x0c\x12\x0c\n\x04type\x18\x03 \x01(\x0c\"J\n\x1bRpbGetBucketKeyPreflistResp\x12+\n\x08preflist\x18\x01 \x03(\x0b\x32\x19.RpbBucketKeyPreflistItem\"L\n\x18RpbBucketKeyPreflistItem\x12\x11\n\tpartition\x18\x01 \x02(\x03\x12\x0c\n\x04node\x18\x02 \x02(\x0c\x12\x0f\n\x07primary\x18\x03 \x02(\x08\"x\n\x0eRpbCoverageReq\x12\x0c\n\x04type\x18\x01 \x01(\x0c\x12\x0e\n\x06\x62ucket\x18\x02 \x02(\x0c\x12\x16\n\x0emin_partitions\x18\x03 \x01(\r\x12\x15\n\rreplace_cover\x18\x04 \x01(\x0c\x12\x19\n\x11unavailable_cover\x18\x05 \x03(\x0c\"5\n\x0fRpbCoverageResp\x12\"\n\x07\x65ntries\x18\x01 \x03(\x0b\x32\x11.RpbCoverageEntry\"Z\n\x10RpbCoverageEntry\x12\n\n\x02ip\x18\x01 \x02(\x0c\x12\x0c\n\x04port\x18\x02 \x02(\r\x12\x15\n\rkeyspace_desc\x18\x03 \x01(\x0c\x12\x15\n\rcover_context\x18\x04 \x02(\x0c\x42#\n\x17\x63om.basho.riak.protobufB\x08RiakKvPB')
+
+
+
+_RPBINDEXREQ_INDEXQUERYTYPE = _descriptor.EnumDescriptor(
+  name='IndexQueryType',
+  full_name='RpbIndexReq.IndexQueryType',
+  filename=None,
+  file=DESCRIPTOR,
+  values=[
+    _descriptor.EnumValueDescriptor(
+      name='eq', index=0, number=0,
+      options=None,
+      type=None),
+    _descriptor.EnumValueDescriptor(
+      name='range', index=1, number=1,
+      options=None,
+      type=None),
+  ],
+  containing_type=None,
+  options=None,
+  serialized_start=1688,
+  serialized_end=1723,
+)
+
+
+_RPBGETCLIENTIDRESP = _descriptor.Descriptor(
+  name='RpbGetClientIdResp',
+  full_name='RpbGetClientIdResp',
+  filename=None,
+  file=DESCRIPTOR,
+  containing_type=None,
+  fields=[
+    _descriptor.FieldDescriptor(
+      name='client_id', full_name='RpbGetClientIdResp.client_id', index=0,
+      number=1, type=12, cpp_type=9, label=2,
+      has_default_value=False, default_value="",
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+  ],
+  extensions=[
+  ],
+  nested_types=[],
+  enum_types=[
+  ],
+  options=None,
+  is_extendable=False,
+  extension_ranges=[],
+  serialized_start=29,
+  serialized_end=68,
+)
+
+
+_RPBSETCLIENTIDREQ = _descriptor.Descriptor(
+  name='RpbSetClientIdReq',
+  full_name='RpbSetClientIdReq',
+  filename=None,
+  file=DESCRIPTOR,
+  containing_type=None,
+  fields=[
+    _descriptor.FieldDescriptor(
+      name='client_id', full_name='RpbSetClientIdReq.client_id', index=0,
+      number=1, type=12, cpp_type=9, label=2,
+      has_default_value=False, default_value="",
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+  ],
+  extensions=[
+  ],
+  nested_types=[],
+  enum_types=[
+  ],
+  options=None,
+  is_extendable=False,
+  extension_ranges=[],
+  serialized_start=70,
+  serialized_end=108,
+)
+
+
+_RPBGETREQ = _descriptor.Descriptor(
+  name='RpbGetReq',
+  full_name='RpbGetReq',
+  filename=None,
+  file=DESCRIPTOR,
+  containing_type=None,
+  fields=[
+    _descriptor.FieldDescriptor(
+      name='bucket', full_name='RpbGetReq.bucket', index=0,
+      number=1, type=12, cpp_type=9, label=2,
+      has_default_value=False, default_value="",
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='key', full_name='RpbGetReq.key', index=1,
+      number=2, type=12, cpp_type=9, label=2,
+      has_default_value=False, default_value="",
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='r', full_name='RpbGetReq.r', index=2,
+      number=3, type=13, cpp_type=3, label=1,
+      has_default_value=False, default_value=0,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='pr', full_name='RpbGetReq.pr', index=3,
+      number=4, type=13, cpp_type=3, label=1,
+      has_default_value=False, default_value=0,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='basic_quorum', full_name='RpbGetReq.basic_quorum', index=4,
+      number=5, type=8, cpp_type=7, label=1,
+      has_default_value=False, default_value=False,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='notfound_ok', full_name='RpbGetReq.notfound_ok', index=5,
+      number=6, type=8, cpp_type=7, label=1,
+      has_default_value=False, default_value=False,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='if_modified', full_name='RpbGetReq.if_modified', index=6,
+      number=7, type=12, cpp_type=9, label=1,
+      has_default_value=False, default_value="",
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='head', full_name='RpbGetReq.head', index=7,
+      number=8, type=8, cpp_type=7, label=1,
+      has_default_value=False, default_value=False,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='deletedvclock', full_name='RpbGetReq.deletedvclock', index=8,
+      number=9, type=8, cpp_type=7, label=1,
+      has_default_value=False, default_value=False,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='timeout', full_name='RpbGetReq.timeout', index=9,
+      number=10, type=13, cpp_type=3, label=1,
+      has_default_value=False, default_value=0,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='sloppy_quorum', full_name='RpbGetReq.sloppy_quorum', index=10,
+      number=11, type=8, cpp_type=7, label=1,
+      has_default_value=False, default_value=False,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='n_val', full_name='RpbGetReq.n_val', index=11,
+      number=12, type=13, cpp_type=3, label=1,
+      has_default_value=False, default_value=0,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='type', full_name='RpbGetReq.type', index=12,
+      number=13, type=12, cpp_type=9, label=1,
+      has_default_value=False, default_value="",
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+  ],
+  extensions=[

riak-2.5.4.tar.gz/riak/pb/riak_pb2.py Added

@@ -0,0 +1,786 @@
+from six import *
+# Generated by the protocol buffer compiler.  DO NOT EDIT!
+# source: riak.proto
+
+from google.protobuf import descriptor as _descriptor
+from google.protobuf import message as _message
+from google.protobuf import reflection as _reflection
+from google.protobuf import descriptor_pb2
+# @@protoc_insertion_point(imports)
+
+
+
+
+DESCRIPTOR = _descriptor.FileDescriptor(
+  name='riak.proto',
+  package='',
+  serialized_pb='\n\nriak.proto\"/\n\x0cRpbErrorResp\x12\x0e\n\x06\x65rrmsg\x18\x01 \x02(\x0c\x12\x0f\n\x07\x65rrcode\x18\x02 \x02(\r\"<\n\x14RpbGetServerInfoResp\x12\x0c\n\x04node\x18\x01 \x01(\x0c\x12\x16\n\x0eserver_version\x18\x02 \x01(\x0c\"%\n\x07RpbPair\x12\x0b\n\x03key\x18\x01 \x02(\x0c\x12\r\n\x05value\x18\x02 \x01(\x0c\"/\n\x0fRpbGetBucketReq\x12\x0e\n\x06\x62ucket\x18\x01 \x02(\x0c\x12\x0c\n\x04type\x18\x02 \x01(\x0c\"2\n\x10RpbGetBucketResp\x12\x1e\n\x05props\x18\x01 \x02(\x0b\x32\x0f.RpbBucketProps\"O\n\x0fRpbSetBucketReq\x12\x0e\n\x06\x62ucket\x18\x01 \x02(\x0c\x12\x1e\n\x05props\x18\x02 \x02(\x0b\x32\x0f.RpbBucketProps\x12\x0c\n\x04type\x18\x03 \x01(\x0c\"1\n\x11RpbResetBucketReq\x12\x0e\n\x06\x62ucket\x18\x01 \x02(\x0c\x12\x0c\n\x04type\x18\x02 \x01(\x0c\"#\n\x13RpbGetBucketTypeReq\x12\x0c\n\x04type\x18\x01 \x02(\x0c\"C\n\x13RpbSetBucketTypeReq\x12\x0c\n\x04type\x18\x01 \x02(\x0c\x12\x1e\n\x05props\x18\x02 \x02(\x0b\x32\x0f.RpbBucketProps\"-\n\tRpbModFun\x12\x0e\n\x06module\x18\x01 \x02(\x0c\x12\x10\n\x08\x66unction\x18\x02 \x02(\x0c\"9\n\rRpbCommitHook\x12\x1a\n\x06modfun\x18\x01 \x01(\x0b\x32\n.RpbModFun\x12\x0c\n\x04name\x18\x02 \x01(\x0c\"\xb0\x05\n\x0eRpbBucketProps\x12\r\n\x05n_val\x18\x01 \x01(\r\x12\x12\n\nallow_mult\x18\x02 \x01(\x08\x12\x17\n\x0flast_write_wins\x18\x03 \x01(\x08\x12!\n\tprecommit\x18\x04 \x03(\x0b\x32\x0e.RpbCommitHook\x12\x1c\n\rhas_precommit\x18\x05 \x01(\x08:\x05\x66\x61lse\x12\"\n\npostcommit\x18\x06 \x03(\x0b\x32\x0e.RpbCommitHook\x12\x1d\n\x0ehas_postcommit\x18\x07 \x01(\x08:\x05\x66\x61lse\x12 \n\x0c\x63hash_keyfun\x18\x08 \x01(\x0b\x32\n.RpbModFun\x12\x1b\n\x07linkfun\x18\t \x01(\x0b\x32\n.RpbModFun\x12\x12\n\nold_vclock\x18\n \x01(\r\x12\x14\n\x0cyoung_vclock\x18\x0b \x01(\r\x12\x12\n\nbig_vclock\x18\x0c \x01(\r\x12\x14\n\x0csmall_vclock\x18\r \x01(\r\x12\n\n\x02pr\x18\x0e \x01(\r\x12\t\n\x01r\x18\x0f \x01(\r\x12\t\n\x01w\x18\x10 \x01(\r\x12\n\n\x02pw\x18\x11 \x01(\r\x12\n\n\x02\x64w\x18\x12 \x01(\r\x12\n\n\x02rw\x18\x13 \x01(\r\x12\x14\n\x0c\x62\x61sic_quorum\x18\x14 \x01(\x08\x12\x13\n\x0bnotfound_ok\x18\x15 \x01(\x08\x12\x0f\n\x07\x62\x61\x63kend\x18\x16 \x01(\x0c\x12\x0e\n\x06search\x18\x17 \x01(\x08\x12)\n\x04repl\x18\x18 \x01(\x0e\x32\x1b.RpbBucketProps.RpbReplMode\x12\x14\n\x0csearch_index\x18\x19 \x01(\x0c\x12\x10\n\x08\x64\x61tatype\x18\x1a \x01(\x0c\x12\x12\n\nconsistent\x18\x1b \x01(\x08\x12\x12\n\nwrite_once\x18\x1c \x01(\x08\">\n\x0bRpbReplMode\x12\t\n\x05\x46\x41LSE\x10\x00\x12\x0c\n\x08REALTIME\x10\x01\x12\x0c\n\x08\x46ULLSYNC\x10\x02\x12\x08\n\x04TRUE\x10\x03\",\n\nRpbAuthReq\x12\x0c\n\x04user\x18\x01 \x02(\x0c\x12\x10\n\x08password\x18\x02 \x02(\x0c\x42!\n\x17\x63om.basho.riak.protobufB\x06RiakPB')
+
+
+
+_RPBBUCKETPROPS_RPBREPLMODE = _descriptor.EnumDescriptor(
+  name='RpbReplMode',
+  full_name='RpbBucketProps.RpbReplMode',
+  filename=None,
+  file=DESCRIPTOR,
+  values=[
+    _descriptor.EnumValueDescriptor(
+      name='FALSE', index=0, number=0,
+      options=None,
+      type=None),
+    _descriptor.EnumValueDescriptor(
+      name='REALTIME', index=1, number=1,
+      options=None,
+      type=None),
+    _descriptor.EnumValueDescriptor(
+      name='FULLSYNC', index=2, number=2,
+      options=None,
+      type=None),
+    _descriptor.EnumValueDescriptor(
+      name='TRUE', index=3, number=3,
+      options=None,
+      type=None),
+  ],
+  containing_type=None,
+  options=None,
+  serialized_start=1236,
+  serialized_end=1298,
+)
+
+
+_RPBERRORRESP = _descriptor.Descriptor(
+  name='RpbErrorResp',
+  full_name='RpbErrorResp',
+  filename=None,
+  file=DESCRIPTOR,
+  containing_type=None,
+  fields=[
+    _descriptor.FieldDescriptor(
+      name='errmsg', full_name='RpbErrorResp.errmsg', index=0,
+      number=1, type=12, cpp_type=9, label=2,
+      has_default_value=False, default_value="",
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='errcode', full_name='RpbErrorResp.errcode', index=1,
+      number=2, type=13, cpp_type=3, label=2,
+      has_default_value=False, default_value=0,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+  ],
+  extensions=[
+  ],
+  nested_types=[],
+  enum_types=[
+  ],
+  options=None,
+  is_extendable=False,
+  extension_ranges=[],
+  serialized_start=14,
+  serialized_end=61,
+)
+
+
+_RPBGETSERVERINFORESP = _descriptor.Descriptor(
+  name='RpbGetServerInfoResp',
+  full_name='RpbGetServerInfoResp',
+  filename=None,
+  file=DESCRIPTOR,
+  containing_type=None,
+  fields=[
+    _descriptor.FieldDescriptor(
+      name='node', full_name='RpbGetServerInfoResp.node', index=0,
+      number=1, type=12, cpp_type=9, label=1,
+      has_default_value=False, default_value="",
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='server_version', full_name='RpbGetServerInfoResp.server_version', index=1,
+      number=2, type=12, cpp_type=9, label=1,
+      has_default_value=False, default_value="",
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+  ],
+  extensions=[
+  ],
+  nested_types=[],
+  enum_types=[
+  ],
+  options=None,
+  is_extendable=False,
+  extension_ranges=[],
+  serialized_start=63,
+  serialized_end=123,
+)
+
+
+_RPBPAIR = _descriptor.Descriptor(
+  name='RpbPair',
+  full_name='RpbPair',
+  filename=None,
+  file=DESCRIPTOR,
+  containing_type=None,
+  fields=[
+    _descriptor.FieldDescriptor(
+      name='key', full_name='RpbPair.key', index=0,
+      number=1, type=12, cpp_type=9, label=2,
+      has_default_value=False, default_value="",
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='value', full_name='RpbPair.value', index=1,
+      number=2, type=12, cpp_type=9, label=1,
+      has_default_value=False, default_value="",
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+  ],
+  extensions=[
+  ],
+  nested_types=[],
+  enum_types=[
+  ],
+  options=None,
+  is_extendable=False,
+  extension_ranges=[],
+  serialized_start=125,
+  serialized_end=162,
+)
+
+
+_RPBGETBUCKETREQ = _descriptor.Descriptor(
+  name='RpbGetBucketReq',
+  full_name='RpbGetBucketReq',
+  filename=None,
+  file=DESCRIPTOR,
+  containing_type=None,
+  fields=[
+    _descriptor.FieldDescriptor(
+      name='bucket', full_name='RpbGetBucketReq.bucket', index=0,
+      number=1, type=12, cpp_type=9, label=2,
+      has_default_value=False, default_value="",
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='type', full_name='RpbGetBucketReq.type', index=1,
+      number=2, type=12, cpp_type=9, label=1,
+      has_default_value=False, default_value="",
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+  ],
+  extensions=[
+  ],
+  nested_types=[],
+  enum_types=[
+  ],
+  options=None,
+  is_extendable=False,
+  extension_ranges=[],
+  serialized_start=164,
+  serialized_end=211,
+)
+
+
+_RPBGETBUCKETRESP = _descriptor.Descriptor(
+  name='RpbGetBucketResp',
+  full_name='RpbGetBucketResp',
+  filename=None,
+  file=DESCRIPTOR,
+  containing_type=None,
+  fields=[
+    _descriptor.FieldDescriptor(
+      name='props', full_name='RpbGetBucketResp.props', index=0,

riak-2.5.4.tar.gz/riak/pb/riak_search_pb2.py Added

@@ -0,0 +1,210 @@
+from six import *
+# Generated by the protocol buffer compiler.  DO NOT EDIT!
+# source: riak_search.proto
+
+from google.protobuf import descriptor as _descriptor
+from google.protobuf import message as _message
+from google.protobuf import reflection as _reflection
+from google.protobuf import descriptor_pb2
+# @@protoc_insertion_point(imports)
+
+
+import riak.pb.riak_pb2
+
+
+DESCRIPTOR = _descriptor.FileDescriptor(
+  name='riak_search.proto',
+  package='',
+  serialized_pb='\n\x11riak_search.proto\x1a\nriak.proto\"(\n\x0cRpbSearchDoc\x12\x18\n\x06\x66ields\x18\x01 \x03(\x0b\x32\x08.RpbPair\"\x9d\x01\n\x11RpbSearchQueryReq\x12\t\n\x01q\x18\x01 \x02(\x0c\x12\r\n\x05index\x18\x02 \x02(\x0c\x12\x0c\n\x04rows\x18\x03 \x01(\r\x12\r\n\x05start\x18\x04 \x01(\r\x12\x0c\n\x04sort\x18\x05 \x01(\x0c\x12\x0e\n\x06\x66ilter\x18\x06 \x01(\x0c\x12\n\n\x02\x64\x66\x18\x07 \x01(\x0c\x12\n\n\x02op\x18\x08 \x01(\x0c\x12\n\n\x02\x66l\x18\t \x03(\x0c\x12\x0f\n\x07presort\x18\n \x01(\x0c\"W\n\x12RpbSearchQueryResp\x12\x1b\n\x04\x64ocs\x18\x01 \x03(\x0b\x32\r.RpbSearchDoc\x12\x11\n\tmax_score\x18\x02 \x01(\x02\x12\x11\n\tnum_found\x18\x03 \x01(\rB\'\n\x17\x63om.basho.riak.protobufB\x0cRiakSearchPB')
+
+
+
+
+_RPBSEARCHDOC = _descriptor.Descriptor(
+  name='RpbSearchDoc',
+  full_name='RpbSearchDoc',
+  filename=None,
+  file=DESCRIPTOR,
+  containing_type=None,
+  fields=[
+    _descriptor.FieldDescriptor(
+      name='fields', full_name='RpbSearchDoc.fields', index=0,
+      number=1, type=11, cpp_type=10, label=3,
+      has_default_value=False, default_value=[],
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+  ],
+  extensions=[
+  ],
+  nested_types=[],
+  enum_types=[
+  ],
+  options=None,
+  is_extendable=False,
+  extension_ranges=[],
+  serialized_start=33,
+  serialized_end=73,
+)
+
+
+_RPBSEARCHQUERYREQ = _descriptor.Descriptor(
+  name='RpbSearchQueryReq',
+  full_name='RpbSearchQueryReq',
+  filename=None,
+  file=DESCRIPTOR,
+  containing_type=None,
+  fields=[
+    _descriptor.FieldDescriptor(
+      name='q', full_name='RpbSearchQueryReq.q', index=0,
+      number=1, type=12, cpp_type=9, label=2,
+      has_default_value=False, default_value="",
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='index', full_name='RpbSearchQueryReq.index', index=1,
+      number=2, type=12, cpp_type=9, label=2,
+      has_default_value=False, default_value="",
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='rows', full_name='RpbSearchQueryReq.rows', index=2,
+      number=3, type=13, cpp_type=3, label=1,
+      has_default_value=False, default_value=0,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='start', full_name='RpbSearchQueryReq.start', index=3,
+      number=4, type=13, cpp_type=3, label=1,
+      has_default_value=False, default_value=0,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='sort', full_name='RpbSearchQueryReq.sort', index=4,
+      number=5, type=12, cpp_type=9, label=1,
+      has_default_value=False, default_value="",
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='filter', full_name='RpbSearchQueryReq.filter', index=5,
+      number=6, type=12, cpp_type=9, label=1,
+      has_default_value=False, default_value="",
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='df', full_name='RpbSearchQueryReq.df', index=6,
+      number=7, type=12, cpp_type=9, label=1,
+      has_default_value=False, default_value="",
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='op', full_name='RpbSearchQueryReq.op', index=7,
+      number=8, type=12, cpp_type=9, label=1,
+      has_default_value=False, default_value="",
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='fl', full_name='RpbSearchQueryReq.fl', index=8,
+      number=9, type=12, cpp_type=9, label=3,
+      has_default_value=False, default_value=[],
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='presort', full_name='RpbSearchQueryReq.presort', index=9,
+      number=10, type=12, cpp_type=9, label=1,
+      has_default_value=False, default_value="",
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+  ],
+  extensions=[
+  ],
+  nested_types=[],
+  enum_types=[
+  ],
+  options=None,
+  is_extendable=False,
+  extension_ranges=[],
+  serialized_start=76,
+  serialized_end=233,
+)
+
+
+_RPBSEARCHQUERYRESP = _descriptor.Descriptor(
+  name='RpbSearchQueryResp',
+  full_name='RpbSearchQueryResp',
+  filename=None,
+  file=DESCRIPTOR,
+  containing_type=None,
+  fields=[
+    _descriptor.FieldDescriptor(
+      name='docs', full_name='RpbSearchQueryResp.docs', index=0,
+      number=1, type=11, cpp_type=10, label=3,
+      has_default_value=False, default_value=[],
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='max_score', full_name='RpbSearchQueryResp.max_score', index=1,
+      number=2, type=2, cpp_type=6, label=1,
+      has_default_value=False, default_value=0,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='num_found', full_name='RpbSearchQueryResp.num_found', index=2,
+      number=3, type=13, cpp_type=3, label=1,
+      has_default_value=False, default_value=0,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+  ],
+  extensions=[
+  ],
+  nested_types=[],
+  enum_types=[
+  ],
+  options=None,
+  is_extendable=False,
+  extension_ranges=[],
+  serialized_start=235,
+  serialized_end=322,
+)
+
+_RPBSEARCHDOC.fields_by_name['fields'].message_type = riak.pb.riak_pb2._RPBPAIR
+_RPBSEARCHQUERYRESP.fields_by_name['docs'].message_type = _RPBSEARCHDOC
+DESCRIPTOR.message_types_by_name['RpbSearchDoc'] = _RPBSEARCHDOC
+DESCRIPTOR.message_types_by_name['RpbSearchQueryReq'] = _RPBSEARCHQUERYREQ
+DESCRIPTOR.message_types_by_name['RpbSearchQueryResp'] = _RPBSEARCHQUERYRESP
+
+@add_metaclass(_reflection.GeneratedProtocolMessageType)
+class RpbSearchDoc(_message.Message):
+  DESCRIPTOR = _RPBSEARCHDOC
+
+  # @@protoc_insertion_point(class_scope:RpbSearchDoc)
+
+@add_metaclass(_reflection.GeneratedProtocolMessageType)
+class RpbSearchQueryReq(_message.Message):
+  DESCRIPTOR = _RPBSEARCHQUERYREQ
+
+  # @@protoc_insertion_point(class_scope:RpbSearchQueryReq)

riak-2.5.4.tar.gz/riak/pb/riak_ts_pb2.py Added

@@ -0,0 +1,915 @@
+from six import *
+# Generated by the protocol buffer compiler.  DO NOT EDIT!
+# source: riak_ts.proto
+
+from google.protobuf.internal import enum_type_wrapper
+from google.protobuf import descriptor as _descriptor
+from google.protobuf import message as _message
+from google.protobuf import reflection as _reflection
+from google.protobuf import descriptor_pb2
+# @@protoc_insertion_point(imports)
+
+
+import riak.pb.riak_pb2
+
+
+DESCRIPTOR = _descriptor.FileDescriptor(
+  name='riak_ts.proto',
+  package='',
+  serialized_pb='\n\rriak_ts.proto\x1a\nriak.proto\"[\n\nTsQueryReq\x12\x1f\n\x05query\x18\x01 \x01(\x0b\x32\x10.TsInterpolation\x12\x15\n\x06stream\x18\x02 \x01(\x08:\x05\x66\x61lse\x12\x15\n\rcover_context\x18\x03 \x01(\x0c\"^\n\x0bTsQueryResp\x12%\n\x07\x63olumns\x18\x01 \x03(\x0b\x32\x14.TsColumnDescription\x12\x14\n\x04rows\x18\x02 \x03(\x0b\x32\x06.TsRow\x12\x12\n\x04\x64one\x18\x03 \x01(\x08:\x04true\"@\n\x08TsGetReq\x12\r\n\x05table\x18\x01 \x02(\x0c\x12\x14\n\x03key\x18\x02 \x03(\x0b\x32\x07.TsCell\x12\x0f\n\x07timeout\x18\x03 \x01(\r\"H\n\tTsGetResp\x12%\n\x07\x63olumns\x18\x01 \x03(\x0b\x32\x14.TsColumnDescription\x12\x14\n\x04rows\x18\x02 \x03(\x0b\x32\x06.TsRow\"V\n\x08TsPutReq\x12\r\n\x05table\x18\x01 \x02(\x0c\x12%\n\x07\x63olumns\x18\x02 \x03(\x0b\x32\x14.TsColumnDescription\x12\x14\n\x04rows\x18\x03 \x03(\x0b\x32\x06.TsRow\"\x0b\n\tTsPutResp\"P\n\x08TsDelReq\x12\r\n\x05table\x18\x01 \x02(\x0c\x12\x14\n\x03key\x18\x02 \x03(\x0b\x32\x07.TsCell\x12\x0e\n\x06vclock\x18\x03 \x01(\x0c\x12\x0f\n\x07timeout\x18\x04 \x01(\r\"\x0b\n\tTsDelResp\"A\n\x0fTsInterpolation\x12\x0c\n\x04\x62\x61se\x18\x01 \x02(\x0c\x12 \n\x0einterpolations\x18\x02 \x03(\x0b\x32\x08.RpbPair\"@\n\x13TsColumnDescription\x12\x0c\n\x04name\x18\x01 \x02(\x0c\x12\x1b\n\x04type\x18\x02 \x02(\x0e\x32\r.TsColumnType\"\x1f\n\x05TsRow\x12\x16\n\x05\x63\x65lls\x18\x01 \x03(\x0b\x32\x07.TsCell\"{\n\x06TsCell\x12\x15\n\rvarchar_value\x18\x01 \x01(\x0c\x12\x14\n\x0csint64_value\x18\x02 \x01(\x12\x12\x17\n\x0ftimestamp_value\x18\x03 \x01(\x12\x12\x15\n\rboolean_value\x18\x04 \x01(\x08\x12\x14\n\x0c\x64ouble_value\x18\x05 \x01(\x01\"/\n\rTsListKeysReq\x12\r\n\x05table\x18\x01 \x02(\x0c\x12\x0f\n\x07timeout\x18\x02 \x01(\r\"4\n\x0eTsListKeysResp\x12\x14\n\x04keys\x18\x01 \x03(\x0b\x32\x06.TsRow\x12\x0c\n\x04\x64one\x18\x02 \x01(\x08\"q\n\rTsCoverageReq\x12\x1f\n\x05query\x18\x01 \x01(\x0b\x32\x10.TsInterpolation\x12\r\n\x05table\x18\x02 \x02(\x0c\x12\x15\n\rreplace_cover\x18\x03 \x01(\x0c\x12\x19\n\x11unavailable_cover\x18\x04 \x03(\x0c\"3\n\x0eTsCoverageResp\x12!\n\x07\x65ntries\x18\x01 \x03(\x0b\x32\x10.TsCoverageEntry\"[\n\x0fTsCoverageEntry\x12\n\n\x02ip\x18\x01 \x02(\x0c\x12\x0c\n\x04port\x18\x02 \x02(\r\x12\x15\n\rcover_context\x18\x03 \x02(\x0c\x12\x17\n\x05range\x18\x04 \x01(\x0b\x32\x08.TsRange\"\x93\x01\n\x07TsRange\x12\x12\n\nfield_name\x18\x01 \x02(\x0c\x12\x13\n\x0blower_bound\x18\x02 \x02(\x12\x12\x1d\n\x15lower_bound_inclusive\x18\x03 \x02(\x08\x12\x13\n\x0bupper_bound\x18\x04 \x02(\x12\x12\x1d\n\x15upper_bound_inclusive\x18\x05 \x02(\x08\x12\x0c\n\x04\x64\x65sc\x18\x06 \x02(\x0c*O\n\x0cTsColumnType\x12\x0b\n\x07VARCHAR\x10\x00\x12\n\n\x06SINT64\x10\x01\x12\n\n\x06\x44OUBLE\x10\x02\x12\r\n\tTIMESTAMP\x10\x03\x12\x0b\n\x07\x42OOLEAN\x10\x04\x42#\n\x17\x63om.basho.riak.protobufB\x08RiakTsPB')
+
+_TSCOLUMNTYPE = _descriptor.EnumDescriptor(
+  name='TsColumnType',
+  full_name='TsColumnType',
+  filename=None,
+  file=DESCRIPTOR,
+  values=[
+    _descriptor.EnumValueDescriptor(
+      name='VARCHAR', index=0, number=0,
+      options=None,
+      type=None),
+    _descriptor.EnumValueDescriptor(
+      name='SINT64', index=1, number=1,
+      options=None,
+      type=None),
+    _descriptor.EnumValueDescriptor(
+      name='DOUBLE', index=2, number=2,
+      options=None,
+      type=None),
+    _descriptor.EnumValueDescriptor(
+      name='TIMESTAMP', index=3, number=3,
+      options=None,
+      type=None),
+    _descriptor.EnumValueDescriptor(
+      name='BOOLEAN', index=4, number=4,
+      options=None,
+      type=None),
+  ],
+  containing_type=None,
+  options=None,
+  serialized_start=1359,
+  serialized_end=1438,
+)
+
+TsColumnType = enum_type_wrapper.EnumTypeWrapper(_TSCOLUMNTYPE)
+VARCHAR = 0
+SINT64 = 1
+DOUBLE = 2
+TIMESTAMP = 3
+BOOLEAN = 4
+
+
+
+_TSQUERYREQ = _descriptor.Descriptor(
+  name='TsQueryReq',
+  full_name='TsQueryReq',
+  filename=None,
+  file=DESCRIPTOR,
+  containing_type=None,
+  fields=[
+    _descriptor.FieldDescriptor(
+      name='query', full_name='TsQueryReq.query', index=0,
+      number=1, type=11, cpp_type=10, label=1,
+      has_default_value=False, default_value=None,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='stream', full_name='TsQueryReq.stream', index=1,
+      number=2, type=8, cpp_type=7, label=1,
+      has_default_value=True, default_value=False,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='cover_context', full_name='TsQueryReq.cover_context', index=2,
+      number=3, type=12, cpp_type=9, label=1,
+      has_default_value=False, default_value="",
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+  ],
+  extensions=[
+  ],
+  nested_types=[],
+  enum_types=[
+  ],
+  options=None,
+  is_extendable=False,
+  extension_ranges=[],
+  serialized_start=29,
+  serialized_end=120,
+)
+
+
+_TSQUERYRESP = _descriptor.Descriptor(
+  name='TsQueryResp',
+  full_name='TsQueryResp',
+  filename=None,
+  file=DESCRIPTOR,
+  containing_type=None,
+  fields=[
+    _descriptor.FieldDescriptor(
+      name='columns', full_name='TsQueryResp.columns', index=0,
+      number=1, type=11, cpp_type=10, label=3,
+      has_default_value=False, default_value=[],
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='rows', full_name='TsQueryResp.rows', index=1,
+      number=2, type=11, cpp_type=10, label=3,
+      has_default_value=False, default_value=[],
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='done', full_name='TsQueryResp.done', index=2,
+      number=3, type=8, cpp_type=7, label=1,
+      has_default_value=True, default_value=True,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+  ],
+  extensions=[
+  ],
+  nested_types=[],
+  enum_types=[
+  ],
+  options=None,
+  is_extendable=False,
+  extension_ranges=[],
+  serialized_start=122,
+  serialized_end=216,
+)
+
+
+_TSGETREQ = _descriptor.Descriptor(
+  name='TsGetReq',
+  full_name='TsGetReq',
+  filename=None,
+  file=DESCRIPTOR,
+  containing_type=None,
+  fields=[
+    _descriptor.FieldDescriptor(
+      name='table', full_name='TsGetReq.table', index=0,
+      number=1, type=12, cpp_type=9, label=2,
+      has_default_value=False, default_value="",
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='key', full_name='TsGetReq.key', index=1,
+      number=2, type=11, cpp_type=10, label=3,
+      has_default_value=False, default_value=[],
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='timeout', full_name='TsGetReq.timeout', index=2,
+      number=3, type=13, cpp_type=3, label=1,
+      has_default_value=False, default_value=0,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+  ],
+  extensions=[
+  ],
+  nested_types=[],
+  enum_types=[
+  ],
+  options=None,
+  is_extendable=False,
+  extension_ranges=[],
+  serialized_start=218,
+  serialized_end=282,
+)
+
+
+_TSGETRESP = _descriptor.Descriptor(
+  name='TsGetResp',
+  full_name='TsGetResp',
+  filename=None,
+  file=DESCRIPTOR,
+  containing_type=None,
+  fields=[
+    _descriptor.FieldDescriptor(
+      name='columns', full_name='TsGetResp.columns', index=0,
+      number=1, type=11, cpp_type=10, label=3,
+      has_default_value=False, default_value=[],

riak-2.5.4.tar.gz/riak/pb/riak_yokozuna_pb2.py Added

@@ -0,0 +1,372 @@
+from six import *
+# Generated by the protocol buffer compiler.  DO NOT EDIT!
+# source: riak_yokozuna.proto
+
+from google.protobuf import descriptor as _descriptor
+from google.protobuf import message as _message
+from google.protobuf import reflection as _reflection
+from google.protobuf import descriptor_pb2
+# @@protoc_insertion_point(imports)
+
+
+
+
+DESCRIPTOR = _descriptor.FileDescriptor(
+  name='riak_yokozuna.proto',
+  package='',
+  serialized_pb='\n\x13riak_yokozuna.proto\"?\n\x10RpbYokozunaIndex\x12\x0c\n\x04name\x18\x01 \x02(\x0c\x12\x0e\n\x06schema\x18\x02 \x01(\x0c\x12\r\n\x05n_val\x18\x03 \x01(\r\"&\n\x16RpbYokozunaIndexGetReq\x12\x0c\n\x04name\x18\x01 \x01(\x0c\";\n\x17RpbYokozunaIndexGetResp\x12 \n\x05index\x18\x01 \x03(\x0b\x32\x11.RpbYokozunaIndex\"K\n\x16RpbYokozunaIndexPutReq\x12 \n\x05index\x18\x01 \x02(\x0b\x32\x11.RpbYokozunaIndex\x12\x0f\n\x07timeout\x18\x02 \x01(\r\")\n\x19RpbYokozunaIndexDeleteReq\x12\x0c\n\x04name\x18\x01 \x02(\x0c\"2\n\x11RpbYokozunaSchema\x12\x0c\n\x04name\x18\x01 \x02(\x0c\x12\x0f\n\x07\x63ontent\x18\x02 \x01(\x0c\"=\n\x17RpbYokozunaSchemaPutReq\x12\"\n\x06schema\x18\x01 \x02(\x0b\x32\x12.RpbYokozunaSchema\"\'\n\x17RpbYokozunaSchemaGetReq\x12\x0c\n\x04name\x18\x01 \x02(\x0c\">\n\x18RpbYokozunaSchemaGetResp\x12\"\n\x06schema\x18\x01 \x02(\x0b\x32\x12.RpbYokozunaSchemaB)\n\x17\x63om.basho.riak.protobufB\x0eRiakYokozunaPB')
+
+
+
+
+_RPBYOKOZUNAINDEX = _descriptor.Descriptor(
+  name='RpbYokozunaIndex',
+  full_name='RpbYokozunaIndex',
+  filename=None,
+  file=DESCRIPTOR,
+  containing_type=None,
+  fields=[
+    _descriptor.FieldDescriptor(
+      name='name', full_name='RpbYokozunaIndex.name', index=0,
+      number=1, type=12, cpp_type=9, label=2,
+      has_default_value=False, default_value="",
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='schema', full_name='RpbYokozunaIndex.schema', index=1,
+      number=2, type=12, cpp_type=9, label=1,
+      has_default_value=False, default_value="",
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='n_val', full_name='RpbYokozunaIndex.n_val', index=2,
+      number=3, type=13, cpp_type=3, label=1,
+      has_default_value=False, default_value=0,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+  ],
+  extensions=[
+  ],
+  nested_types=[],
+  enum_types=[
+  ],
+  options=None,
+  is_extendable=False,
+  extension_ranges=[],
+  serialized_start=23,
+  serialized_end=86,
+)
+
+
+_RPBYOKOZUNAINDEXGETREQ = _descriptor.Descriptor(
+  name='RpbYokozunaIndexGetReq',
+  full_name='RpbYokozunaIndexGetReq',
+  filename=None,
+  file=DESCRIPTOR,
+  containing_type=None,
+  fields=[
+    _descriptor.FieldDescriptor(
+      name='name', full_name='RpbYokozunaIndexGetReq.name', index=0,
+      number=1, type=12, cpp_type=9, label=1,
+      has_default_value=False, default_value="",
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+  ],
+  extensions=[
+  ],
+  nested_types=[],
+  enum_types=[
+  ],
+  options=None,
+  is_extendable=False,
+  extension_ranges=[],
+  serialized_start=88,
+  serialized_end=126,
+)
+
+
+_RPBYOKOZUNAINDEXGETRESP = _descriptor.Descriptor(
+  name='RpbYokozunaIndexGetResp',
+  full_name='RpbYokozunaIndexGetResp',
+  filename=None,
+  file=DESCRIPTOR,
+  containing_type=None,
+  fields=[
+    _descriptor.FieldDescriptor(
+      name='index', full_name='RpbYokozunaIndexGetResp.index', index=0,
+      number=1, type=11, cpp_type=10, label=3,
+      has_default_value=False, default_value=[],
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+  ],
+  extensions=[
+  ],
+  nested_types=[],
+  enum_types=[
+  ],
+  options=None,
+  is_extendable=False,
+  extension_ranges=[],
+  serialized_start=128,
+  serialized_end=187,
+)
+
+
+_RPBYOKOZUNAINDEXPUTREQ = _descriptor.Descriptor(
+  name='RpbYokozunaIndexPutReq',
+  full_name='RpbYokozunaIndexPutReq',
+  filename=None,
+  file=DESCRIPTOR,
+  containing_type=None,
+  fields=[
+    _descriptor.FieldDescriptor(
+      name='index', full_name='RpbYokozunaIndexPutReq.index', index=0,
+      number=1, type=11, cpp_type=10, label=2,
+      has_default_value=False, default_value=None,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='timeout', full_name='RpbYokozunaIndexPutReq.timeout', index=1,
+      number=2, type=13, cpp_type=3, label=1,
+      has_default_value=False, default_value=0,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+  ],
+  extensions=[
+  ],
+  nested_types=[],
+  enum_types=[
+  ],
+  options=None,
+  is_extendable=False,
+  extension_ranges=[],
+  serialized_start=189,
+  serialized_end=264,
+)
+
+
+_RPBYOKOZUNAINDEXDELETEREQ = _descriptor.Descriptor(
+  name='RpbYokozunaIndexDeleteReq',
+  full_name='RpbYokozunaIndexDeleteReq',
+  filename=None,
+  file=DESCRIPTOR,
+  containing_type=None,
+  fields=[
+    _descriptor.FieldDescriptor(
+      name='name', full_name='RpbYokozunaIndexDeleteReq.name', index=0,
+      number=1, type=12, cpp_type=9, label=2,
+      has_default_value=False, default_value="",
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+  ],
+  extensions=[
+  ],
+  nested_types=[],
+  enum_types=[
+  ],
+  options=None,
+  is_extendable=False,
+  extension_ranges=[],
+  serialized_start=266,
+  serialized_end=307,
+)
+
+
+_RPBYOKOZUNASCHEMA = _descriptor.Descriptor(
+  name='RpbYokozunaSchema',
+  full_name='RpbYokozunaSchema',
+  filename=None,
+  file=DESCRIPTOR,
+  containing_type=None,
+  fields=[
+    _descriptor.FieldDescriptor(
+      name='name', full_name='RpbYokozunaSchema.name', index=0,
+      number=1, type=12, cpp_type=9, label=2,
+      has_default_value=False, default_value="",
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='content', full_name='RpbYokozunaSchema.content', index=1,
+      number=2, type=12, cpp_type=9, label=1,

riak-2.1.0.tar.gz/riak/resolver.py -> riak-2.5.4.tar.gz/riak/resolver.py Changed

riak-2.5.4.tar.gz/riak/riak_error.py Added

@@ -0,0 +1,42 @@
+"""
+Copyright 2015 Basho Technologies, Inc.
+
+This file is provided to you under the Apache License,
+Version 2.0 (the "License"); you may not use this file
+except in compliance with the License.  You may obtain
+a copy of the License at
+
+  http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing,
+software distributed under the License is distributed on an
+"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+KIND, either express or implied.  See the License for the
+specific language governing permissions and limitations
+under the License.
+"""
+
+
+class RiakError(Exception):
+    """
+    Base class for exceptions generated in the Riak API.
+    """
+    def __init__(self, *args, **kwargs):
+        super(RiakError, self).__init__(*args, **kwargs)
+        if len(args) > 0:
+            self.value = args[0]
+        else:
+            self.value = 'unknown'
+
+    def __str__(self):
+        return repr(self.value)
+
+
+class ConflictError(RiakError):
+    """
+    Raised when an operation is attempted on a
+    :class:`~riak.riak_object.RiakObject` that has more than one
+    sibling.
+    """
+    def __init__(self, message='Object in conflict'):
+        super(ConflictError, self).__init__(message)

riak-2.1.0.tar.gz/riak/riak_object.py -> riak-2.5.4.tar.gz/riak/riak_object.py Changed

@@ -1,26 +1,8 @@
-"""
-Copyright 2012-2013 Basho Technologies <dev@basho.com>
-Copyright 2010 Rusty Klophaus <rusty@basho.com>
-Copyright 2010 Justin Sheehy <justin@basho.com>
-Copyright 2009 Jay Baird <jay@mochimedia.com>
-
-This file is provided to you under the Apache License,
-Version 2.0 (the "License"); you may not use this file
-except in compliance with the License.  You may obtain
-a copy of the License at
-
-  http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing,
-software distributed under the License is distributed on an
-"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-KIND, either express or implied.  See the License for the
-specific language governing permissions and limitations
-under the License.
-"""
 from riak import ConflictError
 from riak.content import RiakContent
 import base64
+from six import string_types, PY2
+from riak.mapreduce import RiakMapReduce
 
 
 def content_property(name, doc=None):
@@ -67,15 +49,26 @@
     A representation of a vector clock received from Riak.
     """
 
-    _decoders = {
-        'base64': base64.b64decode,
-        'binary': str
-    }
-
-    _encoders = {
-        'base64': base64.b64encode,
-        'binary': str
-    }
+    if PY2:
+        _decoders = {
+            'base64': base64.b64decode,
+            'binary': str
+        }
+
+        _encoders = {
+            'base64': base64.b64encode,
+            'binary': str
+        }
+    else:
+        _decoders = {
+            'base64': base64.b64decode,
+            'binary': bytes
+        }
+
+        _encoders = {
+            'base64': base64.b64encode,
+            'binary': bytes
+        }
 
     def __init__(self, value, encoding):
         self._vclock = self._decoders[encoding].__call__(value)
@@ -109,11 +102,12 @@
          is generated by the server when :func:`store` is called.
         :type key: string
         """
-        try:
-            if isinstance(key, basestring):
-                key = key.encode('ascii')
-        except UnicodeError:
-            raise TypeError('Unicode keys are not supported.')
+        if PY2:
+            try:
+                if isinstance(key, string_types):
+                    key = key.encode('ascii')
+            except UnicodeError:
+                raise TypeError('Unicode keys are not supported.')
 
         if key is not None and len(key) == 0:
             raise ValueError('Key name must either be "None"'
@@ -345,16 +339,25 @@
         self.siblings = []
         return self
 
-    def add(self, *args):
+    def add(self, arg1, arg2=None, arg3=None, bucket_type=None):
         """
         Start assembling a Map/Reduce operation.
         A shortcut for :meth:`~riak.mapreduce.RiakMapReduce.add`.
 
+        :param arg1: the object or bucket to add
+        :type arg1: RiakObject, string
+        :param arg2: a key or list of keys to add (if a bucket is
+          given in arg1)
+        :type arg2: string, list, None
+        :param arg3: key data for this input (must be convertible to JSON)
+        :type arg3: string, list, dict, None
+        :param bucket_type: Optional name of a bucket type
+        :type bucket_type: string, None
         :rtype: :class:`~riak.mapreduce.RiakMapReduce`
         """
         mr = RiakMapReduce(self.client)
-        mr.add(self.bucket.name, self.key)
-        return mr.add(*args)
+        mr.add(self.bucket.name, self.key, bucket_type=bucket_type)
+        return mr.add(arg1, arg2, arg3, bucket_type)
 
     def link(self, *args):
         """
@@ -388,5 +391,3 @@
         mr = RiakMapReduce(self.client)
         mr.add(self.bucket.name, self.key)
         return mr.reduce(*args)
-
-from riak.mapreduce import RiakMapReduce

riak-2.1.0.tar.gz/riak/security.py -> riak-2.5.4.tar.gz/riak/security.py Changed

@@ -16,20 +16,60 @@
 under the License.
 """
 
-import OpenSSL.SSL
-from OpenSSL import crypto
+import ssl
 import warnings
 from riak import RiakError
+from riak.util import str_to_long
+
+if hasattr(ssl, 'SSLContext'):
+    # For Python >= 2.7.9 and Python 3.x
+    USE_STDLIB_SSL = True
+else:
+    # For Python 2.6 and <= 2.7.8
+    USE_STDLIB_SSL = False
+
+if not USE_STDLIB_SSL:
+    import OpenSSL.SSL
+    from OpenSSL import crypto
 
 OPENSSL_VERSION_101G = 268439679
-sslver = OpenSSL.SSL.OPENSSL_VERSION_NUMBER
-# Be sure to use at least OpenSSL 1.0.1g
-if (sslver < OPENSSL_VERSION_101G) or \
-        not hasattr(OpenSSL.SSL, 'TLSv1_2_METHOD'):
-    verstring = OpenSSL.SSL.SSLeay_version(OpenSSL.SSL.SSLEAY_VERSION)
-    msg = "Found {0} version, but expected at least OpenSSL 1.0.1g.  " \
-          "Security may not support TLS 1.2.".format(verstring)
-    warnings.warn(msg, UserWarning)
+if hasattr(ssl, 'OPENSSL_VERSION_NUMBER'):
+    # For Python 2.7 and Python 3.x
+    sslver = ssl.OPENSSL_VERSION_NUMBER
+    # Be sure to use at least OpenSSL 1.0.1g
+    tls_12 = hasattr(ssl, 'PROTOCOL_TLSv1_2')
+    if sslver < OPENSSL_VERSION_101G or not tls_12:
+        verstring = ssl.OPENSSL_VERSION
+        msg = "{0} (>= 1.0.1g required), TLS 1.2 support: {1}" \
+            .format(verstring, tls_12)
+        warnings.warn(msg, UserWarning)
+    if hasattr(ssl, 'PROTOCOL_TLSv1_2'):
+        DEFAULT_TLS_VERSION = ssl.PROTOCOL_TLSv1_2
+    elif hasattr(ssl, 'PROTOCOL_TLSv1_1'):
+        DEFAULT_TLS_VERSION = ssl.PROTOCOL_TLSv1_1
+    elif hasattr(ssl, 'PROTOCOL_TLSv1'):
+        DEFAULT_TLS_VERSION = ssl.PROTOCOL_TLSv1
+    else:
+        DEFAULT_TLS_VERSION = ssl.PROTOCOL_SSLv23
+
+else:
+    # For Python 2.6
+    sslver = OpenSSL.SSL.OPENSSL_VERSION_NUMBER
+    # Be sure to use at least OpenSSL 1.0.1g
+    tls_12 = hasattr(OpenSSL.SSL, 'TLSv1_2_METHOD')
+    if (sslver < OPENSSL_VERSION_101G) or tls_12:
+        verstring = OpenSSL.SSL.SSLeay_version(OpenSSL.SSL.SSLEAY_VERSION)
+        msg = "{0} (>= 1.0.1g required), TLS 1.2 support: {1}" \
+            .format(verstring, tls_12)
+        warnings.warn(msg, UserWarning)
+    if hasattr(OpenSSL.SSL, 'TLSv1_2_METHOD'):
+        DEFAULT_TLS_VERSION = OpenSSL.SSL.TLSv1_2_METHOD
+    elif hasattr(OpenSSL.SSL, 'TLSv1_1_METHOD'):
+        DEFAULT_TLS_VERSION = OpenSSL.SSL.TLSv1_1_METHOD
+    elif hasattr(OpenSSL.SSL, 'TLSv1_METHOD'):
+        DEFAULT_TLS_VERSION = OpenSSL.SSL.TLSv1_METHOD
+    else:
+        DEFAULT_TLS_VERSION = OpenSSL.SSL.SSLv23_METHOD
 
 
 class SecurityError(RiakError):
@@ -53,7 +93,7 @@
                  crl_file=None,
                  crl=None,
                  ciphers=None,
-                 ssl_version=OpenSSL.SSL.TLSv1_2_METHOD):
+                 ssl_version=DEFAULT_TLS_VERSION):
         """
         Container class for security-related settings
 
@@ -114,40 +154,40 @@
         return self._password
 
     @property
-    def pkey(self):
+    def pkey_file(self):
         """
-        Client Private key
+        Client Private Key file
 
-        :rtype: :class:`OpenSSL.crypto.PKey`
+        :rtype: str
         """
-        return self._cached_cert('_pkey', crypto.load_privatekey)
+        return self._pkey_file
 
     @property
-    def cert(self):
+    def cert_file(self):
         """
-        Client Certificate
+        Client Certificate file
 
-        :rtype: :class:`OpenSSL.crypto.X509`
+        :rtype: str
         """
-        return self._cached_cert('_cert', crypto.load_certificate)
+        return self._cert_file
 
     @property
-    def cacert(self):
+    def cacert_file(self):
         """
-        Certifying Authority (CA) Certificate
+        Certifying Authority (CA) Certificate file
 
-        :rtype: :class:`OpenSSL.crypto.X509`
+        :rtype: str
         """
-        return self._cached_cert('_cacert', crypto.load_certificate)
+        return self._cacert_file
 
     @property
-    def crl(self):
+    def crl_file(self):
         """
-        Certificate Revocation List
+        Certificate Revocation List file
 
-        :rtype: :class:`OpenSSL.crypto.CRL`
+        :rtype: str
         """
-        return self._cached_cert('_crl', crypto.load_crl)
+        return self._crl_file
 
     @property
     def ciphers(self):
@@ -167,51 +207,89 @@
         """
         return self._ssl_version
 
-    def _cached_cert(self, key, loader):
-        # If the key is associated with a file, then lazily load and cache it
-        key_file = getattr(self, key + "_file")
-        if (getattr(self, key) is None) and (key_file is not None):
-            cert_list = []
-            # The _file may be a list of files
-            if not isinstance(key_file, list):
-                key_file = [key_file]
-            for filename in key_file:
-                with open(filename, 'r') as f:
-                    cert_list.append(loader(OpenSSL.SSL.FILETYPE_PEM,
-                                            f.read()))
-            # If it is not a list, just store the first element
-            if len(cert_list) == 1:
-                cert_list = cert_list[0]
-            setattr(self, key, cert_list)
-        return getattr(self, key)
-
-    def _has_credential(self, key):
-        """
-        ``True`` if a credential or filename value has been supplied for the
-        given property.
-
-        :param key: which configuration property to check for
-        :type key: str
-        :rtype: bool
-        """
-        internal_key = "_" + key
-        return (getattr(self, internal_key) is not None) or \
-            (getattr(self, internal_key + "_file") is not None)
-
-    def _check_revoked_cert(self, ssl_socket):
-        """
-        Checks whether the server certificate on the passed socket has been
-        revoked by checking the CRL.
-
-        :param ssl_socket: the SSL/TLS socket
-        :rtype: bool
-        :raises SecurityError: when the certificate has been revoked
-        """
-        if not self._has_credential('crl'):
-            return True
-
-        servcert = ssl_socket.get_peer_certificate()
-        servserial = servcert.get_serial_number()
-        for rev in self.crl.get_revoked():
-            if servserial == long(rev.get_serial(), 16):
-                raise SecurityError("Server certificate has been revoked")
+    if not USE_STDLIB_SSL:
+        @property
+        def pkey(self):
+            """
+            Client Private key
+
+            :rtype: :class:`OpenSSL.crypto.PKey`
+            """
+            return self._cached_cert('_pkey', crypto.load_privatekey)
+
+        @property

riak-2.5.4.tar.gz/riak/table.py Added

@@ -0,0 +1,96 @@
+from six import string_types, PY2
+
+
+class Table(object):
+    """
+    The ``Table`` object allows you to access properties on a Riak
+    timeseries table and query timeseries data.
+    """
+    def __init__(self, client, name):
+        """
+        Returns a new ``Table`` instance.
+
+        :param client: A :class:`RiakClient <riak.client.RiakClient>`
+               instance
+        :type client: :class:`RiakClient <riak.client.RiakClient>`
+        :param name: The table's name
+        :type name: string
+        """
+        if not isinstance(name, string_types):
+            raise TypeError('Table name must be a string')
+
+        if PY2:
+            try:
+                name = name.encode('ascii')
+            except UnicodeError:
+                raise TypeError('Unicode table names are not supported.')
+
+        self._client = client
+        self.name = name
+
+    def __str__(self):
+        return self.name
+
+    def __repr__(self):
+        return self.name
+
+    def new(self, rows, columns=None):
+        """
+        A shortcut for manually instantiating a new
+        :class:`~riak.ts_object.TsObject`
+
+        :param rows: An list of lists with timeseries data
+        :type rows: list
+        :param columns: An list of Column names and types. Optional.
+        :type columns: list
+        :rtype: :class:`~riak.ts_object.TsObject`
+        """
+        from riak.ts_object import TsObject
+
+        return TsObject(self._client, self, rows, columns)
+
+    def describe(self):
+        """
+        Retrieves a timeseries table's description.
+
+        :rtype: :class:`TsObject <riak.ts_object.TsObject>`
+        """
+        return self._client.ts_describe(self)
+
+    def get(self, key):
+        """
+        Gets a value from a timeseries table.
+
+        :param key: The timeseries value's key.
+        :type key: list
+        :rtype: :class:`TsObject <riak.ts_object.TsObject>`
+        """
+        return self._client.ts_get(self, key)
+
+    def delete(self, key):
+        """
+        Deletes a value from a timeseries table.
+
+        :param key: The timeseries value's key.
+        :type key: list or dict
+        :rtype: boolean
+        """
+        return self._client.ts_delete(self, key)
+
+    def query(self, query, interpolations=None):
+        """
+        Queries a timeseries table.
+
+        :param query: The timeseries query.
+        :type query: string
+        :rtype: :class:`TsObject <riak.ts_object.TsObject>`
+        """
+        return self._client.ts_query(self, query, interpolations)
+
+    def stream_keys(self, timeout=None):
+        """
+        Streams keys from a timeseries table.
+
+        :rtype: list
+        """
+        return self._client.ts_stream_keys(self, timeout)

riak-2.1.0.tar.gz/riak/test_server.py -> riak-2.5.4.tar.gz/riak/test_server.py Changed

@@ -1,3 +1,4 @@
+from __future__ import print_function
 import os.path
 import threading
 import string
@@ -6,8 +7,10 @@
 import shutil
 import socket
 import time
+import stat
 from subprocess import Popen, PIPE
 from riak.util import deep_merge
+from six import string_types
 
 try:
     bytes
@@ -28,14 +31,14 @@
     def __eq__(self, other):
         return self.str == other
 
-    def __cmp__(self, other):
-        return cmp(self.str, other)
+    def __lt__(self, other):
+        return self.str < other
 
 
 def erlang_config(hash, depth=1):
     def printable(item):
         k, v = item
-        if isinstance(v, str):
+        if isinstance(v, string_types):
             p = '"%s"' % v
         elif isinstance(v, dict):
             p = erlang_config(v, depth + 1)
@@ -191,7 +194,7 @@
             try:
                 socket.create_connection((self._http_ip(), self._http_port()),
                                          1.0)
-            except socket.error, (value, message):
+            except IOError:
                 pass
             else:
                 listening = True
@@ -232,7 +235,9 @@
 
                     temp_bin_file.write(line)
 
-                os.fchmod(temp_bin_file.fileno(), 0755)
+                os.fchmod(temp_bin_file.fileno(),
+                          stat.S_IRWXU | stat.S_IRGRP | stat.S_IXGRP |
+                          stat.S_IROTH | stat.S_IXOTH)
 
     def write_vm_args(self):
         with open(self._vm_args_path(), 'wb') as vm_args:

riak-2.1.0.tar.gz/riak/tests/__init__.py -> riak-2.5.4.tar.gz/riak/tests/__init__.py Changed

@@ -1,4 +1,8 @@
+import logging
 import os
+import socket
+import sys
+
 from riak.test_server import TestServer
 from riak.security import SecurityCreds
 
@@ -12,57 +16,88 @@
     test_server.start()
 
 try:
-    __import__('riak_pb')
+    __import__('riak.pb')
     HAVE_PROTO = True
 except ImportError:
     HAVE_PROTO = False
 
+
+def hostname_resolves(hostname):
+    try:
+        socket.gethostbyname(hostname)
+        return 1
+    except socket.error:
+        return 0
+
+distutils_debug = os.environ.get('DISTUTILS_DEBUG', '0')
+if distutils_debug == '1':
+    logger = logging.getLogger()
+    logger.level = logging.DEBUG
+    logger.addHandler(logging.StreamHandler(sys.stdout))
+
 HOST = os.environ.get('RIAK_TEST_HOST', '127.0.0.1')
 
+PROTOCOL = os.environ.get('RIAK_TEST_PROTOCOL', 'pbc')
+
 PB_HOST = os.environ.get('RIAK_TEST_PB_HOST', HOST)
-PB_PORT = int(os.environ.get('RIAK_TEST_PB_PORT', '8087'))
+PB_PORT = int(os.environ.get('RIAK_TEST_PB_PORT', '10017'))
 
 HTTP_HOST = os.environ.get('RIAK_TEST_HTTP_HOST', HOST)
-HTTP_PORT = int(os.environ.get('RIAK_TEST_HTTP_PORT', '8098'))
+HTTP_PORT = int(os.environ.get('RIAK_TEST_HTTP_PORT', '10018'))
 
 # these ports are used to simulate errors, there shouldn't
 # be anything listening on either port.
 DUMMY_HTTP_PORT = int(os.environ.get('DUMMY_HTTP_PORT', '1023'))
 DUMMY_PB_PORT = int(os.environ.get('DUMMY_PB_PORT', '1022'))
 
-
-SKIP_SEARCH = int(os.environ.get('SKIP_SEARCH', '1'))
+RUN_BTYPES = int(os.environ.get('RUN_BTYPES', '0'))
+RUN_DATATYPES = int(os.environ.get('RUN_DATATYPES', '0'))
+RUN_CLIENT = int(os.environ.get('RUN_CLIENT', '0'))
+RUN_INDEXES = int(os.environ.get('RUN_INDEXES', '0'))
+RUN_KV = int(os.environ.get('RUN_KV', '0'))
+RUN_MAPREDUCE = int(os.environ.get('RUN_MAPREDUCE', '0'))
+RUN_POOL = int(os.environ.get('RUN_POOL', '0'))
+RUN_RESOLVE = int(os.environ.get('RUN_RESOLVE', '0'))
+RUN_SEARCH = int(os.environ.get('RUN_SEARCH', '0'))
+RUN_TIMESERIES = int(os.environ.get('RUN_TIMESERIES', '0'))
 RUN_YZ = int(os.environ.get('RUN_YZ', '0'))
 
-SKIP_INDEXES = int(os.environ.get('SKIP_INDEXES', '1'))
+RUN_SECURITY = int(os.environ.get('RUN_SECURITY', '0'))
+if RUN_SECURITY:
+    h = 'riak-test'
+    if hostname_resolves(h):
+        HOST = PB_HOST = HTTP_HOST = h
+    else:
+        raise AssertionError(
+                'RUN_SECURITY requires that the host name' +
+                ' "riak-test" resolves to the IP address of a Riak node' +
+                ' with security enabled.')
 
-SKIP_POOL = os.environ.get('SKIP_POOL')
-SKIP_RESOLVE = int(os.environ.get('SKIP_RESOLVE', '0'))
-SKIP_BTYPES = int(os.environ.get('SKIP_BTYPES', '0'))
+SECURITY_USER = os.environ.get('RIAK_TEST_SECURITY_USER', 'riakpass')
+SECURITY_PASSWD = os.environ.get('RIAK_TEST_SECURITY_PASSWD', 'Test1234')
 
-RUN_SECURITY = int(os.environ.get('RUN_SECURITY', '0'))
-SECURITY_USER = os.environ.get('RIAK_TEST_SECURITY_USER', 'testuser')
-SECURITY_PASSWD = os.environ.get('RIAK_TEST_SECURITY_PASSWD', 'testpassword')
 SECURITY_CACERT = os.environ.get('RIAK_TEST_SECURITY_CACERT',
-                                 'riak/tests/resources/ca.crt')
+                                 'tools/test-ca/certs/cacert.pem')
 SECURITY_REVOKED = os.environ.get('RIAK_TEST_SECURITY_REVOKED',
-                                  'riak/tests/resources/server.crl')
+                                  'tools/test-ca/crl/crl.pem')
 SECURITY_BAD_CERT = os.environ.get('RIAK_TEST_SECURITY_BAD_CERT',
-                                   'riak/tests/resources/bad_ca.crt')
+                                   'tools/test-ca/certs/badcert.pem')
 # Certificate-based Authentication only supported by PBC
-# N.B., username and password must both still be supplied
-SECURITY_KEY = os.environ.get('RIAK_TEST_SECURITY_KEY',
-                              'riak/tests/resources/client.key')
+SECURITY_KEY = os.environ.get(
+        'RIAK_TEST_SECURITY_KEY',
+        'tools/test-ca/private/riakuser-client-cert-key.pem')
 SECURITY_CERT = os.environ.get('RIAK_TEST_SECURITY_CERT',
-                               'riak/tests/resources/client.crt')
+                               'tools/test-ca/certs/riakuser-client-cert.pem')
 SECURITY_CERT_USER = os.environ.get('RIAK_TEST_SECURITY_CERT_USER',
-                                    'certuser')
-SECURITY_CERT_PASSWD = os.environ.get('RIAK_TEST_SECURITY_CERT_PASSWD',
-                                      'certpass')
+                                    'riakuser')
+
+SECURITY_CIPHERS = 'DHE-RSA-AES128-SHA256:DHE-RSA-AES128-SHA:' + \
+        'DHE-RSA-AES256-SHA256:DHE-RSA-AES256-SHA:AES128-SHA256:' + \
+        'AES128-SHA:AES256-SHA256:AES256-SHA:RC4-SHA'
 
 SECURITY_CREDS = None
 if RUN_SECURITY:
     SECURITY_CREDS = SecurityCreds(username=SECURITY_USER,
                                    password=SECURITY_PASSWD,
-                                   cacert_file=SECURITY_CACERT)
-SKIP_DATATYPES = int(os.environ.get('SKIP_DATATYPES', '0'))
+                                   cacert_file=SECURITY_CACERT,
+                                   ciphers=SECURITY_CIPHERS)

riak-2.5.4.tar.gz/riak/tests/base.py Added

@@ -0,0 +1,64 @@
+# -*- coding: utf-8 -*-
+import logging
+import random
+
+from riak.client import RiakClient
+from riak.tests import HOST, PROTOCOL, PB_PORT, HTTP_PORT, SECURITY_CREDS
+
+
+class IntegrationTestBase(object):
+    host = None
+    pb_port = None
+    http_port = None
+    credentials = None
+
+    @staticmethod
+    def randint():
+        return random.randint(1, 999999)
+
+    @staticmethod
+    def randname(length=12):
+        out = ''
+        for i in range(length):
+            out += chr(random.randint(ord('a'), ord('z')))
+        return out
+
+    @classmethod
+    def create_client(cls, host=None, http_port=None, pb_port=None,
+                      protocol=None, credentials=None, **kwargs):
+        host = host or HOST
+        http_port = http_port or HTTP_PORT
+        pb_port = pb_port or PB_PORT
+
+        if protocol is None:
+            if hasattr(cls, 'protocol') and (cls.protocol is not None):
+                protocol = cls.protocol
+            else:
+                protocol = PROTOCOL
+
+        cls.protocol = protocol
+
+        credentials = credentials or SECURITY_CREDS
+
+        if hasattr(cls, 'client_options'):
+            kwargs.update(cls.client_options)
+
+        logger = logging.getLogger()
+        logger.debug("RiakClient(protocol='%s', host='%s', pb_port='%d', "
+                     "http_port='%d', credentials='%s', kwargs='%s')",
+                     protocol, host, pb_port, http_port, credentials, kwargs)
+
+        return RiakClient(protocol=protocol,
+                          host=host,
+                          http_port=http_port,
+                          credentials=credentials,
+                          pb_port=pb_port,
+                          **kwargs)
+
+    def setUp(self):
+        self.bucket_name = self.randname()
+        self.key_name = self.randname()
+        self.client = self.create_client()
+
+    def tearDown(self):
+        self.client.close()

riak-2.5.4.tar.gz/riak/tests/comparison.py Added

@@ -0,0 +1,120 @@
+# -*- coding: utf-8 -*-
+from six import PY2, PY3
+import collections
+import warnings
+
+
+class Comparison(object):
+    '''
+    Provide a cross-version object comparison operator
+    since its name changed between Python 2.x and Python 3.x
+    '''
+
+    if PY3:
+        # Stolen from Python 2.7.8's unittest
+        _Mismatch = collections.namedtuple('Mismatch', 'actual expected value')
+
+        def _count_diff_all_purpose(self, actual, expected):
+            '''
+            Returns list of (cnt_act, cnt_exp, elem)
+            triples where the counts differ
+            '''
+            # elements need not be hashable
+            s, t = list(actual), list(expected)
+            m, n = len(s), len(t)
+            NULL = object()
+            result = []
+            for i, elem in enumerate(s):
+                if elem is NULL:
+                    continue
+                cnt_s = cnt_t = 0
+                for j in range(i, m):
+                    if s[j] == elem:
+                        cnt_s += 1
+                        s[j] = NULL
+                for j, other_elem in enumerate(t):
+                    if other_elem == elem:
+                        cnt_t += 1
+                        t[j] = NULL
+                if cnt_s != cnt_t:
+                    diff = self._Mismatch(cnt_s, cnt_t, elem)
+                    result.append(diff)
+
+            for i, elem in enumerate(t):
+                if elem is NULL:
+                    continue
+                cnt_t = 0
+                for j in range(i, n):
+                    if t[j] == elem:
+                        cnt_t += 1
+                        t[j] = NULL
+                diff = self._Mismatch(0, cnt_t, elem)
+                result.append(diff)
+            return result
+
+        def _count_diff_hashable(self, actual, expected):
+            '''
+            Returns list of (cnt_act, cnt_exp, elem) triples
+            where the counts differ
+            '''
+            # elements must be hashable
+            s, t = self._ordered_count(actual), self._ordered_count(expected)
+            result = []
+            for elem, cnt_s in s.items():
+                cnt_t = t.get(elem, 0)
+                if cnt_s != cnt_t:
+                    diff = self._Mismatch(cnt_s, cnt_t, elem)
+                    result.append(diff)
+            for elem, cnt_t in t.items():
+                if elem not in s:
+                    diff = self._Mismatch(0, cnt_t, elem)
+                    result.append(diff)
+            return result
+
+        def _ordered_count(self, iterable):
+            'Return dict of element counts, in the order they were first seen'
+            c = collections.OrderedDict()
+            for elem in iterable:
+                c[elem] = c.get(elem, 0) + 1
+            return c
+
+        def assertItemsEqual(self, expected_seq, actual_seq, msg=None):
+            """An unordered sequence specific comparison. It asserts that
+            actual_seq and expected_seq have the same element counts.
+            Equivalent to::
+
+                self.assertEqual(Counter(iter(actual_seq)),
+                                 Counter(iter(expected_seq)))
+
+            Asserts that each element has the same count in both sequences.
+            Example:
+                - [0, 1, 1] and [1, 0, 1] compare equal.
+                - [0, 0, 1] and [0, 1] compare unequal.
+            """
+            first_seq, second_seq = list(expected_seq), list(actual_seq)
+            with warnings.catch_warnings():
+                try:
+                    first = collections.Counter(first_seq)
+                    second = collections.Counter(second_seq)
+                except TypeError:
+                    # Handle case with unhashable elements
+                    differences = self._count_diff_all_purpose(first_seq,
+                                                               second_seq)
+                else:
+                    if first == second:
+                        return
+                    differences = self._count_diff_hashable(first_seq,
+                                                            second_seq)
+
+            if differences:
+                standardMsg = 'Element counts were not equal:\n'
+                lines = ['First has %d, Second has %d:  %r' %
+                         diff for diff in differences]
+                diffMsg = '\n'.join(lines)
+                standardMsg = self._truncateMessage(standardMsg, diffMsg)
+
+    def assert_raises_regex(self, exception, regexp):
+        if PY2:
+            return self.assertRaisesRegexp(exception, regexp)
+        else:
+            return self.assertRaisesRegex(exception, regexp)

riak-2.1.0.tar.gz/riak/tests/pool-grinder.py -> riak-2.5.4.tar.gz/riak/tests/pool-grinder.py Changed

@@ -1,12 +1,34 @@
 #!/usr/bin/env python
-
-from Queue import Queue
+"""
+Copyright 2015 Basho Technologies, Inc.
+
+This file is provided to you under the Apache License,
+Version 2.0 (the "License"); you may not use this file
+except in compliance with the License.  You may obtain
+a copy of the License at
+
+  http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing,
+software distributed under the License is distributed on an
+"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+KIND, either express or implied.  See the License for the
+specific language governing permissions and limitations
+under the License.
+"""
+
+from __future__ import print_function
+from six import PY2
 from threading import Thread
 import sys
-sys.path.append("../transports/")
 from pool import Pool
 from random import SystemRandom
 from time import sleep
+if PY2:
+    from Queue import Queue
+else:
+    from queue import Queue
+sys.path.append("../transports/")
 
 
 class SimplePool(Pool):
@@ -42,7 +64,7 @@
             started.join()
             a.append(rand.uniform(0, 1))
             if psleep > 1:
-                print psleep
+                print(psleep)
             sleep(psleep)
 
     for i in range(n):
@@ -61,7 +83,7 @@
         thr.join()
 
     if set(pool.elements) != set(touched):
-        print set(pool.elements) - set(touched)
+        print(set(pool.elements) - set(touched))
         return False
     else:
         return True
@@ -71,24 +93,24 @@
 while ret:
     ret = test()
     count += 1
-    print count
+    print(count)
 
 
 # INSTRUMENTED FUNCTION
 
 #     def __claim_elements(self):
-#         #print 'waiting for self lock'
+#         #print('waiting for self lock')
 #         with self.lock:
 #             if self.__all_claimed(): # and self.unlocked:
-#                 #print 'waiting on releaser lock'
+#                 #print('waiting on releaser lock')
 #                 with self.releaser:
-#                     print 'waiting for release'
-#                     print 'targets', self.targets
-#                     print 'tomb', self.targets[0].tomb
-#                     print 'claimed', self.targets[0].claimed
-#                     print self.releaser
-#                     print self.lock
-#                     print self.unlocked
+#                     print('waiting for release'')
+#                     print('targets', self.targets)
+#                     print('tomb', self.targets[0].tomb)
+#                     print('claimed', self.targets[0].claimed)
+#                     print(self.releaser)
+#                     print(self.lock)
+#                     print(self.unlocked)
 #                     self.releaser.wait(1)
 #             for element in self.targets:
 #                 if element.tomb:

riak-2.1.0.tar.gz/riak/tests/suite.py -> riak-2.5.4.tar.gz/riak/tests/suite.py Changed

riak-2.1.0.tar.gz/riak/tests/test_2i.py -> riak-2.5.4.tar.gz/riak/tests/test_2i.py Changed

@@ -1,15 +1,12 @@
 # -*- coding: utf-8 -*-
-import platform
-if platform.python_version() < '2.7':
-    unittest = __import__('unittest2')
-else:
-    import unittest
+import unittest
 
 from riak import RiakError
-from . import SKIP_INDEXES
+from riak.tests import RUN_INDEXES
+from riak.tests.base import IntegrationTestBase
 
 
-class TwoITests(object):
+class TwoITests(IntegrationTestBase, unittest.TestCase):
     def is_2i_supported(self):
         # Immediate test to see if 2i is even supported w/ the backend
         try:
@@ -20,7 +17,7 @@
                 return False
             return True  # it failed, but is supported!
 
-    @unittest.skipIf(SKIP_INDEXES, 'SKIP_INDEXES is defined')
+    @unittest.skipUnless(RUN_INDEXES, 'RUN_INDEXES is 0')
     def test_secondary_index_store(self):
         if not self.is_2i_supported():
             raise unittest.SkipTest("2I not supported")
@@ -101,7 +98,7 @@
         # Clean up...
         bucket.get('mykey1').delete()
 
-    @unittest.skipIf(SKIP_INDEXES, 'SKIP_INDEXES is defined')
+    @unittest.skipUnless(RUN_INDEXES, 'RUN_INDEXES is 0')
     def test_set_indexes(self):
         if not self.is_2i_supported():
             raise unittest.SkipTest("2I not supported")
@@ -119,7 +116,7 @@
         self.assertEqual(1, len(result))
         self.assertEqual('foo', str(result[0]))
 
-    @unittest.skipIf(SKIP_INDEXES, 'SKIP_INDEXES is defined')
+    @unittest.skipUnless(RUN_INDEXES, 'RUN_INDEXES is 0')
     def test_remove_indexes(self):
         if not self.is_2i_supported():
             raise unittest.SkipTest("2I not supported")
@@ -179,7 +176,7 @@
         self.assertEqual(1, len([x for x in bar.indexes
                                  if x[0] == 'baz_bin']))
 
-    @unittest.skipIf(SKIP_INDEXES, 'SKIP_INDEXES is defined')
+    @unittest.skipUnless(RUN_INDEXES, 'RUN_INDEXES is 0')
     def test_secondary_index_query(self):
         if not self.is_2i_supported():
             raise unittest.SkipTest("2I not supported")
@@ -188,27 +185,27 @@
 
         # Test an equality query...
         results = bucket.get_index('field1_bin', 'val2')
-        self.assertEquals(1, len(results))
-        self.assertEquals(o2.key, str(results[0]))
+        self.assertEqual(1, len(results))
+        self.assertEqual(o2.key, str(results[0]))
 
         # Test a range query...
         results = bucket.get_index('field1_bin', 'val2', 'val4')
         vals = set([str(key) for key in results])
-        self.assertEquals(3, len(results))
-        self.assertEquals(set([o2.key, o3.key, o4.key]), vals)
+        self.assertEqual(3, len(results))
+        self.assertEqual(set([o2.key, o3.key, o4.key]), vals)
 
         # Test an equality query...
         results = bucket.get_index('field2_int', 1002)
-        self.assertEquals(1, len(results))
-        self.assertEquals(o2.key, str(results[0]))
+        self.assertEqual(1, len(results))
+        self.assertEqual(o2.key, str(results[0]))
 
         # Test a range query...
         results = bucket.get_index('field2_int', 1002, 1004)
         vals = set([str(key) for key in results])
-        self.assertEquals(3, len(results))
-        self.assertEquals(set([o2.key, o3.key, o4.key]), vals)
+        self.assertEqual(3, len(results))
+        self.assertEqual(set([o2.key, o3.key, o4.key]), vals)
 
-    @unittest.skipIf(SKIP_INDEXES, 'SKIP_INDEXES is defined')
+    @unittest.skipUnless(RUN_INDEXES, 'RUN_INDEXES is 0')
     def test_secondary_index_invalid_name(self):
         if not self.is_2i_supported():
             raise unittest.SkipTest("2I not supported")
@@ -218,7 +215,7 @@
         with self.assertRaises(RiakError):
             bucket.new('k', 'a').add_index('field1', 'value1')
 
-    @unittest.skipIf(SKIP_INDEXES, 'SKIP_INDEX is defined')
+    @unittest.skipUnless(RUN_INDEXES, 'RUN_INDEXES is 0')
     def test_set_index(self):
         if not self.is_2i_supported():
             raise unittest.SkipTest("2I not supported")
@@ -236,7 +233,7 @@
         obj.set_index('bar2_int', 10)
         self.assertEqual(set((('bar_int', 3), ('bar2_int', 10))), obj.indexes)
 
-    @unittest.skipIf(SKIP_INDEXES, 'SKIP_INDEX is defined')
+    @unittest.skipUnless(RUN_INDEXES, 'RUN_INDEXES is 0')
     def test_stream_index(self):
         if not self.is_2i_supported():
             raise unittest.SkipTest("2I not supported")
@@ -249,7 +246,7 @@
 
         self.assertEqual(sorted([o1.key, o2.key, o3.key]), sorted(keys))
 
-    @unittest.skipIf(SKIP_INDEXES, 'SKIP_INDEX is defined')
+    @unittest.skipUnless(RUN_INDEXES, 'RUN_INDEXES is 0')
     def test_index_return_terms(self):
         if not self.is_2i_supported():
             raise unittest.SkipTest("2I is not supported")
@@ -273,7 +270,7 @@
         self.assertEqual([(1002, o2.key), (1003, o3.key), (1004, o4.key)],
                          sorted(spairs))
 
-    @unittest.skipIf(SKIP_INDEXES, 'SKIP_INDEX is defined')
+    @unittest.skipUnless(RUN_INDEXES, 'RUN_INDEXES is 0')
     def test_index_pagination(self):
         if not self.is_2i_supported():
             raise unittest.SkipTest("2I is not supported")
@@ -308,7 +305,7 @@
         self.assertEqual(3, pagecount)
         self.assertEqual([o1.key, o2.key, o3.key, o4.key], presults)
 
-    @unittest.skipIf(SKIP_INDEXES, 'SKIP_INDEX is defined')
+    @unittest.skipUnless(RUN_INDEXES, 'RUN_INDEXES is 0')
     def test_index_pagination_return_terms(self):
         if not self.is_2i_supported():
             raise unittest.SkipTest("2I is not supported")
@@ -333,7 +330,7 @@
         self.assertLessEqual(2, len(results))
         self.assertEqual([('val3', o3.key), ('val4', o4.key)], page2)
 
-    @unittest.skipIf(SKIP_INDEXES, 'SKIP_INDEX is defined')
+    @unittest.skipUnless(RUN_INDEXES, 'RUN_INDEXES is 0')
     def test_index_pagination_stream(self):
         if not self.is_2i_supported():
             raise unittest.SkipTest("2I is not supported")
@@ -376,7 +373,7 @@
         self.assertEqual(3, pagecount)
         self.assertEqual([o1.key, o2.key, o3.key, o4.key], presults)
 
-    @unittest.skipIf(SKIP_INDEXES, 'SKIP_INDEX is defined')
+    @unittest.skipUnless(RUN_INDEXES, 'RUN_INDEXES is 0')
     def test_index_pagination_stream_return_terms(self):
         if not self.is_2i_supported():
             raise unittest.SkipTest("2I is not supported")
@@ -408,7 +405,7 @@
         self.assertLessEqual(2, len(results))
         self.assertEqual([('val3', o3.key), ('val4', o4.key)], results)
 
-    @unittest.skipIf(SKIP_INDEXES, 'SKIP_INDEX is defined')
+    @unittest.skipUnless(RUN_INDEXES, 'RUN_INDEXES is 0')
     def test_index_eq_query_return_terms(self):
         if not self.is_2i_supported():
             raise unittest.SkipTest("2I is not supported")
@@ -418,7 +415,7 @@
         results = bucket.get_index('field2_int', 1001, return_terms=True)
         self.assertEqual([(1001, o1.key)], results)
 
-    @unittest.skipIf(SKIP_INDEXES, 'SKIP_INDEX is defined')
+    @unittest.skipUnless(RUN_INDEXES, 'RUN_INDEXES is 0')
     def test_index_eq_query_stream_return_terms(self):
         if not self.is_2i_supported():
             raise unittest.SkipTest("2I is not supported")
@@ -431,25 +428,26 @@
 
         self.assertEqual([(1001, o1.key)], results)
 
-    @unittest.skipIf(SKIP_INDEXES, 'SKIP_INDEX is defined')
+    @unittest.skipUnless(RUN_INDEXES, 'RUN_INDEXES is 0')
     def test_index_timeout(self):
         if not self.is_2i_supported():
             raise unittest.SkipTest("2I is not supported")
 
         bucket, o1, o2, o3, o4 = self._create_index_objects()
 
-        with self.assertRaises(RiakError):
-            bucket.get_index('field1_bin', 'val1', timeout=1)
-
-        with self.assertRaises(RiakError):
-            for i in bucket.stream_index('field1_bin', 'val1', timeout=1):
-                pass
+        # Disable timeouts since they are too racy
+        # with self.assertRaises(RiakError):
+        #        bucket.get_index('field1_bin', 'val1', timeout=1)
+        #
+        #     with self.assertRaises(RiakError):
+        #        for i in bucket.stream_index('field1_bin', 'val1', timeout=1):
+        #             pass

riak-2.1.0.tar.gz/riak/tests/test_btypes.py -> riak-2.5.4.tar.gz/riak/tests/test_btypes.py Changed

@@ -1,16 +1,14 @@
-import platform
+import unittest
 
-if platform.python_version() < '2.7':
-    unittest = __import__('unittest2')
-else:
-    import unittest
-
-from . import SKIP_BTYPES
-from riak.bucket import RiakBucket, BucketType
 from riak import RiakError, RiakObject
+from riak.bucket import RiakBucket, BucketType
+from riak.tests import RUN_BTYPES
+from riak.tests.base import IntegrationTestBase
+from riak.tests.comparison import Comparison
 
 
-class BucketTypeTests(object):
+@unittest.skipUnless(RUN_BTYPES, "RUN_BTYPES is 0")
+class BucketTypeTests(IntegrationTestBase, unittest.TestCase, Comparison):
     def test_btype_init(self):
         btype = self.client.bucket_type('foo')
         self.assertIsInstance(btype, BucketType)
@@ -40,10 +38,9 @@
         self.assertEqual("<BucketType 'default'>", repr(defbtype))
         self.assertEqual("<BucketType 'foo'>", repr(othertype))
 
-    @unittest.skipIf(SKIP_BTYPES == '1', "SKIP_BTYPES is set")
     def test_btype_get_props(self):
         defbtype = self.client.bucket_type("default")
-        btype = self.client.bucket_type("pytest")
+        btype = self.client.bucket_type('no_siblings')
         with self.assertRaises(ValueError):
             defbtype.get_properties()
 
@@ -52,10 +49,9 @@
         self.assertIn('n_val', props)
         self.assertEqual(3, props['n_val'])
 
-    @unittest.skipIf(SKIP_BTYPES == '1', "SKIP_BTYPES is set")
     def test_btype_set_props(self):
         defbtype = self.client.bucket_type("default")
-        btype = self.client.bucket_type("pytest")
+        btype = self.client.bucket_type('no_siblings')
         with self.assertRaises(ValueError):
             defbtype.set_properties({'allow_mult': True})
 
@@ -71,15 +67,13 @@
         finally:
             btype.set_properties(oldprops)
 
-    @unittest.skipIf(SKIP_BTYPES == '1', "SKIP_BTYPES is set")
     def test_btype_set_props_immutable(self):
-        btype = self.client.bucket_type("pytest-maps")
+        btype = self.client.bucket_type("maps")
         with self.assertRaises(RiakError):
             btype.set_property('datatype', 'counter')
 
-    @unittest.skipIf(SKIP_BTYPES == '1', "SKIP_BTYPES is set")
     def test_btype_list_buckets(self):
-        btype = self.client.bucket_type("pytest")
+        btype = self.client.bucket_type('no_siblings')
         bucket = btype.bucket(self.bucket_name)
         obj = bucket.new(self.key_name)
         obj.data = [1, 2, 3]
@@ -92,9 +86,8 @@
 
         self.assertIn(bucket, buckets)
 
-    @unittest.skipIf(SKIP_BTYPES == '1', "SKIP_BTYPES is set")
     def test_btype_list_keys(self):
-        btype = self.client.bucket_type("pytest")
+        btype = self.client.bucket_type('no_siblings')
         bucket = btype.bucket(self.bucket_name)
 
         obj = bucket.new(self.key_name)
@@ -108,7 +101,6 @@
 
         self.assertIn(self.key_name, keys)
 
-    @unittest.skipIf(SKIP_BTYPES == '1', "SKIP_BTYPES is set")
     def test_default_btype_list_buckets(self):
         default_btype = self.client.bucket_type("default")
         bucket = default_btype.bucket(self.bucket_name)
@@ -125,7 +117,6 @@
 
         self.assertItemsEqual(buckets, self.client.get_buckets())
 
-    @unittest.skipIf(SKIP_BTYPES == '1', "SKIP_BTYPES is set")
     def test_default_btype_list_keys(self):
         btype = self.client.bucket_type("default")
         bucket = btype.bucket(self.bucket_name)
@@ -144,9 +135,8 @@
         oldapikeys = self.client.get_keys(self.client.bucket(self.bucket_name))
         self.assertItemsEqual(keys, oldapikeys)
 
-    @unittest.skipIf(SKIP_BTYPES == '1', "SKIP_BTYPES is set")
     def test_multiget_bucket_types(self):
-        btype = self.client.bucket_type('pytest')
+        btype = self.client.bucket_type('no_siblings')
         bucket = btype.bucket(self.bucket_name)
 
         for i in range(100):
@@ -159,3 +149,27 @@
             self.assertIsInstance(mobj, RiakObject)
             self.assertEqual(bucket, mobj.bucket)
             self.assertEqual(btype, mobj.bucket.bucket_type)
+
+    def test_write_once_bucket_type(self):
+        bt = 'write_once'
+        skey = 'write_once-init'
+        btype = self.client.bucket_type(bt)
+        bucket = btype.bucket(bt)
+        sobj = bucket.get(skey)
+        if not sobj.exists:
+            for i in range(100):
+                o = bucket.new(self.key_name + str(i))
+                o.data = {'id': i}
+                o.store()
+            o = bucket.new(skey, data={'id': skey})
+            o.store()
+
+        mget = bucket.multiget([self.key_name + str(i) for i in range(100)])
+        for mobj in mget:
+            self.assertIsInstance(mobj, RiakObject)
+            self.assertEqual(bucket, mobj.bucket)
+            self.assertEqual(btype, mobj.bucket.bucket_type)
+
+        props = btype.get_properties()
+        self.assertIn('write_once', props)
+        self.assertEqual(True, props['write_once'])

riak-2.5.4.tar.gz/riak/tests/test_client.py Added

@@ -0,0 +1,322 @@
+import unittest
+
+from six import PY2
+from threading import Thread
+from riak.riak_object import RiakObject
+from riak.transports.tcp import TcpTransport
+from riak.tests import DUMMY_HTTP_PORT, DUMMY_PB_PORT, \
+        RUN_POOL, RUN_CLIENT
+from riak.tests.base import IntegrationTestBase
+
+if PY2:
+    from Queue import Queue
+else:
+    from queue import Queue
+
+
+@unittest.skipUnless(RUN_CLIENT, 'RUN_CLIENT is 0')
+class ClientTests(IntegrationTestBase, unittest.TestCase):
+    def test_can_set_tcp_keepalive(self):
+        if self.protocol == 'pbc':
+            topts = {'socket_keepalive': True}
+            c = self.create_client(transport_options=topts)
+            for i, r in enumerate(c._tcp_pool.resources):
+                self.assertIsInstance(r, TcpTransport)
+                self.assertTrue(r._socket_keepalive)
+            c.close()
+        else:
+            pass
+
+    def test_uses_client_id_if_given(self):
+        if self.protocol == 'pbc':
+            zero_client_id = "\0\0\0\0"
+            c = self.create_client(client_id=zero_client_id)
+            self.assertEqual(zero_client_id, c.client_id)
+            c.close()
+        else:
+            pass
+
+    def test_request_retries(self):
+        # We guess at some ports that will be unused by Riak or
+        # anything else.
+        client = self.create_client(http_port=DUMMY_HTTP_PORT,
+                                    pb_port=DUMMY_PB_PORT)
+
+        # If retries are exhausted, the final result should also be an
+        # error.
+        self.assertRaises(IOError, client.ping)
+        client.close()
+
+    def test_request_retries_configurable(self):
+        # We guess at some ports that will be unused by Riak or
+        # anything else.
+        client = self.create_client(http_port=DUMMY_HTTP_PORT,
+                                    pb_port=DUMMY_PB_PORT)
+
+        # Change the retry count
+        client.retries = 10
+        self.assertEqual(10, client.retries)
+
+        # The retry count should be a thread local
+        retries = Queue()
+
+        def _target():
+            retries.put(client.retries)
+            retries.join()
+
+        th = Thread(target=_target)
+        th.start()
+        self.assertEqual(3, retries.get(block=True))
+        retries.task_done()
+        th.join()
+
+        # Modify the retries in a with statement
+        with client.retry_count(5):
+            self.assertEqual(5, client.retries)
+            self.assertRaises(IOError, client.ping)
+        client.close()
+
+    def test_timeout_validation(self):
+        bucket = self.client.bucket(self.bucket_name)
+        key = self.key_name
+        obj = bucket.new(key)
+        for bad in [0, -1, False, "foo"]:
+            with self.assertRaises(ValueError):
+                self.client.get_buckets(timeout=bad)
+
+            with self.assertRaises(ValueError):
+                for i in self.client.stream_buckets(timeout=bad):
+                    pass
+
+            with self.assertRaises(ValueError):
+                self.client.get_keys(bucket, timeout=bad)
+
+            with self.assertRaises(ValueError):
+                for i in self.client.stream_keys(bucket, timeout=bad):
+                    pass
+
+            with self.assertRaises(ValueError):
+                self.client.put(obj, timeout=bad)
+
+            with self.assertRaises(ValueError):
+                self.client.get(obj, timeout=bad)
+
+            with self.assertRaises(ValueError):
+                self.client.delete(obj, timeout=bad)
+
+            with self.assertRaises(ValueError):
+                self.client.mapred([], [], bad)
+
+            with self.assertRaises(ValueError):
+                for i in self.client.stream_mapred([], [], bad):
+                    pass
+
+            with self.assertRaises(ValueError):
+                self.client.get_index(bucket, 'field1_bin', 'val1', 'val4',
+                                      timeout=bad)
+
+            with self.assertRaises(ValueError):
+                for i in self.client.stream_index(bucket, 'field1_bin', 'val1',
+                                                  'val4', timeout=bad):
+                    pass
+
+    def test_multiget_bucket(self):
+        """
+        Multiget operations can be invoked on buckets.
+        """
+        keys = [self.key_name, self.randname(), self.randname()]
+        for key in keys:
+            if PY2:
+                self.client.bucket(self.bucket_name)\
+                    .new(key, encoded_data=key, content_type="text/plain")\
+                    .store()
+            else:
+                self.client.bucket(self.bucket_name)\
+                    .new(key, data=key,
+                         content_type="text/plain").store()
+        results = self.client.bucket(self.bucket_name).multiget(keys)
+        for obj in results:
+            self.assertIsInstance(obj, RiakObject)
+            self.assertTrue(obj.exists)
+            if PY2:
+                self.assertEqual(obj.key, obj.encoded_data)
+            else:
+                self.assertEqual(obj.key, obj.data)
+
+    def test_multiget_errors(self):
+        """
+        Unrecoverable errors are captured along with the bucket/key
+        and not propagated.
+        """
+        keys = [self.key_name, self.randname(), self.randname()]
+        client = self.create_client(http_port=DUMMY_HTTP_PORT,
+                                    pb_port=DUMMY_PB_PORT)
+        results = client.bucket(self.bucket_name).multiget(keys)
+        for failure in results:
+            self.assertIsInstance(failure, tuple)
+            self.assertEqual(failure[0], 'default')
+            self.assertEqual(failure[1], self.bucket_name)
+            self.assertIn(failure[2], keys)
+            if PY2:
+                self.assertIsInstance(failure[3], StandardError)  # noqa
+            else:
+                self.assertIsInstance(failure[3], Exception)
+        client.close()
+
+    def test_multiput_errors(self):
+        """
+        Unrecoverable errors are captured along with the bucket/key
+        and not propagated.
+        """
+        client = self.create_client(http_port=DUMMY_HTTP_PORT,
+                                    pb_port=DUMMY_PB_PORT)
+        bucket = client.bucket(self.bucket_name)
+        k1 = self.randname()
+        k2 = self.randname()
+        o1 = RiakObject(client, bucket, k1)
+        o2 = RiakObject(client, bucket, k2)
+
+        if PY2:
+            o1.encoded_data = k1
+            o2.encoded_data = k2
+        else:
+            o1.data = k1
+            o2.data = k2
+
+        objs = [o1, o2]
+        for robj in objs:
+            robj.content_type = 'text/plain'
+
+        results = client.multiput(objs, return_body=True)
+        for failure in results:
+            self.assertIsInstance(failure, tuple)
+            self.assertIsInstance(failure[0], RiakObject)
+            if PY2:
+                self.assertIsInstance(failure[1], StandardError)  # noqa
+            else:
+                self.assertIsInstance(failure[1], Exception)
+        client.close()
+

riak-2.1.0.tar.gz/riak/tests/test_comparison.py -> riak-2.5.4.tar.gz/riak/tests/test_comparison.py Changed

@@ -1,13 +1,9 @@
-import platform
-
-if platform.python_version() < '2.7':
-    unittest = __import__('unittest2')
-else:
-    import unittest
+# -*- coding: utf-8 -*-
+import unittest
 
 from riak.riak_object import RiakObject
 from riak.bucket import RiakBucket, BucketType
-from riak.tests.test_all import BaseTestCase
+from riak.tests.base import IntegrationTestBase
 
 
 class BucketTypeRichComparisonTest(unittest.TestCase):
@@ -136,12 +132,14 @@
         self.assertIsNone(b, 'empty object key not allowed')
 
 
-class RiakClientComparisonTest(unittest.TestCase, BaseTestCase):
+class RiakClientComparisonTest(IntegrationTestBase, unittest.TestCase):
     def test_client_eq(self):
         self.protocol = 'http'
         a = self.create_client(host='host1', http_port=11)
         b = self.create_client(host='host1', http_port=11)
         self.assertEqual(a, b)
+        a.close()
+        b.close()
 
     def test_client_nq(self):
         self.protocol = 'http'
@@ -150,6 +148,9 @@
         c = self.create_client(host='host1', http_port=12)
         self.assertNotEqual(a, b, 'matched with different hosts')
         self.assertNotEqual(a, c, 'matched with different ports')
+        a.close()
+        b.close()
+        c.close()
 
     def test_client_hash(self):
         self.protocol = 'http'
@@ -158,6 +159,9 @@
         c = self.create_client(host='host2', http_port=11)
         self.assertEqual(hash(a), hash(b), 'same object has different hashes')
         self.assertNotEqual(hash(a), hash(c), 'different object has same hash')
+        a.close()
+        b.close()
+        c.close()
 
 if __name__ == '__main__':
     unittest.main()

riak-2.1.0.tar.gz/riak/tests/test_datatypes.py -> riak-2.5.4.tar.gz/riak/tests/test_datatypes.py Changed

@@ -1,16 +1,14 @@
 # -*- coding: utf-8 -*-
-import platform
-if platform.python_version() < '2.7':
-    unittest = __import__('unittest2')
-else:
-    import unittest
-
-from riak import RiakBucket, BucketType
+import unittest
 import riak.datatypes as datatypes
-from . import SKIP_DATATYPES
+
+from riak import RiakBucket, BucketType, RiakObject
+from riak.tests import RUN_DATATYPES
+from riak.tests.base import IntegrationTestBase
+from riak.tests.comparison import Comparison
 
 
-class DatatypeUnitTests(object):
+class DatatypeUnitTestBase(object):
     dtype = None
     bucket = RiakBucket(None, 'test', BucketType(None, 'datatypes'))
 
@@ -48,8 +46,7 @@
         self.check_op_output(op)
 
 
-class FlagUnitTests(DatatypeUnitTests,
-                    unittest.TestCase):
+class FlagUnitTests(DatatypeUnitTestBase, unittest.TestCase):
     dtype = datatypes.Flag
 
     def op(self, dtype):
@@ -68,8 +65,7 @@
         self.assertTrue(dtype.modified)
 
 
-class RegisterUnitTests(DatatypeUnitTests,
-                        unittest.TestCase):
+class RegisterUnitTests(DatatypeUnitTestBase, unittest.TestCase):
     dtype = datatypes.Register
 
     def op(self, dtype):
@@ -79,8 +75,7 @@
         self.assertEqual(('assign', 'foobarbaz'), op)
 
 
-class CounterUnitTests(DatatypeUnitTests,
-                       unittest.TestCase):
+class CounterUnitTests(DatatypeUnitTestBase, unittest.TestCase):
     dtype = datatypes.Counter
 
     def op(self, dtype):
@@ -90,8 +85,7 @@
         self.assertEqual(('increment', 5), op)
 
 
-class SetUnitTests(DatatypeUnitTests,
-                   unittest.TestCase):
+class SetUnitTests(DatatypeUnitTestBase, unittest.TestCase, Comparison):
     dtype = datatypes.Set
 
     def op(self, dtype):
@@ -116,8 +110,7 @@
         self.assertTrue(dtype.modified)
 
 
-class MapUnitTests(DatatypeUnitTests,
-                   unittest.TestCase):
+class MapUnitTests(DatatypeUnitTestBase, unittest.TestCase):
     dtype = datatypes.Map
 
     def op(self, dtype):
@@ -125,6 +118,8 @@
         dtype.registers['b'].assign('testing')
         dtype.flags['c'].enable()
         dtype.maps['d'][('e', 'set')].add('deep value')
+        dtype.maps['f'].counters['g']
+        dtype.maps['h'].maps['i'].flags['j']
 
     def check_op_output(self, op):
         self.assertIn(('update', ('a', 'counter'), ('increment', 2)), op)
@@ -133,6 +128,9 @@
         self.assertIn(('update', ('d', 'map'), [('update', ('e', 'set'),
                                                  {'adds': ['deep value']})]),
                       op)
+        self.assertNotIn(('update', ('f', 'map'), None), op)
+        self.assertNotIn(('update', ('h', 'map'), [('update', ('i', 'map'),
+                                                    None)]), op)
 
     def test_removes_require_context(self):
         dtype = self.dtype(self.bucket, 'key')
@@ -150,10 +148,12 @@
         self.assertTrue(dtype.modified)
 
 
-class DatatypeIntegrationTests(object):
-    @unittest.skipIf(SKIP_DATATYPES, 'SKIP_DATATYPES is set')
+@unittest.skipUnless(RUN_DATATYPES, 'RUN_DATATYPES is 0')
+class DatatypeIntegrationTests(IntegrationTestBase,
+                               unittest.TestCase,
+                               Comparison):
     def test_dt_counter(self):
-        btype = self.client.bucket_type('pytest-counters')
+        btype = self.client.bucket_type('counters')
         bucket = btype.bucket(self.bucket_name)
         mycount = datatypes.Counter(bucket, self.key_name)
         mycount.increment(5)
@@ -168,9 +168,8 @@
         mycount.reload()
         self.assertEqual(2, mycount.value)
 
-    @unittest.skipIf(SKIP_DATATYPES, 'SKIP_DATATYPES is set')
     def test_dt_set(self):
-        btype = self.client.bucket_type('pytest-sets')
+        btype = self.client.bucket_type('sets')
         bucket = btype.bucket(self.bucket_name)
         myset = datatypes.Set(bucket, self.key_name)
         myset.add('Sean')
@@ -191,9 +190,8 @@
         self.assertIn('Brett', myset)
         self.assertNotIn('Sean', myset)
 
-    @unittest.skipIf(SKIP_DATATYPES, 'SKIP_DATATYPES is set')
     def test_dt_map(self):
-        btype = self.client.bucket_type('pytest-maps')
+        btype = self.client.bucket_type('maps')
         bucket = btype.bucket(self.bucket_name)
         mymap = datatypes.Map(bucket, self.key_name)
 
@@ -227,9 +225,8 @@
         self.assertIn('f', mymap.sets)
         self.assertItemsEqual(['thing1', 'thing2'], mymap.sets['f'].value)
 
-    @unittest.skipIf(SKIP_DATATYPES, 'SKIP_DATATYPES is set')
     def test_dt_set_remove_without_context(self):
-        btype = self.client.bucket_type('pytest-sets')
+        btype = self.client.bucket_type('sets')
         bucket = btype.bucket(self.bucket_name)
         set = datatypes.Set(bucket, self.key_name)
 
@@ -239,9 +236,8 @@
         with self.assertRaises(datatypes.ContextRequired):
             set.discard("Y")
 
-    @unittest.skipIf(SKIP_DATATYPES, 'SKIP_DATATYPES is set')
     def test_dt_set_remove_fetching_context(self):
-        btype = self.client.bucket_type('pytest-sets')
+        btype = self.client.bucket_type('sets')
         bucket = btype.bucket(self.bucket_name)
         set = datatypes.Set(bucket, self.key_name)
 
@@ -256,9 +252,8 @@
         set2 = bucket.get(self.key_name)
         self.assertItemsEqual(['X', 'Y'], set2.value)
 
-    @unittest.skipIf(SKIP_DATATYPES, 'SKIP_DATATYPES is set')
     def test_dt_set_add_twice(self):
-        btype = self.client.bucket_type('pytest-sets')
+        btype = self.client.bucket_type('sets')
         bucket = btype.bucket(self.bucket_name)
         set = datatypes.Set(bucket, self.key_name)
 
@@ -273,9 +268,8 @@
         set2 = bucket.get(self.key_name)
         self.assertItemsEqual(['X', 'Y'], set2.value)
 
-    @unittest.skipIf(SKIP_DATATYPES, 'SKIP_DATATYPES is set')
     def test_dt_set_add_wins_in_same_op(self):
-        btype = self.client.bucket_type('pytest-sets')
+        btype = self.client.bucket_type('sets')
         bucket = btype.bucket(self.bucket_name)
         set = datatypes.Set(bucket, self.key_name)
 
@@ -291,9 +285,8 @@
         set2 = bucket.get(self.key_name)
         self.assertItemsEqual(['X', 'Y'], set2.value)
 
-    @unittest.skipIf(SKIP_DATATYPES, 'SKIP_DATATYPES is set')
     def test_dt_set_add_wins_in_same_op_reversed(self):
-        btype = self.client.bucket_type('pytest-sets')
+        btype = self.client.bucket_type('sets')
         bucket = btype.bucket(self.bucket_name)
         set = datatypes.Set(bucket, self.key_name)
 
@@ -309,9 +302,8 @@
         set2 = bucket.get(self.key_name)
         self.assertItemsEqual(['X', 'Y'], set2.value)
 
-    @unittest.skipIf(SKIP_DATATYPES, 'SKIP_DATATYPES is set')
     def test_dt_set_remove_old_context(self):
-        btype = self.client.bucket_type('pytest-sets')
+        btype = self.client.bucket_type('sets')
         bucket = btype.bucket(self.bucket_name)
         set = datatypes.Set(bucket, self.key_name)
 
@@ -331,9 +323,8 @@
         set2 = bucket.get(self.key_name)
         self.assertItemsEqual(['X', 'Y', 'Z'], set2.value)

riak-2.5.4.tar.gz/riak/tests/test_datetime.py Added

riak-2.1.0.tar.gz/riak/tests/test_feature_detection.py -> riak-2.5.4.tar.gz/riak/tests/test_feature_detection.py Changed

@@ -1,27 +1,5 @@
-"""
-Copyright 2012-2014 Basho Technologies, Inc.
-
-This file is provided to you under the Apache License,
-Version 2.0 (the "License"); you may not use this file
-except in compliance with the License.  You may obtain
-a copy of the License at
-
-  http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing,
-software distributed under the License is distributed on an
-"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-KIND, either express or implied.  See the License for the
-specific language governing permissions and limitations
-under the License.
-"""
-
-import platform
-
-if platform.python_version() < '2.7':
-    unittest = __import__('unittest2')
-else:
-    import unittest
+# -*- coding: utf-8 -*-
+import unittest
 
 from riak.transports.feature_detect import FeatureDetection
 
@@ -61,6 +39,8 @@
         self.assertFalse(t.index_term_regex())
         self.assertFalse(t.bucket_types())
         self.assertFalse(t.datatypes())
+        self.assertFalse(t.preflists())
+        self.assertFalse(t.write_once())
 
     def test_10(self):
         t = DummyTransport("1.0.3")
@@ -78,6 +58,8 @@
         self.assertFalse(t.index_term_regex())
         self.assertFalse(t.bucket_types())
         self.assertFalse(t.datatypes())
+        self.assertFalse(t.preflists())
+        self.assertFalse(t.write_once())
 
     def test_11(self):
         t = DummyTransport("1.1.4")
@@ -95,6 +77,8 @@
         self.assertFalse(t.index_term_regex())
         self.assertFalse(t.bucket_types())
         self.assertFalse(t.datatypes())
+        self.assertFalse(t.preflists())
+        self.assertFalse(t.write_once())
 
     def test_12(self):
         t = DummyTransport("1.2.0")
@@ -112,6 +96,8 @@
         self.assertFalse(t.index_term_regex())
         self.assertFalse(t.bucket_types())
         self.assertFalse(t.datatypes())
+        self.assertFalse(t.preflists())
+        self.assertFalse(t.write_once())
 
     def test_12_loose(self):
         t = DummyTransport("1.2.1p3")
@@ -129,6 +115,8 @@
         self.assertFalse(t.index_term_regex())
         self.assertFalse(t.bucket_types())
         self.assertFalse(t.datatypes())
+        self.assertFalse(t.preflists())
+        self.assertFalse(t.write_once())
 
     def test_14(self):
         t = DummyTransport("1.4.0rc1")
@@ -146,6 +134,8 @@
         self.assertFalse(t.index_term_regex())
         self.assertFalse(t.bucket_types())
         self.assertFalse(t.datatypes())
+        self.assertFalse(t.preflists())
+        self.assertFalse(t.write_once())
 
     def test_144(self):
         t = DummyTransport("1.4.6")
@@ -163,6 +153,8 @@
         self.assertTrue(t.index_term_regex())
         self.assertFalse(t.bucket_types())
         self.assertFalse(t.datatypes())
+        self.assertFalse(t.preflists())
+        self.assertFalse(t.write_once())
 
     def test_20(self):
         t = DummyTransport("2.0.1")
@@ -180,6 +172,27 @@
         self.assertTrue(t.index_term_regex())
         self.assertTrue(t.bucket_types())
         self.assertTrue(t.datatypes())
+        self.assertFalse(t.preflists())
+        self.assertFalse(t.write_once())
+
+    def test_21(self):
+        t = DummyTransport("2.1.0")
+        self.assertTrue(t.phaseless_mapred())
+        self.assertTrue(t.pb_indexes())
+        self.assertTrue(t.pb_search())
+        self.assertTrue(t.pb_conditionals())
+        self.assertTrue(t.quorum_controls())
+        self.assertTrue(t.tombstone_vclocks())
+        self.assertTrue(t.pb_head())
+        self.assertTrue(t.pb_clear_bucket_props())
+        self.assertTrue(t.pb_all_bucket_props())
+        self.assertTrue(t.counters())
+        self.assertTrue(t.stream_indexes())
+        self.assertTrue(t.index_term_regex())
+        self.assertTrue(t.bucket_types())
+        self.assertTrue(t.datatypes())
+        self.assertTrue(t.preflists())
+        self.assertTrue(t.write_once())
 
 if __name__ == '__main__':
     unittest.main()

riak-2.1.0.tar.gz/riak/tests/test_filters.py -> riak-2.5.4.tar.gz/riak/tests/test_filters.py Changed

riak-2.1.0.tar.gz/riak/tests/test_kv.py -> riak-2.5.4.tar.gz/riak/tests/test_kv.py Changed

@@ -1,22 +1,51 @@
 # -*- coding: utf-8 -*-
-import os
-import cPickle
 import copy
-import platform
+import os
+import sys
+import unittest
+
+from six import string_types, PY2, PY3
 from time import sleep
 from riak import ConflictError, RiakBucket, RiakError
 from riak.resolver import default_resolver, last_written_resolver
+from riak.tests import RUN_KV, RUN_RESOLVE
+from riak.tests.base import IntegrationTestBase
+from riak.tests.comparison import Comparison
+
 try:
     import simplejson as json
 except ImportError:
     import json
 
-if platform.python_version() < '2.7':
-    unittest = __import__('unittest2')
+if PY2:
+    import cPickle
+    test_pickle_dumps = cPickle.dumps
+    test_pickle_loads = cPickle.loads
 else:
-    import unittest
+    import pickle
+    test_pickle_dumps = pickle.dumps
+    test_pickle_loads = pickle.loads
+
 
-from . import SKIP_RESOLVE
+testrun_sibs_bucket = 'sibsbucket'
+testrun_props_bucket = 'propsbucket'
+
+
+def setUpModule():
+    if not RUN_KV:
+        return
+    c = IntegrationTestBase.create_client()
+    c.bucket(testrun_sibs_bucket).allow_mult = True
+    c.close()
+
+
+def tearDownModule():
+    if not RUN_KV:
+        return
+    c = IntegrationTestBase.create_client()
+    c.bucket(testrun_sibs_bucket).clear_properties()
+    c.bucket(testrun_props_bucket).clear_properties()
+    c.close()
 
 
 class NotJsonSerializable(object):
@@ -37,13 +66,30 @@
         value2_args = copy.copy(other.args)
         value1_args.sort()
         value2_args.sort()
-        for i in xrange(len(value1_args)):
+        for i in range(len(value1_args)):
             if value1_args[i] != value2_args[i]:
                 return False
         return True
 
 
-class BasicKVTests(object):
+@unittest.skipUnless(RUN_KV, 'RUN_KV is 0')
+class BasicKVTests(IntegrationTestBase, unittest.TestCase, Comparison):
+    def test_no_returnbody(self):
+        bucket = self.client.bucket(self.bucket_name)
+        o = bucket.new(self.key_name, "bar").store(return_body=False)
+        self.assertEqual(o.vclock, None)
+
+    def test_many_link_headers_should_work_fine(self):
+        bucket = self.client.bucket(self.bucket_name)
+        o = bucket.new("lots_of_links", "My god, it's full of links!")
+        for i in range(0, 300):
+            link = ("other", "key%d" % i, "next")
+            o.add_link(link)
+
+        o.store()
+        stored_object = bucket.get("lots_of_links")
+        self.assertEqual(len(stored_object.links), 300)
+
     def test_is_alive(self):
         self.assertTrue(self.client.is_alive())
 
@@ -60,18 +106,34 @@
 
         # unicode objects are fine, as long as they don't
         # contain any non-ASCII chars
-        self.client.bucket(unicode(self.bucket_name))
-        self.assertRaises(TypeError, self.client.bucket, u'búcket')
-        self.assertRaises(TypeError, self.client.bucket, 'búcket')
+        if PY2:
+            self.client.bucket(unicode(self.bucket_name))  # noqa
+        else:
+            self.client.bucket(self.bucket_name)
+        if PY2:
+            self.assertRaises(TypeError, self.client.bucket, u'búcket')
+            self.assertRaises(TypeError, self.client.bucket, 'búcket')
+        else:
+            self.client.bucket(u'búcket')
+            self.client.bucket('búcket')
 
         bucket.get(u'foo')
-        self.assertRaises(TypeError, bucket.get, u'føø')
-        self.assertRaises(TypeError, bucket.get, 'føø')
-
-        self.assertRaises(TypeError, bucket.new, u'foo', 'éå')
-        self.assertRaises(TypeError, bucket.new, u'foo', 'éå')
-        self.assertRaises(TypeError, bucket.new, 'foo', u'éå')
-        self.assertRaises(TypeError, bucket.new, 'foo', u'éå')
+        if PY2:
+            self.assertRaises(TypeError, bucket.get, u'føø')
+            self.assertRaises(TypeError, bucket.get, 'føø')
+
+            self.assertRaises(TypeError, bucket.new, u'foo', 'éå')
+            self.assertRaises(TypeError, bucket.new, u'foo', 'éå')
+            self.assertRaises(TypeError, bucket.new, 'foo', u'éå')
+            self.assertRaises(TypeError, bucket.new, 'foo', u'éå')
+        else:
+            bucket.get(u'føø')
+            bucket.get('føø')
+
+            bucket.new(u'foo', 'éå')
+            bucket.new(u'foo', 'éå')
+            bucket.new('foo', u'éå')
+            bucket.new('foo', u'éå')
 
         obj2 = bucket.new('baz', rand, 'application/json')
         obj2.charset = 'UTF-8'
@@ -100,17 +162,21 @@
     def test_string_bucket_name(self):
         # Things that are not strings cannot be bucket names
         for bad in (12345, True, None, {}, []):
-            with self.assertRaisesRegexp(TypeError, 'must be a string'):
+            with self.assert_raises_regex(TypeError, 'must be a string'):
                 self.client.bucket(bad)
 
-            with self.assertRaisesRegexp(TypeError, 'must be a string'):
+            with self.assert_raises_regex(TypeError, 'must be a string'):
                 RiakBucket(self.client, bad, None)
 
-        # Unicode bucket names are not supported, if they can't be
-        # encoded to ASCII. This should be changed in a future
-        # release.
-        with self.assertRaisesRegexp(TypeError,
-                                     'Unicode bucket names are not supported'):
+        # Unicode bucket names are not supported in Python 2.x,
+        # if they can't be encoded to ASCII. This should be changed in a
+        # future  release.
+        if PY2:
+            with self.assert_raises_regex(TypeError,
+                                          'Unicode bucket names '
+                                          'are not supported'):
+                self.client.bucket(u'føø')
+        else:
             self.client.bucket(u'føø')
 
         # This is fine, since it's already ASCII
@@ -119,17 +185,29 @@
     def test_generate_key(self):
         # Ensure that Riak generates a random key when
         # the key passed to bucket.new() is None.
-        bucket = self.client.bucket('random_key_bucket')
-        existing_keys = bucket.get_keys()
+        bucket = self.client.bucket(self.bucket_name)
         o = bucket.new(None, data={})
         self.assertIsNone(o.key)
         o.store()
         self.assertIsNotNone(o.key)
         self.assertNotIn('/', o.key)
-        self.assertNotIn(o.key, existing_keys)
-        self.assertEqual(len(bucket.get_keys()), len(existing_keys) + 1)
+        existing_keys = bucket.get_keys()
+        self.assertEqual(len(existing_keys), 1)
+
+    def maybe_store_keys(self):
+        skey = 'rkb-init'
+        bucket = self.client.bucket('random_key_bucket')
+        sobj = bucket.get(skey)
+        if sobj.exists:
+            return
+        for key in range(1, 1000):
+            o = bucket.new(None, data={})
+            o.store()
+        o = bucket.new(skey, data={})
+        o.store()
 
     def test_stream_keys(self):
+        self.maybe_store_keys()
         bucket = self.client.bucket('random_key_bucket')
         regular_keys = bucket.get_keys()
         self.assertNotEqual(len(regular_keys), 0)

riak-2.1.0.tar.gz/riak/tests/test_mapreduce.py -> riak-2.5.4.tar.gz/riak/tests/test_mapreduce.py Changed

@@ -1,28 +1,49 @@
 # -*- coding: utf-8 -*-
+from __future__ import print_function
 
+import unittest
+
+from six import PY2
 from riak.mapreduce import RiakMapReduce
 from riak import key_filter, RiakError
+from riak.tests import RUN_MAPREDUCE, RUN_SECURITY, RUN_YZ
+from riak.tests.base import IntegrationTestBase
 from riak.tests.test_yokozuna import wait_for_yz_index
-from riak.tests import RUN_SECURITY
-import platform
-if platform.python_version() < '2.7':
-    unittest = __import__('unittest2')
-else:
-    import unittest
+from riak.tests.yz_setup import yzSetUp, yzTearDown
+
+
+testrun_yz_mr = {'btype': 'mr',
+                 'bucket': 'mrbucket',
+                 'index': 'mrbucket'}
+
 
-from . import RUN_YZ
+def setUpModule():
+    yzSetUp(testrun_yz_mr)
 
 
-class LinkTests(object):
+def tearDownModule():
+    yzTearDown(testrun_yz_mr)
+
+
+@unittest.skipUnless(RUN_MAPREDUCE, 'RUN_MAPREDUCE is 0')
+class LinkTests(IntegrationTestBase, unittest.TestCase):
     def test_store_and_get_links(self):
         # Create the object...
         bucket = self.client.bucket(self.bucket_name)
-        bucket.new(key=self.key_name, encoded_data='2',
-                   content_type='application/octet-stream') \
-            .add_link(bucket.new("foo1")) \
-            .add_link(bucket.new("foo2"), "tag") \
-            .add_link(bucket.new("foo3"), "tag2!@#%^&*)") \
-            .store()
+        if PY2:
+            bucket.new(key=self.key_name, encoded_data='2',
+                       content_type='application/octet-stream') \
+                .add_link(bucket.new("foo1")) \
+                .add_link(bucket.new("foo2"), "tag") \
+                .add_link(bucket.new("foo3"), "tag2!@#%^&*)") \
+                .store()
+        else:
+            bucket.new(key=self.key_name, data='2',
+                       content_type='application/octet-stream') \
+                .add_link(bucket.new("foo1")) \
+                .add_link(bucket.new("foo2"), "tag") \
+                .add_link(bucket.new("foo3"), "tag2!@#%^&*)") \
+                .store()
         obj = bucket.get(self.key_name)
         links = obj.links
         self.assertEqual(len(links), 3)
@@ -71,7 +92,8 @@
         self.assertEqual(len(results), 1)
 
 
-class ErlangMapReduceTests(object):
+@unittest.skipUnless(RUN_MAPREDUCE, 'RUN_MAPREDUCE is 0')
+class ErlangMapReduceTests(IntegrationTestBase, unittest.TestCase):
     def test_erlang_map_reduce(self):
         # Create the object...
         bucket = self.client.bucket(self.bucket_name)
@@ -88,6 +110,23 @@
             .run()
         self.assertEqual(len(result), 2)
 
+    def test_erlang_map_reduce_bucket_type(self):
+        # Create the object...
+        btype = self.client.bucket_type('no_siblings')
+        bucket = btype.bucket(self.bucket_name)
+        bucket.new("foo", 2).store()
+        bucket.new("bar", 2).store()
+        bucket.new("baz", 4).store()
+        # Run the map...
+        result = self.client \
+            .add(self.bucket_name, "foo", bucket_type='no_siblings') \
+            .add(self.bucket_name, "bar", bucket_type='no_siblings') \
+            .add(self.bucket_name, "baz", bucket_type='no_siblings') \
+            .map(["riak_kv_mapreduce", "map_object_value"]) \
+            .reduce(["riak_kv_mapreduce", "reduce_set_union"]) \
+            .run()
+        self.assertEqual(len(result), 2)
+
     def test_erlang_source_map_reduce(self):
         # Create the object...
         bucket = self.client.bucket(self.bucket_name)
@@ -95,6 +134,7 @@
         bucket.new("bar", 3).store()
         bucket.new("baz", 4).store()
         strfun_allowed = True
+        result = []
         # Run the map...
         try:
             result = self.client \
@@ -108,6 +148,32 @@
         except RiakError as e:
             if e.value.startswith('May have tried'):
                 strfun_allowed = False
+            else:
+                print("test_erlang_source_map_reduce {}".format(e.value))
+        if strfun_allowed:
+            self.assertEqual(result, ['2', '3', '4'])
+
+    def test_erlang_source_map_reduce_bucket_type(self):
+        # Create the object...
+        btype = self.client.bucket_type('no_siblings')
+        bucket = btype.bucket(self.bucket_name)
+        bucket.new("foo", 2).store()
+        bucket.new("bar", 3).store()
+        bucket.new("baz", 4).store()
+        strfun_allowed = True
+        # Run the map...
+        try:
+            result = self.client \
+                .add(self.bucket_name, "foo", bucket_type='no_siblings') \
+                .add(self.bucket_name, "bar", bucket_type='no_siblings') \
+                .add(self.bucket_name, "baz", bucket_type='no_siblings') \
+                .map("""fun(Object, _KD, _A) ->
+            Value = riak_object:get_value(Object),
+            [Value]
+        end.""", {'language': 'erlang'}).run()
+        except RiakError as e:
+            if e.value.startswith('May have tried'):
+                strfun_allowed = False
         if strfun_allowed:
             self.assertEqual(result, ['2', '3', '4'])
 
@@ -133,7 +199,9 @@
             mr.add_key_filter("tokenize", "-", 1)
 
 
-class JSMapReduceTests(object):
+@unittest.skipUnless(RUN_MAPREDUCE, 'RUN_MAPREDUCE is 0')
+class JSMapReduceTests(IntegrationTestBase, unittest.TestCase):
+
     def test_javascript_source_map(self):
         # Create the object...
         bucket = self.client.bucket(self.bucket_name)
@@ -147,20 +215,29 @@
         # test ASCII-encodable unicode is accepted
         mr.map(u"function (v) { return [JSON.parse(v.values[0].data)]; }")
 
-        # test non-ASCII-encodable unicode is rejected
-        self.assertRaises(TypeError, mr.map,
-                          u"""
-                          function (v) {
-                          /* æ */
-                            return [JSON.parse(v.values[0].data)];
-                          }""")
-
-        # test non-ASCII-encodable string is rejected
-        self.assertRaises(TypeError, mr.map,
-                          """function (v) {
-                               /* æ */
-                               return [JSON.parse(v.values[0].data)];
-                             }""")
+        # test non-ASCII-encodable unicode is rejected in Python 2.x
+        if PY2:
+            self.assertRaises(TypeError, mr.map,
+                              u"""
+                              function (v) {
+                              /* æ */
+                                return [JSON.parse(v.values[0].data)];
+                              }""")
+        else:
+            mr = self.client.add(self.bucket_name, "foo")
+            result = mr.map("""function (v) {
+                      /* æ */
+                        return [JSON.parse(v.values[0].data)];
+                      }""").run()
+            self.assertEqual(result, [2])
+
+        # test non-ASCII-encodable string is rejected in Python 2.x
+        if PY2:
+            self.assertRaises(TypeError, mr.map,
+                              """function (v) {
+                                   /* æ */
+                                   return [JSON.parse(v.values[0].data)];
+                                 }""")
 
     def test_javascript_named_map(self):
         # Create the object...
@@ -173,6 +250,18 @@
             .run()
         self.assertEqual(result, [2])
 
+    def test_javascript_named_map_bucket_type(self):
+        # Create the object...

riak-2.1.0.tar.gz/riak/tests/test_pool.py -> riak-2.5.4.tar.gz/riak/tests/test_pool.py Changed

@@ -1,33 +1,20 @@
-"""
-Copyright 2012 Basho Technologies, Inc.
-
-This file is provided to you under the Apache License,
-Version 2.0 (the "License"); you may not use this file
-except in compliance with the License.  You may obtain
-a copy of the License at
-
-  http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing,
-software distributed under the License is distributed on an
-"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-KIND, either express or implied.  See the License for the
-specific language governing permissions and limitations
-under the License.
-"""
-
-import platform
-from Queue import Queue
+# -*- coding: utf-8 -*-
+import unittest
+
+from six import PY2
 from threading import Thread, currentThread
-from riak.transports.pool import Pool, BadResource
 from random import SystemRandom
 from time import sleep
 
-if platform.python_version() < '2.7':
-    unittest = __import__('unittest2')
+from riak import RiakError
+from riak.tests import RUN_POOL
+from riak.tests.comparison import Comparison
+from riak.transports.pool import Pool, BadResource
+
+if PY2:
+    from Queue import Queue
 else:
-    import unittest
-from . import SKIP_POOL
+    from queue import Queue
 
 
 class SimplePool(Pool):
@@ -48,9 +35,24 @@
         return []
 
 
-@unittest.skipIf(SKIP_POOL,
-                 'Skipping connection pool tests')
-class PoolTest(unittest.TestCase):
+@unittest.skipUnless(RUN_POOL, 'RUN_POOL is 0')
+class PoolTest(unittest.TestCase, Comparison):
+
+    def test_can_raise_bad_resource(self):
+        ex_msg = 'exception-message!'
+        with self.assertRaises(BadResource) as cm:
+            raise BadResource(ex_msg)
+        ex = cm.exception
+        self.assertEqual(ex.args[0], ex_msg)
+
+    def test_bad_resource_inner_exception(self):
+        ex_msg = 'exception-message!'
+        ex = RiakError(ex_msg)
+        with self.assertRaises(BadResource) as cm:
+            raise BadResource(ex)
+        br_ex = cm.exception
+        self.assertEqual(br_ex.args[0], ex)
+
     def test_yields_new_object_when_empty(self):
         """
         The pool should create new resources as needed.

riak-2.1.0.tar.gz/riak/tests/test_search.py -> riak-2.5.4.tar.gz/riak/tests/test_search.py Changed

@@ -1,139 +1,155 @@
 # -*- coding: utf-8 -*-
-import platform
-if platform.python_version() < '2.7':
-    unittest = __import__('unittest2')
-else:
-    import unittest
+from __future__ import print_function
 
-from . import SKIP_SEARCH
+import unittest
 
+from riak.tests import RUN_SEARCH, RUN_YZ
+from riak.tests.base import IntegrationTestBase
 
-class EnableSearchTests(object):
-    @unittest.skipIf(SKIP_SEARCH, 'SKIP_SEARCH is defined')
+testrun_search_bucket = 'searchbucket'
+
+
+def setUpModule():
+    if RUN_SEARCH and not RUN_YZ:
+        c = IntegrationTestBase.create_client()
+        b = c.bucket(testrun_search_bucket)
+        b.enable_search()
+        c.close()
+
+
+def tearDownModule():
+    if RUN_SEARCH and not RUN_YZ:
+        c = IntegrationTestBase.create_client()
+        b = c.bucket(testrun_search_bucket)
+        b.clear_properties()
+        c.close()
+
+
+@unittest.skipUnless(RUN_SEARCH, 'RUN_SEARCH is 0')
+class EnableSearchTests(IntegrationTestBase, unittest.TestCase):
     def test_bucket_search_enabled(self):
         bucket = self.client.bucket(self.bucket_name)
         self.assertFalse(bucket.search_enabled())
 
-    @unittest.skipIf(SKIP_SEARCH, 'SKIP_SEARCH is defined')
     def test_enable_search_commit_hook(self):
-        bucket = self.client.bucket(self.search_bucket)
+        bucket = self.client.bucket(testrun_search_bucket)
         bucket.clear_properties()
-        self.assertFalse(self.create_client().
-                         bucket(self.search_bucket).
-                         search_enabled())
+
+        c = self.create_client()
+        self.assertFalse(c.bucket(testrun_search_bucket).search_enabled())
+        c.close()
+
         bucket.enable_search()
-        self.assertTrue(self.create_client().
-                        bucket(self.search_bucket).
-                        search_enabled())
 
-    @unittest.skipIf(SKIP_SEARCH, 'SKIP_SEARCH is defined')
+        c = self.create_client()
+        self.assertTrue(c.bucket(testrun_search_bucket).search_enabled())
+        c.close()
+
     def test_disable_search_commit_hook(self):
-        bucket = self.client.bucket(self.search_bucket)
+        bucket = self.client.bucket(testrun_search_bucket)
         bucket.clear_properties()
         bucket.enable_search()
-        self.assertTrue(self.create_client().bucket(self.search_bucket)
-                            .search_enabled())
+
+        c = self.create_client()
+        self.assertTrue(c.bucket(testrun_search_bucket).search_enabled())
+        c.close()
+
         bucket.disable_search()
-        self.assertFalse(self.create_client().bucket(self.search_bucket)
-                             .search_enabled())
+
+        c = self.create_client()
+        self.assertFalse(c.bucket(testrun_search_bucket).search_enabled())
+        c.close()
+
         bucket.enable_search()
 
 
-class SolrSearchTests(object):
-    @unittest.skipIf(SKIP_SEARCH, 'SKIP_SEARCH is defined')
+@unittest.skipUnless(RUN_SEARCH, 'RUN_SEARCH is 0')
+class SolrSearchTests(IntegrationTestBase, unittest.TestCase):
     def test_add_document_to_index(self):
-        self.client.fulltext_add(self.search_bucket,
+        self.client.fulltext_add(testrun_search_bucket,
                                  [{"id": "doc", "username": "tony"}])
-        results = self.client.fulltext_search(self.search_bucket,
+        results = self.client.fulltext_search(testrun_search_bucket,
                                               "username:tony")
-        self.assertEquals("tony", results['docs'][0]['username'])
+        self.assertEqual("tony", results['docs'][0]['username'])
 
-    @unittest.skipIf(SKIP_SEARCH, 'SKIP_SEARCH is defined')
     def test_add_multiple_documents_to_index(self):
         self.client.fulltext_add(
-            self.search_bucket,
+            testrun_search_bucket,
             [{"id": "dizzy", "username": "dizzy"},
              {"id": "russell", "username": "russell"}])
         results = self.client.fulltext_search(
-            self.search_bucket, "username:russell OR username:dizzy")
-        self.assertEquals(2, len(results['docs']))
+            testrun_search_bucket, "username:russell OR username:dizzy")
+        self.assertEqual(2, len(results['docs']))
 
-    @unittest.skipIf(SKIP_SEARCH, 'SKIP_SEARCH is defined')
     def test_delete_documents_from_search_by_id(self):
         self.client.fulltext_add(
-            self.search_bucket,
+            testrun_search_bucket,
             [{"id": "dizzy", "username": "dizzy"},
              {"id": "russell", "username": "russell"}])
-        self.client.fulltext_delete(self.search_bucket, docs=["dizzy"])
+        self.client.fulltext_delete(testrun_search_bucket, docs=["dizzy"])
         results = self.client.fulltext_search(
-            self.search_bucket, "username:russell OR username:dizzy")
-        self.assertEquals(1, len(results['docs']))
+            testrun_search_bucket, "username:russell OR username:dizzy")
+        self.assertEqual(1, len(results['docs']))
 
-    @unittest.skipIf(SKIP_SEARCH, 'SKIP_SEARCH is defined')
     def test_delete_documents_from_search_by_query(self):
         self.client.fulltext_add(
-            self.search_bucket,
+            testrun_search_bucket,
             [{"id": "dizzy", "username": "dizzy"},
              {"id": "russell", "username": "russell"}])
         self.client.fulltext_delete(
-            self.search_bucket,
+            testrun_search_bucket,
             queries=["username:dizzy", "username:russell"])
         results = self.client.fulltext_search(
-            self.search_bucket, "username:russell OR username:dizzy")
-        self.assertEquals(0, len(results['docs']))
+            testrun_search_bucket, "username:russell OR username:dizzy")
+        self.assertEqual(0, len(results['docs']))
 
-    @unittest.skipIf(SKIP_SEARCH, 'SKIP_SEARCH is defined')
     def test_delete_documents_from_search_by_query_and_id(self):
         self.client.fulltext_add(
-            self.search_bucket,
+            testrun_search_bucket,
             [{"id": "dizzy", "username": "dizzy"},
              {"id": "russell", "username": "russell"}])
         self.client.fulltext_delete(
-            self.search_bucket,
+            testrun_search_bucket,
             docs=["dizzy"],
             queries=["username:russell"])
         results = self.client.fulltext_search(
-            self.search_bucket,
+            testrun_search_bucket,
             "username:russell OR username:dizzy")
-        self.assertEquals(0, len(results['docs']))
+        self.assertEqual(0, len(results['docs']))
 
 
-class SearchTests(object):
-    @unittest.skipIf(SKIP_SEARCH, 'SKIP_SEARCH is defined')
+@unittest.skipUnless(RUN_SEARCH, 'RUN_SEARCH is 0')
+class SearchTests(IntegrationTestBase, unittest.TestCase):
     def test_solr_search_from_bucket(self):
-        bucket = self.client.bucket(self.search_bucket)
+        bucket = self.client.bucket(testrun_search_bucket)
         bucket.new("user", {"username": "roidrage"}).store()
         results = bucket.search("username:roidrage")
-        self.assertEquals(1, len(results['docs']))
+        self.assertEqual(1, len(results['docs']))
 
-    @unittest.skipIf(SKIP_SEARCH, 'SKIP_SEARCH is defined')
     def test_solr_search_with_params_from_bucket(self):
-        bucket = self.client.bucket(self.search_bucket)
+        bucket = self.client.bucket(testrun_search_bucket)
         bucket.new("user", {"username": "roidrage"}).store()
         results = bucket.search("username:roidrage", wt="xml")
-        self.assertEquals(1, len(results['docs']))
+        self.assertEqual(1, len(results['docs']))
 
-    @unittest.skipIf(SKIP_SEARCH, 'SKIP_SEARCH is defined')
     def test_solr_search_with_params(self):
-        bucket = self.client.bucket(self.search_bucket)
+        bucket = self.client.bucket(testrun_search_bucket)
         bucket.new("user", {"username": "roidrage"}).store()
         results = self.client.fulltext_search(
-            self.search_bucket,
+            testrun_search_bucket,
             "username:roidrage", wt="xml")
-        self.assertEquals(1, len(results['docs']))
+        self.assertEqual(1, len(results['docs']))

riak-2.1.0.tar.gz/riak/tests/test_security.py -> riak-2.5.4.tar.gz/riak/tests/test_security.py Changed

@@ -1,47 +1,34 @@
 # -*- coding: utf-8 -*-
-"""
-Copyright 2014 Basho Technologies, Inc.
+import sys
+import unittest
 
-This file is provided to you under the Apache License,
-Version 2.0 (the "License"); you may not use this file
-except in compliance with the License.  You may obtain
-a copy of the License at
-
-  http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing,
-software distributed under the License is distributed on an
-"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-KIND, either express or implied.  See the License for the
-specific language governing permissions and limitations
-under the License.
-"""
-
-import platform
-if platform.python_version() < '2.7':
-    unittest = __import__('unittest2')
-else:
-    import unittest
 from riak.tests import RUN_SECURITY, SECURITY_USER, SECURITY_PASSWD, \
     SECURITY_CACERT, SECURITY_KEY, SECURITY_CERT, SECURITY_REVOKED, \
-    SECURITY_CERT_USER, SECURITY_CERT_PASSWD, SECURITY_BAD_CERT
+    SECURITY_CERT_USER, SECURITY_BAD_CERT, SECURITY_CIPHERS
 from riak.security import SecurityCreds
+from riak.tests.base import IntegrationTestBase
 
 
-class SecurityTests(object):
-    @unittest.skipIf(RUN_SECURITY, 'RUN_SECURITY is set')
+class SecurityTests(IntegrationTestBase, unittest.TestCase):
+    @unittest.skipIf(RUN_SECURITY, 'RUN_SECURITY is 1')
     def test_security_disabled(self):
-        creds = SecurityCreds(username=SECURITY_USER,
-                              password=SECURITY_PASSWD,
-                              cacert_file=SECURITY_CACERT)
-        client = self.create_client(credentials=creds)
+        """
+        Test valid security settings without security enabled
+        """
+        topts = {'timeout': 1}
+        # NB: can't use SECURITY_CREDS here since they won't be set
+        # if RUN_SECURITY is UN-set
+        creds = SecurityCreds(username='foo', password='bar')
+        client = self.create_client(credentials=creds,
+                                    transport_options=topts)
         myBucket = client.bucket('test')
         val1 = "foobar"
         key1 = myBucket.new('x', data=val1)
         with self.assertRaises(Exception):
             key1.store()
+        client.close()
 
-    @unittest.skipUnless(RUN_SECURITY, 'RUN_SECURITY is not set')
+    @unittest.skipUnless(RUN_SECURITY, 'RUN_SECURITY is 0')
     def test_security_basic_connection(self):
         myBucket = self.client.bucket('test')
         val1 = "foobar"
@@ -49,44 +36,56 @@
         key1.store()
         myBucket.get('x')
 
-    @unittest.skipUnless(RUN_SECURITY, 'RUN_SECURITY is not set')
+    @unittest.skipUnless(RUN_SECURITY, 'RUN_SECURITY is 0')
     def test_security_bad_user(self):
-        creds = SecurityCreds(username='foo', password=SECURITY_PASSWD,
-                              cacert_file=SECURITY_CACERT)
+        creds = SecurityCreds(username='foo',
+                              password=SECURITY_PASSWD,
+                              cacert_file=SECURITY_CACERT,
+                              ciphers=SECURITY_CIPHERS)
         client = self.create_client(credentials=creds)
         with self.assertRaises(Exception):
             client.get_buckets()
+        client.close()
 
-    @unittest.skipUnless(RUN_SECURITY, 'RUN_SECURITY is not set')
+    @unittest.skipUnless(RUN_SECURITY, 'RUN_SECURITY is 0')
     def test_security_bad_password(self):
-        creds = SecurityCreds(username=SECURITY_USER, password='foo',
-                              cacert_file=SECURITY_CACERT)
+        creds = SecurityCreds(username=SECURITY_USER,
+                              password='foo',
+                              cacert_file=SECURITY_CACERT,
+                              ciphers=SECURITY_CIPHERS)
         client = self.create_client(credentials=creds)
         with self.assertRaises(Exception):
             client.get_buckets()
+        client.close()
 
-    @unittest.skipUnless(RUN_SECURITY, 'RUN_SECURITY is not set')
+    @unittest.skipUnless(RUN_SECURITY, 'RUN_SECURITY is 0')
     def test_security_invalid_cert(self):
-        creds = SecurityCreds(username=SECURITY_USER, password=SECURITY_PASSWD,
-                              cacert_file='/tmp/foo')
+        creds = SecurityCreds(username=SECURITY_USER,
+                              password=SECURITY_PASSWD,
+                              cacert_file='/tmp/foo',
+                              ciphers=SECURITY_CIPHERS)
         client = self.create_client(credentials=creds)
         with self.assertRaises(Exception):
             client.get_buckets()
+        client.close()
 
-    @unittest.skipUnless(RUN_SECURITY, 'RUN_SECURITY is not set')
+    @unittest.skipUnless(RUN_SECURITY, 'RUN_SECURITY is 0')
     def test_security_password_without_cacert(self):
-        creds = SecurityCreds(username=SECURITY_USER, password=SECURITY_PASSWD)
+        creds = SecurityCreds(username=SECURITY_USER,
+                              password=SECURITY_PASSWD,
+                              ciphers=SECURITY_CIPHERS)
         client = self.create_client(credentials=creds)
         with self.assertRaises(Exception):
             myBucket = client.bucket('test')
             val1 = "foobar"
             key1 = myBucket.new('x', data=val1)
             key1.store()
+        client.close()
 
-    @unittest.skipUnless(RUN_SECURITY, 'RUN_SECURITY is not set')
+    @unittest.skipUnless(RUN_SECURITY, 'RUN_SECURITY is 0')
     def test_security_cert_authentication(self):
         creds = SecurityCreds(username=SECURITY_CERT_USER,
-                              password=SECURITY_CERT_PASSWD,
+                              ciphers=SECURITY_CIPHERS,
                               cert_file=SECURITY_CERT,
                               pkey_file=SECURITY_KEY,
                               cacert_file=SECURITY_CACERT)
@@ -103,37 +102,48 @@
             with self.assertRaises(Exception):
                 key1.store()
                 myBucket.get('x')
+        client.close()
 
-    @unittest.skipUnless(RUN_SECURITY, 'RUN_SECURITY is not set')
+    @unittest.skipUnless(RUN_SECURITY, 'RUN_SECURITY is 0')
     def test_security_revoked_cert(self):
-        creds = SecurityCreds(username=SECURITY_USER, password=SECURITY_PASSWD,
+        creds = SecurityCreds(username=SECURITY_USER,
+                              password=SECURITY_PASSWD,
+                              ciphers=SECURITY_CIPHERS,
                               cacert_file=SECURITY_CACERT,
                               crl_file=SECURITY_REVOKED)
+        # Currently Python >= 2.7.9 and Python 3.x native CRL doesn't seem to
+        # work as advertised
+        if sys.version_info >= (2, 7, 9):
+            return
         client = self.create_client(credentials=creds)
         with self.assertRaises(Exception):
             client.get_buckets()
+        client.close()
 
-    @unittest.skipUnless(RUN_SECURITY, 'RUN_SECURITY is not set')
+    @unittest.skipUnless(RUN_SECURITY, 'RUN_SECURITY is 0')
     def test_security_bad_ca_cert(self):
         creds = SecurityCreds(username=SECURITY_USER, password=SECURITY_PASSWD,
+                              ciphers=SECURITY_CIPHERS,
                               cacert_file=SECURITY_BAD_CERT)
         client = self.create_client(credentials=creds)
         with self.assertRaises(Exception):
             client.get_buckets()
+        client.close()
 
-    @unittest.skipUnless(RUN_SECURITY, 'RUN_SECURITY is not set')
+    @unittest.skipUnless(RUN_SECURITY, 'RUN_SECURITY is 0')
     def test_security_ciphers(self):
         creds = SecurityCreds(username=SECURITY_USER, password=SECURITY_PASSWD,
-                              cacert_file=SECURITY_CACERT,
-                              ciphers='DHE-RSA-AES256-SHA')
+                              ciphers=SECURITY_CIPHERS,
+                              cacert_file=SECURITY_CACERT)
         client = self.create_client(credentials=creds)
         myBucket = client.bucket('test')
         val1 = "foobar"
         key1 = myBucket.new('x', data=val1)
         key1.store()
         myBucket.get('x')
+        client.close()
 
-    @unittest.skipUnless(RUN_SECURITY, 'RUN_SECURITY is not set')
+    @unittest.skipUnless(RUN_SECURITY, 'RUN_SECURITY is 0')
     def test_security_bad_ciphers(self):
         creds = SecurityCreds(username=SECURITY_USER, password=SECURITY_PASSWD,
                               cacert_file=SECURITY_CACERT,
@@ -141,3 +151,4 @@
         client = self.create_client(credentials=creds)
         with self.assertRaises(Exception):
             client.get_buckets()
+        client.close()

riak-2.1.0.tar.gz/riak/tests/test_server_test.py -> riak-2.5.4.tar.gz/riak/tests/test_server_test.py Changed

@@ -1,7 +1,10 @@
-from riak.test_server import TestServer
+import sys
 import unittest
 
+from riak.test_server import TestServer
+
 
+@unittest.skipIf(sys.platform == 'win32', 'Windows is not supported')
 class TestServerTestCase(unittest.TestCase):
     def setUp(self):
         self.test_server = TestServer()
@@ -10,44 +13,44 @@
         pass
 
     def test_options_defaults(self):
-        self.assertEquals(
+        self.assertEqual(
             self.test_server.app_config["riak_core"]["handoff_port"], 9001)
-        self.assertEquals(
+        self.assertEqual(
             self.test_server.app_config["riak_kv"]["pb_ip"], "127.0.0.1")
 
     def test_merge_riak_core_options(self):
         self.test_server = TestServer(riak_core={"handoff_port": 10000})
-        self.assertEquals(
+        self.assertEqual(
             self.test_server.app_config["riak_core"]["handoff_port"], 10000)
 
     def test_merge_riak_search_options(self):
         self.test_server = TestServer(
             riak_search={"search_backend": "riak_search_backend"})
-        self.assertEquals(
+        self.assertEqual(
             self.test_server.app_config["riak_search"]["search_backend"],
             "riak_search_backend")
 
     def test_merge_riak_kv_options(self):
         self.test_server = TestServer(riak_kv={"pb_ip": "192.168.2.1"})
-        self.assertEquals(self.test_server.app_config["riak_kv"]["pb_ip"],
-                          "192.168.2.1")
+        self.assertEqual(self.test_server.app_config["riak_kv"]["pb_ip"],
+                         "192.168.2.1")
 
     def test_merge_vmargs(self):
         self.test_server = TestServer(vm_args={"-P": 65000})
-        self.assertEquals(self.test_server.vm_args["-P"], 65000)
+        self.assertEqual(self.test_server.vm_args["-P"], 65000)
 
     def test_set_ring_state_dir(self):
-        self.assertEquals(
+        self.assertEqual(
             self.test_server.app_config["riak_core"]["ring_state_dir"],
             "/tmp/riak/test_server/data/ring")
 
     def test_set_default_tmp_dir(self):
-        self.assertEquals(self.test_server.temp_dir, "/tmp/riak/test_server")
+        self.assertEqual(self.test_server.temp_dir, "/tmp/riak/test_server")
 
     def test_set_non_default_tmp_dir(self):
         tmp_dir = '/not/the/default/dir'
         server = TestServer(tmp_dir=tmp_dir)
-        self.assertEquals(server.temp_dir, tmp_dir)
+        self.assertEqual(server.temp_dir, tmp_dir)
 
 
 def suite():

riak-2.5.4.tar.gz/riak/tests/test_timeseries_pbuf.py Added

@@ -0,0 +1,463 @@
+# -*- coding: utf-8 -*-
+import datetime
+import six
+import unittest
+
+import riak.pb.riak_ts_pb2
+from riak.pb.riak_ts_pb2 import TsColumnType
+
+from riak import RiakError
+from riak.codecs.pbuf import PbufCodec
+from riak.table import Table
+from riak.tests import RUN_TIMESERIES
+from riak.tests.base import IntegrationTestBase
+from riak.ts_object import TsObject
+from riak.util import str_to_bytes, bytes_to_str, \
+    unix_time_millis, datetime_from_unix_time_millis, \
+    is_timeseries_supported
+
+table_name = 'GeoCheckin'
+
+bd0 = '时间序列'
+bd1 = 'временные ряды'
+
+fiveMins = datetime.timedelta(0, 300)
+# NB: last arg is microseconds, 987ms expressed
+ts0 = datetime.datetime(2015, 1, 1, 12, 0, 0, 987000)
+ex0ms = 1420113600987
+
+ts1 = ts0 + fiveMins
+ex1ms = 1420113900987
+
+
+@unittest.skipUnless(is_timeseries_supported(), "Timeseries not supported")
+class TimeseriesPbufUnitTests(unittest.TestCase):
+    @classmethod
+    def setUpClass(cls):
+        cls.ts0ms = unix_time_millis(ts0)
+        if cls.ts0ms != ex0ms:
+            raise AssertionError(
+                'expected {:d} to equal {:d}'.format(cls.ts0ms, ex0ms))
+
+        cls.ts1ms = unix_time_millis(ts1)
+        if cls.ts1ms != ex1ms:
+            raise AssertionError(
+                'expected {:d} to equal {:d}'.format(cls.ts1ms, ex1ms))
+
+        cls.rows = [
+            [bd0, 0, 1.2, ts0, True],
+            [bd1, 3, 4.5, ts1, False]
+        ]
+        cls.test_key = ['hash1', 'user2', ts0]
+        cls.table = Table(None, table_name)
+
+    def validate_keyreq(self, req):
+        self.assertEqual(self.table.name, bytes_to_str(req.table))
+        self.assertEqual(len(self.test_key), len(req.key))
+        self.assertEqual('hash1', bytes_to_str(req.key[0].varchar_value))
+        self.assertEqual('user2', bytes_to_str(req.key[1].varchar_value))
+        self.assertEqual(self.ts0ms, req.key[2].timestamp_value)
+
+    def test_encode_decode_timestamp(self):
+        ts0ms = unix_time_millis(ts0)
+        self.assertEqual(ts0ms, ex0ms)
+        ts0_d = datetime_from_unix_time_millis(ts0ms)
+        self.assertEqual(ts0, ts0_d)
+
+    def test_encode_data_for_get(self):
+        c = PbufCodec()
+        msg = c.encode_timeseries_keyreq(
+                self.table, self.test_key, is_delete=False)
+        req = riak.pb.riak_ts_pb2.TsGetReq()
+        req.ParseFromString(msg.data)
+        self.validate_keyreq(req)
+
+    def test_encode_data_for_delete(self):
+        c = PbufCodec()
+        msg = c.encode_timeseries_keyreq(
+                self.table, self.test_key, is_delete=True)
+        req = riak.pb.riak_ts_pb2.TsDelReq()
+        req.ParseFromString(msg.data)
+        self.validate_keyreq(req)
+
+    def test_encode_data_for_put(self):
+        c = PbufCodec()
+        tsobj = TsObject(None, self.table, self.rows, None)
+        msg = c.encode_timeseries_put(tsobj)
+        req = riak.pb.riak_ts_pb2.TsPutReq()
+        req.ParseFromString(msg.data)
+
+        # NB: expected, actual
+        self.assertEqual(self.table.name, bytes_to_str(req.table))
+        self.assertEqual(len(self.rows), len(req.rows))
+
+        r0 = req.rows[0]
+        self.assertEqual(bytes_to_str(r0.cells[0].varchar_value),
+                         self.rows[0][0])
+        self.assertEqual(r0.cells[1].sint64_value, self.rows[0][1])
+        self.assertEqual(r0.cells[2].double_value, self.rows[0][2])
+        self.assertEqual(r0.cells[3].timestamp_value, self.ts0ms)
+        self.assertEqual(r0.cells[4].boolean_value, self.rows[0][4])
+
+        r1 = req.rows[1]
+        self.assertEqual(bytes_to_str(r1.cells[0].varchar_value),
+                         self.rows[1][0])
+        self.assertEqual(r1.cells[1].sint64_value, self.rows[1][1])
+        self.assertEqual(r1.cells[2].double_value, self.rows[1][2])
+        self.assertEqual(r1.cells[3].timestamp_value, self.ts1ms)
+        self.assertEqual(r1.cells[4].boolean_value, self.rows[1][4])
+
+    def test_encode_data_for_listkeys(self):
+        c = PbufCodec(client_timeouts=True)
+        msg = c.encode_timeseries_listkeysreq(self.table, 1234)
+        req = riak.pb.riak_ts_pb2.TsListKeysReq()
+        req.ParseFromString(msg.data)
+        self.assertEqual(self.table.name, bytes_to_str(req.table))
+        self.assertEqual(1234, req.timeout)
+
+    def test_decode_data_from_query(self):
+        tqr = riak.pb.riak_ts_pb2.TsQueryResp()
+
+        c0 = tqr.columns.add()
+        c0.name = str_to_bytes('col_varchar')
+        c0.type = TsColumnType.Value('VARCHAR')
+        c1 = tqr.columns.add()
+        c1.name = str_to_bytes('col_integer')
+        c1.type = TsColumnType.Value('SINT64')
+        c2 = tqr.columns.add()
+        c2.name = str_to_bytes('col_double')
+        c2.type = TsColumnType.Value('DOUBLE')
+        c3 = tqr.columns.add()
+        c3.name = str_to_bytes('col_timestamp')
+        c3.type = TsColumnType.Value('TIMESTAMP')
+        c4 = tqr.columns.add()
+        c4.name = str_to_bytes('col_boolean')
+        c4.type = TsColumnType.Value('BOOLEAN')
+
+        r0 = tqr.rows.add()
+        r0c0 = r0.cells.add()
+        r0c0.varchar_value = str_to_bytes(self.rows[0][0])
+        r0c1 = r0.cells.add()
+        r0c1.sint64_value = self.rows[0][1]
+        r0c2 = r0.cells.add()
+        r0c2.double_value = self.rows[0][2]
+        r0c3 = r0.cells.add()
+        r0c3.timestamp_value = self.ts0ms
+        r0c4 = r0.cells.add()
+        r0c4.boolean_value = self.rows[0][4]
+
+        r1 = tqr.rows.add()
+        r1c0 = r1.cells.add()
+        r1c0.varchar_value = str_to_bytes(self.rows[1][0])
+        r1c1 = r1.cells.add()
+        r1c1.sint64_value = self.rows[1][1]
+        r1c2 = r1.cells.add()
+        r1c2.double_value = self.rows[1][2]
+        r1c3 = r1.cells.add()
+        r1c3.timestamp_value = self.ts1ms
+        r1c4 = r1.cells.add()
+        r1c4.boolean_value = self.rows[1][4]
+
+        tsobj = TsObject(None, self.table)
+        c = PbufCodec()
+        c.decode_timeseries(tqr, tsobj, True)
+
+        self.assertEqual(len(tsobj.rows), len(self.rows))
+        self.assertEqual(len(tsobj.columns.names), len(tqr.columns))
+        self.assertEqual(len(tsobj.columns.types), len(tqr.columns))
+
+        cn, ct = tsobj.columns
+        self.assertEqual(cn[0], 'col_varchar')
+        self.assertEqual(ct[0], 'varchar')
+        self.assertEqual(cn[1], 'col_integer')
+        self.assertEqual(ct[1], 'sint64')
+        self.assertEqual(cn[2], 'col_double')
+        self.assertEqual(ct[2], 'double')
+        self.assertEqual(cn[3], 'col_timestamp')
+        self.assertEqual(ct[3], 'timestamp')
+        self.assertEqual(cn[4], 'col_boolean')
+        self.assertEqual(ct[4], 'boolean')
+
+        r0 = tsobj.rows[0]
+        self.assertEqual(bytes_to_str(r0[0]), self.rows[0][0])
+        self.assertEqual(r0[1], self.rows[0][1])
+        self.assertEqual(r0[2], self.rows[0][2])
+        self.assertEqual(r0[3], ts0)
+        self.assertEqual(r0[4], self.rows[0][4])
+
+        r1 = tsobj.rows[1]
+        self.assertEqual(bytes_to_str(r1[0]), self.rows[1][0])
+        self.assertEqual(r1[1], self.rows[1][1])
+        self.assertEqual(r1[2], self.rows[1][2])
+        self.assertEqual(r1[3], ts1)
+        self.assertEqual(r1[4], self.rows[1][4])
+
+
+@unittest.skipUnless(is_timeseries_supported() and RUN_TIMESERIES,
+                     'Timeseries not supported or RUN_TIMESERIES is 0')
+class TimeseriesPbufTests(IntegrationTestBase, unittest.TestCase):
+    client_options = {'transport_options':

riak-2.5.4.tar.gz/riak/tests/test_timeseries_ttb.py Added

@@ -0,0 +1,272 @@
+# -*- coding: utf-8 -*-
+import datetime
+import logging
+import six
+import unittest
+
+from erlastic import decode, encode
+from erlastic.types import Atom
+
+from riak import RiakError
+from riak.table import Table
+from riak.ts_object import TsObject
+from riak.codecs.ttb import TtbCodec
+from riak.util import str_to_bytes, bytes_to_str, \
+    unix_time_millis, is_timeseries_supported
+from riak.tests import RUN_TIMESERIES
+from riak.tests.base import IntegrationTestBase
+
+rpberrorresp_a = Atom('rpberrorresp')
+tsgetreq_a = Atom('tsgetreq')
+tsgetresp_a = Atom('tsgetresp')
+tsputreq_a = Atom('tsputreq')
+
+udef_a = Atom('undefined')
+varchar_a = Atom('varchar')
+sint64_a = Atom('sint64')
+double_a = Atom('double')
+timestamp_a = Atom('timestamp')
+boolean_a = Atom('boolean')
+
+table_name = 'GeoCheckin'
+
+str0 = 'ascii-0'
+str1 = 'ascii-1'
+
+bd0 = six.u('时间序列')
+bd1 = six.u('временные ряды')
+
+fiveMins = datetime.timedelta(0, 300)
+ts0 = datetime.datetime(2015, 1, 1, 12, 1, 2, 987000)
+ts1 = ts0 + fiveMins
+
+
+@unittest.skipUnless(is_timeseries_supported(), "Timeseries not supported")
+class TimeseriesTtbUnitTests(unittest.TestCase):
+    def setUp(self):
+        self.table = Table(None, table_name)
+
+    def test_encode_data_for_get(self):
+        keylist = [
+            str_to_bytes('hash1'), str_to_bytes('user2'), unix_time_millis(ts0)
+        ]
+        req = tsgetreq_a, str_to_bytes(table_name), keylist, udef_a
+        req_test = encode(req)
+
+        test_key = ['hash1', 'user2', ts0]
+        c = TtbCodec()
+        msg = c.encode_timeseries_keyreq(self.table, test_key)
+        self.assertEqual(req_test, msg.data)
+
+    # {tsgetresp,
+    #   {
+    #     [<<"geohash">>, <<"user">>, <<"time">>,
+    #      <<"weather">>, <<"temperature">>],
+    #     [varchar, varchar, timestamp, varchar, double],
+    #     [(<<"hash1">>, <<"user2">>, 144378190987, <<"typhoon">>, 90.3)]
+    #   }
+    # }
+    def test_decode_data_from_get(self):
+        colnames = ["varchar", "sint64", "double", "timestamp",
+                    "boolean", "varchar", "varchar"]
+        coltypes = [varchar_a, sint64_a, double_a, timestamp_a,
+                    boolean_a, varchar_a, varchar_a]
+        r0 = (bd0, 0, 1.2, unix_time_millis(ts0), True,
+              [], str1, None)
+        r1 = (bd1, 3, 4.5, unix_time_millis(ts1), False,
+              [], str1, None)
+        rows = [r0, r1]
+        # { tsgetresp, { [colnames], [coltypes], [rows] } }
+        data_t = colnames, coltypes, rows
+        rsp_data = tsgetresp_a, data_t
+        rsp_ttb = encode(rsp_data)
+
+        tsobj = TsObject(None, self.table)
+        c = TtbCodec()
+        c.decode_timeseries(decode(rsp_ttb), tsobj)
+
+        for i in range(0, 1):
+            dr = rows[i]
+            r = tsobj.rows[i]  # encoded
+            self.assertEqual(r[0], dr[0].encode('utf-8'))
+            self.assertEqual(r[1], dr[1])
+            self.assertEqual(r[2], dr[2])
+            # NB *not* decoding timestamps
+            # dt = datetime_from_unix_time_millis(dr[3])
+            self.assertEqual(r[3], dr[3])
+            if i == 0:
+                self.assertEqual(r[4], True)
+            else:
+                self.assertEqual(r[4], False)
+            self.assertEqual(r[5], None)
+            self.assertEqual(r[6], dr[6].encode('ascii'))
+            self.assertEqual(r[7], None)
+
+    def test_encode_data_for_put(self):
+        r0 = (bd0, 0, 1.2, unix_time_millis(ts0), True, [])
+        r1 = (bd1, 3, 4.5, unix_time_millis(ts1), False, [])
+        rows = [r0, r1]
+        req = tsputreq_a, str_to_bytes(table_name), [], rows
+        req_test = encode(req)
+
+        rows_to_encode = [
+            [bd0, 0, 1.2, ts0, True, None],
+            [bd1, 3, 4.5, ts1, False, None]
+        ]
+
+        tsobj = TsObject(None, self.table, rows_to_encode, None)
+        c = TtbCodec()
+        msg = c.encode_timeseries_put(tsobj)
+        self.assertEqual(req_test, msg.data)
+
+
+@unittest.skipUnless(is_timeseries_supported() and RUN_TIMESERIES,
+                     'Timeseries not supported or RUN_TIMESERIES is 0')
+class TimeseriesTtbTests(IntegrationTestBase, unittest.TestCase):
+    client_options = {'transport_options':
+                      {'use_ttb': True, 'ts_convert_timestamp': True}}
+
+    @classmethod
+    def setUpClass(cls):
+        super(TimeseriesTtbTests, cls).setUpClass()
+
+    def test_insert_data_via_sql(self):
+        query = """
+            INSERT INTO GeoCheckin_Wide
+            (geohash, user, time, weather, temperature, uv_index, observed)
+                VALUES
+            ('hash3', 'user3', 1460203200000, 'tornado', 43.5, 128, True);
+        """
+        ts_obj = self.client.ts_query('GeoCheckin_Wide', query)
+        self.assertIsNotNone(ts_obj)
+        self.validate_len(ts_obj, 0)
+
+    def test_query_that_creates_table_using_interpolation(self):
+        table = self.randname()
+        query = """CREATE TABLE test-{table} (
+            geohash varchar not null,
+            user varchar not null,
+            time timestamp not null,
+            weather varchar not null,
+            temperature double,
+            PRIMARY KEY((geohash, user, quantum(time, 15, m)),
+                geohash, user, time))
+        """
+        ts_obj = self.client.ts_query(table, query)
+        self.assertIsNotNone(ts_obj)
+        self.assertFalse(hasattr(ts_obj, 'ts_cols'))
+        self.assertIsNone(ts_obj.rows)
+
+    def test_query_that_returns_table_description(self):
+        fmt = 'DESCRIBE {table}'
+        query = fmt.format(table=table_name)
+        ts_obj = self.client.ts_query(table_name, query)
+        self.assertIsNotNone(ts_obj)
+        ts_cols = ts_obj.columns
+        self.assertEqual(len(ts_cols.names), 5)
+        self.assertEqual(len(ts_cols.types), 5)
+        row = ts_obj.rows[0]
+        self.assertEqual(len(row), 5)
+
+    def test_store_and_fetch_gh_483(self):
+        now = datetime.datetime(2015, 1, 1, 12, 0, 0)
+        table = self.client.table(table_name)
+        rows = [
+            ['hash1', 'user2', now, 'frazzle', 12.3]
+        ]
+
+        ts_obj = table.new(rows)
+        result = ts_obj.store()
+        self.assertTrue(result)
+
+        k = ['hash1', 'user2', now]
+        ts_obj = self.client.ts_get(table_name, k)
+        self.assertIsNotNone(ts_obj)
+        ts_cols = ts_obj.columns
+        self.assertEqual(len(ts_cols.names), 5)
+        self.assertEqual(len(ts_cols.types), 5)
+        self.assertEqual(len(ts_obj.rows), 1)
+
+        row = ts_obj.rows[0]
+        self.assertEqual(len(row), 5)
+        exp = [six.b('hash1'), six.b('user2'), now,
+               six.b('frazzle'), 12.3]
+        self.assertEqual(row, exp)
+
+    def test_store_and_fetch_and_query(self):
+        now = datetime.datetime.utcfromtimestamp(144379690.987000)
+        fiveMinsAgo = now - fiveMins
+        tenMinsAgo = fiveMinsAgo - fiveMins

riak-2.5.4.tar.gz/riak/tests/test_util.py Added

@@ -0,0 +1,80 @@
+import datetime
+import unittest
+
+from riak.util import is_timeseries_supported, \
+    datetime_from_unix_time_millis, \
+    unix_time_millis
+
+
+class UtilUnitTests(unittest.TestCase):
+    # NB:
+    # 144379690 secs, 987 msecs past epoch
+    # 144379690987 total msecs past epoch
+    def test_conv_ms_timestamp_to_datetime_and_back(self):
+        if is_timeseries_supported():
+            # this is what would be stored in Riak TS
+            v = 144379690987
+            dt = datetime_from_unix_time_millis(v)
+
+            # This is how Python represents the above
+            utp = 144379690.987000
+            dtp = datetime.datetime.utcfromtimestamp(utp)
+            self.assertEqual(dt, dtp)
+
+            utm = unix_time_millis(dt)
+            self.assertEqual(v, utm)
+        else:
+            pass
+
+    def test_conv_datetime_to_unix_millis(self):
+        # This is the "native" Python unix timestamp including
+        # microseconds, as float. timedelta "total_seconds()"
+        # returns a value like this
+        if is_timeseries_supported():
+            v = 144379690.987000
+            d = datetime.datetime.utcfromtimestamp(v)
+            utm = unix_time_millis(d)
+            self.assertEqual(utm, 144379690987)
+        else:
+            pass
+
+    def test_unix_millis_validation(self):
+        v = 144379690.987
+        with self.assertRaises(ValueError):
+            datetime_from_unix_time_millis(v)
+
+    def test_unix_millis_small_value(self):
+        if is_timeseries_supported():
+            # this is what would be stored in Riak TS
+            v = 1001
+            dt = datetime_from_unix_time_millis(v)
+
+            # This is how Python represents the above
+            utp = 1.001
+            dtp = datetime.datetime.utcfromtimestamp(utp)
+            self.assertEqual(dt, dtp)
+
+            utm = unix_time_millis(dt)
+            self.assertEqual(v, utm)
+        else:
+            pass
+
+    def test_is_timeseries_supported(self):
+        v = (2, 7, 10)
+        self.assertEqual(True, is_timeseries_supported(v))
+        v = (2, 7, 11)
+        self.assertEqual(True, is_timeseries_supported(v))
+        v = (2, 7, 12)
+        self.assertEqual(True, is_timeseries_supported(v))
+        v = (3, 3, 6)
+        self.assertEqual(False, is_timeseries_supported(v))
+        v = (3, 4, 3)
+        self.assertEqual(False, is_timeseries_supported(v))
+        v = (3, 4, 4)
+        self.assertEqual(True, is_timeseries_supported(v))
+        v = (3, 4, 5)
+        self.assertEqual(True, is_timeseries_supported(v))
+        v = (3, 5, 0)
+        self.assertEqual(False, is_timeseries_supported(v))
+        v = (3, 5, 1)
+        self.assertEqual(True, is_timeseries_supported(v))

riak-2.1.0.tar.gz/riak/tests/test_yokozuna.py -> riak-2.5.4.tar.gz/riak/tests/test_yokozuna.py Changed

@@ -1,11 +1,10 @@
 # -*- coding: utf-8 -*-
-import platform
-if platform.python_version() < '2.7':
-    unittest = __import__('unittest2')
-else:
-    import unittest
+import unittest
 
-from . import RUN_YZ
+from riak.tests import RUN_YZ
+from riak.tests.base import IntegrationTestBase
+from riak.tests.comparison import Comparison
+from riak.tests.yz_setup import yzSetUp, yzTearDown
 
 
 def wait_for_yz_index(bucket, key, index=None):
@@ -20,77 +19,87 @@
     while len(bucket.search('_yz_rk:' + key, index=index)['docs']) == 0:
         pass
 
+# YZ index on bucket of the same name
+testrun_yz = {'btype': None, 'bucket': 'yzbucket', 'index': 'yzbucket'}
+# YZ index on bucket of a different name
+testrun_yz_index = {'btype': None,
+                    'bucket': 'yzindexbucket',
+                    'index': 'yzindex'}
 
-class YZSearchTests(object):
-    @unittest.skipUnless(RUN_YZ, 'RUN_YZ is undefined')
+
+def setUpModule():
+    yzSetUp(testrun_yz, testrun_yz_index)
+
+
+def tearDownModule():
+    yzTearDown(testrun_yz, testrun_yz_index)
+
+
+@unittest.skipUnless(RUN_YZ, 'RUN_YZ is 0')
+class YZSearchTests(IntegrationTestBase, unittest.TestCase, Comparison):
     def test_yz_search_from_bucket(self):
-        bucket = self.client.bucket(self.yz['bucket'])
+        bucket = self.client.bucket(testrun_yz['bucket'])
         bucket.new("user", {"user_s": "Z"}).store()
         wait_for_yz_index(bucket, "user")
         results = bucket.search("user_s:Z")
-        self.assertEquals(1, len(results['docs']))
+        self.assertEqual(1, len(results['docs']))
         # TODO: check that docs return useful info
         result = results['docs'][0]
         self.assertIn('_yz_rk', result)
-        self.assertEquals(u'user', result['_yz_rk'])
+        self.assertEqual(u'user', result['_yz_rk'])
         self.assertIn('_yz_rb', result)
-        self.assertEquals(self.yz['bucket'], result['_yz_rb'])
+        self.assertEqual(testrun_yz['bucket'], result['_yz_rb'])
         self.assertIn('score', result)
         self.assertIn('user_s', result)
-        self.assertEquals(u'Z', result['user_s'])
+        self.assertEqual(u'Z', result['user_s'])
 
-    @unittest.skipUnless(RUN_YZ, 'RUN_YZ is undefined')
     def test_yz_search_index_using_bucket(self):
-        bucket = self.client.bucket(self.yz_index['bucket'])
+        bucket = self.client.bucket(testrun_yz_index['bucket'])
         bucket.new("feliz",
                    {"name_s": "Felix", "species_s": "Felis catus"}).store()
-        wait_for_yz_index(bucket, "feliz", index=self.yz_index['index'])
-        results = bucket.search('name_s:Felix', index=self.yz_index['index'])
-        self.assertEquals(1, len(results['docs']))
+        wait_for_yz_index(bucket, "feliz", index=testrun_yz_index['index'])
+        results = bucket.search('name_s:Felix',
+                                index=testrun_yz_index['index'])
+        self.assertEqual(1, len(results['docs']))
 
-    @unittest.skipUnless(RUN_YZ, 'RUN_YZ is undefined')
     def test_yz_search_index_using_wrong_bucket(self):
-        bucket = self.client.bucket(self.yz_index['bucket'])
+        bucket = self.client.bucket(testrun_yz_index['bucket'])
         bucket.new("feliz",
                    {"name_s": "Felix", "species_s": "Felis catus"}).store()
-        wait_for_yz_index(bucket, "feliz", index=self.yz_index['index'])
+        wait_for_yz_index(bucket, "feliz", index=testrun_yz_index['index'])
         with self.assertRaises(Exception):
             bucket.search('name_s:Felix')
 
-    @unittest.skipUnless(RUN_YZ, 'RUN_YZ is undefined')
     def test_yz_get_search_index(self):
-        index = self.client.get_search_index(self.yz['bucket'])
-        self.assertEquals(self.yz['bucket'], index['name'])
-        self.assertEquals('_yz_default', index['schema'])
-        self.assertEquals(3, index['n_val'])
+        index = self.client.get_search_index(testrun_yz['bucket'])
+        self.assertEqual(testrun_yz['bucket'], index['name'])
+        self.assertEqual('_yz_default', index['schema'])
+        self.assertEqual(3, index['n_val'])
         with self.assertRaises(Exception):
-            self.client.get_search_index('NOT' + self.yz['bucket'])
+            self.client.get_search_index('NOT' + testrun_yz['bucket'])
 
-    @unittest.skipUnless(RUN_YZ, 'RUN_YZ is undefined')
     def test_yz_delete_search_index(self):
         # expected to fail, since there's an attached bucket
         with self.assertRaises(Exception):
-            self.client.delete_search_index(self.yz['bucket'])
+            self.client.delete_search_index(testrun_yz['bucket'])
         # detatch bucket from index then delete
-        b = self.client.bucket(self.yz['bucket'])
+        b = self.client.bucket(testrun_yz['bucket'])
         b.set_property('search_index', '_dont_index_')
-        self.assertTrue(self.client.delete_search_index(self.yz['bucket']))
+        self.assertTrue(self.client.delete_search_index(testrun_yz['bucket']))
         # create it again
-        self.client.create_search_index(self.yz['bucket'], '_yz_default', 3)
-        b = self.client.bucket(self.yz['bucket'])
-        b.set_property('search_index', self.yz['bucket'])
+        self.client.create_search_index(testrun_yz['bucket'], '_yz_default', 3)
+        b = self.client.bucket(testrun_yz['bucket'])
+        b.set_property('search_index', testrun_yz['bucket'])
         # Wait for index to apply
         indexes = []
-        while self.yz['bucket'] not in indexes:
+        while testrun_yz['bucket'] not in indexes:
             indexes = [i['name'] for i in self.client.list_search_indexes()]
 
-    @unittest.skipUnless(RUN_YZ, 'RUN_YZ is undefined')
     def test_yz_list_search_indexes(self):
         indexes = self.client.list_search_indexes()
-        self.assertIn(self.yz['bucket'], [item['name'] for item in indexes])
+        self.assertIn(testrun_yz['bucket'], [item['name'] for item in indexes])
         self.assertLessEqual(1, len(indexes))
 
-    @unittest.skipUnless(RUN_YZ, 'RUN_YZ is undefined')
     def test_yz_create_schema(self):
         content = """<?xml version="1.0" encoding="UTF-8" ?>
         <schema name="test" version="1.5">
@@ -123,10 +132,9 @@
         schema_name = self.randname()
         self.assertTrue(self.client.create_search_schema(schema_name, content))
         schema = self.client.get_search_schema(schema_name)
-        self.assertEquals(schema_name, schema['name'])
-        self.assertEquals(content, schema['content'])
+        self.assertEqual(schema_name, schema['name'])
+        self.assertEqual(content, schema['content'])
 
-    @unittest.skipUnless(RUN_YZ, 'RUN_YZ is undefined')
     def test_yz_create_bad_schema(self):
         bad_content = """
         <derp nope nope, how do i computer?
@@ -134,9 +142,8 @@
         with self.assertRaises(Exception):
             self.client.create_search_schema(self.randname(), bad_content)
 
-    @unittest.skipUnless(RUN_YZ, 'RUN_YZ is undefined')
     def test_yz_search_queries(self):
-        bucket = self.client.bucket(self.yz['bucket'])
+        bucket = self.client.bucket(testrun_yz['bucket'])
         bucket.new("Z", {"username_s": "Z", "name_s": "ryan",
                          "age_i": 30}).store()
         bucket.new("R", {"username_s": "R", "name_s": "eric",
@@ -148,51 +155,47 @@
         wait_for_yz_index(bucket, "H")
         # multiterm
         results = bucket.search("username_s:(F OR H)")
-        self.assertEquals(2, len(results['docs']))
+        self.assertEqual(2, len(results['docs']))
         # boolean
         results = bucket.search("username_s:Z AND name_s:ryan")
-        self.assertEquals(1, len(results['docs']))
+        self.assertEqual(1, len(results['docs']))
         # range
         results = bucket.search("age_i:[30 TO 33]")
-        self.assertEquals(2, len(results['docs']))
+        self.assertEqual(2, len(results['docs']))
         # phrase
         results = bucket.search('name_s:"bryan fink"')
-        self.assertEquals(1, len(results['docs']))
+        self.assertEqual(1, len(results['docs']))
         # wildcard
         results = bucket.search('name_s:*ryan*')
-        self.assertEquals(2, len(results['docs']))
+        self.assertEqual(2, len(results['docs']))
         # regexp
         results = bucket.search('name_s:/br.*/')
-        self.assertEquals(2, len(results['docs']))
+        self.assertEqual(2, len(results['docs']))
         # Parameters:
         # limit
         results = bucket.search('username_s:*', rows=2)
-        self.assertEquals(2, len(results['docs']))
+        self.assertEqual(2, len(results['docs']))
         # sort
         results = bucket.search('username_s:*', sort="age_i asc")
-        self.assertEquals(14, int(results['docs'][0]['age_i']))
+        self.assertEqual(14, int(results['docs'][0]['age_i']))
 
-    @unittest.skipUnless(RUN_YZ, 'RUN_YZ is undefined')
     def test_yz_search_utf8(self):
-        bucket = self.client.bucket(self.yz['bucket'])

riak-2.5.4.tar.gz/riak/tests/yz_setup.py Added

@@ -0,0 +1,45 @@
+import logging
+
+from riak import RiakError
+from riak.tests import RUN_YZ
+from riak.tests.base import IntegrationTestBase
+
+
+def yzSetUp(*yzdata):
+    if RUN_YZ:
+        c = IntegrationTestBase.create_client()
+        for yz in yzdata:
+            logging.debug("yzSetUp: %s", yz)
+            c.create_search_index(yz['index'], timeout=30000)
+            if yz['btype'] is not None:
+                t = c.bucket_type(yz['btype'])
+                b = t.bucket(yz['bucket'])
+            else:
+                b = c.bucket(yz['bucket'])
+            # Keep trying to set search bucket property until it succeeds
+            index_set = False
+            while not index_set:
+                try:
+                    b.set_property('search_index', yz['index'])
+                    index_set = True
+                except RiakError:
+                    pass
+        c.close()
+
+
+def yzTearDown(c, *yzdata):
+    if RUN_YZ:
+        c = IntegrationTestBase.create_client()
+        for yz in yzdata:
+            logging.debug("yzTearDown: %s", yz)
+            if yz['btype'] is not None:
+                t = c.bucket_type(yz['btype'])
+                b = t.bucket(yz['bucket'])
+            else:
+                b = c.bucket(yz['bucket'])
+            b.set_property('search_index', '_dont_index_')
+            c.delete_search_index(yz['index'])
+            for keys in b.stream_keys():
+                for key in keys:
+                    b.delete(key)
+        c.close()

riak-2.1.0.tar.gz/riak/transports/feature_detect.py -> riak-2.5.4.tar.gz/riak/transports/feature_detect.py Changed

@@ -1,32 +1,16 @@
-"""
-Copyright 2012 Basho Technologies, Inc.
-
-This file is provided to you under the Apache License,
-Version 2.0 (the "License"); you may not use this file
-except in compliance with the License.  You may obtain
-a copy of the License at
-
-  http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing,
-software distributed under the License is distributed on an
-"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-KIND, either express or implied.  See the License for the
-specific language governing permissions and limitations
-under the License.
-"""
-
 from distutils.version import LooseVersion
 from riak.util import lazy_property
 
 
 versions = {
-    1: LooseVersion("1.0.0"),
-    1.1: LooseVersion("1.1.0"),
-    1.2: LooseVersion("1.2.0"),
-    1.4: LooseVersion("1.4.0"),
-    1.44: LooseVersion("1.4.4"),
-    2.0: LooseVersion("2.0.0")
+    1: LooseVersion('1.0.0'),
+    1.1: LooseVersion('1.1.0'),
+    1.2: LooseVersion('1.2.0'),
+    1.4: LooseVersion('1.4.0'),
+    1.44: LooseVersion('1.4.4'),
+    2.0: LooseVersion('2.0.0'),
+    2.1: LooseVersion('2.1.0'),
+    2.12: LooseVersion('2.1.2')
 }
 
 
@@ -38,7 +22,7 @@
     should return the server's version as a string.
 
     :class:`FeatureDetection` is a parent class of
-    :class:`RiakTransport <riak.transports.transport.RiakTransport>`.
+    :class:`Transport <riak.transports.transport.Transport>`.
     """
 
     def _server_version(self):
@@ -192,6 +176,22 @@
         """
         return self.server_version >= versions[2.0]
 
+    def preflists(self):
+        """
+        Whether bucket/key preflists are supported.
+
+        :rtype: bool
+        """
+        return self.server_version >= versions[2.1]
+
+    def write_once(self):
+        """
+        Whether write-once operations are supported.
+
+        :rtype: bool
+        """
+        return self.server_version >= versions[2.1]
+
     @lazy_property
     def server_version(self):
         return LooseVersion(self._server_version())

riak-2.1.0.tar.gz/riak/transports/http/__init__.py -> riak-2.5.4.tar.gz/riak/transports/http/__init__.py Changed

@@ -1,33 +1,36 @@
-"""
-Copyright 2014 Basho Technologies, Inc.
-
-This file is provided to you under the Apache License,
-Version 2.0 (the "License"); you may not use this file
-except in compliance with the License.  You may obtain
-a copy of the License at
-
-  http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing,
-software distributed under the License is distributed on an
-"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-KIND, either express or implied.  See the License for the
-specific language governing permissions and limitations
-under the License.
-"""
-
-import OpenSSL.SSL
-import httplib
 import socket
 import select
 
-from riak.security import SecurityError
-from riak.transports.security import RiakWrappedSocket, configure_context
+from six import PY2
+from riak.security import SecurityError, USE_STDLIB_SSL
 from riak.transports.pool import Pool
-from riak.transports.http.transport import RiakHttpTransport
-
-
-class NoNagleHTTPConnection(httplib.HTTPConnection):
+from riak.transports.http.transport import HttpTransport
+
+if USE_STDLIB_SSL:
+    import ssl
+    from riak.transports.security import configure_ssl_context
+else:
+    import OpenSSL.SSL
+    from riak.transports.security import RiakWrappedSocket,\
+        configure_pyopenssl_context
+
+if PY2:
+    from httplib import HTTPConnection, \
+        NotConnected, \
+        IncompleteRead, \
+        ImproperConnectionState, \
+        BadStatusLine, \
+        HTTPSConnection
+else:
+    from http.client import HTTPConnection, \
+        HTTPSConnection, \
+        NotConnected, \
+        IncompleteRead, \
+        ImproperConnectionState, \
+        BadStatusLine
+
+
+class NoNagleHTTPConnection(HTTPConnection):
     """
     Setup a connection class which does not use Nagle - deal with
     latency on PUT requests lower than MTU
@@ -36,20 +39,19 @@
         """
         Set TCP_NODELAY on socket
         """
-        httplib.HTTPConnection.connect(self)
+        HTTPConnection.connect(self)
         self.sock.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1)
 
 
 # Inspired by
 # http://code.activestate.com/recipes/577548-https-httplib-client-connection-with-certificate-v/
-class RiakHTTPSConnection(httplib.HTTPSConnection):
+class RiakHTTPSConnection(HTTPSConnection):
     def __init__(self,
                  host,
                  port,
                  credentials,
                  pkey_file=None,
                  cert_file=None,
-                 ciphers=None,
                  timeout=None):
         """
         Class to make a HTTPS connection,
@@ -65,16 +67,31 @@
         :type pkey_file: str
         :param cert_file: PEM formatted certificate chain file
         :type cert_file: str
-        :param ciphers: List of supported SSL ciphers
-        :type ciphers: str
         :param timeout: Number of seconds before timing out
         :type timeout: int
         """
-        httplib.HTTPSConnection.__init__(self,
-                                         host,
-                                         port,
-                                         key_file=pkey_file,
-                                         cert_file=cert_file)
+        if PY2:
+            # NB: it appears that pkey_file / cert_file are never set
+            # in riak/transports/http/connection.py#_connect() method
+            pkf = pkey_file
+            if pkf is None and credentials is not None:
+                pkf = credentials._pkey_file
+
+            cf = cert_file
+            if cf is None and credentials is not None:
+                cf = credentials._cert_file
+
+            HTTPSConnection.__init__(self,
+                                     host,
+                                     port,
+                                     key_file=pkf,
+                                     cert_file=cf)
+        else:
+            super(RiakHTTPSConnection, self). \
+                __init__(host=host,
+                         port=port,
+                         key_file=credentials._pkey_file,
+                         cert_file=credentials._cert_file)
         self.pkey_file = pkey_file
         self.cert_file = cert_file
         self.credentials = credentials
@@ -85,27 +102,39 @@
         Connect to a host on a given (SSL) port using PyOpenSSL.
         """
         sock = socket.create_connection((self.host, self.port), self.timeout)
-        ssl_ctx = OpenSSL.SSL.Context(self.credentials.ssl_version)
-        configure_context(ssl_ctx, self.credentials)
-
-        # attempt to upgrade the socket to SSL
-        cxn = OpenSSL.SSL.Connection(ssl_ctx, sock)
-        cxn.set_connect_state()
-        while True:
-            try:
-                cxn.do_handshake()
-            except OpenSSL.SSL.WantReadError:
-                select.select([sock], [], [])
-                continue
-            except OpenSSL.SSL.Error as e:
-                raise SecurityError('bad handshake - ' + str(e))
-            break
-
-        self.sock = RiakWrappedSocket(cxn, sock)
-        self.credentials._check_revoked_cert(self.sock)
-
-
-class RiakHttpPool(Pool):
+        if not USE_STDLIB_SSL:
+            ssl_ctx = configure_pyopenssl_context(self.credentials)
+
+            # attempt to upgrade the socket to TLS
+            cxn = OpenSSL.SSL.Connection(ssl_ctx, sock)
+            cxn.set_connect_state()
+            while True:
+                try:
+                    cxn.do_handshake()
+                except OpenSSL.SSL.WantReadError:
+                    select.select([sock], [], [])
+                    continue
+                except OpenSSL.SSL.Error as e:
+                    raise SecurityError('bad handshake - ' + str(e))
+                break
+
+            self.sock = RiakWrappedSocket(cxn, sock)
+            self.credentials._check_revoked_cert(self.sock)
+        else:
+            ssl_ctx = configure_ssl_context(self.credentials)
+            if self.timeout is not None:
+                sock.settimeout(self.timeout)
+            self.sock = ssl.SSLSocket(sock=sock,
+                                      keyfile=self.credentials.pkey_file,
+                                      certfile=self.credentials.cert_file,
+                                      cert_reqs=ssl.CERT_REQUIRED,
+                                      ca_certs=self.credentials.cacert_file,
+                                      ciphers=self.credentials.ciphers,
+                                      server_hostname=self.host)
+            self.sock.context = ssl_ctx
+
+
+class HttpPool(Pool):
     """
     A pool of HTTP(S) transport connections.
     """
@@ -116,24 +145,24 @@
         if self.client._credentials:
             self.connection_class = RiakHTTPSConnection
 
-        super(RiakHttpPool, self).__init__()
+        super(HttpPool, self).__init__()
 
     def create_resource(self):
         node = self.client._choose_node()
-        return RiakHttpTransport(node=node,
-                                 client=self.client,
-                                 connection_class=self.connection_class,
-                                 **self.options)
+        return HttpTransport(node=node,

riak-2.1.0.tar.gz/riak/transports/http/connection.py -> riak-2.5.4.tar.gz/riak/transports/http/connection.py Changed

@@ -1,28 +1,17 @@
-"""
-Copyright 2012 Basho Technologies, Inc.
-
-This file is provided to you under the Apache License,
-Version 2.0 (the "License"); you may not use this file
-except in compliance with the License.  You may obtain
-a copy of the License at
+import base64
 
-http://www.apache.org/licenses/LICENSE-2.0
+from six import PY2
+from riak.util import str_to_bytes
 
-Unless required by applicable law or agreed to in writing,
-software distributed under the License is distributed on an
-"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-KIND, either express or implied.  See the License for the
-specific language governing permissions and limitations
-under the License.
-"""
+if PY2:
+    from httplib import NotConnected, HTTPConnection
+else:
+    from http.client import NotConnected, HTTPConnection
 
-import httplib
-import base64
 
-
-class RiakHttpConnection(object):
+class HttpConnection(object):
     """
-    Connection and low-level request methods for RiakHttpTransport.
+    Connection and low-level request methods for HttpTransport.
     """
 
     def _request(self, method, uri, headers={}, body='', stream=False):
@@ -42,7 +31,10 @@
 
         try:
             self._connection.request(method, uri, body, headers)
-            response = self._connection.getresponse()
+            try:
+                response = self._connection.getresponse(buffering=True)
+            except TypeError:
+                response = self._connection.getresponse()
 
             if stream:
                 # The caller is responsible for fully reading the
@@ -60,14 +52,21 @@
         """
         Use the appropriate connection class; optionally with security.
         """
+        timeout = None
+        if self._options is not None and 'timeout' in self._options:
+            timeout = self._options['timeout']
+
         if self._client._credentials:
-            self._connection = \
-                self._connection_class(self._node.host,
-                                       self._node.http_port,
-                                       self._client._credentials)
+            self._connection = self._connection_class(
+                host=self._node.host,
+                port=self._node.http_port,
+                credentials=self._client._credentials,
+                timeout=timeout)
         else:
-            self._connection = self._connection_class(self._node.host,
-                                                      self._node.http_port)
+            self._connection = self._connection_class(
+                    host=self._node.host,
+                    port=self._node.http_port,
+                    timeout=timeout)
         # Forces the population of stats and resources before any
         # other requests are made.
         self.server_version
@@ -78,11 +77,11 @@
         """
         try:
             self._connection.close()
-        except httplib.NotConnected:
+        except NotConnected:
             pass
 
-    # These are set by the RiakHttpTransport initializer
-    _connection_class = httplib.HTTPConnection
+    # These are set by the HttpTransport initializer
+    _connection_class = HTTPConnection
     _node = None
 
     def _security_auth_headers(self, username, password, headers):
@@ -97,6 +96,6 @@
         :type dict
         """
         userColonPassword = username + ":" + password
-        b64UserColonPassword = base64.b64encode(userColonPassword) \
-            .decode("ascii")
+        b64UserColonPassword = base64. \
+            b64encode(str_to_bytes(userColonPassword)).decode("ascii")
         headers['Authorization'] = 'Basic %s' % b64UserColonPassword

riak-2.1.0.tar.gz/riak/transports/http/resources.py -> riak-2.5.4.tar.gz/riak/transports/http/resources.py Changed

@@ -1,30 +1,18 @@
-"""
-Copyright 2012 Basho Technologies, Inc.
-
-This file is provided to you under the Apache License,
-Version 2.0 (the "License"); you may not use this file
-except in compliance with the License.  You may obtain
-a copy of the License at
-
-http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing,
-software distributed under the License is distributed on an
-"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-KIND, either express or implied.  See the License for the
-specific language governing permissions and limitations
-under the License.
-"""
-
 import re
-from urllib import quote_plus, urlencode
+
+from six import PY2
 from riak import RiakError
-from riak.util import lazy_property
+from riak.util import lazy_property, bytes_to_str
 
+if PY2:
+    from urllib import quote_plus, urlencode
+else:
+    from urllib.parse import quote_plus, urlencode
 
-class RiakHttpResources(object):
+
+class HttpResources(object):
     """
-    Methods for RiakHttpTransport related to URL generation, i.e.
+    Methods for HttpTransport related to URL generation, i.e.
     creating the proper paths.
     """
 
@@ -93,7 +81,7 @@
                    **options):
         if not self.riak_kv_wm_buckets:
             raise RiakError("Indexes are unsupported by this Riak node")
-        if finish:
+        if finish is not None:
             finish = quote_plus(str(finish))
         if self.riak_kv_wm_bucket_type and bucket_type:
             return mkpath("/types", quote_plus(bucket_type),
@@ -168,6 +156,30 @@
         return mkpath("/types", quote_plus(bucket_type), "buckets",
                       quote_plus(bucket), "datatypes", key, **options)
 
+    def preflist_path(self, bucket, key, bucket_type=None, **options):
+        """
+        Generate the URL for bucket/key preflist information
+
+        :param bucket: Name of a Riak bucket
+        :type bucket: string
+        :param key: Name of a Key
+        :type key: string
+        :param bucket_type: Optional Riak Bucket Type
+        :type bucket_type: None or string
+        :rtype URL string
+        """
+        if not self.riak_kv_wm_preflist:
+            raise RiakError("Preflists are unsupported by this Riak node")
+        if self.riak_kv_wm_bucket_type and bucket_type:
+            return mkpath("/types", quote_plus(bucket_type),
+                          "buckets", quote_plus(bucket),
+                          "keys", quote_plus(key),
+                          "preflist", **options)
+        else:
+            return mkpath("/buckets", quote_plus(bucket),
+                          "keys", quote_plus(key),
+                          "preflist", **options)
+
     # Feature detection overrides
     def bucket_types(self):
         return self.riak_kv_wm_bucket_type is not None
@@ -176,7 +188,7 @@
         if self.riak_kv_wm_bucket_type is not None:
             return True
         else:
-            return super(RiakHttpResources, self).index_term_regex()
+            return super(HttpResources, self).index_term_regex()
 
     # Resource root paths
     @lazy_property
@@ -222,6 +234,10 @@
         return self.resources.get('riak_kv_wm_counter')
 
     @lazy_property
+    def riak_kv_wm_preflist(self):
+        return self.resources.get('riak_kv_wm_preflist')
+
+    @lazy_property
     def yz_wm_search(self):
         return self.resources.get('yz_wm_search')
 
@@ -248,7 +264,7 @@
     and a dict.
     """
     # Remove empty segments (e.g. no key specified)
-    segments = [s for s in segments if s is not None]
+    segments = [bytes_to_str(s) for s in segments if s is not None]
     # Join the segments into a path
     pathstring = '/'.join(segments)
     # Remove extra slashes
@@ -260,7 +276,7 @@
         if query[key] in [False, True]:
             _query[key] = str(query[key]).lower()
         elif query[key] is not None:
-            if isinstance(query[key], unicode):
+            if PY2 and isinstance(query[key], unicode):  # noqa
                 _query[key] = query[key].encode('utf-8')
             else:
                 _query[key] = query[key]

riak-2.1.0.tar.gz/riak/transports/http/stream.py -> riak-2.5.4.tar.gz/riak/transports/http/stream.py Changed

@@ -1,32 +1,15 @@
-"""
-Copyright 2012 Basho Technologies, Inc.
-
-This file is provided to you under the Apache License,
-Version 2.0 (the "License"); you may not use this file
-except in compliance with the License.  You may obtain
-a copy of the License at
-
-  http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing,
-software distributed under the License is distributed on an
-"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-KIND, either express or implied.  See the License for the
-specific language governing permissions and limitations
-under the License.
-"""
-
 import json
-import string
 import re
+
 from cgi import parse_header
 from email import message_from_string
 from riak.util import decode_index_value
 from riak.client.index_page import CONTINUATION
 from riak import RiakError
+from six import PY2
 
 
-class RiakHttpStream(object):
+class HttpStream(object):
     """
     Base class for HTTP streaming iterators.
     """
@@ -44,9 +27,17 @@
 
     def _read(self):
         chunk = self.response.read(self.BLOCK_SIZE)
-        if chunk == '':
-            self.response_done = True
-        self.buffer += chunk
+        if PY2:
+            if chunk == '':
+                self.response_done = True
+            self.buffer += chunk
+        else:
+            if chunk == b'':
+                self.response_done = True
+            self.buffer += chunk.decode('utf-8')
+
+    def __next__(self):
+        raise NotImplementedError
 
     def next(self):
         raise NotImplementedError
@@ -58,15 +49,16 @@
         self.resource.release()
 
 
-class RiakHttpJsonStream(RiakHttpStream):
+class HttpJsonStream(HttpStream):
     _json_field = None
 
     def next(self):
+        # Python 2.x Version
         while '}' not in self.buffer and not self.response_done:
             self._read()
 
         if '}' in self.buffer:
-            idx = string.index(self.buffer, '}') + 1
+            idx = self.buffer.index('}') + 1
             chunk = self.buffer[:idx]
             self.buffer = self.buffer[idx:]
             jsdict = json.loads(chunk)
@@ -78,27 +70,31 @@
         else:
             raise StopIteration
 
+    def __next__(self):
+        # Python 3.x Version
+        return self.next()
+
 
-class RiakHttpKeyStream(RiakHttpJsonStream):
+class HttpKeyStream(HttpJsonStream):
     """
     Streaming iterator for list-keys over HTTP
     """
     _json_field = u'keys'
 
 
-class RiakHttpBucketStream(RiakHttpJsonStream):
+class HttpBucketStream(HttpJsonStream):
     """
     Streaming iterator for list-buckets over HTTP
     """
     _json_field = u'buckets'
 
 
-class RiakHttpMultipartStream(RiakHttpStream):
+class HttpMultipartStream(HttpStream):
     """
     Streaming iterator for multipart messages over HTTP
     """
     def __init__(self, response):
-        super(RiakHttpMultipartStream, self).__init__(response)
+        super(HttpMultipartStream, self).__init__(response)
         ctypehdr = response.getheader('content-type')
         _, params = parse_header(ctypehdr)
         self.boundary_re = re.compile('\r?\n--%s(?:--)?\r?\n' %
@@ -122,6 +118,10 @@
         else:
             raise StopIteration
 
+    def __next__(self):
+        # Python 3.x Version
+        return self.next()
+
     def try_match(self):
         self.next_boundary = self.boundary_re.search(self.buffer)
         return self.next_boundary
@@ -137,29 +137,33 @@
             self._read()
 
 
-class RiakHttpMapReduceStream(RiakHttpMultipartStream):
+class HttpMapReduceStream(HttpMultipartStream):
     """
     Streaming iterator for MapReduce over HTTP
     """
 
     def next(self):
-        message = super(RiakHttpMapReduceStream, self).next()
+        message = super(HttpMapReduceStream, self).next()
         payload = json.loads(message.get_payload())
         return payload['phase'], payload['data']
 
+    def __next__(self):
+        # Python 3.x Version
+        return self.next()
+
 
-class RiakHttpIndexStream(RiakHttpMultipartStream):
+class HttpIndexStream(HttpMultipartStream):
     """
     Streaming iterator for secondary indexes over HTTP
     """
 
     def __init__(self, response, index, return_terms):
-        super(RiakHttpIndexStream, self).__init__(response)
+        super(HttpIndexStream, self).__init__(response)
         self.index = index
         self.return_terms = return_terms
 
     def next(self):
-        message = super(RiakHttpIndexStream, self).next()
+        message = super(HttpIndexStream, self).next()
         payload = json.loads(message.get_payload())
         if u'error' in payload:
             raise RiakError(payload[u'error'])
@@ -168,9 +172,13 @@
         elif u'results' in payload:
             structs = payload[u'results']
             # Format is {"results":[{"2ikey":"primarykey"}, ...]}
-            return [self._decode_pair(d.items()[0]) for d in structs]
+            return [self._decode_pair(list(d.items())[0]) for d in structs]
         elif u'continuation' in payload:
             return CONTINUATION(payload[u'continuation'])
 
+    def __next__(self):
+        # Python 3.x Version
+        return self.next()
+
     def _decode_pair(self, pair):
         return (decode_index_value(self.index, pair[0]), pair[1])

riak-2.1.0.tar.gz/riak/transports/http/transport.py -> riak-2.5.4.tar.gz/riak/transports/http/transport.py Changed

@@ -1,67 +1,52 @@
-"""
-Copyright 2012 Basho Technologies, Inc.
-Copyright 2010 Rusty Klophaus <rusty@basho.com>
-Copyright 2010 Justin Sheehy <justin@basho.com>
-Copyright 2009 Jay Baird <jay@mochimedia.com>
-
-This file is provided to you under the Apache License,
-Version 2.0 (the "License"); you may not use this file
-except in compliance with the License.  You may obtain
-a copy of the License at
-
-  http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing,
-software distributed under the License is distributed on an
-"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-KIND, either express or implied.  See the License for the
-specific language governing permissions and limitations
-under the License.
-"""
-
 try:
     import simplejson as json
 except ImportError:
     import json
 
-
-import httplib
+from six import PY2
 from xml.dom.minidom import Document
-from riak.transports.transport import RiakTransport
-from riak.transports.http.resources import RiakHttpResources
-from riak.transports.http.connection import RiakHttpConnection
-from riak.transports.http.codec import RiakHttpCodec
-from riak.transports.http.stream import (
-    RiakHttpKeyStream,
-    RiakHttpMapReduceStream,
-    RiakHttpBucketStream,
-    RiakHttpIndexStream)
+
 from riak import RiakError
+from riak.codecs.http import HttpCodec
+from riak.transports.transport import Transport
+from riak.transports.http.resources import HttpResources
+from riak.transports.http.connection import HttpConnection
+from riak.transports.http.stream import (
+    HttpKeyStream,
+    HttpMapReduceStream,
+    HttpBucketStream,
+    HttpIndexStream)
 from riak.security import SecurityError
-from riak.util import decode_index_value
+from riak.util import decode_index_value, bytes_to_str, str_to_long
+
+if PY2:
+    from httplib import HTTPConnection
+else:
+    from http.client import HTTPConnection
 
 
-class RiakHttpTransport(RiakHttpConnection, RiakHttpResources, RiakHttpCodec,
-                        RiakTransport):
+class HttpTransport(Transport,
+                    HttpConnection, HttpResources, HttpCodec):
     """
-    The RiakHttpTransport object holds information necessary to
+    The HttpTransport object holds information necessary to
     connect to Riak via HTTP.
     """
 
     def __init__(self, node=None,
                  client=None,
-                 connection_class=httplib.HTTPConnection,
+                 connection_class=HTTPConnection,
                  client_id=None,
-                 **unused_options):
+                 **options):
         """
         Construct a new HTTP connection to Riak.
         """
-        super(RiakHttpTransport, self).__init__()
+        super(HttpTransport, self).__init__()
 
         self._client = client
         self._node = node
         self._connection_class = connection_class
         self._client_id = client_id
+        self._options = options
         if not self._client_id:
             self._client_id = self.make_random_client_id()
         self._connect()
@@ -71,7 +56,7 @@
         Check server is alive over HTTP
         """
         status, _, body = self._request('GET', self.ping_path())
-        return(status is not None) and (body == 'OK')
+        return(status is not None) and (bytes_to_str(body) == 'OK')
 
     def stats(self):
         """
@@ -80,7 +65,7 @@
         status, _, body = self._request('GET', self.stats_path(),
                                         {'Accept': 'application/json'})
         if status == 200:
-            return json.loads(body)
+            return json.loads(bytes_to_str(body))
         else:
             return None
 
@@ -105,7 +90,7 @@
         status, _, body = self._request('GET', '/',
                                         {'Accept': 'application/json'})
         if status == 200:
-            tmp, resources = json.loads(body), {}
+            tmp, resources = json.loads(bytes_to_str(body)), {}
             for k in tmp:
                 # The keys and values returned by json.loads() are unicode,
                 # which will cause problems when passed into httplib later
@@ -151,7 +136,10 @@
                                bucket_type=bucket_type,
                                **params)
         headers = self._build_put_headers(robj, if_none_match=if_none_match)
-        content = bytearray(robj.encoded_data)
+        if PY2:
+            content = bytearray(robj.encoded_data)
+        else:
+            content = robj.encoded_data
 
         if robj.key is None:
             expect = [201]
@@ -182,7 +170,9 @@
 
         url = self.object_path(robj.bucket.name, robj.key,
                                bucket_type=bucket_type, **params)
-        if self.tombstone_vclocks() and robj.vclock is not None:
+        use_vclocks = (self.tombstone_vclocks() and hasattr(robj, 'vclock') and
+                       robj.vclock is not None)
+        if use_vclocks:
             headers['X-Riak-Vclock'] = robj.vclock.encode('base64')
         response = self._request('DELETE', url, headers)
         self.check_http_code(response[0], [204, 404])
@@ -198,7 +188,7 @@
         status, _, body = self._request('GET', url)
 
         if status == 200:
-            props = json.loads(body)
+            props = json.loads(bytes_to_str(body))
             return props['keys']
         else:
             raise RiakError('Error listing keys.')
@@ -210,7 +200,7 @@
         status, headers, response = self._request('GET', url, stream=True)
 
         if status == 200:
-            return RiakHttpKeyStream(response)
+            return HttpKeyStream(response)
         else:
             raise RiakError('Error listing keys.')
 
@@ -224,7 +214,7 @@
         status, headers, body = self._request('GET', url)
 
         if status == 200:
-            props = json.loads(body)
+            props = json.loads(bytes_to_str(body))
             return props['buckets']
         else:
             raise RiakError('Error getting buckets.')
@@ -243,7 +233,7 @@
         status, headers, response = self._request('GET', url, stream=True)
 
         if status == 200:
-            return RiakHttpBucketStream(response)
+            return HttpBucketStream(response)
         else:
             raise RiakError('Error listing buckets.')
 
@@ -257,7 +247,7 @@
         status, headers, body = self._request('GET', url)
 
         if status == 200:
-            props = json.loads(body)
+            props = json.loads(bytes_to_str(body))
             return props['props']
         else:
             raise RiakError('Error getting bucket properties.')
@@ -311,7 +301,7 @@
         status, headers, body = self._request('GET', url)
 
         if status == 200:
-            props = json.loads(body)
+            props = json.loads(bytes_to_str(body))
             return props['props']
         else:
             raise RiakError('Error getting bucket-type properties.')
@@ -350,7 +340,7 @@
                 'Error running MapReduce operation. Headers: %s Body: %s' %
                 (repr(headers), repr(body)))

riak-2.1.0.tar.gz/riak/transports/pool.py -> riak-2.5.4.tar.gz/riak/transports/pool.py Changed

@@ -1,27 +1,12 @@
-"""
-Copyright 2012 Basho Technologies, Inc.
+from __future__ import print_function
 
-This file is provided to you under the Apache License,
-Version 2.0 (the "License"); you may not use this file
-except in compliance with the License.  You may obtain
-a copy of the License at
-
-  http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing,
-software distributed under the License is distributed on an
-"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-KIND, either express or implied.  See the License for the
-specific language governing permissions and limitations
-under the License.
-"""
+import threading
 
 from contextlib import contextmanager
-import threading
 
 
 # This file is a rough port of the Innertube Ruby library
-class BadResource(StandardError):
+class BadResource(Exception):
     """
     Users of a :class:`Pool` should raise this error when the pool
     resource currently in-use is bad and should be removed from the
@@ -88,7 +73,7 @@
         with pool.transaction() as resource:
             resource.append(1)
         with pool.transaction() as resource2:
-            print repr(resource2) # should be [1]
+            print(repr(resource2)) # should be [1]
 
     """
 
@@ -249,12 +234,17 @@
         return self
 
     def next(self):
+        # Python 2.x version
         if len(self.targets) == 0:
             raise StopIteration
         if len(self.unlocked) == 0:
             self.__claim_resources()
         return self.unlocked.pop(0)
 
+    def __next__(self):
+        # Python 3.x version
+        return self.next()
+
     def __claim_resources(self):
         with self.lock:
             with self.releaser:

riak-2.1.0.tar.gz/riak/transports/security.py -> riak-2.5.4.tar.gz/riak/transports/security.py Changed

@@ -1,5 +1,5 @@
 """
-Copyright 2014 Basho Technologies, Inc.
+Copyright 2015 Basho Technologies, Inc.
 
 This file is provided to you under the Apache License,
 Version 2.0 (the "License"); you may not use this file
@@ -16,13 +16,16 @@
 under the License.
 """
 
-import OpenSSL.SSL
 import socket
-try:
-    from cStringIO import StringIO
-except ImportError:
-    from StringIO import StringIO
-from riak.security import SecurityError
+from riak.security import SecurityError, USE_STDLIB_SSL
+if USE_STDLIB_SSL:
+    import ssl
+else:
+    import OpenSSL.SSL
+    try:
+        from cStringIO import StringIO
+    except ImportError:
+        from StringIO import StringIO
 
 
 def verify_cb(conn, cert, errnum, depth, ok):
@@ -35,250 +38,304 @@
     return ok
 
 
-def configure_context(ssl_ctx, credentials):
-    """
-    Set various options on the SSL context.
+if USE_STDLIB_SSL:
+    def configure_ssl_context(credentials):
+        """
+        Set various options on the SSL context for Python >= 2.7.9 and 3.x.
 
-    :param ssl_ctx: OpenSSL context
-    :type ssl_ctx: :class:`~OpenSSL.SSL.Context`
-    :param credentials: Riak Security Credentials
-    :type credentials: :class:`~riak.security.SecurityCreds`
-    """
+        N.B. versions earlier than 3.4 may not support all security
+        measures, e.g., hostname check.
 
-    if credentials._has_credential('pkey'):
-        ssl_ctx.use_privatekey(credentials.pkey)
-    if credentials._has_credential('cert'):
-        ssl_ctx.use_certificate(credentials.cert)
-    if credentials._has_credential('cacert'):
-        store = ssl_ctx.get_cert_store()
-        cacerts = credentials.cacert
-        if not isinstance(cacerts, list):
-            cacerts = [cacerts]
-        for cacert in cacerts:
-            store.add_cert(cacert)
-    else:
-        raise SecurityError("cacert_file is required in SecurityCreds")
-    ciphers = credentials.ciphers
-    if ciphers is not None:
-        ssl_ctx.set_cipher_list(ciphers)
-    # Demand a certificate
-    ssl_ctx.set_verify(OpenSSL.SSL.VERIFY_PEER |
-                       OpenSSL.SSL.VERIFY_FAIL_IF_NO_PEER_CERT,
-                       verify_cb)
-
-
-# Inspired by
-# https://github.com/shazow/urllib3/blob/master/urllib3/contrib/pyopenssl.py
-class RiakWrappedSocket(object):
-    def __init__(self, connection, socket):
+        :param credentials: Riak Security Credentials
+        :type credentials: :class:`~riak.security.SecurityCreds`
+        :rtype :class:`~ssl.SSLContext`
         """
-        API-compatibility wrapper for Python OpenSSL's Connection-class.
 
-        :param connection: OpenSSL connection
-        :type connection: OpenSSL.SSL.Connection
-        :param socket: Underlying already connected socket
-        :type socket: socket
-        """
-        self.connection = connection
-        self.socket = socket
+        ssl_ctx = ssl.SSLContext(credentials.ssl_version)
+        ssl_ctx.verify_mode = ssl.CERT_REQUIRED
+        if hasattr(ssl_ctx, 'check_hostname'):
+            ssl_ctx.check_hostname = True
+        if credentials.cacert_file is None:
+            raise SecurityError("cacert_file is required in SecurityCreds")
+        if credentials.ciphers is not None:
+            ssl_ctx.set_ciphers(credentials.ciphers)
 
-    def fileno(self):
-        return self.socket.fileno()
+        ssl_ctx.load_verify_locations(credentials.cacert_file)
+        if credentials.ciphers is not None:
+            ssl_ctx.set_ciphers(credentials.ciphers)
 
-    def makefile(self, mode, bufsize=-1):
-        return fileobject(self.connection, mode, bufsize)
+        pkeyfile = credentials.pkey_file
+        certfile = credentials.cert_file
+        if pkeyfile and not certfile:
+            raise SecurityError("cert_file must be specified with pkey_file")
+        if certfile and not pkeyfile:
+            pkeyfile = certfile
+        if certfile:
+            ssl_ctx.load_cert_chain(certfile, pkeyfile)
+        # TODO https://bugs.python.org/issue8813
+        if credentials.crl_file is not None:
+            ssl_ctx.load_verify_locations(credentials.crl_file)
+            ssl_ctx.verify_flags = ssl.VERIFY_CRL_CHECK_LEAF
 
-    def settimeout(self, timeout):
-        return self.socket.settimeout(timeout)
+        # SSLv2 considered harmful.
+        ssl_ctx.options |= ssl.OP_NO_SSLv2
 
-    def sendall(self, data):
-        # SSL seems to need bytes, so force the data to byte encoding
-        return self.connection.sendall(bytes(data))
+        # SSLv3 has problematic security and is only required for really old
+        # clients such as IE6 on Windows XP
+        ssl_ctx.options |= ssl.OP_NO_SSLv3
 
-    def close(self):
-        try:
-            return self.connection.shutdown()
-        except OpenSSL.SSL.Error as err:
-            if err.args == ([],):
-                return False
-            else:
-                raise err
+        # disable compression to prevent CRIME attacks (OpenSSL 1.0+)
+        ssl_ctx.options |= ssl.OP_NO_COMPRESSION
 
+        return ssl_ctx
 
-# Blatantly Stolen from
-# https://github.com/shazow/urllib3/blob/master/urllib3/contrib/pyopenssl.py
-# which is basically a port of the `socket._fileobject` class
-class fileobject(socket._fileobject):
-    """
-    Extension of the socket module's fileobject to use PyOpenSSL.
-    """
+else:
+    def configure_pyopenssl_context(credentials):
+        """
+        Set various options on the SSL context for Python <= 2.7.8.
+
+        :param credentials: Riak Security Credentials
+        :type credentials: :class:`~riak.security.SecurityCreds`
+        :rtype ssl_ctx: :class:`~OpenSSL.SSL.Context`
+        """
 
-    def read(self, size=-1):
-        # Use max, disallow tiny reads in a loop as they are very inefficient.
-        # We never leave read() with any leftover data from a new recv() call
-        # in our internal buffer.
-        rbufsize = max(self._rbufsize, self.default_bufsize)
-        # Our use of StringIO rather than lists of string objects returned by
-        # recv() minimizes memory usage and fragmentation that occurs when
-        # rbufsize is large compared to the typical return value of recv().
-        buf = self._rbuf
-        buf.seek(0, 2)  # seek end
-        if size < 0:
-            # Read until EOF
-            self._rbuf = StringIO()  # reset _rbuf.  we consume it via buf.
-            while True:
-                try:
-                    data = self._sock.recv(rbufsize)
-                except OpenSSL.SSL.WantReadError:
-                    continue
-                if not data:
-                    break
-                buf.write(data)
-            return buf.getvalue()
+        ssl_ctx = OpenSSL.SSL.Context(credentials.ssl_version)
+        if credentials._has_credential('pkey'):
+            ssl_ctx.use_privatekey(credentials.pkey)
+        if credentials._has_credential('cert'):
+            ssl_ctx.use_certificate(credentials.cert)
+        if credentials._has_credential('cacert'):
+            store = ssl_ctx.get_cert_store()
+            cacerts = credentials.cacert
+            if not isinstance(cacerts, list):
+                cacerts = [cacerts]
+            for cacert in cacerts:
+                store.add_cert(cacert)
         else:
-            # Read until size bytes or EOF seen, whichever comes first
-            buf_len = buf.tell()
-            if buf_len >= size:
-                # Already have size bytes in our buffer?  Extract and return.

riak-2.5.4.tar.gz/riak/transports/tcp Added

riak-2.5.4.tar.gz/riak/transports/tcp/__init__.py Added

@@ -0,0 +1,54 @@
+import errno
+import socket
+
+from riak.transports.pool import Pool
+from riak.transports.tcp.transport import TcpTransport
+
+
+class TcpPool(Pool):
+    """
+    A resource pool of TCP transports.
+    """
+    def __init__(self, client, **options):
+        super(TcpPool, self).__init__()
+        self._client = client
+        self._options = options
+
+    def create_resource(self):
+        node = self._client._choose_node()
+        return TcpTransport(node=node,
+                            client=self._client,
+                            **self._options)
+
+    def destroy_resource(self, tcp):
+        tcp.close()
+
+# These are a specific set of socket errors
+# that could be raised on send/recv that indicate
+# that the socket is closed or reset, and is not
+# usable. On seeing any of these errors, the socket
+# should be closed, and the connection re-established.
+CONN_CLOSED_ERRORS = (
+    errno.EHOSTUNREACH,
+    errno.ECONNRESET,
+    errno.ECONNREFUSED,
+    errno.ECONNABORTED,
+    errno.ETIMEDOUT,
+    errno.EBADF,
+    errno.EPIPE
+)
+
+
+def is_retryable(err):
+    """
+    Determines if the given exception is something that is
+    network/socket-related and should thus cause the TCP connection to
+    close and the operation retried on another node.
+
+    :rtype: boolean
+    """
+    if isinstance(err, socket.error):
+        code = err.args[0]
+        return code in CONN_CLOSED_ERRORS
+    else:
+        return False

riak-2.5.4.tar.gz/riak/transports/tcp/connection.py Added

@@ -0,0 +1,253 @@
+import logging
+import socket
+import struct
+
+import riak.pb.riak_pb2
+import riak.pb.messages
+
+from riak import RiakError
+from riak.codecs.pbuf import PbufCodec
+from riak.security import SecurityError, USE_STDLIB_SSL
+from riak.transports.pool import BadResource
+
+if USE_STDLIB_SSL:
+    import ssl
+    from riak.transports.security import configure_ssl_context
+else:
+    from OpenSSL.SSL import Connection
+    from riak.transports.security import configure_pyopenssl_context
+
+
+class TcpConnection(object):
+    def __init__(self):
+        self.bytes_required = False
+
+    """
+    Connection-related methods for TcpTransport.
+    """
+    def _encode_msg(self, msg_code, data=None):
+        if data is None:
+            return struct.pack("!iB", 1, msg_code)
+        hdr = struct.pack("!iB", 1 + len(data), msg_code)
+        return hdr + data
+
+    def _send_recv(self, msg_code, data=None):
+        self._send_msg(msg_code, data)
+        return self._recv_msg()
+
+    def _non_connect_send_recv(self, msg_code, data=None):
+        """
+        Similar to self._send_recv, but doesn't try to initiate a connection,
+        thus preventing an infinite loop.
+        """
+        self._non_connect_send_msg(msg_code, data)
+        return self._recv_msg()
+
+    def _non_connect_send_recv_msg(self, msg):
+        self._non_connect_send_msg(msg.msg_code, msg.data)
+        return self._recv_msg()
+
+    def _non_connect_send_msg(self, msg_code, data):
+        """
+        Similar to self._send, but doesn't try to initiate a connection,
+        thus preventing an infinite loop.
+        """
+        self._socket.sendall(self._encode_msg(msg_code, data))
+
+    def _send_msg(self, msg_code, data):
+        self._connect()
+        self._non_connect_send_msg(msg_code, data)
+
+    def _init_security(self):
+        """
+        Initialize a secure connection to the server.
+        """
+        if not self._starttls():
+            raise SecurityError("Could not start TLS connection")
+        # _ssh_handshake() will throw an exception upon failure
+        self._ssl_handshake()
+        if not self._auth():
+            raise SecurityError("Could not authorize connection")
+
+    def _starttls(self):
+        """
+        Exchange a STARTTLS message with Riak to initiate secure communications
+        return True is Riak responds with a STARTTLS response, False otherwise
+        """
+        resp_code, _ = self._non_connect_send_recv(
+            riak.pb.messages.MSG_CODE_START_TLS)
+        if resp_code == riak.pb.messages.MSG_CODE_START_TLS:
+            return True
+        else:
+            return False
+
+    def _auth(self):
+        """
+        Perform an authorization request against Riak
+        returns True upon success, False otherwise
+        Note: Riak will sleep for a short period of time upon a failed
+              auth request/response to prevent denial of service attacks
+        """
+        codec = PbufCodec()
+        username = self._client._credentials.username
+        password = self._client._credentials.password
+        if not password:
+            password = ''
+        msg = codec.encode_auth(username, password)
+        resp_code, _ = self._non_connect_send_recv_msg(msg)
+        if resp_code == riak.pb.messages.MSG_CODE_AUTH_RESP:
+            return True
+        else:
+            return False
+
+    if not USE_STDLIB_SSL:
+        def _ssl_handshake(self):
+            """
+            Perform an SSL handshake w/ the server.
+            Precondition: a successful STARTTLS exchange has
+                         taken place with Riak
+            returns True upon success, otherwise an exception is raised
+            """
+            if self._client._credentials:
+                try:
+                    ssl_ctx = configure_pyopenssl_context(self.
+                                                          _client._credentials)
+                    # attempt to upgrade the socket to SSL
+                    ssl_socket = Connection(ssl_ctx, self._socket)
+                    ssl_socket.set_connect_state()
+                    ssl_socket.do_handshake()
+                    # ssl handshake successful
+                    self._socket = ssl_socket
+
+                    self._client._credentials._check_revoked_cert(ssl_socket)
+                    return True
+                except Exception as e:
+                    # fail if *any* exceptions are thrown during SSL handshake
+                    raise SecurityError(e)
+    else:
+        def _ssl_handshake(self):
+            """
+            Perform an SSL handshake w/ the server.
+            Precondition: a successful STARTTLS exchange has
+                         taken place with Riak
+            returns True upon success, otherwise an exception is raised
+            """
+            credentials = self._client._credentials
+            if credentials:
+                try:
+                    ssl_ctx = configure_ssl_context(credentials)
+                    host = self._address[0]
+                    ssl_socket = ssl.SSLSocket(sock=self._socket,
+                                               keyfile=credentials.pkey_file,
+                                               certfile=credentials.cert_file,
+                                               cert_reqs=ssl.CERT_REQUIRED,
+                                               ca_certs=credentials.
+                                               cacert_file,
+                                               ciphers=credentials.ciphers,
+                                               server_hostname=host)
+                    ssl_socket.context = ssl_ctx
+                    # ssl handshake successful
+                    ssl_socket.do_handshake()
+                    self._socket = ssl_socket
+                    return True
+                except ssl.SSLError as e:
+                    raise SecurityError(e)
+                except Exception as e:
+                    # fail if *any* exceptions are thrown during SSL handshake
+                    raise SecurityError(e)
+
+    def _recv_msg(self):
+        try:
+            msgbuf = self._recv_pkt()
+        except socket.timeout as e:
+            # A timeout can leave the socket in an inconsistent state because
+            # it might still receive the data later and mix up with a
+            # subsequent request.
+            # https://github.com/basho/riak-python-client/issues/425
+            raise BadResource(e)
+        mv = memoryview(msgbuf)
+        mcb = mv[0:1]
+        if self.bytes_required:
+            mcb = mcb.tobytes()
+        try:
+            msg_code, = struct.unpack("B", mcb)
+        except struct.error:
+            # NB: Python 2.7.3 requires this
+            # http://bugs.python.org/issue10212
+            msg_code, = struct.unpack("B", mv[0:1].tobytes())
+            self.bytes_required = True
+        data = mv[1:].tobytes()
+        return (msg_code, data)
+
+    def _recv_pkt(self):
+        # TODO FUTURE re-use buffer
+        msglen_buf = self._recv(4)
+        # NB: msg length is an unsigned int
+        if self.bytes_required:
+            msglen_buf = bytes(msglen_buf)
+        try:
+            msglen, = struct.unpack('!I', msglen_buf)
+        except struct.error:
+            # NB: Python 2.7.3 requires this
+            # http://bugs.python.org/issue10212
+            msglen, = struct.unpack('!I', bytes(msglen_buf))
+            self.bytes_required = True
+        return self._recv(msglen)
+
+    def _recv(self, msglen):
+        # TODO FUTURE re-use buffer
+        # http://stackoverflow.com/a/15964489

riak-2.5.4.tar.gz/riak/transports/tcp/stream.py Added

@@ -0,0 +1,196 @@
+import json
+
+import riak.pb.messages
+
+from riak.util import decode_index_value, bytes_to_str
+from riak.client.index_page import CONTINUATION
+from riak.codecs.ttb import TtbCodec
+from six import PY2
+
+
+class PbufStream(object):
+    """
+    Used internally by TcpTransport to implement streaming
+    operations. Implements the iterator interface.
+    """
+
+    _expect = None
+
+    def __init__(self, transport, codec):
+        self.finished = False
+        self.transport = transport
+        self.codec = codec
+        self.resource = None
+
+    def __iter__(self):
+        return self
+
+    def next(self):
+        if self.finished:
+            raise StopIteration
+
+        try:
+            resp_code, data = self.transport._recv_msg()
+            self.codec.maybe_riak_error(resp_code, data)
+            expect = self._expect
+            self.codec.maybe_incorrect_code(resp_code, expect)
+            resp = self.codec.parse_msg(expect, data)
+        except:
+            self.finished = True
+            raise
+
+        if self._is_done(resp):
+            self.finished = True
+
+        return resp
+
+    def __next__(self):
+        # Python 3.x Version
+        return self.next()
+
+    def _is_done(self, response):
+        # This could break if new messages don't name the field the
+        # same thing.
+        return response.done
+
+    def attach(self, resource):
+        self.resource = resource
+
+    def close(self):
+        # We have to drain the socket to make sure that we don't get
+        # weird responses when some other request comes after a
+        # failed/prematurely-terminated one.
+        try:
+            while self.next():
+                pass
+        except StopIteration:
+            pass
+        self.resource.release()
+
+
+class PbufKeyStream(PbufStream):
+    """
+    Used internally by TcpTransport to implement key-list streams.
+    """
+
+    _expect = riak.pb.messages.MSG_CODE_LIST_KEYS_RESP
+
+    def next(self):
+        response = super(PbufKeyStream, self).next()
+
+        if response.done and len(response.keys) is 0:
+            raise StopIteration
+
+        return response.keys
+
+    def __next__(self):
+        # Python 3.x Version
+        return self.next()
+
+
+class PbufMapredStream(PbufStream):
+    """
+    Used internally by TcpTransport to implement MapReduce
+    streams.
+    """
+
+    _expect = riak.pb.messages.MSG_CODE_MAP_RED_RESP
+
+    def next(self):
+        response = super(PbufMapredStream, self).next()
+
+        if response.done and not response.HasField('response'):
+            raise StopIteration
+
+        return response.phase, json.loads(bytes_to_str(response.response))
+
+    def __next__(self):
+        # Python 3.x Version
+        return self.next()
+
+
+class PbufBucketStream(PbufStream):
+    """
+    Used internally by TcpTransport to implement key-list streams.
+    """
+
+    _expect = riak.pb.messages.MSG_CODE_LIST_BUCKETS_RESP
+
+    def next(self):
+        response = super(PbufBucketStream, self).next()
+
+        if response.done and len(response.buckets) is 0:
+            raise StopIteration
+
+        return response.buckets
+
+    def __next__(self):
+        # Python 3.x Version
+        return self.next()
+
+
+class PbufIndexStream(PbufStream):
+    """
+    Used internally by TcpTransport to implement Secondary Index
+    streams.
+    """
+
+    _expect = riak.pb.messages.MSG_CODE_INDEX_RESP
+
+    def __init__(self, transport, codec, index, return_terms=False):
+        super(PbufIndexStream, self).__init__(transport, codec)
+        self.index = index
+        self.return_terms = return_terms
+
+    def next(self):
+        response = super(PbufIndexStream, self).next()
+
+        if response.done and not (response.keys or
+                                  response.results or
+                                  response.continuation):
+            raise StopIteration
+
+        if self.return_terms and response.results:
+            return [(decode_index_value(self.index, r.key),
+                     bytes_to_str(r.value))
+                    for r in response.results]
+        elif response.keys:
+            if PY2:
+                return response.keys[:]
+            else:
+                return [bytes_to_str(key) for key in response.keys]
+        elif response.continuation:
+            return CONTINUATION(bytes_to_str(response.continuation))
+
+    def __next__(self):
+        # Python 3.x Version
+        return self.next()
+
+
+class PbufTsKeyStream(PbufStream, TtbCodec):
+    """
+    Used internally by TcpTransport to implement TS key-list streams.
+    """
+
+    _expect = riak.pb.messages.MSG_CODE_TS_LIST_KEYS_RESP
+
+    def __init__(self, transport, codec, convert_timestamp=False):
+        super(PbufTsKeyStream, self).__init__(transport, codec)
+        self._convert_timestamp = convert_timestamp
+
+    def next(self):
+        response = super(PbufTsKeyStream, self).next()
+
+        if response.done and len(response.keys) is 0:
+            raise StopIteration
+
+        keys = []
+        for tsrow in response.keys:
+            keys.append(self.codec.decode_timeseries_row(tsrow,
+                        convert_timestamp=self._convert_timestamp))
+
+        return keys
+
+    def __next__(self):
+        # Python 3.x Version
+        return self.next()

riak-2.5.4.tar.gz/riak/transports/tcp/transport.py Added

@@ -0,0 +1,555 @@
+import six
+
+import riak.pb.messages
+
+from riak import RiakError
+from riak.codecs import Codec, Msg
+from riak.codecs.pbuf import PbufCodec
+from riak.codecs.ttb import TtbCodec
+from riak.pb.messages import MSG_CODE_TS_TTB_MSG
+from riak.transports.transport import Transport
+from riak.ts_object import TsObject
+
+from riak.transports.tcp.connection import TcpConnection
+from riak.transports.tcp.stream import (PbufKeyStream,
+                                        PbufMapredStream,
+                                        PbufBucketStream,
+                                        PbufIndexStream,
+                                        PbufTsKeyStream)
+
+
+class TcpTransport(Transport, TcpConnection):
+    """
+    The TcpTransport object holds a connection to the TCP
+    socket on the Riak server.
+    """
+    def __init__(self,
+                 node=None,
+                 client=None,
+                 timeout=None,
+                 **kwargs):
+        super(TcpTransport, self).__init__()
+
+        self._client = client
+        self._node = node
+        self._address = (node.host, node.pb_port)
+        self._timeout = timeout
+        self._socket = None
+        self._pbuf_c = None
+        self._ttb_c = None
+        self._socket_tcp_options = \
+            kwargs.get('socket_tcp_options', {})
+        self._socket_keepalive = \
+            kwargs.get('socket_keepalive', False)
+        self._ts_convert_timestamp = \
+            kwargs.get('ts_convert_timestamp', False)
+        self._use_ttb = \
+            kwargs.get('use_ttb', True)
+
+    def _get_pbuf_codec(self):
+        if not self._pbuf_c:
+            self._pbuf_c = PbufCodec(
+                    self.client_timeouts(), self.quorum_controls(),
+                    self.tombstone_vclocks(), self.bucket_types())
+        return self._pbuf_c
+
+    def _get_ttb_codec(self):
+        if self._use_ttb:
+            if not self._ttb_c:
+                self._ttb_c = TtbCodec()
+            codec = self._ttb_c
+        else:
+            codec = self._get_pbuf_codec()
+        return codec
+
+    def _get_codec(self, msg_code):
+        if msg_code == MSG_CODE_TS_TTB_MSG:
+            codec = self._get_ttb_codec()
+        elif msg_code == riak.pb.messages.MSG_CODE_TS_GET_REQ:
+            codec = self._get_ttb_codec()
+        elif msg_code == riak.pb.messages.MSG_CODE_TS_PUT_REQ:
+            codec = self._get_ttb_codec()
+        elif msg_code == riak.pb.messages.MSG_CODE_TS_QUERY_REQ:
+            codec = self._get_ttb_codec()
+        else:
+            codec = self._get_pbuf_codec()
+        return codec
+
+    # FeatureDetection API
+    def _server_version(self):
+        server_info = self.get_server_info()
+        ver = server_info['server_version']
+        (maj, min, patch) = [int(v) for v in ver.split('.')]
+        if maj == 0:
+            import datetime
+            now = datetime.datetime.now()
+            if now.year == 2016:
+                # GH-471 As of 20160509 Riak TS OSS 1.3.0 returns '0.8.0' as
+                # the version string.
+                return '2.1.1'
+        return ver
+
+    def ping(self):
+        """
+        Ping the remote server
+        """
+        msg_code = riak.pb.messages.MSG_CODE_PING_REQ
+        codec = self._get_codec(msg_code)
+        msg = codec.encode_ping()
+        resp_code, _ = self._request(msg, codec)
+        if resp_code == riak.pb.messages.MSG_CODE_PING_RESP:
+            return True
+        else:
+            return False
+
+    def get_server_info(self):
+        """
+        Get information about the server
+        """
+        # NB: can't do it this way due to recursion
+        # codec = self._get_codec(ttb_supported=False)
+        codec = PbufCodec()
+        msg = Msg(riak.pb.messages.MSG_CODE_GET_SERVER_INFO_REQ, None,
+                  riak.pb.messages.MSG_CODE_GET_SERVER_INFO_RESP)
+        resp_code, resp = self._request(msg, codec)
+        return codec.decode_get_server_info(resp)
+
+    def _get_client_id(self):
+        msg_code = riak.pb.messages.MSG_CODE_GET_CLIENT_ID_REQ
+        codec = self._get_codec(msg_code)
+        msg = codec.encode_get_client_id()
+        resp_code, resp = self._request(msg, codec)
+        return codec.decode_get_client_id(resp)
+
+    def _set_client_id(self, client_id):
+        msg_code = riak.pb.messages.MSG_CODE_SET_CLIENT_ID_REQ
+        codec = self._get_codec(msg_code)
+        msg = codec.encode_set_client_id(client_id)
+        resp_code, resp = self._request(msg, codec)
+        self._client_id = client_id
+
+    client_id = property(_get_client_id, _set_client_id,
+                         doc="""the client ID for this connection""")
+
+    def get(self, robj, r=None, pr=None, timeout=None, basic_quorum=None,
+            notfound_ok=None):
+        """
+        Serialize get request and deserialize response
+        """
+        msg_code = riak.pb.messages.MSG_CODE_GET_REQ
+        codec = self._get_codec(msg_code)
+        msg = codec.encode_get(robj, r, pr,
+                               timeout, basic_quorum,
+                               notfound_ok)
+        resp_code, resp = self._request(msg, codec)
+        return codec.decode_get(robj, resp)
+
+    def put(self, robj, w=None, dw=None, pw=None, return_body=True,
+            if_none_match=False, timeout=None):
+        msg_code = riak.pb.messages.MSG_CODE_PUT_REQ
+        codec = self._get_codec(msg_code)
+        msg = codec.encode_put(robj, w, dw, pw, return_body,
+                               if_none_match, timeout)
+        resp_code, resp = self._request(msg, codec)
+        return codec.decode_put(robj, resp)
+
+    def ts_describe(self, table):
+        query = 'DESCRIBE {table}'.format(table=table.name)
+        return self.ts_query(table, query)
+
+    def ts_get(self, table, key):
+        msg_code = MSG_CODE_TS_TTB_MSG
+        codec = self._get_codec(msg_code)
+        msg = codec.encode_timeseries_keyreq(table, key)
+        resp_code, resp = self._request(msg, codec)
+        tsobj = TsObject(self._client, table)
+        codec.decode_timeseries(resp, tsobj,
+                                self._ts_convert_timestamp)
+        return tsobj
+
+    def ts_put(self, tsobj):
+        msg_code = MSG_CODE_TS_TTB_MSG
+        codec = self._get_codec(msg_code)
+        msg = codec.encode_timeseries_put(tsobj)
+        resp_code, resp = self._request(msg, codec)
+        return codec.validate_timeseries_put_resp(resp_code, resp)
+
+    def ts_delete(self, table, key):
+        msg_code = riak.pb.messages.MSG_CODE_TS_DEL_REQ
+        codec = self._get_codec(msg_code)
+        msg = codec.encode_timeseries_keyreq(table, key, is_delete=True)
+        resp_code, resp = self._request(msg, codec)
+        if resp is not None:
+            return True
+        else:
+            raise RiakError("missing response object")
+
+    def ts_query(self, table, query, interpolations=None):
+        msg_code = riak.pb.messages.MSG_CODE_TS_QUERY_REQ
+        codec = self._get_codec(msg_code)
+        msg = codec.encode_timeseries_query(table, query, interpolations)
+        resp_code, resp = self._request(msg, codec)
+        tsobj = TsObject(self._client, table)
+        codec.decode_timeseries(resp, tsobj,
+                                self._ts_convert_timestamp)
+        return tsobj
+
+    def ts_stream_keys(self, table, timeout=None):
+        """
+        Streams keys from a timeseries table, returning an iterator that

riak-2.1.0.tar.gz/riak/transports/transport.py -> riak-2.5.4.tar.gz/riak/transports/transport.py Changed

@@ -1,32 +1,15 @@
-"""
-Copyright 2010 Rusty Klophaus <rusty@basho.com>
-Copyright 2010 Justin Sheehy <justin@basho.com>
-Copyright 2009 Jay Baird <jay@mochimedia.com>
-
-This file is provided to you under the Apache License,
-Version 2.0 (the "License"); you may not use this file
-except in compliance with the License.  You may obtain
-a copy of the License at
-
-  http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing,
-software distributed under the License is distributed on an
-"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-KIND, either express or implied.  See the License for the
-specific language governing permissions and limitations
-under the License.
-"""
 import base64
 import random
 import threading
-import platform
 import os
 import json
-from feature_detect import FeatureDetection
+import platform
+
+from six import PY2
+from riak.transports.feature_detect import FeatureDetection
 
 
-class RiakTransport(FeatureDetection):
+class Transport(FeatureDetection):
     """
     Class to encapsulate transport details and methods. All protocol
     transports are subclasses of this class.
@@ -46,8 +29,13 @@
         """
         Returns a random client identifier
         """
-        return ('py_%s' %
-                base64.b64encode(str(random.randint(1, 0x40000000))))
+        if PY2:
+            return ('py_%s' %
+                    base64.b64encode(str(random.randint(1, 0x40000000))))
+        else:
+            return ('py_%s' %
+                    base64.b64encode(bytes(str(random.randint(1, 0x40000000)),
+                                     'ascii')))
 
     @classmethod
     def make_fixed_client_id(self):
@@ -86,6 +74,42 @@
         """
         raise NotImplementedError
 
+    def ts_describe(self, table):
+        """
+        Retrieves a timeseries table description.
+        """
+        raise NotImplementedError
+
+    def ts_get(self, table, key):
+        """
+        Retrieves a timeseries object.
+        """
+        raise NotImplementedError
+
+    def ts_put(self, tsobj):
+        """
+        Stores a timeseries object.
+        """
+        raise NotImplementedError
+
+    def ts_delete(self, table, key):
+        """
+        Deletes a timeseries object.
+        """
+        raise NotImplementedError
+
+    def ts_query(self, table, query, interpolations=None):
+        """
+        Query timeseries data.
+        """
+        raise NotImplementedError
+
+    def ts_stream_keys(self, table, timeout=None):
+        """
+        Streams the list of keys for the table through an iterator.
+        """
+        raise NotImplementedError
+
     def get_buckets(self, bucket_type=None, timeout=None):
         """
         Gets the list of buckets as strings.
@@ -166,7 +190,8 @@
         """
         raise NotImplementedError
 
-    def create_search_index(self, index, schema=None, n_val=None):
+    def create_search_index(self, index, schema=None, n_val=None,
+                            timeout=None):
         """
         Creates a yokozuna search index.
         """
@@ -264,6 +289,13 @@
         """
         raise NotImplementedError
 
+    def get_preflist(self, bucket, key):
+        """
+        Fetches the preflist for a bucket/key.
+        """
+        raise NotImplementedError
+
+    # TODO FUTURE NUKE THIS MAPRED
     def _search_mapred_emu(self, index, query):
         """
         Emulates a search request via MapReduce. Used in the case
@@ -289,6 +321,7 @@
             result['docs'].append({u'id': key})
         return result
 
+    # TODO FUTURE NUKE THIS MAPRED
     def _get_index_mapred_emu(self, bucket, index, startkey, endkey=None):
         """
         Emulates a secondary index request via MapReduce. Used in the
@@ -329,6 +362,5 @@
     def _check_bucket_types(self, bucket_type):
         if not self.bucket_types():
             raise NotImplementedError('Server does not support bucket-types')
-
         if bucket_type.is_default():
             raise ValueError('Cannot manipulate the default bucket-type')

riak-2.5.4.tar.gz/riak/ts_object.py Added

@@ -0,0 +1,51 @@
+import collections
+
+from riak import RiakError
+from riak.table import Table
+
+TsColumns = collections.namedtuple('TsColumns', ['names', 'types'])
+
+
+class TsObject(object):
+    """
+    The TsObject holds information about Timeseries data, plus the data
+    itself.
+    """
+    def __init__(self, client, table, rows=None, columns=None):
+        """
+        Construct a new TsObject.
+
+        :param client: A RiakClient object.
+        :type client: :class:`RiakClient <riak.client.RiakClient>`
+        :param table: The table for the timeseries data as a Table object.
+        :type table: :class:`Table` <riak.table.Table>
+        :param rows: An list of lists with timeseries data
+        :type rows: list
+        :param columns: A TsColumns tuple. Optional
+        :type columns: :class:`TsColumns` <riak.TsColumns>
+        """
+
+        if not isinstance(table, Table):
+            raise ValueError('table must be an instance of Table.')
+
+        self.client = client
+        self.table = table
+
+        if rows is not None and not isinstance(rows, list):
+            raise RiakError("TsObject rows parameter must be a list.")
+        else:
+            self.rows = rows
+
+        if columns is not None and \
+           not isinstance(columns, TsColumns):
+            raise RiakError(
+                "TsObject columns parameter must be a TsColumns instance")
+        else:
+            self.columns = columns
+
+    def store(self):
+        """
+        Store the timeseries data in Riak.
+        :rtype: boolean
+        """
+        return self.client.ts_put(self)

riak-2.5.4.tar.gz/riak/tz.py Added

riak-2.1.0.tar.gz/riak/util.py -> riak-2.5.4.tar.gz/riak/util.py Changed

@@ -1,23 +1,44 @@
-"""
-Copyright 2010 Basho Technologies, Inc.
+from __future__ import print_function
 
-This file is provided to you under the Apache License,
-Version 2.0 (the "License"); you may not use this file
-except in compliance with the License.  You may obtain
-a copy of the License at
+import datetime
+import sys
+import warnings
 
-  http://www.apache.org/licenses/LICENSE-2.0
+from collections import Mapping
+from six import string_types, PY2
 
-Unless required by applicable law or agreed to in writing,
-software distributed under the License is distributed on an
-"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-KIND, either express or implied.  See the License for the
-specific language governing permissions and limitations
-under the License.
-"""
+epoch = datetime.datetime.utcfromtimestamp(0)
+try:
+    import pytz
+    epoch_tz = pytz.utc.localize(epoch)
+except ImportError:
+    from riak.tz import utc
+    epoch_tz = datetime.datetime.fromtimestamp(0, tz=utc)
 
-import warnings
-from collections import Mapping
+
+def unix_time_millis(dt):
+    if dt.tzinfo:
+        td = dt - epoch_tz
+    else:
+        td = dt - epoch
+    tdms = ((td.days * 24 * 3600) + td.seconds) * 1000
+    ms = td.microseconds // 1000
+    return tdms + ms
+
+
+def datetime_from_unix_time_millis(ut):
+    if isinstance(ut, float):
+        raise ValueError('unix timestamp must not be a float, '
+                         'it must be total milliseconds since '
+                         'epoch as an integer')
+    utms = ut / 1000.0
+    return datetime.datetime.utcfromtimestamp(utms)
+
+
+def is_timeseries_supported(v=None):
+    if v is None:
+        v = sys.version_info
+    return v < (3,) or (v[:3] >= (3, 4, 4) and v[:3] != (3, 5, 0))
 
 
 def quacks_like_dict(object):
@@ -46,8 +67,8 @@
             if key not in current_dst:
                 current_dst[key] = current_src[key]
             else:
-                if (quacks_like_dict(current_src[key])
-                        and quacks_like_dict(current_dst[key])):
+                if (quacks_like_dict(current_src[key]) and
+                        quacks_like_dict(current_dst[key])):
                     stack.append((current_dst[key], current_src[key]))
                 else:
                     current_dst[key] = current_src[key]
@@ -67,7 +88,6 @@
     memoization of an object attribute. The property should represent
     immutable data, as it replaces itself on first access.
     '''
-
     def __init__(self, fget):
         self.fget = fget
         self.func_name = fget.__name__
@@ -81,7 +101,36 @@
 
 
 def decode_index_value(index, value):
-    if "_int" in index:
-        return long(value)
-    else:
+    if "_int" in bytes_to_str(index):
+        return str_to_long(value)
+    elif PY2:
         return str(value)
+    else:
+        return bytes_to_str(value)
+
+
+def bytes_to_str(value, encoding='utf-8'):
+    if isinstance(value, string_types) or value is None:
+        return value
+    elif isinstance(value, list):
+        return [bytes_to_str(elem) for elem in value]
+    else:
+        return value.decode(encoding)
+
+
+def str_to_bytes(value, encoding='utf-8'):
+    if PY2 or value is None:
+        return value
+    elif isinstance(value, list):
+        return [str_to_bytes(elem) for elem in value]
+    else:
+        return value.encode(encoding)
+
+
+def str_to_long(value, base=10):
+    if value is None:
+        return None
+    elif PY2:
+        return long(value, base)  # noqa
+    else:
+        return int(value, base)

riak-2.1.0.tar.gz/setup.cfg -> riak-2.5.4.tar.gz/setup.cfg Changed

riak-2.1.0.tar.gz/setup.py -> riak-2.5.4.tar.gz/setup.py Changed

@@ -1,15 +1,36 @@
 #!/usr/bin/env python
-import platform
+
+import codecs
+import sys
+
 from setuptools import setup, find_packages
 from version import get_version
-from commands import preconfigure, configure, create_bucket_types, \
-    setup_security, enable_security, disable_security
+from commands import setup_timeseries, build_messages
+
+install_requires = ['six >= 1.8.0', 'basho_erlastic >= 2.1.1']
+requires = ['six(>=1.8.0)', 'basho_erlastic(>= 2.1.1)']
+
+if sys.version_info[:3] <= (2, 7, 9):
+    install_requires.append("pyOpenSSL >= 0.14")
+    requires.append("pyOpenSSL(>=0.14)")
+
+if sys.version_info[:3] <= (3, 0, 0):
+    install_requires.append('protobuf >=2.4.1, <2.7.0')
+    requires.append('protobuf(>=2.4.1, <2.7.0)')
+else:
+    install_requires.append('python3_protobuf >=2.4.1, <2.6.0')
+    requires.append('python3_protobuf(>=2.4.1, <2.6.0)')
+
+with codecs.open('README.md', 'r', 'utf-8') as f:
+    readme_md = f.read()
 
-install_requires = ["riak_pb >=2.0.0", "pyOpenSSL >= 0.14"]
-requires = ["riak_pb(>=2.0.0)", "pyOpenSSL(>=0.14)"]
-tests_require = []
-if platform.python_version() < '2.7':
-    tests_require.append("unittest2")
+try:
+    import pypandoc
+    long_description = pypandoc.convert('README.md', 'rst')
+    with codecs.open('README.rst', 'w', 'utf-8') as f:
+        f.write(long_description)
+except(IOError, ImportError):
+    long_description = readme_md
 
 setup(
     name='riak',
@@ -17,9 +38,9 @@
     packages=find_packages(),
     requires=requires,
     install_requires=install_requires,
-    tests_require=tests_require,
     package_data={'riak': ['erl_src/*']},
     description='Python client for Riak',
+    long_description=long_description,
     zip_safe=True,
     options={'easy_install': {'allow_hosts': 'pypi.python.org'}},
     include_package_data=True,
@@ -29,14 +50,16 @@
     author_email='clients@basho.com',
     test_suite='riak.tests.suite',
     url='https://github.com/basho/riak-python-client',
-    cmdclass={'create_bucket_types': create_bucket_types,
-              'setup_security': setup_security,
-              'preconfigure': preconfigure,
-              'configure': configure,
-              'enable_security': enable_security,
-              'disable_security': disable_security},
+    cmdclass={
+        'build_messages': build_messages,
+        'setup_timeseries': setup_timeseries
+    },
     classifiers=['License :: OSI Approved :: Apache Software License',
                  'Intended Audience :: Developers',
                  'Operating System :: OS Independent',
+                 'Programming Language :: Python :: 2.7',
+                 'Programming Language :: Python :: 3.3',
+                 'Programming Language :: Python :: 3.4',
+                 'Programming Language :: Python :: 3.5',
                  'Topic :: Database']
     )

riak-2.1.0.tar.gz/version.py -> riak-2.5.4.tar.gz/version.py Changed