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 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 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, 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 __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 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 __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 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 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):
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))
