Merge "Implements blueprint heterogeneous-tilera-architecture-support"

Authors

@@ -46,6 +46,7 @@ Derek Higgins <higginsd@gmail.com>
 Devendra Modium <dmodium@isi.edu>
 Devin Carlen <devin.carlen@gmail.com>
 Donal Lafferty <donal.lafferty@citrix.com>
+Dong-In David Kang <dkang@isi.edu>
 Duncan McGreggor <duncan@dreamhost.com>
 Ed Leafe <ed@leafe.com>
 Edouard Thuleau <edouard1.thuleau@orange.com>
@@ -115,6 +116,7 @@ Michael Gundlach <michael.gundlach@rackspace.com>
 Michael Still <mikal@stillhq.com>
 Mike Lundy <mike@pistoncloud.com>
 Mike Scherbakov <mihgen@gmail.com>
+Mikyung Kang <mkkang@isi.edu>
 Mohammed Naser <mnaser@vexxhost.com>
 Monsyne Dragon <mdragon@rackspace.com>
 Monty Taylor <mordred@inaugust.com>

nova/tests/baremetal/test_proxy_bare_metal.py

@@ -0,0 +1,292 @@
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+
+# Copyright 2011 University of Southern California
+#    Licensed under the Apache License, Version 2.0 (the "License"); you may
+#    not use this file except in compliance with the License. You may obtain
+#    a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#    License for the specific language governing permissions and limitations
+#    under the License.
+
+import __builtin__
+
+import functools
+import mox
+import StringIO
+import stubout
+
+from nova import flags
+from nova import utils
+from nova import test
+from nova.compute import power_state
+from nova import context
+from nova.tests import fake_utils
+from nova import exception
+
+from nova.virt.baremetal import proxy
+from nova.virt.baremetal import dom
+
+FLAGS = flags.FLAGS
+
+
+# Same fake_domains is used by different classes,
+# but different fake_file is used by different classes for unit test.
+fake_domains = [{'status': 1, 'name': 'instance-00000001',
+                 'memory_kb': 16777216, 'kernel_id': '1896115634',
+                 'ramdisk_id': '', 'image_id': '1552326678',
+                 'vcpus': 1, 'node_id': 6,
+                 'mac_address': '02:16:3e:01:4e:c9',
+                 'ip_address': '10.5.1.2'}]
+
+
+class DomainReadWriteTestCase(test.TestCase):
+
+    def setUp(self):
+        self.flags(baremetal_driver='fake')
+        super(DomainReadWriteTestCase, self).setUp()
+
+    def test_read_domain_with_empty_list(self):
+        """Read a file that contains no domains"""
+
+        self.mox.StubOutWithMock(__builtin__, 'open')
+        try:
+            fake_file = StringIO.StringIO('[]')
+            open('/tftpboot/test_fake_dom_file', 'r').AndReturn(fake_file)
+
+            self.mox.ReplayAll()
+
+            domains = dom.read_domains('/tftpboot/test_fake_dom_file')
+
+            self.assertEqual(domains, [])
+
+        finally:
+            self.mox.UnsetStubs()
+
+    def test_read_domain(self):
+        """Read a file that contains at least one domain"""
+        fake_file = StringIO.StringIO('''[{"status": 1,
+         "image_id": "1552326678", "vcpus": 1, "node_id": 6,
+         "name": "instance-00000001", "memory_kb": 16777216,
+         "mac_address": "02:16:3e:01:4e:c9", "kernel_id": "1896115634",
+         "ramdisk_id": "", "ip_address": "10.5.1.2"}]''')
+
+        self.mox.StubOutWithMock(__builtin__, 'open')
+        try:
+            open('/tftpboot/test_fake_dom_file', 'r').AndReturn(fake_file)
+
+            self.mox.ReplayAll()
+
+            domains = dom.read_domains('/tftpboot/test_fake_dom_file')
+
+            self.assertEqual(domains, fake_domains)
+
+        finally:
+            self.mox.UnsetStubs()
+
+    def test_read_no_file(self):
+        """Try to read when the file does not exist
+
+        This should through and IO exception"""
+
+        self.mox.StubOutWithMock(__builtin__, 'open')
+        try:
+            open('/tftpboot/test_fake_dom_file', 'r').AndRaise(\
+            IOError(2, 'No such file or directory',
+                       '/tftpboot/test_fake_dom_file'))
+
+            self.mox.ReplayAll()
+
+            self.assertRaises(exception.NotFound, dom.read_domains,
+                       '/tftpboot/test_fake_dom_file')
+
+        finally:
+            self.mox.UnsetStubs()
+
+    def assertJSONEquals(self, x, y):
+        """Check if two json strings represent the equivalent Python object"""
+        self.assertEquals(utils.loads(x), utils.loads(y))
+        return utils.loads(x) == utils.loads(y)
+
+    def test_write_domain(self):
+        """Write the domain to file"""
+        self.mox.StubOutWithMock(__builtin__, 'open')
+        mock_file = self.mox.CreateMock(file)
+        expected_json = '''[{"status": 1,
+               "image_id": "1552326678", "vcpus": 1, "node_id": 6,
+               "name": "instance-00000001", "memory_kb": 16777216,
+               "mac_address": "02:16:3e:01:4e:c9", "kernel_id": "1896115634",
+               "ramdisk_id": "", "ip_address": "10.5.1.2"}]'''
+        try:
+            open('/tftpboot/test_fake_dom_file', 'w').AndReturn(mock_file)
+
+            # Check if the argument to file.write() represents the same
+            # Python object as expected_json
+            # We can't do an exact string comparison
+            # because of ordering and whitespace
+            mock_file.write(mox.Func(functools.partial(self.assertJSONEquals,\
+                expected_json)))
+            mock_file.close()
+
+            self.mox.ReplayAll()
+
+            dom.write_domains('/tftpboot/test_fake_dom_file', fake_domains)
+
+        finally:
+            self.mox.UnsetStubs()
+
+
+class BareMetalDomTestCase(test.TestCase):
+
+    def setUp(self):
+        self.flags(baremetal_driver='fake')
+        super(BareMetalDomTestCase, self).setUp()
+        # Stub out utils.execute
+        self.stubs = stubout.StubOutForTesting()
+        fake_utils.stub_out_utils_execute(self.stubs)
+
+    def tearDown(self):
+        self.stubs.UnsetAll()
+        super(BareMetalDomTestCase, self).tearDown()
+
+        # Reset the singleton state
+        dom.BareMetalDom._instance = None
+        dom.BareMetalDom._is_init = False
+
+    def test_read_domain_only_once(self):
+        """Confirm that the domain is read from a file only once,
+        even if the object is instantiated multiple times"""
+        self.mox.StubOutWithMock(dom, 'read_domains')
+        self.mox.StubOutWithMock(dom, 'write_domains')
+
+        dom.read_domains('/tftpboot/test_fake_dom_file').AndReturn([])
+        dom.write_domains('/tftpboot/test_fake_dom_file', [])
+
+        self.mox.ReplayAll()
+
+        # Instantiate multiple instances
+        x = dom.BareMetalDom()
+        x = dom.BareMetalDom()
+        x = dom.BareMetalDom()
+
+    def test_init_no_domains(self):
+
+        # Create the mock objects
+        self.mox.StubOutWithMock(dom, 'read_domains')
+        self.mox.StubOutWithMock(dom, 'write_domains')
+
+        dom.read_domains('/tftpboot/test_fake_dom_file').AndReturn([])
+        dom.write_domains('/tftpboot/test_fake_dom_file', [])
+
+        self.mox.ReplayAll()
+
+        # Code under test
+        bmdom = dom.BareMetalDom()
+
+        # Expectd values
+        self.assertEqual(bmdom.fake_dom_nums, 0)
+
+    def test_init_remove_non_running_domain(self):
+        """Check to see that all entries in the domain list are removed
+        except for the one that is in the running state"""
+
+        fake_file = StringIO.StringIO()
+
+        domains = [dict(node_id=1, name='i-00000001',
+                        status=power_state.NOSTATE),
+              dict(node_id=2, name='i-00000002', status=power_state.RUNNING),
+              dict(node_id=3, name='i-00000003', status=power_state.BLOCKED),
+              dict(node_id=4, name='i-00000004', status=power_state.PAUSED),
+              dict(node_id=5, name='i-00000005', status=power_state.SHUTDOWN),
+              dict(node_id=6, name='i-00000006', status=power_state.SHUTOFF),
+              dict(node_id=7, name='i-00000007', status=power_state.CRASHED),
+              dict(node_id=8, name='i-00000008', status=power_state.SUSPENDED),
+              dict(node_id=9, name='i-00000009', status=power_state.FAILED)]
+
+        # Create the mock objects
+        self.mox.StubOutWithMock(dom, 'read_domains')
+        self.mox.StubOutWithMock(dom, 'write_domains')
+        dom.read_domains('/tftpboot/test_fake_dom_file').AndReturn(domains)
+        dom.write_domains('/tftpboot/test_fake_dom_file', domains)
+
+        self.mox.ReplayAll()
+
+        # Code under test
+        bmdom = dom.BareMetalDom()
+
+        self.assertEqual(bmdom.domains, [{'node_id': 2,
+                                          'name': 'i-00000002',
+                                          'status': power_state.RUNNING}])
+        self.assertEqual(bmdom.fake_dom_nums, 1)
+
+    def test_find_domain(self):
+        domain = {'status': 1, 'name': 'instance-00000001',
+                    'memory_kb': 16777216, 'kernel_id': '1896115634',
+                    'ramdisk_id': '', 'image_id': '1552326678',
+                    'vcpus': 1, 'node_id': 6,
+                    'mac_address': '02:16:3e:01:4e:c9',
+                    'ip_address': '10.5.1.2'}
+
+        # Create the mock objects
+        self.mox.StubOutWithMock(dom, 'read_domains')
+        self.mox.StubOutWithMock(dom, 'write_domains')
+
+        # Expected calls
+        dom.read_domains('/tftpboot/test_fake_dom_file')\
+            .AndReturn(fake_domains)
+        dom.write_domains('/tftpboot/test_fake_dom_file', fake_domains)
+
+        self.mox.ReplayAll()
+
+        # Code under test
+        bmdom = dom.BareMetalDom()
+
+        # Expected values
+        self.assertEquals(bmdom.find_domain('instance-00000001'), domain)
+
+
+class ProxyBareMetalTestCase(test.TestCase):
+
+    test_ip = '10.11.12.13'
+    test_instance = {'memory_kb': '1024000',
+                     'basepath': '/some/path',
+                     'bridge_name': 'br100',
+                     'mac_address': '02:12:34:46:56:67',
+                     'vcpus': 2,
+                     'project_id': 'fake',
+                     'bridge': 'br101',
+                     'image_ref': '123456',
+                     'instance_type_id': '5'}  # m1.small
+
+    def setUp(self):
+        self.flags(baremetal_driver='fake')
+        super(ProxyBareMetalTestCase, self).setUp()
+        self.context = context.get_admin_context()
+        fake_utils.stub_out_utils_execute(self.stubs)
+
+    def test_get_info(self):
+        # Create the mock objects
+        self.mox.StubOutWithMock(dom, 'read_domains')
+        self.mox.StubOutWithMock(dom, 'write_domains')
+
+        # Expected calls
+        dom.read_domains('/tftpboot/test_fake_dom_file')\
+            .AndReturn(fake_domains)
+        dom.write_domains('/tftpboot/test_fake_dom_file', fake_domains)
+
+        self.mox.ReplayAll()
+
+        # Code under test
+        conn = proxy.get_connection(True)
+        info = conn.get_info('instance-00000001')
+
+        # Expected values
+        self.assertEquals(info['mem'], 16777216)
+        self.assertEquals(info['state'], 1)
+        self.assertEquals(info['num_cpu'], 1)
+        self.assertEquals(info['cpu_time'], 100)
+        self.assertEquals(info['max_mem'], 16777216)

