def _create_compute_service(self, **kwargs): """Create a compute service.""" dic = {"binary": "nova-compute", "topic": "compute", "report_count": 0, "availability_zone": "dummyzone"} dic["host"] = kwargs.get("host", "dummy") s_ref = db.service_create(self.context, dic) if "created_at" in kwargs.keys() or "updated_at" in kwargs.keys(): t = utils.utcnow() - datetime.timedelta(0) dic["created_at"] = kwargs.get("created_at", t) dic["updated_at"] = kwargs.get("updated_at", t) db.service_update(self.context, s_ref["id"], dic) dic = { "service_id": s_ref["id"], "vcpus": 16, "memory_mb": 32, "local_gb": 100, "vcpus_used": 16, "local_gb_used": 10, "hypervisor_type": "qemu", "hypervisor_version": 12003, "cpu_info": "", } dic["memory_mb_used"] = kwargs.get("memory_mb_used", 32) dic["hypervisor_type"] = kwargs.get("hypervisor_type", "qemu") dic["hypervisor_version"] = kwargs.get("hypervisor_version", 12003) db.compute_node_create(self.context, dic) return db.service_get(self.context, s_ref["id"])
def test_create(self, mock_get): self.mox.StubOutWithMock(db, 'compute_node_create') db.compute_node_create( self.context, { 'service_id': 456, 'stats': fake_stats_db_format, 'host_ip': fake_host_ip, 'supported_instances': fake_supported_hv_specs_db_format, 'uuid': uuidsentinel.fake_compute_node, }).AndReturn(fake_compute_node) self.mox.ReplayAll() compute = compute_node.ComputeNode(context=self.context) compute.service_id = 456 compute.uuid = uuidsentinel.fake_compute_node compute.stats = fake_stats # NOTE (pmurray): host_ip is coerced to an IPAddress compute.host_ip = fake_host_ip compute.supported_hv_specs = fake_supported_hv_specs with mock.patch('oslo_utils.uuidutils.generate_uuid') as mock_gu: compute.create() self.assertFalse(mock_gu.called) self.compare_obj(compute, fake_compute_node, subs=self.subs(), comparators=self.comparators())
def update_available_resource(self, ctxt, host): """Updates compute manager resource info on ComputeNode table. This method is called when nova-coompute launches, and whenever admin executes "nova-manage service update_resource". :param ctxt: security context :param host: hostname that compute manager is currently running """ dic = self._max_phy_resouces(ctxt) #dic = self._sum_phy_hosts(ctxt) dic['hypervisor_type'] = 'physical' dic['hypervisor_version'] = 1 dic['cpu_info'] = 'physical cpu' try: service_ref = db.service_get_all_compute_by_host(ctxt, host)[0] except exception.NotFound: raise exception.ComputeServiceUnavailable(host=host) dic['service_id'] = service_ref['id'] compute_node_ref = service_ref['compute_node'] if not compute_node_ref: LOG.info(_('Compute_service record created for %s ') % host) db.compute_node_create(ctxt, dic) else: LOG.info(_('Compute_service record updated for %s ') % host) db.compute_node_update(ctxt, compute_node_ref[0]['id'], dic)
def _create_compute_service(self): """Create compute-manager(ComputeNode and Service record).""" ctxt = context.get_admin_context() dic = { "host": "dummy", "binary": "nova-compute", "topic": "compute", "report_count": 0, "availability_zone": "dummyzone", } s_ref = db.service_create(ctxt, dic) dic = { "service_id": s_ref["id"], "vcpus": 16, "memory_mb": 32, "local_gb": 100, "vcpus_used": 16, "memory_mb_used": 32, "local_gb_used": 10, "hypervisor_type": "qemu", "hypervisor_version": 12003, "cpu_info": "", } db.compute_node_create(ctxt, dic) return db.service_get(ctxt, s_ref["id"])
def update_available_resource(self, ctxt, host): """Updates compute manager resource info on ComputeNode table. This method is called when nova-coompute launches, and whenever admin executes "nova-manage service update_resource". :param ctxt: security context :param host: hostname that compute manager is currently running """ dic = self._max_baremetal_resources(ctxt) #dic = self._sum_baremetal_resources(ctxt) dic['hypervisor_type'] = self.get_hypervisor_type() dic['hypervisor_version'] = self.get_hypervisor_version() dic['cpu_info'] = 'baremetal cpu' try: service_ref = db.service_get_all_compute_by_host(ctxt, host)[0] except exception.NotFound: raise exception.ComputeServiceUnavailable(host=host) dic['service_id'] = service_ref['id'] compute_node_ref = service_ref['compute_node'] if not compute_node_ref: LOG.info(_('Compute_service record created for %s ') % host) db.compute_node_create(ctxt, dic) else: LOG.info(_('Compute_service record updated for %s ') % host) db.compute_node_update(ctxt, compute_node_ref[0]['id'], dic)
def update_available_resource(self, ctxt, host): """Updates compute manager resource info on ComputeNode table. Since we don't have a real hypervisor, pretend we have lots of disk and ram. """ try: service_ref = db.service_get_all_compute_by_host(ctxt, host)[0] except exception.NotFound: raise exception.ComputeServiceUnavailable(host=host) # Updating host information dic = {'vcpus': 1, 'memory_mb': 4096, 'local_gb': 1028, 'vcpus_used': 0, 'memory_mb_used': 0, 'local_gb_used': 0, 'hypervisor_type': 'fake', 'hypervisor_version': '1.0', 'service_id': service_ref['id'], 'cpu_info': '?'} compute_node_ref = service_ref['compute_node'] if not compute_node_ref: LOG.info(_('Compute_service record created for %s ') % host) db.compute_node_create(ctxt, dic) else: LOG.info(_('Compute_service record updated for %s ') % host) db.compute_node_update(ctxt, compute_node_ref[0]['id'], dic)
def update_available_resource(self, ctxt, host): """Updates compute manager resource info on ComputeNode table. Since we don't have a real hypervisor, pretend we have lots of disk and ram. """ try: service_ref = db.service_get_all_compute_by_host(ctxt, host)[0] except exception.NotFound: raise exception.ComputeServiceUnavailable(host=host) # Updating host information dic = { "vcpus": 1, "memory_mb": 4096, "local_gb": 1028, "vcpus_used": 0, "memory_mb_used": 0, "local_gb_used": 0, "hypervisor_type": "fake", "hypervisor_version": "1.0", "service_id": service_ref["id"], "cpu_info": "?", } compute_node_ref = service_ref["compute_node"] if not compute_node_ref: LOG.info(_("Compute_service record created for %s ") % host) db.compute_node_create(ctxt, dic) else: LOG.info(_("Compute_service record updated for %s ") % host) db.compute_node_update(ctxt, compute_node_ref[0]["id"], dic)
def _create_compute_service(self): """Create compute-manager(ComputeNode and Service record).""" ctxt = self.req.environ["nova.context"] dic = { 'host': 'dummy', 'binary': 'nova-compute', 'topic': 'compute', 'report_count': 0 } s_ref = db.service_create(ctxt, dic) dic = { 'service_id': s_ref['id'], 'vcpus': 16, 'memory_mb': 32, 'local_gb': 100, 'vcpus_used': 16, 'memory_mb_used': 32, 'local_gb_used': 10, 'hypervisor_type': 'qemu', 'hypervisor_version': 12003, 'cpu_info': '', 'stats': {} } db.compute_node_create(ctxt, dic) return db.service_get(ctxt, s_ref['id'])
def _create_compute_service(self, **kwargs): """Create a compute service.""" dic = { 'binary': 'nova-compute', 'topic': 'compute', 'report_count': 0, 'availability_zone': 'dummyzone' } dic['host'] = kwargs.get('host', 'dummy') s_ref = db.service_create(self.context, dic) if 'created_at' in kwargs.keys() or 'updated_at' in kwargs.keys(): t = utils.utcnow() - datetime.timedelta(0) dic['created_at'] = kwargs.get('created_at', t) dic['updated_at'] = kwargs.get('updated_at', t) db.service_update(self.context, s_ref['id'], dic) dic = { 'service_id': s_ref['id'], 'vcpus': 16, 'memory_mb': 32, 'local_gb': 100, 'vcpus_used': 16, 'local_gb_used': 10, 'hypervisor_type': 'qemu', 'hypervisor_version': 12003, 'cpu_info': '' } dic['memory_mb_used'] = kwargs.get('memory_mb_used', 32) dic['hypervisor_type'] = kwargs.get('hypervisor_type', 'qemu') dic['hypervisor_version'] = kwargs.get('hypervisor_version', 12003) db.compute_node_create(self.context, dic) return db.service_get(self.context, s_ref['id'])
def _create_compute_service(self): """Create compute-manager(ComputeNode and Service record).""" ctxt = context.get_admin_context() dic = { 'host': 'dummy', 'binary': 'nova-compute', 'topic': 'compute', 'report_count': 0, 'availability_zone': 'dummyzone' } s_ref = db.service_create(ctxt, dic) dic = { 'service_id': s_ref['id'], 'vcpus': 16, 'memory_mb': 32, 'local_gb': 100, 'vcpus_used': 16, 'memory_mb_used': 32, 'local_gb_used': 10, 'hypervisor_type': 'qemu', 'hypervisor_version': 12003, 'cpu_info': '' } db.compute_node_create(ctxt, dic) return db.service_get(ctxt, s_ref['id'])
def update_available_resource(self, ctxt, host): """Updates compute manager resource info on ComputeNode table. Since we don't have a real hypervisor, pretend we have lots of disk and ram. """ try: service_ref = db.service_get_all_compute_by_host(ctxt, host)[0] except exception.NotFound: raise exception.ComputeServiceUnavailable(host=host) # Updating host information dic = { 'vcpus': 1, 'memory_mb': 4096, 'local_gb': 1028, 'vcpus_used': 0, 'memory_mb_used': 0, 'local_gb_used': 0, 'hypervisor_type': 'fake', 'hypervisor_version': '1.0', 'service_id': service_ref['id'], 'cpu_info': '?' } compute_node_ref = service_ref['compute_node'] if not compute_node_ref: LOG.info(_('Compute_service record created for %s ') % host) db.compute_node_create(ctxt, dic) else: LOG.info(_('Compute_service record updated for %s ') % host) db.compute_node_update(ctxt, compute_node_ref[0]['id'], dic)
def test_compute_node_create(self): self.mox.StubOutWithMock(db, 'compute_node_create') db.compute_node_create(self.context, 'fake-values').AndReturn( 'fake-result') self.mox.ReplayAll() result = self.conductor.compute_node_create(self.context, 'fake-values') self.assertEqual(result, 'fake-result')
def test_compute_node_create(self): self.mox.StubOutWithMock(db, 'compute_node_create') db.compute_node_create(self.context, 'fake-values').AndReturn('fake-result') self.mox.ReplayAll() result = self.conductor.compute_node_create(self.context, 'fake-values') self.assertEqual(result, 'fake-result')
def test_recreate_fails(self): self.mox.StubOutWithMock(db, "compute_node_create") db.compute_node_create(self.context, {"service_id": 456}).AndReturn(fake_compute_node) self.mox.ReplayAll() compute = compute_node.ComputeNode(context=self.context) compute.service_id = 456 compute.create() self.assertRaises(exception.ObjectActionError, compute.create, self.context)
def test_recreate_fails(self): self.mox.StubOutWithMock(db, 'compute_node_create') db.compute_node_create(self.context, {'service_id': 456}).AndReturn( fake_compute_node) self.mox.ReplayAll() compute = compute_node.ComputeNode(context=self.context) compute.service_id = 456 compute.create() self.assertRaises(exception.ObjectActionError, compute.create)
def test_create(self): self.mox.StubOutWithMock(db, 'compute_node_create') db.compute_node_create(self.context, {'service_id': 456}).AndReturn( fake_compute_node) self.mox.ReplayAll() compute = compute_node.ComputeNode() compute.service_id = 456 compute.create(self.context) self.compare_obj(compute, fake_compute_node)
def test_create(self): self.mox.StubOutWithMock(db, 'compute_node_create') db.compute_node_create(self.context, {'service_id': 456}).AndReturn( fake_compute_node) self.mox.ReplayAll() compute = compute_node.ComputeNode() compute.service_id = 456 compute.create(self.context) self._compare(compute, fake_compute_node)
def test_recreate_fails(self, mock_get): self.mox.StubOutWithMock(db, 'compute_node_create') db.compute_node_create( self.context, {'service_id': 456, 'uuid': uuidsentinel.fake_compute_node}).AndReturn( fake_compute_node) self.mox.ReplayAll() compute = compute_node.ComputeNode(context=self.context) compute.service_id = 456 compute.uuid = uuidsentinel.fake_compute_node compute.create() self.assertRaises(exception.ObjectActionError, compute.create)
def test_query_allocates_uuid(self): fake = dict(fake_compute_node) fake.pop('uuid') db.compute_node_create(self.context, fake) with mock.patch('oslo_utils.uuidutils.generate_uuid') as mock_gu: mock_gu.return_value = uuidsentinel.fake_compute_node obj = objects.ComputeNode.get_by_id(self.context, fake['id']) mock_gu.assert_called_once_with() self.assertEqual(uuidsentinel.fake_compute_node, obj.uuid) self.assertNotIn('uuid', obj.obj_get_changes()) with mock.patch('oslo_utils.uuidutils.generate_uuid') as mock_gu: obj = objects.ComputeNode.get_by_id(self.context, fake['id']) self.assertEqual(uuidsentinel.fake_compute_node, obj.uuid) self.assertFalse(mock_gu.called)
def test_create(self): self.mox.StubOutWithMock(db, 'compute_node_create') db.compute_node_create(self.context, { 'service_id': 456, 'stats': fake_stats_db_format }).AndReturn(fake_compute_node) self.mox.ReplayAll() compute = compute_node.ComputeNode() compute.service_id = 456 compute.stats = fake_stats compute.create(self.context) self.compare_obj(compute, fake_compute_node, comparators={'stats': self.json_comparator})
def test_create(self): self.mox.StubOutWithMock(db, 'compute_node_create') db.compute_node_create( self.context, { 'service_id': 456, 'stats': fake_stats_db_format }).AndReturn(fake_compute_node) self.mox.ReplayAll() compute = compute_node.ComputeNode() compute.service_id = 456 compute.stats = fake_stats compute.create(self.context) self.compare_obj(compute, fake_compute_node, comparators={'stats': self.json_comparator})
def _create_compute_service(self): """Create compute-manager(ComputeNode and Service record).""" ctxt = context.get_admin_context() dic = {'host': 'dummy', 'binary': 'nova-compute', 'topic': 'compute', 'report_count': 0, 'availability_zone': 'dummyzone'} s_ref = db.service_create(ctxt, dic) dic = {'service_id': s_ref['id'], 'vcpus': 16, 'memory_mb': 32, 'local_gb': 100, 'vcpus_used': 16, 'memory_mb_used': 32, 'local_gb_used': 10, 'hypervisor_type': 'qemu', 'hypervisor_version': 12003, 'cpu_info': '', 'stats': {}} db.compute_node_create(ctxt, dic) return db.service_get(ctxt, s_ref['id'])
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 setUp(self): map(lambda x: x.delete(), Query(models.Service).all()) map(lambda x: x.delete(), Query(models.ComputeNode).all()) super(ComputeNodeTestCase, self).setUp() self.ctxt = context.get_admin_context() self.service_dict = dict(host='host1', binary='nova-compute', topic=CONF.compute_topic, report_count=1, disabled=False) self.service = db.service_create(self.ctxt, self.service_dict) self.compute_node_dict = dict(vcpus=2, memory_mb=1024, local_gb=2048, vcpus_used=0, memory_mb_used=0, local_gb_used=0, free_ram_mb=1024, free_disk_gb=2048, hypervisor_type="xen", hypervisor_version=1, cpu_info="", running_vms=0, current_workload=0, service_id=self.service['id'], disk_available_least=100, hypervisor_hostname='abracadabra104', host_ip='127.0.0.1', supported_instances='', pci_stats='', metrics='', extra_resources='', stats='', numa_topology='') # add some random stats self.stats = dict(num_instances=3, num_proj_12345=2, num_proj_23456=2, num_vm_building=3) self.compute_node_dict['stats'] = jsonutils.dumps(self.stats) # self.flags(reserved_host_memory_mb=0) # self.flags(reserved_host_disk_mb=0) self.item = db.compute_node_create(self.ctxt, self.compute_node_dict)
def _create_compute_service(self): """Create compute-manager(ComputeNode and Service record).""" ctxt = self.req.environ["nova.context"] dic = {'host': 'dummy', 'binary': 'nova-compute', 'topic': 'compute', 'report_count': 0} s_ref = db.service_create(ctxt, dic) dic = {'service_id': s_ref['id'], 'host': s_ref['host'], 'uuid': uuidsentinel.compute_node, 'vcpus': 16, 'memory_mb': 32, 'local_gb': 100, 'vcpus_used': 16, 'memory_mb_used': 32, 'local_gb_used': 10, 'hypervisor_type': 'qemu', 'hypervisor_version': 12003, 'cpu_info': '', 'stats': ''} db.compute_node_create(ctxt, dic) return db.service_get(ctxt, s_ref['id'])
def create(self, context): if self.obj_attr_is_set('id'): raise exception.ObjectActionError(action='create', reason='already created') updates = self.obj_get_changes() updates.pop('id', None) db_compute = db.compute_node_create(context, updates) self._from_db_object(context, self, db_compute)
def update_available_resource(self, ctxt, host): """Updates compute manager resource info on ComputeNode table. This method is called when nova-coompute launches, and whenever admin executes "nova-manage service update_resource". :param ctxt: security context :param host: hostname that compute manager is currently running """ try: service_ref = db.service_get_all_compute_by_host(ctxt, host)[0] except exception.NotFound: raise exception.ComputeServiceUnavailable(host=host) # Updating host information dic = { "vcpus": self.get_vcpu_total(), "memory_mb": self.get_memory_mb_total(), "local_gb": self.get_local_gb_total(), "vcpus_used": self.get_vcpu_used(), "memory_mb_used": self.get_memory_mb_used(), "local_gb_used": self.get_local_gb_used(), "hypervisor_type": self.get_hypervisor_type(), "hypervisor_version": self.get_hypervisor_version(), "cpu_info": self.get_cpu_info(), "cpu_arch": FLAGS.cpu_arch, "xpu_arch": FLAGS.xpu_arch, "xpus": FLAGS.xpus, "xpu_info": FLAGS.xpu_info, "net_arch": FLAGS.net_arch, "net_info": FLAGS.net_info, "net_mbps": FLAGS.net_mbps, "service_id": service_ref["id"], } compute_node_ref = service_ref["compute_node"] LOG.info(_("#### RLK: cpu_arch = %s ") % FLAGS.cpu_arch) if not compute_node_ref: LOG.info(_("Compute_service record created for %s ") % host) dic["service_id"] = service_ref["id"] db.compute_node_create(ctxt, dic) else: LOG.info(_("Compute_service record updated for %s ") % host) db.compute_node_update(ctxt, compute_node_ref[0]["id"], dic)
def update_available_resource(self, ctxt, host): """Updates compute manager resource info on ComputeNode table. This method is called when nova-coompute launches, and whenever admin executes "nova-manage service update_resource". :param ctxt: security context :param host: hostname that compute manager is currently running """ try: service_ref = db.service_get_all_compute_by_host(ctxt, host)[0] except exception.NotFound: raise exception.ComputeServiceUnavailable(host=host) # Updating host information dic = { 'vcpus': self.get_vcpu_total(), 'memory_mb': self.get_memory_mb_total(), 'local_gb': self.get_local_gb_total(), 'vcpus_used': self.get_vcpu_used(), 'memory_mb_used': self.get_memory_mb_used(), 'local_gb_used': self.get_local_gb_used(), 'hypervisor_type': self.get_hypervisor_type(), 'hypervisor_version': self.get_hypervisor_version(), 'cpu_info': self.get_cpu_info(), 'cpu_arch': FLAGS.cpu_arch, 'xpu_arch': FLAGS.xpu_arch, 'xpus': FLAGS.xpus, 'xpu_info': FLAGS.xpu_info, 'net_arch': FLAGS.net_arch, 'net_info': FLAGS.net_info, 'net_mbps': FLAGS.net_mbps, 'service_id': service_ref['id'] } compute_node_ref = service_ref['compute_node'] LOG.info(_('#### RLK: cpu_arch = %s ') % FLAGS.cpu_arch) if not compute_node_ref: LOG.info(_('Compute_service record created for %s ') % host) dic['service_id'] = service_ref['id'] db.compute_node_create(ctxt, dic) else: LOG.info(_('Compute_service record updated for %s ') % host) db.compute_node_update(ctxt, compute_node_ref[0]['id'], dic)
def generate_data(): def _generate_stats(id_num): stats = {} i = 0 while i < CONF.num_stat: key = 'key%d' % i stats[key] = id_num + i i = i + 1 return stats print "Starting prepare data in DB" ctx = context.get_admin_context() for i in range(CONF.num_comp): if i *100.0 % CONF.num_comp == 0: sys.stdout.write("prepared %d%% data\r" % (i * 100.0 / CONF.num_comp)) sys.stdout.flush() svc_values = { 'host': 'host-%d' % i, 'binary': 'novadbtest', 'topic': 'novadbtest', 'report_count': 0, } #created service record service_ref = jsonutils.to_primitive( db.service_get_by_host_and_topic(ctx, svc_values['host'], svc_values['topic'])) if not service_ref: service_ref = jsonutils.to_primitive( db.service_create(ctx, svc_values)) LOG.info('Service record created for id %d', service_ref['id']) #create/update compute node record comp_values = { 'service_id': service_ref['id'], 'vcpus': i, 'memory_mb': i, 'local_gb': i, 'vcpus_used': i, 'memory_mb_used': i, 'local_gb_used': i, 'hypervisor_type': 'qemu', 'hypervisor_version': 1, 'hypervisor_hostname': 'test', 'free_ram_mb': i, 'free_disk_gb': i, 'current_workload': i, 'running_vms': i, 'disk_available_least': i, } comp_values['cpu_info'] = jsonutils.dumps(_generate_stats(i)) if hasattr(ComputeNode, 'metrics'): comp_values['metrics'] = jsonutils.dumps(_generate_stats(i)) if CONF.join_stats: comp_values['stats'] = _generate_stats(i) compute_ref = jsonutils.to_primitive( db.compute_node_create(ctx, comp_values)) LOG.info('Compute node record created for id %d', compute_ref['id']) print "Finish preparing data in DB"
def update_available_resource(self, ctxt, host): """Updates compute manager resource info on ComputeNode table. This method is called when nova-coompute launches, and whenever admin executes "nova-manage service update_resource". :param ctxt: security context :param host: hostname that compute manager is currently running """ try: service_ref = db.service_get_all_compute_by_host(ctxt, host)[0] except exception.NotFound: raise exception.ComputeServiceUnavailable(host=host) # Updating host information dic = {'vcpus': self.get_vcpu_total(), 'memory_mb': self.get_memory_mb_total(), 'local_gb': self.get_local_gb_total(), 'vcpus_used': self.get_vcpu_used(), 'memory_mb_used': self.get_memory_mb_used(), 'local_gb_used': self.get_local_gb_used(), 'hypervisor_type': self.get_hypervisor_type(), 'hypervisor_version': self.get_hypervisor_version(), 'cpu_info': self.get_cpu_info(), 'cpu_arch': FLAGS.cpu_arch, 'xpu_arch': FLAGS.xpu_arch, 'xpus': FLAGS.xpus, 'xpu_info': FLAGS.xpu_info, 'net_arch': FLAGS.net_arch, 'net_info': FLAGS.net_info, 'net_mbps': FLAGS.net_mbps, 'service_id': service_ref['id']} compute_node_ref = service_ref['compute_node'] LOG.info(_('#### RLK: cpu_arch = %s ') % FLAGS.cpu_arch) if not compute_node_ref: LOG.info(_('Compute_service record created for %s ') % host) dic['service_id'] = service_ref['id'] db.compute_node_create(ctxt, dic) else: LOG.info(_('Compute_service record updated for %s ') % host) db.compute_node_update(ctxt, compute_node_ref[0]['id'], dic)
def update_available_resource(self, ctxt, host): """Updates compute manager resource info on ComputeNode table. This method is called when nova-compute launches, and whenever admin executes "nova-manage service update_resource". :param ctxt: security context :param host: hostname that compute manager is currently running """ try: service_ref = db.service_get_all_compute_by_host(ctxt, host)[0] except exception.NotFound: raise exception.ComputeServiceUnavailable(host=host) host_stats = self.get_host_stats(refresh=True) # Updating host information total_ram_mb = host_stats['host_memory_total'] / (1024 * 1024) free_ram_mb = host_stats['host_memory_free'] / (1024 * 1024) total_disk_gb = host_stats['disk_total'] / (1024 * 1024 * 1024) used_disk_gb = host_stats['disk_used'] / (1024 * 1024 * 1024) dic = { 'vcpus': 0, 'memory_mb': total_ram_mb, 'local_gb': total_disk_gb, 'vcpus_used': 0, 'memory_mb_used': total_ram_mb - free_ram_mb, 'local_gb_used': used_disk_gb, 'hypervisor_type': 'xen', 'hypervisor_version': 0, 'cpu_info': host_stats['host_cpu_info']['cpu_count'] } compute_node_ref = service_ref['compute_node'] if not compute_node_ref: LOG.info(_('Compute_service record created for %s ') % host) dic['service_id'] = service_ref['id'] db.compute_node_create(ctxt, dic) else: LOG.info(_('Compute_service record updated for %s ') % host) db.compute_node_update(ctxt, compute_node_ref[0]['id'], dic)
def update_available_resource(self, ctxt, host): """Updates compute manager resource info on ComputeNode table. This method is called when nova-compute launches, and whenever admin executes "nova-manage service update_resource". :param ctxt: security context :param host: hostname that compute manager is currently running """ try: service_ref = db.service_get_all_compute_by_host(ctxt, host)[0] except exception.NotFound: raise exception.ComputeServiceUnavailable(host=host) host_stats = self.get_host_stats(refresh=True) # Updating host information total_ram_mb = host_stats["host_memory_total"] / (1024 * 1024) free_ram_mb = host_stats["host_memory_free"] / (1024 * 1024) total_disk_gb = host_stats["disk_total"] / (1024 * 1024 * 1024) used_disk_gb = host_stats["disk_used"] / (1024 * 1024 * 1024) dic = { "vcpus": 0, "memory_mb": total_ram_mb, "local_gb": total_disk_gb, "vcpus_used": 0, "memory_mb_used": total_ram_mb - free_ram_mb, "local_gb_used": used_disk_gb, "hypervisor_type": "xen", "hypervisor_version": 0, "hypervisor_hostname": host_stats["host_hostname"], "service_id": service_ref["id"], "cpu_info": host_stats["host_cpu_info"]["cpu_count"], } compute_node_ref = service_ref["compute_node"] if not compute_node_ref: LOG.info(_("Compute_service record created for %s ") % host) db.compute_node_create(ctxt, dic) else: LOG.info(_("Compute_service record updated for %s ") % host) db.compute_node_update(ctxt, compute_node_ref[0]["id"], dic)
def test_create(self): self.mox.StubOutWithMock(db, 'compute_node_create') db.compute_node_create( self.context, { 'service_id': 456, 'stats': fake_stats_db_format, 'host_ip': fake_host_ip, }).AndReturn(fake_compute_node) self.mox.ReplayAll() compute = compute_node.ComputeNode() compute.service_id = 456 compute.stats = fake_stats # NOTE (pmurray): host_ip is coerced to an IPAddress compute.host_ip = fake_host_ip compute.create(self.context) self.compare_obj(compute, fake_compute_node, comparators={'stats': self.json_comparator, 'host_ip': self.str_comparator})
def create(self, context): if self.obj_attr_is_set('id'): raise exception.ObjectActionError(action='create', reason='already created') updates = self.obj_get_changes() self._convert_stats_to_db_format(updates) self._convert_host_ip_to_db_format(updates) db_compute = db.compute_node_create(context, updates) self._from_db_object(context, self, db_compute)
def update_available_resource(self, ctxt, host): """Updates compute manager resource info on ComputeNode table. This method is called when nova-compute launches, and whenever admin executes "nova-manage service update_resource". :param ctxt: security context :param host: hostname that compute manager is currently running """ try: service_ref = db.service_get_all_compute_by_host(ctxt, host)[0] except exception.NotFound: raise exception.ComputeServiceUnavailable(host=host) host_stats = self.get_host_stats(refresh=True) # Updating host information total_ram_mb = host_stats['host_memory_total'] / (1024 * 1024) free_ram_mb = host_stats['host_memory_free'] / (1024 * 1024) total_disk_gb = host_stats['disk_total'] / (1024 * 1024 * 1024) used_disk_gb = host_stats['disk_used'] / (1024 * 1024 * 1024) dic = {'vcpus': 0, 'memory_mb': total_ram_mb, 'local_gb': total_disk_gb, 'vcpus_used': 0, 'memory_mb_used': total_ram_mb - free_ram_mb, 'local_gb_used': used_disk_gb, 'hypervisor_type': 'xen', 'hypervisor_version': 0, 'hypervisor_hostname': host_stats['host_hostname'], 'service_id': service_ref['id'], 'cpu_info': host_stats['host_cpu_info']['cpu_count']} compute_node_ref = service_ref['compute_node'] if not compute_node_ref: LOG.info(_('Compute_service record created for %s ') % host) db.compute_node_create(ctxt, dic) else: LOG.info(_('Compute_service record updated for %s ') % host) db.compute_node_update(ctxt, compute_node_ref[0]['id'], dic)
def test_create(self): self.mox.StubOutWithMock(db, "compute_node_create") db.compute_node_create( self.context, { "service_id": 456, "stats": fake_stats_db_format, "host_ip": fake_host_ip, "supported_instances": fake_supported_hv_specs_db_format, }, ).AndReturn(fake_compute_node) self.mox.ReplayAll() compute = compute_node.ComputeNode(context=self.context) compute.service_id = 456 compute.stats = fake_stats # NOTE (pmurray): host_ip is coerced to an IPAddress compute.host_ip = fake_host_ip compute.supported_hv_specs = fake_supported_hv_specs compute.create() self.compare_obj(compute, fake_compute_node, subs=self.subs(), comparators=self.comparators())
def create(self): if self.obj_attr_is_set("id"): raise exception.ObjectActionError(action="create", reason="already created") updates = self.obj_get_changes() 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_create(self._context, updates) self._from_db_object(self._context, self, db_compute)
def test_create(self): self.mox.StubOutWithMock(db, 'compute_node_create') db.compute_node_create( self.context, { 'service_id': 456, 'stats': fake_stats_db_format, 'host_ip': fake_host_ip, 'supported_instances': fake_supported_hv_specs_db_format, }).AndReturn(fake_compute_node) self.mox.ReplayAll() compute = compute_node.ComputeNode(context=self.context) compute.service_id = 456 compute.stats = fake_stats # NOTE (pmurray): host_ip is coerced to an IPAddress compute.host_ip = fake_host_ip compute.supported_hv_specs = fake_supported_hv_specs compute.create() self.compare_obj(compute, fake_compute_node, subs=self.subs(), comparators=self.comparators())
def update_available_resource(self, context, host): """Updates compute manager resource info on ComputeNode table. This method is called as an periodic tasks and is used only in live migration currently. :param ctxt: security context :param host: hostname that compute manager is currently running """ try: service_ref = db.service_get_all_compute_by_host(context, host)[0] except exception.NotFound: raise exception.ComputeServiceUnavailable(host=host) # Updating host information # TODO(alexpilotti) implemented cpu_info dic = { 'vcpus': self._get_vcpu_total(), 'memory_mb': self._get_memory_mb_total(), 'local_gb': self._get_local_gb_total(), 'vcpus_used': self._get_vcpu_used(), 'memory_mb_used': self._get_memory_mb_used(), 'local_gb_used': self._get_local_gb_used(), 'hypervisor_type': "hyperv", 'hypervisor_version': self._get_hypervisor_version(), 'cpu_info': "unknown", 'service_id': service_ref['id'], 'disk_available_least': 1 } compute_node_ref = service_ref['compute_node'] if not compute_node_ref: LOG.info(_('Compute_service record created for %s ') % host) db.compute_node_create(context, dic) else: LOG.info(_('Compute_service record updated for %s ') % host) db.compute_node_update(context, compute_node_ref[0]['id'], dic)
def _create_compute_service(self): """Create compute-manager(ComputeNode and Service record).""" ctxt = self.req.environ["nova.context"] dic = {"host": "dummy", "binary": "nova-compute", "topic": "compute", "report_count": 0} s_ref = db.service_create(ctxt, dic) dic = { "service_id": s_ref["id"], "vcpus": 16, "memory_mb": 32, "local_gb": 100, "vcpus_used": 16, "memory_mb_used": 32, "local_gb_used": 10, "hypervisor_type": "qemu", "hypervisor_version": 12003, "cpu_info": "", "stats": {}, } db.compute_node_create(ctxt, dic) return db.service_get(ctxt, s_ref["id"])
def _create_compute_service(self, **kwargs): """Create a compute service.""" dic = {'binary': 'nova-compute', 'topic': 'compute', 'report_count': 0, 'availability_zone': 'dummyzone'} dic['host'] = kwargs.get('host', 'dummy') s_ref = db.service_create(self.context, dic) if 'created_at' in kwargs.keys() or 'updated_at' in kwargs.keys(): t = datetime.datetime.utcnow() - datetime.timedelta(0) dic['created_at'] = kwargs.get('created_at', t) dic['updated_at'] = kwargs.get('updated_at', t) db.service_update(self.context, s_ref['id'], dic) dic = {'service_id': s_ref['id'], 'vcpus': 16, 'memory_mb': 32, 'local_gb': 100, 'vcpus_used': 16, 'local_gb_used': 10, 'hypervisor_type': 'qemu', 'hypervisor_version': 12003, 'cpu_info': ''} dic['memory_mb_used'] = kwargs.get('memory_mb_used', 32) dic['hypervisor_type'] = kwargs.get('hypervisor_type', 'qemu') dic['hypervisor_version'] = kwargs.get('hypervisor_version', 12003) db.compute_node_create(self.context, dic) return db.service_get(self.context, s_ref['id'])
def update_available_resource(self, context, host): """Updates compute manager resource info on ComputeNode table. This method is called as an periodic tasks and is used only in live migration currently. :param ctxt: security context :param host: hostname that compute manager is currently running """ try: service_ref = db.service_get_all_compute_by_host(context, host)[0] except exception.NotFound: raise exception.ComputeServiceUnavailable(host=host) # Updating host information # TODO(alexpilotti) implemented cpu_info dic = {'vcpus': self._get_vcpu_total(), 'memory_mb': self._get_memory_mb_total(), 'local_gb': self._get_local_gb_total(), 'vcpus_used': self._get_vcpu_used(), 'memory_mb_used': self._get_memory_mb_used(), 'local_gb_used': self._get_local_gb_used(), 'hypervisor_type': "hyperv", 'hypervisor_version': self._get_hypervisor_version(), 'cpu_info': "unknown", 'service_id': service_ref['id'], 'disk_available_least': 1} compute_node_ref = service_ref['compute_node'] if not compute_node_ref: LOG.info(_('Compute_service record created for %s ') % host) db.compute_node_create(context, dic) else: LOG.info(_('Compute_service record updated for %s ') % host) db.compute_node_update(context, compute_node_ref[0]['id'], dic)
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._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_create(self._context, updates) self._from_db_object(self._context, self, db_compute)
def test_compute_node_create(self): self.mox.StubOutWithMock(db, "compute_node_create") db.compute_node_create(self.context, "fake-values").AndReturn("fake-result") self.mox.ReplayAll() result = self.conductor.compute_node_create(self.context, "fake-values") self.assertEqual(result, "fake-result")
def create(self, context): updates = {} for key in self.obj_what_changed(): updates[key] = self[key] db_compute = db.compute_node_create(context, updates) self._from_db_object(context, self, db_compute)
def _create_helper(self, host): self.compute_node_dict['host'] = host return db.compute_node_create(self.ctxt, self.compute_node_dict)
def create(self, context): updates = self.obj_get_changes() db_compute = db.compute_node_create(context, updates) self._from_db_object(context, self, db_compute)
def _create(self, context, values): """Create the compute node in the DB""" # initialize load stats from existing instances: compute_node = db.compute_node_create(context, values) self.compute_node = dict(compute_node)