class Penguin(object):
def __init__(self, server, socket):
self.logger = Logger("Penguin")
self.server = server
self.socket = socket
def send(self, data):
if self.socket:
self.logger.debug(
"sending packet with data - {} - to client".format(data))
self.socket.sendall(data.encode("utf-8"))
def process_event(event, context):
logger = Logger(event)
processor = Processor(event, context, logger)
try:
processor.validate()
processor.write_to_kinesis()
logger.debug('Successfully converted to json',
payload=processor.payload)
return ok()
except JsonSchemaException as json_exception: # schema validation failed
logger.error('Validation error: ' + str(json_exception))
return nok(HTTP_BAD_REQUEST)
except ClientError as client_error: # kinesis error
logger.error('Client error: ' + str(client_error))
return nok(HTTP_TOO_MANY_REQUESTS)
class Server(object):
def __init__(self, config):
self.logger = Logger("Server")
if not config:
self.logger.warning("Unable to find server configuration")
sys.exit()
self.type = config["type"]
self.port = config["port"]
self.max_penguins = config["max_penguins"] if self.type is "world" else 150
self.penguins = []
self.data_handler = DataHandler(self)
def start_server(self):
server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
server.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
server.bind(("127.0.0.1", self.port))
self.logger.info("{0} server listening on port {1}".format(self.type, self.port))
server.listen(10000)
while True:
client, addr = server.accept()
if len(self.penguins) >= self.max_penguins:
client.close()
self.logger.debug("new connection from {}".format(addr))
penguin = Penguin(self, client)
try:
data = client.recv(512).decode("utf-8")
self.logger.debug(data)
if data[0] == "<":
self.logger.debug("received XML packet - {}".format(data))
self.data_handler.handle_xml(penguin, data)
elif data[0] == "%":
self.logger.debug("received RAW packet - {}".format(data))
self.data_handler.handle_raw(penguin, data)
else:
self.logger.debug("received rogue packet - {}".format(data))
finally:
client.close()
def phase_start_time(logger: Logger, log_prefix: str, index: int,
data: str) -> Optional[datetime]:
'''Get the start time for a given phase and return a time stamp'''
# dates look like:
# Sun Apr 25 16:59:09 2021
# Sat May 1 03:10:43 2021
# 1 2 3 4 5 6 7 8 <- group
expression = r'... (\w{3}) (\w{3})(\s{1,2})(\d+) (\d+):(\d+):(\d+) (\d+)'
res = re.search(expression, data[:250])
if not res:
logger.error(f'{log_prefix} index {index} failed to extract date')
return None
have: int = len(res.groups())
need: int = 8
if have != need:
logger.error(
f'{log_prefix} index {index} failed to match date, need {need} groups, have {have} groups'
)
return None
month = res.group(2)
day = res.group(4)
hour = res.group(5)
minute = res.group(6)
second = res.group(7)
year = res.group(8)
date_string: str = f'{year}-{month}-{day} {hour}:{minute}:{second}'
date_format: str = '%Y-%b-%d %H:%M:%S'
dt = datetime.strptime(date_string, date_format)
logger.debug(f'{log_prefix} index {index} start time {dt}')
return dt
class DBHandler:
def __init__(self, engine_url: str):
self.logger = Logger(self.__class__.__name__)
engine = create_engine(engine_url)
self._Session = sessionmaker(bind=engine)
self.session = self._Session()
Base.metadata.create_all(engine)
def insert(self, data: Union[Topic, Passage]):
self.logger.debug(f'trying to insert new row: {data}')
session = self._Session()
session.add(data)
session.commit()
self.logger.debug(f'inserted new row: {data}')
session.close()
def query_topic(self, **kwargs) -> List[Topic]:
self.logger.debug(f'started query on topics with attributes: {kwargs}')
session = self._Session()
ret = list()
for i in session.query(Topic).filter_by(**kwargs):
ret.append(i)
session.expunge_all()
session.close()
self.logger.debug(f'query finished')
return ret
def query_passage(self, **kwargs) -> List[Passage]:
self.logger.debug(
f'started query on passages with attributes: {kwargs}')
session = self._Session()
ret = list()
for i in session.query(Passage).filter_by(**kwargs):
ret.append(i)
session.expunge_all()
session.close()
self.logger.debug(f'query finished')
return ret
