initial version

Change-Id: I699e0ab082657880998d8618fe29eb7f56c6c661

watcher/applier/README.md

@@ -0,0 +1,11 @@
+# Watcher Actions Applier
+
+This component is in charge of executing the plan of actions built by the Watcher Actions Planner.
+
+For each action of the workflow, this component may call directly the component responsible for this kind of action (Example : Nova API for an instance migration) or via some publish/subscribe pattern on the message bus.
+
+It notifies continuously of the current progress of the Action Plan (and atomic Actions), sending status messages on the bus. Those events may be used by the CEP to trigger new actions.
+
+This component is also connected to the Watcher MySQL database in order to:
+* get the description of the action plan to execute
+* persist its current state so that if it is restarted, it can restore each Action plan context and restart from the last known safe point of each ongoing workflow.

watcher/applier/api/applier.py

@@ -0,0 +1,21 @@
+# -*- encoding: utf-8 -*-
+# Copyright (c) 2015 b<>com
+#
+# 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.
+#
+
+
+class Applier(object):
+    def execute(self, action_plan_uuid):
+        raise NotImplementedError("Should have implemented this")

watcher/applier/api/command_mapper.py

@@ -0,0 +1,21 @@
+# -*- encoding: utf-8 -*-
+# Copyright (c) 2015 b<>com
+#
+# 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.
+#
+
+
+class CommandMapper(object):
+    def build_primitive_command(self, action):
+        raise NotImplementedError("Should have implemented this")

watcher/applier/api/messaging/applier_command.py

@@ -0,0 +1,21 @@
+# -*- encoding: utf-8 -*-
+# Copyright (c) 2015 b<>com
+#
+# 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.
+#
+
+
+class ApplierCommand(object):
+    def execute(self):
+        raise NotImplementedError("Should have implemented this")

watcher/applier/api/primitive_command.py

@@ -0,0 +1,26 @@
+# -*- encoding: utf-8 -*-
+# Copyright (c) 2015 b<>com
+#
+# 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 watcher.applier.api.promise import Promise
+
+
+class PrimitiveCommand(object):
+    @Promise
+    def execute(self):
+        raise NotImplementedError("Should have implemented this")
+
+    @Promise
+    def undo(self):
+        raise NotImplementedError("Should have implemented this")

watcher/applier/api/promise.py

@@ -0,0 +1,48 @@
+# -*- encoding: utf-8 -*-
+# Copyright (c) 2015 b<>com
+#
+# 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 concurrent.futures import Future
+from concurrent.futures import ThreadPoolExecutor
+
+
+class Promise(object):
+    executor = ThreadPoolExecutor(
+        max_workers=10)
+
+    def __init__(self, func):
+        self.func = func
+
+    def resolve(self, *args, **kwargs):
+        resolved_args = []
+        resolved_kwargs = {}
+
+        for i, arg in enumerate(args):
+            if isinstance(arg, Future):
+                resolved_args.append(arg.result())
+            else:
+                resolved_args.append(arg)
+
+        for kw, arg in kwargs.items():
+            if isinstance(arg, Future):
+                resolved_kwargs[kw] = arg.result()
+            else:
+                resolved_kwargs[kw] = arg
+
+        return self.func(*resolved_args, **resolved_kwargs)
+
+    def __call__(self, *args, **kwargs):
+        return self.executor.submit(self.resolve, *args, **kwargs)

watcher/applier/framework/command/hypervisor_state_command.py

@@ -0,0 +1,76 @@
+# -*- encoding: utf-8 -*-
+# Copyright (c) 2015 b<>com
+#
+# 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 keystoneclient.auth.identity import v3
+from keystoneclient import session
+from oslo_config import cfg
+
+from watcher.applier.api.primitive_command import PrimitiveCommand
+from watcher.applier.api.promise import Promise
+from watcher.applier.framework.command.wrapper.nova_wrapper import NovaWrapper
+from watcher.decision_engine.framework.model.hypervisor_state import \
+    HypervisorState
+
+CONF = cfg.CONF
+
+
+class HypervisorStateCommand(PrimitiveCommand):
+    def __init__(self, host, status):
+        self.host = host
+        self.status = status
+
+    def nova_manage_service(self, status):
+        creds = \
+            {'auth_url': CONF.keystone_authtoken.auth_uri,
+             'username': CONF.keystone_authtoken.admin_user,
+             'password': CONF.keystone_authtoken.admin_password,
+             'project_name': CONF.keystone_authtoken.admin_tenant_name,
+             'user_domain_name': "default",
+             'project_domain_name': "default"}
+
+        auth = v3.Password(auth_url=creds['auth_url'],
+                           username=creds['username'],
+                           password=creds['password'],
+                           project_name=creds['project_name'],
+                           user_domain_name=creds[
+                               'user_domain_name'],
+                           project_domain_name=creds[
+                               'project_domain_name'])
+        sess = session.Session(auth=auth)
+        # todo(jed) refactoring
+        wrapper = NovaWrapper(creds, session=sess)
+        if status is True:
+            return wrapper.enable_service_nova_compute(self.host)
+        else:
+            return wrapper.disable_service_nova_compute(self.host)
+
+    @Promise
+    def execute(self):
+        if self.status == HypervisorState.OFFLINE.value:
+            state = False
+        elif self.status == HypervisorState.ONLINE.value:
+            state = True
+        return self.nova_manage_service(state)
+
+    @Promise
+    def undo(self):
+        if self.status == HypervisorState.OFFLINE.value:
+            state = True
+        elif self.status == HypervisorState.ONLINE.value:
+            state = False
+        return self.nova_manage_service(state)

watcher/applier/framework/command/migrate_command.py

