Add baremetal data model

Change-Id: I57b7bb53b3bc84ad383ae485069274f5c5362c50
Implements: blueprint build-baremetal-data-model-in-watcher

watcher/decision_engine/model/collector/ironic.py

@@ -0,0 +1,97 @@
+# -*- encoding: utf-8 -*-
+# Copyright (c) 2017 ZTE Corporation
+#
+# Authors:Yumeng Bao <bao.yumeng@zte.com.cn>
+#
+# 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 oslo_log import log
+
+from watcher.common import ironic_helper
+from watcher.decision_engine.model.collector import base
+from watcher.decision_engine.model import element
+from watcher.decision_engine.model import model_root
+
+LOG = log.getLogger(__name__)
+
+
+class BaremetalClusterDataModelCollector(base.BaseClusterDataModelCollector):
+    """Baremetal cluster data model collector
+
+    The Baremetal cluster data model collector creates an in-memory
+    representation of the resources exposed by the baremetal service.
+    """
+
+    def __init__(self, config, osc=None):
+        super(BaremetalClusterDataModelCollector, self).__init__(config, osc)
+
+    @property
+    def notification_endpoints(self):
+        """Associated notification endpoints
+
+        :return: Associated notification endpoints
+        :rtype: List of :py:class:`~.EventsNotificationEndpoint` instances
+        """
+        return None
+
+    def get_audit_scope_handler(self, audit_scope):
+        return None
+
+    def execute(self):
+        """Build the baremetal cluster data model"""
+        LOG.debug("Building latest Baremetal cluster data model")
+
+        builder = ModelBuilder(self.osc)
+        return builder.execute()
+
+
+class ModelBuilder(object):
+    """Build the graph-based model
+
+    This model builder adds the following data"
+
+    - Baremetal-related knowledge (Ironic)
+    """
+    def __init__(self, osc):
+        self.osc = osc
+        self.model = model_root.BaremetalModelRoot()
+        self.ironic_helper = ironic_helper.IronicHelper(osc=self.osc)
+
+    def add_ironic_node(self, node):
+        # Build and add base node.
+        ironic_node = self.build_ironic_node(node)
+        self.model.add_node(ironic_node)
+
+    def build_ironic_node(self, node):
+        """Build a Baremetal node from a Ironic node
+
+        :param node: A ironic node
+        :type node: :py:class:`~ironicclient.v1.node.Node`
+        """
+        # build up the ironic node.
+        node_attributes = {
+            "uuid": node.uuid,
+            "power_state": node.power_state,
+            "maintenance": node.maintenance,
+            "maintenance_reason": node.maintenance_reason,
+            "extra": {"compute_node_id": node.extra.compute_node_id}
+            }
+
+        ironic_node = element.IronicNode(**node_attributes)
+        return ironic_node
+
+    def execute(self):
+
+        for node in self.ironic_helper.get_ironic_node_list():
+            self.add_ironic_node(node)
+        return self.model

watcher/decision_engine/model/element/__init__.py

@@ -23,6 +23,7 @@ from watcher.decision_engine.model.element import volume
 ServiceState = node.ServiceState
 ComputeNode = node.ComputeNode
 StorageNode = node.StorageNode
+IronicNode = node.IronicNode
 Pool = node.Pool
 
 InstanceState = instance.InstanceState
@@ -37,4 +38,5 @@ __all__ = ['ServiceState',
            'StorageNode',
            'Pool',
            'VolumeState',
-           'Volume']
+           'Volume',
+           'IronicNode']

watcher/decision_engine/model/element/baremetal_resource.py

@@ -0,0 +1,33 @@
+# -*- encoding: utf-8 -*-
+# Copyright (c) 2017 ZTE Corporation
+#
+# 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 abc
+
+import six
+
+from watcher.decision_engine.model.element import base
+from watcher.objects import fields as wfields
+
+
+@six.add_metaclass(abc.ABCMeta)
+class BaremetalResource(base.Element):
+
+    VERSION = '1.0'
+
+    fields = {
+        "uuid": wfields.StringField(),
+        "human_id": wfields.StringField(default=""),
+    }

