Esempio n. 1
0
 def drv_deployable_make_diff(self, context, device_id, cpid_id,
                              old_driver_dep_list, new_driver_dep_list,
                              host_rp):
     """Compare new driver-side deployable object list with the old one in
     one host.
     """
     # use name to identify whether the deployable is the same.
     LOG.info("Start differing deploybles.")
     new_name_list = [
         driver_dep_obj.name for driver_dep_obj in new_driver_dep_list
     ]
     old_name_list = [
         driver_dep_obj.name for driver_dep_obj in old_driver_dep_list
     ]
     same = set(new_name_list) & set(old_name_list)
     added = set(new_name_list) - same
     deleted = set(old_name_list) - same
     # name is deleted.
     for d in deleted:
         old_driver_dep_obj = old_driver_dep_list[old_name_list.index(d)]
         rp_uuid = self.get_rp_uuid_from_obj(old_driver_dep_obj)
         old_driver_dep_obj.destroy(context, device_id)
         self._delete_provider_and_sub_providers(context, rp_uuid)
     # name is added.
     for a in added:
         new_driver_dep_obj = new_driver_dep_list[new_name_list.index(a)]
         new_driver_dep_obj.create(context, device_id, cpid_id)
         self.get_placement_needed_info_and_report(context,
                                                   new_driver_dep_obj,
                                                   host_rp)
     for s in same:
         # get the driver_dep_obj, diff the driver_dep layer
         new_driver_dep_obj = new_driver_dep_list[new_name_list.index(s)]
         old_driver_dep_obj = old_driver_dep_list[old_name_list.index(s)]
         # get dep_obj, it won't be None because it stored before.
         dep_obj = Deployable.get_by_name_deviceid(context, s, device_id)
         # update the driver_dep num_accelerators field
         if dep_obj.num_accelerators != new_driver_dep_obj.num_accelerators:
             dep_obj.num_accelerators = new_driver_dep_obj.num_accelerators
             dep_obj.save(context)
             rp_uuid = self.get_rp_uuid_from_obj(new_driver_dep_obj)
             attrs = new_driver_dep_obj.attribute_list
             resource_class = [i.value for i in attrs if i.key == 'rc'][0]
             inv_data = _gen_resource_inventory(resource_class,
                                                dep_obj.num_accelerators)
             self.placement_client.update_inventory(rp_uuid, inv_data)
         # diff the internal layer: driver_attribute_list
         new_attribute_list = []
         if hasattr(new_driver_dep_obj, 'attribute_list'):
             new_attribute_list = new_driver_dep_obj.attribute_list
         self.drv_attr_make_diff(context, dep_obj.id,
                                 old_driver_dep_obj.attribute_list,
                                 new_attribute_list)
         # diff the internal layer: driver_attach_hanle_list
         self.drv_ah_make_diff(context, dep_obj.id, cpid_id,
                               old_driver_dep_obj.attach_handle_list,
                               new_driver_dep_obj.attach_handle_list)
Esempio n. 2
0
    def _from_db_object(cls, obj, db_obj):
        """Converts a physical function to a formal object.

        :param obj: An object of the class.
        :param db_obj: A DB model of the object
        :return: The object of the class with the database entity added
        """
        obj = Deployable._from_db_object(obj, db_obj)
        if cls is PhysicalFunction:
            obj.virtual_function_list = []
        return obj
Esempio n. 3
0
 def get_by_name(cls, context, name):
     """Form driver-side Deployable object list from DB for one device."""
     # get deployable_obj_list for one device_id
     dep_obj = Deployable.get_by_name(context, name)
     driver_ah_obj_list = DriverAttachHandle.list(context, dep_obj.id)
     # get driver_attr_obj_list fro this dep_obj
     driver_attr_obj_list = DriverAttribute.list(context, dep_obj.id)
     driver_dep_obj = cls(context=context, name=dep_obj.name,
                          num_accelerators=dep_obj.num_accelerators,
                          attribute_list=driver_attr_obj_list,
                          attach_handle_list=driver_ah_obj_list)
     return driver_dep_obj
Esempio n. 4
0
    def create(self, context, device_id, cpid_id):
        """Create a driver-side Deployable object into DB. This object will be
        stored in seperate db tables: deployable & attach_handle &
        attribute table."""

        # first store in deployable table through Deployable Object.
        deployable_obj = Deployable(context=context,
                                    name=self.name,
                                    num_accelerators=self.num_accelerators,
                                    device_id=device_id)
        deployable_obj.create(context)
        # create attribute_list for this deployable
        if hasattr(self, 'attribute_list'):
            for driver_attr in self.attribute_list:
                driver_attr.create(context, deployable_obj.id)

        # create attach_handle_list for this deployable
        if hasattr(self, 'attach_handle_list'):
            for driver_attach_handle in self.attach_handle_list:
                driver_attach_handle.create(context, deployable_obj.id,
                                            cpid_id)
