Fix bug 680

[osm/N2VC.git] / n2vc / vnf.py

diff --git a/n2vc/vnf.py b/n2vc/vnf.py
index 1c1208f..a68e657 100644 (file)
--- a/n2vc/vnf.py
+++ b/n2vc/vnf.py
@@ -19,7 +19,7 @@ if path not in sys.path:
 
 from juju.controller import Controller
 from juju.model import ModelObserver
 
 from juju.controller import Controller
 from juju.model import ModelObserver

-from juju.errors import JujuAPIError
+from juju.errors import JujuAPIError, JujuError

 
 # We might need this to connect to the websocket securely, but test and verify.
 try:
 
 # We might need this to connect to the websocket securely, but test and verify.
 try:


@@ -43,6 +43,10 @@ class N2VCPrimitiveExecutionFailed(Exception):
     """Something failed while attempting to execute a primitive."""
 
 
     """Something failed while attempting to execute a primitive."""
 
 

+class NetworkServiceDoesNotExist(Exception):
+    """The Network Service being acted against does not exist."""
+
+

 # Quiet the debug logging
 logging.getLogger('websockets.protocol').setLevel(logging.INFO)
 logging.getLogger('juju.client.connection').setLevel(logging.WARN)
 # Quiet the debug logging
 logging.getLogger('websockets.protocol').setLevel(logging.INFO)
 logging.getLogger('juju.client.connection').setLevel(logging.WARN)


@@ -53,13 +57,12 @@ logging.getLogger('juju.machine').setLevel(logging.WARN)
 class VCAMonitor(ModelObserver):
     """Monitor state changes within the Juju Model."""
     log = None
 class VCAMonitor(ModelObserver):
     """Monitor state changes within the Juju Model."""
     log = None

-    ns_name = None
-    applications = {}

 
     def __init__(self, ns_name):
         self.log = logging.getLogger(__name__)
 
         self.ns_name = ns_name
 
     def __init__(self, ns_name):
         self.log = logging.getLogger(__name__)
 
         self.ns_name = ns_name

+        self.applications = {}

 
     def AddApplication(self, application_name, callback, *callback_args):
         if application_name not in self.applications:
 
     def AddApplication(self, application_name, callback, *callback_args):
         if application_name not in self.applications:


@@ -144,22 +147,34 @@ class N2VC:
                  secret=None,
                  artifacts=None,
                  loop=None,
                  secret=None,
                  artifacts=None,
                  loop=None,

+                 juju_public_key=None,
+                 ca_cert=None,

                  ):
         """Initialize N2VC
                  ):
         """Initialize N2VC

-
-        :param vcaconfig dict A dictionary containing the VCA configuration
-
-        :param artifacts str The directory where charms required by a vnfd are
+        :param log obj: The logging object to log to
+        :param server str: The IP Address or Hostname of the Juju controller
+        :param port int: The port of the Juju Controller
+        :param user str: The Juju username to authenticate with
+        :param secret str: The Juju password to authenticate with
+        :param artifacts str: The directory where charms required by a vnfd are

             stored.
             stored.

+        :param loop obj: The loop to use.
+        :param juju_public_key str: The contents of the Juju public SSH key
+        :param ca_cert str: The CA certificate to use to authenticate
+

 
         :Example:
 
         :Example:

-        n2vc = N2VC(vcaconfig={
-            'secret': 'MzI3MDJhOTYxYmM0YzRjNTJiYmY1Yzdm',
-            'user': 'admin',
-            'ip-address': '10.44.127.137',
-            'port': 17070,
-            'artifacts': '/path/to/charms'
-        })
+        client = n2vc.vnf.N2VC(
+            log=log,
+            server='10.1.1.28',
+            port=17070,
+            user='admin',
+            secret='admin',
+            artifacts='/app/storage/myvnf/charms',
+            loop=loop,
+            juju_public_key='<contents of the juju public key>',
+            ca_cert='<contents of CA certificate>',
+        )

         """
 
         # Initialize instance-level variables
         """
 
         # Initialize instance-level variables


@@ -186,6 +201,12 @@ class N2VC:
         self.username = ""
         self.secret = ""
 
         self.username = ""
         self.secret = ""
 

+        self.juju_public_key = juju_public_key
+        if juju_public_key:
+            self._create_juju_public_key(juju_public_key)
+
+        self.ca_cert = ca_cert
+

         if log:
             self.log = log
         else:
         if log:
             self.log = log
         else:


@@ -218,6 +239,31 @@ class N2VC:
         """Close any open connections."""
         yield self.logout()
 
         """Close any open connections."""
         yield self.logout()
 