nova/tests/baremetal/test_tilera.py

@@ -0,0 +1,88 @@
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+
+# Copyright (c) 2011 University of Southern California
+#
+#    Licensed under the Apache License, Version 2.0 (the "License"); you may
+#    not use this file except in compliance with the License. You may obtain
+#    a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#    License for the specific language governing permissions and limitations
+#    under the License.
+#
+
+import __builtin__
+import StringIO
+
+from nova import test
+from nova.virt.baremetal import tilera
+
+
+class TileraBareMetalNodesTestCase(test.TestCase):
+
+    def setUp(self):
+        super(TileraBareMetalNodesTestCase, self).setUp()
+        self.board_info = """\
+# board_id  ip_address mac_address 00:1A:CA:00:57:90 \
+00:1A:CA:00:58:98 00:1A:CA:00:58:50
+6            10.0.2.7   00:1A:CA:00:58:5C 10 16218 917 476 1 tilera_hv 1 \
+{"vendor":"tilera","model":"TILEmpower","arch":"TILEPro64","features":\
+["8x8Grid","32bVLIW","5.6MBCache","443BOPS","37TbMesh","700MHz-866MHz",\
+"4DDR2","2XAUIMAC/PHY","2GbEMAC"],"topology":{"cores":"64"}}
+7            10.0.2.8   00:1A:CA:00:58:A4 10 16218 917 476 1 tilera_hv 1 \
+{"vendor":"tilera","model":"TILEmpower","arch":"TILEPro64","features":\
+["8x8Grid","32bVLIW","5.6MBCache","443BOPS","37TbMesh","700MHz-866MHz",\
+"4DDR2","2XAUIMAC/PHY","2GbEMAC"],"topology":{"cores":"64"}}
+8            10.0.2.9   00:1A:CA:00:58:1A 10 16218 917 476 1 tilera_hv 1 \
+{"vendor":"tilera","model":"TILEmpower","arch":"TILEPro64","features":\
+["8x8Grid","32bVLIW","5.6MBCache","443BOPS","37TbMesh","700MHz-866MHz",\
+"4DDR2","2XAUIMAC/PHY","2GbEMAC"],"topology":{"cores":"64"}}
+9            10.0.2.10  00:1A:CA:00:58:38 10 16385 1000 0 0 tilera_hv 1 \
+{"vendor":"tilera","model":"TILEmpower","arch":"TILEPro64","features":\
+["8x8Grid","32bVLIW","5.6MBCache","443BOPS","37TbMesh","700MHz-866MHz",\
+"4DDR2","2XAUIMAC/PHY","2GbEMAC"],"topology":{"cores":"64"}}
+"""
+
+    def tearDown(self):
+        super(TileraBareMetalNodesTestCase, self).tearDown()
+
+        # Reset the singleton state
+        tilera.BareMetalNodes._instance = None
+        tilera.BareMetalNodes._is_init = False
+
+    def test_singleton(self):
+        """Confirm that the object acts like a singleton.
+
+        In this case, we check that it only loads the config file once,
+        even though it has been instantiated multiple times"""
+
+        try:
+            self.mox.StubOutWithMock(__builtin__, 'open')
+
+            open("/tftpboot/tilera_boards", "r").AndReturn(\
+                 StringIO.StringIO(self.board_info))
+
+            self.mox.ReplayAll()
+
+            nodes = tilera.BareMetalNodes("/tftpboot/tilera_boards")
+            nodes = tilera.BareMetalNodes("/tftpboot/tilera_boards")
+        finally:
+            self.mox.UnsetStubs()
+
+    def test_get_hw_info(self):
+        try:
+
+            self.mox.StubOutWithMock(__builtin__, 'open')
+
+            open("/tftpboot/tilera_boards", "r").AndReturn(\
+                StringIO.StringIO(self.board_info))
+
+            self.mox.ReplayAll()
+            nodes = tilera.BareMetalNodes()
+            self.assertEqual(nodes.get_hw_info('vcpus'), 10)
+        finally:
+            self.mox.UnsetStubs()

nova/virt/baremetal/__init__.py

@@ -0,0 +1,15 @@
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+
+# Copyright (c) 2011 University of Southern California
+#
+#    Licensed under the Apache License, Version 2.0 (the "License"); you may
+#    not use this file except in compliance with the License. You may obtain
+#    a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#    License for the specific language governing permissions and limitations
+#    under the License.

nova/virt/baremetal/dom.py