@@ -0,0 +1,100 @@
+# -*- encoding: utf-8 -*-
+# Copyright (c) 2015 b<>com
+#
+# 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 keystoneclient.auth.identity import v3
+from keystoneclient import session
+from oslo_config import cfg
+
+from watcher.applier.api.primitive_command import PrimitiveCommand
+from watcher.applier.api.promise import Promise
+from watcher.applier.framework.command.wrapper.nova_wrapper import NovaWrapper
+from watcher.decision_engine.framework.default_planner import Primitives
+
+CONF = cfg.CONF
+
+
+class MigrateCommand(PrimitiveCommand):
+    def __init__(self, vm_uuid=None,
+                 migration_type=None,
+                 source_hypervisor=None,
+                 destination_hypervisor=None):
+        self.instance_uuid = vm_uuid
+        self.migration_type = migration_type
+        self.source_hypervisor = source_hypervisor
+        self.destination_hypervisor = destination_hypervisor
+
+    def migrate(self, destination):
+
+        creds = \
+            {'auth_url': CONF.keystone_authtoken.auth_uri,
+             'username': CONF.keystone_authtoken.admin_user,
+             'password': CONF.keystone_authtoken.admin_password,
+             'project_name': CONF.keystone_authtoken.admin_tenant_name,
+             'user_domain_name': "default",
+             'project_domain_name': "default"}
+        auth = v3.Password(auth_url=creds['auth_url'],
+                           username=creds['username'],
+                           password=creds['password'],
+                           project_name=creds['project_name'],
+                           user_domain_name=creds[
+                               'user_domain_name'],
+                           project_domain_name=creds[
+                               'project_domain_name'])
+        sess = session.Session(auth=auth)
+        # todo(jed) add class
+        wrapper = NovaWrapper(creds, session=sess)
+        instance = wrapper.find_instance(self.instance_uuid)
+        if instance:
+            project_id = getattr(instance, "tenant_id")
+
+            creds2 = \
+                {'auth_url': CONF.keystone_authtoken.auth_uri,
+                 'username': CONF.keystone_authtoken.admin_user,
+                 'password': CONF.keystone_authtoken.admin_password,
+                 'project_id': project_id,
+                 'user_domain_name': "default",
+                 'project_domain_name': "default"}
+            auth2 = v3.Password(auth_url=creds2['auth_url'],
+                                username=creds2['username'],
+                                password=creds2['password'],
+                                project_id=creds2['project_id'],
+                                user_domain_name=creds2[
+                                    'user_domain_name'],
+                                project_domain_name=creds2[
+                                    'project_domain_name'])
+            sess2 = session.Session(auth=auth2)
+            wrapper2 = NovaWrapper(creds2, session=sess2)
+
+            # todo(jed) remove Primitves
+            if self.migration_type is Primitives.COLD_MIGRATE:
+                return wrapper2.live_migrate_instance(
+                    instance_id=self.instance_uuid,
+                    dest_hostname=destination,
+                    block_migration=True)
+            elif self.migration_type is Primitives.LIVE_MIGRATE:
+                return wrapper2.live_migrate_instance(
+                    instance_id=self.instance_uuid,
+                    dest_hostname=destination,
+                    block_migration=False)
+
+    @Promise
+    def execute(self):
+        return self.migrate(self.destination_hypervisor)
+
+    @Promise
+    def undo(self):
+        return self.migrate(self.source_hypervisor)

watcher/applier/framework/command/nop_command.py

@@ -0,0 +1,31 @@
+# -*- encoding: utf-8 -*-
+# Copyright (c) 2015 b<>com
+#
+# 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 watcher.applier.api.primitive_command import PrimitiveCommand
+from watcher.applier.api.promise import Promise
+
+
+class NopCommand(PrimitiveCommand):
+    def __init__(self):
+        pass
+
+    @Promise
+    def execute(self):
+        return True
+
+    @Promise
+    def undo(self):
+        return True

watcher/applier/framework/command/power_state_command.py

@@ -0,0 +1,33 @@
+# -*- encoding: utf-8 -*-
+# Copyright (c) 2015 b<>com
+#
+# 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 watcher.applier.api.primitive_command import PrimitiveCommand
+from watcher.applier.api.promise import Promise
+
+
+class PowerStateCommand(PrimitiveCommand):
+    def __init__(self):
+        pass
+
+    @Promise
+    def execute(self):
+        pass
+
+    @Promise
+    def undo(self):
+        # TODO(jde): migrate VM from  target_hypervisor
+        # to current_hypervisor in model
+        return True

watcher/applier/framework/command/wrapper/nova_wrapper.py

