Add ManagementInterface

Add a new driver ManagementInterface for management related actions,
the new interface contains the following methods:

* validate() - To validate driver-specific management information. (E.g
  if the node has the right credentials already set)

* set_boot_device() - To set the boot device for a node.

* get_boot_device() - To get the current boot device of a node.

* get_supported_boot_devices() - To get a list of the supported boot
  devices by that driver.

A new file common/boot_devices.py which contains the standardized names
for the acceptable boot devices, the names are based on the IPMITool
names (the default power driver). The idea is that clients won't need to
know the specific boot device names for each driver, drivers which have
different name options than the IPMITool have to translate it internally.

As part of the work to add tests to the FakeManagement interface, other
tests in test_fake.py were modified in order to remove the DB calls.

blueprint: promote-set-boot-device
Change-Id: If2e8074f2e0fbcf962d224024347a0319ac174cf

ironic/common/boot_devices.py

@@ -0,0 +1,42 @@
+# Copyright 2014 Red Hat, Inc.
+# All Rights Reserved.
+#
+#    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.
+
+
+"""
+Mapping of boot devices used when requesting the system to boot
+from an alternate device.
+
+The options presented were based on the IPMItool chassis
+bootdev command. You can find the documentation at:
+http://linux.die.net/man/1/ipmitool
+
+NOTE: This module does not include all the options from ipmitool because
+they don't make sense in the limited context of Ironic right now.
+"""
+
+PXE = 'pxe'
+"Boot from PXE boot"
+
+DISK = 'disk'
+"Boot from default Hard-drive"
+
+CDROM = 'cdrom'
+"Boot from CD/DVD"
+
+BIOS = 'bios'
+"Boot into BIOS setup"
+
+SAFE = 'safe'
+"Boot from default Hard-drive, request Safe Mode"

ironic/drivers/base.py

@@ -69,6 +69,14 @@ class BaseDriver(object):
     May be None, if unsupported by a driver.
     """
 
+    management = None
+    """`Standard` attribute for management related features.
+
+    A reference to an instance of :class:ManagementInterface.
+    May be None, if unsupported by a driver.
+    """
+    standard_interfaces.append('management')
+
     vendor = None
     """Attribute for accessing any vendor-specific extensions.
 
@@ -348,3 +356,55 @@ class VendorInterface(object):
         raise exception.UnsupportedDriverExtension(
             _('Vendor interface does not support driver vendor_passthru '
               'method: %s') % method)
+
+
+@six.add_metaclass(abc.ABCMeta)
+class ManagementInterface(object):
+    """Interface for management related actions."""
+
+    # TODO(lucasagomes): The 'node' parameter
+    # needs to be passed to validate() because of the
+    # ConductorManager.validate_driver_interfaces(). Remove it as part of
+    # https://bugs.launchpad.net/ironic/+bug/1312632.
+    @abc.abstractmethod
+    def validate(self, task, node):
+        """Validate the driver-specific management information.
+
+        :param task: a task from TaskManager.
+        :param node: a single Node to validate.
+        :raises: InvalidParameterValue
+        """
+
+    @abc.abstractmethod
+    def get_supported_boot_devices(self):
+        """Get a list of the supported boot devices.
+
+        :returns: A list with the supported boot devices defined
+                  in :mod:`ironic.common.boot_devices`.
+        """
+
+    @abc.abstractmethod
+    def set_boot_device(self, task, device, **kwargs):
+        """Set the boot device for a node.
+
+        Set the boot device to use on next reboot of the node.
+
+        :param task: a task from TaskManager.
+        :param device: the boot device, one of
+                       :mod:`ironic.common.boot_devices`.
+        :param kwargs: extra driver-specific parameters.
+        :raises: InvalidParameterValue if an invalid boot device is
+                 specified.
+        """
+
+    @abc.abstractmethod
+    def get_boot_device(self, task):
+        """Get the current boot device for a node.
+
+        Provides the current boot device of the node. Be aware that not
+        all drivers support this.
+
+        :param task: a task from TaskManager.
+        :returns: the boot device, one of :mod:`ironic.common.boot_devices`
+                  or None if it is unknown.
+        """

ironic/drivers/fake.py

@@ -42,6 +42,7 @@ class FakeDriver(base.BaseDriver):
                         'second_method': self.b}
         self.vendor = utils.MixinVendorInterface(self.mapping)
         self.console = fake.FakeConsole()
+        self.management = fake.FakeManagement()
 
 
 class FakeIPMIToolDriver(base.BaseDriver):

ironic/drivers/modules/fake.py