+    def _create_juju_public_key(self, public_key):
+        """Recreate the Juju public key on disk.
+
+        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 public_key is None or len(public_key) == 0:
+            if 'OSM_VCA_PUBKEY' in os.environ:
+                public_key = os.getenv('OSM_VCA_PUBKEY', '')
+                if len(public_key == 0):
+                    return
+            else:
+                return
+
+        path = "{}/.local/share/juju/ssh".format(
+            os.path.expanduser('~'),
+        )
+        if not os.path.exists(path):
+            os.makedirs(path)
+
+            with open('{}/juju_id_rsa.pub'.format(path), 'w') as f:
+                f.write(public_key)
+

     def notify_callback(self, model_name, application_name, status, message,
                         callback=None, *callback_args):
         try:
     def notify_callback(self, model_name, application_name, status, message,
                         callback=None, *callback_args):
         try:


@@ -345,6 +391,8 @@ class N2VC:
             'rw_mgmt_ip': '1.2.3.4',
             # Pass the initial-config-primitives section of the vnf or vdu
             'initial-config-primitives': {...}
             'rw_mgmt_ip': '1.2.3.4',
             # Pass the initial-config-primitives section of the vnf or vdu
             'initial-config-primitives': {...}

+            'user_values': dictionary with the day-1 parameters provided at instantiation time. It will replace values
+                inside < >. rw_mgmt_ip will be included here also

           }
         :param dict machine_spec: A dictionary describing the machine to
         install to
           }
         :param dict machine_spec: A dictionary describing the machine to
         install to


@@ -395,11 +443,10 @@ class N2VC:
         # Register this application with the model-level event monitor #
         ################################################################
         if callback:
         # Register this application with the model-level event monitor #
         ################################################################
         if callback:

-            self.monitors[model_name].AddApplication(
+            self.log.debug("JujuApi: Registering callback for {}".format(

                 application_name,
                 application_name,

-                callback,
-                *callback_args
-            )
+            ))
+            await self.Subscribe(model_name, application_name, callback, *callback_args)

 
         ########################################################
         # Check for specific machine placement (native charms) #
 
         ########################################################
         # Check for specific machine placement (native charms) #


@@ -647,15 +694,20 @@ class N2VC:
                 else:
                     seq = primitive['seq']
 
                 else:
                     seq = primitive['seq']
 

-                    params = {}
+                    params_ = {}

                     if 'parameter' in primitive:
                     if 'parameter' in primitive:

-                        params = primitive['parameter']
+                        params_ = primitive['parameter']
+
+                    user_values = params.get("user_values", {})
+                    if 'rw_mgmt_ip' not in user_values:
+                        user_values['rw_mgmt_ip'] = None
+                        # just for backward compatibility, because it will be provided always by modern version of LCM

 
                     primitives[seq] = {
                         'name': primitive['name'],
                         'parameters': self._map_primitive_parameters(
 
                     primitives[seq] = {
                         'name': primitive['name'],
                         'parameters': self._map_primitive_parameters(

-                            params,
-                            {'<rw_mgmt_ip>': None}
+                            params_,
+                            user_values

                         ),
                     }
 
                         ),
                     }
 


@@ -698,7 +750,7 @@ class N2VC:
             'initial-config-primitives': {...}
           }
         """
             'initial-config-primitives': {...}
           }
         """

-        self.log.debug("Executing {}".format(primitive))
+        self.log.debug("Executing primitive={} params={}".format(primitive, params))

         uuid = None
         try:
             if not self.authenticated:
         uuid = None
         try:
             if not self.authenticated:


@@ -748,7 +800,7 @@ class N2VC:
             app = await self.get_application(model, application_name)
             if app:
                 # Remove this application from event monitoring
             app = await self.get_application(model, application_name)
             if app:
                 # Remove this application from event monitoring

-                self.monitors[model_name].RemoveApplication(application_name)
+                await self.Unsubscribe(model_name, application_name)

 
                 # self.notify_callback(model_name, application_name, "removing", callback, *callback_args)
                 self.log.debug(
 
                 # self.notify_callback(model_name, application_name, "removing", callback, *callback_args)
                 self.log.debug(


@@ -758,11 +810,11 @@ class N2VC:
 
                 await self.disconnect_model(self.monitors[model_name])
 
 
                 await self.disconnect_model(self.monitors[model_name])
 

-                # Notify the callback that this charm has been removed.

                 self.notify_callback(
                     model_name,
                     application_name,
                     "removed",
                 self.notify_callback(
                     model_name,
                     application_name,
                     "removed",

+                    "Removing charm {}".format(application_name),

                     callback,
                     *callback_args,
                 )
                     callback,
                     *callback_args,
                 )


@@ -772,8 +824,65 @@ class N2VC:
             self.log.debug(e)
             raise e
 
             self.log.debug(e)
             raise e
 

-    async def DestroyNetworkService(self, nsd):
-        raise NotImplementedError()
+    async def CreateNetworkService(self, ns_uuid):
+        """Create a new Juju model for the Network Service.
+
+        Creates a new Model in the Juju Controller.
+
+        :param str ns_uuid: A unique id representing an instaance of a
+            Network Service.
+
+        :returns: True if the model was created. Raises JujuError on failure.
+        """
+        if not self.authenticated:
+            await self.login()
+
+        models = await self.controller.list_models()
+        if ns_uuid not in models:
+            try:
+                self.models[ns_uuid] = await self.controller.add_model(
+                    ns_uuid
+                )
+            except JujuError as e:
+                if "already exists" not in e.message:
+                    raise e
+
+            # Create an observer for this model
+            await self.create_model_monitor(ns_uuid)
+
+        return True
+
+    async def DestroyNetworkService(self, ns_uuid):
+        """Destroy a Network Service.
+
+        Destroy the Network Service and any deployed charms.
+
+        :param ns_uuid The unique id of the Network Service
+
+        :returns: True if the model was created. Raises JujuError on failure.
+        """
+
+        # Do not delete the default model. The default model was used by all
+        # Network Services, prior to the implementation of a model per NS.
+        if ns_uuid.lower() == "default":
+            return False
+
+        if not self.authenticated:
+            self.log.debug("Authenticating with Juju")
+            await self.login()
+
+        # Disconnect from the Model
+        if ns_uuid in self.models:
+            await self.disconnect_model(self.models[ns_uuid])
+
+        try:
+            await self.controller.destroy_models(ns_uuid)
+        except JujuError:
+            raise NetworkServiceDoesNotExist(
+                "The Network Service '{}' does not exist".format(ns_uuid)
+            )
+
+        return True

 
     async def GetMetrics(self, model_name, application_name):
         """Get the metrics collected by the VCA.
 
     async def GetMetrics(self, model_name, application_name):
         """Get the metrics collected by the VCA.


@@ -796,6 +905,33 @@ class N2VC:
             return True
         return False
 
             return True
         return False
 

+    async def Subscribe(self, ns_name, application_name, callback, *callback_args):
+        """Subscribe to callbacks for an application.
+
+        :param ns_name str: The name of the Network Service
+        :param application_name str: The name of the application
+        :param callback obj: The callback method
+        :param callback_args list: The list of arguments to append to calls to
+            the callback method
+        """
+        self.monitors[ns_name].AddApplication(
+            application_name,
+            callback,
+            *callback_args
+        )
+
+    async def Unsubscribe(self, ns_name, application_name):
+        """Unsubscribe to callbacks for an application.
+
+        Unsubscribes the caller from notifications from a deployed application.
+
+        :param ns_name str: The name of the Network Service
+        :param application_name str: The name of the application
+        """
+        self.monitors[ns_name].RemoveApplication(
+            application_name,
+        )
+

     # Non-public methods
     async def add_relation(self, model_name, relation1, relation2):
         """
     # Non-public methods
     async def add_relation(self, model_name, relation1, relation2):
         """


@@ -852,34 +988,45 @@ class N2VC:
 
         return config
 
 
         return config
 

-    def _map_primitive_parameters(self, parameters, values):
+    def _map_primitive_parameters(self, parameters, user_values):

         params = {}
         for parameter in parameters:
             param = str(parameter['name'])
         params = {}
         for parameter in parameters:
             param = str(parameter['name'])

-            value = None
+            value = parameter.get('value')
+
+            # map parameters inside a < >; e.g. <rw_mgmt_ip>. with the provided user_values.
+            # Must exist at user_values except if there is a default value
+            if isinstance(value, str) and value.startswith("<") and value.endswith(">"):
+                if parameter['value'][1:-1] in user_values:
+                    value = user_values[parameter['value'][1:-1]]
+                elif 'default-value' in parameter:
+                    value = parameter['default-value']
+                else:
+                    raise KeyError("parameter {}='{}' not supplied ".format(param, value))

 
             # If there's no value, use the default-value (if set)
 
             # If there's no value, use the default-value (if set)

-            if parameter['value'] is None and 'default-value' in parameter:
+            if value is None and 'default-value' in parameter:

                 value = parameter['default-value']
 
             # Typecast parameter value, if present
                 value = parameter['default-value']
 
             # Typecast parameter value, if present

-            if 'data-type' in parameter:
-                paramtype = str(parameter['data-type']).lower()
+            paramtype = "string"
+            try:
+                if 'data-type' in parameter:
+                    paramtype = str(parameter['data-type']).lower()

 
 

-                if paramtype == "integer":
-                    value = int(parameter['value'])
-                elif paramtype == "boolean":
-                    value = bool(parameter['value'])
+                    if paramtype == "integer":
+                        value = int(value)
+                    elif paramtype == "boolean":
+                        value = bool(value)
+                    else:
+                        value = str(value)

                 else:
                 else:

-                    value = str(parameter['value'])
-            else:
-                # If there's no data-type, assume the value is a string
-                value = str(parameter['value'])
+                    # If there's no data-type, assume the value is a string
+                    value = str(value)
+            except ValueError:
+                raise ValueError("parameter {}='{}' cannot be converted to type {}".format(param, value, paramtype))

 
 

-            if parameter['value'] == "<rw_mgmt_ip>":
-                params[param] = str(values[parameter['value']])
-            else:
-                params[param] = value
+            params[param] = value

         return params
 
     def _get_config_from_yang(self, config_primitive, values):
         return params
 
     def _get_config_from_yang(self, config_primitive, values):


@@ -918,7 +1065,7 @@ class N2VC:
             elif not c.isalpha():
                 c = "-"
             appname += c
             elif not c.isalpha():
                 c = "-"
             appname += c

-        return re.sub('\-+', '-', appname.lower())
+        return re.sub('-+', '-', appname.lower())

 
     # def format_application_name(self, nsd_name, vnfr_name, member_vnf_index=0):
     #     """Format the name of the application
 
     # def format_application_name(self, nsd_name, vnfr_name, member_vnf_index=0):
     #     """Format the name of the application