Esempio n. 5
0
 def drv_attr_make_diff(self, context, dep_id, old_driver_attr_list,
                        new_driver_attr_list):
     """Diff new driver-side Attribute Object lists with the old one."""
     LOG.info("Start differing attributes.")
     dep_obj = Deployable.get_by_id(context, dep_id)
     driver_dep = DriverDeployable.get_by_name(context, dep_obj.name)
     rp_uuid = self.get_rp_uuid_from_obj(driver_dep)
     new_key_list = [
         driver_attr_obj.key for driver_attr_obj in new_driver_attr_list
     ]
     old_key_list = [
         driver_attr_obj.key for driver_attr_obj in old_driver_attr_list
     ]
     same = set(new_key_list) & set(old_key_list)
     # key is deleted.
     deleted = set(old_key_list) - same
     for d in deleted:
         old_driver_attr_obj = old_driver_attr_list[old_key_list.index(d)]
         self.placement_client.delete_trait_by_name(
             context, rp_uuid, old_driver_attr_obj.value)
         old_driver_attr_obj.delete_by_key(context, dep_id, d)
     # key is added.
     added = set(new_key_list) - same
     for a in added:
         new_driver_attr_obj = new_driver_attr_list[new_key_list.index(a)]
         new_driver_attr_obj.create(context, dep_id)
         self.placement_client.add_traits_to_rp(rp_uuid,
                                                [new_driver_attr_obj.value])
     # key is same, diff the value.
     for s in same:
         # value is not same, update
         new_driver_attr_obj = new_driver_attr_list[new_key_list.index(s)]
         old_driver_attr_obj = old_driver_attr_list[old_key_list.index(s)]
         if new_driver_attr_obj.value != old_driver_attr_obj.value:
             attr_obj = Attribute.get_by_dep_key(context, dep_id, s)
             attr_obj.value = new_driver_attr_obj.value
             attr_obj.save(context)
             # Update traits here.
             if new_driver_attr_obj.key.startswith("trait"):
                 self.placement_client.delete_trait_by_name(
                     context, rp_uuid, old_driver_attr_obj.value)
                 self.placement_client.add_traits_to_rp(
                     rp_uuid, [new_driver_attr_obj.value])
             # Update resource classes here.
             if new_driver_attr_obj.key.startswith("rc"):
                 self.placement_client.ensure_resource_classes(
                     context, [new_driver_attr_obj.value])
                 inv_data = _gen_resource_inventory(
                     new_driver_attr_obj.value, dep_obj.num_accelerators)
                 self.placement_client.update_inventory(rp_uuid, inv_data)
                 self.placement_client.delete_rc_by_name(
                     context, old_driver_attr_obj.value)
Esempio n. 6
0
 def get_placement_needed_info_and_report(self, context, obj,
                                          parent_uuid=None):
     pr_name = obj.name
     attrs = obj.attribute_list
     resource_class = [i.value for i in attrs if i.key == 'rc'][0]
     traits = [i.value for i in attrs
               if six.ensure_str(i.key).startswith("trait")]
     total = obj.num_accelerators
     rp_uuid = self.provider_report(context, pr_name, resource_class,
                                    traits, total, parent_uuid)
     dep_obj = Deployable.get_by_name(context, pr_name)
     dep_obj["rp_uuid"] = rp_uuid
     dep_obj.save(context)
Esempio n. 7
0
 def drv_deployable_make_diff(cls, context, device_id, cpid_id,
                              old_driver_dep_list, new_driver_dep_list):
     """Compare new driver-side deployable object list with the old one in
     one host."""
     # use name to identify whether the deployable is the same.
     LOG.info("Start differing deploybles.")
     new_name_list = [
         driver_dep_obj.name for driver_dep_obj in new_driver_dep_list
     ]
     old_name_list = [
         driver_dep_obj.name for driver_dep_obj in old_driver_dep_list
     ]
     same = set(new_name_list) & set(old_name_list)
     added = set(new_name_list) - same
     deleted = set(old_name_list) - same
     for s in same:
         # get the driver_dep_obj, diff the driver_dep layer
         new_driver_dep_obj = new_driver_dep_list[new_name_list.index(s)]
         old_driver_dep_obj = old_driver_dep_list[old_name_list.index(s)]
         # get dep_obj, it won't be None because it stored before.
         dep_obj = Deployable.get_by_name_deviceid(context, s, device_id)
         # update the driver_dep num_accelerators field
         if dep_obj.num_accelerators != new_driver_dep_obj.num_accelerators:
             dep_obj.num_accelerators = new_driver_dep_obj.num_accelerators
             dep_obj.save(context)
         # diff the internal layer: driver_attribute_list
         new_attribute_list = []
         if hasattr(new_driver_dep_obj, 'attribute_list'):
             new_attribute_list = new_driver_dep_obj.attribute_list
         cls.drv_attr_make_diff(context, dep_obj.id,
                                old_driver_dep_obj.attribute_list,
                                new_attribute_list)
         # diff the internal layer: driver_attach_hanle_list
         cls.drv_ah_make_diff(context, dep_obj.id, cpid_id,
                              old_driver_dep_obj.attach_handle_list,
                              new_driver_dep_obj.attach_handle_list)
     # name is deleted.
     for d in deleted:
         old_driver_dep_obj = old_driver_dep_list[old_name_list.index(d)]
         old_driver_dep_obj.destroy(context, device_id)
     # name is added.
     for a in added:
         new_driver_dep_obj = new_driver_dep_list[new_name_list.index(a)]
         new_driver_dep_obj.create(context, device_id, cpid_id)