@@ -0,0 +1,694 @@
+# -*- encoding: utf-8 -*-
+# Copyright (c) 2015 b<>com
+#
+# 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 random
+import time
+
+import cinderclient.exceptions as ciexceptions
+import cinderclient.v2.client as ciclient
+import glanceclient.v2.client as glclient
+import keystoneclient.v3.client as ksclient
+import neutronclient.neutron.client as netclient
+import novaclient.exceptions as nvexceptions
+import novaclient.v2.client as nvclient
+from watcher.openstack.common import log
+
+LOG = log.getLogger(__name__)
+
+
+class NovaWrapper(object):
+    def __init__(self, creds, session):
+        self.user = creds['username']
+        self.session = session
+        self.neutron = None
+        self.cinder = None
+        self.nova = nvclient.Client("3", session=session)
+        self.keystone = ksclient.Client(**creds)
+        self.glance = None
+
+    def get_hypervisors_list(self):
+        return self.nova.hypervisors.list()
+
+    def find_instance(self, instance_id):
+        search_opts = {'all_tenants': True}
+        instances = self.nova.servers.list(detailed=True,
+                                           search_opts=search_opts)
+        instance = None
+        for _instance in instances:
+            if _instance.id == instance_id:
+                instance = _instance
+                break
+        return instance
+
+    def watcher_non_live_migrate_instance(self, instance_id, hypervisor_id,
+                                          keep_original_image_name=True):
+        """This method migrates a given instance
+
+                using an image of this instance and creating a new instance
+                from this image. It saves some configuration information
+                 about the original instance : security group, list of networks
+                ,list of attached volumes, floating IP, ...
+                in order to apply the same settings to the new instance.
+                At the end of the process the original instance is deleted.
+                It returns True if the migration was successful,
+                False otherwise.
+
+                :param instance_id: the unique id of the instance to migrate.
+                :param keep_original_image_name: flag indicating whether the
+                image name from which the original instance was built must be
+                used as the name of the intermediate image used for migration.
+                If this flag is False, a temporary image name is built
+            """
+
+        new_image_name = ""
+
+        LOG.debug(
+            "Trying a non-live migrate of instance '%s' "
+            "using a temporary image ..." % instance_id)
+
+        # Looking for the instance to migrate
+        instance = self.find_instance(instance_id)
+        if not instance:
+            LOG.debug("Instance %s not found !" % instance_id)
+            return False
+        else:
+            host_name = getattr(instance, "OS-EXT-SRV-ATTR:host")
+            # https://bugs.launchpad.net/nova/+bug/1182965
+            LOG.debug(
+                "Instance %s found on host '%s'." % (instance_id, host_name))
+
+            if not keep_original_image_name:
+                # randrange gives you an integral value
+                irand = random.randint(0, 1000)
+
+                # Building the temporary image name
+                # which will be used for the migration
+                new_image_name = "tmp-migrate-%s-%s" % (instance_id, irand)
+            else:
+                # Get the image name of the current instance.
+                # We'll use the same name for the new instance.
+                imagedict = getattr(instance, "image")
+                image_id = imagedict["id"]
+                image = self.nova.images.get(image_id)
+                new_image_name = getattr(image, "name")
+
+            instance_name = getattr(instance, "name")
+            flavordict = getattr(instance, "flavor")
+            # a_dict = dict([flavorstr.strip('{}').split(":"),])
+            flavor_id = flavordict["id"]
+            flavor = self.nova.flavors.get(flavor_id)
+            flavor_name = getattr(flavor, "name")
+            keypair_name = getattr(instance, "key_name")
+
+            addresses = getattr(instance, "addresses")
+
+            floating_ip = ""
+            network_names_list = []
+
+            for network_name, network_conf_obj in addresses.items():
+                LOG.debug(
+                    "Extracting network configuration for network '%s'" %
+                    network_name)
+
+                network_names_list.append(network_name)
+
+                for net_conf_item in network_conf_obj:
+                    if net_conf_item['OS-EXT-IPS:type'] == "floating":
+                        floating_ip = net_conf_item['addr']
+                        break
+
+            sec_groups_list = getattr(instance, "security_groups")
+            sec_groups = []
+
+            for sec_group_dict in sec_groups_list:
+                sec_groups.append(sec_group_dict['name'])
+
+            # Stopping the old instance properly so
+            # that no new data is sent to it and to its attached volumes
+            stopped_ok = self.stop_instance(instance_id)
+
+            if not stopped_ok:
+                LOG.debug("Could not stop instance: %s" % instance_id)
+                return False
+
+            # Building the temporary image which will be used
+            # to re-build the same instance on another target host
+            image_uuid = self.create_image_from_instance(instance_id,
+                                                         new_image_name)
+
+            if not image_uuid:
+                LOG.debug(
+                    "Could not build temporary image of instance: %s" %
+                    instance_id)
+                return False
+
+            #
+            # We need to get the list of attached volumes and detach
+            # them from the instance in order to attache them later
+            # to the new instance
+            #
+            blocks = []
+
+            # Looks like this :
+            # os-extended-volumes:volumes_attached |
+            # [{u'id': u'c5c3245f-dd59-4d4f-8d3a-89d80135859a'}]
+            attached_volumes = getattr(instance,
+                                       "os-extended-volumes:volumes_attached")
+
+            for attached_volume in attached_volumes:
+                volume_id = attached_volume['id']
+
+                try:
+                    if self.cinder is None:
+                        self.cinder = ciclient.Client('2',
+                                                      session=self.session)
+                    volume = self.cinder.volumes.get(volume_id)
+
+                    attachments_list = getattr(volume, "attachments")
+
+                    device_name = attachments_list[0]['device']
+                    # When a volume is attached to an instance
+                    # it contains the following property :
+                    # attachments = [{u'device': u'/dev/vdb',
+                    # u'server_id': u'742cc508-a2f2-4769-a794-bcdad777e814',
+                    # u'id': u'f6d62785-04b8-400d-9626-88640610f65e',
+                    # u'host_name': None, u'volume_id':
+                    # u'f6d62785-04b8-400d-9626-88640610f65e'}]
+
+                    # boot_index indicates a number
+                    # designating the boot order of the device.
+                    # Use -1 for the boot volume,
+                    # choose 0 for an attached volume.
+                    block_device_mapping_v2_item = {"device_name": device_name,
+                                                    "source_type": "volume",
+                                                    "destination_type":
+                                                        "volume",
+                                                    "uuid": volume_id,
+                                                    "boot_index": "0"}
+
+                    blocks.append(
+                        block_device_mapping_v2_item)
+
+                    LOG.debug("Detaching volume %s from instance: %s" % (
+                        volume_id, instance_id))
+                    # volume.detach()
+                    self.nova.volumes.delete_server_volume(instance_id,
+                                                           volume_id)
+
+                    if not self.wait_for_volume_status(volume, "available", 5,
+                                                       10):
+                        LOG.debug(
+                            "Could not detach volume %s from instance: %s" % (
+                                volume_id, instance_id))
+                        return False
+                except ciexceptions.NotFound:
+                    LOG.debug("Volume '%s' not found " % image_id)
+                    return False
+
+            # We create the new instance from
+            # the intermediate image of the original instance
+            new_instance = self. \
+                create_instance(hypervisor_id,
+                                instance_name,
+                                image_uuid,
+                                flavor_name,
+                                sec_groups,
+                                network_names_list=network_names_list,
+                                keypair_name=keypair_name,
+                                create_new_floating_ip=False,
+                                block_device_mapping_v2=blocks)
+
+            if not new_instance:
+                LOG.debug(
+                    "Could not create new instance "
+                    "for non-live migration of instance %s" % instance_id)
+                return False
+
+            try:
+                LOG.debug("Detaching floating ip '%s' from instance %s" % (
+                    floating_ip, instance_id))
+                # We detach the floating ip from the current instance
+                instance.remove_floating_ip(floating_ip)
+
+                LOG.debug(
+                    "Attaching floating ip '%s' to the new instance %s" % (
+                        floating_ip, new_instance.id))
+
+                # We attach the same floating ip to the new instance
+                new_instance.add_floating_ip(floating_ip)
+            except Exception as e:
+                LOG.debug(e)
+
+            new_host_name = getattr(new_instance, "OS-EXT-SRV-ATTR:host")
+
+            # Deleting the old instance (because no more useful)
+            delete_ok = self.delete_instance(instance_id)
+            if not delete_ok:
+                LOG.debug("Could not delete instance: %s" % instance_id)
+                return False
+
+            LOG.debug(
+                "Instance %s has been successfully migrated "
+                "to new host '%s' and its new id is %s." % (
+                    instance_id, new_host_name, new_instance.id))
+
+            return True
+
+    def built_in_non_live_migrate_instance(self, instance_id, hypervisor_id):
+        """This method uses the Nova built-in non-live migrate()
+            action to migrate a given instance.
+            It returns True if the migration was successful, False otherwise.
+
+                :param instance_id: the unique id of the instance to migrate.
+            """
+
+        LOG.debug(
+            "Trying a Nova built-in non-live "
+            "migrate of instance %s ..." % instance_id)
+
+        # Looking for the instance to migrate
+        instance = self.find_instance(instance_id)
+
+        if not instance:
+            LOG.debug("Instance not found: %s" % instance_id)
+            return False
+        else:
+            host_name = getattr(instance, 'OS-EXT-SRV-ATTR:host')
+            LOG.debug(
+                "Instance %s found on host '%s'." % (instance_id, host_name))
+
+            instance.migrate()
+
+            # Poll at 5 second intervals, until the status is as expected
+            if self.wait_for_instance_status(instance,
+                                             ('VERIFY_RESIZE', 'ERROR'),
+                                             5, 10):
+
+                instance = self.nova.servers.get(instance.id)
+
+                if instance.status == 'VERIFY_RESIZE':
+                    host_name = getattr(instance, 'OS-EXT-SRV-ATTR:host')
+                    LOG.debug(
+                        "Instance %s has been successfully "
+                        "migrated to host '%s'." % (
+                            instance_id, host_name))
+
+                    # We need to confirm that the resize() operation
+                    # has succeeded in order to
+                    # get back instance state to 'ACTIVE'
+                    instance.confirm_resize()
+
+                    return True
+                elif instance.status == 'ERROR':
+                    LOG.debug("Instance %s migration failed" % instance_id)
+
+        return False
+
+    def live_migrate_instance(self, instance_id, dest_hostname,
+                              block_migration=True, retry=120):
+        """This method uses the Nova built-in live_migrate()
+        action to do a live migration of a given instance.
+                It returns True if the migration was successful,
+                False otherwise.
+
+                :param instance_id: the unique id of the instance to migrate.
+                :param dest_hostname: the name of the destination compute node.
+                :param block_migration:  No shared storage is required.
+            """
+
+        LOG.debug("Trying a live migrate of instance %s to host '%s'" % (
+            instance_id, dest_hostname))
+
+        # Looking for the instance to migrate
+        instance = self.find_instance(instance_id)
+
+        if not instance:
+            LOG.debug("Instance not found: %s" % instance_id)
+            return False
+        else:
+            host_name = getattr(instance, 'OS-EXT-SRV-ATTR:host')
+            LOG.debug(
+                "Instance %s found on host '%s'." % (instance_id, host_name))
+
+            instance.live_migrate(host=dest_hostname,
+                                  block_migration=block_migration,
+                                  disk_over_commit=True)
+            while getattr(instance,
+                          'OS-EXT-SRV-ATTR:host') != dest_hostname \
+                    and retry:
+                instance = self.nova.servers.get(instance.id)
+                LOG.debug(
+                    "Waiting the migration of " + str(
+                        instance.human_id) + " to " +
+                    getattr(instance,
+                            'OS-EXT-SRV-ATTR:host'))
+                time.sleep(1)
+                retry -= 1
+
+            host_name = getattr(instance, 'OS-EXT-SRV-ATTR:host')
+            if host_name != dest_hostname:
+                return False
+
+            LOG.debug(
+                "Live migration succeeded : "
+                "instance %s is now on host '%s'." % (
+                    instance_id, host_name))
+
+            return True
+
+        return False
+
+    def enable_service_nova_compute(self, hostname):
+        if self.nova.services.enable(host=hostname,
+                                     binary='nova-compute'). \
+                status == 'enabled':
+            return True
+        else:
+            return False
+
+    def disable_service_nova_compute(self, hostname):
+        if self.nova.services.disable(host=hostname,
+                                      binary='nova-compute'). \
+                status == 'disabled':
+            return True
+        else:
+            return False
+
+    def set_host_offline(self, hostname):
+        # See API on http://developer.openstack.org/api-ref-compute-v2.1.html
+        # especially the PUT request
+        # regarding this resource : /v2.1/os-hosts/​{host_name}​
+        #
+        # The following body should be sent :
+        # {
+        # "host": {
+        # "host": "65c5d5b7e3bd44308e67fc50f362aee6",
+        # "maintenance_mode": "off_maintenance",
+        # "status": "enabled"
+        # }
+        # }
+
+        # Voir ici
+        # https://github.com/openstack/nova/
+        # blob/master/nova/virt/xenapi/host.py
+        # set_host_enabled(self, enabled):
+        # Sets the compute host's ability to accept new instances.
+        # host_maintenance_mode(self, host, mode):
+        # Start/Stop host maintenance window.
+        # On start, it triggers guest VMs evacuation.
+        host = self.nova.hosts.get(hostname)
+
+        if not host:
+            LOG.debug("host not found: %s" % hostname)
+            return False
+        else:
+            host[0].update(
+                {"maintenance_mode": "disable", "status": "disable"})
+            return True
+
+    def create_image_from_instance(self, instance_id, image_name,
+                                   metadata={"reason": "instance_migrate"}):
+        """This method creates a new image from a given instance.
+            It waits for this image to be in 'active' state before returning.
+                 It returns the unique UUID of the created image if successful,
+                 None otherwise
+
+                :param instance_id: the uniqueid of
+                the instance to backup as an image.
+                :param image_name: the name of the image to create.
+                :param metadata: a dictionary containing the list of
+                 key-value pairs to associate to the image as metadata.
+                """
+        if self.glance is None:
+            glance_endpoint = self.keystone. \
+                service_catalog.url_for(service_type='image',
+                                        endpoint_type='publicURL')
+            self.glance = glclient.Client(glance_endpoint,
+                                          token=self.keystone.auth_token)
+
+        LOG.debug(
+            "Trying to create an image from instance %s ..." % instance_id)
+
+        # Looking for the instance
+        instance = self.find_instance(instance_id)
+
+        if not instance:
+            LOG.debug("Instance not found: %s" % instance_id)
+            return None
+        else:
+            host_name = getattr(instance, 'OS-EXT-SRV-ATTR:host')
+            LOG.debug(
+                "Instance %s found on host '%s'." % (instance_id, host_name))
+
+            # We need to wait for an appropriate status
+            # of the instance before we can build an image from it
+            if self.wait_for_instance_status(instance, ('ACTIVE', 'SHUTOFF'),
+                                             5,
+                                             10):
+                image_uuid = self.nova.servers.create_image(instance_id,
+                                                            image_name,
+                                                            metadata)
+
+                image = self.glance.images.get(image_uuid)
+
+                # Waiting for the new image to be officially in ACTIVE state
+                # in order to make sure it can be used
+                status = image.status
+                retry = 10
+                while status != 'active' and status != 'error' and retry:
+                    time.sleep(5)
+                    retry -= 1
+                    # Retrieve the instance again so the status field updates
+                    image = self.glance.images.get(image_uuid)
+                    status = image.status
+                    LOG.debug("Current image status: %s" % status)
+
+                if not image:
+                    LOG.debug("Image not found: %s" % image_uuid)
+                else:
+                    LOG.debug(
+                        "Image %s successfully created for instance %s" % (
+                            image_uuid, instance_id))
+                    return image_uuid
+        return None
+
+    def delete_instance(self, instance_id):
+        """This method deletes a given instance.
+
+                :param instance_id: the unique id of the instance to delete.
+                """
+
+        LOG.debug("Trying to remove instance %s ..." % instance_id)
+
+        instance = self.find_instance(instance_id)
+
+        if not instance:
+            LOG.debug("Instance not found: %s" % instance_id)
+            return False
+        else:
+            self.nova.servers.delete(instance_id)
+            LOG.debug("Instance %s removed." % instance_id)
+            return True
+
+    def stop_instance(self, instance_id):
+        """This method stops a given instance.
+
+                :param instance_id: the unique id of the instance to stop.
+                """
+
+        LOG.debug("Trying to stop instance %s ..." % instance_id)
+
+        instance = self.find_instance(instance_id)
+
+        if not instance:
+            LOG.debug("Instance not found: %s" % instance_id)
+            return False
+        else:
+            self.nova.servers.stop(instance_id)
+
+            if self.wait_for_vm_state(instance, "stopped", 8, 10):
+                LOG.debug("Instance %s stopped." % instance_id)
+                return True
+            else:
+                return False
+
+    def wait_for_vm_state(self, server, vm_state, retry, sleep):
+        """Waits for server to be in vm_state which can be one of the following :
+            active, stopped
+
+            :param server: server object.
+            :param vm_state: for which state we are waiting for
+            :param retry: how many times to retry
+            :param sleep: seconds to sleep between the retries
+            """
+        if not server:
+            return False
+
+        while getattr(server, 'OS-EXT-STS:vm_state') != vm_state and retry:
+            time.sleep(sleep)
+            server = self.nova.servers.get(server)
+            retry -= 1
+        return getattr(server, 'OS-EXT-STS:vm_state') == vm_state
+
+    def wait_for_instance_status(self, instance, status_list, retry, sleep):
+        """Waits for instance to be in status which can be one of the following
+            : BUILD, ACTIVE, ERROR, VERIFY_RESIZE, SHUTOFF
+
+            :param instance: instance object.
+            :param status_list: tuple containing the list of
+             status we are waiting for
+            :param retry: how many times to retry
+            :param sleep: seconds to sleep between the retries
+            """
+        if not instance:
+            return False
+
+        while instance.status not in status_list and retry:
+            LOG.debug("Current instance status: %s" % instance.status)
+            time.sleep(sleep)
+            instance = self.nova.servers.get(instance.id)
+            retry -= 1
+        LOG.debug("Current instance status: %s" % instance.status)
+        return instance.status in status_list
+
+    def create_instance(self, hypervisor_id, inst_name="test", image_id=None,
+                        flavor_name="m1.tiny",
+                        sec_group_list=["default"],
+                        network_names_list=["private"], keypair_name="mykeys",
+                        create_new_floating_ip=True,
+                        block_device_mapping_v2=None):
+        """This method creates a new instance.
+                It also creates, if requested, a new floating IP and associates
+                it with the new instance
+                It returns the unique id of the created instance.
+            """
+
+        LOG.debug(
+            "Trying to create new instance '%s' "
+            "from image '%s' with flavor '%s' ..." % (
+                inst_name, image_id, flavor_name))
+        # TODO(jed) wait feature
+        # Allow admin users to view any keypair
+        # https://bugs.launchpad.net/nova/+bug/1182965
+        if not self.nova.keypairs.findall(name=keypair_name):
+            LOG.debug("Key pair '%s' not found with user '%s'" % (
+                keypair_name, self.user))
+            return
+        else:
+            LOG.debug("Key pair '%s' found with user '%s'" % (
+                keypair_name, self.user))
+
+        try:
+            image = self.nova.images.get(image_id)
+        except nvexceptions.NotFound:
+            LOG.debug("Image '%s' not found " % image_id)
+            return
+
+        try:
+            flavor = self.nova.flavors.find(name=flavor_name)
+        except nvexceptions.NotFound:
+            LOG.debug("Flavor '%s' not found " % flavor_name)
+            return
+
+        # Make sure all security groups exist
+        for sec_group_name in sec_group_list:
+            try:
+                self.nova.security_groups.find(name=sec_group_name)
+
+            except nvexceptions.NotFound:
+                LOG.debug("Security group '%s' not found " % sec_group_name)
+                return
+
+        net_list = list()
+
+        for network_name in network_names_list:
+            nic_id = self.get_network_id_from_name(network_name)
+
+            if not nic_id:
+                LOG.debug("Network '%s' not found " % network_name)
+                return
+            net_obj = {"net-id": nic_id}
+            net_list.append(net_obj)
+        s = self.nova.servers
+        instance = s.create(inst_name,
+                            image, flavor=flavor,
+                            key_name=keypair_name,
+                            security_groups=sec_group_list,
+                            nics=net_list,
+                            block_device_mapping_v2=block_device_mapping_v2,
+                            availability_zone="nova:" +
+                                              hypervisor_id)
+
+        # Poll at 5 second intervals, until the status is no longer 'BUILD'
+        if instance:
+            if self.wait_for_instance_status(instance,
+                                             ('ACTIVE', 'ERROR'), 5, 10):
+                instance = self.nova.servers.get(instance.id)
+
+                if create_new_floating_ip and instance.status == 'ACTIVE':
+                    LOG.debug(
+                        "Creating a new floating IP"
+                        " for instance '%s'" % instance.id)
+                    # Creating floating IP for the new instance
+                    floating_ip = self.nova.floating_ips.create()
+
+                    instance.add_floating_ip(floating_ip)
+
+                    LOG.debug("Instance %s associated to Floating IP '%s'" % (
+                        instance.id, floating_ip.ip))
+
+        return instance
+
+    def get_network_id_from_name(self, net_name="private"):
+        """This method returns the unique id of the provided network name"""
+        if self.neutron is None:
+            self.neutron = netclient.Client('2.0', session=self.session)
+            self.neutron.format = 'json'
+
+        networks = self.neutron.list_networks(name=net_name)
+
+        # LOG.debug(networks)
+        network_id = networks['networks'][0]['id']
+
+        return network_id
+
+    def get_vms_by_hypervisor(self, host):
+        return [vm for vm in
+                self.nova.servers.list(search_opts={"all_tenants": True})
+                if self.get_hostname(vm) == host]
+
+    def get_hostname(self, vm):
+        return str(getattr(vm, 'OS-EXT-SRV-ATTR:host'))
+
+    def get_flavor_instance(self, instance, cache):
+        fid = instance.flavor['id']
+        if fid in cache:
+            flavor = cache.get(fid)
+        else:
+            try:
+                flavor = self.nova.flavors.get(fid)
+            except ciexceptions.NotFound:
+                flavor = None
+            cache[fid] = flavor
+        attr_defaults = [('name', 'unknown-id-%s' % fid),
+                         ('vcpus', 0), ('ram', 0), ('disk', 0),
+                         ('ephemeral', 0)]
+        for attr, default in attr_defaults:
+            if not flavor:
+                instance.flavor[attr] = default
+                continue
+            instance.flavor[attr] = getattr(flavor, attr, default)