watcher/decision_engine/model/element/node.py

@@ -16,6 +16,7 @@
 
 import enum
 
+from watcher.decision_engine.model.element import baremetal_resource
 from watcher.decision_engine.model.element import compute_resource
 from watcher.decision_engine.model.element import storage_resource
 from watcher.objects import base
@@ -78,3 +79,17 @@ class Pool(storage_resource.StorageResource):
 
     def accept(self, visitor):
         raise NotImplementedError()
+
+
+@base.WatcherObjectRegistry.register_if(False)
+class IronicNode(baremetal_resource.BaremetalResource):
+
+    fields = {
+        "power_state": wfields.StringField(),
+        "maintenance": wfields.BooleanField(),
+        "maintenance_reason": wfields.StringField(),
+        "extra": wfields.DictField()
+    }
+
+    def accept(self, visitor):
+        raise NotImplementedError()

watcher/decision_engine/model/model_root.py

@@ -545,3 +545,85 @@ class StorageModelRoot(nx.DiGraph, base.Model):
     def is_isomorphic(cls, G1, G2):
         return nx.algorithms.isomorphism.isomorph.is_isomorphic(
             G1, G2)
+
+
+class BaremetalModelRoot(nx.DiGraph, base.Model):
+
+    """Cluster graph for an Openstack cluster: Baremetal Cluster."""
+
+    def __init__(self, stale=False):
+        super(BaremetalModelRoot, self).__init__()
+        self.stale = stale
+
+    def __nonzero__(self):
+        return not self.stale
+
+    __bool__ = __nonzero__
+
+    @staticmethod
+    def assert_node(obj):
+        if not isinstance(obj, element.IronicNode):
+            raise exception.IllegalArgumentException(
+                message=_("'obj' argument type is not valid: %s") % type(obj))
+
+    @lockutils.synchronized("baremetal_model")
+    def add_node(self, node):
+        self.assert_node(node)
+        super(BaremetalModelRoot, self).add_node(node.uuid, node)
+
+    @lockutils.synchronized("baremetal_model")
+    def remove_node(self, node):
+        self.assert_node(node)
+        try:
+            super(BaremetalModelRoot, self).remove_node(node.uuid)
+        except nx.NetworkXError as exc:
+            LOG.exception(exc)
+            raise exception.IronicNodeNotFound(name=node.uuid)
+
+    @lockutils.synchronized("baremetal_model")
+    def get_all_ironic_nodes(self):
+        return {uuid: cn for uuid, cn in self.nodes(data=True)
+                if isinstance(cn, element.IronicNode)}
+
+    @lockutils.synchronized("baremetal_model")
+    def get_node_by_uuid(self, uuid):
+        try:
+            return self._get_by_uuid(uuid)
+        except exception.BaremetalResourceNotFound:
+            raise exception.IronicNodeNotFound(name=uuid)
+
+    def _get_by_uuid(self, uuid):
+        try:
+            return self.node[uuid]
+        except Exception as exc:
+            LOG.exception(exc)
+        raise exception.BaremetalResourceNotFound(name=uuid)
+
+    def to_string(self):
+        return self.to_xml()
+
+    def to_xml(self):
+        root = etree.Element("ModelRoot")
+        # Build Ironic node tree
+        for cn in sorted(self.get_all_ironic_nodes().values(),
+                         key=lambda cn: cn.uuid):
+            ironic_node_el = cn.as_xml_element()
+            root.append(ironic_node_el)
+
+        return etree.tostring(root, pretty_print=True).decode('utf-8')
+
+    @classmethod
+    def from_xml(cls, data):
+        model = cls()
+
+        root = etree.fromstring(data)
+        for cn in root.findall('.//IronicNode'):
+            node = element.IronicNode(**cn.attrib)
+            model.add_node(node)
+
+        return model
+
+    @classmethod
+    def is_isomorphic(cls, G1, G2):
+        return nx.algorithms.isomorphism.isomorph.is_isomorphic(
+            G1, G2)