From c14bae60505d23b3151e9914d56df44c43646315 Mon Sep 17 00:00:00 2001 From: Noah Levitt Date: Wed, 1 Mar 2017 11:20:27 -0800 Subject: [PATCH] new convention, call Rethinker object `rr` (mnemonic RethinkeR, or *double*[think]), leave rethinkdb as `r` per the rethinkdb convention --- README.rst | 14 ++--- doublethink/orm.py | 26 ++++----- doublethink/rethinker.py | 16 +++--- doublethink/services.py | 28 +++++----- setup.py | 2 +- tests/test_rethinker.py | 114 +++++++++++++++++++-------------------- 6 files changed, 100 insertions(+), 100 deletions(-) diff --git a/README.rst b/README.rst index 646e816..c77f05b 100644 --- a/README.rst +++ b/README.rst @@ -25,9 +25,9 @@ Usage Example :: import doublethink - r = doublethink.Rethinker(['db0.foo.com', 'db0.foo.com:38015', 'db1.foo.com'], 'my_db') - r.table('mytable').insert({'foo':'bar','baz':2}).run() - for result in r.table('mytable'): + rr = doublethink.Rethinker(['db0.foo.com', 'db0.foo.com:38015', 'db1.foo.com'], 'my_db') + rr.table('mytable').insert({'foo':'bar','baz':2}).run() + for result in rr.table('mytable'): print("result={}".format(result)) ORM @@ -42,16 +42,16 @@ Usage Example import doublethink - r = doublethink.Rethinker(['db0.foo.com', 'db0.foo.com:38015', 'db1.foo.com'], 'my_db') + rr = doublethink.Rethinker(['db0.foo.com', 'db0.foo.com:38015', 'db1.foo.com'], 'my_db') class MyTable(doublethink.Document): pass - MyTable.table_create() + MyTable.table_create(rr) - doc1 = MyTable(r, {'animal': 'elephant', 'size': 'large'}) + doc1 = MyTable(rr, {'animal': 'elephant', 'size': 'large'}) doc1.save() - doc1_copy = MyTable.get(r, doc1.id) + doc1_copy = MyTable.get(rr, doc1.id) doc1_copy.food = 'bread' doc1_copy.save() diff --git a/doublethink/orm.py b/doublethink/orm.py index c264f2f..be4452c 100644 --- a/doublethink/orm.py +++ b/doublethink/orm.py @@ -158,25 +158,25 @@ class Document(dict, object): return cls.__name__.lower() @classmethod - def load(cls, rethinker, pk): + def load(cls, rr, pk): ''' Retrieves a document from the database, by primary key. ''' - doc = cls(rethinker) + doc = cls(rr) doc[doc.pk_field] = pk doc.refresh() return doc @classmethod - def table_create(cls, rethinker): + def table_create(cls, rr): ''' Creates the table. Subclasses may want to override this method to do more things, such as creating secondary indexes. ''' - rethinker.table_create(cls.table).run() + rr.table_create(cls.table).run() - def __init__(self, rethinker, d={}): - self._r = rethinker + def __init__(self, rr, d={}): + dict.__setattr__(self, 'rr', rr) self._pk = None self._clear_updates() for k in d: @@ -235,14 +235,14 @@ class Document(dict, object): ''' if not self._pk: try: - pk = self._r.db('rethinkdb').table('table_config').filter({ - 'db': self._r.dbname, 'name': self.table}).get_field( + pk = self.rr.db('rethinkdb').table('table_config').filter({ + 'db': self.rr.dbname, 'name': self.table}).get_field( 'primary_key')[0].run() self._pk = pk except Exception as e: raise Exception( 'problem determining primary key for table %s.%s: %s', - self._r.dbname, self.table, e) + self.rr.dbname, self.table, e) return self._pk @property @@ -270,7 +270,7 @@ class Document(dict, object): # r.literal() to replace, not merge with, nested fields updates = {field: r.literal(self._updates[field]) for field in self._updates} - query = self._r.table(self.table).get( + query = self.rr.table(self.table).get( self.pk_value).update(updates) result = query.run() if result['skipped']: # primary key not found @@ -280,7 +280,7 @@ class Document(dict, object): 'unexpected result %s from rethinkdb query %s' % ( result, query)) if not should_insert and self._deletes: - query = self._r.table(self.table).replace( + query = self.rr.table(self.table).replace( r.row.without(self._deletes)) result = query.run() if result['errors']: # primary key not found @@ -293,7 +293,7 @@ class Document(dict, object): should_insert = True if should_insert: - query = self._r.table(self.table).insert(self) + query = self.rr.table(self.table).insert(self) result = query.run() if result['inserted'] != 1: raise Exception( @@ -309,7 +309,7 @@ class Document(dict, object): ''' Refresh the document from the database. ''' - d = self._r.table(self.table).get(self.pk_value).run() + d = self.rr.table(self.table).get(self.pk_value).run() if d is None: raise KeyError for k in d: diff --git a/doublethink/rethinker.py b/doublethink/rethinker.py index 277d874..b0135c7 100644 --- a/doublethink/rethinker.py +++ b/doublethink/rethinker.py @@ -24,16 +24,16 @@ import types class RethinkerWrapper(object): logger = logging.getLogger('doublethink.RethinkerWrapper') - def __init__(self, rethinker, wrapped): - self.rethinker = rethinker + def __init__(self, rr, wrapped): + self.rr = rr self.wrapped = wrapped def __getattr__(self, name): delegate = getattr(self.wrapped, name) - return self.rethinker.wrap(delegate) + return self.rr.wrap(delegate) def __getitem__(self, key): - return self.rethinker.wrap(self.wrapped.__getitem__)(key) + return self.rr.wrap(self.wrapped.__getitem__)(key) def __repr__(self): return ''.format(repr(self.wrapped)) @@ -41,10 +41,10 @@ class RethinkerWrapper(object): def run(self, db=None): self.wrapped.run # raise AttributeError early while True: - conn = self.rethinker._random_server_connection() + conn = self.rr._random_server_connection() is_iter = False try: - result = self.wrapped.run(conn, db=db or self.rethinker.dbname) + result = self.wrapped.run(conn, db=db or self.rr.dbname) if hasattr(result, '__next__'): is_iter = True def gen(): @@ -72,8 +72,8 @@ class RethinkerWrapper(object): class Rethinker(object): ''' - >>> r = Rethinker(db='my_db') - >>> doc = r.table('my_table').get(1).run() + >>> rr = Rethinker(db='my_db') + >>> doc = rr.table('my_table').get(1).run() ''' logger = logging.getLogger('doublethink.Rethinker') diff --git a/doublethink/services.py b/doublethink/services.py index 4786e91..c1cfc8b 100644 --- a/doublethink/services.py +++ b/doublethink/services.py @@ -39,20 +39,20 @@ class ServiceRegistry(object): logger = logging.getLogger('doublethink.ServiceRegistry') - def __init__(self, rethinker): - self.r = rethinker + def __init__(self, rr): + self.rr = rr self._ensure_table() def _ensure_table(self): - dbs = self.r.db_list().run() - if not self.r.dbname in dbs: - self.logger.info('creating rethinkdb database %s', repr(self.r.dbname)) - self.r.db_create(self.r.dbname).run() - tables = self.r.table_list().run() + dbs = self.rr.db_list().run() + if not self.rr.dbname in dbs: + self.logger.info('creating rethinkdb database %s', repr(self.rr.dbname)) + self.rr.db_create(self.rr.dbname).run() + tables = self.rr.table_list().run() if not 'services' in tables: - self.logger.info("creating rethinkdb table 'services' in database %s", repr(self.r.dbname)) - self.r.table_create('services', shards=1, replicas=min(3, len(self.r.servers))).run() - # self.r.table('sites').index_create...? + self.logger.info("creating rethinkdb table 'services' in database %s", repr(self.rr.dbname)) + self.rr.table_create('services', shards=1, replicas=min(3, len(self.rr.servers))).run() + # self.rr.table('sites').index_create...? def heartbeat(self, status_info): ''' @@ -68,7 +68,7 @@ class ServiceRegistry(object): if not 'pid' in updated_status_info: updated_status_info['pid'] = os.getpid() try: - result = self.r.table('services').insert( + result = self.rr.table('services').insert( updated_status_info, conflict='replace', return_changes=True).run() return result['changes'][0]['new_val'] # XXX check @@ -77,13 +77,13 @@ class ServiceRegistry(object): return status_info def unregister(self, id): - result = self.r.table('services').get(id).delete().run() + result = self.rr.table('services').get(id).delete().run() if result != {'deleted':1,'errors':0,'inserted':0,'replaced':0,'skipped':0,'unchanged':0}: self.logger.warn('unexpected result attempting to delete id=%s from rethinkdb services table: %s', id, result) def available_service(self, role): try: - result = self.r.table('services').filter({"role":role}).filter( + result = self.rr.table('services').filter({"role":role}).filter( lambda svc: r.now().sub(svc["last_heartbeat"]) < 3 * svc["heartbeat_interval"] #.default(20.0) ).order_by("load")[0].run() return result @@ -92,7 +92,7 @@ class ServiceRegistry(object): def available_services(self, role=None): try: - query = self.r.table('services') + query = self.rr.table('services') if role: query = query.filter({"role":role}) query = query.filter( diff --git a/setup.py b/setup.py index ab1d077..fe3da61 100644 --- a/setup.py +++ b/setup.py @@ -3,7 +3,7 @@ import codecs setuptools.setup( name='doublethink', - version='0.2.0.dev65', + version='0.2.0.dev66', packages=['doublethink'], classifiers=[ 'Programming Language :: Python :: 2.7', diff --git a/tests/test_rethinker.py b/tests/test_rethinker.py index 5ba6295..3ad3487 100644 --- a/tests/test_rethinker.py +++ b/tests/test_rethinker.py @@ -22,7 +22,7 @@ import sys import types import gc import pytest -import rethinkdb +import rethinkdb as r import time import socket import os @@ -41,82 +41,82 @@ class RethinkerForTesting(doublethink.Rethinker): return self.last_conn @pytest.fixture(scope="module") -def r(): - r = RethinkerForTesting() +def rr(): + rr = RethinkerForTesting() try: - r.db_drop("doublethink_test_db").run() - except rethinkdb.errors.ReqlOpFailedError: + rr.db_drop("doublethink_test_db").run() + except r.errors.ReqlOpFailedError: pass - result = r.db_create("doublethink_test_db").run() - assert not r.last_conn.is_open() + result = rr.db_create("doublethink_test_db").run() + assert not rr.last_conn.is_open() assert result["dbs_created"] == 1 return RethinkerForTesting(db="doublethink_test_db") @pytest.fixture(scope="module") -def my_table(r): - assert r.table_list().run() == [] - result = r.table_create("my_table").run() - assert not r.last_conn.is_open() +def my_table(rr): + assert rr.table_list().run() == [] + result = rr.table_create("my_table").run() + assert not rr.last_conn.is_open() assert result["tables_created"] == 1 -def test_rethinker(r, my_table): - assert r.table("my_table").index_create("foo").run() == {"created": 1} - assert not r.last_conn.is_open() +def test_rethinker(rr, my_table): + assert rr.table("my_table").index_create("foo").run() == {"created": 1} + assert not rr.last_conn.is_open() - result = r.table("my_table").insert(({"foo":i,"bar":"repeat"*i} for i in range(2000))).run() - assert not r.last_conn.is_open() + result = rr.table("my_table").insert(({"foo":i,"bar":"repeat"*i} for i in range(2000))).run() + assert not rr.last_conn.is_open() assert len(result["generated_keys"]) == 2000 assert result["inserted"] == 2000 - result = r.table("my_table").run() - assert r.last_conn.is_open() # should still be open this time + result = rr.table("my_table").run() + assert rr.last_conn.is_open() # should still be open this time assert isinstance(result, types.GeneratorType) n = 0 for x in result: n += 1 pass # connection should be closed after finished iterating over results - assert not r.last_conn.is_open() + assert not rr.last_conn.is_open() assert n == 2000 - result = r.table("my_table").run() - assert r.last_conn.is_open() # should still be open this time + result = rr.table("my_table").run() + assert rr.last_conn.is_open() # should still be open this time assert isinstance(result, types.GeneratorType) next(result) result = None gc.collect() # connection should be closed after result is garbage-collected - assert not r.last_conn.is_open() + assert not rr.last_conn.is_open() - result = r.table("my_table").run() - assert r.last_conn.is_open() # should still be open this time + result = rr.table("my_table").run() + assert rr.last_conn.is_open() # should still be open this time assert isinstance(result, types.GeneratorType) result = None gc.collect() # connection should be closed after result is garbage-collected - assert not r.last_conn.is_open() + assert not rr.last_conn.is_open() -def test_too_many_errors(r): - with pytest.raises(rethinkdb.errors.ReqlOpFailedError): - r.table_create("too_many_replicas", replicas=99).run() - with pytest.raises(rethinkdb.errors.ReqlOpFailedError): - r.table_create("too_many_shards", shards=99).run() +def test_too_many_errors(rr): + with pytest.raises(r.errors.ReqlOpFailedError): + rr.table_create("too_many_replicas", replicas=99).run() + with pytest.raises(r.errors.ReqlOpFailedError): + rr.table_create("too_many_shards", shards=99).run() -def test_slice(r, my_table): +def test_slice(rr, my_table): """Tests RethinkerWrapper.__getitem__()""" - result = r.table("my_table")[5:10].run() - assert r.last_conn.is_open() # should still be open this time + result = rr.table("my_table")[5:10].run() + assert rr.last_conn.is_open() # should still be open this time assert isinstance(result, types.GeneratorType) n = 0 for x in result: n += 1 pass # connection should be closed after finished iterating over results - assert not r.last_conn.is_open() + assert not rr.last_conn.is_open() assert n == 5 -def test_service_registry(r): - svcreg = doublethink.ServiceRegistry(r) +def test_service_registry(rr): + svcreg = doublethink.ServiceRegistry(rr) assert svcreg.available_service("yes-such-role") == None assert svcreg.available_services("yes-such-role") == [] assert svcreg.available_services() == [] @@ -235,19 +235,19 @@ def test_service_registry(r): assert len(svcreg.available_services("yes-such-role")) == 2 assert len(svcreg.available_services()) == 4 -def test_svcreg_heartbeat_server_down(r): +def test_svcreg_heartbeat_server_down(rr): class MockRethinker: def table(self, *args, **kwargs): raise Exception('catch me if you can') class SortOfFakeServiceRegistry(doublethink.ServiceRegistry): def __init__(self, rethinker): - self.r = rethinker + self.rr = rethinker # self._ensure_table() # not doing this here # no such rethinkdb server - r = MockRethinker() - svcreg = SortOfFakeServiceRegistry(r) + rr = MockRethinker() + svcreg = SortOfFakeServiceRegistry(rr) svc0 = { "role": "role-foo", "load": 100.0, @@ -279,19 +279,19 @@ def test_utcnow(): ## XXX what else can we test without jumping through hoops? -def test_orm(r): +def test_orm(rr): class SomeDoc(doublethink.Document): table = 'some_doc' - SomeDoc.table_create(r) + SomeDoc.table_create(rr) with pytest.raises(Exception): - SomeDoc.table_create(r) + SomeDoc.table_create(rr) # test that overriding Document.table works - assert 'some_doc' in r.table_list().run() - assert not 'somedoc' in r.table_list().run() + assert 'some_doc' in rr.table_list().run() + assert not 'somedoc' in rr.table_list().run() - d = SomeDoc(rethinker=r, d={ + d = SomeDoc(rr, d={ 'a': 'b', 'c': {'d': 'e'}, 'f': ['g', 'h'], @@ -410,7 +410,7 @@ def test_orm(r): assert d._updates == {} assert d._deletes == set() - d_copy = SomeDoc.load(r, d.id) + d_copy = SomeDoc.load(rr, d.id) assert d == d_copy d['zuh'] = 'toot' d.save() @@ -450,7 +450,7 @@ def test_orm(r): assert d._updates == {} assert d._deletes == set() - d_copy = SomeDoc.load(r, d.id) + d_copy = SomeDoc.load(rr, d.id) assert d == d_copy d['yuh'] = 'soot' d.save() @@ -458,19 +458,19 @@ def test_orm(r): d_copy.refresh() assert d == d_copy -def test_orm_pk(r): +def test_orm_pk(rr): class NonstandardPrimaryKey(doublethink.Document): @classmethod def table_create(cls, rethinker): rethinker.table_create(cls.table, primary_key='not_id').run() with pytest.raises(Exception): - NonstandardPrimaryKey.load(r, 'no_such_thing') + NonstandardPrimaryKey.load(rr, 'no_such_thing') - NonstandardPrimaryKey.table_create(r) + NonstandardPrimaryKey.table_create(rr) # new empty doc - f = NonstandardPrimaryKey(r, {}) + f = NonstandardPrimaryKey(rr, {}) f.save() assert f.pk_value assert 'not_id' in f @@ -478,19 +478,19 @@ def test_orm_pk(r): assert len(f.keys()) == 1 with pytest.raises(KeyError): - NonstandardPrimaryKey.load(r, 'no_such_thing') + NonstandardPrimaryKey.load(rr, 'no_such_thing') # new doc with (only) primary key - d = NonstandardPrimaryKey(r, {'not_id': 1}) + d = NonstandardPrimaryKey(rr, {'not_id': 1}) assert d.not_id == 1 assert d.pk_value == 1 d.save() - d_copy = NonstandardPrimaryKey.load(r, 1) + d_copy = NonstandardPrimaryKey.load(rr, 1) assert d == d_copy # new doc with something in it - e = NonstandardPrimaryKey(r, {'some_field': 'something'}) + e = NonstandardPrimaryKey(rr, {'some_field': 'something'}) with pytest.raises(KeyError): e['not_id'] assert e.not_id is None @@ -498,7 +498,7 @@ def test_orm_pk(r): e.save() assert e.not_id - e_copy = NonstandardPrimaryKey.load(r, e.not_id) + e_copy = NonstandardPrimaryKey.load(rr, e.not_id) assert e == e_copy e_copy['blah'] = 'toot' e_copy.save()