watcher/applier/framework/command_executor.py

@@ -0,0 +1,73 @@
+# -*- encoding: utf-8 -*-
+# Copyright (c) 2015 b<>com
+#
+# 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 watcher.applier.framework.default_command_mapper import \
+    DefaultCommandMapper
+
+from watcher.applier.framework.deploy_phase import DeployPhase
+from watcher.applier.framework.messaging.events import Events
+from watcher.common.messaging.events.event import Event
+from watcher.objects import Action
+from watcher.objects.action_plan import Status
+from watcher.openstack.common import log
+
+LOG = log.getLogger(__name__)
+
+
+class CommandExecutor(object):
+    def __init__(self, manager_applier, context):
+        self.manager_applier = manager_applier
+        self.context = context
+        self.deploy = DeployPhase(self)
+        self.mapper = DefaultCommandMapper()
+
+    def get_primitive(self, action):
+        return self.mapper.build_primitive_command(action)
+
+    def notify(self, action, state):
+        db_action = Action.get_by_uuid(self.context, action.uuid)
+        db_action.state = state
+        db_action.save()
+        event = Event()
+        event.set_type(Events.LAUNCH_ACTION)
+        event.set_data({})
+        payload = {'action_uuid': action.uuid,
+                   'action_status': state}
+        self.manager_applier.topic_status.publish_event(event.get_type().name,
+                                                        payload)
+
+    def execute(self, actions):
+        for action in actions:
+            try:
+                self.notify(action, Status.ONGOING)
+                primitive = self.get_primitive(action)
+                result = self.deploy.execute_primitive(primitive)
+                if result is False:
+                    self.notify(action, Status.FAILED)
+                    self.deploy.rollback()
+                    return False
+                else:
+                    self.deploy.populate(primitive)
+                    self.notify(action, Status.SUCCESS)
+            except Exception as e:
+                LOG.error(
+                    "The applier module failed to execute the action" + str(
+                        action) + " with the exception : " + unicode(e))
+                LOG.error("Trigger a rollback")
+                self.notify(action, Status.FAILED)
+                self.deploy.rollback()
+                return False
+        return True

