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
