def getter_http_flask(raw_getter_url, raw_handler_url): """Server's getter using HTTP protocol and Flask framework""" url = urlparse(raw_getter_url) host = url.hostname if url.hostname else DEFAULT_HOST_FLASK port = url.port if url.port else DEFAULT_PORT_FLASK options = {option.split('=')[0]: option.split('=')[1] for option in url.query.split('&')} debug = options.get('debug', DEFAULT_DEBUG_FLASK) use_reloader = options.get(DEFAULT_USE_RELOADER_FLASK) handlers = dynamic_import('handlers', 'handle_message', 'handler', raw_handler_url) url_handler = urlparse(raw_handler_url) handler_scheme = url_handler.scheme if url_handler.scheme else DEFAULT_SCHEME_HANDLER app = Flask(__name__) @app.route('/', methods=['POST']) def get_message(): try: handler = find_handler(handlers, handler_scheme, request.content_type) handler(request.data, request.content_type) except Exception as e: return Response(str(e), 400) return '', 200 try: app.run(host, port, debug=debug, use_reloader=use_reloader) except (Exception, KeyboardInterrupt) as error: logger.warning(str(error)) logger.info('closing handlers') for handler in handlers.values(): handler(None, '') logger.info('closing app')
def find_sender(raw_url): getters = dynamic_import('senders', 'send', 'sender', raw_url) url = urlparse(raw_url) scheme = url.scheme if url.scheme else DEFAULT_SCHEME_SENDER for (item_scheme, ), method in getters.items(): if item_scheme == scheme: return method raise ValueError(f'no available sender for {scheme} scheme')
def find_db_service(raw_url): db_services = dynamic_import('db_services', None, 'DbService', raw_url) url = urlparse(raw_url) scheme = url.scheme if url.scheme else DEFAULT_SCHEME_DB for (cls_scheme, ), cls in db_services.items(): if scheme == cls_scheme: return cls(url) raise ValueError(f'no available db service for scheme {scheme}')
def find_parse_method(raw_url): parse_methods = dynamic_import('parsers', 'parse', 'parse', raw_url) url = urlparse(raw_url) parser_tag = url.scheme.replace('_', '') if url.scheme else DEFAULT_TAG_PARSER for (tag, ), method in parse_methods.items(): if tag == parser_tag: return method raise ValueError(f'no available {url.scheme} parse method')
def find_handler(raw_url, content_type='/'): handlers = dynamic_import('handlers', 'handle_message', 'handler', raw_url) url = urlparse(raw_url) scheme = url.scheme if url.scheme else DEFAULT_SCHEME_HANDLER message_format = content_type.split('/')[0] for (method_scheme, format), method in handlers.items(): if method_scheme == scheme and format == message_format: return method raise ValueError( f'no available handler for scheme {scheme} and format {message_format}')
def find_getter(raw_url): getters = dynamic_import('getters', 'get_message', 'getter') url = urlparse(raw_url) scheme = url.scheme if url.scheme else DEFAULT_SCHEME_GETTER queries = { attr.split('=')[0]: attr.split('=')[1] for attr in raw_url.query.split('&') } framework = queries.get('framework', DEFAULT_FRAMEWORK_BY_CHEME) for (item_scheme, item_framework), method in getters.items(): if item_scheme == scheme and item_framework == framework: return method raise ValueError(f'no available getter for {scheme} scheme')
def find_api_service(raw_url): db_services = dynamic_import('api_services', 'run', 'Api', raw_url) url = urlparse(raw_url) scheme = url.scheme if url.scheme else DEFAULT_SCHEME_API queries = { attr.split('=')[0]: attr.split('=')[1] for attr in raw_url.query.split('&') } framework = queries.get('framework', DEFAULT_FRAMEWORK_BY_CHEME) for (method_scheme, method_framework), method in db_services.items(): if method_scheme == scheme and method_framework == framework: return method raise ValueError( f'no available api service for scheme {scheme} ans framework {framework}' )
def run(self, raw_getter_url='', raw_parser_url='', sender=None): self.parsers = dynamic_import('parsers', 'parse', 'parser', raw_parser_url) self.channel.basic_consume(qugeue=self.q_name, on_message_callback=partial( self.callback, raw_parser_url, sender)) self.channel.basic_qos(prefetch_count=1) try: logger.debug('start consuming') self.is_consuming = True self.channel.start_consuming() except KeyboardInterrupt: return 0 except Exception as error: logger.fatal(str(error)) return 1