watcher/applier/framework/default_applier.py

@@ -0,0 +1,35 @@
+# -*- encoding: utf-8 -*-
+# Copyright (c) 2015 b<>com
+#
+# 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 watcher.applier.api.applier import Applier
+from watcher.applier.framework.command_executor import CommandExecutor
+from watcher.objects import Action
+from watcher.objects import ActionPlan
+
+
+class DefaultApplier(Applier):
+    def __init__(self, manager_applier, context):
+        self.manager_applier = manager_applier
+        self.context = context
+        self.executor = CommandExecutor(manager_applier, context)
+
+    def execute(self, action_plan_uuid):
+        action_plan = ActionPlan.get_by_uuid(self.context, action_plan_uuid)
+        # todo(jed) remove direct access to dbapi need filter in object
+        actions = Action.dbapi.get_action_list(self.context,
+                                               filters={
+                                                   'action_plan_id':
+                                                       action_plan.id})
+        return self.executor.execute(actions)

watcher/applier/framework/default_command_mapper.py

@@ -0,0 +1,46 @@
+# -*- encoding: utf-8 -*-
+# Copyright (c) 2015 b<>com
+#
+# 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 watcher.applier.api.command_mapper import CommandMapper
+from watcher.applier.framework.command.hypervisor_state_command import \
+    HypervisorStateCommand
+from watcher.applier.framework.command.migrate_command import MigrateCommand
+from watcher.applier.framework.command.nop_command import NopCommand
+from watcher.applier.framework.command.power_state_command import \
+    PowerStateCommand
+from watcher.common.exception import ActionNotFound
+from watcher.decision_engine.framework.default_planner import Primitives
+
+
+class DefaultCommandMapper(CommandMapper):
+    def build_primitive_command(self, action):
+        if action.action_type == Primitives.COLD_MIGRATE.value:
+            return MigrateCommand(action.applies_to, Primitives.COLD_MIGRATE,
+                                  action.src,
+                                  action.dst)
+        elif action.action_type == Primitives.LIVE_MIGRATE.value:
+            return MigrateCommand(action.applies_to, Primitives.COLD_MIGRATE,
+                                  action.src,
+                                  action.dst)
+        elif action.action_type == Primitives.HYPERVISOR_STATE.value:
+            return HypervisorStateCommand(action.applies_to, action.parameter)
+        elif action.action_type == Primitives.POWER_STATE.value:
+            return PowerStateCommand()
+        elif action.action_type == Primitives.NOP.value:
+            return NopCommand()
+        else:
+            raise ActionNotFound()