@@ -0,0 +1,268 @@
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+
+# Copyright (c) 2011 University of Southern California
+#
+#    Licensed under the Apache License, Version 2.0 (the "License"); you may
+#    not use this file except in compliance with the License. You may obtain
+#    a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#    License for the specific language governing permissions and limitations
+#    under the License.
+
+from nova.compute import power_state
+from nova import exception
+from nova import flags
+from nova import log as logging
+from nova import utils
+from nova.virt.baremetal import nodes
+
+FLAGS = flags.FLAGS
+
+LOG = logging.getLogger('nova.virt.baremetal.dom')
+
+
+def read_domains(fname):
+    try:
+        f = open(fname, 'r')
+        json = f.read()
+        f.close()
+        domains = utils.loads(json)
+        return domains
+    except IOError:
+        raise exception.NotFound()
+
+
+def write_domains(fname, domains):
+    json = utils.dumps(domains)
+    f = open(fname, 'w')
+    f.write(json)
+    f.close()
+
+
+class BareMetalDom(object):
+    """
+    BareMetalDom class handles fake domain for bare metal back ends.
+
+    This implements the singleton pattern.
+    """
+
+    _instance = None
+    _is_init = False
+
+    def __new__(cls, *args, **kwargs):
+        """
+        Returns the BareMetalDom singleton.
+        """
+        if not cls._instance or ('new' in kwargs and kwargs['new']):
+            cls._instance = super(BareMetalDom, cls).__new__(cls)
+        return cls._instance
+
+    def __init__(self,
+                 fake_dom_file="/tftpboot/test_fake_dom_file"):
+        """
+        Only call __init__ the first time object is instantiated.
+
+        Sets and Opens domain file: /tftpboot/test_fake_dom_file. Even though
+        nova-compute service is rebooted, this file should retain the
+        existing domains.
+        """
+        if self._is_init:
+            return
+        self._is_init = True
+
+        self.fake_dom_file = fake_dom_file
+        self.domains = []
+        self.fake_dom_nums = 0
+        self.baremetal_nodes = nodes.get_baremetal_nodes()
+
+        self._read_domain_from_file()
+
+    def _read_domain_from_file(self):
+        """
+        Reads the domains from a file.
+        """
+        try:
+            self.domains = read_domains(self.fake_dom_file)
+        except IOError:
+            dom = []
+            LOG.debug(_("No domains exist."))
+            return
+        msg = _("============= initial domains =========== : %s")
+        LOG.debug(msg % (self.domains))
+        for dom in self.domains[:]:
+            if dom['status'] == power_state.BUILDING:
+                LOG.debug(_("Building domain: to be removed"))
+                self.destroy_domain(dom['name'])
+                continue
+            elif dom['status'] != power_state.RUNNING:
+                LOG.debug(_("Not running domain: remove"))
+                self.domains.remove(dom)
+                continue
+            res = self.baremetal_nodes.set_status(dom['node_id'],
+                                    dom['status'])
+            if res > 0:
+                self.fake_dom_nums = self.fake_dom_nums + 1
+            else:
+                LOG.debug(_("domain running on an unknown node: discarded"))
+                self.domains.remove(dom)
+                continue
+
+        LOG.debug(_(self.domains))
+        self.store_domain()
+
+    def reboot_domain(self, name):
+        """
+        Finds domain and deactivates (power down) bare-metal node.
+
+        Activates the node again. In case of fail,
+        destroys the domain from domains list.
+        """
+        fd = self.find_domain(name)
+        if fd == []:
+            msg = _("No such domain (%s)")
+            raise exception.NotFound(msg % name)
+        node_ip = self.baremetal_nodes.get_ip_by_id(fd['node_id'])
+
+        try:
+            self.baremetal_nodes.deactivate_node(fd['node_id'])
+        except:
+            msg = _("Failed power down Bare-metal node %s")
+            raise exception.NotFound(msg % fd['node_id'])
+        self.change_domain_state(name, power_state.BUILDING)
+        try:
+            state = self.baremetal_nodes.activate_node(fd['node_id'],
+                node_ip, name, fd['mac_address'], fd['ip_address'])
+            self.change_domain_state(name, state)
+            return state
+        except:
+            LOG.debug(_("deactivate -> activate fails"))
+            self.destroy_domain(name)
+            raise
+
+    def destroy_domain(self, name):
+        """
+        Removes domain from domains list and deactivates node.
+        """
+        fd = self.find_domain(name)
+        if fd == []:
+            LOG.debug(_("destroy_domain: no such domain"))
+            msg = _("No such domain %s")
+            raise exception.NotFound(msg % name)
+
+        try:
+            self.baremetal_nodes.deactivate_node(fd['node_id'])
+
+            self.domains.remove(fd)
+            msg = _("Domains: %s")
+            LOG.debug(msg % (self.domains))
+            msg = _("Nodes: %s")
+            LOG.debug(msg % (self.baremetal_nodes.nodes))
+            self.store_domain()
+            msg = _("After storing domains: %s")
+            LOG.debug(msg % (self.domains))
+        except:
+            LOG.debug(_("deactivation/removing domain failed"))
+            raise
+
+    def create_domain(self, xml_dict, bpath):
+        """
+        Adds a domain to domains list and activates an idle bare-metal node.
+        """
+        LOG.debug(_("===== Domain is being created ====="))
+        fd = self.find_domain(xml_dict['name'])
+        if fd != []:
+            msg = _("Same domain name already exists")
+            raise exception.NotFound(msg)
+        LOG.debug(_("create_domain: before get_idle_node"))
+
+        node_id = self.baremetal_nodes.get_idle_node()
+        node_ip = self.baremetal_nodes.get_ip_by_id(node_id)
+
+        new_dom = {'node_id': node_id,
+                    'name': xml_dict['name'],
+                    'memory_kb': xml_dict['memory_kb'],
+                    'vcpus': xml_dict['vcpus'],
+                    'mac_address': xml_dict['mac_address'],
+                    'user_data': xml_dict['user_data'],
+                    'ip_address': xml_dict['ip_address'],
+                    'image_id': xml_dict['image_id'],
+                    'kernel_id': xml_dict['kernel_id'],
+                    'ramdisk_id': xml_dict['ramdisk_id'],
+                     'status': power_state.BUILDING}
+        self.domains.append(new_dom)
+        msg = _("Created new domain: %s")
+        LOG.debug(msg % (new_dom))
+        self.change_domain_state(new_dom['name'], power_state.BUILDING)
+
+        self.baremetal_nodes.set_image(bpath, node_id)
+
+        state = power_state.NOSTATE
+        try:
+            state = self.baremetal_nodes.activate_node(node_id,
+                node_ip, new_dom['name'], new_dom['mac_address'],
+                new_dom['ip_address'], new_dom['user_data'])
+            self.change_domain_state(new_dom['name'], state)
+        except:
+            self.domains.remove(new_dom)
+            self.baremetal_nodes.free_node(node_id)
+            LOG.debug(_("Failed to boot Bare-metal node %s"), node_id)
+        return state
+
+    def change_domain_state(self, name, state):
+        """
+        Changes domain state by the given state and updates domain file.
+        """
+        l = self.find_domain(name)
+        if l == []:
+            msg = _("No such domain exists")
+            raise exception.NotFound(msg)
+        i = self.domains.index(l)
+        self.domains[i]['status'] = state
+        LOG.debug(_("change_domain_state: to new state %s"), str(state))
+        self.store_domain()
+
+    def store_domain(self):
+        """
+        Stores fake domains to the file.
+        """
+        msg = _("Stored fake domains to the file: %s")
+        LOG.debug(msg % (self.domains))
+        write_domains(self.fake_dom_file, self.domains)
+
+    def find_domain(self, name):
+        """
+        Finds domain by the given name and returns the domain.
+        """
+        for item in self.domains:
+            if item['name'] == name:
+                return item
+        LOG.debug(_("domain does not exist"))
+        return []
+
+    def list_domains(self):
+        """
+        Returns the instance name from domains list.
+        """
+        if self.domains == []:
+            return []
+        return [x['name'] for x in self.domains]
+
+    def get_domain_info(self, instance_name):
+        """
+        Finds domain by the given instance_name and returns informaiton.
+
+        For example, status, memory_kb, vcpus, etc.
+        """
+        domain = self.find_domain(instance_name)
+        if domain != []:
+            return [domain['status'], domain['memory_kb'],
+                    domain['memory_kb'],
+                    domain['vcpus'],
+                    100]
+        else:
+            return [power_state.NOSTATE, '', '', '', '']

nova/virt/baremetal/fake.py

