def __init__(self, catalog, req, resp):
self.log = Log.get('agent-instance-lcp')
self.req = req
self.resp = resp
self.req_lcp = []
self.actions = []
self.parameters = []
self.resources = []
self.catalogs = {'actions': {}, 'parameters': {}, 'resources': {}}
operations = wrap(self.req.get('operations', []))
for req_op in operations:
req_lcp_op = {}
self.req_lcp.append(req_lcp_op)
self.__prepare(req_lcp_op,
'actions',
catalog=catalog.actions,
data=req_op.get('actions', []),
transform_handler=self.__transform_action)
self.__prepare(req_lcp_op,
'parameters',
catalog=catalog.parameters,
data=req_op.get('parameters', []),
transform_handler=self.__transform_parameter)
self.__prepare(req_lcp_op,
'resources',
catalog=catalog.resources,
data=req_op.get('resources', []),
transform_handler=self.__transform_resource)
self.num = len(operations)
def heartbeat_exec_env(exec_env):
log = Log.get('heartbeat')
try:
id = exec_env.meta.id
lcp = exec_env.lcp
lbl = f'{id} (LCP at {exec_env.hostname}:{lcp.port})'
if exec_env.enabled:
schema = 'https' if lcp.https else 'http'
resp = post(f'{schema}://{exec_env.hostname}:{lcp.port}/status',
timeout=Arg_Reader.db.hb_timeout,
headers={'Authorization': create_token()},
json={'id': id})
if resp.status_code == HTTP_Status.OK:
data = resp.json()
id = data.pop('id', None)
lcp.started = data.get('started', None)
lcp.last_heartbeat = data.get('last_heartbeat', None)
log.success(f'Connection established with exec-env {lbl}')
else:
lcp.last_heartbeat = None
log.warning(f'Connection reset with exec-env {lbl}')
log.notice(f'Response: {resp.content}')
if not lcp.https:
lcp.https = False
exec_env.save()
else:
log.notice(f'Exec-env {lbl} not enabled')
except ConnectTimeout:
log.error(f'Connection timeout with exec-env {lbl}')
except ConnectionError:
log.error(f'Connection refused with exec-env {lbl}')
except Exception as exception:
log.exception(f'Exception during connection with exec-env {lbl}',
exception)
def api(title, version):
log = Log.get('api')
middlewares = [Negotiation_Middleware()]
if Arg_Reader.db.auth:
log.notice('JWT authentication enabled')
middlewares.append(
Falcon_Auth_Middleware(
JWT_Auth_Backend(
user_loader=lambda token: {'user': token},
secret_key=Arg_Reader.db.auth_secret_key,
auth_header_prefix=Arg_Reader.db.auth_header_prefix),
exempt_routes=['/api/doc', '/api/doc/swagger.json']))
else:
log.notice('JWT authentication disabled')
if Arg_Reader.db.https:
log.notice('Force to use HTTPS instead of HTTP')
middlewares.append(RequireHTTPS())
else:
log.notice('HTTPS not set')
if Arg_Reader.db.apm_enabled:
log.notice('Elastic APM enabled')
middlewares.append(
Elastic_Apm_Middleware(service_name='lcp-apm',
server_url=Arg_Reader.db.apm_server))
else:
log.notice('Elastic APM disabled')
instance = API(middleware=middlewares)
media_handlers = {
falcon.MEDIA_JSON:
JSON_Handler(loads=loads,
dumps=partial(dumps, ensure_ascii=False, sort_keys=True)),
falcon.MEDIA_MSGPACK:
Message_Pack_Handler(),
falcon.MEDIA_XML:
XML_Handler(),
falcon.MEDIA_YAML:
YAML_Handler()
}
instance.req_options.media_handlers.update(media_handlers)
instance.resp_options.media_handlers.update(media_handlers)
instance.add_error_handler(*Bad_Request_Handler.get())
instance.add_error_handler(*Internal_Server_Error_Handler.get())
instance.add_error_handler(*Unsupported_Media_Type_Handler.get())
api_spec = Spec(api=instance, title=title, version=version)
routes(api=instance, spec=api_spec.get())
falcon_api_doc(instance,
config_path='./swagger/schema.json',
url_prefix='/api/doc',
title='API doc')
api_spec.write()
return instance
def routes(api, spec):
log = Log.get('resource')
for res_class in db:
res = res_class()
for route in wrap(res_class.routes):
api.add_route(route, res)
spec.path(resource=res)
log.success(f'{route} endpoint configured')
def __init__(self):
"""Set the data and logger."""
self.data = {
'id': False,
'started': datetime_to_str(),
'last_heartbeat': False
}
self.log = Log.get('status')
def property_parser(schema, source, path, value):
with open(source, 'rb') as file:
content = Properties()
content.load(file, 'utf-8')
k = '.'.join(path)
try:
old_value, _ = content[k]
except Exception as e:
Log.get('property-parser').exception(f'Parsing property {k}', e)
old_value = None
if old_value != value:
content[k] = value
with open(source, 'wb') as file:
content.store(file, encoding='utf-8')
return {'value': {'new': value, 'old': old_value}}
else:
return {'note': NO_CHANGE_NEEDED}
def __init__(self):
"""Set the data and logger."""
cls = Status_Resource
self.data = dict(id=None,
started=datetime_to_str(),
last_heartbeat=None)
ttl = int(Arg_Reader.db.auth_max_ttl)
cls.auth_db = TTL_Ordered_Dict(default_ttl=ttl)
self.log = Log.get('status')
def parse(self, query, id=None):
try:
self.__select(query)
self.s.query = self.__where(query, id=id)
self.__order(query)
self.__limit(query)
except Request_Error as req_err:
raise HTTP_Bad_Request(title=req_err.error,
description=req_err.info)
except HTTP_Bad_Request as http_bad_req:
raise http_bad_req
except Exception as exception:
Log.get('query-reader').error(f'Exception: {exception}')
raise HTTP_Bad_Request(
title='Not valid JSON',
description=
'The request body is not a valid JSON or it is not encoded as UTF-8.'
)
return self.s
def __init__(self):
if self.doc is not None:
self.log = Log.get(self.doc.Index.name)
err_es_init = True
while err_es_init:
try:
msg = f'Start initialization index {self.doc.Index.name}'
self.log.info(msg)
self.doc.init()
msg = f'Index {self.doc.Index.name} initialized'
self.log.success(msg)
err_es_init = False
except Exception as e:
msg = f'Initialization index {self.doc.Index.name} not possible'
self.log.exception(msg, e)
msg = f'Waiting for {Arg_Reader.db.es_retry_period} seconds and try again'
self.log.info(msg)
sleep(Arg_Reader.db.es_retry_period)
else:
Log.get(self.__class__.__name__).warning('doc not set')
def connection(endpoint, timeout, retry_period):
log = Log.get('elastic-search')
try:
log.info(f'Start connection to Elasticsearch ({endpoint})')
connections.create_connection(hosts=endpoint, timeout=timeout)
except Exception as exception:
log.exception(f'Connection to Elasticsearch ({endpoint}) not possible',
exception)
log.warn(f'Try again in {retry_period} seconds')
sleep(retry_period)
connection(endpoint, timeout, retry_period)
else:
log.success(f'Connection to Elasticsearch ({endpoint}) established')
def __init__(self):
self.host = Arg_Reader.db.polycube_host
self.port = Arg_Reader.db.polycube_port
self.timeout = Arg_Reader.db.polycube_timeout
self.endpoint = f'http://{self.host}:{self.port}/polycube/v1'
self.log = Log.get('polycube')
self.log.info(f'Check connection to {self.endpoint}')
try:
resp_req = get_req(self.endpoint,
timeout=Arg_Reader.db.polycube_timeout)
self.__manager(resp_req)
except Connection_Error as e:
self.log.exception(e)
def property_parser(schema, source, path, value):
with open(source, 'rb') as file:
content = Properties()
content.load(file, 'utf-8')
k = '.'.join(path)
try:
old_value, _ = content[k]
except Exception as e:
Log.get('property-parser').exception(e)
old_value = None
if old_value != value:
content[k] = value
with open(source, 'wb') as file:
content.store(file, encoding='utf-8')
return dict(schema=schema,
source=source,
path=path,
value=dict(new=value, old=old_value))
else:
return dict(schema=schema,
source=source,
path=path,
value=value,
note=NO_CHANGE_NEEDED)
def __init__(self):
"""Initialize the log."""
self.log = Log.get(self.routes[0].replace('/', ''))
def __init__(self, catalog, req, resp):
self.log = Log.get('ebpf-program-instance-lcp')
self.req = req
self.resp = resp
self.req_lcp = {}
self.catalog = catalog
def __get(code):
po = cpo.get(code, None)
if po is None:
Log.get('http-lib').warn(f'{code} without priority order.')
def __log():
return Log.get('lcp')
def __init__(self, dev_username, dev_password):
super().__init__(self.__auth)
self.dev_username = dev_username
self.dev_password = dev_password
self.log = Log.get('basic-auth-backend-extended')
def __init__(self, message, error=False, exception=None, **kwargs):
self.log = Log.get(self.__class__.__name__)
self.data = {'message': message}
if exception is not None:
self.data.update(exception=extract_info(exception))
self.data.update(kwargs)
import waitress # noqa: E402
from rich import pretty, traceback # noqa: E402
from rich.console import Console # noqa: E402
from rich.panel import Panel # noqa: E402
pretty.install()
traceback.install(show_locals=False)
from about import project, title, version # noqa: E402
from api import api # noqa: E402
from reader.arg import Arg_Reader # noqa: E402
from utils.log import Log # noqa: E402
db = Arg_Reader.read()
if db.version is not None:
print(db.version)
else:
ident = f'{project} - {title} v:{version}'
console = Console()
console.print(Panel.fit(ident))
Log.init(config=db.log_config)
api_instance = api(title=title, version=version)
Log.get('api').success(f'Accept requests at {db.host}:{db.port}')
waitress.serve(api_instance,
host=db.host,
port=db.port,
expose_tracebacks=False,
ident=ident,
_quiet=True)
