def __init__(self): super(ProxyServer, self).__init__() self.router = ZMQUtils.create_bind_router(router_addr) self.dealer = ZMQUtils.create_bind_dealer(dealer_addr) self.poll = ZMQUtils.create_poller() self.poll.register(self.router, zmq.POLLIN) self.poll.register(self.dealer, zmq.POLLIN)
def __init__(self): super(ThreadTwo, self).__init__() self.recver = ZMQUtils.create_bind_pair(step2_addr) self.sender = ZMQUtils.create_conn_pair(step3_addr) self.daemon = True t = ThreadOne() t.start()
def __init__(self, identify): super(AsyncClient, self).__init__() self.identify = identify self.dealer = ZMQUtils.create_durable_dealer(dealer_addr, identify) self.poll = ZMQUtils.create_poller() self.poll.register(self.dealer, zmq.POLLIN) self.daemon = True
def __init__(self): super(Server, self).__init__() self.front = ZMQUtils.create_bind_router(dealer_addr) self.back = ZMQUtils.create_bind_dealer(worker_addr) self.poll = ZMQUtils.create_poller() self.poll.register(self.front, zmq.POLLIN) self.poll.register(self.back, zmq.POLLIN) self._create_thread()
def _create_state_sock(self, index, number): back_state_addr = state_addr % index self.back_state = ZMQUtils.create_bind_pub(back_state_addr) front_statr_addrs = [] for i in xrange(number): if i == index: continue addr = state_addr % i front_statr_addrs.append(addr) self.front_state = ZMQUtils.create_conn_sub(front_statr_addrs) self.front_state.setsockopt(zmq.SUBSCRIBE, "")
def _create_sock(cls): sockets = [] for index in range(2): zmq_addr = addr % index sock = ZMQUtils.create_conn_pull(zmq_addr) sockets.append(sock) return sockets
def _response_loop(self): poll = ZMQUtils.create_poller() poll.register(self.back_local, zmq.POLLIN) poll.register(self.back_cloud, zmq.POLLIN) timeout = 1000 if len(self.worker) > 0 else None sockets = dict(poll.poll(timeout)) response = None if self.back_local in sockets: parts = self.back_local.recv_multipart() self.worker.append(parts[0]) if parts[2] == "READY": print_msg("cluster recv work ready") else: response = parts print_msg("cluster %d recv response from local: %s" % (self.index, response)) response = response[2:] elif self.back_cloud in sockets: parts = self.back_cloud.recv_multipart() response = parts[2:] print_msg("cluster %d recv response from cloud: %s" % (self.index, response)) if response is not None: address = response[0] if address in self.peer_identifies: self.front_cloud.send_multipart(response) else: self.front_local.send_multipart(response)
def __init__(self, index, run_queue, next_queue): super(SendTwoThread, self).__init__() self.index = index self.sender = ZMQUtils.create_conn_req(addr) self.run_queue = run_queue self.next_queue = next_queue self.daemon = True
def _request_loop(self): poll = ZMQUtils.create_poller() poll.register(self.front_local, zmq.POLLIN) poll.register(self.front_cloud, zmq.POLLIN) while len(self.worker) > 0: sockets = dict(poll.poll(timeout=5000)) routable = False if self.front_local in sockets: msgs = self.front_local.recv_multipart() print_msg("cluster receive request from local: %s" % msgs) routable = True elif self.front_cloud in sockets: msgs = self.front_cloud.recv_multipart() print_msg("cluster receive request from cloud: %s" % msgs) else: print_msg("no request") return if routable and len(self.peer_addrs) != 0 and random.randint(1, 5) == 1: rand_peer = random.choice(self.peer_identifies) msgs = [rand_peer, ""] + msgs print_msg("cluster %d route to other cluster: %s" % (self.index, msgs)) self.back_cloud.send_multipart(msgs) else: work_addr = self.worker[0] self.worker = self.worker[1:] work_msg = [work_addr, ""] + msgs self.back_local.send_multipart(work_msg) print_msg("cluster %d send msg to local: %s" % (self.index, work_msg))
def _create_cloud_sock(self, index, number): cloud_zmq_addr = cloud_addr % index self_identify = cloud_identify % index self.front_cloud = ZMQUtils.create_bind_router(cloud_zmq_addr, identify=self_identify) peer_cloud_addrs = [] peer_cloud_idents = [] for i in xrange(number): if i == index: continue peer_addr = cloud_addr % i peer_ident = cloud_identify % i peer_cloud_addrs.append(peer_addr) peer_cloud_idents.append(peer_ident) self.back_cloud = ZMQUtils.create_durable_router(peer_cloud_addrs, self_identify) self.peer_addrs = peer_cloud_addrs self.peer_identifies = peer_cloud_idents
def _get_ready_sockets(self): self.poll = ZMQUtils.create_poller() if len(self.workers) == 0: self.poll.register(self.back, zmq.POLLIN) else: self.poll.register(self.back, zmq.POLLIN) self.poll.register(self.front, zmq.POLLIN) return dict(self.poll.poll())
def _state_loop(self): poll = ZMQUtils.create_poller() sockets = dict(poll.poll(1000)) if self.front_state in sockets: peer_name, available = self.front_state.recv_multipart() print_msg("cluster %d recv: %s %s" % (self.index, peer_name, available)) else: index = str(self.index) available = str(random.randint(1, 4)) self.back_state.send_multipart([index, available]) print_msg("cluster %s send: %s %s" % (index, index, available))
def run(self): index = 0 while True: send_index = index print "send: %d" % send_index self.req.send(str(send_index)) index += 1 poll = ZMQUtils.create_poller() poll.register(self.req, zmq.POLLIN) result = dict(poll.poll(timeout=1000)) if not result: self._create_req() continue response = self.req.recv() if response != str(send_index): print "wo kao"
def __init__(self): super(ClientThread, self).__init__() self.sender = ZMQUtils.create_conn_req(front_addr)
def _create_local_sock(self, index): front_addr = local_front_addr % index back_addr = local_back_addr % index self.front_local = ZMQUtils.create_bind_router(front_addr) self.back_local = ZMQUtils.create_bind_router(back_addr)
def __init__(self): super(SubServer, self).__init__() self.receiver = ZMQUtils.create_conn_sub(addr) # 必须要设置filter,否则收不到消息 self.receiver.setsockopt(zmq.SUBSCRIBE, "B")
def __init__(self): super(PubServer, self).__init__() self.sender = ZMQUtils.create_bind_pub(addr)
def __init__(self): super(BrokerServer, self).__init__() self.front = ZMQUtils.create_bind_router(front_addr) self.back = ZMQUtils.create_bind_router(back_addr) self.poll = ZMQUtils.create_poller() self.workers = []
def __init__(self): self.recver = ZMQUtils.create_conn_sub(sub_addr) self.syncer = ZMQUtils.create_conn_req(sync_addr) self.recver.setsockopt(zmq.SUBSCRIBE, "")
def __init__(self): super(RepServer, self).__init__() self.receiver = ZMQUtils.create_bind_rep(addr) self.index = 1
def __init__(self, front_addr, index): super(ClientThread, self).__init__() self.req = ZMQUtils.create_conn_req(front_addr) self.daemon = True self.index = index
def __init__(self): self.router = ZMQUtils.create_bind_router(inproc) self.uuid_req = ZMQUtils.create_conn_req(inproc) self.dura_req = ZMQUtils.create_durable_req(inproc, "hello")
def __init__(self): super(WorkerThread, self).__init__() self.recver = ZMQUtils.create_conn_req(back_addr) self.daemon = True
def __init__(self): self.sender = ZMQUtils.create_bind_router(inproc) self.idents = ["A", "B"] self._create_thread()
def __init__(self): super(PullServer, self).__init__() self.recver = ZMQUtils.create_conn_pull(addr)
def __init__(self, back_addr, index): super(WorkerThread, self).__init__() self.req = ZMQUtils.create_conn_req(back_addr) self.index = index self.daemon = True
def __init__(self): super(WorkerServer, self).__init__() self.receiver = ZMQUtils.create_conn_pull(dispatcher_addr) self.sender = ZMQUtils.create_conn_push(collector_addr) self.count = 0
def __init__(self): super(ThreadOne, self).__init__() self.sender = ZMQUtils.create_conn_pair(step2_addr) self.daemon = True
def __init__(self): super(DispatchServer, self).__init__() self.sender = ZMQUtils.create_bind_push(addr) self.counter = 1
def __init__(self): super(ThreadThree, self).__init__() self.recver = ZMQUtils.create_bind_pair(step3_addr) self.daemon = True t = ThreadTwo() t.start()
def __init__(self): self.recver = ZMQUtils.create_durable_sub(sub_addr, "hello") self.syncer = ZMQUtils.create_conn_push(sync_addr) self.recver.setsockopt(zmq.SUBSCRIBE, "")
def __init__(self, identify): super(DealerThread, self).__init__() self.identify = identify self.recver = ZMQUtils.create_conn_dealer(inproc, identify=identify)
def __init__(self): super(RouteServer, self).__init__() self.route = ZMQUtils.create_bind_router(addr) self.rep = ZMQUtils.create_durable_rep(addr, "A")
def _create_poll(cls, sockets): poller = ZMQUtils.create_poller() for sock in sockets: poller.register(sock, zmq.POLLIN) return poller
def _init_zmq(self, zmq_addr): self.sender = ZMQUtils.create_bind_push(zmq_addr)