@@ -0,0 +1,157 @@
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+
+# Copyright (c) 2011 University of Southern California
+#
+#    Licensed under the Apache License, Version 2.0 (the "License"); you may
+#    not use this file except in compliance with the License. You may obtain
+#    a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#    License for the specific language governing permissions and limitations
+#    under the License.
+#
+
+
+def get_baremetal_nodes():
+    return BareMetalNodes()
+
+
+class BareMetalNodes(object):
+    """
+    This manages node information and implements singleton.
+
+    BareMetalNodes class handles machine architectures of interest to
+    technical computing users have either poor or non-existent support
+    for virtualization.
+    """
+
+    def get_hw_info(self, field):
+        """
+        Returns hardware information of bare-metal node by the given field.
+
+        Given field can be vcpus, memory_mb, local_gb, memory_mb_used,
+        local_gb_used, hypervisor_type, hypervisor_version, and cpu_info.
+        """
+        return "fake"
+
+    def set_status(self, node_id, status):
+        """
+        Sets status of the given node by the given status.
+
+        Returns 1 if the node is in the nodes list.
+        """
+        return True
+
+    def get_status(self):
+        """
+        Gets status of the given node.
+        """
+        pass
+
+    def get_idle_node(self):
+        """
+        Gets an idle node, sets the status as 1 (RUNNING) and Returns node ID.
+        """
+        return False
+
+    def get_ip_by_id(self, id):
+        """
+        Returns default IP address of the given node.
+        """
+        return "127.0.0.1"
+
+    def free_node(self, node_id):
+        """
+        Sets/frees status of the given node as 0 (IDLE).
+        """
+        return False
+
+    def power_mgr(self, node_id, mode):
+        """
+        Changes power state of the given node.
+
+        According to the mode (1-ON, 2-OFF, 3-REBOOT), power state can be
+        changed. /tftpboot/pdu_mgr script handles power management of
+        PDU (Power Distribution Unit).
+        """
+        pass
+
+    def deactivate_node(self, node_id):
+        """
+        Deactivates the given node by turnning it off.
+        """
+        pass
+
+    def network_set(self, node_ip, mac_address, ip_address):
+        """
+        Sets network configuration based on the given ip and mac address.
+
+        User can access the bare-metal node using ssh.
+        """
+        pass
+
+    def iptables_set(self, node_ip, user_data):
+        """
+        Sets security setting (iptables:port) if needed.
+        """
+        pass
+
+    def check_activated(self, node_id, node_ip):
+        """
+        Checks whether the given node is activated or not.
+        """
+        pass
+
+    def vmlinux_set(self, node_id, mode):
+        """
+        Sets kernel into default path (/tftpboot) if needed.
+
+        From basepath to /tftpboot, kernel is set based on the given mode
+        such as 0-NoSet, 1-SetVmlinux, or 9-RemoveVmlinux.
+        """
+        pass
+
+    def sleep_mgr(self, time):
+        """
+        Sleeps until the node is activated.
+        """
+        pass
+
+    def ssh_set(self, node_ip):
+        """
+        Sets and Runs sshd in the node.
+        """
+        pass
+
+    def activate_node(self, node_id, node_ip, name, mac_address, \
+                      ip_address):
+        """
+        Activates the given node using ID, IP, and MAC address.
+        """
+        pass
+
+    def get_console_output(self, console_log):
+        """
+        Gets console output of the given node.
+        """
+        pass
+
+    def get_image(self, bp):
+        """
+        Gets the bare-metal file system image into the instance path.
+
+        Noting to do for tilera nodes: actual image is used.
+        """
+        pass
+
+    def set_image(self, bpath, node_id):
+        """
+        Sets the PXE bare-metal file system from the instance path.
+
+        This should be done after ssh key is injected.
+        """
+        pass

nova/virt/baremetal/nodes.py

@@ -0,0 +1,42 @@
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+
+# Copyright (c) 2011 University of Southern California
+#
+#    Licensed under the Apache License, Version 2.0 (the "License"); you may
+#    not use this file except in compliance with the License. You may obtain
+#    a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#    License for the specific language governing permissions and limitations
+#    under the License.
+#
+
+from nova.virt.baremetal import tilera
+from nova.virt.baremetal import fake
+from nova.openstack.common import cfg
+from nova import flags
+from nova import exception
+
+FLAGS = flags.FLAGS
+
+global_opts = [
+    cfg.StrOpt('baremetal_driver',
+               default='tilera',
+               help='Bare-metal driver runs on')
+    ]
+
+FLAGS.add_options(global_opts)
+
+
+def get_baremetal_nodes():
+    d = FLAGS.baremetal_driver
+    if  d == 'tilera':
+        return tilera.get_baremetal_nodes()
+    elif d == 'fake':
+        return fake.get_baremetal_nodes()
+    else:
+        raise exception.Error(_("Unknown baremetal driver %(d)s"))

nova/virt/baremetal/proxy.py

