def __init__(self, port, attrs=None): Thread.__init__(self) self._loop = True self.out_socket = context.socket(ROUTER) self.out_socket.bind("tcp://*:" + str(port)) self.port = port self.in_socket = context.socket(PULL) self.in_socket.bind("inproc://replies" + str(port)) self._poller = Poller() self._poller.register(self.out_socket, POLLIN) self._poller.register(self.in_socket, POLLIN) self._attrs = attrs try: self._pattern = globify(attrs["origin"]) except ValueError as err: raise ConfigError('Invalid file pattern: ' + str(err)) self._deleter = Deleter() try: self._station = self._attrs["station"] except (KeyError, TypeError): LOGGER.warning("Station is not defined in config file") self._station = "unknown" LOGGER.debug("Station is '%s'" % self._station)
def __init__(self, address, name=""): """Bind the publisher class to a port. """ # pylint: disable=E1103 self.name = name self.destination = address self.publish = context.socket(zmq.PUB) # Check for port 0 (random port) u__ = urlsplit(self.destination) port = u__.port if port == 0: dest = urlunsplit((u__.scheme, u__.hostname, u__.path, u__.query, u__.fragment)) self.port_number = self.publish.bind_to_random_port(dest) netloc = u__.hostname + ":" + str(self.port_number) self.destination = urlunsplit((u__.scheme, netloc, u__.path, u__.query, u__.fragment)) else: self.publish.bind(self.destination) self.port_number = port logger.info("publisher started on port " + str(self.port_number)) # Initialize no heartbeat self._heartbeat = None
def get_pub_address(name, timeout=10, nameserver="localhost"): """Get the address of the publisher for a given publisher *name* from the nameserver on *nameserver* (localhost by default). """ # Socket to talk to server socket = context.socket(REQ) try: socket.setsockopt(LINGER, timeout * 1000) socket.connect("tcp://" + nameserver + ":" + str(PORT)) poller = Poller() poller.register(socket, POLLIN) message = Message("/oper/ns", "request", {"service": name}) socket.send(str(message)) # Get the reply. sock = poller.poll(timeout=timeout * 1000) if sock: if sock[0][0] == socket: message = Message.decode(socket.recv(NOBLOCK)) return message.data else: raise TimeoutError("Didn't get an address after %d seconds." % timeout) finally: socket.close()
def run(self, *args): """Run the listener and answer to requests. """ del args arec = AddressReceiver(max_age=self._max_age) arec.start() port = PORT try: self.listener = context.socket(REP) self.listener.bind("tcp://*:" + str(port)) poller = Poller() poller.register(self.listener, POLLIN) while self.loop: socks = dict(poller.poll(1000)) if socks: if socks.get(self.listener) == POLLIN: msg = self.listener.recv() else: continue logger.debug("Replying to request: " + str(msg)) msg = Message.decode(msg) self.listener.send_unicode(str(get_active_address( msg.data["service"], arec))) except KeyboardInterrupt: # Needed to stop the nameserver. pass finally: arec.stop() self.listener.close()
def __init__(self, address, name=""): """Bind the publisher class to a port. """ # pylint: disable=E1103 self.name = name self.destination = address self.publish = context.socket(zmq.PUB) # Check for port 0 (random port) u__ = urlsplit(self.destination) port = u__.port if port == 0: dest = urlunsplit((u__.scheme, u__.hostname, u__.path, u__.query, u__.fragment)) self.port_number = self.publish.bind_to_random_port(dest) netloc = u__.hostname + ":" + str(self.port_number) self.destination = urlunsplit((u__.scheme, netloc, u__.path, u__.query, u__.fragment)) else: self.publish.bind(self.destination) self.port_number = port LOGGER.info("publisher started on port %s", str(self.port_number)) # Initialize no heartbeat self._heartbeat = None self._pub_lock = Lock()
def add_hook_pull(self, address, callback): """Same as above, but with a PULL socket. (e.g good for pushed 'inproc' messages from another thread). """ logger("Subscriber adding PULL hook " + str(address)) socket = context.socket(PULL) socket.connect(address) self._add_hook(socket, callback)
def send_and_recv(self, msg, url): """Connect to url, send *msg*, wait for response and close. Return the response. """ client = context.socket(zmq.REQ) client.connect(url) client.send(msg) resp = client.recv() client.close() return resp
def reset(self, addr): with self._lock: idx = self._addresses.index(addr) self._poller.unregister(self.subscribers[idx]) self.subscribers[idx].setsockopt(LINGER, 0) self.subscribers[idx].close() self.subscribers[idx] = context.socket(SUB) self.subscribers[idx].setsockopt(SUBSCRIBE, "pytroll") self.subscribers[idx].connect(addr) self._poller.register(self.subscribers[idx], POLLIN)
def __init__(self, holder, port, station): Thread.__init__(self) self._holder = holder self._loop = True self._port = port self._station = station self._lock = Lock() self._socket = context.socket(REP) self._socket.bind("tcp://*:" + str(self._port)) self._poller = Poller() self._poller.register(self._socket, POLLIN)
def __init__(self, addresses, translate=False): self._addresses = addresses self._translate = translate self.subscribers = [] self._poller = Poller() for addr in self._addresses: subscriber = context.socket(SUB) subscriber.setsockopt(SUBSCRIBE, "pytroll") subscriber.connect(addr) self.subscribers.append(subscriber) self._poller.register(subscriber) self._lock = Lock() self._loop = True
def reply_and_send(self, fun, address, message): in_socket = context.socket(PUSH) in_socket.connect("inproc://replies" + str(self.port)) reply = Message(message.subject, "error") try: reply = fun(message) except: LOGGER.exception( "Something went wrong" " when processing the request: %s", str(message)) finally: LOGGER.debug("Response: " + str(message)) in_socket.send_multipart([address, b'', str(reply)])
def add_hook_sub(self, address, topics, callback): """Specify a *callback* in the same stream (thread) as the main receive loop. The callback will be called with the received messages from the specified subscription. Good for operations, which is required to be done in the same thread as the main recieve loop (e.q operations on the underlying sockets). """ logger.info("Subscriber adding SUB hook " + str(address) + " for topics " + str(topics)) socket = context.socket(SUB) for t__ in self._magickfy_topics(topics): socket.setsockopt(SUBSCRIBE, t__) socket.connect(address) self._add_hook(socket, callback)
def __init__(self, holder, host, pubport, reqport, sched): Thread.__init__(self) self._holder = holder self._pubaddress = "tcp://" + host + ":" + str(pubport) self._reqaddress = "tcp://" + host + ":" + str(reqport) self._req = SimpleRequester(host, reqport) self._subsocket = context.socket(SUB) self._subsocket.connect(self._pubaddress) self._subsocket.setsockopt(SUBSCRIBE, "pytroll") self._poller = Poller() self._poller.register(self._subsocket, POLLIN) self._lock = Lock() self._loop = True self._sched = sched
def _send_to_address(self, address, data, timeout=10): """send data to *address* and *port* without verification of response. """ # Socket to talk to server socket = context.socket(REQ) try: socket.setsockopt(LINGER, timeout * 1000) if address.find(":") == -1: socket.connect("tcp://%s:%d" % (address, self.default_port)) else: socket.connect("tcp://%s" % address) socket.send(data) message = socket.recv() if message != "ok": logger.warn("invalid acknowledge received: %s" % message) finally: socket.close()
def add(self, address, topics=None): """Add *address* to the subscribing list for *topics*. It topics is None we will subscibe to already specified topics. """ if address in self.addresses: return False topics = self._magickfy_topics(topics) or self._topics logger.info("Subscriber adding address " + str(address) + " with topics " + str(topics)) subscriber = context.socket(SUB) for t__ in topics: subscriber.setsockopt(SUBSCRIBE, t__) subscriber.connect(address) self.sub_addr[subscriber] = address self.addr_sub[address] = subscriber if self.poller: self.poller.register(subscriber, POLLIN) return True
def connect(self): """Connect to the server """ self._socket = context.socket(REQ) self._socket.connect(self._reqaddress) self._poller.register(self._socket, POLLIN)
def __init__(self, port): self._socket = context.socket(PUB) self._socket.bind("tcp://*:" + str(port)) self._lock = Lock()
def __init__(self, port=None): self._port = port or default_publish_port self._socket = context.socket(REP) self._socket.bind("tcp://*:" + str(port))