def send_message():
outsock = DieselZMQSocket(zctx.socket(zmq.DEALER), connect="tcp://127.0.0.1:5000")
for x in xrange(500000):
outsock.send("yo dawg %s" % x)
if x % 1000 == 0:
sleep()
def send_message():
outsock = DieselZMQSocket(zctx.socket(zmq.DEALER),
connect="tcp://127.0.0.1:5000")
for x in xrange(500000):
outsock.send("yo dawg %s" % x)
if x % 1000 == 0:
sleep()
def handle_messages():
insock = DieselZMQSocket(zctx.socket(zmq.DEALER), bind="inproc://foo")
for x in xrange(500000):
msg = insock.recv()
assert msg == "yo dawg %s" % x
delt = time.time() - t
print "500000 messages in %ss (%.1f/s)" % (delt, 500000.0 / delt)
quickstop()
def send_message():
global t
outsock = DieselZMQSocket(zctx.socket(zmq.DEALER), connect="inproc://foo")
t = time.time()
for x in xrange(500000):
outsock.send("yo dawg %s" % x)
if x % 1000 == 0:
sleep()
def echo_client():
sock = zctx.socket(zmq.DEALER)
sock.identity = "client:%d" % cids.pop()
s = DieselZMQSocket(sock, connect='tcp://127.0.0.1:4321')
for i in xrange(10):
s.send('msg:%d' % i)
r = s.recv()
assert r == 'msg:%d' % i
print sock.identity, 'received', r
def echo_client():
sock = zctx.socket(zmq.DEALER)
sock.identity = "client:%d" % cids.pop()
s = DieselZMQSocket(sock, connect='tcp://127.0.0.1:4321')
for i in xrange(10):
s.send('msg:%d' % i)
r = s.recv()
assert r == 'msg:%d' % i
print sock.identity, 'received', r
def get_messages():
outsock = DieselZMQSocket(zctx.socket(zmq.DEALER), bind="tcp://127.0.0.1:5000")
t = time.time()
for x in xrange(500000):
msg = outsock.recv()
assert msg == "yo dawg %s" % x
if x % 1000 == 0:
sleep()
delt = time.time() - t
print "500000 messages in %ss (%.1f/s)" % (delt, 500000.0 / delt)
quickstop()
def get_messages():
outsock = DieselZMQSocket(zctx.socket(zmq.DEALER),
bind="tcp://127.0.0.1:5000")
t = time.time()
for x in xrange(500000):
msg = outsock.recv()
assert msg == "yo dawg %s" % x
if x % 1000 == 0:
sleep()
delt = time.time() - t
print "500000 messages in %ss (%.1f/s)" % (delt, 500000.0 / delt)
quickstop()
def get_messages():
outsock = DieselZMQSocket(zctx.socket(zmq.DEALER),
bind="tcp://127.0.0.1:5000")
for x in xrange(1000):
t, m = first(sleep=1.0, waits=[outsock])
if t == 'sleep':
print "sleep timeout!"
else:
print "zmq:", m
quickstop()
def __init__(self, host, port, timeout=30, logger=default_logger):
self._sock = DieselZMQSocket(zctx.socket(zmq.REQ), connect="tcp://%s:%d" % (host, port))
self.timeout = timeout
self.logger = logger
self.is_closed = False
class MontageClient(object):
# __init__ :: string -> int -> (int) -> (f(start, result)) -> client
def __init__(self, host, port, timeout=30, logger=default_logger):
self._sock = DieselZMQSocket(zctx.socket(zmq.REQ), connect="tcp://%s:%d" % (host, port))
self.timeout = timeout
self.logger = logger
self.is_closed = False
def close(self):
self.is_closed = True
self._sock.__exit__()
self._sock = None
@property
def sock(self):
assert self._sock is not None, 'The socket has already been closed'
return self._sock
# for flexibility in put_many
def newMontageObject(self, bucket, key, data, vclock=None):
obj = proto.MontageObject(bucket=bucket,
key=key)
obj.data = data
if vclock:
obj.vclock = vclock
return obj
def _monitor_get(self, start, result):
duration = time.time() - start
#if duration > 1:
if True:
self.logger('DB', 'SLOW_FETCH',
action='MONTAGE_GET',
bucket=result.bucket,
key=result.key,
duration=duration,
length=len(result.data) if result else 0)
if result and len(result.data) > 2097152: # two megabytes
self.logger('DB', 'BIG_FETCH',
action='MONTAGE_GET',
bucket=result.bucket,
key=result.key,
duration=duration,
length=len(result.data))
if result and result.fetch_resolutions__exists and result.fetch_resolutions > 10:
self.logger('DB', 'MANY_SIBLINGS_FETCH',
action='MONTAGE_GET',
bucket=result.bucket,
key=result.key,
duration=duration,
length=len(result.data),
num_siblings=result.fetch_resolutions)
# get :: bucket -> key -> MontageObject
def get(self, bucket, key):
req = proto.MontageGet(bucket=bucket,key=key)
start = time.time()
resp = self._do_request(req, bucket, key)
assert len(resp.status) == 1, \
'There should only be one status response'
assert len(resp.subs) == 0, \
'There should not be any subqueries'
status = resp.status[0]
if status == proto.MISSING:
return None
if status == proto.EXISTS:
self._monitor_get(start, resp.master)
return resp.master
else:
raise RiakException('Error fetching from magicd (b=%s, k=%s)' % (bucket, key))
def _get_subs(self, start, resp):
out = []
i = 0
for status in resp.status:
if status == proto.MISSING:
out.append(None)
if status == proto.EXISTS:
sub = resp.subs[i]
self._monitor_get(start, sub)
out.append(sub)
i += 1
assert i == len(resp.subs), "incomplete status list"
return out
# get_many :: [(bucket, key)] -> [MontageObject
def get_many(self, buckets_keys):
req = proto.MontageGetMany()
gets_ = []
for (b, k) in buckets_keys:
gets_.append(proto.MontageGet(bucket=b, key=k))
req.gets.set(gets_)
start = time.time()
resp = self._do_request(req)
assert len(resp.status) == len(buckets_keys), \
'You should receive as many status responses as you requested'
return self._get_subs(start, resp)
# get_by :: bucket -> key -> [target_bucket] -> [MontageObject]
def get_by(self, bucket, key, targets):
return self.get_by_(bucket=bucket, key=key, targets=targets)[1]
# returns ref key (as MontageObject) along with values
# get_by_ :: bucket -> key -> [target_bucket] -> (MontageObject, [MontageObject])
def get_by_(self, bucket, key, targets):
req = proto.MontageGetReference(bucket=bucket, key=key)
req.target_buckets.set(targets)
start = time.time()
resp = self._do_request(req, bucket, key)
return (resp.master, self._get_subs(start, resp))
# delete :: bucket -> key -> ()
def delete(self, bucket, key):
req = proto.MontageDelete(bucket=bucket, key=key)
resp = self._do_request(req, bucket, key)
assert isinstance(resp, proto.MontageDeleteResponse), \
'Delete should always get DeleteResponse back'
# put :: bucket -> key -> data -> (vclock) -> obj
def put(self, bucket, key, data, vclock=None):
req = proto.MontagePut(object=self.newMontageObject(bucket=bucket,
key=key,
data=data,
vclock=vclock))
resp = self._do_request(req)
if resp.modified:
return resp.object
else:
return None
# put_many :: [obj] -> [obj]
def put_many(self, mos):
req = proto.MontagePutMany()
req.objects.set(mos)
resp = self._do_request(req)
return [ r.object for r in resp.objects ]
def command(self, command, argument):
req = proto.MontageCommand(command=command,
argument=argument)
resp = self._do_request(req)
return resp
def _do_request(self, req, bucket=None, key=None):
try:
return self.recv(self.send(req))
except MontageRequestTimeout, e:
e.riak_bucket = bucket
e.riak_key = key
raise