watcher/applier/framework/deploy_phase.py

@@ -0,0 +1,46 @@
+# -*- encoding: utf-8 -*-
+# Copyright (c) 2015 b<>com
+#
+# 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 watcher.openstack.common import log
+LOG = log.getLogger(__name__)
+
+
+class DeployPhase(object):
+    def __init__(self, executor):
+        # todo(jed) oslo_conf 10 secondes
+        self.maxTimeout = 100000
+        self.commands = []
+        self.executor = executor
+
+    def set_max_time(self, mt):
+        self.maxTimeout = mt
+
+    def get_max_time(self):
+        return self.maxTimeout
+
+    def populate(self, action):
+        self.commands.append(action)
+
+    def execute_primitive(self, primitive):
+        futur = primitive.execute(primitive)
+        return futur.result(self.get_max_time())
+
+    def rollback(self):
+        reverted = sorted(self.commands, reverse=True)
+        for primitive in reverted:
+            try:
+                self.execute_primitive(primitive)
+            except Exception as e:
+                LOG.error(e)

watcher/applier/framework/manager_applier.py

@@ -0,0 +1,98 @@
+# -*- encoding: utf-8 -*-
+# Copyright (c) 2015 b<>com
+#
+# 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 concurrent.futures import ThreadPoolExecutor
+
+from oslo_config import cfg
+
+from watcher.applier.framework.messaging.trigger_action_plan import \
+    TriggerActionPlan
+from watcher.common.messaging.messaging_core import MessagingCore
+from watcher.common.messaging.notification_handler import NotificationHandler
+from watcher.decision_engine.framework.messaging.events import Events
+from watcher.openstack.common import log
+
+CONF = cfg.CONF
+
+LOG = log.getLogger(__name__)
+
+# Register options
+APPLIER_MANAGER_OPTS = [
+    cfg.IntOpt('applier_worker', default='1', help='The number of worker'),
+    cfg.StrOpt('topic_control',
+               default='watcher.applier.control',
+               help='The topic name used for'
+                    'control events, this topic '
+                    'used for rpc call '),
+    cfg.StrOpt('topic_status',
+               default='watcher.applier.status',
+               help='The topic name used for '
+                    'status events, this topic '
+                    'is used so as to notify'
+                    'the others components '
+                    'of the system'),
+    cfg.StrOpt('publisher_id',
+               default='watcher.applier.api',
+               help='The identifier used by watcher '
+                    'module on the message broker')
+]
+CONF = cfg.CONF
+opt_group = cfg.OptGroup(name='watcher_applier',
+                         title='Options for the Applier messaging'
+                               'core')
+CONF.register_group(opt_group)
+CONF.register_opts(APPLIER_MANAGER_OPTS, opt_group)
+
+CONF.import_opt('admin_user', 'keystonemiddleware.auth_token',
+                group='keystone_authtoken')
+CONF.import_opt('admin_tenant_name', 'keystonemiddleware.auth_token',
+                group='keystone_authtoken')
+CONF.import_opt('admin_password', 'keystonemiddleware.auth_token',
+                group='keystone_authtoken')
+CONF.import_opt('auth_uri', 'keystonemiddleware.auth_token',
+                group='keystone_authtoken')
+
+
+class ApplierManager(MessagingCore):
+    API_VERSION = '1.0'
+    # todo(jed) need workflow
+
+    def __init__(self):
+        MessagingCore.__init__(self, CONF.watcher_applier.publisher_id,
+                               CONF.watcher_applier.topic_control,
+                               CONF.watcher_applier.topic_status)
+        # shared executor of the workflow
+        self.executor = ThreadPoolExecutor(max_workers=1)
+        self.handler = NotificationHandler(self.publisher_id)
+        self.handler.register_observer(self)
+        self.add_event_listener(Events.ALL, self.event_receive)
+        # trigger action_plan
+        self.topic_control.add_endpoint(TriggerActionPlan(self))
+
+    def join(self):
+        self.topic_control.join()
+        self.topic_status.join()
+
+    def event_receive(self, event):
+        try:
+            request_id = event.get_request_id()
+            event_type = event.get_type()
+            data = event.get_data()
+            LOG.debug("request id => %s" % request_id)
+            LOG.debug("type_event => %s" % str(event_type))
+            LOG.debug("data       => %s" % str(data))
+        except Exception as e:
+            LOG.error("evt %s" % e.message)
+            raise e

