--- /dev/null
+##
+# Copyright 2019 Telefonica Investigacion y Desarrollo, S.A.U.
+# This file is part of OSM
+# All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+# implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+# For those usages not covered by the Apache License, Version 2.0 please
+# contact with: nfvlabs@tid.es
+##
+
+import asyncio
+import time
+
+from juju.model import ModelObserver, Model
+from juju.machine import Machine
+from juju.application import Application
+from juju.action import Action
+
+from n2vc.n2vc_conn import N2VCConnector, juju_status_2_osm_status
+from n2vc.exceptions import N2VCTimeoutException
+
+
+class _Entity:
+ def __init__(self, entity_id: str, entity_type: str, obj: object, db_dict: dict):
+ self.entity_id = entity_id
+ self.entity_type = entity_type
+ self.obj = obj
+ self.event = asyncio.Event()
+ self.db_dict = db_dict
+
+
+class JujuModelObserver(ModelObserver):
+
+ def __init__(self, n2vc: N2VCConnector, model: Model):
+ self.n2vc = n2vc
+ self.model = model
+ model.add_observer(self)
+ self.machines = dict()
+ self.applications = dict()
+ self.actions = dict()
+
+ def register_machine(self, machine: Machine, db_dict: dict):
+ entity_id = machine.entity_id
+ entity = _Entity(entity_id=entity_id, entity_type='machine', obj=machine, db_dict=db_dict)
+ self.machines[entity_id] = entity
+
+ def unregister_machine(self, machine_id: str):
+ if machine_id in self.machines:
+ del self.machines[machine_id]
+
+ def is_machine_registered(self, machine_id: str):
+ return machine_id in self.machines
+
+ def register_application(self, application: Application, db_dict: dict):
+ entity_id = application.entity_id
+ entity = _Entity(entity_id=entity_id, entity_type='application', obj=application, db_dict=db_dict)
+ self.applications[entity_id] = entity
+
+ def unregister_application(self, application_id: str):
+ if application_id in self.applications:
+ del self.applications[application_id]
+
+ def is_application_registered(self, application_id: str):
+ return application_id in self.applications
+
+ def register_action(self, action: Action, db_dict: dict):
+ entity_id = action.entity_id
+ entity = _Entity(entity_id=entity_id, entity_type='action', obj=action, db_dict=db_dict)
+ self.actions[entity_id] = entity
+
+ def unregister_action(self, action_id: str):
+ if action_id in self.actions:
+ del self.actions[action_id]
+
+ def is_action_registered(self, action_id: str):
+ return action_id in self.actions
+
+ async def wait_for_machine(
+ self,
+ machine_id: str,
+ progress_timeout: float = None,
+ total_timeout: float = None) -> int:
+
+ if not self.is_machine_registered(machine_id):
+ return
+
+ # wait for a final state
+ entity = self.machines[machine_id]
+ return await self._wait_for_entity(
+ entity=entity,
+ field_to_check='agent_status',
+ final_states_list=['started'],
+ progress_timeout=progress_timeout,
+ total_timeout=total_timeout)
+
+ async def wait_for_application(
+ self,
+ application_id: str,
+ progress_timeout: float = None,
+ total_timeout: float = None) -> int:
+
+ if not self.is_application_registered(application_id):
+ return
+
+ # application statuses: unknown, active, waiting
+ # wait for a final state
+ entity = self.applications[application_id]
+ return await self._wait_for_entity(
+ entity=entity,
+ field_to_check='status',
+ final_states_list=['active', 'blocked'],
+ progress_timeout=progress_timeout,
+ total_timeout=total_timeout)
+
+ async def wait_for_action(
+ self,
+ action_id: str,
+ progress_timeout: float = None,
+ total_timeout: float = None) -> int:
+
+ if not self.is_action_registered(action_id):
+ return
+
+ # action statuses: pending, running, completed, failed, cancelled
+ # wait for a final state
+ entity = self.actions[action_id]
+ return await self._wait_for_entity(
+ entity=entity,
+ field_to_check='status',
+ final_states_list=['completed', 'failed', 'cancelled'],
+ progress_timeout=progress_timeout,
+ total_timeout=total_timeout)
+
+ async def _wait_for_entity(
+ self,
+ entity: _Entity,
+ field_to_check: str,
+ final_states_list: list,
+ progress_timeout: float = None,
+ total_timeout: float = None) -> int:
+
+ # default values for no timeout
+ if total_timeout is None:
+ total_timeout = 100000
+ if progress_timeout is None:
+ progress_timeout = 100000
+
+ # max end time
+ now = time.time()
+ total_end = now + total_timeout
+
+ if now >= total_end:
+ raise N2VCTimeoutException(
+ message='Total timeout {} seconds, {}: {}'.format(total_timeout, entity.entity_type, entity.entity_id),
+ timeout='total'
+ )
+
+ # update next progress timeout
+ progress_end = now + progress_timeout # type: float
+
+ # which is closest? progress or end timeout?
+ closest_end = min(total_end, progress_end)
+
+ next_timeout = closest_end - now
+
+ retries = 0
+
+ while entity.obj.__getattribute__(field_to_check) not in final_states_list:
+ retries += 1
+ if await _wait_for_event_or_timeout(entity.event, next_timeout):
+ entity.event.clear()
+ else:
+ message = 'Progress timeout {} seconds, {}}: {}'\
+ .format(progress_timeout, entity.entity_type, entity.entity_id)
+ self.n2vc.debug(message)
+ raise N2VCTimeoutException(message=message, timeout='progress')
+ self.n2vc.debug('End of wait. Final state: {}, retries: {}'
+ .format(entity.obj.__getattribute__(field_to_check), retries))
+ return retries
+
+ async def on_change(self, delta, old, new, model):
+
+ if new is None:
+ return
+
+ # log
+ self.n2vc.debug('on_change(): type: {}, entity: {}, id: {}'
+ .format(delta.type, delta.entity, new.entity_id))
+
+ if delta.entity == 'machine':
+
+ # check registered machine
+ if new.entity_id not in self.machines:
+ return
+
+ # write change in database
+ await self.n2vc.write_app_status_to_db(
+ db_dict=self.machines[new.entity_id].db_dict,
+ status=juju_status_2_osm_status(delta.entity, new.agent_status),
+ detailed_status=new.status_message,
+ vca_status=new.status,
+ entity_type='machine'
+ )
+
+ # set event for this machine
+ self.machines[new.entity_id].event.set()
+
+ elif delta.entity == 'application':
+
+ # check registered application
+ if new.entity_id not in self.applications:
+ return
+
+ # write change in database
+ await self.n2vc.write_app_status_to_db(
+ db_dict=self.applications[new.entity_id].db_dict,
+ status=juju_status_2_osm_status(delta.entity, new.status),
+ detailed_status=new.status_message,
+ vca_status=new.status,
+ entity_type='application'
+ )
+
+ # set event for this application
+ self.applications[new.entity_id].event.set()
+
+ elif delta.entity == 'unit':
+
+ # get the application for this unit
+ application_id = delta.data['application']
+
+ # check registered application
+ if application_id not in self.applications:
+ return
+
+ # write change in database
+ await self.n2vc.write_app_status_to_db(
+ db_dict=self.applications[application_id].db_dict,
+ status=juju_status_2_osm_status(delta.entity, new.workload_status),
+ detailed_status=new.workload_status_message,
+ vca_status=new.workload_status,
+ entity_type='unit'
+ )
+
+ # set event for this application
+ self.applications[application_id].event.set()
+
+ elif delta.entity == 'action':
+
+ # check registered action
+ if new.entity_id not in self.actions:
+ return
+
+ # write change in database
+ await self.n2vc.write_app_status_to_db(
+ db_dict=self.actions[new.entity_id].db_dict,
+ status=juju_status_2_osm_status(delta.entity, new.status),
+ detailed_status=new.status,
+ vca_status=new.status,
+ entity_type='action'
+ )
+
+ # set event for this application
+ self.actions[new.entity_id].event.set()
+
+
+async def _wait_for_event_or_timeout(event: asyncio.Event, timeout: float = None):
+ try:
+ await asyncio.wait_for(fut=event.wait(), timeout=timeout)
+ except asyncio.TimeoutError:
+ pass
+ return event.is_set()
--- /dev/null
+##
+# Copyright 2019 Telefonica Investigacion y Desarrollo, S.A.U.
+# This file is part of OSM
+# All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+# implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+# For those usages not covered by the Apache License, Version 2.0 please
+# contact with: nfvlabs@tid.es
+##
+
+
+import abc
+import asyncio
+import os
+import subprocess
+import shlex
+import time
+from enum import Enum
+from http import HTTPStatus
+from n2vc.loggable import Loggable
+from n2vc.exceptions import N2VCBadArgumentsException
+
+from osm_common.dbmongo import DbException
+
+
+class N2VCDeploymentStatus(Enum):
+ PENDING = 'pending'
+ RUNNING = 'running'
+ COMPLETED = 'completed'
+ FAILED = 'failed'
+ UNKNOWN = 'unknown'
+
+
+class N2VCConnector(abc.ABC, Loggable):
+ """Generic N2VC connector
+
+ Abstract class
+ """
+
+ """
+ ##################################################################################################
+ ########################################## P U B L I C ###########################################
+ ##################################################################################################
+ """
+
+ def __init__(
+ self,
+ db: object,
+ fs: object,
+ log: object,
+ loop: object,
+ url: str,
+ username: str,
+ vca_config: dict,
+ on_update_db = None
+ ):
+ """Initialize N2VC abstract connector. It defines de API for VCA connectors
+
+ :param object db: Mongo object managing the MongoDB (repo common DbBase)
+ :param object fs: FileSystem object managing the package artifacts (repo common FsBase)
+ :param object log: the logging object to log to
+ :param object loop: the loop to use for asyncio (default current thread loop)
+ :param str url: a string that how to connect to the VCA (if needed, IP and port can be obtained from there)
+ :param str username: the username to authenticate with VCA
+ :param dict vca_config: Additional parameters for the specific VCA. For example, for juju it will contain:
+ secret: The password to authenticate with
+ public_key: The contents of the juju public SSH key
+ ca_cert str: The CA certificate used to authenticate
+ :param on_update_db: callback called when n2vc connector updates database. Received arguments:
+ table: e.g. "nsrs"
+ filter: e.g. {_id: <nsd-id> }
+ path: e.g. "_admin.deployed.VCA.3."
+ updated_data: e.g. , "{ _admin.deployed.VCA.3.status: 'xxx', etc }"
+ """
+
+ # parent class
+ Loggable.__init__(self, log=log, log_to_console=True, prefix='\nN2VC')
+
+ # check arguments
+ if db is None:
+ raise N2VCBadArgumentsException('Argument db is mandatory', ['db'])
+ if fs is None:
+ raise N2VCBadArgumentsException('Argument fs is mandatory', ['fs'])
+
+ self.info('url={}, username={}, vca_config={}'.format(url, username, vca_config))
+
+ # store arguments into self
+ self.db = db
+ self.fs = fs
+ self.loop = loop or asyncio.get_event_loop()
+ self.url = url
+ self.username = username
+ self.vca_config = vca_config
+ self.on_update_db = on_update_db
+
+ # generate private/public key-pair
+ self.get_public_key()
+
+ @abc.abstractmethod
+ async def get_status(self, namespace: str):
+ """Get namespace status
+
+ :param namespace: we obtain ns from namespace
+ """
+
+ # TODO: review which public key
+ async def get_public_key(self) -> str:
+ """Get the VCA ssh-public-key
+
+ Returns the SSH public key from local mahine, to be injected into virtual machines to
+ be managed by the VCA.
+ First run, a ssh keypair will be created.
+ The public key is injected into a VM so that we can provision the
+ machine with Juju, after which Juju will communicate with the VM
+ directly via the juju agent.
+ """
+
+ public_key = ''
+
+ # Find the path where we expect our key lives (~/.ssh)
+ homedir = os.environ['HOME']
+ sshdir = "{}/.ssh".format(homedir)
+ if not os.path.exists(sshdir):
+ os.mkdir(sshdir)
+
+ self.private_key_path = "{}/id_n2vc_rsa".format(sshdir)
+ self.public_key_path = "{}.pub".format(self.private_key_path)
+
+ # If we don't have a key generated, then we have to generate it using ssh-keygen
+ if not os.path.exists(self.private_key_path):
+ cmd = "ssh-keygen -t {} -b {} -N '' -f {}".format(
+ "rsa",
+ "4096",
+ self.private_key_path
+ )
+ # run command with arguments
+ subprocess.check_output(shlex.split(cmd))
+
+ # Read the public key. Only one public key (one line) in the file
+ with open(self.public_key_path, "r") as file:
+ public_key = file.readline()
+
+ return public_key
+
+ @abc.abstractmethod
+ async def create_execution_environment(
+ self,
+ namespace: str,
+ db_dict: dict,
+ reuse_ee_id: str = None,
+ progress_timeout: float = None,
+ total_timeout: float = None
+ ) -> (str, dict):
+ """Create an Execution Environment. Returns when it is created or raises an exception on failing
+
+ :param str namespace: Contains a dot separate string.
+ LCM will use: [<nsi-id>].<ns-id>.<vnf-id>.<vdu-id>[-<count>]
+ :param dict db_dict: where to write to database when the status changes.
+ It contains a dictionary with {collection: str, filter: {}, path: str},
+ e.g. {collection: "nsrs", filter: {_id: <nsd-id>, path: "_admin.deployed.VCA.3"}
+ :param str reuse_ee_id: ee id from an older execution. It allows us to reuse an older environment
+ :param float progress_timeout:
+ :param float total_timeout:
+ :returns str, dict: id of the new execution environment and credentials for it
+ (credentials can contains hostname, username, etc depending on underlying cloud)
+ """
+
+ @abc.abstractmethod
+ async def register_execution_environment(
+ self,
+ namespace: str,
+ credentials: dict,
+ db_dict: dict,
+ progress_timeout: float = None,
+ total_timeout: float = None
+ ) -> str:
+ """
+ Register an existing execution environment at the VCA
+
+ :param str namespace: same as create_execution_environment method
+ :param dict credentials: credentials to access the existing execution environment
+ (it can contains hostname, username, path to private key, etc depending on underlying cloud)
+ :param dict db_dict: where to write to database when the status changes.
+ It contains a dictionary with {collection: str, filter: {}, path: str},
+ e.g. {collection: "nsrs", filter: {_id: <nsd-id>, path: "_admin.deployed.VCA.3"}
+ :param float progress_timeout:
+ :param float total_timeout:
+ :returns str: id of the execution environment
+ """
+
+ @abc.abstractmethod
+ async def install_configuration_sw(
+ self,
+ ee_id: str,
+ artifact_path: str,
+ db_dict: dict,
+ progress_timeout: float = None,
+ total_timeout: float = None
+ ):
+ """
+ Install the software inside the execution environment identified by ee_id
+
+ :param str ee_id: the id of the execution environment returned by create_execution_environment
+ or register_execution_environment
+ :param str artifact_path: where to locate the artifacts (parent folder) using the self.fs
+ the final artifact path will be a combination of this artifact_path and additional string from
+ the config_dict (e.g. charm name)
+ :param dict db_dict: where to write into database when the status changes.
+ It contains a dict with {collection: <str>, filter: {}, path: <str>},
+ e.g. {collection: "nsrs", filter: {_id: <nsd-id>, path: "_admin.deployed.VCA.3"}
+ :param float progress_timeout:
+ :param float total_timeout:
+ """
+
+ @abc.abstractmethod
+ async def get_ee_ssh_public__key(
+ self,
+ ee_id: str,
+ db_dict: dict,
+ progress_timeout: float = None,
+ total_timeout: float = None
+ ) -> str:
+ """
+ Generate a priv/pub key pair in the execution environment and return the public key
+
+ :param str ee_id: the id of the execution environment returned by create_execution_environment
+ or register_execution_environment
+ :param dict db_dict: where to write into database when the status changes.
+ It contains a dict with {collection: <str>, filter: {}, path: <str>},
+ e.g. {collection: "nsrs", filter: {_id: <nsd-id>, path: "_admin.deployed.VCA.3"}
+ :param float progress_timeout:
+ :param float total_timeout:
+ :returns: public key of the execution environment
+ For the case of juju proxy charm ssh-layered, it is the one returned by 'get-ssh-public-key'
+ primitive.
+ It raises a N2VC exception if fails
+ """
+
+ @abc.abstractmethod
+ async def add_relation(
+ self,
+ ee_id_1: str,
+ ee_id_2: str,
+ endpoint_1: str,
+ endpoint_2: str
+ ):
+ """
+ Add a relation between two Execution Environments (using their associated endpoints).
+
+ :param str ee_id_1: The id of the first execution environment
+ :param str ee_id_2: The id of the second execution environment
+ :param str endpoint_1: The endpoint in the first execution environment
+ :param str endpoint_2: The endpoint in the second execution environment
+ """
+
+ # TODO
+ @abc.abstractmethod
+ async def remove_relation(
+ self
+ ):
+ """
+ """
+
+ # TODO
+ @abc.abstractmethod
+ async def deregister_execution_environments(
+ self
+ ):
+ """
+ """
+
+ @abc.abstractmethod
+ async def delete_namespace(
+ self,
+ namespace: str,
+ db_dict: dict = None,
+ total_timeout: float = None
+ ):
+ """
+ Remove a network scenario and its execution environments
+ :param namespace: [<nsi-id>].<ns-id>
+ :param dict db_dict: where to write into database when the status changes.
+ It contains a dict with {collection: <str>, filter: {}, path: <str>},
+ e.g. {collection: "nsrs", filter: {_id: <nsd-id>, path: "_admin.deployed.VCA.3"}
+ :param float total_timeout:
+ """
+
+ @abc.abstractmethod
+ async def delete_execution_environment(
+ self,
+ ee_id: str,
+ db_dict: dict = None,
+ total_timeout: float = None
+ ):
+ """
+ Delete an execution environment
+ :param str ee_id: id of the execution environment to delete
+ :param dict db_dict: where to write into database when the status changes.
+ It contains a dict with {collection: <str>, filter: {}, path: <str>},
+ e.g. {collection: "nsrs", filter: {_id: <nsd-id>, path: "_admin.deployed.VCA.3"}
+ :param float total_timeout:
+ """
+
+ @abc.abstractmethod
+ async def exec_primitive(
+ self,
+ ee_id: str,
+ primitive_name: str,
+ params_dict: dict,
+ db_dict: dict = None,
+ progress_timeout: float = None,
+ total_timeout: float = None
+ ) -> str:
+ """
+ Execute a primitive in the execution environment
+
+ :param str ee_id: the one returned by create_execution_environment or register_execution_environment
+ :param str primitive_name: must be one defined in the software. There is one called 'config',
+ where, for the proxy case, the 'credentials' of VM are provided
+ :param dict params_dict: parameters of the action
+ :param dict db_dict: where to write into database when the status changes.
+ It contains a dict with {collection: <str>, filter: {}, path: <str>},
+ e.g. {collection: "nsrs", filter: {_id: <nsd-id>, path: "_admin.deployed.VCA.3"}
+ :param float progress_timeout:
+ :param float total_timeout:
+ :returns str: primitive result, if ok. It raises exceptions in case of fail
+ """
+
+ async def disconnect(self):
+ """
+ Disconnect from VCA
+ """
+
+ """
+ ##################################################################################################
+ ########################################## P R I V A T E #########################################
+ ##################################################################################################
+ """
+
+ def _get_namespace_components(self, namespace: str) -> (str, str, str, str, str):
+ """
+ Split namespace components
+
+ :param namespace: [<nsi-id>].<ns-id>.<vnf-id>.<vdu-id>[-<count>]
+ :return: nsi_id, ns_id, vnf_id, vdu_id, vdu_count
+ """
+
+ # check parameters
+ if namespace is None or len(namespace) == 0:
+ raise N2VCBadArgumentsException('Argument namespace is mandatory', ['namespace'])
+
+ # split namespace components
+ parts = namespace.split('.')
+ nsi_id = None
+ ns_id = None
+ vnf_id = None
+ vdu_id = None
+ vdu_count = None
+ if len(parts) > 0 and len(parts[0]) > 0:
+ nsi_id = parts[0]
+ if len(parts) > 1 and len(parts[1]) > 0:
+ ns_id = parts[1]
+ if len(parts) > 2 and len(parts[2]) > 0:
+ vnf_id = parts[2]
+ if len(parts) > 3 and len(parts[3]) > 0:
+ vdu_id = parts[3]
+ vdu_parts = parts[3].split('-')
+ if len(vdu_parts) > 1:
+ vdu_id = vdu_parts[0]
+ vdu_count = vdu_parts[1]
+
+ return nsi_id, ns_id, vnf_id, vdu_id, vdu_count
+
+ async def write_app_status_to_db(
+ self,
+ db_dict: dict,
+ status: N2VCDeploymentStatus,
+ detailed_status: str,
+ vca_status: str,
+ entity_type: str
+ ):
+ if not db_dict:
+ self.debug('No db_dict => No database write')
+ return
+
+ self.debug('status={} / detailed-status={} / VCA-status={} / entity_type={}'
+ .format(str(status.value), detailed_status, vca_status, entity_type))
+
+ try:
+
+ the_table = db_dict['collection']
+ the_filter = db_dict['filter']
+ the_path = db_dict['path']
+ if not the_path[-1] == '.':
+ the_path = the_path + '.'
+ update_dict = {
+ the_path + 'status': str(status.value),
+ the_path + 'detailed-status': detailed_status,
+ the_path + 'VCA-status': vca_status,
+ the_path + 'entity-type': entity_type,
+ the_path + 'status-time': str(time.time()),
+ }
+
+ self.db.set_one(
+ table=the_table,
+ q_filter=the_filter,
+ update_dict=update_dict,
+ fail_on_empty=True
+ )
+
+ # database callback
+ if self.on_update_db:
+ if asyncio.iscoroutinefunction(self.on_update_db):
+ await self.on_update_db(the_table, the_filter, the_path, update_dict)
+ else:
+ self.on_update_db(the_table, the_filter, the_path, update_dict)
+
+ except DbException as e:
+ if e.http_code == HTTPStatus.NOT_FOUND:
+ self.error('NOT_FOUND error: Exception writing status to database: {}'.format(e))
+ else:
+ self.info('Exception writing status to database: {}'.format(e))
+
+
+def juju_status_2_osm_status(type: str, status: str) -> N2VCDeploymentStatus:
+ if type == 'application' or type == 'unit':
+ if status in ['waiting', 'maintenance']:
+ return N2VCDeploymentStatus.RUNNING
+ elif status in ['active']:
+ return N2VCDeploymentStatus.COMPLETED
+ elif status in ['blocked']:
+ return N2VCDeploymentStatus.RUNNING
+ else:
+ return N2VCDeploymentStatus.UNKNOWN
+ elif type == 'action':
+ if status in ['running']:
+ return N2VCDeploymentStatus.RUNNING
+ elif status in ['completed']:
+ return N2VCDeploymentStatus.COMPLETED
+ else:
+ return N2VCDeploymentStatus.UNKNOWN
+ elif type == 'machine':
+ if status in ['pending']:
+ return N2VCDeploymentStatus.PENDING
+ elif status in ['started']:
+ return N2VCDeploymentStatus.COMPLETED
+ else:
+ return N2VCDeploymentStatus.UNKNOWN
+
+ return N2VCDeploymentStatus.FAILED
--- /dev/null
+##
+# Copyright 2019 Telefonica Investigacion y Desarrollo, S.A.U.
+# This file is part of OSM
+# All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+# implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+# For those usages not covered by the Apache License, Version 2.0 please
+# contact with: nfvlabs@tid.es
+##
+
+import logging
+import os
+import asyncio
+import time
+import base64
+import binascii
+import re
+
+from n2vc.n2vc_conn import N2VCConnector
+from n2vc.exceptions \
+ import N2VCBadArgumentsException, N2VCException, N2VCConnectionException, \
+ N2VCExecutionException, N2VCInvalidCertificate
+from n2vc.juju_observer import JujuModelObserver
+
+from juju.controller import Controller
+from juju.model import Model
+from juju.application import Application
+from juju.action import Action
+from juju.machine import Machine
+
+
+class N2VCJujuConnector(N2VCConnector):
+
+ """
+ ##################################################################################################
+ ########################################## P U B L I C ###########################################
+ ##################################################################################################
+ """
+
+ def __init__(
+ self,
+ db: object,
+ fs: object,
+ log: object = None,
+ loop: object = None,
+ url: str = '127.0.0.1:17070',
+ username: str = 'admin',
+ vca_config: dict = None,
+ on_update_db=None,
+ api_proxy=None
+ ):
+ """Initialize juju N2VC connector
+ """
+
+ # parent class constructor
+ N2VCConnector.__init__(
+ self,
+ db=db,
+ fs=fs,
+ log=log,
+ loop=loop,
+ url=url,
+ username=username,
+ vca_config=vca_config,
+ on_update_db=on_update_db
+ )
+
+ # silence websocket traffic log
+ logging.getLogger('websockets.protocol').setLevel(logging.INFO)
+ logging.getLogger('juju.client.connection').setLevel(logging.WARN)
+ logging.getLogger('model').setLevel(logging.WARN)
+
+ self.info('Initializing N2VC juju connector...')
+
+ """
+ ##############################################################
+ # check arguments
+ ##############################################################
+ """
+
+ # juju URL
+ if url is None:
+ raise N2VCBadArgumentsException('Argument url is mandatory', ['url'])
+ url_parts = url.split(':')
+ if len(url_parts) != 2:
+ raise N2VCBadArgumentsException('Argument url: bad format (localhost:port) -> {}'.format(url), ['url'])
+ self.hostname = url_parts[0]
+ try:
+ self.port = int(url_parts[1])
+ except ValueError:
+ raise N2VCBadArgumentsException('url port must be a number -> {}'.format(url), ['url'])
+
+ # juju USERNAME
+ if username is None:
+ raise N2VCBadArgumentsException('Argument username is mandatory', ['username'])
+
+ # juju CONFIGURATION
+ if vca_config is None:
+ raise N2VCBadArgumentsException('Argument vca_config is mandatory', ['vca_config'])
+
+ if 'secret' in vca_config:
+ self.secret = vca_config['secret']
+ else:
+ raise N2VCBadArgumentsException('Argument vca_config.secret is mandatory', ['vca_config.secret'])
+
+ # pubkey of juju client in osm machine: ~/.local/share/juju/ssh/juju_id_rsa.pub
+ # if exists, it will be written in lcm container: _create_juju_public_key()
+ if 'public_key' in vca_config:
+ self.public_key = vca_config['public_key']
+ else:
+ self.public_key = None
+
+ # TODO: Verify ca_cert is valid before using. VCA will crash
+ # if the ca_cert isn't formatted correctly.
+ def base64_to_cacert(b64string):
+ """Convert the base64-encoded string containing the VCA CACERT.
+
+ The input string....
+
+ """
+ try:
+ cacert = base64.b64decode(b64string).decode("utf-8")
+
+ cacert = re.sub(
+ r'\\n',
+ r'\n',
+ cacert,
+ )
+ except binascii.Error as e:
+ self.debug("Caught binascii.Error: {}".format(e))
+ raise N2VCInvalidCertificate(message="Invalid CA Certificate")
+
+ return cacert
+
+ self.ca_cert = vca_config.get('ca_cert')
+ if self.ca_cert:
+ self.ca_cert = base64_to_cacert(vca_config['ca_cert'])
+
+ if api_proxy:
+ self.api_proxy = api_proxy
+ else:
+ self.warning('api_proxy is not configured. Support for native charms is disabled')
+
+ self.debug('Arguments have been checked')
+
+ # juju data
+ self.controller = None # it will be filled when connect to juju
+ self.juju_models = {} # model objects for every model_name
+ self.juju_observers = {} # model observers for every model_name
+ self._connecting = False # while connecting to juju (to avoid duplicate connections)
+ self._authenticated = False # it will be True when juju connection be stablished
+ self._creating_model = False # True during model creation
+
+ # create juju pub key file in lcm container at ./local/share/juju/ssh/juju_id_rsa.pub
+ self._create_juju_public_key()
+
+ self.info('N2VC juju connector initialized')
+
+ async def get_status(self, namespace: str):
+ self.info('Getting NS status. namespace: {}'.format(namespace))
+
+ if not self._authenticated:
+ await self._juju_login()
+
+ nsi_id, ns_id, vnf_id, vdu_id, vdu_count = self._get_namespace_components(namespace=namespace)
+ # model name is ns_id
+ model_name = ns_id
+ if model_name is None:
+ msg = 'Namespace {} not valid'.format(namespace)
+ self.error(msg)
+ raise N2VCBadArgumentsException(msg, ['namespace'])
+
+ # get juju model (create model if needed)
+ model = await self._juju_get_model(model_name=model_name)
+
+ status = await model.get_status()
+
+ return status
+
+ async def create_execution_environment(
+ self,
+ namespace: str,
+ db_dict: dict,
+ reuse_ee_id: str = None,
+ progress_timeout: float = None,
+ total_timeout: float = None
+ ) -> (str, dict):
+
+ self.info('Creating execution environment. namespace: {}, reuse_ee_id: {}'.format(namespace, reuse_ee_id))
+
+ if not self._authenticated:
+ await self._juju_login()
+
+ machine_id = None
+ if reuse_ee_id:
+ model_name, application_name, machine_id = self._get_ee_id_components(ee_id=reuse_ee_id)
+ else:
+ nsi_id, ns_id, vnf_id, vdu_id, vdu_count = self._get_namespace_components(namespace=namespace)
+ # model name is ns_id
+ model_name = ns_id
+ # application name
+ application_name = self._get_application_name(namespace=namespace)
+
+ self.debug('model name: {}, application name: {}, machine_id: {}'
+ .format(model_name, application_name, machine_id))
+
+ # create or reuse a new juju machine
+ try:
+ machine = await self._juju_create_machine(
+ model_name=model_name,
+ application_name=application_name,
+ machine_id=machine_id,
+ db_dict=db_dict,
+ progress_timeout=progress_timeout,
+ total_timeout=total_timeout
+ )
+ except Exception as e:
+ message = 'Error creating machine on juju: {}'.format(e)
+ self.error(message)
+ raise N2VCException(message=message)
+
+ # id for the execution environment
+ ee_id = N2VCJujuConnector._build_ee_id(
+ model_name=model_name,
+ application_name=application_name,
+ machine_id=str(machine.entity_id)
+ )
+ self.debug('ee_id: {}'.format(ee_id))
+
+ # new machine credentials
+ credentials = dict()
+ credentials['hostname'] = machine.dns_name
+
+ self.info('Execution environment created. ee_id: {}, credentials: {}'.format(ee_id, credentials))
+
+ return ee_id, credentials
+
+ async def register_execution_environment(
+ self,
+ namespace: str,
+ credentials: dict,
+ db_dict: dict,
+ progress_timeout: float = None,
+ total_timeout: float = None
+ ) -> str:
+
+ if not self._authenticated:
+ await self._juju_login()
+
+ self.info('Registering execution environment. namespace={}, credentials={}'.format(namespace, credentials))
+
+ if credentials is None:
+ raise N2VCBadArgumentsException(message='credentials are mandatory', bad_args=['credentials'])
+ if 'hostname' in credentials:
+ hostname = credentials['hostname']
+ else:
+ raise N2VCBadArgumentsException(message='hostname is mandatory', bad_args=['credentials.hostname'])
+ if 'username' in credentials:
+ username = credentials['username']
+ else:
+ raise N2VCBadArgumentsException(message='username is mandatory', bad_args=['credentials.username'])
+ if 'private_key_path' in credentials:
+ private_key_path = credentials['private_key_path']
+ else:
+ # if not passed as argument, use generated private key path
+ private_key_path = self.private_key_path
+
+ nsi_id, ns_id, vnf_id, vdu_id, vdu_count = self._get_namespace_components(namespace=namespace)
+
+ # model name
+ model_name = ns_id
+ # application name
+ application_name = self._get_application_name(namespace=namespace)
+
+ # register machine on juju
+ try:
+ machine = await self._juju_provision_machine(
+ model_name=model_name,
+ hostname=hostname,
+ username=username,
+ private_key_path=private_key_path,
+ db_dict=db_dict,
+ progress_timeout=progress_timeout,
+ total_timeout=total_timeout
+ )
+ except Exception as e:
+ self.error('Error registering machine: {}'.format(e))
+ raise N2VCException(message='Error registering machine on juju: {}'.format(e))
+ self.info('Machine registered')
+
+ # id for the execution environment
+ ee_id = N2VCJujuConnector._build_ee_id(
+ model_name=model_name,
+ application_name=application_name,
+ machine_id=str(machine.entity_id)
+ )
+
+ self.info('Execution environment registered. ee_id: {}'.format(ee_id))
+
+ return ee_id
+
+ async def install_configuration_sw(
+ self,
+ ee_id: str,
+ artifact_path: str,
+ db_dict: dict,
+ progress_timeout: float = None,
+ total_timeout: float = None
+ ):
+
+ self.info('Installing configuration sw on ee_id: {}, artifact path: {}, db_dict: {}'
+ .format(ee_id, artifact_path, db_dict))
+
+ if not self._authenticated:
+ await self._juju_login()
+
+ # check arguments
+ if ee_id is None or len(ee_id) == 0:
+ raise N2VCBadArgumentsException(message='ee_id is mandatory', bad_args=['ee_id'])
+ if artifact_path is None or len(artifact_path) == 0:
+ raise N2VCBadArgumentsException(message='artifact_path is mandatory', bad_args=['artifact_path'])
+ if db_dict is None:
+ raise N2VCBadArgumentsException(message='db_dict is mandatory', bad_args=['db_dict'])
+
+ try:
+ model_name, application_name, machine_id = N2VCJujuConnector._get_ee_id_components(ee_id=ee_id)
+ self.debug('model: {}, application: {}, machine: {}'.format(model_name, application_name, machine_id))
+ except Exception as e:
+ raise N2VCBadArgumentsException(
+ message='ee_id={} is not a valid execution environment id'.format(ee_id),
+ bad_args=['ee_id']
+ )
+
+ # remove // in charm path
+ while artifact_path.find('//') >= 0:
+ artifact_path = artifact_path.replace('//', '/')
+
+ # check charm path
+ if not self.fs.file_exists(artifact_path, mode="dir"):
+ msg = 'artifact path does not exist: {}'.format(artifact_path)
+ raise N2VCBadArgumentsException(message=msg, bad_args=['artifact_path'])
+
+ if artifact_path.startswith('/'):
+ full_path = self.fs.path + artifact_path
+ else:
+ full_path = self.fs.path + '/' + artifact_path
+
+ try:
+ application, retries = await self._juju_deploy_charm(
+ model_name=model_name,
+ application_name=application_name,
+ charm_path=full_path,
+ machine_id=machine_id,
+ db_dict=db_dict,
+ progress_timeout=progress_timeout,
+ total_timeout=total_timeout
+ )
+ except Exception as e:
+ raise N2VCException(message='Error desploying charm into ee={} : {}'.format(ee_id, e))
+
+ self.info('Configuration sw installed')
+
+ async def get_ee_ssh_public__key(
+ self,
+ ee_id: str,
+ db_dict: dict,
+ progress_timeout: float = None,
+ total_timeout: float = None
+ ) -> str:
+
+ self.info('Generating priv/pub key pair and get pub key on ee_id: {}, db_dict: {}'.format(ee_id, db_dict))
+
+ if not self._authenticated:
+ await self._juju_login()
+
+ # check arguments
+ if ee_id is None or len(ee_id) == 0:
+ raise N2VCBadArgumentsException(message='ee_id is mandatory', bad_args=['ee_id'])
+ if db_dict is None:
+ raise N2VCBadArgumentsException(message='db_dict is mandatory', bad_args=['db_dict'])
+
+ try:
+ model_name, application_name, machine_id = N2VCJujuConnector._get_ee_id_components(ee_id=ee_id)
+ self.debug('model: {}, application: {}, machine: {}'.format(model_name, application_name, machine_id))
+ except Exception as e:
+ raise N2VCBadArgumentsException(
+ message='ee_id={} is not a valid execution environment id'.format(ee_id),
+ bad_args=['ee_id']
+ )
+
+ # try to execute ssh layer primitives (if exist):
+ # generate-ssh-key
+ # get-ssh-public-key
+
+ output = None
+
+ # execute action: generate-ssh-key
+ try:
+ output, status = await self._juju_execute_action(
+ model_name=model_name,
+ application_name=application_name,
+ action_name='generate-ssh-key',
+ db_dict=db_dict,
+ progress_timeout=progress_timeout,
+ total_timeout=total_timeout
+ )
+ except Exception as e:
+ self.info('Cannot execute action generate-ssh-key: {}\nContinuing...'.format(e))
+
+ # execute action: get-ssh-public-key
+ try:
+ output, status = await self._juju_execute_action(
+ model_name=model_name,
+ application_name=application_name,
+ action_name='get-ssh-public-key',
+ db_dict=db_dict,
+ progress_timeout=progress_timeout,
+ total_timeout=total_timeout
+ )
+ except Exception as e:
+ msg = 'Cannot execute action get-ssh-public-key: {}\n'.format(e)
+ self.info(msg)
+ raise e
+
+ # return public key if exists
+ return output
+
+ async def add_relation(
+ self,
+ ee_id_1: str,
+ ee_id_2: str,
+ endpoint_1: str,
+ endpoint_2: str
+ ):
+
+ self.debug('adding new relation between {} and {}, endpoints: {}, {}'
+ .format(ee_id_1, ee_id_2, endpoint_1, endpoint_2))
+
+ if not self._authenticated:
+ await self._juju_login()
+
+ # get model, application and machines
+ model_1, app_1, machine_1 = self._get_ee_id_components(ee_id_1)
+ model_2, app_2, machine_2 = self._get_ee_id_components(ee_id_2)
+
+ # model must be the same
+ if model_1 != model_2:
+ message = 'EE models are not the same: {} vs {}'.format(ee_id_1, ee_id_2)
+ self.error(message)
+ raise N2VCBadArgumentsException(message=message, bad_args=['ee_id_1', 'ee_id_2'])
+
+ # add juju relations between two applications
+ try:
+ self._juju_add_relation()
+ except Exception as e:
+ message = 'Error adding relation between {} and {}'.format(ee_id_1, ee_id_2)
+ self.error(message)
+ raise N2VCException(message=message)
+
+ async def remove_relation(
+ self
+ ):
+ if not self._authenticated:
+ await self._juju_login()
+ # TODO
+ self.info('Method not implemented yet')
+ raise NotImplemented()
+
+ async def deregister_execution_environments(
+ self
+ ):
+ if not self._authenticated:
+ await self._juju_login()
+ # TODO
+ self.info('Method not implemented yet')
+ raise NotImplemented()
+
+ async def delete_namespace(
+ self,
+ namespace: str,
+ db_dict: dict = None,
+ total_timeout: float = None
+ ):
+ self.info('Deleting namespace={}'.format(namespace))
+
+ if not self._authenticated:
+ await self._juju_login()
+
+ # check arguments
+ if namespace is None:
+ raise N2VCBadArgumentsException(message='namespace is mandatory', bad_args=['namespace'])
+
+ nsi_id, ns_id, vnf_id, vdu_id, vdu_count = self._get_namespace_components(namespace=namespace)
+ if ns_id is not None:
+ self.debug('Deleting model {}'.format(ns_id))
+ try:
+ await self._juju_destroy_model(
+ model_name=ns_id,
+ total_timeout=total_timeout
+ )
+ except Exception as e:
+ raise N2VCException(message='Error deleting namespace {} : {}'.format(namespace, e))
+ else:
+ raise N2VCBadArgumentsException(message='only ns_id is permitted to delete yet', bad_args=['namespace'])
+
+ self.info('Namespace {} deleted'.format(namespace))
+
+ async def delete_execution_environment(
+ self,
+ ee_id: str,
+ db_dict: dict = None,
+ total_timeout: float = None
+ ):
+ self.info('Deleting execution environment ee_id={}'.format(ee_id))
+
+ if not self._authenticated:
+ await self._juju_login()
+
+ # check arguments
+ if ee_id is None:
+ raise N2VCBadArgumentsException(message='ee_id is mandatory', bad_args=['ee_id'])
+
+ model_name, application_name, machine_id = self._get_ee_id_components(ee_id=ee_id)
+
+ # destroy the application
+ try:
+ await self._juju_destroy_application(model_name=model_name, application_name=application_name)
+ except Exception as e:
+ raise N2VCException(message='Error deleting execution environment {} (application {}) : {}'
+ .format(ee_id, application_name, e))
+
+ # destroy the machine
+ try:
+ await self._juju_destroy_machine(
+ model_name=model_name,
+ machine_id=machine_id,
+ total_timeout=total_timeout
+ )
+ except Exception as e:
+ raise N2VCException(message='Error deleting execution environment {} (machine {}) : {}'
+ .format(ee_id, machine_id, e))
+
+ self.info('Execution environment {} deleted'.format(ee_id))
+
+ async def exec_primitive(
+ self,
+ ee_id: str,
+ primitive_name: str,
+ params_dict: dict,
+ db_dict: dict = None,
+ progress_timeout: float = None,
+ total_timeout: float = None
+ ) -> str:
+
+ self.info('Executing primitive: {} on ee: {}, params: {}'.format(primitive_name, ee_id, params_dict))
+
+ if not self._authenticated:
+ await self._juju_login()
+
+ # check arguments
+ if ee_id is None or len(ee_id) == 0:
+ raise N2VCBadArgumentsException(message='ee_id is mandatory', bad_args=['ee_id'])
+ if primitive_name is None or len(primitive_name) == 0:
+ raise N2VCBadArgumentsException(message='action_name is mandatory', bad_args=['action_name'])
+ if params_dict is None:
+ params_dict = dict()
+
+ try:
+ model_name, application_name, machine_id = N2VCJujuConnector._get_ee_id_components(ee_id=ee_id)
+ except Exception:
+ raise N2VCBadArgumentsException(
+ message='ee_id={} is not a valid execution environment id'.format(ee_id),
+ bad_args=['ee_id']
+ )
+
+ if primitive_name == 'config':
+ # Special case: config primitive
+ try:
+ await self._juju_configure_application(
+ model_name=model_name,
+ application_name=application_name,
+ config=params_dict,
+ db_dict=db_dict,
+ progress_timeout=progress_timeout,
+ total_timeout=total_timeout
+ )
+ except Exception as e:
+ self.error('Error configuring juju application: {}'.format(e))
+ raise N2VCExecutionException(
+ message='Error configuring application into ee={} : {}'.format(ee_id, e),
+ primitive_name=primitive_name
+ )
+ return 'CONFIG OK'
+ else:
+ try:
+ output, status = await self._juju_execute_action(
+ model_name=model_name,
+ application_name=application_name,
+ action_name=primitive_name,
+ db_dict=db_dict,
+ progress_timeout=progress_timeout,
+ total_timeout=total_timeout,
+ **params_dict
+ )
+ if status == 'completed':
+ return output
+ else:
+ raise Exception('status is not completed: {}'.format(status))
+ except Exception as e:
+ self.error('Error executing primitive {}: {}'.format(primitive_name, e))
+ raise N2VCExecutionException(
+ message='Error executing primitive {} into ee={} : {}'.format(primitive_name, ee_id, e),
+ primitive_name=primitive_name
+ )
+
+ async def disconnect(self):
+ self.info('closing juju N2VC...')
+ await self._juju_logout()
+
+ """
+ ##################################################################################################
+ ########################################## P R I V A T E #########################################
+ ##################################################################################################
+ """
+
+ def _write_ee_id_db(
+ self,
+ db_dict: dict,
+ ee_id: str
+ ):
+
+ # write ee_id to database: _admin.deployed.VCA.x
+ try:
+ the_table = db_dict['collection']
+ the_filter = db_dict['filter']
+ the_path = db_dict['path']
+ if not the_path[-1] == '.':
+ the_path = the_path + '.'
+ update_dict = {the_path + 'ee_id': ee_id}
+ self.debug('Writing ee_id to database: {}'.format(the_path))
+ self.db.set_one(
+ table=the_table,
+ q_filter=the_filter,
+ update_dict=update_dict,
+ fail_on_empty=True
+ )
+ except Exception as e:
+ self.error('Error writing ee_id to database: {}'.format(e))
+
+ @staticmethod
+ def _build_ee_id(
+ model_name: str,
+ application_name: str,
+ machine_id: str
+ ):
+ """
+ Build an execution environment id form model, application and machine
+ :param model_name:
+ :param application_name:
+ :param machine_id:
+ :return:
+ """
+ # id for the execution environment
+ return '{}.{}.{}'.format(model_name, application_name, machine_id)
+
+ @staticmethod
+ def _get_ee_id_components(
+ ee_id: str
+ ) -> (str, str, str):
+ """
+ Get model, application and machine components from an execution environment id
+ :param ee_id:
+ :return: model_name, application_name, machine_id
+ """
+
+ if ee_id is None:
+ return None, None, None
+
+ # split components of id
+ parts = ee_id.split('.')
+ model_name = parts[0]
+ application_name = parts[1]
+ machine_id = parts[2]
+ return model_name, application_name, machine_id
+
+ def _get_application_name(self, namespace: str) -> str:
+ """
+ Build application name from namespace
+ :param namespace:
+ :return: app-vnf-<vnf id>-vdu-<vdu-id>-cnt-<vdu-count>
+ """
+
+ # split namespace components
+ _, _, vnf_id, vdu_id, vdu_count = self._get_namespace_components(namespace=namespace)
+
+ if vnf_id is None or len(vnf_id) == 0:
+ vnf_id = ''
+ else:
+ vnf_id = 'vnf-' + vnf_id
+
+ if vdu_id is None or len(vdu_id) == 0:
+ vdu_id = ''
+ else:
+ vdu_id = '-vdu-' + vdu_id
+
+ if vdu_count is None or len(vdu_count) == 0:
+ vdu_count = ''
+ else:
+ vdu_count = '-cnt-' + vdu_count
+
+ application_name = 'app-{}{}{}'.format(vnf_id, vdu_id, vdu_count)
+
+ return N2VCJujuConnector._format_app_name(application_name)
+
+ async def _juju_create_machine(
+ self,
+ model_name: str,
+ application_name: str,
+ machine_id: str = None,
+ db_dict: dict = None,
+ progress_timeout: float = None,
+ total_timeout: float = None
+ ) -> Machine:
+
+ self.debug('creating machine in model: {}, existing machine id: {}'.format(model_name, machine_id))
+
+ # get juju model and observer (create model if needed)
+ model = await self._juju_get_model(model_name=model_name)
+ observer = self.juju_observers[model_name]
+
+ # find machine id in model
+ machine = None
+ if machine_id is not None:
+ self.debug('Finding existing machine id {} in model'.format(machine_id))
+ # get juju existing machines in the model
+ existing_machines = await model.get_machines()
+ if machine_id in existing_machines:
+ self.debug('Machine id {} found in model (reusing it)'.format(machine_id))
+ machine = model.machines[machine_id]
+
+ if machine is None:
+ self.debug('Creating a new machine in juju...')
+ # machine does not exist, create it and wait for it
+ machine = await model.add_machine(
+ spec=None,
+ constraints=None,
+ disks=None,
+ series='xenial'
+ )
+
+ # register machine with observer
+ observer.register_machine(machine=machine, db_dict=db_dict)
+
+ # id for the execution environment
+ ee_id = N2VCJujuConnector._build_ee_id(
+ model_name=model_name,
+ application_name=application_name,
+ machine_id=str(machine.entity_id)
+ )
+
+ # write ee_id in database
+ self._write_ee_id_db(
+ db_dict=db_dict,
+ ee_id=ee_id
+ )
+
+ # wait for machine creation
+ await observer.wait_for_machine(
+ machine_id=str(machine.entity_id),
+ progress_timeout=progress_timeout,
+ total_timeout=total_timeout
+ )
+
+ else:
+
+ self.debug('Reusing old machine pending')
+
+ # register machine with observer
+ observer.register_machine(machine=machine, db_dict=db_dict)
+
+ # machine does exist, but it is in creation process (pending), wait for create finalisation
+ await observer.wait_for_machine(
+ machine_id=machine.entity_id,
+ progress_timeout=progress_timeout,
+ total_timeout=total_timeout)
+
+ self.debug("Machine ready at " + str(machine.dns_name))
+ return machine
+
+ async def _juju_provision_machine(
+ self,
+ model_name: str,
+ hostname: str,
+ username: str,
+ private_key_path: str,
+ db_dict: dict = None,
+ progress_timeout: float = None,
+ total_timeout: float = None
+ ) -> Machine:
+
+ self.debug('provisioning machine. model: {}, hostname: {}'.format(model_name, hostname))
+
+ if not self._authenticated:
+ await self._juju_login()
+
+ # get juju model and observer
+ model = await self._juju_get_model(model_name=model_name)
+ observer = self.juju_observers[model_name]
+
+ spec = 'ssh:{}@{}:{}'.format(username, hostname, private_key_path)
+ self.debug('provisioning machine {}'.format(spec))
+ try:
+ machine = await model.add_machine(spec=spec)
+ except Exception as e:
+ import sys
+ import traceback
+ traceback.print_exc(file=sys.stdout)
+ print('-' * 60)
+ raise e
+
+ # register machine with observer
+ observer.register_machine(machine=machine, db_dict=db_dict)
+
+ # wait for machine creation
+ self.debug('waiting for provision completed... {}'.format(machine.entity_id))
+ await observer.wait_for_machine(
+ machine=machine,
+ progress_timeout=progress_timeout,
+ total_timeout=total_timeout
+ )
+
+ self.debug("Machine provisioned {}".format(machine.entity_id))
+ return machine
+
+ async def _juju_deploy_charm(
+ self,
+ model_name: str,
+ application_name: str,
+ charm_path: str,
+ machine_id: str,
+ db_dict: dict,
+ progress_timeout: float = None,
+ total_timeout: float = None
+ ) -> (Application, int):
+
+ # get juju model and observer
+ model = await self._juju_get_model(model_name=model_name)
+ observer = self.juju_observers[model_name]
+
+ # check if application already exists
+ application = None
+ if application_name in model.applications:
+ application = model.applications[application_name]
+
+ if application is None:
+
+ # application does not exist, create it and wait for it
+ self.debug('deploying application {} to machine {}, model {}'
+ .format(application_name, machine_id, model_name))
+ self.debug('charm: {}'.format(charm_path))
+ application = await model.deploy(
+ entity_url=charm_path,
+ application_name=application_name,
+ channel='stable',
+ num_units=1,
+ series='xenial',
+ to=machine_id
+ )
+
+ # register application with observer
+ observer.register_application(application=application, db_dict=db_dict)
+
+ self.debug('waiting for application deployed... {}'.format(application.entity_id))
+ retries = await observer.wait_for_application(
+ application_id=application.entity_id,
+ progress_timeout=progress_timeout,
+ total_timeout=total_timeout)
+ self.debug('application deployed')
+
+ else:
+
+ # register application with observer
+ observer.register_application(application=application, db_dict=db_dict)
+
+ # application already exists, but not finalised
+ self.debug('application already exists, waiting for deployed...')
+ retries = await observer.wait_for_application(
+ application_id=application.entity_id,
+ progress_timeout=progress_timeout,
+ total_timeout=total_timeout)
+ self.debug('application deployed')
+
+ return application, retries
+
+ async def _juju_execute_action(
+ self,
+ model_name: str,
+ application_name: str,
+ action_name: str,
+ db_dict: dict,
+ progress_timeout: float = None,
+ total_timeout: float = None,
+ **kwargs
+ ) -> Action:
+
+ # get juju model and observer
+ model = await self._juju_get_model(model_name=model_name)
+ observer = self.juju_observers[model_name]
+
+ application = await self._juju_get_application(model_name=model_name, application_name=application_name)
+
+ self.debug('trying to execute action {}'.format(action_name))
+ unit = application.units[0]
+ if unit is not None:
+ actions = await application.get_actions()
+ if action_name in actions:
+ self.debug('executing action {} with params {}'.format(action_name, kwargs))
+ action = await unit.run_action(action_name, **kwargs)
+
+ # register action with observer
+ observer.register_action(action=action, db_dict=db_dict)
+
+ self.debug(' waiting for action completed or error...')
+ await observer.wait_for_action(
+ action_id=action.entity_id,
+ progress_timeout=progress_timeout,
+ total_timeout=total_timeout)
+ self.debug('action completed with status: {}'.format(action.status))
+ output = await model.get_action_output(action_uuid=action.entity_id)
+ status = await model.get_action_status(uuid_or_prefix=action.entity_id)
+ if action.entity_id in status:
+ status = status[action.entity_id]
+ else:
+ status = 'failed'
+ return output, status
+
+ raise N2VCExecutionException(
+ message='Cannot execute action on charm',
+ primitive_name=action_name
+ )
+
+ async def _juju_configure_application(
+ self,
+ model_name: str,
+ application_name: str,
+ config: dict,
+ db_dict: dict,
+ progress_timeout: float = None,
+ total_timeout: float = None
+ ):
+
+ # get juju model
+ model = await self._juju_get_model(model_name=model_name)
+
+ # get the application
+ application = await self._juju_get_application(model_name=model_name, application_name=application_name)
+
+ self.debug('configuring the application {} -> {}'.format(application_name, config))
+ res = await application.set_config(config)
+ self.debug('application {} configured. res={}'.format(application_name, res))
+
+ # Verify the config is set
+ new_conf = await application.get_config()
+ for key in config:
+ value = new_conf[key]['value']
+ self.debug(' {} = {}'.format(key, value))
+ if config[key] != value:
+ raise N2VCException(
+ message='key {} is not configured correctly {} != {}'.format(key, config[key], new_conf[key])
+ )
+
+ # check if 'verify-ssh-credentials' action exists
+ unit = application.units[0]
+ actions = await application.get_actions()
+ if 'verify-ssh-credentials' not in actions:
+ msg = 'Action verify-ssh-credentials does not exist in application {}'.format(application_name)
+ return False
+
+ # execute verify-credentials
+ num_retries = 20
+ retry_timeout = 15.0
+ for i in range(num_retries):
+ try:
+ self.debug('Executing action verify-ssh-credentials...')
+ output, ok = await self._juju_execute_action(
+ model_name=model_name,
+ application_name=application_name,
+ action_name='verify-ssh-credentials',
+ db_dict=db_dict,
+ progress_timeout=progress_timeout,
+ total_timeout=total_timeout
+ )
+ self.debug('Result: {}, output: {}'.format(ok, output))
+ return True
+ except Exception as e:
+ self.debug('Error executing verify-ssh-credentials: {}. Retrying...'.format(e))
+ await asyncio.sleep(retry_timeout)
+ else:
+ self.error('Error executing verify-ssh-credentials after {} retries. '.format(num_retries))
+ return False
+
+ async def _juju_get_application(
+ self,
+ model_name: str,
+ application_name: str
+ ):
+ """Get the deployed application."""
+
+ model = await self._juju_get_model(model_name=model_name)
+
+ application_name = N2VCJujuConnector._format_app_name(application_name)
+
+ if model.applications and application_name in model.applications:
+ return model.applications[application_name]
+ else:
+ raise N2VCException(message='Cannot get application {} from model {}'.format(application_name, model_name))
+
+ async def _juju_get_model(self, model_name: str) -> Model:
+ """ Get a model object from juju controller
+
+ :param str model_name: name of the model
+ :returns Model: model obtained from juju controller or Exception
+ """
+
+ # format model name
+ model_name = N2VCJujuConnector._format_model_name(model_name)
+
+ if model_name in self.juju_models:
+ return self.juju_models[model_name]
+
+ if self._creating_model:
+ self.debug('Another coroutine is creating a model. Wait...')
+ while self._creating_model:
+ # another coroutine is creating a model, wait
+ await asyncio.sleep(0.1)
+ # retry (perhaps another coroutine has created the model meanwhile)
+ if model_name in self.juju_models:
+ return self.juju_models[model_name]
+
+ try:
+ self._creating_model = True
+
+ # get juju model names from juju
+ model_list = await self.controller.list_models()
+
+ if model_name not in model_list:
+ self.info('Model {} does not exist. Creating new model...'.format(model_name))
+ model = await self.controller.add_model(
+ model_name=model_name,
+ config={'authorized-keys': self.public_key}
+ )
+ self.info('New model created, name={}'.format(model_name))
+ else:
+ self.debug('Model already exists in juju. Getting model {}'.format(model_name))
+ model = await self.controller.get_model(model_name)
+ self.debug('Existing model in juju, name={}'.format(model_name))
+
+ self.juju_models[model_name] = model
+ self.juju_observers[model_name] = JujuModelObserver(n2vc=self, model=model)
+ return model
+
+ except Exception as e:
+ msg = 'Cannot get model {}. Exception: {}'.format(model_name, e)
+ self.error(msg)
+ raise N2VCException(msg)
+ finally:
+ self._creating_model = False
+
+ async def _juju_add_relation(
+ self,
+ model_name: str,
+ application_name_1: str,
+ application_name_2: str,
+ relation_1: str,
+ relation_2: str
+ ):
+
+ self.debug('adding relation')
+
+ # get juju model and observer
+ model = await self._juju_get_model(model_name=model_name)
+
+ r1 = '{}:{}'.format(application_name_1, relation_1)
+ r2 = '{}:{}'.format(application_name_2, relation_2)
+ await model.add_relation(relation1=r1, relation2=r2)
+
+ async def _juju_destroy_application(
+ self,
+ model_name: str,
+ application_name: str
+ ):
+
+ self.debug('Destroying application {} in model {}'.format(application_name, model_name))
+
+ # get juju model and observer
+ model = await self._juju_get_model(model_name=model_name)
+
+ application = model.applications.get(application_name)
+ if application:
+ await application.destroy()
+ else:
+ self.debug('Application not found: {}'.format(application_name))
+
+ async def _juju_destroy_machine(
+ self,
+ model_name: str,
+ machine_id: str,
+ total_timeout: float = None
+ ):
+
+ self.debug('Destroying machine {} in model {}'.format(machine_id, model_name))
+
+ if total_timeout is None:
+ total_timeout = 3600
+
+ # get juju model and observer
+ model = await self._juju_get_model(model_name=model_name)
+
+ machines = await model.get_machines()
+ if machine_id in machines:
+ machine = model.machines[machine_id]
+ await machine.destroy(force=True)
+ # max timeout
+ end = time.time() + total_timeout
+ # wait for machine removal
+ machines = await model.get_machines()
+ while machine_id in machines and time.time() < end:
+ self.debug('Waiting for machine {} is destroyed'.format(machine_id))
+ await asyncio.sleep(0.5)
+ machines = await model.get_machines()
+ self.debug('Machine destroyed: {}'.format(machine_id))
+ else:
+ self.debug('Machine not found: {}'.format(machine_id))
+
+ async def _juju_destroy_model(
+ self,
+ model_name: str,
+ total_timeout: float = None
+ ):
+
+ self.debug('Destroying model {}'.format(model_name))
+
+ if total_timeout is None:
+ total_timeout = 3600
+
+ model = await self._juju_get_model(model_name=model_name)
+ uuid = model.info.uuid
+
+ self.debug('disconnecting model {}...'.format(model_name))
+ await self._juju_disconnect_model(model_name=model_name)
+ self.juju_models[model_name] = None
+ self.juju_observers[model_name] = None
+
+ self.debug('destroying model {}...'.format(model_name))
+ await self.controller.destroy_model(uuid)
+
+ # wait for model is completely destroyed
+ end = time.time() + total_timeout
+ while time.time() < end:
+ self.debug('waiting for model is destroyed...')
+ try:
+ await self.controller.get_model(uuid)
+ except Exception:
+ self.debug('model destroyed')
+ return
+ await asyncio.sleep(1.0)
+
+ async def _juju_login(self):
+ """Connect to juju controller
+
+ """
+
+ # if already authenticated, exit function
+ if self._authenticated:
+ return
+
+ # if connecting, wait for finish
+ # another task could be trying to connect in parallel
+ while self._connecting:
+ await asyncio.sleep(0.1)
+
+ # double check after other task has finished
+ if self._authenticated:
+ return
+
+ try:
+ self._connecting = True
+ self.info(
+ 'connecting to juju controller: {} {}:{} ca_cert: {}'
+ .format(self.url, self.username, self.secret, '\n'+self.ca_cert if self.ca_cert else 'None'))
+
+ # Create controller object
+ self.controller = Controller(loop=self.loop)
+ # Connect to controller
+ await self.controller.connect(
+ endpoint=self.url,
+ username=self.username,
+ password=self.secret,
+ cacert=self.ca_cert
+ )
+ self._authenticated = True
+ self.info('juju controller connected')
+ except Exception as e:
+ message = 'Exception connecting to juju: {}'.format(e)
+ self.error(message)
+ raise N2VCConnectionException(
+ message=message,
+ url=self.url
+ )
+ finally:
+ self._connecting = False
+
+ async def _juju_logout(self):
+ """Logout of the Juju controller."""
+ if not self._authenticated:
+ return False
+
+ # disconnect all models
+ for model_name in self.juju_models:
+ try:
+ await self._juju_disconnect_model(model_name)
+ except Exception as e:
+ self.error('Error disconnecting model {} : {}'.format(model_name, e))
+ # continue with next model...
+
+ self.info("Disconnecting controller")
+ try:
+ await self.controller.disconnect()
+ except Exception as e:
+ raise N2VCConnectionException(message='Error disconnecting controller: {}'.format(e), url=self.url)
+
+ self.controller = None
+ self._authenticated = False
+ self.info('disconnected')
+
+ async def _juju_disconnect_model(
+ self,
+ model_name: str
+ ):
+ self.debug("Disconnecting model {}".format(model_name))
+ if model_name in self.juju_models:
+ await self.juju_models[model_name].disconnect()
+ self.juju_models[model_name] = None
+ self.juju_observers[model_name] = None
+
+ def _create_juju_public_key(self):
+ """Recreate the Juju public key on lcm container, if needed
+ Certain libjuju commands expect to be run from the same machine as Juju
+ is bootstrapped to. This method will write the public key to disk in
+ that location: ~/.local/share/juju/ssh/juju_id_rsa.pub
+ """
+
+ # Make sure that we have a public key before writing to disk
+ if self.public_key is None or len(self.public_key) == 0:
+ if 'OSMLCM_VCA_PUBKEY' in os.environ:
+ self.public_key = os.getenv('OSMLCM_VCA_PUBKEY', '')
+ if len(self.public_key) == 0:
+ return
+ else:
+ return
+
+ pk_path = "{}/.local/share/juju/ssh".format(os.path.expanduser('~'))
+ file_path = "{}/juju_id_rsa.pub".format(pk_path)
+ self.debug('writing juju public key to file:\n{}\npublic key: {}'.format(file_path, self.public_key))
+ if not os.path.exists(pk_path):
+ # create path and write file
+ os.makedirs(pk_path)
+ with open(file_path, 'w') as f:
+ self.debug('Creating juju public key file: {}'.format(file_path))
+ f.write(self.public_key)
+ else:
+ self.debug('juju public key file already exists: {}'.format(file_path))
+
+ @staticmethod
+ def _format_model_name(name: str) -> str:
+ """Format the name of the model.
+
+ Model names may only contain lowercase letters, digits and hyphens
+ """
+
+ return name.replace('_', '-').replace(' ', '-').lower()
+
+ @staticmethod
+ def _format_app_name(name: str) -> str:
+ """Format the name of the application (in order to assure valid application name).
+
+ Application names have restrictions (run juju deploy --help):
+ - contains lowercase letters 'a'-'z'
+ - contains numbers '0'-'9'
+ - contains hyphens '-'
+ - starts with a lowercase letter
+ - not two or more consecutive hyphens
+ - after a hyphen, not a group with all numbers
+ """
+
+ def all_numbers(s: str) -> bool:
+ for c in s:
+ if not c.isdigit():
+ return False
+ return True
+
+ new_name = name.replace('_', '-')
+ new_name = new_name.replace(' ', '-')
+ new_name = new_name.lower()
+ while new_name.find('--') >= 0:
+ new_name = new_name.replace('--', '-')
+ groups = new_name.split('-')
+
+ # find 'all numbers' groups and prefix them with a letter
+ app_name = ''
+ for i in range(len(groups)):
+ group = groups[i]
+ if all_numbers(group):
+ group = 'z' + group
+ if i > 0:
+ app_name += '-'
+ app_name += group
+
+ if app_name[0].isdigit():
+ app_name = 'z' + app_name
+
+ return app_name
projects / osm / N2VC.git / commitdiff