def __init__(self, in_address, out_addresses): self._in_socket = nanomsg.Socket(nanomsg.PULL) self._in_socket.bind(in_address) self._out_sockets = [nanomsg.Socket(nanomsg.PUSH) for i in out_addresses] for socket, address in zip(self._out_sockets, out_addresses): socket.bind(address) self._loop = asyncio.get_event_loop()
def setup_broker(self): self.brokerChanged = False if self.bsub != None: self.bsub.close() self.bsub = None self.apply_timeouts() if self.broker_address == "unknown": logger.error("Deferring broker setup as address is still unknown.") return self.bsub = nn.Socket(nn.SUB) self.bsub.connect("tcp://%s:8687" % (self.broker_address)) self.bsub.set_string_option(nn.SUB, nn.SUB_SUBSCRIBE, "global") self.bsub.set_string_option(nn.SUB, nn.SUB_SUBSCRIBE, "local") self.bsub.set_string_option(nn.SUB, nn.SUB_SUBSCRIBE, "notlocal") if self.jobid != None: self.bsub.set_string_option(nn.SUB, nn.SUB_SUBSCRIBE, self.jobid) self.bsub.set_string_option(nn.SUB, nn.SUB_SUBSCRIBE, "tracker") self.apply_timeouts() self.bpub = nn.Socket(nn.PUB) self.bpub.connect("tcp://%s:8686" % (self.broker_address)) logger.info("Broker setup complete")
def __init__( self, app, appconfig, workdata ): WorkerBase.__init__( self, app, appconfig, workdata ) self.surveyorname = workdata["hostname"] self.vsub = nn.Socket( nn.SUB, domain=nn.AF_SP ) self.vpub = nn.Socket( nn.PUB, domain=nn.AF_SP ) self.broker_address = None self.bonjour = BonjourResolver( "_vertexremap._tcp", self.cb_broker_changed ) self.bonjour.start() inputfile = os.path.join( self.remaproot, "data", self.workdata["inputfile"] ) outputdir = os.path.join( self.remaproot, "job", self.jobid, "part" ) self.input = self.app.create_vertex_reader( inputfile ) self.outputdir = outputdir self.partitions = {} self.mode = MODE_IDLE self.surveyor = nn.Socket( nn.RESPONDENT ) self.surveyor.connect( "tcp://%s:8688"%(self.surveyorname) ) # 6 seconds self.surveyor.set_int_option( nn.SOL_SOCKET, nn.RCVTIMEO, 50 ) self.vertices = {} logger.info("Waiting to get vertex broker host from bonjour") self.ready = False
def connect(self): if self._server is None: self._server = nmsg.Socket(nmsg.REP) self._server_endpoint = self._server.bind(self._uri) self._client = nmsg.Socket(nmsg.REQ) self._client_endpoint = self._client.connect(self._uri) return self._server
def main(): # declare a socket subscriber_sock = nn.Socket(domain=nn.AF_SP, protocol=nn.SUB) subscriber_sock.set_string_option(level=nn.SUB, option=nn.SUB_SUBSCRIBE, value="") # bind the above socket to an endpoint subscriber_sock.connect("tcp://127.0.0.1:50000") # global counters for messaging stats subscriber_sock_msg_processed = 0 try: start_time = time.time() while (1): print subscriber_sock.recv() subscriber_sock_msg_processed = subscriber_sock_msg_processed + 1 except KeyboardInterrupt, e: end_time = time.time() delta = end_time - start_time print 'total messages processed by subscriber_sock: %s' % subscriber_sock_msg_processed print 'messages processed by subscriber_sock per second: %s' % str( int(subscriber_sock_msg_processed / delta))
def __init__(self, conf, driver_names, use_nanoconfig_service, publisher_endpoint, nanoconfig_service_endpoint, nanoconfig_update_endpoint, nanoconfig_profile): """ :param conf: Configuration obtained from a configuration file :type conf: oslo_config.cfg.ConfigOpts instance :param driver_names: The list of driver names to register :type driver_names: list of str :param use_nanoconfig_service: Indicates whether or not it should use a nanoconfig service :type use_nanoconfig_service: bool :param publisher_endpoint: Publisher server URI :type publisher_endpoint: str :param nanoconfig_service_endpoint: Nanoconfig service URI :type nanoconfig_service_endpoint: str :param nanoconfig_update_endpoint: Nanoconfig update service URI :type nanoconfig_update_endpoint: str :param nanoconfig_profile: Nanoconfig profile URI :type nanoconfig_profile: str """ super(Agent, self).__init__(conf, driver_names) self.socket = nanomsg.Socket(nanomsg.PUSH) self.use_nanoconfig_service = use_nanoconfig_service self.publisher_endpoint = publisher_endpoint self.nanoconfig_service_endpoint = nanoconfig_service_endpoint self.nanoconfig_update_endpoint = nanoconfig_update_endpoint self.nanoconfig_profile = nanoconfig_profile
def main(): global msg_processed # declare a socket publisher_sock = nn.Socket(domain=nn.AF_SP, protocol=nn.PUB) # bind the above socket to an endpoint publisher_sock.bind("tcp://127.0.0.1:50000") try: start_time = time.time() while (1): # read the message which the client has sent publisher_sock.send("Current time in Bangalore, India: %s" % str(datetime.datetime.now())) msg_processed = msg_processed + 1 except KeyboardInterrupt, e: end_time = time.time() print 'total messages processed: %s' % str(msg_processed) print 'messages processed per second: %s' % str( int(msg_processed / (end_time - start_time))) print 'messages processed per minute: %s' % str( int(msg_processed / (end_time - start_time)) * 60)
def main(): # sockets who will communicate among themselves s2 = nn.Socket(domain=nn.AF_SP, protocol=nn.PAIR) # connect to the above declared endpoint s2.connect("ipc://test-ipc-pair") # global counters on msgs prrocessed by both peers s2_msg_processed = 0 start_time = time.time() try: while (1): print s2.recv() s2_msg_processed = s2_msg_processed + 1 s2.send("Hi! from s2") except KeyboardInterrupt, e: end_time = time.time() print 'total messages processed by s2: %s' % s2_msg_processed print 'total messages processed by s2 per sec: %s' % str( int(s2_msg_processed / (end_time - start_time)))
def main(): global msg_processed # declare a socket respondent_sock = nn.Socket(domain=nn.AF_SP, protocol=nn.RESPONDENT) # bind the sock respondent_sock.connect("tcp://127.0.0.1:50000") try: start_time = time.time() while (1): print respondent_sock.recv() # read the message which the client has sent respondent_sock.send("I provide payments: %s" % str(os.getpid())) msg_processed = msg_processed + 1 except KeyboardInterrupt, e: end_time = time.time() print 'total messages processed: %s' % str(msg_processed) print 'messages processed per second: %s' % str( int(msg_processed / (end_time - start_time))) print 'messages processed per minute: %s' % str( int(msg_processed / (end_time - start_time)) * 60)
def main(): global msg_processed # declare a socket push_sock = nn.Socket(domain=nn.AF_SP, protocol=nn.PUSH) # bind the above socket to an endpoint push_sock.bind("tcp://127.0.0.1:50000") try: start_time = time.time() while (1): # send a message push_sock.send("Hi! from push_sock at: tcp://127.0.0.1:50000") msg_processed = msg_processed + 1 except KeyboardInterrupt, e: end_time = time.time() print 'total messages processed: %s' % str(msg_processed) print 'messages processed per second: %s' % str( int(msg_processed / (end_time - start_time))) print 'messages processed per minute: %s' % str( int(msg_processed / (end_time - start_time)) * 60)
def __init__(self): super(ReaderThread, self).__init__() self.inst = None self.interrupted = False self.soc_pub = nanomsg.Socket(nanomsg.PUB) self.soc_pub.bind("tcp://*:12345")
def __create_NN_subscriber(self): """Function used to create a NN publisher""" try: import nanomsg self.NN_installed = True except ImportError: print("NEP WARNING: Nanomsg not installed") self.NN_installed = False if self.NN_installed == False: msg = "Unable to use surveyor pattern due that Nanomsg is not installed " raise ValueError(msg) else: success, self.port, self.ip = self.__network_selection() if success: try: self.sock = nanomsg.Socket(nanomsg.SUB) self.sock.set_string_option(nanomsg.SUB, nanomsg.SUB_SUBSCRIBE, self.topic) #TODO: zmq.CONFLATE in nanomsg # Only keeps last mesange in queue self.__connect_NN_socket() except Exception as e: exc_type, exc_obj, exc_tb = sys.exc_info() fname = os.path.split( exc_tb.tb_frame.f_code.co_filename)[1] print(exc_type, fname, exc_tb.tb_lineno)
def main(): # sockets who will communicate among themselves s1 = nn.Socket(domain=nn.AF_SP, protocol=nn.PAIR) # bind to an endpoint s1.bind("tcp://127.0.0.1:50000") # global counters on msgs prrocessed by both peers s1_msg_processed = 0 start_time = time.time() try: while (1): s1.send("Hi! from s1") print s1.recv() s1_msg_processed = s1_msg_processed + 1 except KeyboardInterrupt, e: end_time = time.time() print 'total messages processed by s1: %s' % s1_msg_processed print 'total messages processed by s1 per sec: %s' % str( int(s1_msg_processed / (end_time - start_time)))
def main(): # declare a socket client_sock = nn.Socket(domain=nn.AF_SP, protocol=nn.REQ) # bind the above socket to an endpoint client_sock.connect("tcp://127.0.0.1:50000") # global counters for messaging stats client_sock_msg_processed = 0 try: start_time = time.time() while (1): # send a message to the server msg = 'Hi! from a client with os level PID: %s' % os.getpid() msg = client_sock.send(msg) # process the response from the server print client_sock.recv() client_sock_msg_processed = client_sock_msg_processed + 1 except KeyboardInterrupt, e: end_time = time.time() delta = end_time - start_time print 'total messages processed by client_sock: %s' % client_sock_msg_processed print 'messages processed by client_sock per second: %s' % str( int(client_sock_msg_processed / delta))
def main(): global msg_processed # declare a socket app_sock = nn.Socket(domain=nn.AF_SP, protocol=nn.BUS) app_sock.bind("tcp://127.0.0.1:50003") # bind the above socket to an endpoint app_sock.connect("tcp://127.0.0.1:50000") app_sock.connect("tcp://127.0.0.1:50001") app_sock.connect("tcp://127.0.0.1:50002") try: start_time = time.time() while (1): # send a response back app_sock.send("Hi! app_sock with PID: %s" % str(os.getpid())) # read the message which the client has sent print app_sock.recv() msg_processed = msg_processed + 1 except KeyboardInterrupt, e: end_time = time.time() print 'total messages processed: %s' % str(msg_processed) print 'messages processed per second: %s' % str(int(msg_processed/(end_time - start_time))) print 'messages processed per minute: %s' % str(int(msg_processed/(end_time - start_time)) * 60)
def main(): # declare a socket pull_sock = nn.Socket(domain=nn.AF_SP, protocol=nn.PULL) # bind the above socket to an endpoint pull_sock.connect("tcp://127.0.0.1:50000") # global counters for messaging stats pull_sock_msg_processed = 0 try: start_time = time.time() while (1): # process the response from the server print pull_sock.recv() pull_sock_msg_processed = pull_sock_msg_processed + 1 except KeyboardInterrupt, e: end_time = time.time() delta = end_time - start_time print 'total messages processed by pull_sock: %s' % pull_sock_msg_processed print 'messages processed by pull_sock per second: %s' % str( int(pull_sock_msg_processed / delta))
def start(self): exe_dir = path.join(conf.get('home'), 'bin') exe_path = path.join(exe_dir, 'jamovi-engine') si = None stdout = sys.stdout stderr = sys.stderr if platform.uname().system == 'Windows': si = subprocess.STARTUPINFO() si.dwFlags |= subprocess.STARTF_USESHOWWINDOW stdout = None stderr = None # stdouts seem to break things on windows # be a bit wary to make changes to the Popen call # seemingly inconsequential changes can break things on windows address = self._conn_root + '-' + str(self._index) con = '--con={}'.format(address) pth = '--path={}'.format(self._session_path) self._process = subprocess.Popen([exe_path, con, pth], startupinfo=si, stdout=stdout, stderr=stderr) self._socket = nanomsg.Socket(nanomsg.PAIR) self._socket._set_recv_timeout(500) self._socket.bind(address) self._thread = threading.Thread(target=self._run) self._thread.start()
def __init__(self, source, elements, output): self.source = source self.elements = elements self.output = output self.interrupted = False self.soc_sub = nanomsg.Socket(nanomsg.SUB)
def init_socket(self): self.request = nanomsg.Socket(nanomsg.REQ) # self.request.setsockopt(zmq.IDENTITY, "xraycli-" + str(os.getpid())) self.request.recv_timeout = 1000 self.request.send_timeout = 1000 self.request.connect('ipc://{}/{}'.format(self.XRAY_NODES_PATH, self.node)) self.intiated = True
def __init__(self, address, encoder=None, authenticator=None, socket=None, bind=False, timeouts=(None, None)): # Defaults socket = socket or nanomsg.Socket(nanomsg.REQ) encoder = encoder or MsgPackEncoder() super(Requester, self).__init__( socket, address, bind, encoder, authenticator, timeouts)
def __init__(self, workdata, config): FileModule.__init__(self,workdata,config) self.surveyor = nn.Socket( nn.SURVEYOR ) self.surveyor.bind( "tcp://0.0.0.0:8688" ) # 10 seconds max self.surveyor.set_int_option( nn.SURVEYOR, nn.SURVEYOR_DEADLINE, 10000 ) self.superstep = 0 self.mode = MODE_SHIFT self.first = True
def __init__(self, redis, bus_id, channels_bus_list): self._id = bus_id # create sockets self._bus_socket = nanomsg.Socket(nanomsg.BUS) self._respondent_socket = nanomsg.Socket(nanomsg.RESPONDENT) bus_socket_port_number = get_free_port(redis, CHANNELS_BUS) self._bus_socket.bind("tcp://*:%d" % bus_socket_port_number) BUS_BY_FD[self.recv_fd] = self # connect to other bus sockets for remote_bus in channels_bus_list: self._bus_socket.connect(remote_bus) self.__bus_addr = "tcp://%s:%d" % (socket.getfqdn(), bus_socket_port_number) # respondent socket is used to reply to survey requests respondent_socket_port_number = get_free_port(redis, CHANNELS_RESPONDENT) self._respondent_socket.bind("tcp://*:%d" % respondent_socket_port_number) BUS_BY_FD[self._respondent_socket.recv_fd] = self self.__bus_respondent_addr = "tcp://%s:%d" % ( socket.getfqdn(), respondent_socket_port_number) # remove addresses in redis at exit atexit.register(_clean_redis, redis, self.addr, self.respondent_addr) # receiver thread takes care of dispatching received values to right channels global RECEIVER_THREAD if RECEIVER_THREAD is None: global WAKE_UP_SOCKET_W global WAKE_UP_SOCKET_R WAKE_UP_SOCKET_W = nanomsg.Socket(nanomsg.PAIR) WAKE_UP_SOCKET_W.bind("inproc://beacon/channels/wake_up_loop") WAKE_UP_SOCKET_R = nanomsg.Socket(nanomsg.PAIR) WAKE_UP_SOCKET_R.connect("inproc://beacon/channels/wake_up_loop") RECEIVER_THREAD = threading.start_new_thread( receive_channels_values, ()) atexit.register(stop_receiver_thread) else: WAKE_UP_SOCKET_W.send('!')
def main(): ts_analyser = TSAnalyser() socket = nanomsg.Socket(nanomsg.PAIR) socket.connect(sys.argv[1]) start = time.monotonic() while True: msg = socket.recv() print(msg) continue for diff, spi_diff in process_message(msg): ts_analyser.feed(diff, spi_diff)
def nanomsg_bus_recv(): with nanomsg.Socket(nanomsg.BUS) as socket: socket.connect("tcp://futoke.ru:{}".format(PORT)) start = time.time() for i in range(MSG_COUNT): socket.recv() end = time.time() print(MSG_COUNT / (end - start))
def __init__(self, listeners=None, raw_listeners=None, loop=None): self._socket = nanomsg.Socket(nanomsg.PULL) if listeners is None: listeners = [] self._listeners = listeners if raw_listeners is None: raw_listeners = [] self._raw_listeners = raw_listeners if loop is None: loop = asyncio.get_event_loop() self._loop = loop
def nanomsg_pubsub_recv(): with nanomsg.Socket(nanomsg.SUB) as socket: socket.connect("tcp://futoke.ru:{}".format(PORT)) socket.set_string_option(nanomsg.SUB, nanomsg.SUB_SUBSCRIBE, '') start = time.time() for i in range(MSG_COUNT): socket.recv() end = time.time() print(MSG_COUNT / (end - start))
def __init__(self, address, encoder=None, authenticator=None, socket=None, bind=True, timeouts=(None, None)): # Defaults socket = socket or nanomsg.Socket(nanomsg.REP) encoder = encoder or MsgPackEncoder() super(Responder, self).__init__( socket, address, bind, encoder, authenticator, timeouts) self.methods = {} self.descriptions = {}
def start(self): exe_dir = path.join(conf.get('home'), 'bin') exe_path = path.join(exe_dir, 'jamovi-engine') env = os.environ.copy() env['R_HOME'] = conf.get('r_home', env.get('R_HOME', '')) env['R_LIBS'] = conf.get('r_libs', env.get('R_LIBS', '')) env['FONTCONFIG_PATH'] = conf.get('fontconfig_path', env.get('FONTCONFIG_PATH', '')) env['JAMOVI_MODULES_PATH'] = conf.get( 'modules_path', env.get('JAMOVI_MODULES_PATH', '')) si = None stdout = sys.stdout stderr = sys.stderr # Additional customizations for windows if platform.uname().system == 'Windows': si = subprocess.STARTUPINFO() stdout = None stderr = None # stdouts seem to break things on windows # makes the engine windows visible in debug mode (on windows) if not conf.get('debug', False): si.dwFlags |= subprocess.STARTF_USESHOWWINDOW # be a bit wary to make changes to the Popen call # seemingly inconsequential changes can break things on windows con = '--con={}'.format(self._conn_path) pth = '--path={}'.format(self._data_path) try: self._process = subprocess.Popen([exe_path, con, pth], startupinfo=si, stdout=stdout, stderr=stderr, env=env) self._socket = nanomsg.Socket(nanomsg.PAIR) self._socket._set_recv_timeout(500) self._socket.bind(self._conn_path) self._thread = threading.Thread(target=self._run) self._thread.start() except BaseException as e: self._parent._notify_engine_event({ 'type': 'error', 'message': 'Engine process could not be started', 'cause': str(e), })
def __init__(self, topic, timeout=1000, node_name="default", debug=False): """ Nanomsg surveyor class Parameters ---------- topic : string Surveyor topic timeout : int Maximun miliseconds waiting for response debug: bool If True some additional information of the subscriber is shown """ self.topic = topic print("SURVEY: " + self.topic + " waiting for NEP master ...") self.pid = os.getpid() success, port, ip = nep.masterRegister(node_name, self.topic, master_ip='127.0.0.1', master_port=7000, socket="surveyor", pid=self.pid, data_type="json") print("SURVEY: " + self.topic + " socket ready") self.debug = debug if success: self.NN_installed = False try: import nanomsg self.NN_installed = True except ImportError: print("Nanomsg not installed") self.NN_installed = False if self.NN_installed == False: msg = "Unable to use surveyor pattern due that Nanomsg is not installed " raise ValueError(msg) self.sock = nanomsg.Socket(nanomsg.SURVEYOR) endpoint = "tcp://" + ip + ":" + str(port) self.sock.bind(endpoint) self.sock.set_int_option(nanomsg.SURVEYOR, nanomsg.SURVEYOR_DEADLINE, timeout) time.sleep(1) if self.debug: print("surveyor started in: " + str(endpoint))
def __init__(self, source, conf, limits, steps, doblit=False): super(PlottingThread, self).__init__() self.interrupted = False self.source = source self.conf = conf self.limits = limits self.steps = steps self.doblit = doblit self.soc_sub = nanomsg.Socket(nanomsg.SUB) self.soc_sub.set_string_option(nanomsg.SUB, nanomsg.SUB_SUBSCRIBE, "") self.soc_sub.set_int_option(nanomsg.SOL_SOCKET, nanomsg.RECONNECT_IVL, 1000) self.soc_sub.set_int_option(nanomsg.SOL_SOCKET, nanomsg.RECONNECT_IVL_MAX, 1000 * 30) self.soc_sub.connect(self.source)