def send(self, message_type=None, message_type_args={}, request_id=None): if(not request_id): request_id = uuid.uuid4() context = zmq.Context() socket = context.socket(zmq.REQ) socket.connect("tcp://{0}:{1}".format(self._ip, self._port)) socket.poll(timeout=1) poller = zmq.Poller() poller.register(socket, zmq.POLLIN) lib.debug.info("Sending request {0} …".format(request_id)) timestarted = time.time() hostdetails = simplejson.dumps({'hostname':lib.hostname_ip.hostname, 'ip':lib.hostname_ip.ip}) send_msg = simplejson.dumps(self.process(message_type, message_type_args,hostdetails)) socket.send_multipart([bytes(unicode(request_id)), bytes(unicode(hostdetails)), bytes(unicode(message_type)), bytes(unicode(send_msg))]) while(True): sockets = dict(poller.poll(10000)) if(sockets): for s in sockets.keys(): if(sockets[s] == zmq.POLLIN): try: (recv_id, recv_hostdetails, recv_msg_type, recved_msg) = s.recv_multipart() recv_message = self.process(recv_msg_type, recved_msg,recv_hostdetails) lib.debug.info("Received reply %s : %s [ %s ]" % (recv_id, recv_message, time.time() - timestarted)) except: lib.debug.info (sys.exc_info()) break break lib.debug.info ("Reciever Timeout error : Check if the server is running") socket.close() context.term()
def _worker(self,worker_url, worker_id=uuid.uuid4()): if (sys.platform.lower().find("linux") >= 0): setproctitle.setproctitle("server-worker") lib.debug.info (worker_url) context = zmq.Context() # Socket to talk to dispatcher socket = context.socket(zmq.REP) socket.poll(timeout=1) socket.connect(worker_url) while True: (request_id_rep, state_name_rep, topic_rep, msg_rep) = socket.recv_multipart() rep_sock.send_multipart([request_id_rep, state_name, msg_rep]) lib.debug.debug(msg_rep) try: msg_reved = simplejson.loads(msg_rep) if (msg_reved['status'] == "free"): hosts_recieved[msg_reved['hostid']] = msg_reved lib.debug.debug("sending state : " + state_name_rep + " : ") else: return (msg_reved['status'] + " : " + msg_reved['request_id']) except: lib.debug.error(str(state_name) + " : " + str(request_id) + " : " + str(sys.exc_info())) return (str(state_name) + " : " + str(request_id) + " : " + str(sys.exc_info())) while True: received = socket.recv_multipart() lib.debug.info("Received request: [ {0} ] -> [ {1} ]".format(str(worker_id),msg_type_args)) reply = self.process(received) reply_to_send = simplejson.dumps(reply) socket.send_multipart([bytes(unicode(hostid)),bytes(unicode(request_id)),bytes(unicode(reply_to_send))]) lib.debug.info("Replied to request: [ {0} ] -> [ {1} ]".format(str(worker_id), msg_type_args))
def send(self, socket, routing=[]): if hasattr(self, "_remote"): assert not self._remote, "send() called on a non-local Communicable object." json_str, buffers = json_encode(self.__dict__) socket.send_multipart( routing + [self.__class__.__module__, self.__class__.__name__] + [json_str] + buffers, copy=False )
def send(self, socket, routing=[]): if hasattr(self, '_remote'): assert not self._remote, "send() called on a non-local Communicable object." json_str, buffers = json_encode(self.__dict__) socket.send_multipart( routing + [self.__class__.__module__, self.__class__.__name__] + [json_str] + buffers, copy=False)
def run(self): context = zmq.Context() socket = context.socket(zmq.REP) socket.bind("tcp://*:%s" % port) time.sleep(0.1) while True: msg = socket.recv() res = self.dispatch_request(msg) socket.send_multipart(res)
def ban_swabber(ip): if not zmq: raise SystemExit("swabber engine enabled but zmq not available!") context = zmq.Context() socket = context.socket(zmq.PUB) socket.connect("tcp://127.0.0.1:22620") socket.send_multipart(("swabber_bans", ip)) socket.close() return True
def send(self, socket, routing=[]): if hasattr(self, '_remote'): assert not self._remote, "send() called on a non-local Communicable object." sendable_dict = dict( (k, v) for k, v in self.__dict__.items() if (not k.startswith('_')) and (not callable(self.__dict__[k]))) # replace each buffer with its metadata, and send it separately buffers = [] encoder = make_CP_encoder(buffers) json_str = json.dumps(sendable_dict, default=encoder) socket.send_multipart( routing + [self.__class__.__module__, self.__class__.__name__] + [json_str] + buffers, copy=False)
def send(self, socket, routing=[]): if hasattr(self, '_remote'): assert not self._remote, "send() called on a non-local Communicable object." sendable_dict = dict((k, v) for k, v in self.__dict__.items() if (not k.startswith('_')) and (not callable(self.__dict__[k]))) # replace each buffer with its metadata, and send it separately buffers = [] encoder = make_CP_encoder(buffers) json_str = json.dumps(sendable_dict, default=encoder) socket.send_multipart(routing + [self.__class__.__module__, self.__class__.__name__] + [json_str] + buffers, copy=False)
def handler(socket, msg): ti = str(threading.currentThread().ident) print ti + "] Handling new message " #print msg if len(msg) == 4: msgfrom = msg[0] msgtxt = msg[1] msgid = msg[2] reply_wanted = msg[3] print "\tid:" + msgid + " reply_wanted:" + reply_wanted if reply_wanted == "1": print "\tthey want a reply. sending it." socket.send_multipart([msgfrom, 'fooreply', msgid])
def sendmsg(socket, msg, msgid, callback): """ Send a message on a socket. Messages are always sent asynchronously. If a callback is specified, it will be called when a reply is received. """ if socket != None and msg != None: reply_wanted = 0 if callback != None: reply_wanted = 1 callback_registry_lock.acquire() callback_registry[msgid] = callback callback_registry_lock.release() socket.send_multipart([msg, msgid, str(reply_wanted)])
def watch_batch(self, batch_id): # Setup a connection to the validator ctx = zmq.Context() socket = ctx.socket(zmq.DEALER) socket.connect(current_app.config['SAWTOOTH_VALIDATOR_URL']) # Construct the request request = client_batch_submit_pb2.ClientBatchStatusRequest( batch_ids=[batch_id], wait=True).SerializeToString() # Construct the message wrapper correlation_id = batch_id + uuid.uuid4( ).hex # This must be unique for all in-process requests msg = Message(correlation_id=correlation_id, message_type=Message.CLIENT_BATCH_STATUS_REQUEST, content=request) # Send the request socket.send_multipart([msg.SerializeToString()]) # Receive the response resp = socket.recv_multipart()[-1] # Parse the message wrapper msg = Message() msg.ParseFromString(resp) # Validate the response type if msg.message_type != Message.CLIENT_BATCH_STATUS_RESPONSE: current_app.logger.error("Unexpected response message type") return # Parse the response response = client_batch_submit_pb2.ClientBatchStatusResponse() response.ParseFromString(msg.content) # Validate the response status if response.status != client_batch_submit_pb2.ClientBatchSubmitResponse.OK: current_app.logger.error("watch batch status failed: {}".format( response.response_message)) return # Close the connection to the validator socket.close() return client_batch_submit_pb2.ClientBatchStatus.Status.Name( response.batch_statuses[0].status)
def _reply_heartbeat(self, target): """Worker will kill its jobs when it lost connection with the master. """ socket = self.ctx.socket(zmq.REP) socket.linger = 0 socket.setsockopt(zmq.RCVTIMEO, remote_constants.HEARTBEAT_RCVTIMEO_S * 1000) heartbeat_master_port =\ socket.bind_to_random_port("tcp://*") self.master_heartbeat_address = "{}:{}".format(self.worker_ip, heartbeat_master_port) logger.set_dir( os.path.expanduser('~/.parl_data/worker/{}'.format( self.master_heartbeat_address.replace(':', '_')))) self.heartbeat_socket_initialized.set() logger.info("[Worker] Connect to the master node successfully. " "({} CPUs)".format(self.cpu_num)) while self.master_is_alive and self.worker_is_alive: try: message = socket.recv_multipart() worker_status = self._get_worker_status() socket.send_multipart([ remote_constants.HEARTBEAT_TAG, to_byte(str(worker_status[0])), to_byte(str(worker_status[1])), to_byte(worker_status[2]), to_byte(str(worker_status[3])) ]) except zmq.error.Again as e: self.master_is_alive = False except zmq.error.ContextTerminated as e: break socket.close(0) logger.warning( "[Worker] lost connection with the master, will exit reply heartbeat for master." ) self.worker_status.clear() self.log_server_proc.kill() self.log_server_proc.wait() # exit the worker self.worker_is_alive = False self.exit()
def _reply_heartbeat(self): """Reply heartbeat signals to the master node.""" socket = self.ctx.socket(zmq.REP) socket.linger = 0 socket.setsockopt(zmq.RCVTIMEO, remote_constants.HEARTBEAT_RCVTIMEO_S * 1000) reply_master_heartbeat_port =\ socket.bind_to_random_port(addr="tcp://*") self.reply_master_heartbeat_address = "{}:{}".format( get_ip_address(), reply_master_heartbeat_port) self.heartbeat_socket_initialized.set() connected = False while self.client_is_alive and self.master_is_alive: try: message = socket.recv_multipart() elapsed_time = datetime.timedelta(seconds=int(time.time() - self.start_time)) socket.send_multipart([ remote_constants.HEARTBEAT_TAG, to_byte(self.executable_path), to_byte(str(self.actor_num)), to_byte(str(elapsed_time)), to_byte(str(self.log_monitor_url)), ]) # TODO: remove additional information except zmq.error.Again as e: if connected: logger.warning("[Client] Cannot connect to the master." "Please check if it is still alive.") else: logger.warning( "[Client] Cannot connect to the master." "Please check the firewall between client and master.(e.g., ping the master IP)" ) self.master_is_alive = False socket.close(0) logger.warning("Client exit replying heartbeat for master.")
def send_to_zmq_zipped_multi(socket, identity, obj, protocol=2): """pickle an object, and zip the pickle before sending it""" p = pickle.dumps(obj, protocol) z = zlib.compress(p) return socket.send_multipart([identity, z], flags=zmq.NOBLOCK)
def process_IN_MODIFY(self, event): if event.pathname == self.pathname: socket = zmq.Socket(zmq.Context.instance(), zmq.PUSH) socket.connect(self.bep) socket.send_multipart([EMPTY, VERSION, '\x04']) socket.close()
from machinetalk.protobuf.object_pb2 import ProtocolParameters # reload(sys) # sys.setdefaultencoding('utf8') print "default encoding: " + sys.getdefaultencoding() context = zmq.Context() socket = context.socket(zmq.ROUTER) identity = "worker12" socket.identity = identity.encode('utf8') uri = "tcp://machinekit.local:6202" socket.connect(uri) cont = Container() cont.type = MT_PING txBuffer = cont.SerializeToString() socket = context.socket(zmq.DEALER) socket.setsockopt(zmq.RCVTIMEO, 1000) socket.setsockopt(zmq.LINGER, 10) print "sending txBuffer: " + txBuffer socket.send_multipart([identity + txBuffer], zmq.NOBLOCK) #socket.send(txBuffer) cont.clear()
def send_message(socket, message): socket.send_multipart(message)
wf = None for i, port in enumerate(PORTS): socket = context.socket(zmq.PUB) socket.bind("tcp://*:%s" % port) sockets.append(socket) wf = wave.open(FILE, 'rb') CHUNK = 4096 FORMAT = pyaudio.paInt16 CHANNELS = 1 RATE = 44100 p = pyaudio.PyAudio() framecount = 1 while True: time.sleep(0.001) framecount += 1 data = wf.readframes(CHUNK) if len(data) == 0: wf = wave.open(FILE, 'rb') data = wf.readframes(CHUNK) for i, socket in enumerate(sockets): if len(data) > 0: socket.send_multipart([TOPIC, data, timenow()]) print "Sending data %d" % framecount