def main(args, context):
logger = logging.getLogger(__name__)
settings = configuration.Config()
serializer = serialization.Serializer()
input_data = communication.connect_socket(
context,
socket_type=zmq.PUB,
connection=settings.connections["input_data"])
logger.info("Starting data stream. Sending %d elements.", args.n)
try:
for i in xrange(args.n):
logger.debug("Sending: %s", str(i))
message = i
message_buffer = serializer.write_buffer(message, topic="camera")
input_data.send(message_buffer)
time.sleep(args.s)
logger.info("Data transfer complete.")
except Exception as e:
logger.exception("Failed sending camera data.")
logger.info("Shutting down camera data stream.")
sys.exit()
return
def main(args, context):
logger = logging.getLogger(__name__)
settings = configuration.Config()
serializer = serialization.Serializer()
output_data = communication.connect_socket(
context,
socket_type=zmq.SUB,
connection=settings.connections["output_data"])
output_data.setsockopt(zmq.SUBSCRIBE, settings.topics["weights"])
logger.info("Listening for data stream.")
try:
while True:
message_buffer = output_data.recv()
message = serializer.read_buffer(message_buffer, topic="weights")
logger.info("Recieved: %s", message)
time.sleep(args.s)
except Exception as e:
logger.exception("Listening failed.")
logger.info("Shutting down monitor.")
sys.exit()
except KeyboardInterrupt as e:
logger.debug("User interrupt.")
logger.info("Shutting down monitor.")
sys.exit()
return
async def post_import(request):
ser = serialization.Serializer()
try:
import_id = db.get_next_id()
db.fill_import(import_id, ser.deserialize_citizens(await request.text()))
except ValidationError as e:
return web.json_response({"error": e.messages}, status=400)
return web.json_response({"data": {"import_id": import_id}}, status=201)
async def patch_info(request):
ser = serialization.Serializer()
try:
result = db.patch_user_data(request.match_info["import_id"], request.match_info["citizen_id"],
ser.deserialize_patch_data(await request.text()))
except ValidationError as e:
return web.json_response({"error": e.messages}, status=400)
return web.json_response({"data": result}, status=200)
def __init__(self,
topic,
sleep=0,
connection="output_data",
settings=configuration.Config(),
serializer=serialization.Serializer()):
super(Monitor, self).__init__(topic, sleep, connection, settings,
serializer)
self.logger = logging.getLogger(topic + " monitor")
self.logger.setLevel(logging.DEBUG)
self.logger.info("Starting to monitor: %s", self.topic)
def __init__(self,
config=configuration.Config(),
serializer=serialization.Serializer(),
payload=payload.Payload()):
self.context = zmq.Context()
self.settings = config
self.serializer = serializer
self.payload = payload
self.controller = communication.connect_socket(
self.context,
socket_type=zmq.REQ,
connection=self.settings.connections["commander"])
self.logger = logging.getLogger("commander")
def __init__(self,
config=configuration.Config(),
FPGA=fpga.FPGA(),
serializer=serialization.Serializer()):
self.context = zmq.Context()
self.settings = config
self.FPGA = FPGA
self.serializer = serializer
self.connections = self.settings.connections
self.read_commands = self.settings.read_commands
self.write_commands = self.settings.write_commands
self.topics = self.settings.topics
self.logger = logging.getLogger("controller")
self.logger.debug("Initializing controller ...")
self.logger.debug("Connecting sockets ...")
self.commander = communication.bind_socket(
self.context,
socket_type=zmq.REP,
connection=self.connections["controller"])
self.input_data = communication.bind_socket(
self.context,
socket_type=zmq.SUB,
connection=self.connections["camera"])
self.output_data = communication.bind_socket(
self.context,
socket_type=zmq.PUB,
connection=self.connections["monitor"])
#input subscribes to any topic, i.e. these sockets read from all their connections at once
self.input_data.setsockopt(zmq.SUBSCRIBE, "")
self.logger.debug("Initializing poll sets ...")
# Initialize poll set
self.poller = zmq.Poller()
self.poller.register(self.commander, zmq.POLLIN)
self.poller.register(self.input_data, zmq.POLLIN)
self.logger.debug("Initialization complete.")
self.command = None
def __init__(self,
topic,
sleep=0,
connection="output_data",
settings=configuration.Config(),
serializer=serialization.Serializer()):
self.context = zmq.Context()
self.settings = settings
self.serializer = serializer
self.sleep = sleep
self.topic = topic
self.logger_parent = logging.getLogger("topical monitor")
self.logger_parent.setLevel(logging.INFO)
self.data = communication.connect_socket(
self.context,
socket_type=zmq.SUB,
connection=self.settings.connections[connection])
self.data.setsockopt(zmq.SUBSCRIBE, self.settings.topics[topic])
def __init__(self,
topic,
path,
sleep=0,
connection="output_data",
settings=configuration.Config(),
serializer=serialization.Serializer()):
super(FileLogger, self).__init__(topic, sleep, connection, settings,
serializer)
self.logger = logging.getLogger(topic + " logger")
self.logger.setLevel(logging.DEBUG)
self.folder = os.path.join(path, topic)
self.log_file = os.path.join(self.folder, topic + "_store" + ".txt")
self.prepare_save(self.folder)
self.store = open(self.log_file, "w")
self.logger.info("Starting to log %s to file: %s", self.topic,
self.log_file)
