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):
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, 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 _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 _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 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(ClientThread, self).__init__()
self.sender = ZMQUtils.create_conn_req(front_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):
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(WorkerThread, self).__init__()
self.recver = ZMQUtils.create_conn_req(back_addr)
self.daemon = True
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__(self):
super(RepServer, self).__init__()
self.receiver = ZMQUtils.create_bind_rep(addr)
self.index = 1
def _init_zmq(self, zmq_addr):
self.sender = ZMQUtils.create_bind_push(zmq_addr)
