def test_run_power_down_interrupt(observatory):
def start_pocs():
pocs = POCS(observatory, messaging=True)
pocs.initialize()
pocs.observatory.scheduler.fields_list = [{'name': 'KIC 8462852',
'position': '20h06m15.4536s +44d27m24.75s',
'priority': '100',
'exp_time': 2,
'min_nexp': 1,
'exp_set_size': 1,
}]
pocs.logger.info('Starting observatory run')
pocs.run()
pocs_process = Process(target=start_pocs)
pocs_process.start()
pub = PanMessaging.create_publisher(6500)
sub = PanMessaging.create_subscriber(6511)
while True:
msg_type, msg_obj = sub.receive_message()
if msg_type == 'STATUS':
current_state = msg_obj.get('state', {})
if current_state == 'pointing':
pub.send_message('POCS-CMD', 'shutdown')
break
pocs_process.join()
assert pocs_process.is_alive() is False
def test_run_wait_until_safe(db, observatory):
os.environ['POCSTIME'] = '2016-08-13 23:00:00'
def start_pocs():
observatory.config['simulator'] = ['camera', 'mount', 'night']
pocs = POCS(observatory,
messaging=True, safe_delay=15)
pocs.db.current.remove({})
pocs.initialize()
pocs.logger.info('Starting observatory run')
assert pocs.is_weather_safe() is False
pocs.send_message('RUNNING')
pocs.run(run_once=True, exit_when_done=True)
assert pocs.is_weather_safe() is True
pub = PanMessaging.create_publisher(6500)
sub = PanMessaging.create_subscriber(6511)
pocs_process = Process(target=start_pocs)
pocs_process.start()
# Wait for the running message
while True:
msg_type, msg_obj = sub.receive_message()
if msg_obj is None:
time.sleep(2)
continue
if msg_obj.get('message', '') == 'RUNNING':
time.sleep(2)
# Insert a dummy weather record to break wait
db.insert_current('weather', {'safe': True})
if msg_type == 'STATUS':
current_state = msg_obj.get('state', {})
if current_state == 'pointing':
pub.send_message('POCS-CMD', 'shutdown')
break
time.sleep(0.5)
pocs_process.join()
assert pocs_process.is_alive() is False
def main(sensor=None, watch_key=None, channel=None, port=6511, format=False, **kwargs):
sub = PanMessaging.create_subscriber(port)
i = 0
while True:
data = None
try:
msg_channel, msg_data = sub.receive_message()
except KeyError:
continue
else:
if msg_channel != channel:
continue
try:
data = msg_data['data'][sensor]
except KeyError:
continue
if watch_key in data:
data = data[watch_key]
if data is not None:
if format and hasattr(data, 'items'):
for k, v in data.items():
try:
if i % 15 == 0:
print(" {:17s} |".format(k), end='')
else:
print("{:18.02f} |".format(v), end='')
except ValueError:
print(k, ': ', v)
except TypeError:
print(k, ': ', v)
print("")
else:
print(data)
i += 1
def check_message_loop(cmd_queue):
cmd_subscriber = PanMessaging.create_subscriber(cmd_port + 1)
poller = zmq.Poller()
poller.register(cmd_subscriber.socket, zmq.POLLIN)
try:
while self._do_cmd_check:
# Poll for messages
sockets = dict(poller.poll(500)) # 500 ms timeout
if cmd_subscriber.socket in sockets and \
sockets[cmd_subscriber.socket] == zmq.POLLIN:
msg_type, msg_obj = cmd_subscriber.receive_message(flags=zmq.NOBLOCK)
# Put the message in a queue to be processed
if msg_type == 'POCS-CMD':
cmd_queue.put(msg_obj)
time.sleep(1)
except KeyboardInterrupt:
pass
def create_forwarder(port):
try:
PanMessaging.create_forwarder(port, port + 1)
except Exception:
pass
def _setup_messaging(self):
cmd_port = self.config['messaging']['cmd_port']
msg_port = self.config['messaging']['msg_port']
def create_forwarder(port):
try:
PanMessaging.create_forwarder(port, port + 1)
except Exception:
pass
cmd_forwarder_process = multiprocessing.Process(
target=create_forwarder, args=(
cmd_port,), name='CmdForwarder')
cmd_forwarder_process.start()
msg_forwarder_process = multiprocessing.Process(
target=create_forwarder, args=(
msg_port,), name='MsgForwarder')
msg_forwarder_process.start()
self._do_cmd_check = True
self._cmd_queue = multiprocessing.Queue()
self._sched_queue = multiprocessing.Queue()
self._msg_publisher = PanMessaging.create_publisher(msg_port)
def check_message_loop(cmd_queue):
cmd_subscriber = PanMessaging.create_subscriber(cmd_port + 1)
poller = zmq.Poller()
poller.register(cmd_subscriber.socket, zmq.POLLIN)
try:
while self._do_cmd_check:
# Poll for messages
sockets = dict(poller.poll(500)) # 500 ms timeout
if cmd_subscriber.socket in sockets and \
sockets[cmd_subscriber.socket] == zmq.POLLIN:
msg_type, msg_obj = cmd_subscriber.receive_message(flags=zmq.NOBLOCK)
# Put the message in a queue to be processed
if msg_type == 'POCS-CMD':
cmd_queue.put(msg_obj)
time.sleep(1)
except KeyboardInterrupt:
pass
self.logger.debug('Starting command message loop')
check_messages_process = multiprocessing.Process(
target=check_message_loop, args=(self._cmd_queue,))
check_messages_process.name = 'MessageCheckLoop'
check_messages_process.start()
self.logger.debug('Command message subscriber set up on port {}'.format(cmd_port))
self._processes = {
'check_messages': check_messages_process,
'cmd_forwarder': cmd_forwarder_process,
'msg_forwarder': msg_forwarder_process,
}
def send_message(self, msg, channel='environment'):
if self.messaging is None:
self.messaging = PanMessaging.create_publisher(6510)
self.messaging.send_message(channel, msg)
#!/usr/bin/env python
from pocs.utils.messaging import PanMessaging
from_port = 6510
to_port = 6511
print("Starting message forwarding, hit Ctrl-c to stop")
print("Port: {} -> {}".format(from_port, to_port))
try:
f = PanMessaging.create_forwarder(from_port, to_port)
except KeyboardInterrupt:
print("Shutting down and exiting...")
def pub():
messaging = PanMessaging.create_publisher(12345, bind=False, connect=True)
time.sleep(2) # Wait for publisher to start up
yield messaging
messaging.close()
def sub():
messaging = PanMessaging.create_subscriber(54321)
yield messaging
messaging.close()
def start_forwarder():
PanMessaging.create_forwarder(12345, 54321)
def send_message(self, msg, channel='weather'):
if self.messaging is None:
self.messaging = PanMessaging.create_publisher(6510)
self.messaging.send_message(channel, msg)