def __init__(self, *args, **kwargs):
super(RliteConnection, self).__init__(*args, **kwargs)
self.rlite = hirlite.Rlite(path=self.filename)
self.q = Queue()
if self.db:
self.send_command('SELECT', self.db)
self.read_response()
def update_timestamp(key, timestamp):
'''update the redis key with timestamp
:param key: unique identifier
:param timestamp: timestamp
'''
import hirlite
rlite = hirlite.Rlite(path='timer.rld')
rlite.command('set', key, timestamp)
def test_pubsub(self):
self.assertEquals([b'subscribe', b'channel', 1],
self.rlite.command('subscribe', 'channel',
'channel2'))
self.assertEquals([b'subscribe', b'channel2', 2],
self.rlite.command('__rlite_poll'))
rlite2 = hirlite.Rlite(PersistentTest.PATH)
self.assertEquals(1, rlite2.command('publish', 'channel',
'hello world'))
r = self.rlite.command('__rlite_poll', '0')
self.assertEquals(r, [b'message', b'channel', b'hello world'])
self.assertEquals([b'unsubscribe', b'channel2', 1],
self.rlite.command('unsubscribe'))
self.assertEquals([b'unsubscribe', b'channel', 0],
self.rlite.command('__rlite_poll'))
self.assertEquals(None, self.rlite.command('__rlite_poll'))
def __init__(self,
name=None,
fn=None,
use_secret=CRYPT_USE_SECRET,
path_secret=PATH_CRYPT_SECRET,
encrypt_values=False,
encryptor_func=None,
decryptor_func=None):
# defaults
if not name and fn: name = os.path.basename(fn).replace('.', '_')
self.name, self.fn = name, fn
# use secret? for salting
if use_secret and path_secret:
if not os.path.exists(path_secret):
self.secret = get_random_binary_id()
from comrad.backend.keymaker import make_key_discreet
self.log('shhh! creating secret:',
make_key_discreet(self.secret))
with open(path_secret, 'wb') as of:
of.write(self.secret)
else:
with open(path_secret, 'rb') as f:
self.secret = f.read()
else:
self.secret = b''
self.encrypt_values = encrypt_values
if self.secret and encrypt_values and (not encryptor_func
or not decryptor_func):
from comrad.backend.keymaker import ComradSymmetricKeyWithPassphrase
self.key = ComradSymmetricKeyWithPassphrase(passphrase=self.secret)
encryptor_func = self.key.encrypt
decryptor_func = self.key.decrypt
self.encryptor_func = encryptor_func
self.decryptor_func = decryptor_func
# self.store = FilesystemStore(self.fn)
# self.store = RedisStore(redis.StrictRedis())
# self.db = Vedis(self.fn)
# self.db = WalrusLite(self.fn)
import hirlite
self.db = hirlite.Rlite(path=self.fn)
def get_timestamp(key):
'''Fetch last runtime
:param key: unique identifier
'''
from datetime import datetime, timedelta
import hirlite
rlite = hirlite.Rlite(path='timer.rld')
if rlite.command('get', key):
timestamp = rlite.command('get', key)
else:
timestamp = datetime.utcnow() - timedelta(minutes=60)
try: #py3
timestamp = timestamp.decode("utf-8")
except AttributeError:
timestamp = timestamp
return timestamp
def initRLite(the_path='./translation.rdb'):
global _rlite
_rlite = hirlite.Rlite(encoding='utf8', path=the_path)
def test_write_close_open(self):
self.rlite.command('set', 'key', 'value')
self.rlite = hirlite.Rlite(
PersistentTest.PATH) # close db, open a new one
self.assertEquals(b'value', self.rlite.command('get', 'key'))
def setUp(self):
if os.path.exists(PersistentTest.PATH):
os.unlink(PersistentTest.PATH)
self.rlite = hirlite.Rlite(PersistentTest.PATH)
def setUp(self):
self.rlite = hirlite.Rlite()
def test_encoding(self):
snowman = b'\xe2\x98\x83'
self.assertEquals(snowman, self.rlite.command('ping', snowman))
self.rlite = hirlite.Rlite(encoding='utf8')
self.assertEquals(snowman.decode('utf-8'),
self.rlite.command('ping', snowman))