@@ -0,0 +1,799 @@
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+
+# Copyright (c) 2011 University of Southern California
+#
+#    Licensed under the Apache License, Version 2.0 (the "License"); you may
+#    not use this file except in compliance with the License. You may obtain
+#    a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#    License for the specific language governing permissions and limitations
+#    under the License.
+#
+"""
+A connection to a hypervisor through baremetal.
+
+**Related Flags**
+
+:baremetal_type:  Baremetal domain type.
+:baremetal_uri:  Override for the default baremetal URI (baremetal_type).
+:rescue_image_id:  Rescue ami image (default: ami-rescue).
+:rescue_kernel_id:  Rescue aki image (default: aki-rescue).
+:rescue_ramdisk_id:  Rescue ari image (default: ari-rescue).
+:injected_network_template:  Template file for injected network
+:allow_project_net_traffic:  Whether to allow in project network traffic
+
+"""
+
+import hashlib
+import os
+import shutil
+import time
+
+from nova import context as nova_context
+from nova import db
+from nova import exception
+from nova import flags
+from nova import log as logging
+from nova import utils
+from nova.openstack.common import cfg
+from nova.compute import instance_types
+from nova.compute import power_state
+from nova.compute import vm_states
+from nova.virt import disk
+from nova.virt.disk import api as disk
+from nova.virt import driver
+from nova.virt.baremetal import nodes
+from nova.virt.baremetal import dom
+from nova.virt.libvirt import utils as libvirt_utils
+
+
+Template = None
+
+LOG = logging.getLogger('nova.virt.baremetal.proxy')
+
+FLAGS = flags.FLAGS
+
+global_opts = [
+    cfg.StrOpt('baremetal_injected_network_template',
+                default=utils.abspath('virt/interfaces.template'),
+                help='Template file for injected network'),
+    cfg.StrOpt('baremetal_type',
+                default='baremetal',
+                help='baremetal domain type'),
+    cfg.StrOpt('baremetal_uri',
+                default='',
+                help='Override the default baremetal URI'),
+    cfg.BoolOpt('baremetal_allow_project_net_traffic',
+                 default=True,
+                 help='Whether to allow in project network traffic')
+    ]
+
+FLAGS.add_options(global_opts)
+
+
+def get_connection(read_only):
+    # These are loaded late so that there's no need to install these
+    # libraries when not using baremetal.
+    # Cheetah is separate because the unit tests want to load Cheetah,
+    # but not baremetal.
+    _late_load_cheetah()
+    return ProxyConnection(read_only)
+
+
+def _late_load_cheetah():
+    global Template
+    if Template is None:
+        t = __import__('Cheetah.Template', globals(), locals(),
+                       ['Template'], -1)
+        Template = t.Template
+
+
+class ProxyConnection(driver.ComputeDriver):
+
+    def __init__(self, read_only):
+        super(ProxyConnection, self).__init__()
+        self.baremetal_nodes = nodes.get_baremetal_nodes()
+        self._wrapped_conn = None
+        self.read_only = read_only
+        self._host_state = None
+
+    @property
+    def HostState(self):
+        if not self._host_state:
+            self._host_state = HostState(self.read_only)
+        return self._host_state
+
+    def init_host(self, host):
+        pass
+
+    def _get_connection(self):
+        self._wrapped_conn = dom.BareMetalDom()
+        return self._wrapped_conn
+    _conn = property(_get_connection)
+
+    def get_pty_for_instance(self, instance_name):
+        raise NotImplementedError()
+
+    def list_instances(self):
+        return self._conn.list_domains()
+
+    def _map_to_instance_info(self, domain_name):
+        """Gets info from a virsh domain object into an InstanceInfo"""
+        (state, _max_mem, _mem, _num_cpu, _cpu_time) \
+            = self._conn.get_domain_info(domain_name)
+        name = domain_name
+        return driver.InstanceInfo(name, state)
+
+    def list_instances_detail(self):
+        infos = []
+        for domain_name in self._conn.list_domains():
+            info = self._map_to_instance_info(domain_name)
+            infos.append(info)
+        return infos
+
+    def destroy(self, instance, network_info, block_device_info=None,
+                cleanup=True):
+        timer = utils.LoopingCall(f=None)
+
+        while True:
+            try:
+                self._conn.destroy_domain(instance['name'])
+                break
+            except Exception as ex:
+                msg = (_("Error encountered when destroying instance "
+                        "'%(name)s': %(ex)s") %
+                        {"name": instance["name"], "ex": ex})
+                LOG.debug(msg)
+                break
+
+        if cleanup:
+            self._cleanup(instance)
+
+        return True
+
+    def _cleanup(self, instance):
+        target = os.path.join(FLAGS.instances_path, instance['name'])
+        instance_name = instance['name']
+        LOG.info(_('instance %(instance_name)s: deleting instance files'
+                ' %(target)s') % locals())
+        if FLAGS.baremetal_type == 'lxc':
+            disk.destroy_container(self.container)
+        if os.path.exists(target):
+            shutil.rmtree(target)
+
+    @exception.wrap_exception
+    def attach_volume(self, instance_name, device_path, mountpoint):
+        raise exception.APIError("attach_volume not supported for baremetal.")
+
+    @exception.wrap_exception
+    def detach_volume(self, instance_name, mountpoint):
+        raise exception.APIError("detach_volume not supported for baremetal.")
+
+    @exception.wrap_exception
+    def snapshot(self, instance, image_id):
+        raise exception.APIError("snapshot not supported for baremetal.")
+
+    @exception.wrap_exception
+    def reboot(self, instance):
+        timer = utils.LoopingCall(f=None)
+
+        def _wait_for_reboot():
+            try:
+                state = self._conn.reboot_domain(instance['name'])
+                if state == power_state.RUNNING:
+                    LOG.debug(_('instance %s: rebooted'), instance['name'])
+                    timer.stop()
+            except:
+                LOG.exception(_('_wait_for_reboot failed'))
+                timer.stop()
+        timer.f = _wait_for_reboot
+        return timer.start(interval=0.5, now=True)
+
+    @exception.wrap_exception
+    def rescue(self, context, instance, network_info):
+        """Loads a VM using rescue images.
+
+        A rescue is normally performed when something goes wrong with the
+        primary images and data needs to be corrected/recovered. Rescuing
+        should not edit or over-ride the original image, only allow for
+        data recovery.
+
+        """
+        self.destroy(instance, False)
+
+        xml_dict = self.to_xml_dict(instance, rescue=True)
+        rescue_images = {'image_id': FLAGS.baremetal_rescue_image_id,
+                         'kernel_id': FLAGS.baremetal_rescue_kernel_id,
+                         'ramdisk_id': FLAGS.baremetal_rescue_ramdisk_id}
+        self._create_image(instance, '.rescue', rescue_images,
+                           network_info=network_info)
+
+        timer = utils.LoopingCall(f=None)
+
+        def _wait_for_rescue():
+            try:
+                state = self._conn.reboot_domain(instance['name'])
+                if state == power_state.RUNNING:
+                    LOG.debug(_('instance %s: rescued'), instance['name'])
+                    timer.stop()
+            except:
+                LOG.exception(_('_wait_for_rescue failed'))
+                timer.stop()
+        timer.f = _wait_for_reboot
+        return timer.start(interval=0.5, now=True)
+
+    @exception.wrap_exception
+    def unrescue(self, instance, network_info):
+        """Reboot the VM which is being rescued back into primary images.
+
+        Because reboot destroys and re-creates instances, unresue should
+        simply call reboot.
+
+        """
+        self.reboot(instance)
+
+    def spawn(self, context, instance, image_meta, network_info,
+              block_device_info=None):
+        LOG.debug(_("<============= spawn of baremetal =============>"))
+
+        def basepath(fname='', suffix=''):
+            return os.path.join(FLAGS.instances_path,
+                                instance['name'],
+                                fname + suffix)
+        bpath = basepath(suffix='')
+        timer = utils.LoopingCall(f=None)
+
+        xml_dict = self.to_xml_dict(instance, network_info)
+        self._create_image(context, instance, xml_dict,
+            network_info=network_info,
+            block_device_info=block_device_info)
+        LOG.debug(_("instance %s: is building"), instance['name'])
+        LOG.debug(_(xml_dict))
+
+        def _wait_for_boot():
+            try:
+                LOG.debug(_("Key is injected but instance is not running yet"))
+                db.instance_update(context, instance['id'],
+                    {'vm_state': vm_states.BUILDING})
+                state = self._conn.create_domain(xml_dict, bpath)
+                if state == power_state.RUNNING:
+                    LOG.debug(_('instance %s: booted'), instance['name'])
+                    db.instance_update(context, instance['id'],
+                            {'vm_state': vm_states.ACTIVE})
+                    LOG.debug(_('~~~~~~ current state = %s ~~~~~~'), state)
+                    LOG.debug(_("instance %s spawned successfully"),
+                            instance['name'])
+                else:
+                    LOG.debug(_('instance %s:not booted'), instance['name'])
+            except Exception as Exn:
+                LOG.debug(_("Bremetal assignment is overcommitted."))
+                db.instance_update(context, instance['id'],
+                           {'vm_state': vm_states.OVERCOMMIT,
+                            'power_state': power_state.SUSPENDED})
+            timer.stop()
+        timer.f = _wait_for_boot
+
+        return timer.start(interval=0.5, now=True)
+
+    def get_console_output(self, instance):
+        console_log = os.path.join(FLAGS.instances_path, instance['name'],
+                                   'console.log')
+
+        libvirt_utils.chown(console_log, os.getuid())
+
+        fd = self._conn.find_domain(instance['name'])
+
+        self.baremetal_nodes.get_console_output(console_log, fd['node_id'])
+
+        fpath = console_log
+
+        return libvirt_utils.load_file(fpath)
+
+    @exception.wrap_exception
+    def get_ajax_console(self, instance):
+        raise NotImplementedError()
+
+    @exception.wrap_exception
+    def get_vnc_console(self, instance):
+        raise NotImplementedError()
+
+    @staticmethod
+    def _cache_image(fn, target, fname, cow=False, *args, **kwargs):
+        """Wrapper for a method that creates an image that caches the image.
+
+        This wrapper will save the image into a common store and create a
+        copy for use by the hypervisor.
+
+        The underlying method should specify a kwarg of target representing
+        where the image will be saved.
+
+        fname is used as the filename of the base image.  The filename needs
+        to be unique to a given image.
+
+        If cow is True, it will make a CoW image instead of a copy.
+        """
+        if not os.path.exists(target):
+            base_dir = os.path.join(FLAGS.instances_path, '_base')
+            if not os.path.exists(base_dir):
+                libvirt_utils.ensure_tree(base_dir)
+            base = os.path.join(base_dir, fname)
+
+            @utils.synchronized(fname)
+            def call_if_not_exists(base, fn, *args, **kwargs):
+                if not os.path.exists(base):
+                    fn(target=base, *args, **kwargs)
+
+            call_if_not_exists(base, fn, *args, **kwargs)
+
+            if cow:
+                libvirt_utils.create_cow_image(base, target)
+            else:
+                libvirt_utils.copy_image(base, target)
+
+    def _fetch_image(self, context, target, image_id, user_id, project_id,
+                     size=None):
+        """Grab image and optionally attempt to resize it"""
+        images.fetch_to_raw(context, image_id, target, user_id, project_id)
+
+    def _create_image(self, context, inst, xml, suffix='',
+                      disk_images=None, network_info=None,
+                      block_device_info=None):
+        if not suffix:
+            suffix = ''
+
+        # syntactic nicety
+        def basepath(fname='', suffix=suffix):
+            return os.path.join(FLAGS.instances_path,
+                                inst['name'],
+                                fname + suffix)
+
+        # ensure directories exist and are writable
+        libvirt_utils.ensure_tree(basepath(suffix=''))
+        utils.execute('chmod', '0777', basepath(suffix=''))
+
+        LOG.info(_('instance %s: Creating image'), inst['name'])
+
+        if FLAGS.baremetal_type == 'lxc':
+            container_dir = '%s/rootfs' % basepath(suffix='')
+            libvirt_utils.ensure_tree(container_dir)
+
+        # NOTE(vish): No need add the suffix to console.log
+        libvirt_utils.write_to_file(basepath('console.log', ''), '', 007)
+
+        if not disk_images:
+            disk_images = {'image_id': inst['image_ref'],
+                           'kernel_id': inst['kernel_id'],
+                           'ramdisk_id': inst['ramdisk_id']}
+
+        if disk_images['kernel_id']:
+            fname = disk_images['kernel_id']
+            self._cache_image(fn=libvirt_utils.fetch_image,
+                              context=context,
+                              target=basepath('kernel'),
+                              fname=fname,
+                              cow=False,
+                              image_id=disk_images['kernel_id'],
+                              user_id=inst['user_id'],
+                              project_id=inst['project_id'])
+            if disk_images['ramdisk_id']:
+                fname = disk_images['ramdisk_id']
+                self._cache_image(fn=libvirt_utils.fetch_image,
+                                  context=context,
+                                  target=basepath('ramdisk'),
+                                  fname=fname,
+                                  cow=False,
+                                  image_id=disk_images['ramdisk_id'],
+                                  user_id=inst['user_id'],
+                                  project_id=inst['project_id'])
+
+        root_fname = hashlib.sha1(str(disk_images['image_id'])).hexdigest()
+        size = inst['root_gb'] * 1024 * 1024 * 1024
+
+        inst_type_id = inst['instance_type_id']
+        inst_type = instance_types.get_instance_type(inst_type_id)
+        if inst_type['name'] == 'm1.tiny' or suffix == '.rescue':
+            size = None
+            root_fname += "_sm"
+        else:
+            root_fname += "_%d" % inst['root_gb']
+
+        self._cache_image(fn=libvirt_utils.fetch_image,
+                          context=context,
+                          target=basepath('root'),
+                          fname=root_fname,
+                          cow=False,  # FLAGS.use_cow_images,
+                          image_id=disk_images['image_id'],
+                          user_id=inst['user_id'],
+                          project_id=inst['project_id'],
+                          size=size)
+
+        # For now, we assume that if we're not using a kernel, we're using a
+        # partitioned disk image where the target partition is the first
+        # partition
+        target_partition = None
+        if not inst['kernel_id']:
+            target_partition = "1"
+
+        if FLAGS.baremetal_type == 'lxc':
+            target_partition = None
+
+        if inst['key_data']:
+            key = str(inst['key_data'])
+        else:
+            key = None
+        net = None
+
+        nets = []
+        ifc_template = open(FLAGS.injected_network_template).read()
+        ifc_num = -1
+        have_injected_networks = False
+        admin_context = nova_context.get_admin_context()
+        for (network_ref, mapping) in network_info:
+            ifc_num += 1
+
+            if not network_ref['injected']:
+                continue
+
+            have_injected_networks = True
+            address = mapping['ips'][0]['ip']
+            netmask = mapping['ips'][0]['netmask']
+            address_v6 = None
+            gateway_v6 = None
+            netmask_v6 = None
+            if FLAGS.use_ipv6:
+                address_v6 = mapping['ip6s'][0]['ip']
+                netmask_v6 = mapping['ip6s'][0]['netmask']
+                gateway_v6 = mapping['gateway_v6']
+            net_info = {'name': 'eth%d' % ifc_num,
+                   'address': address,
+                   'netmask': netmask,
+                   'gateway': mapping['gateway'],
+                   'broadcast': mapping['broadcast'],
+                   'dns': ' '.join(mapping['dns']),
+                   'address_v6': address_v6,
+                   'gateway_v6': gateway_v6,
+                   'netmask_v6': netmask_v6}
+            nets.append(net_info)
+
+        if have_injected_networks:
+            net = str(Template(ifc_template,
+                               searchList=[{'interfaces': nets,
+                                            'use_ipv6': FLAGS.use_ipv6}]))
+
+        metadata = inst.get('metadata')
+        if any((key, net, metadata)):
+            inst_name = inst['name']
+
+            injection_path = basepath('root')
+            img_id = inst.image_ref
+            disable_auto_fsck = True
+
+            for injection in ('metadata', 'key', 'net'):
+                if locals()[injection]:
+                    LOG.info(_('instance %(inst_name)s: injecting '
+                               '%(injection)s into image %(img_id)s'
+                               % locals()))
+            try:
+                disk.inject_data(injection_path, key, net, metadata,
+                                 partition=target_partition,
+                                 use_cow=False,  # FLAGS.use_cow_images,
+                                 disable_auto_fsck=disable_auto_fsck)
+
+            except Exception as e:
+                # This could be a windows image, or a vmdk format disk
+                LOG.warn(_('instance %(inst_name)s: ignoring error injecting'
+                        ' data into image %(img_id)s (%(e)s)') % locals())
+
+    def _prepare_xml_info(self, instance, network_info, rescue,
+                          block_device_info=None):
+        # block_device_mapping = driver.block_device_info_get_mapping(
+        #    block_device_info)
+        map = 0
+        for (network, mapping) in network_info:
+            map += 1
+
+        nics = []
+        # FIXME(vish): stick this in db
+        inst_type_id = instance['instance_type_id']
+        inst_type = instance_types.get_instance_type(inst_type_id)
+
+        driver_type = 'raw'
+
+        xml_info = {'type': FLAGS.baremetal_type,
+                    'name': instance['name'],
+                    'basepath': os.path.join(FLAGS.instances_path,
+                                             instance['name']),
+                    'memory_kb': inst_type['memory_mb'] * 1024,
+                    'vcpus': inst_type['vcpus'],
+                    'rescue': rescue,
+                    'driver_type': driver_type,
+                    'nics': nics,
+                    'ip_address': mapping['ips'][0]['ip'],
+                    'mac_address': mapping['mac'],
+                    'user_data': instance['user_data'],
+                    'image_id': instance['image_ref'],
+                    'kernel_id': instance['kernel_id'],
+                    'ramdisk_id': instance['ramdisk_id']}
+
+        if not rescue:
+            if instance['kernel_id']:
+                xml_info['kernel'] = xml_info['basepath'] + "/kernel"
+
+            if instance['ramdisk_id']:
+                xml_info['ramdisk'] = xml_info['basepath'] + "/ramdisk"
+
+            xml_info['disk'] = xml_info['basepath'] + "/disk"
+        return xml_info
+
+    def to_xml_dict(self, instance, rescue=False, network_info=None):
+        LOG.debug(_('instance %s: starting toXML method'), instance['name'])
+        xml_info = self._prepare_xml_info(instance, rescue, network_info)
+        LOG.debug(_('instance %s: finished toXML method'), instance['name'])
+        return xml_info
+
+    def get_info(self, instance_name):
+        """Retrieve information from baremetal for a specific instance name.
+
+        If a baremetal error is encountered during lookup, we might raise a
+        NotFound exception or Error exception depending on how severe the
+        baremetal error is.
+
+        """
+        (state, max_mem, mem, num_cpu, cpu_time) \
+                = self._conn.get_domain_info(instance_name)
+        return {'state': state,
+                'max_mem': max_mem,
+                'mem': mem,
+                'num_cpu': num_cpu,
+                'cpu_time': cpu_time}
+
+    def _create_new_domain(self, persistent=True, launch_flags=0):
+        raise NotImplementedError()
+
+    def get_diagnostics(self, instance_name):
+        raise exception.ApiError(_("diagnostics are not supported "
+                                   "for baremetal"))
+
+    def get_disks(self, instance_name):
+        raise NotImplementedError()
+
+    def get_interfaces(self, instance_name):
+        raise NotImplementedError()
+
+    def get_vcpu_total(self):
+        """Get vcpu number of physical computer.
+
+        :returns: the number of cpu core.
+
+        """
+
+        # On certain platforms, this will raise a NotImplementedError.
+        try:
+            return self.baremetal_nodes.get_hw_info('vcpus')
+        except NotImplementedError:
+            LOG.warn(_("Cannot get the number of cpu, because this "
+                       "function is not implemented for this platform. "
+                       "This error can be safely ignored for now."))
+            return False
+
+    def get_memory_mb_total(self):
+        """Get the total memory size(MB) of physical computer.
+
+        :returns: the total amount of memory(MB).
+
+        """
+        return self.baremetal_nodes.get_hw_info('memory_mb')
+
+    def get_local_gb_total(self):
+        """Get the total hdd size(GB) of physical computer.
+
+        :returns:
+            The total amount of HDD(GB).
+            Note that this value shows a partition where
+            NOVA-INST-DIR/instances mounts.
+
+        """
+        return self.baremetal_nodes.get_hw_info('local_gb')
+
+    def get_vcpu_used(self):
+        """ Get vcpu usage number of physical computer.
+
+        :returns: The total number of vcpu that currently used.
+
+        """
+
+        total = 0
+        for dom_id in self._conn.list_domains():
+            total += 1
+        return total
+
+    def get_memory_mb_used(self):
+        """Get the free memory size(MB) of physical computer.
+
+        :returns: the total usage of memory(MB).
+
+        """
+        return self.baremetal_nodes.get_hw_info('memory_mb_used')
+
+    def get_local_gb_used(self):
+        """Get the free hdd size(GB) of physical computer.
+
+        :returns:
+           The total usage of HDD(GB).
+           Note that this value shows a partition where
+           NOVA-INST-DIR/instances mounts.
+
+        """
+        return self.baremetal_nodes.get_hw_info('local_gb_used')
+
+    def get_hypervisor_type(self):
+        """Get hypervisor type.
+
+        :returns: hypervisor type (ex. qemu)
+
+        """
+        return self.baremetal_nodes.get_hw_info('hypervisor_type')
+
+    def get_hypervisor_version(self):
+        """Get hypervisor version.
+
+        :returns: hypervisor version (ex. 12003)
+
+        """
+        return self.baremetal_nodes.get_hw_info('hypervisor_version')
+
+    def get_cpu_info(self):
+        """Get cpuinfo information.
+
+        Obtains cpu feature from virConnect.getCapabilities,
+        and returns as a json string.
+
+        :return: see above description
+
+        """
+        return self.baremetal_nodes.get_hw_info('cpu_info')
+
+    def block_stats(self, instance_name, disk):
+        raise NotImplementedError()
+
+    def interface_stats(self, instance_name, interface):
+        raise NotImplementedError()
+
+    def get_console_pool_info(self, console_type):
+        #TODO(mdragon): console proxy should be implemented for baremetal,
+        #               in case someone wants to use it.
+        #               For now return fake data.
+        return  {'address': '127.0.0.1',
+                 'username': 'fakeuser',
+                 'password': 'fakepassword'}
+
+    def refresh_security_group_rules(self, security_group_id):
+        # Bare metal doesn't currently support security groups
+        pass
+
+    def refresh_security_group_members(self, security_group_id):
+        # Bare metal doesn't currently support security groups
+        pass
+
+    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 compare_cpu(self, cpu_info):
+        raise NotImplementedError()
+
+    def ensure_filtering_rules_for_instance(self, instance_ref,
+                                            time=None):
+        raise NotImplementedError()
+
+    def live_migration(self, ctxt, instance_ref, dest,
+                       post_method, recover_method):
+        raise NotImplementedError()
+
+    def unfilter_instance(self, instance_ref):
+        """See comments of same method in firewall_driver."""
+        pass
+
+    def update_host_status(self):
+        """Update the status info of the host, and return those values
+            to the calling program."""
+        return self.HostState.update_status()
+
+    def get_host_stats(self, refresh=False):
+        """Return the current state of the host. If 'refresh' is
+           True, run the update first."""
+        LOG.debug(_("Updating!"))
+        return self.HostState.get_host_stats(refresh=refresh)
+
+
+class HostState(object):
+    """Manages information about the XenServer host this compute
+    node is running on.
+    """
+
+    def __init__(self, read_only):
+        super(HostState, self).__init__()
+        self.read_only = read_only
+        self._stats = {}
+        self.update_status()
+
+    def get_host_stats(self, refresh=False):
+        """Return the current state of the host. If 'refresh' is
+        True, run the update first.
+        """
+        if refresh:
+            self.update_status()
+        return self._stats
+
+    def update_status(self):
+        """
+        We can get host status information.
+        """
+        LOG.debug(_("Updating host stats"))
+        connection = get_connection(self.read_only)
+        data = {}
+        data["vcpus"] = connection.get_vcpu_total()
+        data["vcpus_used"] = connection.get_vcpu_used()
+        data["cpu_info"] = connection.get_cpu_info()
+        data["cpu_arch"] = FLAGS.cpu_arch
+        data["xpus"] = FLAGS.xpus
+        data["xpu_arch"] = FLAGS.xpu_arch
+        data["xpu_info"] = FLAGS.xpu_info
+        data["net_arch"] = FLAGS.net_arch
+        data["net_info"] = FLAGS.net_info
+        data["net_mbps"] = FLAGS.net_mbps
+        data["disk_total"] = connection.get_local_gb_total()
+        data["disk_used"] = connection.get_local_gb_used()
+        data["disk_available"] = data["disk_total"] - data["disk_used"]
+        data["host_memory_total"] = connection.get_memory_mb_total()
+        data["host_memory_free"] = data["host_memory_total"] - \
+            connection.get_memory_mb_used()
+        data["hypervisor_type"] = connection.get_hypervisor_type()
+        data["hypervisor_version"] = connection.get_hypervisor_version()
+        self._stats = data

