Return DTS error instead of exception for failures 14/1714/1
authorPhilip Joseph <philip.joseph@riftio.com>
Thu, 27 Apr 2017 09:50:05 +0000 (15:20 +0530)
committerPhilip Joseph <philip.joseph@riftio.com>
Thu, 27 Apr 2017 10:53:49 +0000 (16:23 +0530)
Change-Id: I4e025b469a119650aa925c5193981143e07c1033
Signed-off-by: Philip Joseph <philip.joseph@riftio.com>
rwlaunchpad/plugins/rwnsm/rift/tasklets/rwnsmtasklet/rwnsmtasklet.py

index 85b31a5..7572fe9 100755 (executable)
@@ -35,7 +35,7 @@ from enum import Enum
 
 import gi
 gi.require_version('RwYang', '1.0')
-gi.require_version('RwNsdYang', '1.0')
+gi.require_version('NsdYang', '1.0')
 gi.require_version('RwDts', '1.0')
 gi.require_version('RwNsmYang', '1.0')
 gi.require_version('RwNsrYang', '1.0')
@@ -2822,9 +2822,14 @@ class NsdDtsHandler(object):
                 # Delete an NSD record
                 self._log.debug("Deleting NSD with id %s", msg.id)
                 if self._nsm.nsd_in_use(msg.id):
-                    self._log.debug("Cannot delete NSD in use - %s", msg.id)
-                    err = "Cannot delete an NSD in use - %s" % msg.id
-                    raise NetworkServiceDescriptorRefCountExists(err)
+                    errmsg = "Cannot delete an NSD in use - %s" % msg.id
+                    self._log.error(errmsg)
+                    xpath = ks_path.to_xpath(NsdYang.get_schema())
+                    xact_info.send_error_xpath(RwTypes.RwStatus.FAILURE,
+                                               xpath,
+                                               errmsg)
+                    xact_info.respond_xpath(rwdts.XactRspCode.NACK)
+                    return
 
                 yield from delete_nsd_libs(msg.id)
                 self._nsm.delete_nsd(msg.id)
@@ -3010,9 +3015,18 @@ class NsrRpcDtsHandler(object):
                     "nsr_id":str(uuid.uuid4())
                 })
 
-            if not ('name' in rpc_ip and  'nsd_ref' in rpc_ip and ('cloud_account' in rpc_ip or 'om_datacenter' in rpc_ip)):
-                self._log.error("Mandatory parameters name or nsd_ref or cloud account not found in start-network-service {}".format(rpc_ip))
-
+            if not ('name' in rpc_ip and  'nsd_ref' in rpc_ip and
+                    ('cloud_account' in rpc_ip or 'om_datacenter' in rpc_ip)):
+                errmsg = (
+                    "Mandatory parameters name or nsd_ref or cloud account not found in start-network-service {}".
+                    format(rpc_ip))
+                self._log.error(errmsg)
+                xact_info.send_error_xpath(RwTypes.RwStatus.FAILURE,
+                                           NsrRpcDtsHandler.EXEC_NSR_CONF_O_XPATH,
+                                           errmsg)
+                xact_info.respond_xpath(rwdts.XactRspCode.NACK,
+                                        NsrRpcDtsHandler.EXEC_NSR_CONF_O_XPATH)
+                return
 
             self._log.debug("start-network-service RPC input: {}".format(rpc_ip))
 
@@ -3022,9 +3036,6 @@ class NsrRpcDtsHandler(object):
 
                 nsd_copy = self.nsm.get_nsd(rpc_ip.nsd_ref)
 
-                #if not self._manager:
-                #    self._manager = yield from self._connect()
-
                 self._log.debug("Configuring ns-instance-config with name  %s nsd-ref: %s",
                         rpc_ip.name, rpc_ip.nsd_ref)
 
@@ -3038,18 +3049,10 @@ class NsrRpcDtsHandler(object):
                 ns_instance_config.nsd.from_dict(nsd_copy.msg.as_dict())
 
                 payload_dict = ns_instance_config.to_json(self._model)
-                #xml = ns_instance_config.to_xml_v2(self._model)
-                #netconf_xml = self.wrap_netconf_config_xml(xml)
 
-                #self._log.debug("Sending configure ns-instance-config xml to %s: %s",
-                #        netconf_xml, NsrRpcDtsHandler.NETCONF_IP_ADDRESS)
                 self._log.debug("Sending configure ns-instance-config json to %s: %s",
                         self._nsr_config_url,ns_instance_config)
 
-                #response = yield from self._manager.edit_config(
-                #           target="running",
-                #           config=netconf_xml,
-                #           )
                 response = yield from self._loop.run_in_executor(
                     None,
                     self._apply_ns_instance_config,
@@ -3062,13 +3065,15 @@ class NsrRpcDtsHandler(object):
                                         NsrRpcDtsHandler.EXEC_NSR_CONF_O_XPATH,
                                         rpc_op)
             except Exception as e:
-                self._log.error("Exception processing the "
-                                "start-network-service: {}".format(e))
-                self._log.exception(e)
+                errmsg = ("Exception processing the "
+                          "start-network-service: {}".format(e))
+                self._log.exception(errmsg)
+                xact_info.send_error_xpath(RwTypes.RwStatus.FAILURE,
+                                           NsrRpcDtsHandler.EXEC_NSR_CONF_O_XPATH,
+                                           errmsg)
                 xact_info.respond_xpath(rwdts.XactRspCode.NACK,
                                         NsrRpcDtsHandler.EXEC_NSR_CONF_O_XPATH)
 
-
         hdl_ns = rift.tasklets.DTS.RegistrationHandler(on_prepare=on_ns_config_prepare,)
 
         with self._dts.group_create() as group:
@@ -3361,43 +3366,76 @@ class NsrDtsHandler(object):
             fref = ProtobufC.FieldReference.alloc()
             fref.goto_whole_message(msg.to_pbcm())
 
+            def send_err_msg(err_msg):
+                self._log.error(errmsg)
+                xact_info.send_error_xpath(RwTypes.RwStatus.FAILURE,
+                                           xpath,
+                                           errmsg)
+                xact_info.respond_xpath(rwdts.XactRspCode.NACK)
+
+
             if action in [rwdts.QueryAction.CREATE, rwdts.QueryAction.UPDATE, rwdts.QueryAction.DELETE]:
                 # if this is an NSR create
                 if action != rwdts.QueryAction.DELETE and msg.id not in self._nsm.nsrs:
                     # Ensure the Cloud account/datacenter has been specified
                     if not msg.has_field("cloud_account") and not msg.has_field("om_datacenter"):
-                        raise NsrInstantiationFailed("Cloud account or datacenter not specified in NSR")
+                        errmsg = ("Cloud account or datacenter not specified in NS {}".
+                                  format(msg.name))
+                        send_err_msg(errmsg)
+                        return
 
                     # Check if nsd is specified
                     if not msg.has_field("nsd"):
-                        raise NsrInstantiationFailed("NSD not specified in NSR")
+                        errmsg = ("NSD not specified in NS {}".
+                                  format(msg.name))
+                        send_err_msg(errmsg)
+                        return
 
                 else:
                     nsr = self._nsm.nsrs[msg.id]
 
                     if msg.has_field("nsd"):
                         if nsr.state != NetworkServiceRecordState.RUNNING:
-                            raise NsrVlUpdateError("Unable to update VL when NSR not in running state")
+                            errmsg = ("Unable to update VL when NS {} not in running state".
+                                      format(msg.name))
+                            send_err_msg(errmsg)
+                            return
+
                         if 'vld' not in msg.nsd or len(msg.nsd.vld) == 0:
-                            raise NsrVlUpdateError("NS config NSD should have atleast 1 VLD defined")
+                            errmsg = ("NS config {} NSD should have atleast 1 VLD".
+                                      format(msg.name))
+                            send_err_msg(errmsg)
+                            return
 
                     if msg.has_field("scaling_group"):
                         if nsr.state != NetworkServiceRecordState.RUNNING:
-                            raise ScalingOperationError("Unable to perform scaling action when NS is not in running state")
+                            errmsg = ("Unable to perform scaling action when NS {} not in running state".
+                                      format(msg.name))
+                            send_err_msg(errmsg)
+                            return
 
                         if len(msg.scaling_group) > 1:
-                            raise ScalingOperationError("Only a single scaling group can be configured at a time")
+                            errmsg = ("Only a single scaling group can be configured at a time for NS {}".
+                                      format(msg.name))
+                            send_err_msg(errmsg)
+                            return
 
                         for group_msg in msg.scaling_group:
                             num_new_group_instances = len(group_msg.instance)
                             if num_new_group_instances > 1:
-                                raise ScalingOperationError("Only a single scaling instance can be modified at a time")
+                                errmsg = ("Only a single scaling instance can be modified at a time for NS {}".
+                                          format(msg.name))
+                                send_err_msg(errmsg)
+                                return
 
                             elif num_new_group_instances == 1:
                                 scale_group = nsr.scaling_groups[group_msg.scaling_group_name_ref]
                                 if action in [rwdts.QueryAction.CREATE, rwdts.QueryAction.UPDATE]:
                                     if len(scale_group.instances) == scale_group.max_instance_count:
-                                        raise ScalingOperationError("Max instances for %s reached" % scale_group)
+                                        errmsg = (" Max instances for {} reached for NS {}".
+                                                  format(str(scale_group), msg.name))
+                                        send_err_msg(errmsg)
+                                        return
 
             acg.handle.prepare_complete_ok(xact_info.handle)