Python db.compute_node_get函数代码示例

 def test_get_by_id(self):
     self.mox.StubOutWithMock(db, 'compute_node_get')
     db.compute_node_get(self.context, 123).AndReturn(fake_compute_node)
     self.mox.ReplayAll()
     compute = compute_node.ComputeNode.get_by_id(self.context, 123)
     self.compare_obj(compute, fake_compute_node,
                      comparators={'stats': self.json_comparator})

 def test_get_by_id(self):
     ctxt = context.get_admin_context()
     self.mox.StubOutWithMock(db, 'compute_node_get')
     db.compute_node_get(ctxt, 123).AndReturn(fake_compute_node)
     self.mox.ReplayAll()
     compute = compute_node.ComputeNode.get_by_id(ctxt, 123)
     self._compare(compute, fake_compute_node)

    def create(self):
        if self.obj_attr_is_set('id'):
            raise exception.ObjectActionError(action='create',
                                              reason='already created')
        updates = self.obj_get_changes()
        if 'uuid' not in updates:
            updates['uuid'] = uuidutils.generate_uuid()
            self.uuid = updates['uuid']

        self._convert_stats_to_db_format(updates)
        self._convert_host_ip_to_db_format(updates)
        self._convert_supported_instances_to_db_format(updates)
        self._convert_pci_stats_to_db_format(updates)

        if self._should_manage_inventory():
            self._create_inventory(updates)

        db_compute = db.compute_node_create(self._context, updates)
        # NOTE(danms): compute_node_create() operates on (and returns) the
        # compute node model only. We need to get the full inventory-based
        # result in order to satisfy _from_db_object(). So, we do a double
        # query here. This can be removed in Newton once we're sure that all
        # compute nodes are inventory-based
        db_compute = db.compute_node_get(self._context, db_compute['id'])
        self._from_db_object(self._context, self, db_compute)

 def show(self, req, id):
     context = req.environ['nova.context']
     authorize(context)
     try:
         hyp = db.compute_node_get(context, int(id))
     except (ValueError, exception.ComputeHostNotFound):
         msg = _("Hypervisor with ID '%s' could not be found.") % id
         raise webob.exc.HTTPNotFound(explanation=msg)
     return dict(hypervisor=self._view_hypervisor(hyp, True))

 def show(self, req, resp_obj, id):
     context = req.environ['nova.context']
     resp_obj.attach(xml=PciHypervisorTemplate())
     hypervisor = resp_obj.obj['hypervisor']
     # TODO(yjiang5): Change to compute node object after that change merged
     #compute_node = compute_obj.ComputeNode.get_by_id(
     #    context, hypervisor['id'])
     compute_node = db.compute_node_get(context, hypervisor['id'])
     self._extend_hypervisor(hypervisor, compute_node)

 def detail(self, req, resp_obj):
     context = req.environ['nova.context']
     hypervisors = list(resp_obj.obj['hypervisors'])
     for hypervisor in hypervisors:
         # TODO(yjiang5): Change to compute node object after
         # that changes merged
         # compute_node = compute_obj.ComputeNode.get_by_id(
         #    context, hypervisor['id'])
         compute_node = db.compute_node_get(context, hypervisor['id'])
         hypervisor['os-pci:pci_stats'] = compute_node['pci_stats']

    def uptime(self, req, id):
        context = req.environ['nova.context']
        authorize(context)
        try:
            hyp = db.compute_node_get(context, int(id))
        except (ValueError, exception.ComputeHostNotFound):
            msg = _("Hypervisor with ID '%s' could not be found.") % id
            raise webob.exc.HTTPNotFound(explanation=msg)

        # Get the uptime
        try:
            uptime = self.api.get_host_uptime(context, hyp)
        except NotImplementedError:
            msg = _("Virt driver does not implement uptime function.")
            raise webob.exc.HTTPNotImplemented(explanation=msg)

        return dict(hypervisor=self._view_hypervisor(hyp, False,
                                                     uptime=uptime))

    def save(self, prune_stats=False):
        # NOTE(belliott) ignore prune_stats param, no longer relevant

        updates = self.obj_get_changes()
        updates.pop('id', None)
        self._convert_stats_to_db_format(updates)
        self._convert_host_ip_to_db_format(updates)
        self._convert_supported_instances_to_db_format(updates)
        self._convert_pci_stats_to_db_format(updates)

        db_compute = db.compute_node_update(self._context, self.id, updates)
        # NOTE(danms): compute_node_update() operates on (and returns) the
        # compute node model only. We need to get the full inventory-based
        # result in order to satisfy _from_db_object(). So, we do a double
        # query here. This can be removed in Newton once we're sure that all
        # compute nodes are inventory-based
        db_compute = db.compute_node_get(self._context, self.id)
        self._from_db_object(self._context, self, db_compute)

 def get_by_id(cls, context, compute_id):
     db_compute = db.compute_node_get(context, compute_id)
     return cls._from_db_object(context, cls(), db_compute)