nova/virt/baremetal/tilera.py

@@ -0,0 +1,368 @@
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+
+# Copyright (c) 2011 University of Southern California
+#
+#    Licensed under the Apache License, Version 2.0 (the "License"); you may
+#    not use this file except in compliance with the License. You may obtain
+#    a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#    License for the specific language governing permissions and limitations
+#    under the License.
+
+"""
+Tilera back-end for bare-metal compute node provisioning
+
+The details of this implementation are specific to ISI's testbed. This code
+is provided here as an example of how to implement a backend.
+"""
+
+import base64
+import os
+import subprocess
+import time
+
+from nova.compute import power_state
+from nova.openstack.common import cfg
+from nova import exception
+from nova import flags
+from nova import log as logging
+from nova import utils
+
+FLAGS = flags.FLAGS
+
+global_opts = [
+    cfg.StrOpt('tile_monitor',
+               default='/usr/local/TileraMDE/bin/tile-monitor',
+               help='Tilera command line program for Bare-metal driver')
+    ]
+
+FLAGS.add_options(global_opts)
+
+LOG = logging.getLogger('nova.virt.tilera')
+
+
+def get_baremetal_nodes():
+    return BareMetalNodes()
+
+
+class BareMetalNodes(object):
+    """
+    This manages node information and implements singleton.
+
+    BareMetalNodes class handles machine architectures of interest to
+    technical computing users have either poor or non-existent support
+    for virtualization.
+    """
+
+    _instance = None
+    _is_init = False
+
+    def __new__(cls, *args, **kwargs):
+        """
+        Returns the BareMetalNodes singleton.
+        """
+        if not cls._instance or ('new' in kwargs and kwargs['new']):
+            cls._instance = super(BareMetalNodes, cls).__new__(cls)
+        return cls._instance
+
+    def __init__(self, file_name="/tftpboot/tilera_boards"):
+        """
+        Only call __init__ the first time object is instantiated.
+
+        From the bare-metal node list file: /tftpboot/tilera_boards,
+        reads each item of each node such as node ID, IP address,
+        MAC address, vcpus, memory, hdd, hypervisor type/version, and cpu
+        and appends each node information into nodes list.
+        """
+        if self._is_init:
+            return
+        self._is_init = True
+
+        self.nodes = []
+        self.BOARD_ID = 0
+        self.IP_ADDR = 1
+        self.MAC_ADDR = 2
+        self.VCPUS = 3
+        self.MEMORY_MB = 4
+        self.LOCAL_GB = 5
+        self.MEMORY_MB_USED = 6
+        self.LOCAL_GB_USED = 7
+        self.HYPERVISOR_TYPE = 8
+        self.HYPERVISOR_VER = 9
+        self.CPU_INFO = 10
+
+        fp = open(file_name, "r")
+        for item in fp:
+            l = item.split()
+            if l[0] == '#':
+                continue
+            l_d = {'node_id': int(l[self.BOARD_ID]),
+                    'ip_addr': l[self.IP_ADDR],
+                    'mac_addr': l[self.MAC_ADDR],
+                    'status': power_state.NOSTATE,
+                    'vcpus': int(l[self.VCPUS]),
+                    'memory_mb': int(l[self.MEMORY_MB]),
+                    'local_gb': int(l[self.LOCAL_GB]),
+                    'memory_mb_used': int(l[self.MEMORY_MB_USED]),
+                    'local_gb_used': int(l[self.LOCAL_GB_USED]),
+                    'hypervisor_type': l[self.HYPERVISOR_TYPE],
+                    'hypervisor_version': int(l[self.HYPERVISOR_VER]),
+                    'cpu_info': l[self.CPU_INFO]}
+            self.nodes.append(l_d)
+        fp.close()
+
+    def get_hw_info(self, field):
+        """
+        Returns hardware information of bare-metal node by the given field.
+
+        Given field can be vcpus, memory_mb, local_gb, memory_mb_used,
+        local_gb_used, hypervisor_type, hypervisor_version, and cpu_info.
+        """
+        for node in self.nodes:
+            if node['node_id'] == 9:
+                if field == 'vcpus':
+                    return node['vcpus']
+                elif field == 'memory_mb':
+                    return node['memory_mb']
+                elif field == 'local_gb':
+                    return node['local_gb']
+                elif field == 'memory_mb_used':
+                    return node['memory_mb_used']
+                elif field == 'local_gb_used':
+                    return node['local_gb_used']
+                elif field == 'hypervisor_type':
+                    return node['hypervisor_type']
+                elif field == 'hypervisor_version':
+                    return node['hypervisor_version']
+                elif field == 'cpu_info':
+                    return node['cpu_info']
+
+    def set_status(self, node_id, status):
+        """
+        Sets status of the given node by the given status.
+
+        Returns 1 if the node is in the nodes list.
+        """
+        for node in self.nodes:
+            if node['node_id'] == node_id:
+                node['status'] = status
+                return True
+        return False
+
+    def get_status(self):
+        """
+        Gets status of the given node.
+        """
+        pass
+
+    def get_idle_node(self):
+        """
+        Gets an idle node, sets the status as 1 (RUNNING) and Returns node ID.
+        """
+        for item in self.nodes:
+            if item['status'] == 0:
+                item['status'] = 1      # make status RUNNING
+                return item['node_id']
+        raise exception.NotFound("No free nodes available")
+
+    def get_ip_by_id(self, id):
+        """
+        Returns default IP address of the given node.
+        """
+        for item in self.nodes:
+            if item['node_id'] == id:
+                return item['ip_addr']
+
+    def free_node(self, node_id):
+        """
+        Sets/frees status of the given node as 0 (IDLE).
+        """
+        LOG.debug(_("free_node...."))
+        for item in self.nodes:
+            if item['node_id'] == str(node_id):
+                item['status'] = 0  # make status IDLE
+
+    def power_mgr(self, node_id, mode):
+        """
+        Changes power state of the given node.
+
+        According to the mode (1-ON, 2-OFF, 3-REBOOT), power state can be
+        changed. /tftpboot/pdu_mgr script handles power management of
+        PDU (Power Distribution Unit).
+        """
+        if node_id < 5:
+            pdu_num = 1
+            pdu_outlet_num = node_id + 5
+        else:
+            pdu_num = 2
+            pdu_outlet_num = node_id
+        path1 = "10.0.100." + str(pdu_num)
+        utils.execute('/tftpboot/pdu_mgr', path1, str(pdu_outlet_num), \
+            str(mode), '>>', 'pdu_output')
+
+    def deactivate_node(self, node_id):
+        """
+        Deactivates the given node by turnning it off.
+
+        /tftpboot/fs_x directory is a NFS of node#x
+        and /tftpboot/root_x file is an file system image of node#x.
+        """
+        node_ip = self.get_ip_by_id(node_id)
+        LOG.debug(_("deactivate_node is called for \
+               node_id = %(id)s node_ip = %(ip)s"),
+               {'id': str(node_id), 'ip': node_ip})
+        for item in self.nodes:
+            if item['node_id'] == node_id:
+                LOG.debug(_("status of node is set to 0"))
+                item['status'] = 0
+        self.power_mgr(node_id, 2)
+        self.sleep_mgr(5)
+        path = "/tftpboot/fs_" + str(node_id)
+        pathx = "/tftpboot/root_" + str(node_id)
+        utils.execute('sudo', '/usr/sbin/rpc.mountd')
+        try:
+            utils.execute('sudo', 'umount', '-f', pathx)
+            utils.execute('sudo', 'rm', '-f', pathx)
+        except:
+            LOG.debug(_("rootfs is already removed"))
+
+    def network_set(self, node_ip, mac_address, ip_address):
+        """
+        Sets network configuration based on the given ip and mac address.
+
+        User can access the bare-metal node using ssh.
+        """
+        cmd = FLAGS.tile_monitor + \
+            " --resume --net " + node_ip + " --run - " + \
+            "ifconfig xgbe0 hw ether " + mac_address + \
+            " - --wait --run - ifconfig xgbe0 " + ip_address + \
+            " - --wait --quit"
+        subprocess.Popen(cmd, shell=True)
+        #utils.execute(cmd, shell=True)
+        self.sleep_mgr(5)
+
+    def iptables_set(self, node_ip, user_data):
+        """
+        Sets security setting (iptables:port) if needed.
+
+        iptables -A INPUT -p tcp ! -s $IP --dport $PORT -j DROP
+        /tftpboot/iptables_rule script sets iptables rule on the given node.
+        """
+        if user_data != '':
+            open_ip = base64.b64decode(user_data)
+            utils.execute('/tftpboot/iptables_rule', node_ip, open_ip)
+
+    def check_activated(self, node_id, node_ip):
+        """
+        Checks whether the given node is activated or not.
+        """
+        LOG.debug(_("Before ping to the bare-metal node"))
+        tile_output = "/tftpboot/tile_output_" + str(node_id)
+        grep_cmd = "ping -c1 " + node_ip + " | grep Unreachable > " \
+                   + tile_output
+        subprocess.Popen(grep_cmd, shell=True)
+        self.sleep_mgr(5)
+
+        file = open(tile_output, "r")
+        out_msg = file.readline().find("Unreachable")
+        utils.execute('sudo', 'rm', tile_output)
+        if out_msg == -1:
+            cmd = "TILERA_BOARD_#" + str(node_id) + " " + node_ip \
+                + " is ready"
+            LOG.debug(_(cmd))
+            return True
+        else:
+            cmd = "TILERA_BOARD_#" + str(node_id) + " " \
+                + node_ip + " is not ready, out_msg=" + out_msg
+            LOG.debug(_(cmd))
+            self.power_mgr(node_id, 2)
+            return False
+
+    def vmlinux_set(self, node_id, mode):
+        """
+        Sets kernel into default path (/tftpboot) if needed.
+
+        From basepath to /tftpboot, kernel is set based on the given mode
+        such as 0-NoSet, 1-SetVmlinux, or 9-RemoveVmlinux.
+        """
+        cmd = "Noting to do for tilera nodes: vmlinux is in CF"
+        LOG.debug(_(cmd))
+
+    def sleep_mgr(self, time_in_seconds):
+        """
+        Sleeps until the node is activated.
+        """
+        time.sleep(time_in_seconds)
+
+    def ssh_set(self, node_ip):
+        """
+        Sets and Runs sshd in the node.
+        """
+        cmd = FLAGS.tile_monitor + \
+            " --resume --net " + node_ip + " --run - " + \
+            "/usr/sbin/sshd - --wait --quit"
+        subprocess.Popen(cmd, shell=True)
+        self.sleep_mgr(5)
+
+    def activate_node(self, node_id, node_ip, name, mac_address, \
+                      ip_address, user_data):
+        """
+        Activates the given node using ID, IP, and MAC address.
+        """
+        LOG.debug(_("activate_node"))
+
+        self.power_mgr(node_id, 2)
+        self.power_mgr(node_id, 3)
+        self.sleep_mgr(100)
+
+        try:
+            self.check_activated(node_id, node_ip)
+            self.network_set(node_ip, mac_address, ip_address)
+            self.ssh_set(node_ip)
+            self.iptables_set(node_ip, user_data)
+            return power_state.RUNNING
+        except Exception as ex:
+            self.deactivate_node(node_id)
+            raise exception.Error(_("Node is unknown error state."))
+
+    def get_console_output(self, console_log, node_id):
+        """
+        Gets console output of the given node.
+        """
+        node_ip = self.get_ip_by_id(node_id)
+        log_path = "/tftpboot/log_" + str(node_id)
+        kmsg_cmd = FLAGS.tile_monitor + \
+                   " --resume --net " + node_ip + \
+                   " -- dmesg > " + log_path
+        subprocess.Popen(kmsg_cmd, shell=True)
+        self.sleep_mgr(5)
+        utils.execute('cp', log_path, console_log)
+
+    def get_image(self, bp):
+        """
+        Gets the bare-metal file system image into the instance path.
+
+        Noting to do for tilera nodes: actual image is used.
+        """
+        path_fs = "/tftpboot/tilera_fs"
+        path_root = bp + "/root"
+        utils.execute('cp', path_fs, path_root)
+
+    def set_image(self, bpath, node_id):
+        """
+        Sets the PXE bare-metal file system from the instance path.
+
+        This should be done after ssh key is injected.
+        /tftpboot/fs_x directory is a NFS of node#x.
+        /tftpboot/root_x file is an file system image of node#x.
+        """
+        path1 = bpath + "/root"
+        pathx = "/tftpboot/root_" + str(node_id)
+        path2 = "/tftpboot/fs_" + str(node_id)
+        utils.execute('sudo', 'mv', path1, pathx)
+        utils.execute('sudo', 'mount', '-o', 'loop', pathx, path2)

nova/virt/connection.py

@@ -34,6 +34,13 @@ from nova.virt import xenapi_conn
 LOG = logging.getLogger("nova.virt.connection")
 FLAGS = flags.FLAGS
 
+"""
+In case of baremetal (FLAGS.connection_type),
+specific driver is set by FLAGS.baremetal_driver
+"""
+if FLAGS.connection_type == 'baremetal':
+    from nova.virt.baremetal import proxy
+
 
 def get_connection(read_only=False):
     """
@@ -69,6 +76,8 @@ def get_connection(read_only=False):
         conn = xenapi_conn.get_connection(read_only)
     elif t == 'vmwareapi':
         conn = vmwareapi_conn.get_connection(read_only)
+    elif t == 'baremetal':
+        conn = proxy.get_connection(read_only)
     else:
         raise Exception('Unknown connection type "%s"' % t)