@@ -971,9 +1118,13 @@ class N2VC:
             models = await self.controller.list_models()
 
             if model_name not in models:
             models = await self.controller.list_models()
 
             if model_name not in models:

-                self.models[model_name] = await self.controller.add_model(
-                    model_name
-                )
+                try:
+                    self.models[model_name] = await self.controller.add_model(
+                        model_name
+                    )
+                except JujuError as e:
+                    if "already exists" not in e.message:
+                        raise e

             else:
                 self.models[model_name] = await self.controller.get_model(
                     model_name
             else:
                 self.models[model_name] = await self.controller.get_model(
                     model_name


@@ -982,10 +1133,20 @@ class N2VC:
             self.refcount['model'] += 1
 
             # Create an observer for this model
             self.refcount['model'] += 1
 
             # Create an observer for this model

+            await self.create_model_monitor(model_name)
+
+        return self.models[model_name]
+
+    async def create_model_monitor(self, model_name):
+        """Create a monitor for the model, if none exists."""
+        if not self.authenticated:
+            await self.login()
+
+        if model_name not in self.monitors:

             self.monitors[model_name] = VCAMonitor(model_name)
             self.models[model_name].add_observer(self.monitors[model_name])
 
             self.monitors[model_name] = VCAMonitor(model_name)
             self.models[model_name].add_observer(self.monitors[model_name])
 

-        return self.models[model_name]
+        return True

 
     async def login(self):
         """Login to the Juju controller."""
 
     async def login(self):
         """Login to the Juju controller."""


@@ -997,7 +1158,6 @@ class N2VC:
 
         self.log.debug("JujuApi: Logging into controller")
 
 
         self.log.debug("JujuApi: Logging into controller")
 

-        cacert = None

         self.controller = Controller(loop=self.loop)
 
         if self.secret:
         self.controller = Controller(loop=self.loop)
 
         if self.secret:


@@ -1013,7 +1173,7 @@ class N2VC:
                 endpoint=self.endpoint,
                 username=self.user,
                 password=self.secret,
                 endpoint=self.endpoint,
                 username=self.user,
                 password=self.secret,

-                cacert=cacert,
+                cacert=self.ca_cert,

             )
             self.refcount['controller'] += 1
         else:
             )
             self.refcount['controller'] += 1
         else:


@@ -1033,7 +1193,7 @@ class N2VC:
     async def logout(self):
         """Logout of the Juju controller."""
         if not self.authenticated:
     async def logout(self):
         """Logout of the Juju controller."""
         if not self.authenticated:

-            return
+            return False

 
         try:
             for model in self.models:
 
         try:
             for model in self.models:


@@ -1056,15 +1216,11 @@ class N2VC:
                 "Fatal error logging out of Juju Controller: {}".format(e)
             )
             raise e
                 "Fatal error logging out of Juju Controller: {}".format(e)
             )
             raise e

+        return True

 
     async def disconnect_model(self, model):
         self.log.debug("Disconnecting model {}".format(model))
         if model in self.models:
 
     async def disconnect_model(self, model):
         self.log.debug("Disconnecting model {}".format(model))
         if model in self.models:

-            print(self.models[model].applications)
-            if len(self.models[model].applications) == 0:
-                print("Destroying empty model")
-                await self.controller.destroy_models(model)
-

             print("Disconnecting model")
             await self.models[model].disconnect()
             self.refcount['model'] -= 1
             print("Disconnecting model")
             await self.models[model].disconnect()
             self.refcount['model'] -= 1