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 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