watcher/applier/framework/messaging/events.py

@@ -0,0 +1,22 @@
+# -*- encoding: utf-8 -*-
+# Copyright (c) 2015 b<>com
+#
+# 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 enum import Enum
+
+
+class Events(Enum):
+    LAUNCH_ACTION_PLAN = "launch_action_plan"
+    LAUNCH_ACTION = "launch_action"

watcher/applier/framework/messaging/launch_action_plan.py

@@ -0,0 +1,65 @@
+# -*- encoding: utf-8 -*-
+# Copyright (c) 2015 b<>com
+#
+# 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 watcher.applier.api.messaging.applier_command import ApplierCommand
+from watcher.applier.framework.default_applier import DefaultApplier
+from watcher.applier.framework.messaging.events import Events
+from watcher.common.messaging.events.event import Event
+from watcher.objects.action_plan import ActionPlan
+from watcher.objects.action_plan import Status
+
+from watcher.openstack.common import log
+
+LOG = log.getLogger(__name__)
+
+
+class LaunchActionPlanCommand(ApplierCommand):
+    def __init__(self, context, manager_applier, action_plan_uuid):
+        self.ctx = context
+        self.action_plan_uuid = action_plan_uuid
+        self.manager_applier = manager_applier
+
+    def notify(self, uuid, event_type, status):
+        action_plan = ActionPlan.get_by_uuid(self.ctx, uuid)
+        action_plan.state = status
+        action_plan.save()
+        event = Event()
+        event.set_type(event_type)
+        event.set_data({})
+        payload = {'action_plan__uuid': uuid,
+                   'action_plan_status': status}
+        self.manager_applier.topic_status.publish_event(event.get_type().name,
+                                                        payload)
+
+    def execute(self):
+        try:
+            # update state
+            self.notify(self.action_plan_uuid,
+                        Events.LAUNCH_ACTION_PLAN,
+                        Status.ONGOING)
+            applier = DefaultApplier(self.manager_applier, self.ctx)
+            result = applier.execute(self.action_plan_uuid)
+        except Exception as e:
+            result = False
+            LOG.error("Launch Action Plan " + unicode(e))
+        finally:
+            if result is True:
+                status = Status.SUCCESS
+            else:
+                status = Status.FAILED
+            # update state
+            self.notify(self.action_plan_uuid, Events.LAUNCH_ACTION_PLAN,
+                        status)

