def from_external_config_file(cls,
path,
instance_type,
environment=DEFAULT_ENVIRONMENT,
system_folders=False):
instance_name = Path(path).stem
self_ = cls.__new__(cls)
self_.name = instance_name
self_.scope = "system" if system_folders else "user"
self_.config_dir = Path(path).parent
self_.config_file = path
self_.environment = environment
self_.set_folders(instance_type, instance_name, system_folders)
module_name = logger_name(__name__)
self_.log = logging.getLogger(module_name)
if self_.LOGGING_ENABLED:
self_.setup_logging()
self_.log.debug("Test!")
return self_
def __init__(self):
"""Create a new CryptorBase instance."""
self.log = logging.getLogger(logger_name(__name__))
# -*- coding: utf-8 -*-
import logging
from http import HTTPStatus
from flasgger import swag_from
from pathlib import Path
from vantage6.server.resource import (with_user, ServicesResources)
from vantage6.common import logger_name
from vantage6.server.model import Rule as db_Rule
from vantage6.server.resource._schema import RuleSchema
module_name = logger_name(__name__)
log = logging.getLogger(module_name)
def setup(api, api_base, services):
path = "/".join([api_base, module_name])
log.info(f'Setting up "{path}" and subdirectories')
api.add_resource(Rule,
path,
endpoint='rule_without_id',
methods=('GET', ),
resource_class_kwargs=services)
api.add_resource(Rule,
path + '/<int:id>',
endpoint='rule_with_id',
methods=('GET', ),
resource_class_kwargs=services)
# -*- coding: utf-8 -*-
import logging
import base64
from marshmallow import fields
from marshmallow_sqlalchemy import ModelSchema
from flask import url_for
from vantage6.server import db
from vantage6.common import logger_name
from vantage6.common.globals import STRING_ENCODING
log = logging.getLogger(logger_name(__name__))
class HATEOASModelSchema(ModelSchema):
"""Convert foreign-key fields to HATEOAS specification."""
api = None
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
# to one relationship
setattr(self, "node", lambda obj: self.hateos("node", obj))
setattr(self, "organization",
lambda obj: self.hateos("organization", obj))
setattr(self, "collaboration",
lambda obj: self.hateos("collaboration", obj))
setattr(self, "user", lambda obj: self.hateos("user", obj))
setattr(self, "result", lambda obj: self.hateos("result", obj))
class DefaultSocketNamespace(Namespace):
"""
Handlers for SocketIO events are different than handlers for routes and
that introduces a lot of confusion around what can and cannot be done in a
SocketIO handler. The main difference is that all the SocketIO events
generated for a client occur in the context of a single long running
request.
"""
log = logging.getLogger(logger_name(__name__))
def on_connect(self):
"""
A new incomming connection request from a client.
New incomming connections are authenticated using their
JWT authorization token which is obtained from the REST api.
A session is created for each connected clients which lives
as long as the connection is active. There has not been made
any difference between connecting and re-connecting.
"""
self.log.info(f'Client connected: "{request.sid}"')
# try to catch jwt authorization token.
try:
verify_jwt_in_request()
except jwt.exceptions.ExpiredSignatureError:
self.log.error("JWT has expired")
emit("expired_token", "", room=request.sid)
except Exception as e:
self.log.error(
"Could not connect client! No or Invalid JWT token?")
self.log.exception(e)
session.name = "no-sure-yet"
self.__join_room_and_notify(request.sid)
# FIXME: expired probably doesn't cover it ...
emit("expired_token", "", room=request.sid)
return
# get identity from token.
user_or_node_id = get_jwt_identity()
session.auth = auth = db.Authenticatable.get(user_or_node_id)
session.auth.status = 'online'
session.auth.save()
# It appears to be necessary to use the root socketio instance
# otherwise events cannot be sent outside the current namespace.
# In this case, only events to '/tasks' can be emitted otherwise.
server.socketio.emit('node-status-changed', namespace='/admin')
# define socket-session variables.
session.type = auth.type
session.name = auth.username if session.type == 'user' else auth.name
self.log.info(
f'Client identified as <{session.type}>: <{session.name}>')
# join appropiate rooms, nodes join a specific collaboration room.
# users do not belong to specific collaborations.
session.rooms = ['all_connections', 'all_' + session.type + 's']
if session.type == 'node':
session.rooms.append('collaboration_' + str(auth.collaboration_id))
session.rooms.append('node_' + str(auth.id))
elif session.type == 'user':
session.rooms.append('user_' + str(auth.id))
for room in session.rooms:
self.__join_room_and_notify(room)
def on_disconnect(self):
"""
Client that disconnects needs to leave all rooms.
"""
for room in session.rooms:
# self.__leave_room_and_notify(room)
self.__leave_room_and_notify(room)
session.auth.status = 'offline'
session.auth.save()
# It appears to be necessary to use the root socketio instance
# otherwise events cannot be sent outside the current namespace.
# In this case, only events to '/tasks' can be emitted otherwise.
self.log.warning('emitting to /admin')
server.socketio.emit('node-status-changed', namespace='/admin')
self.log.info(f'{session.name} disconnected')
def on_message(self, message: str):
"""
An incomming message from any client.
Parameters
----------
message : str
message that is going to be displayed in the server-log
"""
self.log.info('received message: ' + message)
def on_error(self, e: str):
"""
An incomming error from any of the client.
Parameters
----------
e : str
error message that is being displayed in the server log
"""
self.log.error(e)
def on_join_room(self, room: str):
"""
Let clients join any room they like by specifying the name.
Parameters
----------
room : str
name of the room the client wants to join
"""
self.__join_room_and_notify(room)
def on_container_failed(self, node_id: int, status_code: int,
result_id: int, collaboration_id: int):
"""
An algorithm container has crashed at a node.
This event notifies all nodes, and users that a container has crashed
in their collaboration.
Parameters
----------
node_id : int
node_id where the algorithm container was running
status_code : int
status code from the container
result_id : int
result_id for which the container was running
collaboration_id : int
collaboration for which the task was running
"""
# obtain run id,
run_id = db.Result.get(result_id).task.run_id
self.log.critical(
f"A container in for run_id={run_id} and result_id={result_id}"
f" within collaboration_id={collaboration_id} on node_id={node_id}"
f" exited with status_code={status_code}.")
room = "collaboration_" + str(collaboration_id)
emit("container_failed", run_id, room=room)
def __join_room_and_notify(self, room: str):
"""
Joins room and notify other clients in this room.
Parameters
----------
room : str
name of the room the client want to join
"""
join_room(room)
msg = f'<{session.name}> joined room <{room}>'
self.log.info(msg)
emit('message', msg, room=room)
def __leave_room_and_notify(self, room: str):
"""
Leave room and notify other clients in this room.
Parameters
----------
room : str
name of the room the client is leaving
"""
leave_room(room)
msg = f'{session.name} left room {room}'
self.log.info(msg)
emit('message', msg, room=room)
# TODO: to be removed in version 2.x.x. nodes 1.1.0 dont use this anymore.
def on_ping(self, node_id):
# self.log.debug(f"ping from id={node_id}")
room = f"node_{node_id}"
emit("pang", "success!", room=room)
import logging
import re
import docker
import requests
import base64
import json
from dateutil.parser import parse
from requests.api import request
from vantage6.common import logger_name
from vantage6.common import ClickLogger
logger = logger_name(__name__)
log = logging.getLogger(logger)
docker_client = docker.from_env()
def registry_basic_auth_header(docker_client, registry):
"""Obtain credentials for registry
This is a wrapper around docker-py to obtain the credentials used
to access a registry. Normally communication to the registry goes
through the Docker deamon API (locally), therefore we have to take
extra steps in order to communicate with the (Harbor) registry
directly.
Note that this has only been tested for the harbor registries.
Parameters