Esempio n. 8
0
    def destroy(self, context, device_id):
        """delete one driver-side deployable by calling existing Deployable
        and AttachHandle Object. Use name&host to identify Deployable and
        attach_info to identify the AttachHandle"""

        # get deployable_id by name, get only one value.
        dep_obj = Deployable.get_by_name_deviceid(context, self.name,
                                                  device_id)
        # delete attach_handle
        if hasattr(self, 'attach_handle_list'):
            for driver_ah_obj in self.attach_handle_list:
                # get attach_handle_obj, exist and only one.
                driver_ah_obj.destroy(context, dep_obj.id)
        # delete attribute_list
        if hasattr(self, 'attribute_list'):
            DriverAttribute.destroy(context, dep_obj.id)
        # delete dep_obj
        if dep_obj is not None:
            dep_obj.destroy(context)
Esempio n. 9
0
 def drv_deployable_make_diff(self, context, device_id, cpid_id,
                              old_driver_dep_list, new_driver_dep_list,
                              host_rp):
     """Compare new driver-side deployable object list with the old one in
     one host.
     """
     # use name to identify whether the deployable is the same.
     LOG.info("Start differing deploybles.")
     new_name_list = [
         driver_dep_obj.name for driver_dep_obj in new_driver_dep_list
     ]
     old_name_list = [
         driver_dep_obj.name for driver_dep_obj in old_driver_dep_list
     ]
     same = set(new_name_list) & set(old_name_list)
     added = set(new_name_list) - same
     deleted = set(old_name_list) - same
     # name is deleted.
     for d in deleted:
         old_driver_dep_obj = old_driver_dep_list[old_name_list.index(d)]
         rp_uuid = self.get_rp_uuid_from_obj(old_driver_dep_obj)
         old_driver_dep_obj.destroy(context, device_id)
         self._delete_provider_and_sub_providers(context, rp_uuid)
     # name is added.
     for a in added:
         new_driver_dep_obj = new_driver_dep_list[new_name_list.index(a)]
         new_driver_dep_obj.create(context, device_id, cpid_id)
         try:
             self.get_placement_needed_info_and_report(
                 context, new_driver_dep_obj, host_rp)
         except Exception as exc:
             LOG.info(
                 "Failed to add deployable %(deployable)s. "
                 "Reason: %(reason)s", {
                     'deployable': new_driver_dep_obj,
                     'reason': exc
                 })
             new_driver_dep_obj.destroy(context, device_id)
             rp_uuid = self.get_rp_uuid_from_obj(new_driver_dep_obj)
             # TODO(All): If report data to Placement raise exception, we
             # should revert driver deployable created in Cyborg and
             # rp created in Placement to reduce the risk of data
             # inconsistency here between Cyborg and Placement,
             # we will consider to fix in V release.
             self._delete_provider_and_sub_providers(context, rp_uuid)
     for s in same:
         # get the driver_dep_obj, diff the driver_dep layer
         new_driver_dep_obj = new_driver_dep_list[new_name_list.index(s)]
         old_driver_dep_obj = old_driver_dep_list[old_name_list.index(s)]
         # get dep_obj, it won't be None because it stored before.
         dep_obj = Deployable.get_by_name_deviceid(context, s, device_id)
         # update the driver_dep num_accelerators field
         if dep_obj.num_accelerators != new_driver_dep_obj.num_accelerators:
             dep_obj.num_accelerators = new_driver_dep_obj.num_accelerators
             dep_obj.save(context)
             rp_uuid = self.get_rp_uuid_from_obj(new_driver_dep_obj)
             attrs = new_driver_dep_obj.attribute_list
             resource_class = [i.value for i in attrs if i.key == 'rc'][0]
             inv_data = _gen_resource_inventory(resource_class,
                                                dep_obj.num_accelerators)
             self.placement_client.update_inventory(rp_uuid, inv_data)
         # diff the internal layer: driver_attribute_list
         new_attribute_list = []
         if hasattr(new_driver_dep_obj, 'attribute_list'):
             new_attribute_list = new_driver_dep_obj.attribute_list
         self.drv_attr_make_diff(context, dep_obj.id,
                                 old_driver_dep_obj.attribute_list,
                                 new_attribute_list)
         # diff the internal layer: driver_attach_hanle_list
         self.drv_ah_make_diff(context, dep_obj.id, cpid_id,
                               old_driver_dep_obj.attach_handle_list,
                               new_driver_dep_obj.attach_handle_list)