watcher/applier/framework/messaging/trigger_action_plan.py

@@ -0,0 +1,44 @@
+# -*- encoding: utf-8 -*-
+# Copyright (c) 2015 b<>com
+#
+# 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 watcher.applier.framework.messaging.launch_action_plan import \
+    LaunchActionPlanCommand
+from watcher.openstack.common import log
+
+LOG = log.getLogger(__name__)
+
+
+class TriggerActionPlan(object):
+    def __init__(self, manager_applier):
+        self.manager_applier = manager_applier
+
+    def do_launch_action_plan(self, context, action_plan_uuid):
+        try:
+            cmd = LaunchActionPlanCommand(context,
+                                          self.manager_applier,
+                                          action_plan_uuid)
+            cmd.execute()
+        except Exception as e:
+            LOG.error("do_launch_action_plan " + unicode(e))
+
+    def launch_action_plan(self, context, action_plan_uuid):
+        LOG.debug("Trigger ActionPlan %s" % action_plan_uuid)
+        # submit
+        self.manager_applier.executor.submit(self.do_launch_action_plan,
+                                             context,
+                                             action_plan_uuid)
+        return action_plan_uuid

watcher/applier/framework/rpcapi.py

@@ -0,0 +1,70 @@
+# -*- encoding: utf-8 -*-
+# Copyright (c) 2015 b<>com
+#
+# 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_config import cfg
+import oslo_messaging as om
+
+
+from watcher.applier.framework.manager_applier import APPLIER_MANAGER_OPTS
+from watcher.applier.framework.manager_applier import opt_group
+from watcher.common import exception
+from watcher.common import utils
+
+
+from watcher.common.messaging.messaging_core import MessagingCore
+from watcher.common.messaging.notification_handler import NotificationHandler
+from watcher.common.messaging.utils.transport_url_builder import \
+    TransportUrlBuilder
+from watcher.openstack.common import log
+
+LOG = log.getLogger(__name__)
+CONF = cfg.CONF
+CONF.register_group(opt_group)
+CONF.register_opts(APPLIER_MANAGER_OPTS, opt_group)
+
+
+class ApplierAPI(MessagingCore):
+    MessagingCore.API_VERSION = '1.0'
+
+    def __init__(self):
+        MessagingCore.__init__(self, CONF.watcher_applier.publisher_id,
+                               CONF.watcher_applier.topic_control,
+                               CONF.watcher_applier.topic_status)
+        self.handler = NotificationHandler(self.publisher_id)
+        self.handler.register_observer(self)
+        self.topic_status.add_endpoint(self.handler)
+        transport = om.get_transport(CONF, TransportUrlBuilder().url)
+        target = om.Target(
+            topic=CONF.watcher_applier.topic_control,
+            version=MessagingCore.API_VERSION)
+
+        self.client = om.RPCClient(transport, target,
+                                   serializer=self.serializer)
+
+    def launch_action_plan(self, context, action_plan_uuid=None):
+        if not utils.is_uuid_like(action_plan_uuid):
+            raise exception.InvalidUuidOrName(name=action_plan_uuid)
+
+        return self.client.call(
+            context.to_dict(), 'launch_action_plan',
+            action_plan_uuid=action_plan_uuid)
+
+    def event_receive(self, event):
+        try:
+            pass
+        except Exception as e:
+            LOG.error("evt %s" % e.message)
+            raise e