@@ -24,6 +24,7 @@ functionality between a power interface and a deploy interface, when both rely
 on seprate vendor_passthru methods.
 """
 
+from ironic.common import boot_devices
 from ironic.common import exception
 from ironic.common import states
 from ironic.drivers import base
@@ -143,3 +144,21 @@ class FakeConsole(base.ConsoleInterface):
 
     def get_console(self, task, node):
         return {}
+
+
+class FakeManagement(base.ManagementInterface):
+    """Example implementation of a simple management interface."""
+
+    def validate(self, task, node):
+        return True
+
+    def get_supported_boot_devices(self):
+        return [boot_devices.PXE]
+
+    def set_boot_device(self, task, device, **kwargs):
+        if device not in self.get_supported_boot_devices():
+            raise exception.InvalidParameterValue(_(
+                "Invalid boot device %s specified.") % device)
+
+    def get_boot_device(self, task):
+        return boot_devices.PXE

ironic/tests/conductor/test_manager.py

@@ -752,6 +752,7 @@ class ManagerTestCase(tests_db_base.DbTestCase):
                                                       node['uuid'])
         expected = {'console': {'result': True},
                     'power': {'result': True},
+                    'management': {'result': True},
                     'deploy': {'result': True}}
         self.assertEqual(expected, ret)
 

ironic/tests/drivers/test_fake.py

@@ -17,16 +17,18 @@
 
 """Test class for Fake driver."""
 
+import mock
+
+from ironic.common import boot_devices
 from ironic.common import driver_factory
 from ironic.common import exception
 from ironic.common import states
 from ironic.conductor import task_manager
-from ironic.db import api as db_api
 from ironic.drivers import base as driver_base
 from ironic.openstack.common import context
 from ironic.tests import base
 from ironic.tests.conductor import utils as mgr_utils
-from ironic.tests.db import utils as db_utils
+from ironic.tests.objects import utils as obj_utils
 
 
 class FakeDriverTestCase(base.TestCase):
@@ -34,11 +36,13 @@ class FakeDriverTestCase(base.TestCase):
     def setUp(self):
         super(FakeDriverTestCase, self).setUp()
         self.context = context.get_admin_context()
-        self.dbapi = db_api.get_instance()
         mgr_utils.mock_the_extension_manager()
         self.driver = driver_factory.get_driver("fake")
-        db_node = db_utils.get_test_node()
-        self.node = self.dbapi.create_node(db_node)
+        self.node = obj_utils.get_test_node(self.context)
+        self.task = mock.Mock(spec=task_manager.TaskManager)
+        self.task.shared = False
+        self.task.node = self.node
+        self.task.driver = self.driver
 
     def test_driver_interfaces(self):
         # fake driver implements only 3 out of 5 interfaces
@@ -50,15 +54,14 @@ class FakeDriverTestCase(base.TestCase):
         self.assertIsNone(self.driver.rescue)
 
     def test_power_interface(self):
-        with task_manager.acquire(self.context,
-                                  [self.node.uuid]) as task:
-            self.driver.power.validate(task, self.node)
-            self.driver.power.get_power_state(task, self.node)
-            self.assertRaises(exception.InvalidParameterValue,
-                              self.driver.power.set_power_state,
-                              task, self.node, states.NOSTATE)
-            self.driver.power.set_power_state(task, self.node, states.POWER_ON)
-            self.driver.power.reboot(task, self.node)
+        self.driver.power.validate(self.task, self.node)
+        self.driver.power.get_power_state(self.task, self.node)
+        self.assertRaises(exception.InvalidParameterValue,
+                          self.driver.power.set_power_state,
+                          self.task, self.node, states.NOSTATE)
+        self.driver.power.set_power_state(self.task, self.node,
+                                          states.POWER_ON)
+        self.driver.power.reboot(self.task, self.node)
 
     def test_deploy_interface(self):
         self.driver.deploy.validate(None, self.node)
@@ -70,3 +73,23 @@ class FakeDriverTestCase(base.TestCase):
 
         self.driver.deploy.clean_up(None, None)
         self.driver.deploy.tear_down(None, None)
+
+    def test_management_interface_validate(self):
+        self.driver.management.validate(self.task, self.node)
+
+    def test_management_interface_set_boot_device_good(self):
+            self.driver.management.set_boot_device(self.task, boot_devices.PXE)
+
+    def test_management_interface_set_boot_device_fail(self):
+        self.assertRaises(exception.InvalidParameterValue,
+                          self.driver.management.set_boot_device, self.task,
+                          'not-supported')
+
+    def test_management_interface_get_supported_boot_devices(self):
+        expected = [boot_devices.PXE]
+        self.assertEqual(expected,
+                         self.driver.management.get_supported_boot_devices())
+
+    def test_management_interface_get_boot_device(self):
+        self.assertEqual(boot_devices.PXE,
+                         self.driver.management.get_boot_device(self.task))