Merge "Added information on plugin mechanism to glossary"

Unicode type resource state is now handled in the same fashion as resource state specified by general string.

Change-Id: I35ffa09015283b51c935515436735aecbe83a9d6
Closes-Bug: #1565764

.gitignore

@@ -44,6 +44,8 @@ output/*/index.html
 # Sphinx
 doc/build
 doc/source/api
+doc/source/samples
+doc/source/watcher.conf.sample
 
 # pbr generates these
 AUTHORS

README.rst

@@ -10,12 +10,12 @@ Watcher
 
 OpenStack Watcher provides a flexible and scalable resource optimization
 service for multi-tenant OpenStack-based clouds.
-Watcher provides a complete optimization loop—including everything from a
+Watcher provides a complete optimization loop-including everything from a
 metrics receiver, complex event processor and profiler, optimization processor
 and an action plan applier. This provides a robust framework to realize a wide
 range of cloud optimization goals, including the reduction of data center
 operating costs, increased system performance via intelligent virtual machine
-migration, increased energy efficiency—and more!
+migration, increased energy efficiency-and more!
 
 * Free software: Apache license
 * Wiki: http://wiki.openstack.org/wiki/Watcher

devstack/lib/watcher

@@ -80,10 +80,7 @@ function cleanup_watcher {
 # configure_watcher() - Set config files, create data dirs, etc
 function configure_watcher {
     # Put config files in ``/etc/watcher`` for everyone to find
-    if [[  ! -d $WATCHER_CONF_DIR  ]]; then
-        sudo mkdir -p $WATCHER_CONF_DIR
-        sudo chown $STACK_USER $WATCHER_CONF_DIR
-    fi
+    sudo install -d -o $STACK_USER $WATCHER_CONF_DIR
 
     install_default_policy watcher
 
@@ -99,15 +96,13 @@ function configure_watcher {
 function create_watcher_accounts {
     create_service_user "watcher" "admin"
 
-    if [[ "$KEYSTONE_CATALOG_BACKEND" = 'sql' ]]; then
-        local watcher_service=$(get_or_create_service "watcher" \
-            "infra-optim" "Watcher Infrastructure Optimization Service")
-        get_or_create_endpoint $watcher_service \
-            "$REGION_NAME" \
-            "$WATCHER_SERVICE_PROTOCOL://$WATCHER_SERVICE_HOST:$WATCHER_SERVICE_PORT" \
-            "$WATCHER_SERVICE_PROTOCOL://$WATCHER_SERVICE_HOST:$WATCHER_SERVICE_PORT" \
-            "$WATCHER_SERVICE_PROTOCOL://$WATCHER_SERVICE_HOST:$WATCHER_SERVICE_PORT"
-    fi
+    local watcher_service=$(get_or_create_service "watcher" \
+        "infra-optim" "Watcher Infrastructure Optimization Service")
+    get_or_create_endpoint $watcher_service \
+        "$REGION_NAME" \
+        "$WATCHER_SERVICE_PROTOCOL://$WATCHER_SERVICE_HOST:$WATCHER_SERVICE_PORT" \
+        "$WATCHER_SERVICE_PROTOCOL://$WATCHER_SERVICE_HOST:$WATCHER_SERVICE_PORT" \
+        "$WATCHER_SERVICE_PROTOCOL://$WATCHER_SERVICE_HOST:$WATCHER_SERVICE_PORT"
 }
 
 # create_watcher_conf() - Create a new watcher.conf file
@@ -128,14 +123,8 @@ function create_watcher_conf {
     iniset $WATCHER_CONF oslo_messaging_rabbit rabbit_password $RABBIT_PASSWORD
     iniset $WATCHER_CONF oslo_messaging_rabbit rabbit_host $RABBIT_HOST
 
-    iniset $WATCHER_CONF keystone_authtoken admin_user watcher
-    iniset $WATCHER_CONF keystone_authtoken admin_password $SERVICE_PASSWORD
-    iniset $WATCHER_CONF keystone_authtoken admin_tenant_name $SERVICE_TENANT_NAME
-
     configure_auth_token_middleware $WATCHER_CONF watcher $WATCHER_AUTH_CACHE_DIR
-
-    iniset $WATCHER_CONF keystone_authtoken auth_uri $KEYSTONE_SERVICE_URI/v3
-    iniset $WATCHER_CONF keystone_authtoken auth_version v3
+    configure_auth_token_middleware $WATCHER_CONF watcher $WATCHER_AUTH_CACHE_DIR "watcher_clients_auth"
 
     if is_fedora || is_suse; then
         # watcher defaults to /usr/local/bin, but fedora and suse pip like to
@@ -178,9 +167,8 @@ function create_watcher_conf {
 # create_watcher_cache_dir() - Part of the init_watcher() process
 function create_watcher_cache_dir {
     # Create cache dir
-    sudo mkdir -p $WATCHER_AUTH_CACHE_DIR
-    sudo chown $STACK_USER $WATCHER_AUTH_CACHE_DIR
-    rm -f $WATCHER_AUTH_CACHE_DIR/*
+    sudo install -d -o $STACK_USER $WATCHER_AUTH_CACHE_DIR
+    rm -rf $WATCHER_AUTH_CACHE_DIR/*
 }
 
 # init_watcher() - Initialize databases, etc.

doc/source/architecture.rst

@@ -127,7 +127,19 @@ Watcher CLI
 The watcher command-line interface (CLI) can be used to interact with the
 Watcher system in order to control it or to know its current status.
 
-Please, read `the detailed documentation about Watcher CLI <https://factory.b-com.com/www/watcher/doc/python-watcherclient/>`_
+Please, read `the detailed documentation about Watcher CLI
+<https://factory.b-com.com/www/watcher/doc/python-watcherclient/>`_.
+
+.. _archi_watcher_dashboard_definition:
+
+Watcher Dashboard
+-----------------
+
+The Watcher Dashboard can be used to interact with the Watcher system through
+Horizon in order to control it or to know its current status.
+
+Please, read `the detailed documentation about Watcher Dashboard
+<https://factory.b-com.com/www/watcher/doc/watcher-dashboard/>`_.
 
 .. _archi_watcher_database_definition:
 
@@ -349,6 +361,28 @@ State Machine diagrams
 Audit State Machine
 -------------------
 
+An :ref:`Audit <audit_definition>` has a life-cycle and its current state may
+be one of the following:
+
+-  **PENDING** : a request for an :ref:`Audit <audit_definition>` has been
+   submitted (either manually by the
+   :ref:`Administrator <administrator_definition>` or automatically via some
+   event handling mechanism) and is in the queue for being processed by the
+   :ref:`Watcher Decision Engine <watcher_decision_engine_definition>`
+-  **ONGOING** : the :ref:`Audit <audit_definition>` is currently being
+   processed by the
+   :ref:`Watcher Decision Engine <watcher_decision_engine_definition>`
+-  **SUCCEEDED** : the :ref:`Audit <audit_definition>` has been executed
+   successfully and at least one solution was found
+-  **FAILED** : an error occured while executing the
+   :ref:`Audit <audit_definition>`
+-  **DELETED** : the :ref:`Audit <audit_definition>` is still stored in the
+   :ref:`Watcher database <watcher_database_definition>` but is not returned
+   any more through the Watcher APIs.
+-  **CANCELLED** : the :ref:`Audit <audit_definition>` was in **PENDING** or
+   **ONGOING** state and was cancelled by the
+   :ref:`Administrator <administrator_definition>`
+
 The following diagram shows the different possible states of an
 :ref:`Audit <audit_definition>` and what event makes the state change to a new
 value:
@@ -361,6 +395,31 @@ value:
 Action Plan State Machine
 -------------------------
 
+An :ref:`Action Plan <action_plan_definition>` has a life-cycle and its current
+state may be one of the following:
+
+-  **RECOMMENDED** : the :ref:`Action Plan <action_plan_definition>` is waiting
+   for a validation from the :ref:`Administrator <administrator_definition>`
+-  **PENDING** : a request for an :ref:`Action Plan <action_plan_definition>`
+   has been submitted (due to an
+   :ref:`Administrator <administrator_definition>` executing an
+   :ref:`Audit <audit_definition>`) and is in the queue for
+   being processed by the :ref:`Watcher Applier <watcher_applier_definition>`
+-  **ONGOING** : the :ref:`Action Plan <action_plan_definition>` is currently
+   being processed by the :ref:`Watcher Applier <watcher_applier_definition>`
+-  **SUCCEEDED** : the :ref:`Action Plan <action_plan_definition>` has been
+   executed successfully (i.e. all :ref:`Actions <action_definition>` that it
+   contains have been executed successfully)
+-  **FAILED** : an error occured while executing the
+   :ref:`Action Plan <action_plan_definition>`
+-  **DELETED** : the :ref:`Action Plan <action_plan_definition>` is still
+   stored in the :ref:`Watcher database <watcher_database_definition>` but is
+   not returned any more through the Watcher APIs.
+-  **CANCELLED** : the :ref:`Action Plan <action_plan_definition>` was in
+   **PENDING** or **ONGOING** state and was cancelled by the
+   :ref:`Administrator <administrator_definition>`
+
+
 The following diagram shows the different possible states of an
 :ref:`Action Plan <action_plan_definition>` and what event makes the state
 change to a new value:

doc/source/conf.py

@@ -18,6 +18,7 @@ from watcher import version as watcher_version
 # Add any Sphinx extension module names here, as strings. They can be
 # extensions coming with Sphinx (named 'sphinx.ext.*') or your custom ones.
 extensions = [
+    'oslo_config.sphinxconfiggen',
     'sphinx.ext.autodoc',
     'sphinx.ext.viewcode',
     'sphinxcontrib.httpdomain',
@@ -28,7 +29,8 @@ extensions = [
 ]
 
 wsme_protocols = ['restjson']
-
+config_generator_config_file = '../../etc/watcher/watcher-config-generator.conf'
+sample_config_basename = 'watcher'
 
 # autodoc generation is a bit aggressive and a nuisance when doing heavy
 # text edit cycles.

doc/source/config-generator.conf

@@ -0,0 +1 @@
+../../etc/watcher/watcher-config-generator.conf

doc/source/deploy/conf-files.rst

@@ -0,0 +1,14 @@
+.. _watcher_sample_configuration_files:
+
+==================================
+Watcher sample configuration files
+==================================
+
+watcher.conf
+~~~~~~~~~~~~
+
+The ``watcher.conf`` file contains most of the options to configure the
+Watcher services.
+
+.. literalinclude:: ../watcher.conf.sample
+   :language: ini

doc/source/deploy/configuration.rst

@@ -34,6 +34,8 @@ The Watcher service includes the following components:
 - ``watcher-applier``: applies the action plan.
 - `python-watcherclient`_: A command-line interface (CLI) for interacting with
   the Watcher service.
+- `watcher-dashboard`_: An Horizon plugin for interacting with the Watcher
+  service.
 
 Additionally, the Bare Metal service has certain external dependencies, which
 are very similar to other OpenStack services:
@@ -52,6 +54,7 @@ additional functionality:
 .. _`ceilometer`: https://github.com/openstack/ceilometer
 .. _`nova`: https://github.com/openstack/nova
 .. _`python-watcherclient`: https://github.com/openstack/python-watcherclient
+.. _`watcher-dashboard`: https://github.com/openstack/watcher-dashboard
 .. _`watcher metering`: https://github.com/b-com/watcher-metering
 .. _`RabbitMQ`: https://www.rabbitmq.com/
 
@@ -160,17 +163,33 @@ Configure the Watcher service
 The Watcher service is configured via its configuration file. This file
 is typically located at ``/etc/watcher/watcher.conf``.
 
+You can easily generate and update a sample configuration file
+named :ref:`watcher.conf.sample <watcher_sample_configuration_files>` by using
+these following commands::
+
+    $ git clone git://git.openstack.org/openstack/watcher
+    $ cd watcher/
+    $ tox -econfig
+    $ vi etc/watcher/watcher.conf.sample
+
+
 The configuration file is organized into the following sections:
 
 * ``[DEFAULT]`` - General configuration
 * ``[api]`` - API server configuration
 * ``[database]`` - SQL driver configuration
 * ``[keystone_authtoken]`` - Keystone Authentication plugin configuration
+* ``[watcher_clients_auth]`` - Keystone auth configuration for clients
 * ``[watcher_applier]`` - Watcher Applier module configuration
 * ``[watcher_decision_engine]`` - Watcher Decision Engine module configuration
 * ``[watcher_goals]`` - Goals mapping configuration
 * ``[watcher_strategies]`` - Strategy configuration
 * ``[oslo_messaging_rabbit]`` - Oslo Messaging RabbitMQ driver configuration
+* ``[ceilometer_client]`` - Ceilometer client configuration
+* ``[cinder_client]`` - Cinder client configuration
+* ``[glance_client]`` - Glance client configuration
+* ``[nova_client]`` - Nova client configuration
+* ``[neutron_client]`` - Neutron client configuration
 
 The Watcher configuration file is expected to be named
 ``watcher.conf``. When starting Watcher, you can specify a different
@@ -237,39 +256,105 @@ so that the watcher service is configured for your needs.
     #rabbit_port = 5672
 
 
-#. Configure the Watcher Service to use these credentials with the Identity
-   Service. Replace IDENTITY_IP with the IP of the Identity server, and
-   replace WATCHER_PASSWORD with the password you chose for the ``watcher``
-   user in the Identity Service::
+#. Watcher API shall validate the token provided by every incoming request,
+   via keystonemiddleware, which requires the Watcher service to be configured
+   with the right credentials for the Identity service.
 
-    [keystone_authtoken]
+   In the configuration section here below:
 
-    # Complete public Identity API endpoint (string value)
-    #auth_uri=<None>
-    auth_uri=http://IDENTITY_IP:5000/v3
+   * replace IDENTITY_IP with the IP of the Identity server
+   * replace WATCHER_PASSWORD with the password you chose for the ``watcher``
+     user
+   * replace KEYSTONE_SERVICE_PROJECT_NAME with the name of project created
+     for OpenStack services (e.g. ``service``) ::
 
-    # Complete admin Identity API endpoint. This should specify the
-    # unversioned root endpoint e.g. https://localhost:35357/ (string
-    # value)
-    #identity_uri = <None>
-    identity_uri = http://IDENTITY_IP:5000
+        [keystone_authtoken]
 
-    # Keystone account username (string value)
-    #admin_user=<None>
-    admin_user=watcher
+        # Authentication type to load (unknown value)
+        # Deprecated group/name - [DEFAULT]/auth_plugin
+        #auth_type = <None>
+        auth_type = password
 
-    # Keystone account password (string value)
-    #admin_password=<None>
-    admin_password=WATCHER_DBPASSWORD
+        # Authentication URL (unknown value)
+        #auth_url = <None>
+        auth_url = http://IDENTITY_IP:35357
 
-    # Keystone service account tenant name to validate user tokens
-    # (string value)
-    #admin_tenant_name=admin
-    admin_tenant_name=KEYSTONE_SERVICE_PROJECT_NAME
+        # Username (unknown value)
+        # Deprecated group/name - [DEFAULT]/username
+        #username = <None>
+        username=watcher
 
-    # Directory used to cache files related to PKI tokens (string
-    # value)
-    #signing_dir=<None>
+        # User's password (unknown value)
+        #password = <None>
+        password = WATCHER_PASSWORD
+
+        # Domain ID containing project (unknown value)
+        #project_domain_id = <None>
+        project_domain_id = default
+
+        # User's domain id (unknown value)
+        #user_domain_id = <None>
+        user_domain_id = default
+
+        # Project name to scope to (unknown value)
+        # Deprecated group/name - [DEFAULT]/tenant-name
+        #project_name = <None>
+        project_name = KEYSTONE_SERVICE_PROJECT_NAME
+
+#. Watcher's decision engine and applier interact with other OpenStack
+   projects through those projects' clients. In order to instantiate these
+   clients, Watcher needs to request a new session from the Identity service
+   using the right credentials.
+
+   In the configuration section here below:
+
+   * replace IDENTITY_IP with the IP of the Identity server
+   * replace WATCHER_PASSWORD with the password you chose for the ``watcher``
+     user
+   * replace KEYSTONE_SERVICE_PROJECT_NAME with the name of project created
+     for OpenStack services (e.g. ``service``) ::
+
+        [watcher_clients_auth]
+
+        # Authentication type to load (unknown value)
+        # Deprecated group/name - [DEFAULT]/auth_plugin
+        #auth_type = <None>
+        auth_type = password
+
+        # Authentication URL (unknown value)
+        #auth_url = <None>
+        auth_url = http://IDENTITY_IP:35357
+
+        # Username (unknown value)
+        # Deprecated group/name - [DEFAULT]/username
+        #username = <None>
+        username=watcher
+
+        # User's password (unknown value)
+        #password = <None>
+        password = WATCHER_PASSWORD
+
+        # Domain ID containing project (unknown value)
+        #project_domain_id = <None>
+        project_domain_id = default
+
+        # User's domain id (unknown value)
+        #user_domain_id = <None>
+        user_domain_id = default
+
+        # Project name to scope to (unknown value)
+        # Deprecated group/name - [DEFAULT]/tenant-name
+        #project_name = <None>
+        project_name = KEYSTONE_SERVICE_PROJECT_NAME
+
+#. Configure the clients to use a specific version if desired. For example, to
+   configure Watcher to use a Nova client with version 2.1, use::
+
+    [nova_client]
+
+    # Version of Nova API to use in novaclient. (string value)
+    #api_version = 2
+    api_version = 2.1
 
 #. Create the Watcher Service database tables::
 

doc/source/deploy/user-guide.rst

@@ -38,7 +38,11 @@ If you need help on a specific command, you can use:
 
   $ watcher help COMMAND
 
+If you want to deploy Watcher in Horizon, please refer to the `Watcher Horizon
+plugin installation guide`_.
+
 .. _`installation guide`: https://factory.b-com.com/www/watcher/doc/python-watcherclient
+.. _`Watcher Horizon plugin installation guide`: https://factory.b-com.com/www/watcher/doc/watcher-dashboard/deploy/installation.html
 
 Seeing what the Watcher CLI can do ?
 ------------------------------------
@@ -60,7 +64,7 @@ This goal should be declared in the Watcher service configuration file
 
 .. code:: bash
 
-  $ watcher audit-template-create my_first_audit SERVERS_CONSOLIDATION
+  $ watcher audit-template-create my_first_audit DUMMY
 
 If you get "*You must provide a username via either --os-username or via
 env[OS_USERNAME]*" you may have to verify your credentials.

doc/source/dev/contributing.rst

@@ -60,3 +60,12 @@ Code Hosting
 Code Review
     https://review.openstack.org/#/q/status:open+project:openstack/watcher,n,z
 
+IRC Channel
+    ``#openstack-watcher`` (changelog_)
+
+Weekly Meetings
+    on Wednesdays at 14:00 UTC in the ``#openstack-meeting-4`` IRC
+    channel (`meetings logs`_)
+
+.. _changelog: http://eavesdrop.openstack.org/irclogs/%23openstack-watcher/
+.. _meetings logs:  http://eavesdrop.openstack.org/meetings/watcher/

doc/source/dev/devstack.rst

@@ -9,35 +9,97 @@ Set up a development environment via DevStack
 =============================================
 
 Watcher is currently able to optimize compute resources - specifically Nova
-compute hosts - via operations such as live migrations.  In order for you to
+compute hosts - via operations such as live migrations. In order for you to
 fully be able to exercise what Watcher can do, it is necessary to have a
-multinode environment to use.  If you have no experience with DevStack, you
-should check out the `DevStack documentation`_ and be comfortable with the
-basics of DevStack before attempting to get a multinode DevStack setup with
-the Watcher plugin.
+multinode environment to use.
 
 You can set up the Watcher services quickly and easily using a Watcher
-DevStack plugin.  See `PluginModelDocs`_ for information on DevStack's plugin
-model.
-
-.. _DevStack documentation: http://docs.openstack.org/developer/devstack/
-.. _PluginModelDocs: http://docs.openstack.org/developer/devstack/plugins.html
-
-It is recommended that you build off of the provided example local.conf files
-(`local.conf.controller`_, `local.conf.compute`_).  You'll likely want to
-configure something to obtain metrics, such as Ceilometer.  Ceilometer is used
-in the example local.conf files.
-
-To configure the Watcher services with DevStack, add the following to the
+DevStack plugin. See `PluginModelDocs`_ for information on DevStack's plugin
+model. To enable the Watcher plugin with DevStack, add the following to the
 `[[local|localrc]]` section of your controller's `local.conf` to enable the
 Watcher plugin::
 
     enable_plugin watcher git://git.openstack.org/openstack/watcher
 
-Then run devstack normally::
+For more detailed instructions, see `Detailed DevStack Instructions`_. Check
+out the `DevStack documentation`_ for more information regarding DevStack.
 
-    cd /opt/stack/devstack
-    ./stack.sh
+.. _PluginModelDocs: http://docs.openstack.org/developer/devstack/plugins.html
+.. _DevStack documentation: http://docs.openstack.org/developer/devstack/
+
+Detailed DevStack Instructions
+==============================
+
+#. Obtain N (where N >= 1) servers (virtual machines preferred for DevStack).
+   One of these servers will be the controller node while the others will be
+   compute nodes. N is preferably >= 3 so that you have at least 2 compute
+   nodes, but in order to stand up the Watcher services only 1 server is
+   needed (i.e., no computes are needed if you want to just experiment with
+   the Watcher services). These servers can be VMs running on your local
+   machine via VirtualBox if you prefer. DevStack currently recommends that
+   you use Ubuntu 14.04 LTS. The servers should also have connections to the
+   same network such that they are all able to communicate with one another.
+
+#. For each server, clone the DevStack repository and create the stack user::
+
+       sudo apt-get update
+       sudo apt-get install git
+       git clone https://git.openstack.org/openstack-dev/devstack
+       sudo ./devstack/tools/create-stack-user.sh
+
+   Now you have a stack user that is used to run the DevStack processes. You
+   may want to give your stack user a password to allow SSH via a password::
+
+       sudo passwd stack
+
+#. Switch to the stack user and clone the DevStack repo again::
+
+       sudo su stack
+       cd ~
+       git clone https://git.openstack.org/openstack-dev/devstack
+
+#. For each compute node, copy the provided `local.conf.compute`_ example file
+   to the compute node's system at ~/devstack/local.conf. Make sure the
+   HOST_IP and SERVICE_HOST values are changed appropriately - i.e., HOST_IP
+   is set to the IP address of the compute node and SERVICE_HOST is set to the
+   IP address of the controller node.
+
+   If you need specific metrics collected (or want to use something other
+   than Ceilometer), be sure to configure it. For example, in the
+   `local.conf.compute`_ example file, the appropriate ceilometer plugins and
+   services are enabled and disabled. If you were using something other than
+   Ceilometer, then you would likely want to configure it likewise. The
+   example file also sets the compute monitors nova configuration option to
+   use the CPU virt driver. If you needed other metrics, it may be necessary
+   to configure similar configuration options for the projects providing those
+   metrics.
+
+#. For the controller node, copy the provided `local.conf.controller`_ example
+   file to the controller node's system at ~/devstack/local.conf. Make sure
+   the HOST_IP value is changed appropriately - i.e., HOST_IP is set to the IP
+   address of the controller node.
+
+   Note: if you want to use another Watcher git repository (such as a local
+   one), then change the enable plugin line::
+
+       enable_plugin watcher <your_local_git_repo> [optional_branch]
+
+   If you do this, then the Watcher DevStack plugin will try to pull the
+   python-watcherclient repo from <your_local_git_repo>/../, so either make
+   sure that is also available or specify WATCHERCLIENT_REPO in the local.conf
+   file.
+
+   Note: if you want to use a specific branch, specify WATCHER_BRANCH in the
+   local.conf file. By default it will use the master branch.
+
+#. Start stacking from the controller node::
+
+       ./devstack/stack.sh
+
+#. Start stacking on each of the compute nodes using the same command.
+
+#. Configure the environment for live migration via NFS. See the
+   `Multi-Node DevStack Environment`_ section for more details.
 
 .. _local.conf.controller: https://github.com/openstack/watcher/tree/master/devstack/local.conf.controller
 .. _local.conf.compute: https://github.com/openstack/watcher/tree/master/devstack/local.conf.compute
@@ -104,7 +166,6 @@ Restart the libvirt service::
 
     sudo service libvirt-bin restart
 
-
 Setting up SSH keys between compute nodes to enable live migration
 ------------------------------------------------------------------
 
@@ -113,8 +174,8 @@ each compute node:
 
 1. The SOURCE root user's public RSA key (likely in /root/.ssh/id_rsa.pub)
    needs to be in the DESTINATION stack user's authorized_keys file
-   (~stack/.ssh/authorized_keys).  This can be accomplished by manually
-   copying the contents from the file on the SOURCE to the DESTINATION.  If
+   (~stack/.ssh/authorized_keys). This can be accomplished by manually
+   copying the contents from the file on the SOURCE to the DESTINATION. If
    you have a password configured for the stack user, then you can use the
    following command to accomplish the same thing::
 
@@ -122,7 +183,7 @@ each compute node:
 
 2. The DESTINATION host's public ECDSA key (/etc/ssh/ssh_host_ecdsa_key.pub)
    needs to be in the SOURCE root user's known_hosts file
-   (/root/.ssh/known_hosts).  This can be accomplished by running the
+   (/root/.ssh/known_hosts). This can be accomplished by running the
    following on the SOURCE machine (hostname must be used)::
 
         ssh-keyscan -H DEST_HOSTNAME | sudo tee -a /root/.ssh/known_hosts
@@ -131,3 +192,13 @@ In essence, this means that every compute node's root user's public RSA key
 must exist in every other compute node's stack user's authorized_keys file and
 every compute node's public ECDSA key needs to be in every other compute
 node's root user's known_hosts file.
+
+
+Environment final checkup
+-------------------------
+
+If you are willing to make sure everything is in order in your DevStack
+environment, you can run the Watcher Tempest tests which will validate its API
+but also that you can perform the typical Watcher workflows. To do so, have a
+look at the :ref:`Tempest tests <tempest_tests>` section which will explain to
+you how to run them.

doc/source/dev/environment.rst

@@ -4,6 +4,8 @@
 
           https://creativecommons.org/licenses/by/3.0/
 
+.. _watcher_developement_environment:
+
 =========================================
 Set up a development environment manually
 =========================================
@@ -143,34 +145,13 @@ You should then be able to `import watcher` using Python without issue:
 
 If you can import watcher without a traceback, you should be ready to develop.
 
-Run Watcher unit tests
-======================
+Run Watcher tests
+=================
 
-All unit tests should be run using tox. To run the unit tests under py27 and
-also run the pep8 tests:
+Watcher provides both :ref:`unit tests <unit_tests>` and
+:ref:`functional/tempest tests <tempest_tests>`. Please refer to :doc:`testing`
+to understand how to run them.
 
-.. code-block:: bash
-
-    $ workon watcher
-    (watcher) $ pip install tox
-
-    (watcher) $ cd watcher
-    (watcher) $ tox -epep8 -epy27
-
-You may pass options to the test programs using positional arguments. To run a
-specific unit test, this passes the -r option and desired test (regex string)
-to os-testr:
-
-.. code-block:: bash
-
-    $ workon watcher
-    (watcher) $ tox -epy27 -- tests.api
-
-When you're done, deactivate the virtualenv:
-
-.. code-block:: bash
-
-    $ deactivate
 
 Build the Watcher documentation
 ===============================
@@ -269,6 +250,11 @@ interface.
 
 .. _`python-watcherclient`: https://github.com/openstack/python-watcherclient
 
+There is also an Horizon plugin for Watcher `watcher-dashboard`_ which
+allows to interact with Watcher through a web-based interface.
+
+.. _`watcher-dashboard`: https://github.com/openstack/watcher-dashboard
+
 
 Exercising the Watcher Services locally
 =======================================

doc/source/dev/plugin/action-plugin.rst

@@ -0,0 +1,171 @@
+..
+      Except where otherwise noted, this document is licensed under Creative
+      Commons Attribution 3.0 License.  You can view the license at:
+
+          https://creativecommons.org/licenses/by/3.0/
+
+==================
+Build a new action
+==================
+
+Watcher Applier has an external :ref:`action <action_definition>` plugin
+interface which gives anyone the ability to integrate an external
+:ref:`action <action_definition>` in order to extend the initial set of actions
+Watcher provides.
+
+This section gives some guidelines on how to implement and integrate custom
+actions with Watcher.
+
+
+Creating a new plugin
+=====================
+
+First of all you have to extend the base :py:class:`BaseAction` class which
+defines a set of abstract methods and/or properties that you will have to
+implement:
+
+ - The :py:attr:`~.BaseAction.schema` is an abstract property that you have to
+   implement. This is the first function to be called by the
+   :ref:`applier <watcher_applier_definition>` before any further processing
+   and its role is to validate the input parameters that were provided to it.
+ - The :py:meth:`~.BaseAction.precondition` is called before the execution of
+   an action. This method is a hook that can be used to perform some
+   initializations or to make some more advanced validation on its input
+   parameters. If you wish to block the execution based on this factor, you
+   simply have to ``raise`` an exception.
+ - The :py:meth:`~.BaseAction.postcondition` is called after the execution of
+   an action. As this function is called regardless of whether an action
+   succeeded or not, this can prove itself useful to perform cleanup
+   operations.
+ - The :py:meth:`~.BaseAction.execute` is the main component of an action.
+   This is where you should implement the logic of your action.
+ - The :py:meth:`~.BaseAction.revert` allows you to roll back the targeted
+   resource to its original state following a faulty execution. Indeed, this
+   method is called by the workflow engine whenever an action raises an
+   exception.
+
+Here is an example showing how you can write a plugin called ``DummyAction``:
+
+.. code-block:: python
+
+    # Filepath = <PROJECT_DIR>/thirdparty/dummy.py
+    # Import path = thirdparty.dummy
+    import voluptuous
+
+    from watcher.applier.actions import base
+
+
+    class DummyAction(baseBaseAction):
+
+        @property
+        def schema(self):
+            return voluptuous.Schema({})
+
+        def execute(self):
+            # Does nothing
+            pass  # Only returning False is considered as a failure
+
+        def revert(self):
+            # Does nothing
+            pass
+
+        def precondition(self):
+            # No pre-checks are done here
+            pass
+
+        def postcondition(self):
+            # Nothing done here
+            pass
+
+
+This implementation is the most basic one. So if you want to have more advanced
+examples, have a look at the implementation of the actions already provided
+by Watcher like.
+To get a better understanding on how to implement a more advanced action,
+have a look at the :py:class:`~watcher.applier.actions.migration.Migrate`
+class.
+
+Input validation
+----------------
+
+As you can see in the previous example, we are using `Voluptuous`_ to validate
+the input parameters of an action. So if you want to learn more about how to
+work with `Voluptuous`_, you can have a look at their `documentation`_ here:
+
+.. _Voluptuous: https://github.com/alecthomas/voluptuous
+.. _documentation: https://github.com/alecthomas/voluptuous/blob/master/README.md
+
+Abstract Plugin Class
+=====================
+
+Here below is the abstract ``BaseAction`` class that every single action
+should implement:
+
+.. autoclass:: watcher.applier.actions.base.BaseAction
+    :members:
+    :noindex:
+
+    .. py:attribute:: schema
+
+        Defines a Schema that the input parameters shall comply to
+
+        :returns: A schema declaring the input parameters this action should be
+                  provided along with their respective constraints
+                  (e.g. type, value range, ...)
+        :rtype: :py:class:`voluptuous.Schema` instance
+
+
+Register a new entry point
+==========================
+
+In order for the Watcher Applier to load your new action, the
+action must be registered as a named entry point under the
+``watcher_actions`` entry point of your ``setup.py`` file. If you are using
+pbr_, this entry point should be placed in your ``setup.cfg`` file.
+
+The name you give to your entry point has to be unique.
+
+Here below is how you would proceed to register ``DummyAction`` using pbr_:
+
+.. code-block:: ini
+
+    [entry_points]
+    watcher_actions =
+        dummy = thirdparty.dummy:DummyAction
+
+.. _pbr: http://docs.openstack.org/developer/pbr/
+
+
+Using action plugins
+====================
+
+The Watcher Applier service will automatically discover any installed plugins
+when it is restarted. If a Python package containing a custom plugin is
+installed within the same environment as Watcher, Watcher will automatically
+make that plugin available for use.
+
+At this point, you can use your new action plugin in your :ref:`strategy plugin
+<implement_strategy_plugin>` if you reference it via the use of the
+:py:meth:`~.Solution.add_action` method:
+
+.. code-block:: python
+
+    # [...]
+    self.solution.add_action(
+        action_type="dummy",  # Name of the entry point we registered earlier
+        applies_to="",
+        input_parameters={})
+
+By doing so, your action will be saved within the Watcher Database, ready to be
+processed by the planner for creating an action plan which can then be executed
+by the Watcher Applier via its workflow engine.
+
+
+Scheduling of an action plugin
+==============================
+
+Watcher provides a basic built-in :ref:`planner <watcher_planner_definition>`
+which is only able to process the Watcher built-in actions. Therefore, you will
+either have to use an existing third-party planner or :ref:`implement another
+planner <implement_planner_plugin>` that will be able to take into account your
+new action plugin.

doc/source/dev/plugin/base-setup.rst

@@ -0,0 +1,90 @@
+..
+      Except where otherwise noted, this document is licensed under Creative
+      Commons Attribution 3.0 License.  You can view the license at:
+
+          https://creativecommons.org/licenses/by/3.0/
+
+.. _plugin-base_setup:
+
+=======================================
+Create a third-party plugin for Watcher
+=======================================
+
+Watcher provides a plugin architecture which allows anyone to extend the
+existing functionalities by implementing third-party plugins. This process can
+be cumbersome so this documentation is there to help you get going as quickly
+as possible.
+
+
+Pre-requisites
+==============
+
+We assume that you have set up a working Watcher development environment. So if
+this not already the case, you can check out our documentation which explains
+how to set up a :ref:`development environment
+<watcher_developement_environment>`.
+
+.. _development environment:
+
+Third party project scaffolding
+===============================
+
+First off, we need to create the project structure. To do so, we can use
+`cookiecutter`_ and the `OpenStack cookiecutter`_ project scaffolder to
+generate the skeleton of our project::
+
+    $ virtualenv thirdparty
+    $ source thirdparty/bin/activate
+    $ pip install cookiecutter
+    $ cookiecutter https://github.com/openstack-dev/cookiecutter
+
+The last command will ask you for many information, and If you set
+``module_name`` and ``repo_name`` as ``thirdparty``, you should end up with a
+structure that looks like this::
+
+    $ cd thirdparty
+    $ tree .
+    .
+    ├── babel.cfg
+    ├── CONTRIBUTING.rst
+    ├── doc
+    │   └── source
+    │       ├── conf.py
+    │       ├── contributing.rst
+    │       ├── index.rst
+    │       ├── installation.rst
+    │       ├── readme.rst
+    │       └── usage.rst
+    ├── HACKING.rst
+    ├── LICENSE
+    ├── MANIFEST.in
+    ├── README.rst
+    ├── requirements.txt
+    ├── setup.cfg
+    ├── setup.py
+    ├── test-requirements.txt
+    ├── thirdparty
+    │   ├── __init__.py
+    │   └── tests
+    │       ├── base.py
+    │       ├── __init__.py
+    │       └── test_thirdparty.py
+    └── tox.ini
+
+.. _cookiecutter: https://github.com/audreyr/cookiecutter
+.. _OpenStack cookiecutter: https://github.com/openstack-dev/cookiecutter
+
+Implementing a plugin for Watcher
+=================================
+
+Now that the project skeleton has been created, you can start the
+implementation of your plugin. As of now, you can implement the following
+plugins for Watcher:
+
+- A :ref:`strategy plugin <implement_strategy_plugin>`
+- A :ref:`planner plugin <implement_planner_plugin>`
+- An :ref:`action plugin <implement_strategy_plugin>`
+- A :ref:`workflow engine plugin <implement_workflow_engine_plugin>`
+
+If you want to learn more on how to implement them, you can refer to their
+dedicated documentation.

doc/source/dev/plugin/planner-plugin.rst

@@ -0,0 +1,127 @@
+..
+      Except where otherwise noted, this document is licensed under Creative
+      Commons Attribution 3.0 License.  You can view the license at:
+
+          https://creativecommons.org/licenses/by/3.0/
+
+.. _implement_planner_plugin:
+
+===================
+Build a new planner
+===================
+
+Watcher :ref:`Decision Engine <watcher_decision_engine_definition>` has an
+external :ref:`planner <planner_definition>` plugin interface which gives
+anyone the ability to integrate an external :ref:`planner <planner_definition>`
+in order to extend the initial set of planners Watcher provides.
+
+This section gives some guidelines on how to implement and integrate custom
+planners with Watcher.
+
+.. _Decision Engine: watcher_decision_engine_definition
+
+Creating a new plugin
+=====================
+
+First of all you have to extend the base :py:class:`~.BasePlanner` class which
+defines an abstract method that you will have to implement. The
+:py:meth:`~.BasePlanner.schedule` is the method being called by the Decision
+Engine to schedule a given solution (:py:class:`~.BaseSolution`) into an
+:ref:`action plan <action_plan_definition>` by ordering/sequencing an unordered
+set of actions contained in the proposed solution (for more details, see
+:ref:`definition of a solution <solution_definition>`).
+
+Here is an example showing how you can write a planner plugin called
+``DummyPlanner``:
+
+.. code-block:: python
+
+    # Filepath = third-party/third_party/dummy.py
+    # Import path = third_party.dummy
+    import uuid
+    from watcher.decision_engine.planner import base
+
+
+    class DummyPlanner(base.BasePlanner):
+
+        def _create_action_plan(self, context, audit_id):
+            action_plan_dict = {
+                'uuid': uuid.uuid4(),
+                'audit_id': audit_id,
+                'first_action_id': None,
+                'state': objects.action_plan.State.RECOMMENDED
+            }
+
+            new_action_plan = objects.ActionPlan(context, **action_plan_dict)
+            new_action_plan.create(context)
+            new_action_plan.save()
+            return new_action_plan
+
+        def schedule(self, context, audit_id, solution):
+            # Empty action plan
+            action_plan = self._create_action_plan(context, audit_id)
+            # todo: You need to create the workflow of actions here
+            # and attach it to the action plan
+            return action_plan
+
+This implementation is the most basic one. So if you want to have more advanced
+examples, have a look at the implementation of planners already provided by
+Watcher like :py:class:`~.DefaultPlanner`. A list with all available planner
+plugins can be found :ref:`here <watcher_planners>`.
+
+Abstract Plugin Class
+=====================
+
+Here below is the abstract ``BasePlanner`` class that every single planner
+should implement:
+
+.. autoclass:: watcher.decision_engine.planner.base.BasePlanner
+    :members:
+    :noindex:
+
+
+Register a new entry point
+==========================
+
+In order for the Watcher Decision Engine to load your new planner, the
+latter must be registered as a new entry point under the
+``watcher_planners`` entry point namespace of your ``setup.py`` file. If you
+are using pbr_, this entry point should be placed in your ``setup.cfg`` file.
+
+The name you give to your entry point has to be unique.
+
+Here below is how you would proceed to register ``DummyPlanner`` using pbr_:
+
+.. code-block:: ini
+
+    [entry_points]
+    watcher_planners =
+        dummy = third_party.dummy:DummyPlanner
+
+.. _pbr: http://docs.openstack.org/developer/pbr/
+
+
+Using planner plugins
+=====================
+
+The :ref:`Watcher Decision Engine <watcher_decision_engine_definition>` service
+will automatically discover any installed plugins when it is started. This
+means that if Watcher is already running when you install your plugin, you will
+have to restart the related Watcher services. If a Python package containing a
+custom plugin is installed within the same environment as Watcher, Watcher will
+automatically make that plugin available for use.
+
+At this point, Watcher will use your new planner if you referenced it in the
+``planner`` option under the ``[watcher_planner]`` section of your
+``watcher.conf`` configuration file when you started it. For example, if you
+want to use the ``dummy`` planner you just installed, you would have to
+select it as followed:
+
+.. code-block:: ini
+
+    [watcher_planner]
+    planner = dummy
+
+As you may have noticed, only a single planner implementation can be activated
+at a time, so make sure it is generic enough to support all your strategies
+and actions.

doc/source/dev/plugin/strategy-plugin.rst

@@ -4,17 +4,19 @@
 
           https://creativecommons.org/licenses/by/3.0/
 
+.. _implement_strategy_plugin:
+
 =================================
 Build a new optimization strategy
 =================================
 
 Watcher Decision Engine has an external :ref:`strategy <strategy_definition>`
 plugin interface which gives anyone the ability to integrate an external
-:ref:`strategy <strategy_definition>` in order to make use of placement
-algorithms.
+strategy in order to make use of placement algorithms.
 
 This section gives some guidelines on how to implement and integrate custom
-Stategies with Watcher.
+strategies with Watcher.
+
 
 Pre-requisites
 ==============
@@ -29,15 +31,14 @@ Creating a new plugin
 
 First of all you have to:
 
-- Extend the base ``BaseStrategy`` class
-- Implement its ``execute`` method
+- Extend :py:class:`~.BaseStrategy`
+- Implement its :py:meth:`~.BaseStrategy.execute` method
 
 Here is an example showing how you can write a plugin called ``DummyStrategy``:
 
 .. code-block:: python
 
-    # Filepath = third-party/third_party/dummy.py
-    # Import path = third_party.dummy
+    import uuid
 
     class DummyStrategy(BaseStrategy):
 
@@ -48,14 +49,25 @@ Here is an example showing how you can write a plugin called ``DummyStrategy``:
             super(DummyStrategy, self).__init__(name, description)
 
         def execute(self, model):
-            self.solution.add_change_request(
-                Migrate(vm=my_vm, src_hypervisor=src, dest_hypervisor=dest)
-            )
+            migration_type = 'live'
+            src_hypervisor = 'compute-host-1'
+            dst_hypervisor = 'compute-host-2'
+            instance_id = uuid.uuid4()
+            parameters = {'migration_type': migration_type,
+                          'src_hypervisor': src_hypervisor,
+                          'dst_hypervisor': dst_hypervisor}
+            self.solution.add_action(action_type="migration",
+                                     resource_id=instance_id,
+                                     input_parameters=parameters)
             # Do some more stuff here ...
             return self.solution
 
-As you can see in the above example, the ``execute()`` method returns a
-solution as required.
+As you can see in the above example, the :py:meth:`~.BaseStrategy.execute`
+method returns a :py:class:`~.BaseSolution` instance as required. This solution
+is what wraps the abstract set of actions the strategy recommends to you. This
+solution is then processed by a :ref:`planner <planner_definition>` to produce
+an action plan which shall contain the sequenced flow of actions to be
+executed by the :ref:`Watcher Applier <watcher_applier_definition>`.
 
 Please note that your strategy class will be instantiated without any
 parameter. Therefore, you should make sure not to make any of them required in
@@ -65,13 +77,10 @@ your ``__init__`` method.
 Abstract Plugin Class
 =====================
 
-Here below is the abstract ``BaseStrategy`` class that every single strategy
-should implement:
+Here below is the abstract :py:class:`~.BaseStrategy` class that every single
+strategy should implement:
 
-.. automodule:: watcher.decision_engine.strategy.strategies.base
-    :noindex:
-
-.. autoclass:: BaseStrategy
+.. autoclass:: watcher.decision_engine.strategy.strategies.base.BaseStrategy
     :members:
     :noindex:
 
@@ -92,11 +101,11 @@ Here below is how you would proceed to register ``DummyStrategy`` using pbr_:
 
     [entry_points]
     watcher_strategies =
-        dummy = third_party.dummy:DummyStrategy
+        dummy = thirdparty.dummy:DummyStrategy
 
 
 To get a better understanding on how to implement a more advanced strategy,
-have a look at the :py:class:`BasicConsolidation` class.
+have a look at the :py:class:`~.BasicConsolidation` class.
 
 .. _pbr: http://docs.openstack.org/developer/pbr/
 
@@ -104,12 +113,12 @@ Using strategy plugins
 ======================
 
 The Watcher Decision Engine service will automatically discover any installed
-plugins when it is run. If a Python package containing a custom plugin is
+plugins when it is restarted. If a Python package containing a custom plugin is
 installed within the same environment as Watcher, Watcher will automatically
 make that plugin available for use.
 
-At this point, the way Watcher will use your new strategy if you reference it
-in the ``goals`` under the ``[watcher_goals]`` section of your ``watcher.conf``
+At this point, Watcher will use your new strategy if you reference it in the
+``goals`` under the ``[watcher_goals]`` section of your ``watcher.conf``
 configuration file. For example, if you want to use a ``dummy`` strategy you
 just installed, you would have to associate it to a goal like this:
 
@@ -143,13 +152,13 @@ pluggable backend.
 Finally, if your strategy requires new metrics not covered by Ceilometer, you
 can add them through a Ceilometer `plugin`_.
 
-
 .. _`Helper`: https://github.com/openstack/watcher/blob/master/watcher/metrics_engine/cluster_history/ceilometer.py#L31
 .. _`Ceilometer developer guide`: http://docs.openstack.org/developer/ceilometer/architecture.html#storing-the-data
 .. _`here`: http://docs.openstack.org/developer/ceilometer/install/dbreco.html#choosing-a-database-backend
 .. _`plugin`: http://docs.openstack.org/developer/ceilometer/plugins.html
 .. _`Ceilosca`: https://github.com/openstack/monasca-ceilometer/blob/master/ceilosca/ceilometer/storage/impl_monasca.py
 
+
 Read usage metrics using the Python binding
 -------------------------------------------
 
@@ -157,39 +166,43 @@ You can find the information about the Ceilometer Python binding on the
 OpenStack `ceilometer client python API documentation
 <http://docs.openstack.org/developer/python-ceilometerclient/api.html>`_
 
-The first step is to authenticate against the Ceilometer service
-(assuming that you already imported the Ceilometer client for Python)
-with this call:
+To facilitate the process, Watcher provides the ``osc`` attribute to every
+strategy which includes clients to major OpenStack services, including
+Ceilometer. So to access it within your strategy, you can do the following:
 
 .. code-block:: py
 
- cclient = ceilometerclient.client.get_client(VERSION, os_username=USERNAME,
-  os_password=PASSWORD, os_tenant_name=PROJECT_NAME, os_auth_url=AUTH_URL)
+    # Within your strategy "execute()"
+    cclient = self.osc.ceilometer
+    # TODO: Do something here
 
 Using that you can now query the values for that specific metric:
 
 .. code-block:: py
 
- value_cpu = cclient.samples.list(meter_name='cpu_util', limit=10, q=query)
+    query = None  # e.g. [{'field': 'foo', 'op': 'le', 'value': 34},]
+    value_cpu = cclient.samples.list(
+        meter_name='cpu_util',
+        limit=10, q=query)
+
 
 Read usage metrics using the Watcher Cluster History Helper
 -----------------------------------------------------------
 
 Here below is the abstract ``BaseClusterHistory`` class of the Helper.
 
-.. automodule:: watcher.metrics_engine.cluster_history.api
-    :noindex:
-
-.. autoclass:: BaseClusterHistory
+.. autoclass:: watcher.metrics_engine.cluster_history.api.BaseClusterHistory
     :members:
     :noindex:
 
 
-The following snippet code shows how to create a Cluster History class:
+The following code snippet shows how to create a Cluster History class:
 
 .. code-block:: py
 
-    query_history  = CeilometerClusterHistory()
+    from watcher.metrics_engine.cluster_history import ceilometer as ceil
+
+    query_history  = ceil.CeilometerClusterHistory()
 
 Using that you can now query the values for that specific metric:
 
@@ -200,4 +213,3 @@ Using that you can now query the values for that specific metric:
                                   period="7200",
                                   aggregate='avg'
                                   )
-

doc/source/dev/plugins.rst

@@ -0,0 +1,38 @@
+..
+      Except where otherwise noted, this document is licensed under Creative
+      Commons Attribution 3.0 License.  You can view the license at:
+
+          https://creativecommons.org/licenses/by/3.0/
+
+
+=================
+Available Plugins
+=================
+
+.. _watcher_strategies:
+
+Strategies
+==========
+
+.. drivers-doc:: watcher_strategies
+
+.. _watcher_actions:
+
+Actions
+=======
+
+.. drivers-doc:: watcher_actions
+
+.. _watcher_workflow_engines:
+
+Workflow Engines
+================
+
+.. drivers-doc:: watcher_workflow_engines
+
+.. _watcher_planners:
+
+Planners
+========
+
+.. drivers-doc:: watcher_planners

doc/source/dev/testing.rst

@@ -0,0 +1,50 @@
+..
+      Except where otherwise noted, this document is licensed under Creative
+      Commons Attribution 3.0 License.  You can view the license at:
+
+          https://creativecommons.org/licenses/by/3.0/
+
+=======
+Testing
+=======
+
+.. _unit_tests:
+
+Unit tests
+==========
+
+All unit tests should be run using `tox`_. To run the same unit tests that are
+executing onto `Gerrit`_ which includes ``py34``, ``py27`` and ``pep8``, you
+can issue the following command::
+
+    $ workon watcher
+    (watcher) $ pip install tox
+    (watcher) $ cd watcher
+    (watcher) $ tox
+
+If you want to only run one of the aforementioned, you can then issue one of
+the following::
+
+    $ workon watcher
+    (watcher) $ tox -e py34
+    (watcher) $ tox -e py27
+    (watcher) $ tox -e pep8
+
+.. _tox: https://tox.readthedocs.org/
+.. _Gerrit: http://review.openstack.org/
+
+You may pass options to the test programs using positional arguments. To run a
+specific unit test, you can pass extra options to `os-testr`_ after putting
+the ``--`` separator. So using the ``-r`` option followed by a regex string,
+you can run the desired test::
+
+    $ workon watcher
+    (watcher) $ tox -e py27 -- -r watcher.tests.api
+
+.. _os-testr: http://docs.openstack.org/developer/os-testr/
+
+When you're done, deactivate the virtualenv::
+
+    $ deactivate
+
+.. include:: ../../../watcher_tempest_plugin/README.rst

doc/source/glossary.rst

@@ -213,27 +213,27 @@ Here are some examples of
 
 It can be any of the `the official list of available resource types defined in OpenStack for HEAT <http://docs.openstack.org/developer/heat/template_guide/openstack.html>`_.
 
-.. _efficiency_definition:
+.. _efficacy_definition:
 
-Optimization Efficiency
-=======================
+Optimization Efficacy
+=====================
 
-The :ref:`Optimization Efficiency <efficiency_definition>` is the objective
+The :ref:`Optimization Efficacy <efficacy_definition>` is the objective
 measure of how much of the :ref:`Goal <goal_definition>` has been achieved in
 respect with constraints and :ref:`SLAs <sla_definition>` defined by the
 :ref:`Customer <customer_definition>`.
 
-The way efficiency is evaluated will depend on the
+The way efficacy is evaluated will depend on the
 :ref:`Goal <goal_definition>` to achieve.
 
-Of course, the efficiency will be relevant only as long as the
+Of course, the efficacy will be relevant only as long as the
 :ref:`Action Plan <action_plan_definition>` is relevant
 (i.e., the current state of the :ref:`Cluster <cluster_definition>`
 has not changed in a way that a new :ref:`Audit <audit_definition>` would need
 to be launched).
 
 For example, if the :ref:`Goal <goal_definition>` is to lower the energy
-consumption, the :ref:`Efficiency <efficiency_definition>` will be computed
+consumption, the :ref:`Efficacy <efficacy_definition>` will be computed
 using several indicators (KPIs):
 
 -  the percentage of energy gain (which must be the highest possible)
@@ -244,7 +244,7 @@ using several indicators (KPIs):
 All those indicators (KPIs) are computed within a given timeframe, which is the
 time taken to execute the whole :ref:`Action Plan <action_plan_definition>`.
 
-The efficiency also enables the :ref:`Administrator <administrator_definition>`
+The efficacy also enables the :ref:`Administrator <administrator_definition>`
 to objectively compare different :ref:`Strategies <strategy_definition>` for
 the same goal and same workload of the :ref:`Cluster <cluster_definition>`.
 

doc/source/image_src/plantuml/action_plan_state_machine.txt

@@ -1,15 +1,15 @@
 @startuml
 
 [*] --> RECOMMENDED: The Watcher Planner\ncreates the Action Plan
-RECOMMENDED --> TRIGGERED: Administrator launches\nthe Action Plan
-TRIGGERED --> ONGOING: The Watcher Applier receives the request\nto launch the Action Plan
+RECOMMENDED --> PENDING: Adminisrator launches\nthe Action Plan
+PENDING --> ONGOING: The Watcher Applier receives the request\nto launch the Action Plan
 ONGOING --> FAILED: Something failed while executing\nthe Action Plan in the Watcher Applier
 ONGOING --> SUCCEEDED: The Watcher Applier executed\nthe Action Plan successfully
 FAILED --> DELETED : Administrator removes\nAction Plan
 SUCCEEDED --> DELETED : Administrator removes\nAction Plan
 ONGOING --> CANCELLED : Administrator cancels\nAction Plan
 RECOMMENDED --> CANCELLED : Administrator cancels\nAction Plan
-TRIGGERED --> CANCELLED : Administrator cancels\nAction Plan
+PENDING --> CANCELLED : Administrator cancels\nAction Plan
 CANCELLED --> DELETED
 DELETED --> [*]
 

doc/source/index.rst

@@ -22,6 +22,7 @@ Watcher project consists of several source code repositories:
 * `watcher`_ - is the main repository. It contains code for Watcher API server,
   Watcher Decision Engine and Watcher Applier.
 * `python-watcherclient`_ - Client library and CLI client for Watcher.
+* `watcher-dashboard`_ - Watcher Horizon plugin.
 
 The documentation provided here is continually kept up-to-date based
 on the latest code, and may not represent the state of the project at any
@@ -29,6 +30,7 @@ specific prior release.
 
 .. _watcher: https://git.openstack.org/cgit/openstack/watcher/
 .. _python-watcherclient: https://git.openstack.org/cgit/openstack/python-watcherclient/
+.. _watcher-dashboard: https://git.openstack.org/cgit/openstack/watcher-dashboard/
 
 Developer Guide
 ===============
@@ -53,7 +55,8 @@ Getting Started
   dev/environment
   dev/devstack
   deploy/configuration
-
+  deploy/conf-files
+  dev/testing
 
 API References
 --------------
@@ -69,7 +72,11 @@ Plugins
 .. toctree::
   :maxdepth: 1
 
-  dev/strategy-plugin
+  dev/plugin/base-setup
+  dev/plugin/strategy-plugin
+  dev/plugin/action-plugin
+  dev/plugin/planner-plugin
+  dev/plugins
 
 
 Admin Guide

doc/source/man/watcher-db-manage.rst

@@ -52,7 +52,7 @@ run the following::
 
   Show the program's version number and exit.
 
-.. option:: upgrade, downgrade, stamp, revision, version, create_schema
+.. option:: upgrade, downgrade, stamp, revision, version, create_schema, purge
 
   The :ref:`command <db-manage_cmds>` to run.
 
@@ -219,3 +219,42 @@ version
   Show help for version and exit.
 
 This command will output the current database version.
+
+purge
+-----
+
+.. program:: purge
+
+.. option:: -h, --help
+
+  Show help for purge and exit.
+
+.. option:: -d, --age-in-days
+
+  The number of days (starting from today) before which we consider soft
+  deleted objects as expired and should hence be erased. By default, all
+  objects soft deleted are considered expired. This can be useful as removing
+  a significant amount of objects may cause a performance issues.
+
+.. option:: -n, --max-number
+
+  The maximum number of database objects we expect to be deleted. If exceeded,
+  this will prevent any deletion.
+
+.. option:: -t, --audit-template
+
+  Either the UUID or name of the soft deleted audit template to purge. This
+  will also include any related objects with it.
+
+.. option:: -e, --exclude-orphans
+
+  This is a flag to indicate when we want to exclude orphan objects from
+  deletion.
+
+.. option:: --dry-run
+
+  This is a flag to indicate when we want to perform a dry run. This will show
+  the objects that would be deleted instead of actually deleting them.
+
+This command will purge the current database by removing both its soft deleted
+and orphan objects.

doc/source/webapi/v1.rst

@@ -8,6 +8,19 @@
 RESTful Web API (v1)
 ====================
 
+Goals
+=====
+
+.. rest-controller:: watcher.api.controllers.v1.goal:GoalsController
+   :webprefix: /v1/goal
+
+.. autotype:: watcher.api.controllers.v1.goal.GoalCollection
+   :members:
+
+.. autotype:: watcher.api.controllers.v1.goal.Goal
+   :members:
+
+
 Audit Templates
 ===============
 

etc/watcher/README-watcher.conf.txt

@@ -0,0 +1,4 @@
+To generate the sample watcher.conf file, run the following
+command from the top level of the watcher directory:
+
+tox -econfig

etc/watcher/watcher-config-generator.conf

@@ -0,0 +1,9 @@
+[DEFAULT]
+output_file = etc/watcher/watcher.conf.sample
+wrap_width = 79
+
+namespace = watcher
+namespace = keystonemiddleware.auth_token
+namespace = oslo.log
+namespace = oslo.db
+namespace = oslo.messaging

etc/watcher/watcher.conf.sample

@@ -1,775 +0,0 @@
-[DEFAULT]
-
-#
-# From oslo.log
-#
-
-# Use syslog for logging. Existing syslog format is DEPRECATED and
-# will be changed later to honor RFC5424. This option is ignored if
-# log_config_append is set. (boolean value)
-#use_syslog = false
-
-# Enables or disables syslog rfc5424 format for logging. If enabled,
-# prefixes the MSG part of the syslog message with APP-NAME (RFC5424).
-# The format without the APP-NAME is deprecated in Kilo, and will be
-# removed in Mitaka, along with this option. This option is ignored if
-# log_config_append is set. (boolean value)
-# This option is deprecated for removal.
-# Its value may be silently ignored in the future.
-#use_syslog_rfc_format = true
-
-# (Optional) The base directory used for relative log_file  paths.
-# This option is ignored if log_config_append is set. (string value)
-# Deprecated group/name - [DEFAULT]/logdir
-#log_dir = <None>
-
-# Syslog facility to receive log lines. This option is ignored if
-# log_config_append is set. (string value)
-#syslog_log_facility = LOG_USER
-
-# Log output to standard error. This option is ignored if
-# log_config_append is set. (boolean value)
-#use_stderr = true
-
-# Format string to use for log messages with context. (string value)
-#logging_context_format_string = %(asctime)s.%(msecs)03d %(process)d %(levelname)s %(name)s [%(request_id)s %(user_identity)s] %(instance)s%(message)s
-
-# Format string to use for log messages when context is undefined.
-# (string value)
-#logging_default_format_string = %(asctime)s.%(msecs)03d %(process)d %(levelname)s %(name)s [-] %(instance)s%(message)s
-
-# Additional data to append to log message when logging level for the
-# message is DEBUG. (string value)
-#logging_debug_format_suffix = %(funcName)s %(pathname)s:%(lineno)d
-
-# If set to true, the logging level will be set to DEBUG instead of
-# the default INFO level. (boolean value)
-#debug = false
-
-# Prefix each line of exception output with this format. (string
-# value)
-#logging_exception_prefix = %(asctime)s.%(msecs)03d %(process)d ERROR %(name)s %(instance)s
-
-# If set to false, the logging level will be set to WARNING instead of
-# the default INFO level. (boolean value)
-# This option is deprecated for removal.
-# Its value may be silently ignored in the future.
-#verbose = true
-
-# Defines the format string for %(user_identity)s that is used in
-# logging_context_format_string. (string value)
-#logging_user_identity_format = %(user)s %(tenant)s %(domain)s %(user_domain)s %(project_domain)s
-
-# The name of a logging configuration file. This file is appended to
-# any existing logging configuration files. For details about logging
-# configuration files, see the Python logging module documentation.
-# Note that when logging configuration files are used all logging
-# configuration is defined in the configuration file and other logging
-# configuration options are ignored (for example, log_format). (string
-# value)
-# Deprecated group/name - [DEFAULT]/log_config
-#log_config_append = <None>
-
-# List of package logging levels in logger=LEVEL pairs. This option is
-# ignored if log_config_append is set. (list value)
-#default_log_levels = amqp=WARN,amqplib=WARN,boto=WARN,qpid=WARN,sqlalchemy=WARN,suds=INFO,oslo.messaging=INFO,iso8601=WARN,requests.packages.urllib3.connectionpool=WARN,urllib3.connectionpool=WARN,websocket=WARN,requests.packages.urllib3.util.retry=WARN,urllib3.util.retry=WARN,keystonemiddleware=WARN,routes.middleware=WARN,stevedore=WARN,taskflow=WARN,keystoneauth=WARN
-
-# DEPRECATED. A logging.Formatter log message format string which may
-# use any of the available logging.LogRecord attributes. This option
-# is deprecated.  Please use logging_context_format_string and
-# logging_default_format_string instead. This option is ignored if
-# log_config_append is set. (string value)
-#log_format = <None>
-
-# Enables or disables publication of error events. (boolean value)
-#publish_errors = false
-
-# Defines the format string for %%(asctime)s in log records. Default:
-# %(default)s . This option is ignored if log_config_append is set.
-# (string value)
-#log_date_format = %Y-%m-%d %H:%M:%S
-
-# The format for an instance that is passed with the log message.
-# (string value)
-#instance_format = "[instance: %(uuid)s] "
-
-# (Optional) Name of log file to send logging output to. If no default
-# is set, logging will go to stderr as defined by use_stderr. This
-# option is ignored if log_config_append is set. (string value)
-# Deprecated group/name - [DEFAULT]/logfile
-#log_file = <None>
-
-# The format for an instance UUID that is passed with the log message.
-# (string value)
-#instance_uuid_format = "[instance: %(uuid)s] "
-
-# Enables or disables fatal status of deprecations. (boolean value)
-#fatal_deprecations = false
-
-# Uses logging handler designed to watch file system. When log file is
-# moved or removed this handler will open a new log file with
-# specified path instantaneously. It makes sense only if log_file
-# option is specified and Linux platform is used. This option is
-# ignored if log_config_append is set. (boolean value)
-#watch_log_file = false
-
-#
-# From oslo.messaging
-#
-
-# Directory for holding IPC sockets. (string value)
-#rpc_zmq_ipc_dir = /var/run/openstack
-
-# Number of retries to find free port number before fail with
-# ZMQBindError. (integer value)
-#rpc_zmq_bind_port_retries = 100
-
-# AMQP topic used for OpenStack notifications. (list value)
-# Deprecated group/name - [rpc_notifier2]/topics
-# Deprecated group/name - [DEFAULT]/notification_topics
-#topics = notifications
-
-# Name of this node. Must be a valid hostname, FQDN, or IP address.
-# Must match "host" option, if running Nova. (string value)
-#rpc_zmq_host = localhost
-
-# The messaging driver to use, defaults to rabbit. Other drivers
-# include amqp and zmq. (string value)
-#rpc_backend = rabbit
-
-# Host to locate redis. (string value)
-#host = 127.0.0.1
-
-# Seconds to wait before a cast expires (TTL). Only supported by
-# impl_zmq. (integer value)
-#rpc_cast_timeout = 30
-
-# Seconds to wait for a response from a call. (integer value)
-#rpc_response_timeout = 60
-
-# Use this port to connect to redis host. (port value)
-# Minimum value: 1
-# Maximum value: 65535
-#port = 6379
-
-# The default number of seconds that poll should wait. Poll raises
-# timeout exception when timeout expired. (integer value)
-#rpc_poll_timeout = 1
-
-# A URL representing the messaging driver to use and its full
-# configuration. If not set, we fall back to the rpc_backend option
-# and driver specific configuration. (string value)
-#transport_url = <None>
-
-# Password for Redis server (optional). (string value)
-#password =
-
-# Configures zmq-messaging to use proxy with non PUB/SUB patterns.
-# (boolean value)
-#direct_over_proxy = true
-
-# The Drivers(s) to handle sending notifications. Possible values are
-# messaging, messagingv2, routing, log, test, noop (multi valued)
-# Deprecated group/name - [DEFAULT]/notification_driver
-#driver =
-
-# Size of executor thread pool. (integer value)
-# Deprecated group/name - [DEFAULT]/rpc_thread_pool_size
-#executor_thread_pool_size = 64
-
-# Size of RPC connection pool. (integer value)
-# Deprecated group/name - [DEFAULT]/rpc_conn_pool_size
-#rpc_conn_pool_size = 30
-
-# Use PUB/SUB pattern for fanout methods. PUB/SUB always uses proxy.
-# (boolean value)
-#use_pub_sub = true
-
-# A URL representing the messaging driver to use for notifications. If
-# not set, we fall back to the same configuration used for RPC.
-# (string value)
-# Deprecated group/name - [DEFAULT]/notification_transport_url
-#transport_url = <None>
-
-# ZeroMQ bind address. Should be a wildcard (*), an ethernet
-# interface, or IP. The "host" option should point or resolve to this
-# address. (string value)
-#rpc_zmq_bind_address = *
-
-# MatchMaker driver. (string value)
-#rpc_zmq_matchmaker = redis
-
-# Minimal port number for random ports range. (port value)
-# Minimum value: 1
-# Maximum value: 65535
-#rpc_zmq_min_port = 49152
-
-# Type of concurrency used. Either "native" or "eventlet" (string
-# value)
-#rpc_zmq_concurrency = eventlet
-
-# Number of ZeroMQ contexts, defaults to 1. (integer value)
-#rpc_zmq_contexts = 1
-
-# Maximal port number for random ports range. (integer value)
-# Minimum value: 1
-# Maximum value: 65536
-#rpc_zmq_max_port = 65536
-
-# The default exchange under which topics are scoped. May be
-# overridden by an exchange name specified in the transport_url
-# option. (string value)
-#control_exchange = openstack
-
-# Maximum number of ingress messages to locally buffer per topic.
-# Default is unlimited. (integer value)
-#rpc_zmq_topic_backlog = <None>
-
-
-[api]
-
-#
-# From watcher
-#
-
-# The port for the watcher API server (integer value)
-#port = 9322
-
-# The listen IP for the watcher API server (string value)
-#host = 0.0.0.0
-
-# The maximum number of items returned in a single response from a
-# collection resource. (integer value)
-#max_limit = 1000
-
-
-[database]
-
-#
-# From oslo.db
-#
-
-# The SQLAlchemy connection string to use to connect to the database.
-# (string value)
-# Deprecated group/name - [DEFAULT]/sql_connection
-# Deprecated group/name - [DATABASE]/sql_connection
-# Deprecated group/name - [sql]/connection
-#connection = <None>
-
-# Add Python stack traces to SQL as comment strings. (boolean value)
-# Deprecated group/name - [DEFAULT]/sql_connection_trace
-#connection_trace = false
-
-# Seconds between retries of a database transaction. (integer value)
-#db_retry_interval = 1
-
-# Timeout before idle SQL connections are reaped. (integer value)
-# Deprecated group/name - [DEFAULT]/sql_idle_timeout
-# Deprecated group/name - [DATABASE]/sql_idle_timeout
-# Deprecated group/name - [sql]/idle_timeout
-#idle_timeout = 3600
-
-# If set, use this value for pool_timeout with SQLAlchemy. (integer
-# value)
-# Deprecated group/name - [DATABASE]/sqlalchemy_pool_timeout
-#pool_timeout = <None>
-
-# If True, SQLite uses synchronous mode. (boolean value)
-# Deprecated group/name - [DEFAULT]/sqlite_synchronous
-#sqlite_synchronous = true
-
-# If db_inc_retry_interval is set, the maximum seconds between retries
-# of a database operation. (integer value)
-#db_max_retry_interval = 10
-
-# Enable the experimental use of database reconnect on connection
-# lost. (boolean value)
-#use_db_reconnect = false
-
-# Interval between retries of opening a SQL connection. (integer
-# value)
-# Deprecated group/name - [DEFAULT]/sql_retry_interval
-# Deprecated group/name - [DATABASE]/reconnect_interval
-#retry_interval = 10
-
-# The file name to use with SQLite. (string value)
-# Deprecated group/name - [DEFAULT]/sqlite_db
-#sqlite_db = oslo.sqlite
-
-# Maximum retries in case of connection error or deadlock error before
-# error is raised. Set to -1 to specify an infinite retry count.
-# (integer value)
-#db_max_retries = 20
-
-# If True, increases the interval between retries of a database
-# operation up to db_max_retry_interval. (boolean value)
-#db_inc_retry_interval = true
-
-# The SQLAlchemy connection string to use to connect to the slave
-# database. (string value)
-#slave_connection = <None>
-
-# Maximum number of SQL connections to keep open in a pool. (integer
-# value)
-# Deprecated group/name - [DEFAULT]/sql_max_pool_size
-# Deprecated group/name - [DATABASE]/sql_max_pool_size
-#max_pool_size = <None>
-
-# Maximum number of database connection retries during startup. Set to
-# -1 to specify an infinite retry count. (integer value)
-# Deprecated group/name - [DEFAULT]/sql_max_retries
-# Deprecated group/name - [DATABASE]/sql_max_retries
-#max_retries = 10
-
-# Minimum number of SQL connections to keep open in a pool. (integer
-# value)
-# Deprecated group/name - [DEFAULT]/sql_min_pool_size
-# Deprecated group/name - [DATABASE]/sql_min_pool_size
-#min_pool_size = 1
-
-# Verbosity of SQL debugging information: 0=None, 100=Everything.
-# (integer value)
-# Deprecated group/name - [DEFAULT]/sql_connection_debug
-#connection_debug = 0
-
-# If set, use this value for max_overflow with SQLAlchemy. (integer
-# value)
-# Deprecated group/name - [DEFAULT]/sql_max_overflow
-# Deprecated group/name - [DATABASE]/sqlalchemy_max_overflow
-#max_overflow = <None>
-
-# The SQL mode to be used for MySQL sessions. This option, including
-# the default, overrides any server-set SQL mode. To use whatever SQL
-# mode is set by the server configuration, set this to no value.
-# Example: mysql_sql_mode= (string value)
-#mysql_sql_mode = TRADITIONAL
-
-# The back end to use for the database. (string value)
-# Deprecated group/name - [DEFAULT]/db_backend
-#backend = sqlalchemy
-
-
-[keystone_authtoken]
-
-#
-# From keystonemiddleware.auth_token
-#
-
-# A PEM encoded Certificate Authority to use when verifying HTTPs
-# connections. Defaults to system CAs. (string value)
-#cafile = <None>
-
-# (Optional) Indicate whether to set the X-Service-Catalog header. If
-# False, middleware will not ask for service catalog on token
-# validation and will not set the X-Service-Catalog header. (boolean
-# value)
-#include_service_catalog = true
-
-# (Optional) If defined, indicate whether token data should be
-# authenticated or authenticated and encrypted. If MAC, token data is
-# authenticated (with HMAC) in the cache. If ENCRYPT, token data is
-# encrypted and authenticated in the cache. If the value is not one of
-# these options or empty, auth_token will raise an exception on
-# initialization. (string value)
-# Allowed values: None, MAC, ENCRYPT
-#memcache_security_strategy = None
-
-# Verify HTTPS connections. (boolean value)
-#insecure = false
-
-# Used to control the use and type of token binding. Can be set to:
-# "disabled" to not check token binding. "permissive" (default) to
-# validate binding information if the bind type is of a form known to
-# the server and ignore it if not. "strict" like "permissive" but if
-# the bind type is unknown the token will be rejected. "required" any
-# form of token binding is needed to be allowed. Finally the name of a
-# binding method that must be present in tokens. (string value)
-#enforce_token_bind = permissive
-
-# The region in which the identity server can be found. (string value)
-#region_name = <None>
-
-# If true, the revocation list will be checked for cached tokens. This
-# requires that PKI tokens are configured on the identity server.
-# (boolean value)
-#check_revocations_for_cached = false
-
-# Request timeout value for communicating with Identity API server.
-# (integer value)
-#http_connect_timeout = <None>
-
-# Directory used to cache files related to PKI tokens. (string value)
-#signing_dir = <None>
-
-# Hash algorithms to use for hashing PKI tokens. This may be a single
-# algorithm or multiple. The algorithms are those supported by Python
-# standard hashlib.new(). The hashes will be tried in the order given,
-# so put the preferred one first for performance. The result of the
-# first hash will be stored in the cache. This will typically be set
-# to multiple values only while migrating from a less secure algorithm
-# to a more secure one. Once all the old tokens are expired this
-# option should be set to a single value for better performance. (list
-# value)
-#hash_algorithms = md5
-
-# Optionally specify a list of memcached server(s) to use for caching.
-# If left undefined, tokens will instead be cached in-process. (list
-# value)
-# Deprecated group/name - [DEFAULT]/memcache_servers
-#memcached_servers = <None>
-
-# Required if identity server requires client certificate (string
-# value)
-#certfile = <None>
-
-# Authentication type to load (unknown value)
-# Deprecated group/name - [DEFAULT]/auth_plugin
-#auth_type = <None>
-
-# Config Section from which to load plugin specific options (unknown
-# value)
-#auth_section = <None>
-
-# In order to prevent excessive effort spent validating tokens, the
-# middleware caches previously-seen tokens for a configurable duration
-# (in seconds). Set to -1 to disable caching completely. (integer
-# value)
-#token_cache_time = 300
-
-# API version of the admin Identity API endpoint. (string value)
-#auth_version = <None>
-
-# Determines the frequency at which the list of revoked tokens is
-# retrieved from the Identity service (in seconds). A high number of
-# revocation events combined with a low cache duration may
-# significantly reduce performance. (integer value)
-#revocation_cache_time = 10
-
-# Complete public Identity API endpoint. (string value)
-#auth_uri = <None>
-
-# (Optional) Socket timeout in seconds for communicating with a
-# memcached server. (integer value)
-#memcache_pool_socket_timeout = 3
-
-# (Optional, mandatory if memcache_security_strategy is defined) This
-# string is used for key derivation. (string value)
-#memcache_secret_key = <None>
-
-# Do not handle authorization requests within the middleware, but
-# delegate the authorization decision to downstream WSGI components.
-# (boolean value)
-#delay_auth_decision = false
-
-# (Optional) Use the advanced (eventlet safe) memcached client pool.
-# The advanced pool will only work under python 2.x. (boolean value)
-#memcache_use_advanced_pool = false
-
-# (Optional) Maximum total number of open connections to every
-# memcached server. (integer value)
-#memcache_pool_maxsize = 10
-
-# How many times are we trying to reconnect when communicating with
-# Identity API Server. (integer value)
-#http_request_max_retries = 3
-
-# (Optional) Number of seconds memcached server is considered dead
-# before it is tried again. (integer value)
-#memcache_pool_dead_retry = 300
-
-# (Optional) Number of seconds a connection to memcached is held
-# unused in the pool before it is closed. (integer value)
-#memcache_pool_unused_timeout = 60
-
-# (Optional) Number of seconds that an operation will wait to get a
-# memcached client connection from the pool. (integer value)
-#memcache_pool_conn_get_timeout = 10
-
-# Env key for the swift cache. (string value)
-#cache = <None>
-
-# Required if identity server requires client certificate (string
-# value)
-#keyfile = <None>
-
-
-[matchmaker_redis]
-
-#
-# From oslo.messaging
-#
-
-# Password for Redis server (optional). (string value)
-#password =
-
-# Host to locate redis. (string value)
-#host = 127.0.0.1
-
-# Use this port to connect to redis host. (port value)
-# Minimum value: 1
-# Maximum value: 65535
-#port = 6379
-
-
-[oslo_messaging_amqp]
-
-#
-# From oslo.messaging
-#
-
-# Timeout for inactive connections (in seconds) (integer value)
-# Deprecated group/name - [amqp1]/idle_timeout
-#idle_timeout = 0
-
-# Password for message broker authentication (string value)
-# Deprecated group/name - [amqp1]/password
-#password =
-
-# Identifying certificate PEM file to present to clients (string
-# value)
-# Deprecated group/name - [amqp1]/ssl_cert_file
-#ssl_cert_file =
-
-# Private key PEM file used to sign cert_file certificate (string
-# value)
-# Deprecated group/name - [amqp1]/ssl_key_file
-#ssl_key_file =
-
-# address prefix when sending to any server in group (string value)
-# Deprecated group/name - [amqp1]/group_request_prefix
-#group_request_prefix = unicast
-
-# Path to directory that contains the SASL configuration (string
-# value)
-# Deprecated group/name - [amqp1]/sasl_config_dir
-#sasl_config_dir =
-
-# Debug: dump AMQP frames to stdout (boolean value)
-# Deprecated group/name - [amqp1]/trace
-#trace = false
-
-# Password for decrypting ssl_key_file (if encrypted) (string value)
-# Deprecated group/name - [amqp1]/ssl_key_password
-#ssl_key_password = <None>
-
-# address prefix used when sending to a specific server (string value)
-# Deprecated group/name - [amqp1]/server_request_prefix
-#server_request_prefix = exclusive
-
-# Name of configuration file (without .conf suffix) (string value)
-# Deprecated group/name - [amqp1]/sasl_config_name
-#sasl_config_name =
-
-# Name for the AMQP container (string value)
-# Deprecated group/name - [amqp1]/container_name
-#container_name = <None>
-
-# Accept clients using either SSL or plain TCP (boolean value)
-# Deprecated group/name - [amqp1]/allow_insecure_clients
-#allow_insecure_clients = false
-
-# CA certificate PEM file to verify server certificate (string value)
-# Deprecated group/name - [amqp1]/ssl_ca_file
-#ssl_ca_file =
-
-# User name for message broker authentication (string value)
-# Deprecated group/name - [amqp1]/username
-#username =
-
-# address prefix used when broadcasting to all servers (string value)
-# Deprecated group/name - [amqp1]/broadcast_prefix
-#broadcast_prefix = broadcast
-
-# Space separated list of acceptable SASL mechanisms (string value)
-# Deprecated group/name - [amqp1]/sasl_mechanisms
-#sasl_mechanisms =
-
-
-[oslo_messaging_rabbit]
-
-#
-# From oslo.messaging
-#
-
-# The RabbitMQ password. (string value)
-# Deprecated group/name - [DEFAULT]/rabbit_password
-#rabbit_password = guest
-
-# SSL cert file (valid only if SSL enabled). (string value)
-# Deprecated group/name - [DEFAULT]/kombu_ssl_certfile
-#kombu_ssl_certfile =
-
-# The RabbitMQ login method. (string value)
-# Deprecated group/name - [DEFAULT]/rabbit_login_method
-#rabbit_login_method = AMQPLAIN
-
-# How long to backoff for between retries when connecting to RabbitMQ.
-# (integer value)
-# Deprecated group/name - [DEFAULT]/rabbit_retry_backoff
-#rabbit_retry_backoff = 2
-
-# SSL certification authority file (valid only if SSL enabled).
-# (string value)
-# Deprecated group/name - [DEFAULT]/kombu_ssl_ca_certs
-#kombu_ssl_ca_certs =
-
-# The RabbitMQ virtual host. (string value)
-# Deprecated group/name - [DEFAULT]/rabbit_virtual_host
-#rabbit_virtual_host = /
-
-# How long to wait before reconnecting in response to an AMQP consumer
-# cancel notification. (floating point value)
-# Deprecated group/name - [DEFAULT]/kombu_reconnect_delay
-#kombu_reconnect_delay = 1.0
-
-# How frequently to retry connecting with RabbitMQ. (integer value)
-#rabbit_retry_interval = 1
-
-# How long to wait a missing client beforce abandoning to send it its
-# replies. This value should not be longer than rpc_response_timeout.
-# (integer value)
-# Deprecated group/name - [DEFAULT]/kombu_reconnect_timeout
-#kombu_missing_consumer_retry_timeout = 60
-
-# Deprecated, use rpc_backend=kombu+memory or rpc_backend=fake
-# (boolean value)
-# Deprecated group/name - [DEFAULT]/fake_rabbit
-#fake_rabbit = false
-
-# Determines how the next RabbitMQ node is chosen in case the one we
-# are currently connected to becomes unavailable. Takes effect only if
-# more than one RabbitMQ node is provided in config. (string value)
-# Allowed values: round-robin, shuffle
-#kombu_failover_strategy = round-robin
-
-# How often times during the heartbeat_timeout_threshold we check the
-# heartbeat. (integer value)
-#heartbeat_rate = 2
-
-# The RabbitMQ broker address where a single node is used. (string
-# value)
-# Deprecated group/name - [DEFAULT]/rabbit_host
-#rabbit_host = localhost
-
-# The RabbitMQ broker port where a single node is used. (port value)
-# Minimum value: 1
-# Maximum value: 65535
-# Deprecated group/name - [DEFAULT]/rabbit_port
-#rabbit_port = 5672
-
-# Use HA queues in RabbitMQ (x-ha-policy: all). If you change this
-# option, you must wipe the RabbitMQ database. (boolean value)
-# Deprecated group/name - [DEFAULT]/rabbit_ha_queues
-#rabbit_ha_queues = false
-
-# Use durable queues in AMQP. (boolean value)
-# Deprecated group/name - [DEFAULT]/amqp_durable_queues
-# Deprecated group/name - [DEFAULT]/rabbit_durable_queues
-#amqp_durable_queues = false
-
-# Maximum number of RabbitMQ connection retries. Default is 0
-# (infinite retry count). (integer value)
-# Deprecated group/name - [DEFAULT]/rabbit_max_retries
-#rabbit_max_retries = 0
-
-# RabbitMQ HA cluster host:port pairs. (list value)
-# Deprecated group/name - [DEFAULT]/rabbit_hosts
-#rabbit_hosts = $rabbit_host:$rabbit_port
-
-# Auto-delete queues in AMQP. (boolean value)
-# Deprecated group/name - [DEFAULT]/amqp_auto_delete
-#amqp_auto_delete = false
-
-# Number of seconds after which the Rabbit broker is considered down
-# if heartbeat's keep-alive fails (0 disable the heartbeat).
-# EXPERIMENTAL (integer value)
-#heartbeat_timeout_threshold = 60
-
-# Connect over SSL for RabbitMQ. (boolean value)
-# Deprecated group/name - [DEFAULT]/rabbit_use_ssl
-#rabbit_use_ssl = false
-
-# SSL version to use (valid only if SSL enabled). Valid values are
-# TLSv1 and SSLv23. SSLv2, SSLv3, TLSv1_1, and TLSv1_2 may be
-# available on some distributions. (string value)
-# Deprecated group/name - [DEFAULT]/kombu_ssl_version
-#kombu_ssl_version =
-
-# The RabbitMQ userid. (string value)
-# Deprecated group/name - [DEFAULT]/rabbit_userid
-#rabbit_userid = guest
-
-# SSL key file (valid only if SSL enabled). (string value)
-# Deprecated group/name - [DEFAULT]/kombu_ssl_keyfile
-#kombu_ssl_keyfile =
-
-
-[watcher_applier]
-
-#
-# From watcher
-#
-
-# Number of workers for applier, default value is 1. (integer value)
-# Minimum value: 1
-#workers = 1
-
-# Select the engine to use to execute the workflow (string value)
-#workflow_engine = taskflow
-
-# The topic name used forcontrol events, this topic used for rpc call
-# (string value)
-#topic_control = watcher.applier.control
-
-# The identifier used by watcher module on the message broker (string
-# value)
-#publisher_id = watcher.applier.api
-
-# The topic name used for status events, this topic is used so as to
-# notifythe others components of the system (string value)
-#topic_status = watcher.applier.status
-
-
-[watcher_decision_engine]
-
-#
-# From watcher
-#
-
-# The identifier used by watcher module on the message broker (string
-# value)
-#publisher_id = watcher.decision.api
-
-# The topic name used forcontrol events, this topic used for rpc call
-# (string value)
-#topic_control = watcher.decision.control
-
-# The maximum number of threads that can be used to execute strategies
-# (integer value)
-#max_workers = 2
-
-# The topic name used for status events, this topic is used so as to
-# notifythe others components of the system (string value)
-#topic_status = watcher.decision.status
-
-
-[watcher_goals]
-
-#
-# From watcher
-#
-
-# Goals used for the optimization. Maps each goal to an associated
-# strategy (for example: BASIC_CONSOLIDATION:basic,
-# MY_GOAL:my_strategy_1) (dict value)
-#goals = DUMMY:dummy
-
-
-[watcher_planner]
-
-#
-# From watcher
-#
-
-# The selected planner used to schedule the actions (string value)
-#planner = default

requirements.txt

@@ -2,29 +2,34 @@
 # of appearance. Changing the order has an impact on the overall integration
 # process, which may cause wedges in the gate later.
 
-enum34;python_version=='2.7' or python_version=='2.6'
-jsonpatch>=1.1
-keystonemiddleware>=2.0.0,!=2.4.0
-oslo.config>=2.3.0  # Apache-2.0
-oslo.db>=2.4.1      # Apache-2.0
-oslo.i18n>=1.5.0    # Apache-2.0
-oslo.log>=1.8.0     # Apache-2.0
-oslo.messaging>=1.16.0,!=1.17.0,!=1.17.1,!=2.6.0,!=2.6.1 # Apache-2.0
-oslo.policy>=0.5.0  # Apache-2.0
-oslo.service>=0.7.0 # Apache-2.0
-oslo.utils>=2.0.0,!=2.6.0  # Apache-2.0
-PasteDeploy>=1.5.0
-pbr>=1.6
-pecan>=1.0.0
-python-ceilometerclient>=1.5.0
-python-cinderclient>=1.3.1
-python-glanceclient>=0.18.0
-python-keystoneclient>=1.6.0,!=1.8.0
-python-neutronclient>=2.6.0
-python-novaclient>=2.28.1,!=2.33.0
-python-openstackclient>=1.5.0
-six>=1.9.0
-SQLAlchemy>=0.9.9,<1.1.0
-stevedore>=1.5.0    # Apache-2.0
-taskflow>=1.25.0 # Apache-2.0
-WSME>=0.7
+enum34;python_version=='2.7' or python_version=='2.6' or python_version=='3.3' # BSD
+jsonpatch>=1.1 # BSD
+keystoneauth1>=2.1.0 # Apache-2.0
+keystonemiddleware!=4.1.0,>=4.0.0 # Apache-2.0
+oslo.config>=3.7.0 # Apache-2.0
+oslo.context>=0.2.0 # Apache-2.0
+oslo.db>=4.1.0 # Apache-2.0
+oslo.i18n>=2.1.0 # Apache-2.0
+oslo.log>=1.14.0 # Apache-2.0
+oslo.messaging>=4.0.0 # Apache-2.0
+oslo.policy>=0.5.0 # Apache-2.0
+oslo.service>=1.0.0 # Apache-2.0
+oslo.utils>=3.5.0 # Apache-2.0
+PasteDeploy>=1.5.0 # MIT
+pbr>=1.6 # Apache-2.0
+pecan>=1.0.0 # BSD
+PrettyTable<0.8,>=0.7 # BSD
+voluptuous>=0.8.6 # BSD License
+python-ceilometerclient>=2.2.1 # Apache-2.0
+python-cinderclient>=1.3.1 # Apache-2.0
+python-glanceclient>=2.0.0 # Apache-2.0
+python-keystoneclient!=1.8.0,!=2.1.0,>=1.6.0 # Apache-2.0
+python-neutronclient!=4.1.0,>=2.6.0 # Apache-2.0
+python-novaclient!=2.33.0,>=2.29.0 # Apache-2.0
+python-openstackclient>=2.1.0 # Apache-2.0
+six>=1.9.0 # MIT
+SQLAlchemy<1.1.0,>=1.0.10 # MIT
+stevedore>=1.5.0 # Apache-2.0
+taskflow>=1.26.0 # Apache-2.0
+WebOb>=1.2.3 # MIT
+WSME>=0.8 # MIT

setup.cfg

@@ -49,6 +49,7 @@ watcher_strategies =
     dummy = watcher.decision_engine.strategy.strategies.dummy_strategy:DummyStrategy
     basic = watcher.decision_engine.strategy.strategies.basic_consolidation:BasicConsolidation
     outlet_temp_control = watcher.decision_engine.strategy.strategies.outlet_temp_control:OutletTempControl
+    vm_workload_consolidation = watcher.decision_engine.strategy.strategies.vm_workload_consolidation:VMWorkloadConsolidation
 
 watcher_actions =
     migrate = watcher.applier.actions.migration:Migrate
@@ -63,7 +64,8 @@ watcher_planners =
     default  = watcher.decision_engine.planner.default:DefaultPlanner
 
 [pbr]
-autodoc_index_modules = True
+warnerrors = true
+autodoc_index_modules = true
 autodoc_exclude_modules =
     watcher.db.sqlalchemy.alembic.env
     watcher.db.sqlalchemy.alembic.versions.*

setup.py

@@ -1,4 +1,3 @@
-#!/usr/bin/env python
 # Copyright (c) 2013 Hewlett-Packard Development Company, L.P.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -26,5 +25,5 @@ except ImportError:
     pass
 
 setuptools.setup(
-    setup_requires=['pbr'],
+    setup_requires=['pbr>=1.8'],
     pbr=True)

test-requirements.txt

@@ -2,23 +2,20 @@
 # of appearance. Changing the order has an impact on the overall integration
 # process, which may cause wedges in the gate later.
 
-coverage>=3.6
-discover
+coverage>=3.6 # Apache-2.0
+discover # BSD
 doc8 # Apache-2.0
-hacking>=0.10.2,<0.11
-mock>=1.2
-oslotest>=1.10.0  # Apache-2.0
-os-testr>=0.1.0
-python-subunit>=0.0.18
-testrepository>=0.0.18
-testscenarios>=0.4
-testtools>=1.4.0
+freezegun # Apache-2.0
+hacking<0.11,>=0.10.2
+mock>=1.2 # BSD
+oslotest>=1.10.0 # Apache-2.0
+os-testr>=0.4.1 # Apache-2.0
+python-subunit>=0.0.18 # Apache-2.0/BSD
+testrepository>=0.0.18 # Apache-2.0/BSD
+testscenarios>=0.4 # Apache-2.0/BSD
+testtools>=1.4.0 # MIT
 
 # Doc requirements
-oslosphinx>=2.5.0 # Apache-2.0
-sphinx>=1.1.2,!=1.2.0,!=1.3b1,<1.3
-sphinxcontrib-pecanwsme>=0.8
-
-# For PyPI distribution
-twine
-
+oslosphinx!=3.4.0,>=2.5.0 # Apache-2.0
+sphinx!=1.2.0,!=1.3b1,<1.3,>=1.1.2 # BSD
+sphinxcontrib-pecanwsme>=0.8 # Apache-2.0

tox.ini

@@ -26,7 +26,7 @@ setenv = PYTHONHASHSEED=0
 commands = {posargs}
 
 [testenv:cover]
-commands = python setup.py testr --coverage --omit="watcher/tests/*" --testr-args='{posargs}'
+commands = python setup.py testr --coverage --testr-args='{posargs}'
 
 [testenv:docs]
 setenv = PYTHONHASHSEED=0
@@ -35,17 +35,12 @@ commands =
     python setup.py build_sphinx
 
 [testenv:debug]
-commands = oslo_debug_helper {posargs}
+commands = oslo_debug_helper -t watcher/tests {posargs}
 
 [testenv:config]
 sitepackages = False
 commands =
-  oslo-config-generator --namespace watcher \
-                        --namespace keystonemiddleware.auth_token \
-                        --namespace oslo.log \
-                        --namespace oslo.db \
-                        --namespace oslo.messaging \
-                        --output-file etc/watcher/watcher.conf.sample
+    oslo-config-generator --config-file etc/watcher/watcher-config-generator.conf
 
 [flake8]
 show-source=True
@@ -53,11 +48,6 @@ ignore=
 builtins= _
 exclude=.venv,.git,.tox,dist,doc,*lib/python*,*egg,build,*sqlalchemy/alembic/versions/*,demo/
 
-[testenv:pypi]
-commands =
-    python setup.py sdist bdist_wheel
-    twine upload --config-file .pypirc {posargs} dist/*
-
 [testenv:wheel]
 commands = python setup.py bdist_wheel
 
@@ -67,4 +57,4 @@ import_exceptions = watcher._i18n
 [doc8]
 extension=.rst
 # todo: stop ignoring doc/source/man when https://bugs.launchpad.net/doc8/+bug/1502391 is fixed
-ignore-path=doc/source/image_src,doc/source/man
+ignore-path=doc/source/image_src,doc/source/man,doc/source/api

watcher/api/controllers/v1/action.py

@@ -49,6 +49,10 @@ be one of the following:
 -  **CANCELLED** : the :ref:`Action <action_definition>` was in **PENDING** or
    **ONGOING** state and was cancelled by the
    :ref:`Administrator <administrator_definition>`
+
+:ref:`Some default implementations are provided <watcher_planners>`, but it is
+possible to :ref:`develop new implementations <implement_action_plugin>` which
+are dynamically loaded by Watcher at launch time.
 """
 
 import datetime
@@ -129,13 +133,10 @@ class Action(base.APIBase):
     alarm = types.uuid
     """An alarm UUID related to this action"""
 
-    applies_to = wtypes.text
-    """Applies to"""
-
     action_type = wtypes.text
     """Action type"""
 
-    input_parameters = wtypes.DictType(wtypes.text, wtypes.text)
+    input_parameters = types.jsontype
     """One or more key/value pairs """
 
     next_uuid = wsme.wsproperty(types.uuid, _get_next_uuid,
@@ -257,7 +258,7 @@ class ActionsController(rest.RestController):
                                 resource_url=None,
                                 action_plan_uuid=None, audit_uuid=None):
         limit = api_utils.validate_limit(limit)
-        sort_dir = api_utils.validate_sort_dir(sort_dir)
+        api_utils.validate_sort_dir(sort_dir)
 
         marker_obj = None
         if marker:
@@ -288,10 +289,10 @@ class ActionsController(rest.RestController):
                                                    sort_key=sort_key,
                                                    sort_dir=sort_dir)
 
-    @wsme_pecan.wsexpose(ActionCollection, types.uuid, types.uuid,
-                         int, wtypes.text, wtypes.text, types.uuid,
+    @wsme_pecan.wsexpose(ActionCollection, types.uuid, int,
+                         wtypes.text, wtypes.text, types.uuid,
                          types.uuid)
-    def get_all(self, action_uuid=None, marker=None, limit=None,
+    def get_all(self, marker=None, limit=None,
                 sort_key='id', sort_dir='asc', action_plan_uuid=None,
                 audit_uuid=None):
         """Retrieve a list of actions.
@@ -312,16 +313,14 @@ class ActionsController(rest.RestController):
             marker, limit, sort_key, sort_dir,
             action_plan_uuid=action_plan_uuid, audit_uuid=audit_uuid)
 
-    @wsme_pecan.wsexpose(ActionCollection, types.uuid,
-                         types.uuid, int, wtypes.text, wtypes.text,
-                         types.uuid, types.uuid)
-    def detail(self, action_uuid=None, marker=None, limit=None,
+    @wsme_pecan.wsexpose(ActionCollection, types.uuid, int,
+                         wtypes.text, wtypes.text, types.uuid,
+                         types.uuid)
+    def detail(self, marker=None, limit=None,
                sort_key='id', sort_dir='asc', action_plan_uuid=None,
                audit_uuid=None):
         """Retrieve a list of actions with detail.
 
-        :param action_uuid: UUID of a action, to get only actions for that
-                            action.
         :param marker: pagination marker for large data sets.
         :param limit: maximum number of resources to return in a single result.
         :param sort_key: column to sort results by. Default: id.
@@ -364,6 +363,10 @@ class ActionsController(rest.RestController):
 
         :param action: a action within the request body.
         """
+        # FIXME: blueprint edit-action-plan-flow
+        raise exception.OperationNotPermitted(
+            _("Cannot create an action directly"))
+
         if self.from_actions:
             raise exception.OperationNotPermitted
 
@@ -384,6 +387,10 @@ class ActionsController(rest.RestController):
         :param action_uuid: UUID of a action.
         :param patch: a json PATCH document to apply to this action.
         """
+        # FIXME: blueprint edit-action-plan-flow
+        raise exception.OperationNotPermitted(
+            _("Cannot modify an action directly"))
+
         if self.from_actions:
             raise exception.OperationNotPermitted
 
@@ -416,6 +423,9 @@ class ActionsController(rest.RestController):
 
         :param action_uuid: UUID of a action.
         """
+        # FIXME: blueprint edit-action-plan-flow
+        raise exception.OperationNotPermitted(
+            _("Cannot delete an action directly"))
 
         action_to_delete = objects.Action.get_by_uuid(
             pecan.request.context,

watcher/api/controllers/v1/action_plan.py

@@ -49,24 +49,9 @@ standard workflow model description formats such as
 `Business Process Model and Notation 2.0 (BPMN 2.0) <http://www.omg.org/spec/BPMN/2.0/>`_
 or `Unified Modeling Language (UML) <http://www.uml.org/>`_.
 
-An :ref:`Action Plan <action_plan_definition>` has a life-cycle and its current
-state may be one of the following:
-
--  **RECOMMENDED** : the :ref:`Action Plan <action_plan_definition>` is waiting
-   for a validation from the :ref:`Administrator <administrator_definition>`
--  **ONGOING** : the :ref:`Action Plan <action_plan_definition>` is currently
-   being processed by the :ref:`Watcher Applier <watcher_applier_definition>`
--  **SUCCEEDED** : the :ref:`Action Plan <action_plan_definition>` has been
-   executed successfully (i.e. all :ref:`Actions <action_definition>` that it
-   contains have been executed successfully)
--  **FAILED** : an error occured while executing the
-   :ref:`Action Plan <action_plan_definition>`
--  **DELETED** : the :ref:`Action Plan <action_plan_definition>` is still
-   stored in the :ref:`Watcher database <watcher_database_definition>` but is
-   not returned any more through the Watcher APIs.
--  **CANCELLED** : the :ref:`Action Plan <action_plan_definition>` was in
-   **PENDING** or **ONGOING** state and was cancelled by the
-   :ref:`Administrator <administrator_definition>`
+To see the life-cycle and description of 
+:ref:`Action Plan <action_plan_definition>` states, visit :ref:`the Action Plan state
+machine <action_plan_state_machine>`.
 """  # noqa
 
 import datetime
@@ -181,7 +166,6 @@ class ActionPlan(base.APIBase):
 
         self.fields = []
         fields = list(objects.ActionPlan.fields)
-        fields.append('audit_uuid')
         for field in fields:
             # Skip fields we do not expose.
             if not hasattr(self, field):
@@ -189,14 +173,19 @@ class ActionPlan(base.APIBase):
             self.fields.append(field)
             setattr(self, field, kwargs.get(field, wtypes.Unset))
 
-        self.fields.append('audit_id')
+        self.fields.append('audit_uuid')
+        self.fields.append('first_action_uuid')
+
         setattr(self, 'audit_uuid', kwargs.get('audit_id', wtypes.Unset))
+        setattr(self, 'first_action_uuid',
+                kwargs.get('first_action_id', wtypes.Unset))
 
     @staticmethod
     def _convert_with_links(action_plan, url, expand=True):
         if not expand:
-            action_plan.unset_fields_except(['uuid', 'state', 'updated_at',
-                                             'audit_uuid'])
+            action_plan.unset_fields_except(
+                ['uuid', 'state', 'updated_at',
+                 'audit_uuid', 'first_action_uuid'])
 
         action_plan.links = [link.Link.make_link(
             'self', url,
@@ -279,7 +268,7 @@ class ActionPlansController(rest.RestController):
                                      resource_url=None, audit_uuid=None):
 
         limit = api_utils.validate_limit(limit)
-        sort_dir = api_utils.validate_sort_dir(sort_dir)
+        api_utils.validate_sort_dir(sort_dir)
 
         marker_obj = None
         if marker:
@@ -402,12 +391,12 @@ class ActionPlansController(rest.RestController):
         # transitions that are allowed via PATCH
         allowed_patch_transitions = [
             (ap_objects.State.RECOMMENDED,
-             ap_objects.State.TRIGGERED),
+             ap_objects.State.PENDING),
             (ap_objects.State.RECOMMENDED,
              ap_objects.State.CANCELLED),
             (ap_objects.State.ONGOING,
              ap_objects.State.CANCELLED),
-            (ap_objects.State.TRIGGERED,
+            (ap_objects.State.PENDING,
              ap_objects.State.CANCELLED),
         ]
 
@@ -423,7 +412,7 @@ class ActionPlansController(rest.RestController):
                         initial_state=action_plan_to_update.state,
                         new_state=action_plan.state))
 
-            if action_plan.state == ap_objects.State.TRIGGERED:
+            if action_plan.state == ap_objects.State.PENDING:
                 launch_action_plan = True
 
         # Update only the fields that have changed
@@ -439,7 +428,7 @@ class ActionPlansController(rest.RestController):
                 action_plan_to_update[field] = patch_val
 
             if (field == 'state'
-                    and patch_val == objects.action_plan.State.TRIGGERED):
+                    and patch_val == objects.action_plan.State.PENDING):
                 launch_action_plan = True
 
         action_plan_to_update.save()

watcher/api/controllers/v1/audit.py

@@ -25,28 +25,8 @@ on a given :ref:`Cluster <cluster_definition>`.
 For each :ref:`Audit <audit_definition>`, the Watcher system generates an
 :ref:`Action Plan <action_plan_definition>`.
 
-An :ref:`Audit <audit_definition>` has a life-cycle and its current state may
-be one of the following:
-
--  **PENDING** : a request for an :ref:`Audit <audit_definition>` has been
-   submitted (either manually by the
-   :ref:`Administrator <administrator_definition>` or automatically via some
-   event handling mechanism) and is in the queue for being processed by the
-   :ref:`Watcher Decision Engine <watcher_decision_engine_definition>`
--  **ONGOING** : the :ref:`Audit <audit_definition>` is currently being
-   processed by the
-   :ref:`Watcher Decision Engine <watcher_decision_engine_definition>`
--  **SUCCEEDED** : the :ref:`Audit <audit_definition>` has been executed
-   successfully (note that it may not necessarily produce a
-   :ref:`Solution <solution_definition>`).
--  **FAILED** : an error occured while executing the
-   :ref:`Audit <audit_definition>`
--  **DELETED** : the :ref:`Audit <audit_definition>` is still stored in the
-   :ref:`Watcher database <watcher_database_definition>` but is not returned
-   any more through the Watcher APIs.
--  **CANCELLED** : the :ref:`Audit <audit_definition>` was in **PENDING** or
-   **ONGOING** state and was cancelled by the
-   :ref:`Administrator <administrator_definition>`
+To see the life-cycle and description of an :ref:`Audit <audit_definition>`
+states, visit :ref:`the Audit State machine <audit_state_machine>`.
 """
 
 import datetime
@@ -65,7 +45,7 @@ from watcher.api.controllers.v1 import types
 from watcher.api.controllers.v1 import utils as api_utils
 from watcher.common import exception
 from watcher.common import utils
-from watcher.decision_engine.rpcapi import DecisionEngineAPI
+from watcher.decision_engine import rpcapi
 from watcher import objects
 
 
@@ -263,7 +243,7 @@ class AuditsController(rest.RestController):
                                sort_key, sort_dir, expand=False,
                                resource_url=None, audit_template=None):
         limit = api_utils.validate_limit(limit)
-        sort_dir = api_utils.validate_sort_dir(sort_dir)
+        api_utils.validate_sort_dir(sort_dir)
 
         marker_obj = None
         if marker:
@@ -369,7 +349,7 @@ class AuditsController(rest.RestController):
 
         # trigger decision-engine to run the audit
 
-        dc_client = DecisionEngineAPI()
+        dc_client = rpcapi.DecisionEngineAPI()
         dc_client.trigger_audit(context, new_audit.uuid)
 
         return Audit.convert_with_links(new_audit)

watcher/api/controllers/v1/audit_template.py

@@ -50,6 +50,7 @@ provided as a list of key-value pairs.
 
 import datetime
 
+from oslo_config import cfg
 import pecan
 from pecan import rest
 import wsme
@@ -67,11 +68,25 @@ from watcher import objects
 
 
 class AuditTemplatePatchType(types.JsonPatchType):
-
     @staticmethod
     def mandatory_attrs():
         return []
 
+    @staticmethod
+    def validate(patch):
+        if patch.path == "/goal":
+            AuditTemplatePatchType._validate_goal(patch)
+        return types.JsonPatchType.validate(patch)
+
+    @staticmethod
+    def _validate_goal(patch):
+        serialized_patch = {'path': patch.path, 'op': patch.op}
+        if patch.value is not wsme.Unset:
+            serialized_patch['value'] = patch.value
+        new_goal = patch.value
+        if new_goal and new_goal not in cfg.CONF.watcher_goals.goals.keys():
+            raise exception.InvalidGoal(goal=new_goal)
+
 
 class AuditTemplate(base.APIBase):
     """API representation of a audit template.
@@ -149,13 +164,19 @@ class AuditTemplate(base.APIBase):
                      name='My Audit Template',
                      description='Description of my audit template',
                      host_aggregate=5,
-                     goal='SERVERS_CONSOLIDATION',
+                     goal='DUMMY',
                      extra={'automatic': True},
                      created_at=datetime.datetime.utcnow(),
                      deleted_at=None,
                      updated_at=datetime.datetime.utcnow())
         return cls._convert_with_links(sample, 'http://localhost:9322', expand)
 
+    @staticmethod
+    def validate(audit_template):
+        if audit_template.goal not in cfg.CONF.watcher_goals.goals.keys():
+            raise exception.InvalidGoal(audit_template.goal)
+        return audit_template
+
 
 class AuditTemplateCollection(collection.Collection):
     """API representation of a collection of audit templates."""
@@ -197,12 +218,13 @@ class AuditTemplatesController(rest.RestController):
         'detail': ['GET'],
     }
 
-    def _get_audit_templates_collection(self, marker, limit,
+    def _get_audit_templates_collection(self, filters, marker, limit,
                                         sort_key, sort_dir, expand=False,
                                         resource_url=None):
-
+        api_utils.validate_search_filters(
+            filters, objects.audit_template.AuditTemplate.fields.keys())
         limit = api_utils.validate_limit(limit)
-        sort_dir = api_utils.validate_sort_dir(sort_dir)
+        api_utils.validate_sort_dir(sort_dir)
 
         marker_obj = None
         if marker:
@@ -212,6 +234,7 @@ class AuditTemplatesController(rest.RestController):
 
         audit_templates = objects.AuditTemplate.list(
             pecan.request.context,
+            filters,
             limit,
             marker_obj, sort_key=sort_key,
             sort_dir=sort_dir)
@@ -223,26 +246,30 @@ class AuditTemplatesController(rest.RestController):
                                                           sort_key=sort_key,
                                                           sort_dir=sort_dir)
 
-    @wsme_pecan.wsexpose(AuditTemplateCollection, types.uuid, int,
-                         wtypes.text, wtypes.text)
-    def get_all(self, marker=None, limit=None,
+    @wsme_pecan.wsexpose(AuditTemplateCollection, wtypes.text,
+                         types.uuid, int, wtypes.text, wtypes.text)
+    def get_all(self, goal=None, marker=None, limit=None,
                 sort_key='id', sort_dir='asc'):
         """Retrieve a list of audit templates.
 
+        :param goal: goal name to filter by (case sensitive)
         :param marker: pagination marker for large data sets.
         :param limit: maximum number of resources to return in a single result.
         :param sort_key: column to sort results by. Default: id.
         :param sort_dir: direction to sort. "asc" or "desc". Default: asc.
         """
-        return self._get_audit_templates_collection(marker, limit, sort_key,
-                                                    sort_dir)
+        filters = api_utils.as_filters_dict(goal=goal)
 
-    @wsme_pecan.wsexpose(AuditTemplateCollection, types.uuid, int,
+        return self._get_audit_templates_collection(
+            filters, marker, limit, sort_key, sort_dir)
+
+    @wsme_pecan.wsexpose(AuditTemplateCollection, wtypes.text, types.uuid, int,
                          wtypes.text, wtypes.text)
-    def detail(self, marker=None, limit=None,
+    def detail(self, goal=None, marker=None, limit=None,
                sort_key='id', sort_dir='asc'):
         """Retrieve a list of audit templates with detail.
 
+        :param goal: goal name to filter by (case sensitive)
         :param marker: pagination marker for large data sets.
         :param limit: maximum number of resources to return in a single result.
         :param sort_key: column to sort results by. Default: id.
@@ -253,9 +280,11 @@ class AuditTemplatesController(rest.RestController):
         if parent != "audit_templates":
             raise exception.HTTPNotFound
 
+        filters = api_utils.as_filters_dict(goal=goal)
+
         expand = True
         resource_url = '/'.join(['audit_templates', 'detail'])
-        return self._get_audit_templates_collection(marker, limit,
+        return self._get_audit_templates_collection(filters, marker, limit,
                                                     sort_key, sort_dir, expand,
                                                     resource_url)
 
@@ -263,7 +292,7 @@ class AuditTemplatesController(rest.RestController):
     def get_one(self, audit_template):
         """Retrieve information about the given audit template.
 
-        :param audit template_uuid: UUID or name of an audit template.
+        :param audit audit_template: UUID or name of an audit template.
         """
         if self.from_audit_templates:
             raise exception.OperationNotPermitted
@@ -279,12 +308,14 @@ class AuditTemplatesController(rest.RestController):
 
         return AuditTemplate.convert_with_links(rpc_audit_template)
 
+    @wsme.validate(types.uuid, AuditTemplate)
     @wsme_pecan.wsexpose(AuditTemplate, body=AuditTemplate, status_code=201)
     def post(self, audit_template):
         """Create a new audit template.
 
         :param audit template: a audit template within the request body.
         """
+
         if self.from_audit_templates:
             raise exception.OperationNotPermitted
 

watcher/api/controllers/v1/goal.py

@@ -159,7 +159,7 @@ class GoalsController(rest.RestController):
                               resource_url=None, goal_name=None):
 
         limit = api_utils.validate_limit(limit)
-        sort_dir = api_utils.validate_sort_dir(sort_dir)
+        api_utils.validate_sort_dir(sort_dir)
 
         goals = []
 

watcher/api/controllers/v1/utils.py

@@ -47,7 +47,15 @@ def validate_sort_dir(sort_dir):
         raise wsme.exc.ClientSideError(_("Invalid sort direction: %s. "
                                          "Acceptable values are "
                                          "'asc' or 'desc'") % sort_dir)
-    return sort_dir
+
+
+def validate_search_filters(filters, allowed_fields):
+    # Very leightweight validation for now
+    # todo: improve this (e.g. https://www.parse.com/docs/rest/guide/#queries)
+    for filter_name in filters.keys():
+        if filter_name not in allowed_fields:
+            raise wsme.exc.ClientSideError(
+                _("Invalid filter: %s") % filter_name)
 
 
 def apply_jsonpatch(doc, patch):
@@ -58,3 +66,12 @@ def apply_jsonpatch(doc, patch):
                         ' the resource is not allowed')
                 raise wsme.exc.ClientSideError(msg % p['path'])
     return jsonpatch.apply_patch(doc, jsonpatch.JsonPatch(patch))
+
+
+def as_filters_dict(**filters):
+    filters_dict = {}
+    for filter_name, filter_value in filters.items():
+        if filter_value:
+            filters_dict[filter_name] = filter_value
+
+    return filters_dict

watcher/applier/action_plan/default.py

@@ -43,8 +43,8 @@ class DefaultActionPlanHandler(base.BaseActionPlanHandler):
         ev.data = {}
         payload = {'action_plan__uuid': uuid,
                    'action_plan_state': state}
-        self.applier_manager.topic_status.publish_event(ev.type.name,
-                                                        payload)
+        self.applier_manager.status_topic_handler.publish_event(
+            ev.type.name, payload)
 
     def execute(self):
         try:
@@ -52,17 +52,16 @@ class DefaultActionPlanHandler(base.BaseActionPlanHandler):
             self.notify(self.action_plan_uuid,
                         event_types.EventTypes.LAUNCH_ACTION_PLAN,
                         ap_objects.State.ONGOING)
-            applier = default.DefaultApplier(self.applier_manager, self.ctx)
-            result = applier.execute(self.action_plan_uuid)
+            applier = default.DefaultApplier(self.ctx, self.applier_manager)
+            applier.execute(self.action_plan_uuid)
+            state = ap_objects.State.SUCCEEDED
+
         except Exception as e:
             LOG.exception(e)
-            result = False
+            state = ap_objects.State.FAILED
+
         finally:
-            if result is True:
-                status = ap_objects.State.SUCCEEDED
-            else:
-                status = ap_objects.State.FAILED
             # update state
             self.notify(self.action_plan_uuid,
                         event_types.EventTypes.LAUNCH_ACTION_PLAN,
-                        status)
+                        state)

watcher/applier/actions/base.py

@@ -22,12 +22,27 @@ import abc
 
 import six
 
+from watcher.common import clients
+
 
 @six.add_metaclass(abc.ABCMeta)
 class BaseAction(object):
-    def __init__(self):
+    # NOTE(jed) by convention we decided
+    # that the attribute "resource_id" is the unique id of
+    # the resource to which the Action applies to allow us to use it in the
+    # watcher dashboard and will be nested in input_parameters
+    RESOURCE_ID = 'resource_id'
+
+    def __init__(self, osc=None):
+        """:param osc: an OpenStackClients instance"""
         self._input_parameters = {}
-        self._applies_to = ""
+        self._osc = osc
+
+    @property
+    def osc(self):
+        if not self._osc:
+            self._osc = clients.OpenStackClients()
+        return self._osc
 
     @property
     def input_parameters(self):
@@ -38,25 +53,64 @@ class BaseAction(object):
         self._input_parameters = p
 
     @property
-    def applies_to(self):
-        return self._applies_to
-
-    @applies_to.setter
-    def applies_to(self, a):
-        self._applies_to = a
+    def resource_id(self):
+        return self.input_parameters[self.RESOURCE_ID]
 
     @abc.abstractmethod
     def execute(self):
+        """Executes the main logic of the action
+
+        This method can be used to perform an action on a given set of input
+        parameters to accomplish some type of operation. This operation may
+        return a boolean value as a result of its execution. If False, this
+        will be considered as an error and will then trigger the reverting of
+        the actions.
+
+        :returns: A flag indicating whether or not the action succeeded
+        :rtype: bool
+        """
         raise NotImplementedError()
 
     @abc.abstractmethod
     def revert(self):
+        """Revert this action
+
+        This method should rollback the resource to its initial state in the
+        event of a faulty execution. This happens when the action raised an
+        exception during its :py:meth:`~.BaseAction.execute`.
+        """
         raise NotImplementedError()
 
     @abc.abstractmethod
     def precondition(self):
+        """Hook: called before the execution of an action
+
+        This method can be used to perform some initializations or to make
+        some more advanced validation on its input parameters. So if you wish
+        to block its execution based on this factor, `raise` the related
+        exception.
+        """
         raise NotImplementedError()
 
     @abc.abstractmethod
     def postcondition(self):
+        """Hook: called after the execution of an action
+
+        This function is called regardless of whether an action succeded or
+        not. So you can use it to perform cleanup operations.
+        """
         raise NotImplementedError()
+
+    @abc.abstractproperty
+    def schema(self):
+        """Defines a Schema that the input parameters shall comply to
+
+        :returns: A schema declaring the input parameters this action should be
+                  provided along with their respective constraints
+        :rtype: :py:class:`voluptuous.Schema` instance
+        """
+        raise NotImplementedError()
+
+    def validate_parameters(self):
+        self.schema(self.input_parameters)
+        return True

watcher/applier/actions/change_nova_service_state.py

@@ -16,54 +16,84 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 #
-
+import six
+import voluptuous
 
 from watcher._i18n import _
 from watcher.applier.actions import base
 from watcher.common import exception
-from watcher.common import keystone as kclient
-from watcher.common import nova as nclient
+from watcher.common import nova_helper
 from watcher.decision_engine.model import hypervisor_state as hstate
 
 
 class ChangeNovaServiceState(base.BaseAction):
+    """Disables or enables the nova-compute service, deployed on a host
+
+    By using this action, you will be able to update the state of a
+    nova-compute service. A disabled nova-compute service can not be selected
+    by the nova scheduler for future deployment of server.
+
+    The action schema is::
+
+        schema = Schema({
+         'resource_id': str,
+         'state': str,
+        })
+
+    The `resource_id` references a nova-compute service name (list of available
+    nova-compute services is returned by this command: ``nova service-list
+    --binary nova-compute``).
+    The `state` value should either be `ONLINE` or `OFFLINE`.
+    """
+
+    STATE = 'state'
+
+    @property
+    def schema(self):
+        return voluptuous.Schema({
+            voluptuous.Required(self.RESOURCE_ID):
+                voluptuous.All(
+                    voluptuous.Any(*six.string_types),
+                    voluptuous.Length(min=1)),
+            voluptuous.Required(self.STATE):
+                voluptuous.Any(*[state.value
+                                 for state in list(hstate.HypervisorState)]),
+        })
 
     @property
     def host(self):
-        return self.applies_to
+        return self.resource_id
 
     @property
     def state(self):
-        return self.input_parameters.get('state')
+        return self.input_parameters.get(self.STATE)
 
     def execute(self):
         target_state = None
-        if self.state == hstate.HypervisorState.OFFLINE.value:
+        if self.state == hstate.HypervisorState.DISABLED.value:
             target_state = False
-        elif self.status == hstate.HypervisorState.ONLINE.value:
+        elif self.state == hstate.HypervisorState.ENABLED.value:
             target_state = True
-        return self.nova_manage_service(target_state)
+        return self._nova_manage_service(target_state)
 
     def revert(self):
         target_state = None
-        if self.state == hstate.HypervisorState.OFFLINE.value:
+        if self.state == hstate.HypervisorState.DISABLED.value:
             target_state = True
-        elif self.state == hstate.HypervisorState.ONLINE.value:
+        elif self.state == hstate.HypervisorState.ENABLED.value:
             target_state = False
-        return self.nova_manage_service(target_state)
+        return self._nova_manage_service(target_state)
 
-    def nova_manage_service(self, state):
+    def _nova_manage_service(self, state):
         if state is None:
             raise exception.IllegalArgumentException(
                 message=_("The target state is not defined"))
 
-        keystone = kclient.KeystoneClient()
-        wrapper = nclient.NovaClient(keystone.get_credentials(),
-                                     session=keystone.get_session())
+        nova = nova_helper.NovaHelper(osc=self.osc)
         if state is True:
-            return wrapper.enable_service_nova_compute(self.host)
+            return nova.enable_service_nova_compute(self.host)
         else:
-            return wrapper.disable_service_nova_compute(self.host)
+            return nova.disable_service_nova_compute(self.host)
 
     def precondition(self):
         pass

watcher/applier/actions/factory.py

@@ -28,9 +28,15 @@ class ActionFactory(object):
     def __init__(self):
         self.action_loader = default.DefaultActionLoader()
 
-    def make_action(self, object_action):
+    def make_action(self, object_action, osc=None):
         LOG.debug("Creating instance of %s", object_action.action_type)
-        loaded_action = self.action_loader.load(name=object_action.action_type)
+        loaded_action = self.action_loader.load(name=object_action.action_type,
+                                                osc=osc)
         loaded_action.input_parameters = object_action.input_parameters
-        loaded_action.applies_to = object_action.applies_to
+        LOG.debug("Checking the input parameters")
+        # NOTE(jed) if we change the schema of an action and we try to reload
+        # an older version of the Action, the validation can fail.
+        # We need to add the versioning of an Action or a migration tool.
+        # We can also create an new Action which extends the previous one.
+        loaded_action.validate_parameters()
         return loaded_action

watcher/applier/actions/migration.py

@@ -18,45 +18,128 @@
 #
 
 from oslo_log import log
+import six
+import voluptuous
 
+from watcher._i18n import _, _LC
 from watcher.applier.actions import base
 from watcher.common import exception
-from watcher.common import keystone as kclient
-from watcher.common import nova as nclient
+from watcher.common import nova_helper
+from watcher.common import utils
 
 LOG = log.getLogger(__name__)
 
 
 class Migrate(base.BaseAction):
+    """Live-Migrates a server to a destination nova-compute host
+
+    This action will allow you to migrate a server to another compute
+    destination host. As of now, only live migration can be performed using
+    this action.
+    .. If either host uses shared storage, you can use ``live``
+    .. as ``migration_type``. If both source and destination hosts provide
+    .. local disks, you can set the block_migration parameter to True (not
+    .. supported for yet).
+
+    The action schema is::
+
+        schema = Schema({
+         'resource_id': str,  # should be a UUID
+         'migration_type': str,  # choices -> "live" only
+         'dst_hypervisor': str,
+         'src_hypervisor': str,
+        })
+
+    The `resource_id` is the UUID of the server to migrate. Only live migration
+    is supported.
+    The `src_hypervisor` and `dst_hypervisor` parameters are respectively the
+    source and the destination compute hostname (list of available compute
+    hosts is returned by this command: ``nova service-list --binary
+    nova-compute``).
+    """
+
+    # input parameters constants
+    MIGRATION_TYPE = 'migration_type'
+    LIVE_MIGRATION = 'live'
+    DST_HYPERVISOR = 'dst_hypervisor'
+    SRC_HYPERVISOR = 'src_hypervisor'
+
+    def check_resource_id(self, value):
+        if (value is not None and
+                len(value) > 0 and not
+                utils.is_uuid_like(value)):
+            raise voluptuous.Invalid(_("The parameter"
+                                       " resource_id is invalid."))
+
+    @property
+    def schema(self):
+        return voluptuous.Schema({
+            voluptuous.Required(self.RESOURCE_ID): self.check_resource_id,
+            voluptuous.Required(self.MIGRATION_TYPE,
+                                default=self.LIVE_MIGRATION):
+                                    voluptuous.Any(*[self.LIVE_MIGRATION]),
+            voluptuous.Required(self.DST_HYPERVISOR):
+                voluptuous.All(voluptuous.Any(*six.string_types),
+                               voluptuous.Length(min=1)),
+            voluptuous.Required(self.SRC_HYPERVISOR):
+                voluptuous.All(voluptuous.Any(*six.string_types),
+                               voluptuous.Length(min=1)),
+        })
+
     @property
     def instance_uuid(self):
-        return self.applies_to
+        return self.resource_id
 
     @property
     def migration_type(self):
-        return self.input_parameters.get('migration_type')
+        return self.input_parameters.get(self.MIGRATION_TYPE)
 
     @property
     def dst_hypervisor(self):
-        return self.input_parameters.get('dst_hypervisor')
+        return self.input_parameters.get(self.DST_HYPERVISOR)
 
     @property
     def src_hypervisor(self):
-        return self.input_parameters.get('src_hypervisor')
+        return self.input_parameters.get(self.SRC_HYPERVISOR)
+
+    def _live_migrate_instance(self, nova, destination):
+        result = None
+        try:
+            result = nova.live_migrate_instance(instance_id=self.instance_uuid,
+                                                dest_hostname=destination)
+        except nova_helper.nvexceptions.ClientException as e:
+            if e.code == 400:
+                LOG.debug("Live migration of instance %s failed. "
+                          "Trying to live migrate using block migration."
+                          % self.instance_uuid)
+                result = nova.live_migrate_instance(
+                    instance_id=self.instance_uuid,
+                    dest_hostname=destination,
+                    block_migration=True)
+            else:
+                LOG.debug("Nova client exception occured while live migrating "
+                          "instance %s.Exception: %s" %
+                          (self.instance_uuid, e))
+        except Exception:
+            LOG.critical(_LC("Unexpected error occured. Migration failed for"
+                             "instance %s. Leaving instance on previous "
+                             "host."), self.instance_uuid)
+
+        return result
 
     def migrate(self, destination):
-        keystone = kclient.KeystoneClient()
-        wrapper = nclient.NovaClient(keystone.get_credentials(),
-                                     session=keystone.get_session())
-        LOG.debug("Migrate instance %s to %s  ", self.instance_uuid,
+        nova = nova_helper.NovaHelper(osc=self.osc)
+        LOG.debug("Migrate instance %s to %s", self.instance_uuid,
                   destination)
-        instance = wrapper.find_instance(self.instance_uuid)
+        instance = nova.find_instance(self.instance_uuid)
         if instance:
             if self.migration_type == 'live':
-                return wrapper.live_migrate_instance(
-                    instance_id=self.instance_uuid, dest_hostname=destination)
+                return self._live_migrate_instance(nova, destination)
             else:
-                raise exception.InvalidParameterValue(err=self.migration_type)
+                raise exception.Invalid(
+                    message=(_('Migration of type %(migration_type)s is not '
+                               'supported.') %
+                             {'migration_type': self.migration_type}))
         else:
             raise exception.InstanceNotFound(name=self.instance_uuid)
 

watcher/applier/actions/nop.py

@@ -18,6 +18,8 @@
 #
 
 from oslo_log import log
+import six
+import voluptuous
 
 from watcher.applier.actions import base
 
@@ -26,10 +28,29 @@ LOG = log.getLogger(__name__)
 
 
 class Nop(base.BaseAction):
+    """logs a message
+
+    The action schema is::
+
+        schema = Schema({
+         'message': str,
+        })
+
+    The `message` is the actual message that will be logged.
+    """
+
+    MESSAGE = 'message'
+
+    @property
+    def schema(self):
+        return voluptuous.Schema({
+            voluptuous.Required(self.MESSAGE): voluptuous.Any(
+                voluptuous.Any(*six.string_types), None)
+        })
 
     @property
     def message(self):
-        return self.input_parameters.get('message')
+        return self.input_parameters.get(self.MESSAGE)
 
     def execute(self):
         LOG.debug("executing action NOP message:%s ", self.message)

watcher/applier/actions/sleep.py

@@ -18,19 +18,39 @@
 #
 import time
 
+
 from oslo_log import log
+import voluptuous
 
 from watcher.applier.actions import base
 
-
 LOG = log.getLogger(__name__)
 
 
 class Sleep(base.BaseAction):
+    """Makes the executor of the action plan wait for a given duration
+
+    The action schema is::
+
+        schema = Schema({
+         'duration': float,
+        })
+
+    The `duration` is expressed in seconds.
+    """
+
+    DURATION = 'duration'
+
+    @property
+    def schema(self):
+        return voluptuous.Schema({
+            voluptuous.Required(self.DURATION, default=1):
+                voluptuous.All(float, voluptuous.Range(min=0))
+        })
 
     @property
     def duration(self):
-        return int(self.input_parameters.get('duration'))
+        return int(self.input_parameters.get(self.DURATION))
 
     def execute(self):
         LOG.debug("Starting action Sleep duration:%s ", self.duration)

watcher/applier/default.py

@@ -28,7 +28,7 @@ CONF = cfg.CONF
 
 
 class DefaultApplier(base.BaseApplier):
-    def __init__(self, applier_manager, context):
+    def __init__(self, context, applier_manager):
         super(DefaultApplier, self).__init__()
         self._applier_manager = applier_manager
         self._loader = default.DefaultWorkFlowEngineLoader()
@@ -48,9 +48,10 @@ class DefaultApplier(base.BaseApplier):
         if self._engine is None:
             selected_workflow_engine = CONF.watcher_applier.workflow_engine
             LOG.debug("Loading workflow engine %s ", selected_workflow_engine)
-            self._engine = self._loader.load(name=selected_workflow_engine)
-            self._engine.context = self.context
-            self._engine.applier_manager = self.applier_manager
+            self._engine = self._loader.load(
+                name=selected_workflow_engine,
+                context=self.context,
+                applier_manager=self.applier_manager)
         return self._engine
 
     def execute(self, action_plan_uuid):

watcher/applier/manager.py

@@ -34,12 +34,12 @@ APPLIER_MANAGER_OPTS = [
                min=1,
                required=True,
                help='Number of workers for applier, default value is 1.'),
-    cfg.StrOpt('topic_control',
+    cfg.StrOpt('conductor_topic',
                default='watcher.applier.control',
                help='The topic name used for'
                     'control events, this topic '
                     'used for rpc call '),
-    cfg.StrOpt('topic_status',
+    cfg.StrOpt('status_topic',
                default='watcher.applier.status',
                help='The topic name used for '
                     'status events, this topic '
@@ -67,12 +67,13 @@ class ApplierManager(messaging_core.MessagingCore):
     def __init__(self):
         super(ApplierManager, self).__init__(
             CONF.watcher_applier.publisher_id,
-            CONF.watcher_applier.topic_control,
-            CONF.watcher_applier.topic_status,
+            CONF.watcher_applier.conductor_topic,
+            CONF.watcher_applier.status_topic,
             api_version=self.API_VERSION,
         )
-        self.topic_control.add_endpoint(trigger.TriggerActionPlan(self))
+        self.conductor_topic_handler.add_endpoint(
+            trigger.TriggerActionPlan(self))
 
     def join(self):
-        self.topic_control.join()
-        self.topic_status.join()
+        self.conductor_topic_handler.join()
+        self.status_topic_handler.join()

watcher/applier/rpcapi.py

@@ -39,17 +39,17 @@ class ApplierAPI(messaging_core.MessagingCore):
     def __init__(self):
         super(ApplierAPI, self).__init__(
             CONF.watcher_applier.publisher_id,
-            CONF.watcher_applier.topic_control,
-            CONF.watcher_applier.topic_status,
+            CONF.watcher_applier.conductor_topic,
+            CONF.watcher_applier.status_topic,
             api_version=self.API_VERSION,
         )
         self.handler = notification.NotificationHandler(self.publisher_id)
         self.handler.register_observer(self)
-        self.topic_status.add_endpoint(self.handler)
+        self.status_topic_handler.add_endpoint(self.handler)
         transport = om.get_transport(CONF)
 
         target = om.Target(
-            topic=CONF.watcher_applier.topic_control,
+            topic=CONF.watcher_applier.conductor_topic,
             version=self.API_VERSION,
         )
 
@@ -63,10 +63,3 @@ class ApplierAPI(messaging_core.MessagingCore):
         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.exception(e)
-            raise

watcher/applier/workflow_engine/base.py

@@ -22,33 +22,33 @@ import six
 
 from watcher.applier.actions import factory
 from watcher.applier.messaging import event_types
+from watcher.common import clients
 from watcher.common.messaging.events import event
 from watcher import objects
 
 
 @six.add_metaclass(abc.ABCMeta)
 class BaseWorkFlowEngine(object):
-    def __init__(self):
-        self._applier_manager = None
-        self._context = None
+    def __init__(self, context=None, applier_manager=None):
+        self._context = context
+        self._applier_manager = applier_manager
         self._action_factory = factory.ActionFactory()
+        self._osc = None
 
     @property
     def context(self):
         return self._context
 
-    @context.setter
-    def context(self, c):
-        self._context = c
+    @property
+    def osc(self):
+        if not self._osc:
+            self._osc = clients.OpenStackClients()
+        return self._osc
 
     @property
     def applier_manager(self):
         return self._applier_manager
 
-    @applier_manager.setter
-    def applier_manager(self, a):
-        self._applier_manager = a
-
     @property
     def action_factory(self):
         return self._action_factory
@@ -62,8 +62,8 @@ class BaseWorkFlowEngine(object):
         ev.data = {}
         payload = {'action_uuid': action.uuid,
                    'action_state': state}
-        self.applier_manager.topic_status.publish_event(ev.type.name,
-                                                        payload)
+        self.applier_manager.status_topic_handler.publish_event(
+            ev.type.name, payload)
 
     @abc.abstractmethod
     def execute(self, actions):

watcher/applier/workflow_engine/default.py

@@ -22,12 +22,19 @@ from taskflow import task
 
 from watcher._i18n import _LE, _LW, _LC
 from watcher.applier.workflow_engine import base
+from watcher.common import exception
 from watcher.objects import action as obj_action
 
 LOG = log.getLogger(__name__)
 
 
 class DefaultWorkFlowEngine(base.BaseWorkFlowEngine):
+    """Taskflow as a workflow engine for Watcher
+
+    Full documentation on taskflow at
+    http://docs.openstack.org/developer/taskflow/
+    """
+
     def decider(self, history):
         # FIXME(jed) not possible with the current Watcher Planner
         #
@@ -71,10 +78,9 @@ class DefaultWorkFlowEngine(base.BaseWorkFlowEngine):
 
             e = engines.load(flow)
             e.run()
-            return True
+
         except Exception as e:
-            LOG.exception(e)
-            return False
+            raise exception.WorkflowExecutionException(error=e)
 
 
 class TaskFlowActionContainer(task.Task):
@@ -89,7 +95,9 @@ class TaskFlowActionContainer(task.Task):
     @property
     def action(self):
         if self.loaded_action is None:
-            action = self.engine.action_factory.make_action(self._db_action)
+            action = self.engine.action_factory.make_action(
+                self._db_action,
+                osc=self._engine.osc)
             self.loaded_action = action
         return self.loaded_action
 
@@ -113,14 +121,9 @@ class TaskFlowActionContainer(task.Task):
         try:
             LOG.debug("Running action %s", self.name)
 
-            # todo(jed) remove return (true or false) raise an Exception
-            result = self.action.execute()
-            if result is not True:
-                self.engine.notify(self._db_action,
-                                   obj_action.State.FAILED)
-            else:
-                self.engine.notify(self._db_action,
-                                   obj_action.State.SUCCEEDED)
+            self.action.execute()
+            self.engine.notify(self._db_action,
+                               obj_action.State.SUCCEEDED)
         except Exception as e:
             LOG.exception(e)
             LOG.error(_LE('The WorkFlow Engine has failed '

watcher/cmd/applier.py

@@ -25,7 +25,7 @@ from oslo_config import cfg
 from oslo_log import log as logging
 
 from watcher import _i18n
-from watcher.applier.manager import ApplierManager
+from watcher.applier import manager
 from watcher.common import service
 
 LOG = logging.getLogger(__name__)
@@ -40,6 +40,6 @@ def main():
     LOG.debug("Configuration:")
     cfg.CONF.log_opt_values(LOG, std_logging.DEBUG)
 
-    server = ApplierManager()
+    server = manager.ApplierManager()
     server.connect()
     server.join()

watcher/cmd/dbmanage.py

@@ -25,7 +25,7 @@ from oslo_config import cfg
 
 from watcher.common import service
 from watcher.db import migration
-
+from watcher.db import purge
 
 CONF = cfg.CONF
 
@@ -56,6 +56,12 @@ class DBCommand(object):
     def create_schema():
         migration.create_schema()
 
+    @staticmethod
+    def purge():
+        purge.purge(CONF.command.age_in_days, CONF.command.max_number,
+                    CONF.command.audit_template, CONF.command.exclude_orphans,
+                    CONF.command.dry_run)
+
 
 def add_command_parsers(subparsers):
     parser = subparsers.add_parser(
@@ -96,6 +102,33 @@ def add_command_parsers(subparsers):
         help="Create the database schema.")
     parser.set_defaults(func=DBCommand.create_schema)
 
+    parser = subparsers.add_parser(
+        'purge',
+        help="Purge the database.")
+    parser.add_argument('-d', '--age-in-days',
+                        help="Number of days since deletion (from today) "
+                             "to exclude from the purge. If None, everything "
+                             "will be purged.",
+                        type=int, default=None, nargs='?')
+    parser.add_argument('-n', '--max-number',
+                        help="Max number of objects expected to be deleted. "
+                             "Prevents the deletion if exceeded. No limit if "
+                             "set to None.",
+                        type=int, default=None, nargs='?')
+    parser.add_argument('-t', '--audit-template',
+                        help="UUID or name of the audit template to purge.",
+                        type=str, default=None, nargs='?')
+    parser.add_argument('-e', '--exclude-orphans', action='store_true',
+                        help="Flag to indicate whether or not you want to "
+                             "exclude orphans from deletion (default: False).",
+                        default=False)
+    parser.add_argument('--dry-run', action='store_true',
+                        help="Flag to indicate whether or not you want to "
+                             "perform a dry run (no deletion).",
+                        default=False)
+
+    parser.set_defaults(func=DBCommand.purge)
+
 
 command_opt = cfg.SubCommandOpt('command',
                                 title='Command',
@@ -114,6 +147,7 @@ def main():
     valid_commands = set([
         'upgrade', 'downgrade', 'revision',
         'version', 'stamp', 'create_schema',
+        'purge',
     ])
     if not set(sys.argv).intersection(valid_commands):
         sys.argv.append('upgrade')

watcher/cmd/decisionengine.py

@@ -26,7 +26,7 @@ from oslo_log import log as logging
 
 from watcher import _i18n
 from watcher.common import service
-from watcher.decision_engine.manager import DecisionEngineManager
+from watcher.decision_engine import manager
 
 
 LOG = logging.getLogger(__name__)
@@ -41,6 +41,6 @@ def main():
     LOG.debug("Configuration:")
     cfg.CONF.log_opt_values(LOG, std_logging.DEBUG)
 
-    server = DecisionEngineManager()
+    server = manager.DecisionEngineManager()
     server.connect()
     server.join()

watcher/common/ceilometer_helper.py

@@ -17,30 +17,16 @@
 # limitations under the License.
 #
 
-from ceilometerclient import client
 from ceilometerclient.exc import HTTPUnauthorized
 
-from watcher.common import keystone
+from watcher.common import clients
 
 
-class CeilometerClient(object):
-    def __init__(self, api_version='2'):
-        self._cmclient = None
-        self._api_version = api_version
-
-    @property
-    def cmclient(self):
-        """Initialization of Ceilometer client."""
-        if not self._cmclient:
-            ksclient = keystone.KeystoneClient()
-            creds = ksclient.get_credentials()
-            endpoint = ksclient.get_endpoint(
-                service_type='metering',
-                endpoint_type='publicURL')
-            self._cmclient = client.get_client(self._api_version,
-                                               ceilometer_url=endpoint,
-                                               **creds)
-        return self._cmclient
+class CeilometerHelper(object):
+    def __init__(self, osc=None):
+        """:param osc: an OpenStackClients instance"""
+        self.osc = osc if osc else clients.OpenStackClients()
+        self.ceilometer = self.osc.ceilometer()
 
     def build_query(self, user_id=None, tenant_id=None, resource_id=None,
                     user_ids=None, tenant_ids=None, resource_ids=None):
@@ -83,20 +69,21 @@ class CeilometerClient(object):
         try:
             return f(*args, **kargs)
         except HTTPUnauthorized:
-            self.reset_client()
+            self.osc.reset_clients()
+            self.ceilometer = self.osc.ceilometer()
             return f(*args, **kargs)
         except Exception:
             raise
 
     def query_sample(self, meter_name, query, limit=1):
-        return self.query_retry(f=self.cmclient.samples.list,
+        return self.query_retry(f=self.ceilometer.samples.list,
                                 meter_name=meter_name,
                                 limit=limit,
                                 q=query)
 
     def statistic_list(self, meter_name, query=None, period=None):
         """List of statistics."""
-        statistics = self.cmclient.statistics.list(
+        statistics = self.ceilometer.statistics.list(
             meter_name=meter_name,
             q=query,
             period=period)
@@ -104,7 +91,8 @@ class CeilometerClient(object):
 
     def meter_list(self, query=None):
         """List the user's meters."""
-        meters = self.query_retry(f=self.cmclient.meters.list, query=query)
+        meters = self.query_retry(f=self.ceilometer.meters.list,
+                                  query=query)
         return meters
 
     def statistic_aggregation(self,
@@ -125,7 +113,7 @@ class CeilometerClient(object):
         """
 
         query = self.build_query(resource_id=resource_id)
-        statistic = self.query_retry(f=self.cmclient.statistics.list,
+        statistic = self.query_retry(f=self.ceilometer.statistics.list,
                                      meter_name=meter_name,
                                      q=query,
                                      period=period,
@@ -140,7 +128,8 @@ class CeilometerClient(object):
 
     def get_last_sample_values(self, resource_id, meter_name, limit=1):
         samples = self.query_sample(meter_name=meter_name,
-                                    query=self.build_query(resource_id))
+                                    query=self.build_query(resource_id),
+                                    limit=limit)
         values = []
         for index, sample in enumerate(samples):
             values.append(
@@ -156,6 +145,3 @@ class CeilometerClient(object):
             return samples[-1]._info['counter_volume']
         else:
             return False
-
-    def reset_client(self):
-        self._cmclient = None

watcher/common/clients.py

@@ -0,0 +1,158 @@
+# 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 ceilometerclient import client as ceclient
+from cinderclient import client as ciclient
+from glanceclient import client as glclient
+from keystoneauth1 import loading as ka_loading
+from keystoneclient import client as keyclient
+from neutronclient.neutron import client as netclient
+from novaclient import client as nvclient
+from oslo_config import cfg
+
+from watcher._i18n import _
+from watcher.common import exception
+
+
+NOVA_CLIENT_OPTS = [
+    cfg.StrOpt('api_version',
+               default='2',
+               help=_('Version of Nova API to use in novaclient.'))]
+
+GLANCE_CLIENT_OPTS = [
+    cfg.StrOpt('api_version',
+               default='2',
+               help=_('Version of Glance API to use in glanceclient.'))]
+
+CINDER_CLIENT_OPTS = [
+    cfg.StrOpt('api_version',
+               default='2',
+               help=_('Version of Cinder API to use in cinderclient.'))]
+
+CEILOMETER_CLIENT_OPTS = [
+    cfg.StrOpt('api_version',
+               default='2',
+               help=_('Version of Ceilometer API to use in '
+                      'ceilometerclient.'))]
+
+NEUTRON_CLIENT_OPTS = [
+    cfg.StrOpt('api_version',
+               default='2.0',
+               help=_('Version of Neutron API to use in neutronclient.'))]
+
+cfg.CONF.register_opts(NOVA_CLIENT_OPTS, group='nova_client')
+cfg.CONF.register_opts(GLANCE_CLIENT_OPTS, group='glance_client')
+cfg.CONF.register_opts(CINDER_CLIENT_OPTS, group='cinder_client')
+cfg.CONF.register_opts(CEILOMETER_CLIENT_OPTS, group='ceilometer_client')
+cfg.CONF.register_opts(NEUTRON_CLIENT_OPTS, group='neutron_client')
+
+_CLIENTS_AUTH_GROUP = 'watcher_clients_auth'
+
+ka_loading.register_auth_conf_options(cfg.CONF, _CLIENTS_AUTH_GROUP)
+ka_loading.register_session_conf_options(cfg.CONF, _CLIENTS_AUTH_GROUP)
+
+
+class OpenStackClients(object):
+    """Convenience class to create and cache client instances."""
+
+    def __init__(self):
+        self.reset_clients()
+
+    def reset_clients(self):
+        self._session = None
+        self._keystone = None
+        self._nova = None
+        self._glance = None
+        self._cinder = None
+        self._ceilometer = None
+        self._neutron = None
+
+    def _get_keystone_session(self):
+        auth = ka_loading.load_auth_from_conf_options(cfg.CONF,
+                                                      _CLIENTS_AUTH_GROUP)
+        sess = ka_loading.load_session_from_conf_options(cfg.CONF,
+                                                         _CLIENTS_AUTH_GROUP,
+                                                         auth=auth)
+        return sess
+
+    @property
+    def auth_url(self):
+        return self.keystone().auth_url
+
+    @property
+    def session(self):
+        if not self._session:
+            self._session = self._get_keystone_session()
+        return self._session
+
+    def _get_client_option(self, client, option):
+        return getattr(getattr(cfg.CONF, '%s_client' % client), option)
+
+    @exception.wrap_keystone_exception
+    def keystone(self):
+        if not self._keystone:
+            self._keystone = keyclient.Client(session=self.session)
+
+        return self._keystone
+
+    @exception.wrap_keystone_exception
+    def nova(self):
+        if self._nova:
+            return self._nova
+
+        novaclient_version = self._get_client_option('nova', 'api_version')
+        self._nova = nvclient.Client(novaclient_version,
+                                     session=self.session)
+        return self._nova
+
+    @exception.wrap_keystone_exception
+    def glance(self):
+        if self._glance:
+            return self._glance
+
+        glanceclient_version = self._get_client_option('glance', 'api_version')
+        self._glance = glclient.Client(glanceclient_version,
+                                       session=self.session)
+        return self._glance
+
+    @exception.wrap_keystone_exception
+    def cinder(self):
+        if self._cinder:
+            return self._cinder
+
+        cinderclient_version = self._get_client_option('cinder', 'api_version')
+        self._cinder = ciclient.Client(cinderclient_version,
+                                       session=self.session)
+        return self._cinder
+
+    @exception.wrap_keystone_exception
+    def ceilometer(self):
+        if self._ceilometer:
+            return self._ceilometer
+
+        ceilometerclient_version = self._get_client_option('ceilometer',
+                                                           'api_version')
+        self._ceilometer = ceclient.get_client(ceilometerclient_version,
+                                               session=self.session)
+        return self._ceilometer
+
+    @exception.wrap_keystone_exception
+    def neutron(self):
+        if self._neutron:
+            return self._neutron
+
+        neutronclient_version = self._get_client_option('neutron',
+                                                        'api_version')
+        self._neutron = netclient.Client(neutronclient_version,
+                                         session=self.session)
+        self._neutron.format = 'json'
+        return self._neutron

watcher/common/config.py

@@ -22,6 +22,8 @@ from watcher import version
 
 
 def parse_args(argv, default_config_files=None):
+    default_config_files = (default_config_files or
+                            cfg.find_config_files(project='watcher'))
     rpc.set_defaults(control_exchange='watcher')
     cfg.CONF(argv[1:],
              project='python-watcher',

watcher/common/exception.py

@@ -22,6 +22,10 @@ SHOULD include dedicated exception logging.
 
 """
 
+import functools
+import sys
+
+from keystoneclient import exceptions as keystone_exceptions
 from oslo_config import cfg
 from oslo_log import log as logging
 import six
@@ -40,6 +44,23 @@ CONF = cfg.CONF
 CONF.register_opts(exc_log_opts)
 
 
+def wrap_keystone_exception(func):
+    """Wrap keystone exceptions and throw Watcher specific exceptions."""
+    @functools.wraps(func)
+    def wrapped(*args, **kw):
+        try:
+            return func(*args, **kw)
+        except keystone_exceptions.AuthorizationFailure:
+            raise AuthorizationFailure(
+                client=func.__name__, reason=sys.exc_info()[1])
+        except keystone_exceptions.ClientException:
+            raise AuthorizationFailure(
+                client=func.__name__,
+                reason=(_('Unexpected keystone client error occurred: %s')
+                        % sys.exc_info()[1]))
+    return wrapped
+
+
 class WatcherException(Exception):
     """Base Watcher Exception
 
@@ -133,12 +154,6 @@ class InvalidGoal(Invalid):
     msg_fmt = _("Goal %(goal)s is not defined in Watcher configuration file")
 
 
-# Cannot be templated as the error syntax varies.
-# msg needs to be constructed when raised.
-class InvalidParameterValue(Invalid):
-    msg_fmt = _("%(err)s")
-
-
 class InvalidUUID(Invalid):
     msg_fmt = _("Expected a uuid but received %(uuid)s")
 
@@ -179,7 +194,7 @@ class AuditReferenced(Invalid):
 
 
 class ActionPlanNotFound(ResourceNotFound):
-    msg_fmt = _("ActionPlan %(action plan)s could not be found")
+    msg_fmt = _("ActionPlan %(action_plan)s could not be found")
 
 
 class ActionPlanAlreadyExists(Conflict):
@@ -219,6 +234,9 @@ class PatchError(Invalid):
 
 # decision engine
 
+class WorkflowExecutionException(WatcherException):
+    msg_fmt = _('Workflow execution error: %(error)s')
+
 
 class IllegalArgumentException(WatcherException):
     msg_fmt = _('Illegal argument')
@@ -232,6 +250,10 @@ class NoDataFound(WatcherException):
     msg_fmt = _('No rows were returned')
 
 
+class AuthorizationFailure(WatcherException):
+    msg_fmt = _('%(client)s connection failed. Reason: %(reason)s')
+
+
 class KeystoneFailure(WatcherException):
     msg_fmt = _("'Keystone API endpoint is missing''")
 
@@ -260,3 +282,15 @@ class HypervisorNotFound(WatcherException):
 
 class LoadingError(WatcherException):
     msg_fmt = _("Error loading plugin '%(name)s'")
+
+
+class ReservedWord(WatcherException):
+    msg_fmt = _("The identifier '%(name)s' is a reserved word")
+
+
+class NotSoftDeletedStateError(WatcherException):
+    msg_fmt = _("The %(name)s resource %(id)s is not soft deleted")
+
+
+class NegativeLimitError(WatcherException):
+    msg_fmt = _("Limit should be positive")

watcher/common/keystone.py

@@ -1,131 +0,0 @@
-# -*- encoding: utf-8 -*-
-# Copyright (c) 2015 b<>com
-#
-# Authors: Jean-Emile DARTOIS <jean-emile.dartois@b-com.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 generic
-from keystoneclient import session as keystone_session
-from oslo_config import cfg
-from oslo_log import log
-from six.moves.urllib.parse import urljoin
-from six.moves.urllib.parse import urlparse
-
-from watcher._i18n import _
-from watcher.common import exception
-
-
-LOG = log.getLogger(__name__)
-CONF = cfg.CONF
-
-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')
-CONF.import_opt('auth_version', 'keystonemiddleware.auth_token',
-                group='keystone_authtoken')
-CONF.import_opt('insecure', 'keystonemiddleware.auth_token',
-                group='keystone_authtoken')
-
-
-class KeystoneClient(object):
-    def __init__(self):
-        self._ks_client = None
-        self._session = None
-        self._auth = None
-        self._token = None
-
-    def get_endpoint(self, **kwargs):
-        kc = self.get_ksclient()
-        if not kc.has_service_catalog():
-            raise exception.KeystoneFailure(
-                _('No Keystone service catalog loaded')
-            )
-        attr = None
-        filter_value = None
-        if kwargs.get('region_name'):
-            attr = 'region'
-            filter_value = kwargs.get('region_name')
-        return kc.service_catalog.url_for(
-            service_type=kwargs.get('service_type') or 'metering',
-            attr=attr,
-            filter_value=filter_value,
-            endpoint_type=kwargs.get('endpoint_type') or 'publicURL')
-
-    def _is_apiv3(self, auth_url, auth_version):
-        return auth_version == 'v3.0' or '/v3' in urlparse(auth_url).path
-
-    def get_keystone_url(self, auth_url, auth_version):
-        """Gives an http/https url to contact keystone."""
-
-        api_v3 = self._is_apiv3(auth_url, auth_version)
-        api_version = 'v3' if api_v3 else 'v2.0'
-        # NOTE(lucasagomes): Get rid of the trailing '/' otherwise urljoin()
-        #   fails to override the version in the URL
-        return urljoin(auth_url.rstrip('/'), api_version)
-
-    def get_ksclient(self, creds=None):
-        """Get an endpoint and auth token from Keystone."""
-        auth_version = CONF.keystone_authtoken.auth_version
-        auth_url = CONF.keystone_authtoken.auth_uri
-        api_v3 = self._is_apiv3(auth_url, auth_version)
-        if creds is None:
-            ks_args = self._get_credentials(api_v3)
-        else:
-            ks_args = creds
-
-        if api_v3:
-            from keystoneclient.v3 import client
-        else:
-            from keystoneclient.v2_0 import client
-        # generic
-        # ksclient = client.Client(version=api_version,
-        # session=session,**ks_args)
-
-        return client.Client(**ks_args)
-
-    def _get_credentials(self, api_v3):
-        if api_v3:
-            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"}
-        else:
-            creds = \
-                {'auth_url': CONF.keystone_authtoken.auth_uri,
-                 'username': CONF.keystone_authtoken.admin_user,
-                 'password': CONF.keystone_authtoken.admin_password,
-                 'tenant_name': CONF.keystone_authtoken.admin_tenant_name}
-        LOG.debug(creds)
-        return creds
-
-    def get_credentials(self):
-        api_v3 = self._is_apiv3(CONF.keystone_authtoken.auth_uri,
-                                CONF.keystone_authtoken.auth_version)
-        return self._get_credentials(api_v3)
-
-    def get_session(self):
-        creds = self.get_credentials()
-        self._auth = generic.Password(**creds)
-        session = keystone_session.Session(auth=self._auth)
-        return session

watcher/common/loader/default.py

@@ -31,7 +31,7 @@ class DefaultLoader(BaseLoader):
         super(DefaultLoader, self).__init__()
         self.namespace = namespace
 
-    def load(self, name):
+    def load(self, name, **kwargs):
         try:
             LOG.debug("Loading in namespace %s => %s ", self.namespace, name)
             driver_manager = DriverManager(namespace=self.namespace,
@@ -41,7 +41,7 @@ class DefaultLoader(BaseLoader):
             LOG.exception(exc)
             raise exception.LoadingError(name=name)
 
-        return loaded()
+        return loaded(**kwargs)
 
     def list_available(self):
         extension_manager = ExtensionManager(namespace=self.namespace)

watcher/common/messaging/events/event_dispatcher.py

@@ -16,7 +16,7 @@
 
 from oslo_log import log
 
-from watcher.decision_engine.messaging.events import Events
+from watcher.decision_engine.messaging import events as messaging_events
 
 LOG = log.getLogger(__name__)
 
@@ -43,8 +43,8 @@ class EventDispatcher(object):
         """
         Dispatch an instance of Event class
         """
-        if Events.ALL in self._events.keys():
-            listeners = self._events[Events.ALL]
+        if messaging_events.Events.ALL in self._events.keys():
+            listeners = self._events[messaging_events.Events.ALL]
             for listener in listeners:
                 listener(event)
 

watcher/common/messaging/messaging_core.py

@@ -16,58 +16,100 @@
 
 from oslo_config import cfg
 from oslo_log import log
-from watcher.common.messaging.events.event_dispatcher import \
-    EventDispatcher
-from watcher.common.messaging.messaging_handler import \
-    MessagingHandler
-from watcher.common.rpc import RequestContextSerializer
+import oslo_messaging as om
 
-from watcher.objects.base import WatcherObjectSerializer
+from watcher.common.messaging.events import event_dispatcher as dispatcher
+from watcher.common.messaging import messaging_handler
+from watcher.common import rpc
+
+from watcher.objects import base
 
 LOG = log.getLogger(__name__)
 CONF = cfg.CONF
 
 
-class MessagingCore(EventDispatcher):
+class MessagingCore(dispatcher.EventDispatcher):
 
     API_VERSION = '1.0'
 
-    def __init__(self, publisher_id, topic_control, topic_status,
+    def __init__(self, publisher_id, conductor_topic, status_topic,
                  api_version=API_VERSION):
         super(MessagingCore, self).__init__()
-        self.serializer = RequestContextSerializer(WatcherObjectSerializer())
+        self.serializer = rpc.RequestContextSerializer(
+            base.WatcherObjectSerializer())
         self.publisher_id = publisher_id
         self.api_version = api_version
-        self.topic_control = self.build_topic(topic_control)
-        self.topic_status = self.build_topic(topic_status)
 
-    def build_topic(self, topic_name):
-        return MessagingHandler(self.publisher_id, topic_name, self,
-                                self.api_version, self.serializer)
+        self.conductor_topic = conductor_topic
+        self.status_topic = status_topic
+        self.conductor_topic_handler = self.build_topic_handler(
+            conductor_topic)
+        self.status_topic_handler = self.build_topic_handler(status_topic)
+
+        self._conductor_client = None
+        self._status_client = None
+
+    @property
+    def conductor_client(self):
+        if self._conductor_client is None:
+            transport = om.get_transport(CONF)
+            target = om.Target(
+                topic=self.conductor_topic,
+                version=self.API_VERSION,
+            )
+            self._conductor_client = om.RPCClient(
+                transport, target, serializer=self.serializer)
+        return self._conductor_client
+
+    @conductor_client.setter
+    def conductor_client(self, c):
+        self.conductor_client = c
+
+    @property
+    def status_client(self):
+        if self._status_client is None:
+            transport = om.get_transport(CONF)
+            target = om.Target(
+                topic=self.status_topic,
+                version=self.API_VERSION,
+            )
+            self._status_client = om.RPCClient(
+                transport, target, serializer=self.serializer)
+        return self._status_client
+
+    @status_client.setter
+    def status_client(self, c):
+        self.status_client = c
+
+    def build_topic_handler(self, topic_name):
+        return messaging_handler.MessagingHandler(
+            self.publisher_id, topic_name, self,
+            self.api_version, self.serializer)
 
     def connect(self):
         LOG.debug("Connecting to '%s' (%s)",
                   CONF.transport_url, CONF.rpc_backend)
-        self.topic_control.start()
-        self.topic_status.start()
+        self.conductor_topic_handler.start()
+        self.status_topic_handler.start()
 
     def disconnect(self):
         LOG.debug("Disconnecting from '%s' (%s)",
                   CONF.transport_url, CONF.rpc_backend)
-        self.topic_control.stop()
-        self.topic_status.stop()
+        self.conductor_topic_handler.stop()
+        self.status_topic_handler.stop()
 
     def publish_control(self, event, payload):
-        return self.topic_control.publish_event(event, payload)
+        return self.conductor_topic_handler.publish_event(event, payload)
 
     def publish_status(self, event, payload, request_id=None):
-        return self.topic_status.publish_event(event, payload, request_id)
+        return self.status_topic_handler.publish_event(
+            event, payload, request_id)
 
     def get_version(self):
         return self.api_version
 
     def check_api_version(self, context):
-        api_manager_version = self.client.call(
+        api_manager_version = self.conductor_client.call(
             context.to_dict(), 'check_api_version',
             api_version=self.api_version)
         return api_manager_version

watcher/common/messaging/messaging_handler.py

@@ -38,11 +38,11 @@ CONF = cfg.CONF
 
 class MessagingHandler(threading.Thread):
 
-    def __init__(self, publisher_id, topic_watcher, endpoint, version,
+    def __init__(self, publisher_id, topic_name, endpoint, version,
                  serializer=None):
         super(MessagingHandler, self).__init__()
         self.publisher_id = publisher_id
-        self.topic_watcher = topic_watcher
+        self.topic_name = topic_name
         self.__endpoints = []
         self.__serializer = serializer
         self.__version = version
@@ -72,7 +72,7 @@ class MessagingHandler(threading.Thread):
         return om.Notifier(
             self.__transport,
             publisher_id=self.publisher_id,
-            topic=self.topic_watcher,
+            topic=self.topic_name,
             serializer=serializer
         )
 
@@ -87,7 +87,7 @@ class MessagingHandler(threading.Thread):
             self.__notifier = self.build_notifier()
             if len(self.__endpoints):
                 target = om.Target(
-                    topic=self.topic_watcher,
+                    topic=self.topic_name,
                     # For compatibility, we can override it with 'host' opt
                     server=CONF.host or socket.getfqdn(),
                     version=self.__version,
@@ -101,7 +101,7 @@ class MessagingHandler(threading.Thread):
             LOG.error(_LE("Messaging configuration error"))
 
     def run(self):
-        LOG.debug("configure MessagingHandler for %s" % self.topic_watcher)
+        LOG.debug("configure MessagingHandler for %s" % self.topic_name)
         self._configure()
         if len(self.__endpoints) > 0:
             LOG.debug("Starting up server")

watcher/common/messaging/notification_handler.py

@@ -18,17 +18,16 @@ import eventlet
 from oslo_log import log
 import oslo_messaging as messaging
 
-from watcher.common.messaging.utils.observable import \
-    Observable
+from watcher.common.messaging.utils import observable
 
 
 eventlet.monkey_patch()
 LOG = log.getLogger(__name__)
 
 
-class NotificationHandler(Observable):
+class NotificationHandler(observable.Observable):
     def __init__(self, publisher_id):
-        Observable.__init__(self)
+        super(NotificationHandler, self).__init__()
         self.publisher_id = publisher_id
 
     def info(self, ctx, publisher_id, event_type, payload, metadata):

watcher/common/messaging/utils/observable.py

@@ -14,19 +14,14 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from oslo_log import log
-
-from watcher.common.messaging.utils.synchronization import \
-    Synchronization
-
-LOG = log.getLogger(__name__)
+from watcher.common.messaging.utils import synchronization
 
 
-class Observable(Synchronization):
+class Observable(synchronization.Synchronization):
     def __init__(self):
+        super(Observable, self).__init__()
         self.__observers = []
         self.changed = 0
-        Synchronization.__init__(self)
 
     def set_changed(self):
         self.changed = 1

watcher/common/nova_helper.py

@@ -23,29 +23,22 @@ import time
 from oslo_log import log
 
 import cinderclient.exceptions as ciexceptions
-import cinderclient.v2.client as ciclient
-import glanceclient.v2.client as glclient
-import neutronclient.neutron.client as netclient
-import novaclient.client as nvclient
 import novaclient.exceptions as nvexceptions
 
-from watcher.common import keystone
+from watcher.common import clients
 
 LOG = log.getLogger(__name__)
 
 
-class NovaClient(object):
-    NOVA_CLIENT_API_VERSION = "2"
+class NovaHelper(object):
 
-    def __init__(self, creds, session):
-        self.user = creds['username']
-        self.session = session
-        self.neutron = None
-        self.cinder = None
-        self.nova = nvclient.Client(self.NOVA_CLIENT_API_VERSION,
-                                    session=session)
-        self.keystone = keystone.KeystoneClient().get_ksclient(creds)
-        self.glance = None
+    def __init__(self, osc=None):
+        """:param osc: an OpenStackClients instance"""
+        self.osc = osc if osc else clients.OpenStackClients()
+        self.neutron = self.osc.neutron()
+        self.cinder = self.osc.cinder()
+        self.nova = self.osc.nova()
+        self.glance = self.osc.glance()
 
     def get_hypervisors_list(self):
         return self.nova.hypervisors.list()
@@ -180,9 +173,6 @@ class NovaClient(object):
                 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")
@@ -275,58 +265,6 @@ class NovaClient(object):
 
             return True
 
-    def built_in_non_live_migrate_instance(self, instance_id, hypervisor_id):
-        """This method does a live migration of a given instance
-
-        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=False, retry=120):
         """This method does a live migration of a given instance
@@ -446,13 +384,6 @@ class NovaClient(object):
         :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)
 
@@ -676,10 +607,6 @@ class NovaClient(object):
 
     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)

watcher/common/service.py

@@ -102,7 +102,7 @@ class RPCService(service.Service):
                      '%(host)s.'),
                  {'service': self.topic, 'host': self.host})
 
-    def _handle_signal(self, signo, frame):
+    def _handle_signal(self):
         LOG.info(_LI('Got signal SIGUSR1. Not deregistering on next shutdown '
                      'of service %(service)s on host %(host)s.'),
                  {'service': self.topic, 'host': self.host})

watcher/db/api.py

@@ -71,7 +71,7 @@ class BaseConnection(object):
                          'name': 'example',
                          'description': 'free text description'
                          'host_aggregate': 'nova aggregate name or id'
-                         'goal': 'SERVER_CONSOLiDATION'
+                         'goal': 'DUMMY'
                          'extra': {'automatic': True}
                         }
         :returns: An audit template.
@@ -98,7 +98,7 @@ class BaseConnection(object):
         :raises: AuditTemplateNotFound
         """
 
-    def get_audit_template_by__name(self, context, audit_template_name):
+    def get_audit_template_by_name(self, context, audit_template_name):
         """Return an audit template.
 
         :param context: The security context
@@ -122,7 +122,7 @@ class BaseConnection(object):
         :param audit_template_id: The id or uuid of an audit template.
         :returns: An audit template.
         :raises: AuditTemplateNotFound
-        :raises: InvalidParameterValue
+        :raises: Invalid
         """
 
     @abc.abstractmethod
@@ -209,7 +209,7 @@ class BaseConnection(object):
         :param audit_id: The id or uuid of an audit.
         :returns: An audit.
         :raises: AuditNotFound
-        :raises: InvalidParameterValue
+        :raises: Invalid
         """
 
     def soft_delete_audit(self, audit_id):
@@ -299,6 +299,7 @@ class BaseConnection(object):
         :returns: A action.
         :raises: ActionNotFound
         :raises: ActionReferenced
+        :raises: Invalid
         """
 
     @abc.abstractmethod
@@ -371,4 +372,5 @@ class BaseConnection(object):
         :returns: An action plan.
         :raises: ActionPlanNotFound
         :raises: ActionPlanReferenced
+        :raises: Invalid
         """

watcher/db/purge.py

@@ -0,0 +1,410 @@
+# -*- encoding: utf-8 -*-
+# Copyright (c) 2016 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 __future__ import print_function
+
+import collections
+import datetime
+import itertools
+import sys
+
+from oslo_log import log
+from oslo_utils import strutils
+import prettytable as ptable
+from six.moves import input
+
+from watcher._i18n import _, _LI
+from watcher.common import context
+from watcher.common import exception
+from watcher.common import utils
+from watcher import objects
+
+LOG = log.getLogger(__name__)
+
+
+class WatcherObjectsMap(object):
+    """Wrapper to deal with watcher objects per type
+
+    This wrapper object contains a list of watcher objects per type.
+    Its main use is to simplify the merge of watcher objects by avoiding
+    duplicates, but also for representing the relationships between these
+    objects.
+    """
+
+    # This is for generating the .pot translations
+    keymap = collections.OrderedDict([
+        ("audit_templates", _("Audit Templates")),
+        ("audits", _("Audits")),
+        ("action_plans", _("Action Plans")),
+        ("actions", _("Actions")),
+    ])
+
+    def __init__(self):
+        for attr_name in self.__class__.keys():
+            setattr(self, attr_name, [])
+
+    def values(self):
+        return (getattr(self, key) for key in self.__class__.keys())
+
+    @classmethod
+    def keys(cls):
+        return cls.keymap.keys()
+
+    def __iter__(self):
+        return itertools.chain(*self.values())
+
+    def __add__(self, other):
+        new_map = self.__class__()
+
+        # Merge the 2 items dicts into a new object (and avoid dupes)
+        for attr_name, initials, others in zip(self.keys(), self.values(),
+                                               other.values()):
+            # Creates a copy
+            merged = initials[:]
+            initials_ids = [item.id for item in initials]
+            non_dupes = [item for item in others
+                         if item.id not in initials_ids]
+            merged += non_dupes
+
+            setattr(new_map, attr_name, merged)
+
+        return new_map
+
+    def __str__(self):
+        out = ""
+        for key, vals in zip(self.keys(), self.values()):
+            ids = [val.id for val in vals]
+            out += "%(key)s: %(val)s" % (dict(key=key, val=ids))
+            out += "\n"
+        return out
+
+    def __len__(self):
+        return sum(len(getattr(self, key)) for key in self.keys())
+
+    def get_count_table(self):
+        headers = list(self.keymap.values())
+        headers.append(_("Total"))  # We also add a total count
+        counters = [len(cat_vals) for cat_vals in self.values()] + [len(self)]
+        table = ptable.PrettyTable(field_names=headers)
+        table.add_row(counters)
+        return table.get_string()
+
+
+class PurgeCommand(object):
+    """Purges the DB by removing soft deleted entries
+
+    The workflow for this purge is the following:
+
+    # Find soft deleted objects which are expired
+    # Find orphan objects
+    # Find their related objects whether they are expired or not
+    # Merge them together
+    # If it does not exceed the limit, destroy them all
+    """
+
+    ctx = context.make_context(show_deleted=True)
+
+    def __init__(self, age_in_days=None, max_number=None,
+                 uuid=None, exclude_orphans=False, dry_run=None):
+        self.age_in_days = age_in_days
+        self.max_number = max_number
+        self.uuid = uuid
+        self.exclude_orphans = exclude_orphans
+        self.dry_run = dry_run
+
+        self._delete_up_to_max = None
+        self._objects_map = WatcherObjectsMap()
+
+    def get_expiry_date(self):
+        if not self.age_in_days:
+            return None
+        today = datetime.datetime.today()
+        expiry_date = today - datetime.timedelta(days=self.age_in_days)
+        return expiry_date
+
+    @classmethod
+    def get_audit_template_uuid(cls, uuid_or_name):
+        if uuid_or_name is None:
+            return
+
+        query_func = None
+        if not utils.is_uuid_like(uuid_or_name):
+            query_func = objects.audit_template.AuditTemplate.get_by_name
+        else:
+            query_func = objects.audit_template.AuditTemplate.get_by_uuid
+
+        try:
+            audit_template = query_func(cls.ctx, uuid_or_name)
+        except Exception as exc:
+            LOG.exception(exc)
+            raise exception.AuditTemplateNotFound(audit_template=uuid_or_name)
+
+        if not audit_template.deleted_at:
+            raise exception.NotSoftDeletedStateError(
+                name=_('Audit Template'), id=uuid_or_name)
+
+        return audit_template.uuid
+
+    def _find_audit_templates(self, filters=None):
+        return objects.audit_template.AuditTemplate.list(
+            self.ctx, filters=filters)
+
+    def _find_audits(self, filters=None):
+        return objects.audit.Audit.list(self.ctx, filters=filters)
+
+    def _find_action_plans(self, filters=None):
+        return objects.action_plan.ActionPlan.list(self.ctx, filters=filters)
+
+    def _find_actions(self, filters=None):
+        return objects.action.Action.list(self.ctx, filters=filters)
+
+    def _find_orphans(self):
+        orphans = WatcherObjectsMap()
+
+        filters = dict(deleted=False)
+        audit_templates = objects.audit_template.AuditTemplate.list(
+            self.ctx, filters=filters)
+        audits = objects.audit.Audit.list(self.ctx, filters=filters)
+        action_plans = objects.action_plan.ActionPlan.list(
+            self.ctx, filters=filters)
+        actions = objects.action.Action.list(self.ctx, filters=filters)
+
+        audit_template_ids = set(at.id for at in audit_templates)
+        orphans.audits = [
+            audit for audit in audits
+            if audit.audit_template_id not in audit_template_ids]
+
+        # Objects with orphan parents are themselves orphans
+        audit_ids = [audit.id for audit in (a for a in audits
+                                            if a not in orphans.audits)]
+        orphans.action_plans = [
+            ap for ap in action_plans
+            if ap.audit_id not in audit_ids]
+
+        # Objects with orphan parents are themselves orphans
+        action_plan_ids = [ap.id for ap in (a for a in action_plans
+                                            if a not in orphans.action_plans)]
+        orphans.actions = [
+            action for action in actions
+            if action.action_plan_id not in action_plan_ids]
+
+        LOG.debug("Orphans found:\n%s", orphans)
+        LOG.info(_LI("Orphans found:\n%s"), orphans.get_count_table())
+
+        return orphans
+
+    def _find_soft_deleted_objects(self):
+        to_be_deleted = WatcherObjectsMap()
+
+        expiry_date = self.get_expiry_date()
+        filters = dict(deleted=True)
+        if self.uuid:
+            filters["uuid"] = self.uuid
+        if expiry_date:
+            filters.update(dict(deleted_at__lt=expiry_date))
+
+        to_be_deleted.audit_templates.extend(
+            self._find_audit_templates(filters))
+        to_be_deleted.audits.extend(self._find_audits(filters))
+        to_be_deleted.action_plans.extend(self._find_action_plans(filters))
+        to_be_deleted.actions.extend(self._find_actions(filters))
+
+        soft_deleted_objs = self._find_related_objects(
+            to_be_deleted, base_filters=dict(deleted=True))
+
+        LOG.debug("Soft deleted objects:\n%s", soft_deleted_objs)
+
+        return soft_deleted_objs
+
+    def _find_related_objects(self, objects_map, base_filters=None):
+        base_filters = base_filters or {}
+
+        for audit_template in objects_map.audit_templates:
+            filters = {}
+            filters.update(base_filters)
+            filters.update(dict(audit_template_id=audit_template.id))
+            related_objs = WatcherObjectsMap()
+            related_objs.audits = self._find_audits(filters)
+            objects_map += related_objs
+
+        for audit in objects_map.audits:
+            filters = {}
+            filters.update(base_filters)
+            filters.update(dict(audit_id=audit.id))
+            related_objs = WatcherObjectsMap()
+            related_objs.action_plans = self._find_action_plans(filters)
+            objects_map += related_objs
+
+        for action_plan in objects_map.action_plans:
+            filters = {}
+            filters.update(base_filters)
+            filters.update(dict(action_plan_id=action_plan.id))
+            related_objs = WatcherObjectsMap()
+            related_objs.actions = self._find_actions(filters)
+            objects_map += related_objs
+
+        return objects_map
+
+    def confirmation_prompt(self):
+        print(self._objects_map.get_count_table())
+        raw_val = input(
+            _("There are %(count)d objects set for deletion. "
+              "Continue? [y/N]") % dict(count=len(self._objects_map)))
+
+        return strutils.bool_from_string(raw_val)
+
+    def delete_up_to_max_prompt(self, objects_map):
+        print(objects_map.get_count_table())
+        print(_("The number of objects (%(num)s) to delete from the database "
+                "exceeds the maximum number of objects (%(max_number)s) "
+                "specified.") % dict(max_number=self.max_number,
+                                     num=len(objects_map)))
+        raw_val = input(
+            _("Do you want to delete objects up to the specified maximum "
+              "number? [y/N]"))
+
+        self._delete_up_to_max = strutils.bool_from_string(raw_val)
+
+        return self._delete_up_to_max
+
+    def _aggregate_objects(self):
+        """Objects aggregated on a 'per audit template' basis"""
+        # todo: aggregate orphans as well
+        aggregate = []
+        for audit_template in self._objects_map.audit_templates:
+            related_objs = WatcherObjectsMap()
+            related_objs.audit_templates = [audit_template]
+            related_objs.audits = [
+                audit for audit in self._objects_map.audits
+                if audit.audit_template_id == audit_template.id
+            ]
+            audit_ids = [audit.id for audit in related_objs.audits]
+            related_objs.action_plans = [
+                action_plan for action_plan in self._objects_map.action_plans
+                if action_plan.audit_id in audit_ids
+            ]
+            action_plan_ids = [
+                action_plan.id for action_plan in related_objs.action_plans
+            ]
+            related_objs.actions = [
+                action for action in self._objects_map.actions
+                if action.action_plan_id in action_plan_ids
+            ]
+            aggregate.append(related_objs)
+
+        return aggregate
+
+    def _get_objects_up_to_limit(self):
+        aggregated_objects = self._aggregate_objects()
+        to_be_deleted_subset = WatcherObjectsMap()
+
+        for aggregate in aggregated_objects:
+            if len(aggregate) + len(to_be_deleted_subset) <= self.max_number:
+                to_be_deleted_subset += aggregate
+            else:
+                break
+
+        LOG.debug(to_be_deleted_subset)
+        return to_be_deleted_subset
+
+    def find_objects_to_delete(self):
+        """Finds all the objects to be purged
+
+        :returns: A mapping with all the Watcher objects to purged
+        :rtype: :py:class:`~.WatcherObjectsMap` instance
+        """
+        to_be_deleted = self._find_soft_deleted_objects()
+
+        if not self.exclude_orphans:
+            to_be_deleted += self._find_orphans()
+
+        LOG.debug("Objects to be deleted:\n%s", to_be_deleted)
+
+        return to_be_deleted
+
+    def do_delete(self):
+        LOG.info(_LI("Deleting..."))
+        # Reversed to avoid errors with foreign keys
+        for entry in reversed(list(self._objects_map)):
+            entry.destroy()
+
+    def execute(self):
+        LOG.info(_LI("Starting purge command"))
+        self._objects_map = self.find_objects_to_delete()
+
+        if (self.max_number is not None and
+                len(self._objects_map) > self.max_number):
+            if self.delete_up_to_max_prompt(self._objects_map):
+                self._objects_map = self._get_objects_up_to_limit()
+            else:
+                return
+
+        _orphans_note = (_(" (orphans excluded)") if self.exclude_orphans
+                         else _(" (may include orphans)"))
+        if not self.dry_run and self.confirmation_prompt():
+            self.do_delete()
+            print(_("Purge results summary%s:") % _orphans_note)
+            LOG.info(_LI("Purge results summary%s:"), _orphans_note)
+        else:
+            LOG.debug(self._objects_map)
+            print(_("Here below is a table containing the objects "
+                    "that can be purged%s:") % _orphans_note)
+
+        LOG.info("\n%s", self._objects_map.get_count_table())
+        print(self._objects_map.get_count_table())
+        LOG.info(_LI("Purge process completed"))
+
+
+def purge(age_in_days, max_number, audit_template, exclude_orphans, dry_run):
+    """Removes soft deleted objects from the database
+
+    :param age_in_days: Number of days since deletion (from today)
+        to exclude from the purge. If None, everything will be purged.
+    :type age_in_days: int
+    :param max_number: Max number of objects expected to be deleted.
+                  Prevents the deletion if exceeded. No limit if set to None.
+    :type max_number: int
+    :param audit_template: UUID or name of the audit template to purge.
+    :type audit_template: str
+    :param exclude_orphans: Flag to indicate whether or not you want to
+                            exclude orphans from deletion (default: False).
+    :type exclude_orphans: bool
+    :param dry_run: Flag to indicate whether or not you want to perform
+                    a dry run (no deletion).
+    :type dry_run: bool
+    """
+    try:
+        if max_number and max_number < 0:
+            raise exception.NegativeLimitError
+
+        LOG.info("[options] age_in_days = %s", age_in_days)
+        LOG.info("[options] max_number = %s", max_number)
+        LOG.info("[options] audit_template = %s", audit_template)
+        LOG.info("[options] exclude_orphans = %s", exclude_orphans)
+        LOG.info("[options] dry_run = %s", dry_run)
+
+        uuid = PurgeCommand.get_audit_template_uuid(audit_template)
+
+        cmd = PurgeCommand(age_in_days, max_number, uuid,
+                           exclude_orphans, dry_run)
+
+        cmd.execute()
+
+    except Exception as exc:
+        LOG.exception(exc)
+        print(exc)
+        sys.exit(1)

watcher/db/sqlalchemy/api.py

@@ -29,7 +29,10 @@ from watcher.common import exception
 from watcher.common import utils
 from watcher.db import api
 from watcher.db.sqlalchemy import models
+from watcher.objects import action as action_objects
+from watcher.objects import action_plan as ap_objects
 from watcher.objects import audit as audit_objects
+from watcher.objects import utils as objutils
 
 CONF = cfg.CONF
 LOG = log.getLogger(__name__)
@@ -105,12 +108,88 @@ class Connection(api.BaseConnection):
     """SqlAlchemy connection."""
 
     def __init__(self):
-        pass
+        super(Connection, self).__init__()
+
+    def __add_soft_delete_mixin_filters(self, query, filters, model):
+        if 'deleted' in filters:
+            if bool(filters['deleted']):
+                query = query.filter(model.deleted != 0)
+            else:
+                query = query.filter(model.deleted == 0)
+        if 'deleted_at__eq' in filters:
+            query = query.filter(
+                model.deleted_at == objutils.datetime_or_str_or_none(
+                    filters['deleted_at__eq']))
+        if 'deleted_at__gt' in filters:
+            query = query.filter(
+                model.deleted_at > objutils.datetime_or_str_or_none(
+                    filters['deleted_at__gt']))
+        if 'deleted_at__gte' in filters:
+            query = query.filter(
+                model.deleted_at >= objutils.datetime_or_str_or_none(
+                    filters['deleted_at__gte']))
+        if 'deleted_at__lt' in filters:
+            query = query.filter(
+                model.deleted_at < objutils.datetime_or_str_or_none(
+                    filters['deleted_at__lt']))
+        if 'deleted_at__lte' in filters:
+            query = query.filter(
+                model.deleted_at <= objutils.datetime_or_str_or_none(
+                    filters['deleted_at__lte']))
+
+        return query
+
+    def __add_timestamp_mixin_filters(self, query, filters, model):
+        if 'created_at__eq' in filters:
+            query = query.filter(
+                model.created_at == objutils.datetime_or_str_or_none(
+                    filters['created_at__eq']))
+        if 'created_at__gt' in filters:
+            query = query.filter(
+                model.created_at > objutils.datetime_or_str_or_none(
+                    filters['created_at__gt']))
+        if 'created_at__gte' in filters:
+            query = query.filter(
+                model.created_at >= objutils.datetime_or_str_or_none(
+                    filters['created_at__gte']))
+        if 'created_at__lt' in filters:
+            query = query.filter(
+                model.created_at < objutils.datetime_or_str_or_none(
+                    filters['created_at__lt']))
+        if 'created_at__lte' in filters:
+            query = query.filter(
+                model.created_at <= objutils.datetime_or_str_or_none(
+                    filters['created_at__lte']))
+
+        if 'updated_at__eq' in filters:
+            query = query.filter(
+                model.updated_at == objutils.datetime_or_str_or_none(
+                    filters['updated_at__eq']))
+        if 'updated_at__gt' in filters:
+            query = query.filter(
+                model.updated_at > objutils.datetime_or_str_or_none(
+                    filters['updated_at__gt']))
+        if 'updated_at__gte' in filters:
+            query = query.filter(
+                model.updated_at >= objutils.datetime_or_str_or_none(
+                    filters['updated_at__gte']))
+        if 'updated_at__lt' in filters:
+            query = query.filter(
+                model.updated_at < objutils.datetime_or_str_or_none(
+                    filters['updated_at__lt']))
+        if 'updated_at__lte' in filters:
+            query = query.filter(
+                model.updated_at <= objutils.datetime_or_str_or_none(
+                    filters['updated_at__lte']))
+
+        return query
 
     def _add_audit_templates_filters(self, query, filters):
         if filters is None:
             filters = []
 
+        if 'uuid' in filters:
+            query = query.filter_by(uuid=filters['uuid'])
         if 'name' in filters:
             query = query.filter_by(name=filters['name'])
         if 'host_aggregate' in filters:
@@ -118,12 +197,19 @@ class Connection(api.BaseConnection):
         if 'goal' in filters:
             query = query.filter_by(goal=filters['goal'])
 
+        query = self.__add_soft_delete_mixin_filters(
+            query, filters, models.AuditTemplate)
+        query = self.__add_timestamp_mixin_filters(
+            query, filters, models.AuditTemplate)
+
         return query
 
     def _add_audits_filters(self, query, filters):
         if filters is None:
             filters = []
 
+        if 'uuid' in filters:
+            query = query.filter_by(uuid=filters['uuid'])
         if 'type' in filters:
             query = query.filter_by(type=filters['type'])
         if 'state' in filters:
@@ -144,12 +230,20 @@ class Connection(api.BaseConnection):
             query = query.filter(
                 models.AuditTemplate.name ==
                 filters['audit_template_name'])
+
+        query = self.__add_soft_delete_mixin_filters(
+            query, filters, models.Audit)
+        query = self.__add_timestamp_mixin_filters(
+            query, filters, models.Audit)
+
         return query
 
     def _add_action_plans_filters(self, query, filters):
         if filters is None:
             filters = []
 
+        if 'uuid' in filters:
+            query = query.filter_by(uuid=filters['uuid'])
         if 'state' in filters:
             query = query.filter_by(state=filters['state'])
         if 'audit_id' in filters:
@@ -158,12 +252,20 @@ class Connection(api.BaseConnection):
             query = query.join(models.Audit,
                                models.ActionPlan.audit_id == models.Audit.id)
             query = query.filter(models.Audit.uuid == filters['audit_uuid'])
+
+        query = self.__add_soft_delete_mixin_filters(
+            query, filters, models.ActionPlan)
+        query = self.__add_timestamp_mixin_filters(
+            query, filters, models.ActionPlan)
+
         return query
 
     def _add_actions_filters(self, query, filters):
         if filters is None:
             filters = []
 
+        if 'uuid' in filters:
+            query = query.filter_by(uuid=filters['uuid'])
         if 'action_plan_id' in filters:
             query = query.filter_by(action_plan_id=filters['action_plan_id'])
         if 'action_plan_uuid' in filters:
@@ -184,6 +286,11 @@ class Connection(api.BaseConnection):
         if 'alarm' in filters:
             query = query.filter_by(alarm=filters['alarm'])
 
+        query = self.__add_soft_delete_mixin_filters(
+            query, filters, models.Action)
+        query = self.__add_timestamp_mixin_filters(
+            query, filters, models.Action)
+
         return query
 
     def get_audit_template_list(self, context, filters=None, limit=None,
@@ -193,7 +300,6 @@ class Connection(api.BaseConnection):
         query = self._add_audit_templates_filters(query, filters)
         if not context.show_deleted:
             query = query.filter_by(deleted_at=None)
-
         return _paginate_query(models.AuditTemplate, limit, marker,
                                sort_key, sort_dir, query)
 
@@ -274,8 +380,9 @@ class Connection(api.BaseConnection):
 
     def update_audit_template(self, audit_template_id, values):
         if 'uuid' in values:
-            msg = _("Cannot overwrite UUID for an existing AuditTemplate.")
-            raise exception.InvalidParameterValue(err=msg)
+            raise exception.Invalid(
+                message=_("Cannot overwrite UUID for an existing "
+                          "Audit Template."))
 
         return self._do_update_audit_template(audit_template_id, values)
 
@@ -311,7 +418,8 @@ class Connection(api.BaseConnection):
         query = model_query(models.Audit)
         query = self._add_audits_filters(query, filters)
         if not context.show_deleted:
-            query = query.filter(~(models.Audit.state == 'DELETED'))
+            query = query.filter(
+                ~(models.Audit.state == audit_objects.State.DELETED))
 
         return _paginate_query(models.Audit, limit, marker,
                                sort_key, sort_dir, query)
@@ -339,7 +447,7 @@ class Connection(api.BaseConnection):
         try:
             audit = query.one()
             if not context.show_deleted:
-                if audit.state == 'DELETED':
+                if audit.state == audit_objects.State.DELETED:
                     raise exception.AuditNotFound(audit=audit_id)
             return audit
         except exc.NoResultFound:
@@ -352,7 +460,7 @@ class Connection(api.BaseConnection):
         try:
             audit = query.one()
             if not context.show_deleted:
-                if audit.state == 'DELETED':
+                if audit.state == audit_objects.State.DELETED:
                     raise exception.AuditNotFound(audit=audit_uuid)
             return audit
         except exc.NoResultFound:
@@ -383,8 +491,9 @@ class Connection(api.BaseConnection):
 
     def update_audit(self, audit_id, values):
         if 'uuid' in values:
-            msg = _("Cannot overwrite UUID for an existing Audit.")
-            raise exception.InvalidParameterValue(err=msg)
+            raise exception.Invalid(
+                message=_("Cannot overwrite UUID for an existing "
+                          "Audit."))
 
         return self._do_update_audit(audit_id, values)
 
@@ -419,7 +528,8 @@ class Connection(api.BaseConnection):
         query = model_query(models.Action)
         query = self._add_actions_filters(query, filters)
         if not context.show_deleted:
-            query = query.filter(~(models.Action.state == 'DELETED'))
+            query = query.filter(
+                ~(models.Action.state == action_objects.State.DELETED))
         return _paginate_query(models.Action, limit, marker,
                                sort_key, sort_dir, query)
 
@@ -442,7 +552,7 @@ class Connection(api.BaseConnection):
         try:
             action = query.one()
             if not context.show_deleted:
-                if action.state == 'DELETED':
+                if action.state == action_objects.State.DELETED:
                     raise exception.ActionNotFound(
                         action=action_id)
             return action
@@ -455,7 +565,7 @@ class Connection(api.BaseConnection):
         try:
             action = query.one()
             if not context.show_deleted:
-                if action.state == 'DELETED':
+                if action.state == action_objects.State.DELETED:
                     raise exception.ActionNotFound(
                         action=action_uuid)
             return action
@@ -474,8 +584,9 @@ class Connection(api.BaseConnection):
     def update_action(self, action_id, values):
         # NOTE(dtantsur): this can lead to very strange errors
         if 'uuid' in values:
-            msg = _("Cannot overwrite UUID for an existing Action.")
-            raise exception.InvalidParameterValue(err=msg)
+            raise exception.Invalid(
+                message=_("Cannot overwrite UUID for an existing "
+                          "Action."))
 
         return self._do_update_action(action_id, values)
 
@@ -511,7 +622,8 @@ class Connection(api.BaseConnection):
         query = model_query(models.ActionPlan)
         query = self._add_action_plans_filters(query, filters)
         if not context.show_deleted:
-            query = query.filter(~(models.ActionPlan.state == 'DELETED'))
+            query = query.filter(
+                ~(models.ActionPlan.state == ap_objects.State.DELETED))
 
         return _paginate_query(models.ActionPlan, limit, marker,
                                sort_key, sort_dir, query)
@@ -536,7 +648,7 @@ class Connection(api.BaseConnection):
         try:
             action_plan = query.one()
             if not context.show_deleted:
-                if action_plan.state == 'DELETED':
+                if action_plan.state == ap_objects.State.DELETED:
                     raise exception.ActionPlanNotFound(
                         action_plan=action_plan_id)
             return action_plan
@@ -550,7 +662,7 @@ class Connection(api.BaseConnection):
         try:
             action_plan = query.one()
             if not context.show_deleted:
-                if action_plan.state == 'DELETED':
+                if action_plan.state == ap_objects.State.DELETED:
                     raise exception.ActionPlanNotFound(
                         action_plan=action_plan__uuid)
             return action_plan
@@ -583,8 +695,9 @@ class Connection(api.BaseConnection):
 
     def update_action_plan(self, action_plan_id, values):
         if 'uuid' in values:
-            msg = _("Cannot overwrite UUID for an existing Audit.")
-            raise exception.InvalidParameterValue(err=msg)
+            raise exception.Invalid(
+                message=_("Cannot overwrite UUID for an existing "
+                          "Action Plan."))
 
         return self._do_update_action_plan(action_plan_id, values)
 

watcher/db/sqlalchemy/migration.py

@@ -32,7 +32,7 @@ def _alembic_config():
     return config
 
 
-def version(config=None, engine=None):
+def version(engine=None):
     """Current database version.
 
     :returns: Database version

watcher/db/sqlalchemy/models.py

@@ -160,7 +160,6 @@ class Action(Base):
                             nullable=False)
     # only for the first version
     action_type = Column(String(255), nullable=False)
-    applies_to = Column(String(255), nullable=True)
     input_parameters = Column(JSONEncodedDict, nullable=True)
     state = Column(String(20), nullable=True)
     # todo(jed) remove parameter alarm

watcher/decision_engine/audit/default.py

@@ -54,8 +54,8 @@ class DefaultAuditHandler(base.BaseAuditHandler):
         event.data = {}
         payload = {'audit_uuid': audit_uuid,
                    'audit_status': status}
-        self.messaging.topic_status.publish_event(event.type.name,
-                                                  payload)
+        self.messaging.status_topic_handler.publish_event(
+            event.type.name, payload)
 
     def update_audit_state(self, request_context, audit_uuid, state):
         LOG.debug("Update audit state: %s", state)

watcher/decision_engine/manager.py

@@ -40,20 +40,20 @@ See :doc:`../architecture` for more details on this component.
 from oslo_config import cfg
 from oslo_log import log
 
-from watcher.common.messaging.messaging_core import MessagingCore
-from watcher.decision_engine.messaging.audit_endpoint import AuditEndpoint
+from watcher.common.messaging import messaging_core
+from watcher.decision_engine.messaging import audit_endpoint
 
 
 LOG = log.getLogger(__name__)
 CONF = cfg.CONF
 
 WATCHER_DECISION_ENGINE_OPTS = [
-    cfg.StrOpt('topic_control',
+    cfg.StrOpt('conductor_topic',
                default='watcher.decision.control',
                help='The topic name used for'
                     'control events, this topic '
                     'used for rpc call '),
-    cfg.StrOpt('topic_status',
+    cfg.StrOpt('status_topic',
                default='watcher.decision.status',
                help='The topic name used for '
                     'status events, this topic '
@@ -78,18 +78,18 @@ CONF.register_group(decision_engine_opt_group)
 CONF.register_opts(WATCHER_DECISION_ENGINE_OPTS, decision_engine_opt_group)
 
 
-class DecisionEngineManager(MessagingCore):
+class DecisionEngineManager(messaging_core.MessagingCore):
     def __init__(self):
         super(DecisionEngineManager, self).__init__(
             CONF.watcher_decision_engine.publisher_id,
-            CONF.watcher_decision_engine.topic_control,
-            CONF.watcher_decision_engine.topic_status,
+            CONF.watcher_decision_engine.conductor_topic,
+            CONF.watcher_decision_engine.status_topic,
             api_version=self.API_VERSION)
-        endpoint = AuditEndpoint(self,
-                                 max_workers=CONF.watcher_decision_engine.
-                                 max_workers)
-        self.topic_control.add_endpoint(endpoint)
+        endpoint = audit_endpoint.AuditEndpoint(
+            self,
+            max_workers=CONF.watcher_decision_engine.max_workers)
+        self.conductor_topic_handler.add_endpoint(endpoint)
 
     def join(self):
-        self.topic_control.join()
-        self.topic_status.join()
+        self.conductor_topic_handler.join()
+        self.status_topic_handler.join()

watcher/decision_engine/messaging/audit_endpoint.py

@@ -16,11 +16,11 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 #
-from concurrent.futures import ThreadPoolExecutor
+from concurrent import futures
 
 from oslo_log import log
 
-from watcher.decision_engine.audit.default import DefaultAuditHandler
+from watcher.decision_engine.audit import default
 
 LOG = log.getLogger(__name__)
 
@@ -28,7 +28,7 @@ LOG = log.getLogger(__name__)
 class AuditEndpoint(object):
     def __init__(self, messaging, max_workers):
         self._messaging = messaging
-        self._executor = ThreadPoolExecutor(max_workers=max_workers)
+        self._executor = futures.ThreadPoolExecutor(max_workers=max_workers)
 
     @property
     def executor(self):
@@ -39,7 +39,7 @@ class AuditEndpoint(object):
         return self._messaging
 
     def do_trigger_audit(self, context, audit_uuid):
-        audit = DefaultAuditHandler(self.messaging)
+        audit = default.DefaultAuditHandler(self.messaging)
         audit.execute(audit_uuid, context)
 
     def trigger_audit(self, context, audit_uuid):

watcher/decision_engine/model/resource.py

@@ -21,6 +21,7 @@ class ResourceType(Enum):
     cpu_cores = 'num_cores'
     memory = 'memory'
     disk = 'disk'
+    disk_capacity = 'disk_capacity'
 
 
 class Resource(object):

watcher/decision_engine/planner/base.py

@@ -37,6 +37,10 @@ congestion which may decrease the :ref:`SLA <sla_definition>` for
 It is also important to schedule :ref:`Actions <action_definition>` in order to
 avoid security issues such as denial of service on core OpenStack services.
 
+:ref:`Some default implementations are provided <watcher_planners>`, but it is
+possible to :ref:`develop new implementations <implement_planner_plugin>`
+which are dynamically loaded by Watcher at launch time.
+
 See :doc:`../architecture` for more details on this component.
 """
 
@@ -50,11 +54,13 @@ class BasePlanner(object):
     def schedule(self, context, audit_uuid, solution):
         """The  planner receives a solution to schedule
 
-        :param solution: the solution given by the strategy to
+        :param solution: A solution provided by a strategy for scheduling
+        :type solution: :py:class:`~.BaseSolution` subclass instance
         :param audit_uuid: the audit uuid
-        :return: ActionPlan ordered sequence of change requests
-            such that all security, dependency, and performance
-            requirements are met.
+        :type audit_uuid: str
+        :return: Action plan with an ordered sequence of actions such that all
+                 security, dependency, and performance requirements are met.
+        :rtype: :py:class:`watcher.objects.action_plan.ActionPlan` instance
         """
         # example: directed acyclic graph
         raise NotImplementedError()

watcher/decision_engine/planner/default.py

@@ -28,6 +28,13 @@ LOG = log.getLogger(__name__)
 
 
 class DefaultPlanner(base.BasePlanner):
+    """Default planner implementation
+
+    This implementation comes with basic rules with a fixed set of action types
+    that are weighted. An action having a lower weight will be scheduled before
+    the other ones.
+    """
+
     priorities = {
         'nop': 0,
         'sleep': 1,
@@ -38,14 +45,12 @@ class DefaultPlanner(base.BasePlanner):
     def create_action(self,
                       action_plan_id,
                       action_type,
-                      applies_to,
                       input_parameters=None):
         uuid = utils.generate_uuid()
         action = {
             'uuid': uuid,
             'action_plan_id': int(action_plan_id),
             'action_type': action_type,
-            'applies_to': applies_to,
             'input_parameters': input_parameters,
             'state': objects.action.State.PENDING,
             'alarm': None,
@@ -63,8 +68,6 @@ class DefaultPlanner(base.BasePlanner):
             json_action = self.create_action(action_plan_id=action_plan.id,
                                              action_type=action.get(
                                                  'action_type'),
-                                             applies_to=action.get(
-                                                 'applies_to'),
                                              input_parameters=action.get(
                                                  'input_parameters'))
             to_schedule.append((self.priorities[action.get('action_type')],

watcher/decision_engine/rpcapi.py

@@ -19,10 +19,10 @@
 
 from oslo_config import cfg
 from oslo_log import log
-import oslo_messaging as om
 
 from watcher.common import exception
-from watcher.common.messaging.messaging_core import MessagingCore
+from watcher.common.messaging import messaging_core
+from watcher.common.messaging import notification_handler
 from watcher.common import utils
 from watcher.decision_engine.manager import decision_engine_opt_group
 from watcher.decision_engine.manager import WATCHER_DECISION_ENGINE_OPTS
@@ -35,27 +35,22 @@ CONF.register_group(decision_engine_opt_group)
 CONF.register_opts(WATCHER_DECISION_ENGINE_OPTS, decision_engine_opt_group)
 
 
-class DecisionEngineAPI(MessagingCore):
+class DecisionEngineAPI(messaging_core.MessagingCore):
 
     def __init__(self):
         super(DecisionEngineAPI, self).__init__(
             CONF.watcher_decision_engine.publisher_id,
-            CONF.watcher_decision_engine.topic_control,
-            CONF.watcher_decision_engine.topic_status,
+            CONF.watcher_decision_engine.conductor_topic,
+            CONF.watcher_decision_engine.status_topic,
             api_version=self.API_VERSION,
         )
-
-        transport = om.get_transport(CONF)
-        target = om.Target(
-            topic=CONF.watcher_decision_engine.topic_control,
-            version=self.API_VERSION,
-        )
-        self.client = om.RPCClient(transport, target,
-                                   serializer=self.serializer)
+        self.handler = notification_handler.NotificationHandler(
+            self.publisher_id)
+        self.status_topic_handler.add_endpoint(self.handler)
 
     def trigger_audit(self, context, audit_uuid=None):
         if not utils.is_uuid_like(audit_uuid):
             raise exception.InvalidUuidOrName(name=audit_uuid)
 
-        return self.client.call(
+        return self.conductor_client.call(
             context.to_dict(), 'trigger_audit', audit_uuid=audit_uuid)

watcher/decision_engine/solution/base.py

@@ -87,13 +87,13 @@ class BaseSolution(object):
     @abc.abstractmethod
     def add_action(self,
                    action_type,
-                   applies_to,
+                   resource_id,
                    input_parameters=None):
         """Add a new Action in the Action Plan
 
         :param action_type: the unique id of an action type defined in
             entry point 'watcher_actions'
-        :param applies_to: the unique id of the resource to which the
+        :param resource_id: the unique id of the resource to which the
             `Action` applies.
         :param input_parameters: An array of input parameters provided as
             key-value pairs of strings. Each key-pair contains names and

watcher/decision_engine/solution/default.py

@@ -18,12 +18,14 @@
 #
 from oslo_log import log
 
-from watcher.decision_engine.solution.base import BaseSolution
+from watcher.applier.actions import base as baction
+from watcher.common import exception
+from watcher.decision_engine.solution import base
 
 LOG = log.getLogger(__name__)
 
 
-class DefaultSolution(BaseSolution):
+class DefaultSolution(base.BaseSolution):
     def __init__(self):
         """Stores a set of actions generated by a strategy
 
@@ -34,12 +36,17 @@ class DefaultSolution(BaseSolution):
         self._actions = []
 
     def add_action(self, action_type,
-                   applies_to,
-                   input_parameters=None):
-        # todo(jed) add https://pypi.python.org/pypi/schema
+                   input_parameters=None,
+                   resource_id=None):
+
+        if input_parameters is not None:
+            if baction.BaseAction.RESOURCE_ID in input_parameters.keys():
+                raise exception.ReservedWord(name=baction.BaseAction.
+                                             RESOURCE_ID)
+        if resource_id is not None:
+            input_parameters[baction.BaseAction.RESOURCE_ID] = resource_id
         action = {
             'action_type': action_type,
-            'applies_to': applies_to,
             'input_parameters': input_parameters
         }
         self._actions.append(action)

watcher/decision_engine/strategy/common/level.py

@@ -17,10 +17,10 @@
 # limitations under the License.
 #
 
-from enum import Enum
+import enum
 
 
-class StrategyLevel(Enum):
+class StrategyLevel(enum.Enum):
     conservative = "conservative"
     balanced = "balanced"
     growth = "growth"

watcher/decision_engine/strategy/context/default.py

@@ -15,22 +15,22 @@
 # limitations under the License.
 from oslo_log import log
 
-from watcher.decision_engine.strategy.context.base import BaseStrategyContext
-from watcher.decision_engine.strategy.selection.default import \
-    DefaultStrategySelector
-from watcher.metrics_engine.cluster_model_collector.manager import \
-    CollectorManager
+from watcher.common import clients
+from watcher.decision_engine.strategy.context import base
+from watcher.decision_engine.strategy.selection import default
+from watcher.metrics_engine.cluster_model_collector import manager
+
 from watcher import objects
 
 LOG = log.getLogger(__name__)
 
 
-class DefaultStrategyContext(BaseStrategyContext):
+class DefaultStrategyContext(base.BaseStrategyContext):
     def __init__(self):
         super(DefaultStrategyContext, self).__init__()
         LOG.debug("Initializing Strategy Context")
-        self._strategy_selector = DefaultStrategySelector()
-        self._collector_manager = CollectorManager()
+        self._strategy_selector = default.DefaultStrategySelector()
+        self._collector_manager = manager.CollectorManager()
 
     @property
     def collector(self):
@@ -47,15 +47,17 @@ class DefaultStrategyContext(BaseStrategyContext):
         audit_template = objects.\
             AuditTemplate.get_by_id(request_context, audit.audit_template_id)
 
+        osc = clients.OpenStackClients()
+
         # todo(jed) retrieve in audit_template parameters (threshold,...)
         # todo(jed) create ActionPlan
-        collector_manager = self.collector.get_cluster_model_collector()
+        collector_manager = self.collector.get_cluster_model_collector(osc=osc)
 
         # todo(jed) remove call to get_latest_cluster_data_model
         cluster_data_model = collector_manager.get_latest_cluster_data_model()
 
-        selected_strategy = self.strategy_selector. \
-            define_from_goal(audit_template.goal)
+        selected_strategy = self.strategy_selector.define_from_goal(
+            audit_template.goal, osc=osc)
 
         # todo(jed) add parameters and remove cluster_data_model
         return selected_strategy.execute(cluster_data_model)

watcher/decision_engine/strategy/loading/default.py

@@ -21,12 +21,12 @@ from __future__ import unicode_literals
 
 from oslo_log import log
 
-from watcher.common.loader.default import DefaultLoader
+from watcher.common.loader import default
 
 LOG = log.getLogger(__name__)
 
 
-class DefaultStrategyLoader(DefaultLoader):
+class DefaultStrategyLoader(default.DefaultLoader):
     def __init__(self):
         super(DefaultStrategyLoader, self).__init__(
             namespace='watcher_strategies')

watcher/decision_engine/strategy/selection/default.py

@@ -48,11 +48,12 @@ class DefaultStrategySelector(base.BaseSelector):
         super(DefaultStrategySelector, self).__init__()
         self.strategy_loader = default.DefaultStrategyLoader()
 
-    def define_from_goal(self, goal_name):
+    def define_from_goal(self, goal_name, osc=None):
+        """:param osc: an OpenStackClients instance"""
         strategy_to_load = None
         try:
             strategy_to_load = CONF.watcher_goals.goals[goal_name]
-            return self.strategy_loader.load(strategy_to_load)
+            return self.strategy_loader.load(strategy_to_load, osc=osc)
         except KeyError as exc:
             LOG.exception(exc)
             raise exception.WatcherException(

watcher/decision_engine/strategy/strategies/__init__.py

@@ -18,10 +18,14 @@
 from watcher.decision_engine.strategy.strategies import basic_consolidation
 from watcher.decision_engine.strategy.strategies import dummy_strategy
 from watcher.decision_engine.strategy.strategies import outlet_temp_control
+from watcher.decision_engine.strategy.strategies \
+    import vm_workload_consolidation
 
 BasicConsolidation = basic_consolidation.BasicConsolidation
 OutletTempControl = outlet_temp_control.OutletTempControl
 DummyStrategy = dummy_strategy.DummyStrategy
+VMWorkloadConsolidation = vm_workload_consolidation.VMWorkloadConsolidation
 
 
-__all__ = (BasicConsolidation, OutletTempControl, DummyStrategy)
+__all__ = (BasicConsolidation, OutletTempControl, DummyStrategy,
+           VMWorkloadConsolidation)

watcher/decision_engine/strategy/strategies/base.py

@@ -30,15 +30,20 @@ to find an optimal :ref:`Solution <solution_definition>`.
 When a new :ref:`Goal <goal_definition>` is added to the Watcher configuration,
 at least one default associated :ref:`Strategy <strategy_definition>` should be
 provided as well.
+
+:ref:`Some default implementations are provided <watcher_strategies>`, but it
+is possible to :ref:`develop new implementations <implement_strategy_plugin>`
+which are dynamically loaded by Watcher at launch time.
 """
 
 import abc
+
 from oslo_log import log
 import six
 
-
-from watcher.decision_engine.solution.default import DefaultSolution
-from watcher.decision_engine.strategy.common.level import StrategyLevel
+from watcher.common import clients
+from watcher.decision_engine.solution import default
+from watcher.decision_engine.strategy.common import level
 
 LOG = log.getLogger(__name__)
 
@@ -51,25 +56,33 @@ class BaseStrategy(object):
     Solution for a given Goal.
     """
 
-    def __init__(self, name=None, description=None):
+    def __init__(self, name=None, description=None, osc=None):
+        """:param osc: an OpenStackClients instance"""
         self._name = name
         self.description = description
         # default strategy level
-        self._strategy_level = StrategyLevel.conservative
+        self._strategy_level = level.StrategyLevel.conservative
         self._cluster_state_collector = None
         # the solution given by the strategy
-        self._solution = DefaultSolution()
+        self._solution = default.DefaultSolution()
+        self._osc = osc
 
     @abc.abstractmethod
-    def execute(self, model):
+    def execute(self, original_model):
         """Execute a strategy
 
-        :param model: The name of the strategy to execute (loaded dynamically)
+        :param original_model: The model the strategy is executed on
         :type model: str
         :return: A computed solution (via a placement algorithm)
         :rtype: :class:`watcher.decision_engine.solution.base.BaseSolution`
         """
 
+    @property
+    def osc(self):
+        if not self._osc:
+            self._osc = clients.OpenStackClients()
+        return self._osc
+
     @property
     def solution(self):
         return self._solution

watcher/decision_engine/strategy/strategies/basic_consolidation.py

@@ -16,22 +16,55 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 #
+"""
+*Good server consolidation strategy*
+
+Consolidation of VMs is essential to achieve energy optimization in cloud
+environments such as OpenStack. As VMs are spinned up and/or moved over time,
+it becomes necessary to migrate VMs among servers to lower the costs. However,
+migration of VMs introduces runtime overheads and consumes extra energy, thus
+a good server consolidation strategy should carefully plan for migration in
+order to both minimize energy consumption and comply to the various SLAs.
+"""
 
 from oslo_log import log
 
 from watcher._i18n import _LE, _LI, _LW
 from watcher.common import exception
-from watcher.decision_engine.model.hypervisor_state import HypervisorState
-from watcher.decision_engine.model.resource import ResourceType
-from watcher.decision_engine.model.vm_state import VMState
-from watcher.decision_engine.strategy.strategies.base import BaseStrategy
-from watcher.metrics_engine.cluster_history.ceilometer import \
-    CeilometerClusterHistory
+from watcher.decision_engine.model import hypervisor_state as hyper_state
+from watcher.decision_engine.model import resource
+from watcher.decision_engine.model import vm_state
+from watcher.decision_engine.strategy.strategies import base
+from watcher.metrics_engine.cluster_history import ceilometer as \
+    ceilometer_cluster_history
 
 LOG = log.getLogger(__name__)
 
 
-class BasicConsolidation(BaseStrategy):
+class BasicConsolidation(base.BaseStrategy):
+    """Basic offline consolidation using live migration
+
+    *Description*
+
+    This is server consolidation algorithm which not only minimizes the overall
+    number of used servers, but also minimizes the number of migrations.
+
+    *Requirements*
+
+    * You must have at least 2 physical compute nodes to run this strategy.
+
+    *Limitations*
+
+    - It has been developed only for tests.
+    - It assumes that the virtual machine and the compute node are on the same
+      private network.
+    - It assume that live migrations are possible
+
+    *Spec URL*
+
+    <None>
+    """
+
     DEFAULT_NAME = "basic"
     DEFAULT_DESCRIPTION = "Basic offline consolidation"
 
@@ -41,35 +74,17 @@ class BasicConsolidation(BaseStrategy):
     MIGRATION = "migrate"
     CHANGE_NOVA_SERVICE_STATE = "change_nova_service_state"
 
-    def __init__(self, name=DEFAULT_NAME, description=DEFAULT_DESCRIPTION):
+    def __init__(self, name=DEFAULT_NAME, description=DEFAULT_DESCRIPTION,
+                 osc=None):
         """Basic offline Consolidation using live migration
 
-    The basic consolidation algorithm has several limitations.
-    It has been developed only for tests.
-    eg: The BasicConsolidation assumes that the virtual mahine and
-    the compute node are on the same private network.
-
-    Good Strategy :
-    The workloads of the VMs are changing over the time
-    and often tend to migrate from one physical machine to another.
-    Hence, the traditional and offline heuristics such as bin packing
-    are not applicable for the placement VM in cloud computing.
-    So, the decision Engine optimizer provides placement strategy considering
-    not only the performance effects but also the workload characteristics of
-    VMs and others metrics like the power consumption and
-    the tenants constraints (SLAs).
-
-    The watcher optimizer uses an online VM placement technique
-    based on machine learning and meta-heuristics that must handle :
-    - multi-objectives
-    - Contradictory objectives
-    - Adapt to changes dynamically
-    - Fast convergence
-
-        :param name: the name of the strategy
-        :param description: a description of the strategy
+        :param name: The name of the strategy (Default: "basic")
+        :param description: The description of the strategy
+                            (Default: "Basic offline consolidation")
+        :param osc: An :py:class:`~watcher.common.clients.OpenStackClients`
+                    instance
         """
-        super(BasicConsolidation, self).__init__(name, description)
+        super(BasicConsolidation, self).__init__(name, description, osc)
 
         # set default value for the number of released nodes
         self.number_of_released_nodes = 0
@@ -102,12 +117,13 @@ class BasicConsolidation(BaseStrategy):
     @property
     def ceilometer(self):
         if self._ceilometer is None:
-            self._ceilometer = CeilometerClusterHistory()
+            self._ceilometer = (ceilometer_cluster_history.
+                                CeilometerClusterHistory(osc=self.osc))
         return self._ceilometer
 
     @ceilometer.setter
-    def ceilometer(self, c):
-        self._ceilometer = c
+    def ceilometer(self, ceilometer):
+        self._ceilometer = ceilometer
 
     def compute_attempts(self, size_cluster):
         """Upper bound of the number of migration
@@ -116,13 +132,13 @@ class BasicConsolidation(BaseStrategy):
         """
         self.migration_attempts = size_cluster * self.bound_migration
 
-    def check_migration(self, model,
+    def check_migration(self, cluster_data_model,
                         src_hypervisor,
                         dest_hypervisor,
                         vm_to_mig):
         """check if the migration is possible
 
-        :param model: the current state of the cluster
+        :param cluster_data_model: the current state of the cluster
         :param src_hypervisor: the current node of the virtual machine
         :param dest_hypervisor: the destination of the virtual machine
         :param vm_to_mig: the virtual machine
@@ -139,28 +155,32 @@ class BasicConsolidation(BaseStrategy):
         total_cores = 0
         total_disk = 0
         total_mem = 0
-        cap_cores = model.get_resource_from_id(ResourceType.cpu_cores)
-        cap_disk = model.get_resource_from_id(ResourceType.disk)
-        cap_mem = model.get_resource_from_id(ResourceType.memory)
+        cpu_capacity = cluster_data_model.get_resource_from_id(
+            resource.ResourceType.cpu_cores)
+        disk_capacity = cluster_data_model.get_resource_from_id(
+            resource.ResourceType.disk)
+        memory_capacity = cluster_data_model.get_resource_from_id(
+            resource.ResourceType.memory)
 
-        for vm_id in model.get_mapping().get_node_vms(dest_hypervisor):
-            vm = model.get_vm_from_id(vm_id)
-            total_cores += cap_cores.get_capacity(vm)
-            total_disk += cap_disk.get_capacity(vm)
-            total_mem += cap_mem.get_capacity(vm)
+        for vm_id in cluster_data_model. \
+                get_mapping().get_node_vms(dest_hypervisor):
+            vm = cluster_data_model.get_vm_from_id(vm_id)
+            total_cores += cpu_capacity.get_capacity(vm)
+            total_disk += disk_capacity.get_capacity(vm)
+            total_mem += memory_capacity.get_capacity(vm)
 
         # capacity requested by hypervisor
-        total_cores += cap_cores.get_capacity(vm_to_mig)
-        total_disk += cap_disk.get_capacity(vm_to_mig)
-        total_mem += cap_mem.get_capacity(vm_to_mig)
+        total_cores += cpu_capacity.get_capacity(vm_to_mig)
+        total_disk += disk_capacity.get_capacity(vm_to_mig)
+        total_mem += memory_capacity.get_capacity(vm_to_mig)
 
-        return self.check_threshold(model,
+        return self.check_threshold(cluster_data_model,
                                     dest_hypervisor,
                                     total_cores,
                                     total_disk,
                                     total_mem)
 
-    def check_threshold(self, model,
+    def check_threshold(self, cluster_data_model,
                         dest_hypervisor,
                         total_cores,
                         total_disk,
@@ -170,23 +190,23 @@ class BasicConsolidation(BaseStrategy):
         check the threshold value defined by the ratio of
         aggregated CPU capacity of VMs on one node to CPU capacity
         of this node must not exceed the threshold value.
-        :param dest_hypervisor:
+        :param cluster_data_model: the current state of the cluster
+        :param dest_hypervisor: the destination of the virtual machine
         :param total_cores
         :param total_disk
         :param total_mem
         :return: True if the threshold is not exceed
         """
-        cap_cores = model.get_resource_from_id(ResourceType.cpu_cores)
-        cap_disk = model.get_resource_from_id(ResourceType.disk)
-        cap_mem = model.get_resource_from_id(ResourceType.memory)
-        # available
-        cores_available = cap_cores.get_capacity(dest_hypervisor)
-        disk_available = cap_disk.get_capacity(dest_hypervisor)
-        mem_available = cap_mem.get_capacity(dest_hypervisor)
+        cpu_capacity = cluster_data_model.get_resource_from_id(
+            resource.ResourceType.cpu_cores).get_capacity(dest_hypervisor)
+        disk_capacity = cluster_data_model.get_resource_from_id(
+            resource.ResourceType.disk).get_capacity(dest_hypervisor)
+        memory_capacity = cluster_data_model.get_resource_from_id(
+            resource.ResourceType.memory).get_capacity(dest_hypervisor)
 
-        if cores_available >= total_cores * self.threshold_cores \
-                and disk_available >= total_disk * self.threshold_disk \
-                and mem_available >= total_mem * self.threshold_mem:
+        if (cpu_capacity >= total_cores * self.threshold_cores and
+                disk_capacity >= total_disk * self.threshold_disk and
+                memory_capacity >= total_mem * self.threshold_mem):
             return True
         else:
             return False
@@ -212,25 +232,26 @@ class BasicConsolidation(BaseStrategy):
     def get_number_of_migrations(self):
         return self.number_of_migrations
 
-    def calculate_weight(self, model, element, total_cores_used,
-                         total_disk_used, total_memory_used):
+    def calculate_weight(self, cluster_data_model, element,
+                         total_cores_used, total_disk_used,
+                         total_memory_used):
         """Calculate weight of every resource
 
-        :param model:
+        :param cluster_data_model:
         :param element:
         :param total_cores_used:
         :param total_disk_used:
         :param total_memory_used:
         :return:
         """
-        cpu_capacity = model.get_resource_from_id(
-            ResourceType.cpu_cores).get_capacity(element)
+        cpu_capacity = cluster_data_model.get_resource_from_id(
+            resource.ResourceType.cpu_cores).get_capacity(element)
 
-        disk_capacity = model.get_resource_from_id(
-            ResourceType.disk).get_capacity(element)
+        disk_capacity = cluster_data_model.get_resource_from_id(
+            resource.ResourceType.disk).get_capacity(element)
 
-        memory_capacity = model.get_resource_from_id(
-            ResourceType.memory).get_capacity(element)
+        memory_capacity = cluster_data_model.get_resource_from_id(
+            resource.ResourceType.memory).get_capacity(element)
 
         score_cores = (1 - (float(cpu_capacity) - float(total_cores_used)) /
                        float(cpu_capacity))
@@ -256,25 +277,25 @@ class BasicConsolidation(BaseStrategy):
             :return:
             """
         resource_id = "%s_%s" % (hypervisor.uuid, hypervisor.hostname)
-        cpu_avg_vm = self.ceilometer. \
+        host_avg_cpu_util = self.ceilometer. \
             statistic_aggregation(resource_id=resource_id,
                                   meter_name=self.HOST_CPU_USAGE_METRIC_NAME,
                                   period="7200",
                                   aggregate='avg'
                                   )
-        if cpu_avg_vm is None:
+        if host_avg_cpu_util is None:
             LOG.error(
                 _LE("No values returned by %(resource_id)s "
                     "for %(metric_name)s"),
                 resource_id=resource_id,
                 metric_name=self.HOST_CPU_USAGE_METRIC_NAME,
             )
-            cpu_avg_vm = 100
+            host_avg_cpu_util = 100
 
         cpu_capacity = model.get_resource_from_id(
-            ResourceType.cpu_cores).get_capacity(hypervisor)
+            resource.ResourceType.cpu_cores).get_capacity(hypervisor)
 
-        total_cores_used = cpu_capacity * (cpu_avg_vm / 100)
+        total_cores_used = cpu_capacity * (host_avg_cpu_util / 100)
 
         return self.calculate_weight(model, hypervisor, total_cores_used,
                                      0,
@@ -292,14 +313,14 @@ class BasicConsolidation(BaseStrategy):
         else:
             return 0
 
-    def calculate_score_vm(self, vm, model):
+    def calculate_score_vm(self, vm, cluster_data_model):
         """Calculate Score of virtual machine
 
         :param vm: the virtual machine
-        :param model: the model
+        :param cluster_data_model: the cluster model
         :return: score
         """
-        if model is None:
+        if cluster_data_model is None:
             raise exception.ClusterStateNotDefined()
 
         vm_cpu_utilization = self.ceilometer. \
@@ -318,23 +339,22 @@ class BasicConsolidation(BaseStrategy):
             )
             vm_cpu_utilization = 100
 
-        cpu_capacity = model.get_resource_from_id(
-            ResourceType.cpu_cores).get_capacity(vm)
+        cpu_capacity = cluster_data_model.get_resource_from_id(
+            resource.ResourceType.cpu_cores).get_capacity(vm)
 
         total_cores_used = cpu_capacity * (vm_cpu_utilization / 100.0)
 
-        return self.calculate_weight(model, vm, total_cores_used,
-                                     0,
-                                     0)
+        return self.calculate_weight(cluster_data_model, vm,
+                                     total_cores_used, 0, 0)
 
-    def add_change_service_state(self, applies_to, state):
+    def add_change_service_state(self, resource_id, state):
         parameters = {'state': state}
         self.solution.add_action(action_type=self.CHANGE_NOVA_SERVICE_STATE,
-                                 applies_to=applies_to,
+                                 resource_id=resource_id,
                                  input_parameters=parameters)
 
     def add_migration(self,
-                      applies_to,
+                      resource_id,
                       migration_type,
                       src_hypervisor,
                       dst_hypervisor):
@@ -342,17 +362,19 @@ class BasicConsolidation(BaseStrategy):
                       'src_hypervisor': src_hypervisor,
                       'dst_hypervisor': dst_hypervisor}
         self.solution.add_action(action_type=self.MIGRATION,
-                                 applies_to=applies_to,
+                                 resource_id=resource_id,
                                  input_parameters=parameters)
 
-    def score_of_nodes(self, current_model, score):
+    def score_of_nodes(self, cluster_data_model, score):
         """Calculate score of nodes based on load by VMs"""
-        for hypervisor_id in current_model.get_all_hypervisors():
-            hypervisor = current_model.get_hypervisor_from_id(hypervisor_id)
-            count = current_model.get_mapping(). \
+        for hypervisor_id in cluster_data_model.get_all_hypervisors():
+            hypervisor = cluster_data_model. \
+                get_hypervisor_from_id(hypervisor_id)
+            count = cluster_data_model.get_mapping(). \
                 get_node_vms_from_id(hypervisor_id)
             if len(count) > 0:
-                result = self.calculate_score_node(hypervisor, current_model)
+                result = self.calculate_score_node(hypervisor,
+                                                   cluster_data_model)
             else:
                 ''' the hypervisor has not VMs '''
                 result = 0
@@ -360,16 +382,16 @@ class BasicConsolidation(BaseStrategy):
                 score.append((hypervisor_id, result))
         return score
 
-    def node_and_vm_score(self, s, score, current_model):
+    def node_and_vm_score(self, sorted_score, score, current_model):
         """Get List of VMs from Node"""
-        node_to_release = s[len(score) - 1][0]
+        node_to_release = sorted_score[len(score) - 1][0]
         vms_to_mig = current_model.get_mapping().get_node_vms_from_id(
             node_to_release)
 
         vm_score = []
         for vm_id in vms_to_mig:
             vm = current_model.get_vm_from_id(vm_id)
-            if vm.state == VMState.ACTIVE.value:
+            if vm.state == vm_state.VMState.ACTIVE.value:
                 vm_score.append(
                     (vm_id, self.calculate_score_vm(vm, current_model)))
 
@@ -388,51 +410,53 @@ class BasicConsolidation(BaseStrategy):
                 mig_src_hypervisor)) == 0:
             self.add_change_service_state(mig_src_hypervisor.
                                           uuid,
-                                          HypervisorState.
-                                          OFFLINE.value)
+                                          hyper_state.HypervisorState.
+                                          DISABLED.value)
             self.number_of_released_nodes += 1
 
-    def calculate_m(self, v, current_model, node_to_release, s):
-        m = 0
-        for vm in v:
-            for j in range(0, len(s)):
+    def calculate_num_migrations(self, sorted_vms, current_model,
+                                 node_to_release, sorted_score):
+        number_migrations = 0
+        for vm in sorted_vms:
+            for j in range(0, len(sorted_score)):
                 mig_vm = current_model.get_vm_from_id(vm[0])
                 mig_src_hypervisor = current_model.get_hypervisor_from_id(
                     node_to_release)
                 mig_dst_hypervisor = current_model.get_hypervisor_from_id(
-                    s[j][0])
+                    sorted_score[j][0])
 
                 result = self.check_migration(current_model,
                                               mig_src_hypervisor,
                                               mig_dst_hypervisor, mig_vm)
-                if result is True:
+                if result:
                     self.create_migration_vm(
                         current_model, mig_vm,
                         mig_src_hypervisor, mig_dst_hypervisor)
-                    m += 1
+                    number_migrations += 1
                     break
-        return m
+        return number_migrations
 
-    def unsuccessful_migration_actualization(self, m, unsuccessful_migration):
-        if m > 0:
-            self.number_of_migrations += m
+    def unsuccessful_migration_actualization(self, number_migrations,
+                                             unsuccessful_migration):
+        if number_migrations > 0:
+            self.number_of_migrations += number_migrations
             return 0
         else:
             return unsuccessful_migration + 1
 
-    def execute(self, orign_model):
+    def execute(self, original_model):
         LOG.info(_LI("Initializing Sercon Consolidation"))
 
-        if orign_model is None:
+        if original_model is None:
             raise exception.ClusterStateNotDefined()
 
         # todo(jed) clone model
-        current_model = orign_model
+        current_model = original_model
 
         self.efficacy = 100
         unsuccessful_migration = 0
 
-        first = True
+        first_migration = True
         size_cluster = len(current_model.get_all_hypervisors())
         if size_cluster == 0:
             raise exception.ClusterEmpty()
@@ -444,24 +468,24 @@ class BasicConsolidation(BaseStrategy):
             count = current_model.get_mapping(). \
                 get_node_vms_from_id(hypervisor_id)
             if len(count) == 0:
-                if hypervisor.state == HypervisorState.ONLINE:
+                if hypervisor.state == hyper_state.HypervisorState.ENABLED:
                     self.add_change_service_state(hypervisor_id,
-                                                  HypervisorState.
-                                                  OFFLINE.value)
+                                                  hyper_state.HypervisorState.
+                                                  DISABLED.value)
 
         while self.get_allowed_migration_attempts() >= unsuccessful_migration:
-            if first is not True:
+            if not first_migration:
                 self.efficacy = self.calculate_migration_efficacy()
                 if self.efficacy < float(self.target_efficacy):
                     break
-            first = False
+            first_migration = False
             score = []
 
             score = self.score_of_nodes(current_model, score)
 
             ''' sort compute nodes by Score decreasing '''''
-            s = sorted(score, reverse=True, key=lambda x: (x[1]))
-            LOG.debug("Hypervisor(s) BFD {0}".format(s))
+            sorted_score = sorted(score, reverse=True, key=lambda x: (x[1]))
+            LOG.debug("Hypervisor(s) BFD {0}".format(sorted_score))
 
             ''' get Node to be released '''
             if len(score) == 0:
@@ -471,17 +495,18 @@ class BasicConsolidation(BaseStrategy):
                 break
 
             node_to_release, vm_score = self.node_and_vm_score(
-                s, score, current_model)
+                sorted_score, score, current_model)
 
             ''' sort VMs by Score '''
-            v = sorted(vm_score, reverse=True, key=lambda x: (x[1]))
+            sorted_vms = sorted(vm_score, reverse=True, key=lambda x: (x[1]))
             # BFD: Best Fit Decrease
-            LOG.debug("VM(s) BFD {0}".format(v))
+            LOG.debug("VM(s) BFD {0}".format(sorted_vms))
 
-            m = self.calculate_m(v, current_model, node_to_release, s)
+            migrations = self.calculate_num_migrations(
+                sorted_vms, current_model, node_to_release, sorted_score)
 
             unsuccessful_migration = self.unsuccessful_migration_actualization(
-                m, unsuccessful_migration)
+                migrations, unsuccessful_migration)
         infos = {
             "number_of_migrations": self.number_of_migrations,
             "number_of_nodes_released": self.number_of_released_nodes,

watcher/decision_engine/strategy/strategies/dummy_strategy.py

@@ -18,33 +18,52 @@
 #
 from oslo_log import log
 
-from watcher.decision_engine.strategy.strategies.base import BaseStrategy
+from watcher.decision_engine.strategy.strategies import base
 
 LOG = log.getLogger(__name__)
 
 
-class DummyStrategy(BaseStrategy):
+class DummyStrategy(base.BaseStrategy):
+    """Dummy strategy used for integration testing via Tempest
+
+    *Description*
+
+    This strategy does not provide any useful optimization. Indeed, its only
+    purpose is to be used by Tempest tests.
+
+    *Requirements*
+
+    <None>
+
+    *Limitations*
+
+    Do not use in production.
+
+    *Spec URL*
+
+    <None>
+    """
+
     DEFAULT_NAME = "dummy"
     DEFAULT_DESCRIPTION = "Dummy Strategy"
 
     NOP = "nop"
     SLEEP = "sleep"
 
-    def __init__(self, name=DEFAULT_NAME, description=DEFAULT_DESCRIPTION):
-        super(DummyStrategy, self).__init__(name, description)
+    def __init__(self, name=DEFAULT_NAME, description=DEFAULT_DESCRIPTION,
+                 osc=None):
+        super(DummyStrategy, self).__init__(name, description, osc)
 
-    def execute(self, model):
+    def execute(self, original_model):
+        LOG.debug("Executing Dummy strategy")
         parameters = {'message': 'hello World'}
         self.solution.add_action(action_type=self.NOP,
-                                 applies_to="",
                                  input_parameters=parameters)
 
         parameters = {'message': 'Welcome'}
         self.solution.add_action(action_type=self.NOP,
-                                 applies_to="",
                                  input_parameters=parameters)
 
         self.solution.add_action(action_type=self.SLEEP,
-                                 applies_to="",
-                                 input_parameters={'duration': '5'})
+                                 input_parameters={'duration': 5.0})
         return self.solution

watcher/decision_engine/strategy/strategies/outlet_temp_control.py

@@ -16,20 +16,60 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 #
+
+"""
+*Good Thermal Strategy*:
+
+Towards to software defined infrastructure, the power and thermal
+intelligences is being adopted to optimize workload, which can help
+improve efficiency, reduce power, as well as to improve datacenter PUE
+and lower down operation cost in data center.
+Outlet (Exhaust Air) Temperature is one of the important thermal
+telemetries to measure thermal/workload status of server.
+"""
+
 from oslo_log import log
 
 from watcher._i18n import _LE
 from watcher.common import exception as wexc
-from watcher.decision_engine.model.resource import ResourceType
-from watcher.decision_engine.model.vm_state import VMState
-from watcher.decision_engine.strategy.strategies.base import BaseStrategy
-from watcher.metrics_engine.cluster_history.ceilometer import \
-    CeilometerClusterHistory
+from watcher.decision_engine.model import resource
+from watcher.decision_engine.model import vm_state
+from watcher.decision_engine.strategy.strategies import base
+from watcher.metrics_engine.cluster_history import ceilometer as ceil
+
 
 LOG = log.getLogger(__name__)
 
 
-class OutletTempControl(BaseStrategy):
+class OutletTempControl(base.BaseStrategy):
+    """[PoC] Outlet temperature control using live migration
+
+    *Description*
+
+    It is a migration strategy based on the outlet temperature of compute
+    hosts. It generates solutions to move a workload whenever a server's
+    outlet temperature is higher than the specified threshold.
+
+    *Requirements*
+
+    * Hardware: All computer hosts should support IPMI and PTAS technology
+    * Software: Ceilometer component ceilometer-agent-ipmi running
+      in each compute host, and Ceilometer API can report such telemetry
+      ``hardware.ipmi.node.outlet_temperature`` successfully.
+    * You must have at least 2 physical compute hosts to run this strategy.
+
+    *Limitations*
+
+    - This is a proof of concept that is not meant to be used in production
+    - We cannot forecast how many servers should be migrated. This is the
+      reason why we only plan a single virtual machine migration at a time.
+      So it's better to use this algorithm with `CONTINUOUS` audits.
+    - It assume that live migrations are possible
+
+    *Spec URL*
+
+    https://github.com/openstack/watcher-specs/blob/master/specs/mitaka/approved/outlet-temperature-based-strategy.rst
+    """  # noqa
 
     DEFAULT_NAME = "outlet_temp_control"
     DEFAULT_DESCRIPTION = "outlet temperature based migration strategy"
@@ -40,35 +80,15 @@ class OutletTempControl(BaseStrategy):
 
     MIGRATION = "migrate"
 
-    def __init__(self, name=DEFAULT_NAME, description=DEFAULT_DESCRIPTION):
-        """[PoC]Outlet temperature control using live migration
-
-        It is a migration strategy based on the Outlet Temperature of physical
-        servers. It generates solutions to move a workload whenever a server’s
-        outlet temperature is higher than the specified threshold. As of now,
-        we cannot forecast how many instances should be migrated. This is the
-        reason why we simply plan a single virtual machine migration.
-        So it's better to use this algorithm with CONTINUOUS audits.
-
-        Requirements:
-        * Hardware: computer node should support IPMI and PTAS technology
-        * Software: Ceilometer component ceilometer-agent-ipmi running
-          in each compute node, and Ceilometer API can report such telemetry
-          "hardware.ipmi.node.outlet_temperature" successfully.
-        * You must have at least 2 physical compute nodes to run this strategy.
-
-        Good Strategy:
-        Towards to software defined infrastructure, the power and thermal
-        intelligences is being adopted to optimize workload, which can help
-        improve efficiency, reduce power, as well as to improve datacenter PUE
-        and lower down operation cost in data center.
-        Outlet(Exhaust Air) Temperature is one of the important thermal
-        telemetries to measure thermal/workload status of server.
+    def __init__(self, name=DEFAULT_NAME, description=DEFAULT_DESCRIPTION,
+                 osc=None):
+        """Outlet temperature control using live migration
 
         :param name: the name of the strategy
         :param description: a description of the strategy
+        :param osc: an OpenStackClients object
         """
-        super(OutletTempControl, self).__init__(name, description)
+        super(OutletTempControl, self).__init__(name, description, osc)
         # the migration plan will be triggered when the outlet temperature
         # reaches threshold
         # TODO(zhenzanz): Threshold should be configurable for each audit
@@ -79,32 +99,33 @@ class OutletTempControl(BaseStrategy):
     @property
     def ceilometer(self):
         if self._ceilometer is None:
-            self._ceilometer = CeilometerClusterHistory()
+            self._ceilometer = ceil.CeilometerClusterHistory(osc=self.osc)
         return self._ceilometer
 
     @ceilometer.setter
     def ceilometer(self, c):
         self._ceilometer = c
 
-    def calc_used_res(self, model, hypervisor, cap_cores, cap_mem, cap_disk):
+    def calc_used_res(self, cluster_data_model, hypervisor, cpu_capacity,
+                      memory_capacity, disk_capacity):
         '''calculate the used vcpus, memory and disk based on VM flavors'''
-        vms = model.get_mapping().get_node_vms(hypervisor)
+        vms = cluster_data_model.get_mapping().get_node_vms(hypervisor)
         vcpus_used = 0
         memory_mb_used = 0
         disk_gb_used = 0
         if len(vms) > 0:
             for vm_id in vms:
-                vm = model.get_vm_from_id(vm_id)
-                vcpus_used += cap_cores.get_capacity(vm)
-                memory_mb_used += cap_mem.get_capacity(vm)
-                disk_gb_used += cap_disk.get_capacity(vm)
+                vm = cluster_data_model.get_vm_from_id(vm_id)
+                vcpus_used += cpu_capacity.get_capacity(vm)
+                memory_mb_used += memory_capacity.get_capacity(vm)
+                disk_gb_used += disk_capacity.get_capacity(vm)
 
         return vcpus_used, memory_mb_used, disk_gb_used
 
-    def group_hosts_by_outlet_temp(self, model):
-        '''Group hosts based on outlet temp meters'''
+    def group_hosts_by_outlet_temp(self, cluster_data_model):
+        """Group hosts based on outlet temp meters"""
 
-        hypervisors = model.get_all_hypervisors()
+        hypervisors = cluster_data_model.get_all_hypervisors()
         size_cluster = len(hypervisors)
         if size_cluster == 0:
             raise wexc.ClusterEmpty()
@@ -112,7 +133,8 @@ class OutletTempControl(BaseStrategy):
         hosts_need_release = []
         hosts_target = []
         for hypervisor_id in hypervisors:
-            hypervisor = model.get_hypervisor_from_id(hypervisor_id)
+            hypervisor = cluster_data_model.get_hypervisor_from_id(
+                hypervisor_id)
             resource_id = hypervisor.uuid
 
             outlet_temp = self.ceilometer.statistic_aggregation(
@@ -134,18 +156,19 @@ class OutletTempControl(BaseStrategy):
                 hosts_target.append(hvmap)
         return hosts_need_release, hosts_target
 
-    def choose_vm_to_migrate(self, model, hosts):
-        '''pick up an active vm instance to migrate from provided hosts'''
+    def choose_vm_to_migrate(self, cluster_data_model, hosts):
+        """pick up an active vm instance to migrate from provided hosts"""
 
         for hvmap in hosts:
             mig_src_hypervisor = hvmap['hv']
-            vms_of_src = model.get_mapping().get_node_vms(mig_src_hypervisor)
+            vms_of_src = cluster_data_model.get_mapping().get_node_vms(
+                mig_src_hypervisor)
             if len(vms_of_src) > 0:
                 for vm_id in vms_of_src:
                     try:
                         # select the first active VM to migrate
-                        vm = model.get_vm_from_id(vm_id)
-                        if vm.state != VMState.ACTIVE.value:
+                        vm = cluster_data_model.get_vm_from_id(vm_id)
+                        if vm.state != vm_state.VMState.ACTIVE.value:
                             LOG.info(_LE("VM not active, skipped: %s"),
                                      vm.uuid)
                             continue
@@ -156,44 +179,45 @@ class OutletTempControl(BaseStrategy):
 
         return None
 
-    def filter_dest_servers(self, model, hosts, vm_to_migrate):
-        '''Only return hosts with sufficient available resources'''
+    def filter_dest_servers(self, cluster_data_model, hosts, vm_to_migrate):
+        """Only return hosts with sufficient available resources"""
 
-        cap_cores = model.get_resource_from_id(ResourceType.cpu_cores)
-        cap_disk = model.get_resource_from_id(ResourceType.disk)
-        cap_mem = model.get_resource_from_id(ResourceType.memory)
+        cpu_capacity = cluster_data_model.get_resource_from_id(
+            resource.ResourceType.cpu_cores)
+        disk_capacity = cluster_data_model.get_resource_from_id(
+            resource.ResourceType.disk)
+        memory_capacity = cluster_data_model.get_resource_from_id(
+            resource.ResourceType.memory)
 
-        required_cores = cap_cores.get_capacity(vm_to_migrate)
-        required_disk = cap_disk.get_capacity(vm_to_migrate)
-        required_mem = cap_mem.get_capacity(vm_to_migrate)
+        required_cores = cpu_capacity.get_capacity(vm_to_migrate)
+        required_disk = disk_capacity.get_capacity(vm_to_migrate)
+        required_memory = memory_capacity.get_capacity(vm_to_migrate)
 
         # filter hypervisors without enough resource
         dest_servers = []
         for hvmap in hosts:
             host = hvmap['hv']
             # available
-            cores_used, mem_used, disk_used = self.calc_used_res(model,
-                                                                 host,
-                                                                 cap_cores,
-                                                                 cap_mem,
-                                                                 cap_disk)
-            cores_available = cap_cores.get_capacity(host) - cores_used
-            disk_available = cap_disk.get_capacity(host) - mem_used
-            mem_available = cap_mem.get_capacity(host) - disk_used
+            cores_used, mem_used, disk_used = self.calc_used_res(
+                cluster_data_model, host, cpu_capacity, memory_capacity,
+                disk_capacity)
+            cores_available = cpu_capacity.get_capacity(host) - cores_used
+            disk_available = disk_capacity.get_capacity(host) - mem_used
+            mem_available = memory_capacity.get_capacity(host) - disk_used
             if cores_available >= required_cores \
                     and disk_available >= required_disk \
-                    and mem_available >= required_mem:
+                    and mem_available >= required_memory:
                 dest_servers.append(hvmap)
 
         return dest_servers
 
-    def execute(self, orign_model):
+    def execute(self, original_model):
         LOG.debug("Initializing Outlet temperature strategy")
 
-        if orign_model is None:
+        if original_model is None:
             raise wexc.ClusterStateNotDefined()
 
-        current_model = orign_model
+        current_model = original_model
         hosts_need_release, hosts_target = self.group_hosts_by_outlet_temp(
             current_model)
 
@@ -237,10 +261,10 @@ class OutletTempControl(BaseStrategy):
                                                   mig_src_hypervisor,
                                                   mig_dst_hypervisor):
             parameters = {'migration_type': 'live',
-                          'src_hypervisor': mig_src_hypervisor,
-                          'dst_hypervisor': mig_dst_hypervisor}
+                          'src_hypervisor': mig_src_hypervisor.uuid,
+                          'dst_hypervisor': mig_dst_hypervisor.uuid}
             self.solution.add_action(action_type=self.MIGRATION,
-                                     applies_to=vm_src,
+                                     resource_id=vm_src.uuid,
                                      input_parameters=parameters)
 
         self.solution.model = current_model

watcher/decision_engine/strategy/strategies/vm_workload_consolidation.py

@@ -0,0 +1,523 @@
+# -*- encoding: utf-8 -*-
+#
+# Authors: Vojtech CIMA <cima@zhaw.ch>
+#          Bruno GRAZIOLI <gaea@zhaw.ch>
+#          Sean MURPHY <murp@zhaw.ch>
+#
+# 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 copy import deepcopy
+
+from oslo_log import log
+import six
+
+from watcher._i18n import _LE, _LI
+from watcher.common import exception
+from watcher.decision_engine.model import hypervisor_state as hyper_state
+from watcher.decision_engine.model import resource
+from watcher.decision_engine.model import vm_state
+from watcher.decision_engine.strategy.strategies import base
+from watcher.metrics_engine.cluster_history import ceilometer \
+    as ceilometer_cluster_history
+
+LOG = log.getLogger(__name__)
+
+
+class VMWorkloadConsolidation(base.BaseStrategy):
+    """VM Workload Consolidation Strategy.
+
+    A load consolidation strategy based on heuristic first-fit
+    algorithm which focuses on measured CPU utilization and tries to
+    minimize hosts which have too much or too little load respecting
+    resource capacity constraints.
+
+    This strategy produces a solution resulting in more efficient
+    utilization of cluster resources using following four phases:
+     * Offload phase - handling over-utilized resources
+     * Consolidation phase - handling under-utilized resources
+     * Solution optimization - reducing number of migrations
+     * Deactivation of unused hypervisors
+
+    A capacity coefficients (cc) might be used to adjust optimization
+    thresholds. Different resources may require different coefficient
+    values as well as setting up different coefficient values in both
+    phases may lead to to more efficient consolidation in the end.
+    If the cc equals 1 the full resource capacity may be used, cc
+    values lower than 1 will lead to resource under utilization and
+    values higher than 1 will lead to resource overbooking.
+    e.g. If targeted utilization is 80% of hypervisor capacity,
+    the coefficient in the consolidation phase will be 0.8, but
+    may any lower value in the offloading phase. The lower it gets
+    the cluster will appear more released (distributed) for the
+    following consolidation phase.
+
+    As this strategy laverages VM live migration to move the load
+    from one hypervisor to another, this feature needs to be set up
+    correctly on all hypervisors within the cluster.
+    This strategy assumes it is possible to live migrate any VM from
+    an active hypervisor to any other active hypervisor.
+    """
+
+    DEFAULT_NAME = 'vm_workload_consolidation'
+    DEFAULT_DESCRIPTION = 'VM Workload Consolidation Strategy'
+
+    def __init__(self, name=DEFAULT_NAME, description=DEFAULT_DESCRIPTION,
+                 osc=None):
+        super(VMWorkloadConsolidation, self).__init__(name, description, osc)
+        self._ceilometer = None
+        self.number_of_migrations = 0
+        self.number_of_released_hypervisors = 0
+        self.ceilometer_vm_data_cache = dict()
+
+    @property
+    def ceilometer(self):
+        if self._ceilometer is None:
+            self._ceilometer = (ceilometer_cluster_history.
+                                CeilometerClusterHistory(osc=self.osc))
+        return self._ceilometer
+
+    @ceilometer.setter
+    def ceilometer(self, ceilometer):
+        self._ceilometer = ceilometer
+
+    def get_state_str(self, state):
+        """Get resource state in string format.
+
+        :param state: resource state of unknown type
+        """
+        if isinstance(state, six.string_types):
+            return state
+        elif (type(state) == hyper_state.HypervisorState or
+              type(state) == vm_state.VMState):
+            return state.value
+        else:
+            LOG.error(_LE('Unexpexted resource state type, '
+                          'state=%(state)s, state_type=%(st)s.'),
+                      state=state,
+                      st=type(state))
+            raise exception.WatcherException
+
+    def add_action_activate_hypervisor(self, hypervisor):
+        """Add an action for hypervisor activation into the solution.
+
+        :param hypervisor: hypervisor object
+        :return: None
+        """
+        params = {'state': hyper_state.HypervisorState.ONLINE.value}
+        self.solution.add_action(
+            action_type='change_nova_service_state',
+            resource_id=hypervisor.uuid,
+            input_parameters=params)
+        self.number_of_released_hypervisors -= 1
+
+    def add_action_deactivate_hypervisor(self, hypervisor):
+        """Add an action for hypervisor deactivation into the solution.
+
+        :param hypervisor: hypervisor object
+        :return: None
+        """
+        params = {'state': hyper_state.HypervisorState.OFFLINE.value}
+        self.solution.add_action(
+            action_type='change_nova_service_state',
+            resource_id=hypervisor.uuid,
+            input_parameters=params)
+        self.number_of_released_hypervisors += 1
+
+    def add_migration(self, vm_uuid, src_hypervisor,
+                      dst_hypervisor, model):
+        """Add an action for VM migration into the solution.
+
+        :param vm_uuid: vm uuid
+        :param src_hypervisor: hypervisor object
+        :param dst_hypervisor: hypervisor object
+        :param model: model_root object
+        :return: None
+        """
+        vm = model.get_vm_from_id(vm_uuid)
+
+        vm_state_str = self.get_state_str(vm.state)
+        if vm_state_str != vm_state.VMState.ACTIVE.value:
+            '''
+            Watcher curently only supports live VM migration and block live
+            VM migration which both requires migrated VM to be active.
+            When supported, the cold migration may be used as a fallback
+            migration mechanism to move non active VMs.
+            '''
+            LOG.error(_LE('Cannot live migrate: vm_uuid=%(vm_uuid)s, '
+                          'state=%(vm_state)s.'),
+                      vm_uuid=vm_uuid,
+                      vm_state=vm_state_str)
+            raise exception.WatcherException
+
+        migration_type = 'live'
+
+        dst_hyper_state_str = self.get_state_str(dst_hypervisor.state)
+        if dst_hyper_state_str == hyper_state.HypervisorState.OFFLINE.value:
+            self.add_action_activate_hypervisor(dst_hypervisor)
+        model.get_mapping().unmap(src_hypervisor, vm)
+        model.get_mapping().map(dst_hypervisor, vm)
+
+        params = {'migration_type': migration_type,
+                  'src_hypervisor': src_hypervisor.uuid,
+                  'dst_hypervisor': dst_hypervisor.uuid}
+        self.solution.add_action(action_type='migrate',
+                                 resource_id=vm.uuid,
+                                 input_parameters=params)
+        self.number_of_migrations += 1
+
+    def deactivate_unused_hypervisors(self, model):
+        """Generate actions for deactivation of unused hypervisors.
+
+        :param model: model_root object
+        :return: None
+        """
+        for hypervisor in model.get_all_hypervisors().values():
+            if len(model.get_mapping().get_node_vms(hypervisor)) == 0:
+                self.add_action_deactivate_hypervisor(hypervisor)
+
+    def get_prediction_model(self, model):
+        """Return a deepcopy of a model representing current cluster state.
+
+        :param model: model_root object
+        :return: model_root object
+        """
+        return deepcopy(model)
+
+    def get_vm_utilization(self, vm_uuid, model, period=3600, aggr='avg'):
+        """Collect cpu, ram and disk utilization statistics of a VM.
+
+        :param vm_uuid: vm object
+        :param model: model_root object
+        :param period: seconds
+        :param aggr: string
+        :return: dict(cpu(number of vcpus used), ram(MB used), disk(B used))
+        """
+        if vm_uuid in self.ceilometer_vm_data_cache.keys():
+            return self.ceilometer_vm_data_cache.get(vm_uuid)
+
+        cpu_util_metric = 'cpu_util'
+        ram_util_metric = 'memory.usage'
+
+        ram_alloc_metric = 'memory'
+        disk_alloc_metric = 'disk.root.size'
+        vm_cpu_util = self.ceilometer.statistic_aggregation(
+            resource_id=vm_uuid, meter_name=cpu_util_metric,
+            period=period, aggregate=aggr)
+        vm_cpu_cores = model.get_resource_from_id(
+            resource.ResourceType.cpu_cores).get_capacity(
+                model.get_vm_from_id(vm_uuid))
+
+        if vm_cpu_util:
+            total_cpu_utilization = vm_cpu_cores * (vm_cpu_util / 100.0)
+        else:
+            total_cpu_utilization = vm_cpu_cores
+
+        vm_ram_util = self.ceilometer.statistic_aggregation(
+            resource_id=vm_uuid, meter_name=ram_util_metric,
+            period=period, aggregate=aggr)
+
+        if not vm_ram_util:
+            vm_ram_util = self.ceilometer.statistic_aggregation(
+                resource_id=vm_uuid, meter_name=ram_alloc_metric,
+                period=period, aggregate=aggr)
+
+        vm_disk_util = self.ceilometer.statistic_aggregation(
+            resource_id=vm_uuid, meter_name=disk_alloc_metric,
+            period=period, aggregate=aggr)
+
+        if not vm_ram_util or not vm_disk_util:
+            LOG.error(
+                _LE('No values returned by %(resource_id)s '
+                    'for memory.usage or disk.root.size'),
+                resource_id=vm_uuid
+            )
+            raise exception.NoDataFound
+
+        self.ceilometer_vm_data_cache[vm_uuid] = dict(
+            cpu=total_cpu_utilization, ram=vm_ram_util, disk=vm_disk_util)
+        return self.ceilometer_vm_data_cache.get(vm_uuid)
+
+    def get_hypervisor_utilization(self, hypervisor, model, period=3600,
+                                   aggr='avg'):
+        """Collect cpu, ram and disk utilization statistics of a hypervisor.
+
+        :param hypervisor: hypervisor object
+        :param model: model_root object
+        :param period: seconds
+        :param aggr: string
+        :return: dict(cpu(number of cores used), ram(MB used), disk(B used))
+        """
+        hypervisor_vms = model.get_mapping().get_node_vms_from_id(
+            hypervisor.uuid)
+        hypervisor_ram_util = 0
+        hypervisor_disk_util = 0
+        hypervisor_cpu_util = 0
+        for vm_uuid in hypervisor_vms:
+            vm_util = self.get_vm_utilization(vm_uuid, model, period, aggr)
+            hypervisor_cpu_util += vm_util['cpu']
+            hypervisor_ram_util += vm_util['ram']
+            hypervisor_disk_util += vm_util['disk']
+
+        return dict(cpu=hypervisor_cpu_util, ram=hypervisor_ram_util,
+                    disk=hypervisor_disk_util)
+
+    def get_hypervisor_capacity(self, hypervisor, model):
+        """Collect cpu, ram and disk capacity of a hypervisor.
+
+        :param hypervisor: hypervisor object
+        :param model: model_root object
+        :return: dict(cpu(cores), ram(MB), disk(B))
+        """
+        hypervisor_cpu_capacity = model.get_resource_from_id(
+            resource.ResourceType.cpu_cores).get_capacity(hypervisor)
+
+        hypervisor_disk_capacity = model.get_resource_from_id(
+            resource.ResourceType.disk_capacity).get_capacity(hypervisor)
+
+        hypervisor_ram_capacity = model.get_resource_from_id(
+            resource.ResourceType.memory).get_capacity(hypervisor)
+        return dict(cpu=hypervisor_cpu_capacity, ram=hypervisor_ram_capacity,
+                    disk=hypervisor_disk_capacity)
+
+    def get_relative_hypervisor_utilization(self, hypervisor, model):
+        """Return relative hypervisor utilization (rhu).
+
+        :param hypervisor: hypervisor object
+        :param model: model_root object
+        :return: {'cpu': <0,1>, 'ram': <0,1>, 'disk': <0,1>}
+        """
+        rhu = {}
+        util = self.get_hypervisor_utilization(hypervisor, model)
+        cap = self.get_hypervisor_capacity(hypervisor, model)
+        for k in util.keys():
+            rhu[k] = float(util[k]) / float(cap[k])
+        return rhu
+
+    def get_relative_cluster_utilization(self, model):
+        """Calculate relative cluster utilization (rcu).
+
+        RCU is an average of relative utilizations (rhu) of active hypervisors.
+        :param model: model_root object
+        :return: {'cpu': <0,1>, 'ram': <0,1>, 'disk': <0,1>}
+        """
+        hypervisors = model.get_all_hypervisors().values()
+        rcu = {}
+        counters = {}
+        for hypervisor in hypervisors:
+            hyper_state_str = self.get_state_str(hypervisor.state)
+            if hyper_state_str == hyper_state.HypervisorState.ONLINE.value:
+                rhu = self.get_relative_hypervisor_utilization(
+                    hypervisor, model)
+                for k in rhu.keys():
+                    if k not in rcu:
+                        rcu[k] = 0
+                    if k not in counters:
+                        counters[k] = 0
+                    rcu[k] += rhu[k]
+                    counters[k] += 1
+        for k in rcu.keys():
+            rcu[k] /= counters[k]
+        return rcu
+
+    def is_overloaded(self, hypervisor, model, cc):
+        """Indicate whether a hypervisor is overloaded.
+
+        This considers provided resource capacity coefficients (cc).
+        :param hypervisor: hypervisor object
+        :param model: model_root object
+        :param cc: dictionary containing resource capacity coefficients
+        :return: [True, False]
+        """
+        hypervisor_capacity = self.get_hypervisor_capacity(hypervisor, model)
+        hypervisor_utilization = self.get_hypervisor_utilization(
+            hypervisor, model)
+        metrics = ['cpu']
+        for m in metrics:
+            if hypervisor_utilization[m] > hypervisor_capacity[m] * cc[m]:
+                return True
+        return False
+
+    def vm_fits(self, vm_uuid, hypervisor, model, cc):
+        """Indicate whether is a hypervisor able to accomodate a VM.
+
+        This considers provided resource capacity coefficients (cc).
+        :param vm_uuid: string
+        :param hypervisor: hypervisor object
+        :param model: model_root object
+        :param cc: dictionary containing resource capacity coefficients
+        :return: [True, False]
+        """
+        hypervisor_capacity = self.get_hypervisor_capacity(hypervisor, model)
+        hypervisor_utilization = self.get_hypervisor_utilization(
+            hypervisor, model)
+        vm_utilization = self.get_vm_utilization(vm_uuid, model)
+        metrics = ['cpu', 'ram', 'disk']
+        for m in metrics:
+            if (vm_utilization[m] + hypervisor_utilization[m] >
+                    hypervisor_capacity[m] * cc[m]):
+                return False
+        return True
+
+    def optimize_solution(self, model):
+        """Optimize solution.
+
+        This is done by eliminating unnecessary or circular set of migrations
+        which can be replaced by a more efficient solution.
+        e.g.:
+         * A->B, B->C => replace migrations A->B, B->C with
+           a single migration A->C as both solution result in
+           VM running on hypervisor C which can be achieved with
+           one migration instead of two.
+         * A->B, B->A => remove A->B and B->A as they do not result
+           in a new VM placement.
+
+        :param model: model_root object
+        """
+        migrate_actions = (
+            a for a in self.solution.actions if a[
+                'action_type'] == 'migrate')
+        vm_to_be_migrated = (a['input_parameters']['resource_id']
+                             for a in migrate_actions)
+        vm_uuids = list(set(vm_to_be_migrated))
+        for vm_uuid in vm_uuids:
+            actions = list(
+                a for a in self.solution.actions if a[
+                    'input_parameters'][
+                        'resource_id'] == vm_uuid)
+            if len(actions) > 1:
+                src = actions[0]['input_parameters']['src_hypervisor']
+                dst = actions[-1]['input_parameters']['dst_hypervisor']
+                for a in actions:
+                    self.solution.actions.remove(a)
+                    self.number_of_migrations -= 1
+                if src != dst:
+                    self.add_migration(vm_uuid, src, dst, model)
+
+    def offload_phase(self, model, cc):
+        """Perform offloading phase.
+
+        This considers provided resource capacity coefficients.
+        Offload phase performing first-fit based bin packing to offload
+        overloaded hypervisors. This is done in a fashion of moving
+        the least CPU utilized VM first as live migration these
+        generaly causes less troubles. This phase results in a cluster
+        with no overloaded hypervisors.
+        * This phase is be able to activate turned off hypervisors (if needed
+        and any available) in the case of the resource capacity provided by
+        active hypervisors is not able to accomodate all the load.
+        As the offload phase is later followed by the consolidation phase,
+        the hypervisor activation in this phase doesn't necessarily results
+        in more activated hypervisors in the final solution.
+
+        :param model: model_root object
+        :param cc: dictionary containing resource capacity coefficients
+        """
+        sorted_hypervisors = sorted(
+            model.get_all_hypervisors().values(),
+            key=lambda x: self.get_hypervisor_utilization(x, model)['cpu'])
+        for hypervisor in reversed(sorted_hypervisors):
+            if self.is_overloaded(hypervisor, model, cc):
+                for vm in sorted(model.get_mapping().get_node_vms(hypervisor),
+                                 key=lambda x: self.get_vm_utilization(
+                        x, model)['cpu']):
+                    for dst_hypervisor in reversed(sorted_hypervisors):
+                        if self.vm_fits(vm, dst_hypervisor, model, cc):
+                            self.add_migration(vm, hypervisor,
+                                               dst_hypervisor, model)
+                            break
+                    if not self.is_overloaded(hypervisor, model, cc):
+                        break
+
+    def consolidation_phase(self, model, cc):
+        """Perform consolidation phase.
+
+        This considers provided resource capacity coefficients.
+        Consolidation phase performing first-fit based bin packing.
+        First, hypervisors with the lowest cpu utilization are consolidated
+        by moving their load to hypervisors with the highest cpu utilization
+        which can accomodate the load. In this phase the most cpu utilizied
+        VMs are prioritizied as their load is more difficult to accomodate
+        in the system than less cpu utilizied VMs which can be later used
+        to fill smaller CPU capacity gaps.
+
+        :param model: model_root object
+        :param cc: dictionary containing resource capacity coefficients
+        """
+        sorted_hypervisors = sorted(
+            model.get_all_hypervisors().values(),
+            key=lambda x: self.get_hypervisor_utilization(x, model)['cpu'])
+        asc = 0
+        for hypervisor in sorted_hypervisors:
+            vms = sorted(model.get_mapping().get_node_vms(hypervisor),
+                         key=lambda x: self.get_vm_utilization(x,
+                                                               model)['cpu'])
+            for vm in reversed(vms):
+                dsc = len(sorted_hypervisors) - 1
+                for dst_hypervisor in reversed(sorted_hypervisors):
+                    if asc >= dsc:
+                        break
+                    if self.vm_fits(vm, dst_hypervisor, model, cc):
+                        self.add_migration(vm, hypervisor,
+                                           dst_hypervisor, model)
+                        break
+                    dsc -= 1
+            asc += 1
+
+    def execute(self, original_model):
+        """Execute strategy.
+
+        This strategy produces a solution resulting in more
+        efficient utilization of cluster resources using following
+        four phases:
+         * Offload phase - handling over-utilized resources
+         * Consolidation phase - handling under-utilized resources
+         * Solution optimization - reducing number of migrations
+         * Deactivation of unused hypervisors
+
+        :param original_model: root_model object
+        """
+        LOG.info(_LI('Executing Smart Strategy'))
+        model = self.get_prediction_model(original_model)
+        rcu = self.get_relative_cluster_utilization(model)
+        self.ceilometer_vm_data_cache = dict()
+
+        cc = {'cpu': 1.0, 'ram': 1.0, 'disk': 1.0}
+
+        # Offloading phase
+        self.offload_phase(model, cc)
+
+        # Consolidation phase
+        self.consolidation_phase(model, cc)
+
+        # Optimize solution
+        self.optimize_solution(model)
+
+        # Deactivate unused hypervisors
+        self.deactivate_unused_hypervisors(model)
+
+        rcu_after = self.get_relative_cluster_utilization(model)
+        info = {
+            'number_of_migrations': self.number_of_migrations,
+            'number_of_released_hypervisors':
+                self.number_of_released_hypervisors,
+            'relative_cluster_utilization_before': str(rcu),
+            'relative_cluster_utilization_after': str(rcu_after)
+        }
+
+        LOG.debug(info)
+
+        self.solution.model = model
+        self.solution.efficacy = rcu_after['cpu']
+
+        return self.solution

watcher/doc.py

@@ -17,21 +17,56 @@
 from __future__ import unicode_literals
 
 import importlib
+import inspect
 
 from docutils import nodes
 from docutils.parsers import rst
-from docutils import statemachine as sm
+from docutils import statemachine
+from stevedore import extension
 
 from watcher.version import version_info
 
-import textwrap
+
+class BaseWatcherDirective(rst.Directive):
+
+    def __init__(self, name, arguments, options, content, lineno,
+                 content_offset, block_text, state, state_machine):
+        super(BaseWatcherDirective, self).__init__(
+            name, arguments, options, content, lineno,
+            content_offset, block_text, state, state_machine)
+        self.result = statemachine.ViewList()
+
+    def run(self):
+        raise NotImplementedError('Must override run() is subclass.')
+
+    def add_line(self, line, *lineno):
+        """Append one line of generated reST to the output."""
+        self.result.append(line, rst.directives.unchanged, *lineno)
+
+    def add_textblock(self, textblock):
+        for line in textblock.splitlines():
+            self.add_line(line)
+
+    def add_object_docstring(self, obj):
+        obj_raw_docstring = obj.__doc__ or ""
+
+        # Maybe it's within the __init__
+        if not obj_raw_docstring and hasattr(obj, "__init__"):
+            if obj.__init__.__doc__:
+                obj_raw_docstring = obj.__init__.__doc__
+
+        if not obj_raw_docstring:
+            # Raise a warning to make the tests fail wit doc8
+            raise self.error("No docstring available for this plugin!")
+
+        obj_docstring = inspect.cleandoc(obj_raw_docstring)
+        self.add_textblock(obj_docstring)
 
 
-class WatcherTerm(rst.Directive):
+class WatcherTerm(BaseWatcherDirective):
     """Directive to import an RST formatted docstring into the Watcher glossary
 
-    How to use it
-    -------------
+    **How to use it**
 
     # inside your .py file
     class DocumentedObject(object):
@@ -47,17 +82,7 @@ class WatcherTerm(rst.Directive):
     # You need to put an import path as an argument for this directive to work
     required_arguments = 1
 
-    def add_textblock(self, textblock, *lineno):
-        for line in textblock.splitlines():
-            self.add_line(line)
-
-    def add_line(self, line, *lineno):
-        """Append one line of generated reST to the output."""
-        self.result.append(line, rst.directives.unchanged, *lineno)
-
     def run(self):
-        self.result = sm.ViewList()
-
         cls_path = self.arguments[0]
 
         try:
@@ -65,20 +90,82 @@ class WatcherTerm(rst.Directive):
         except Exception as exc:
             raise self.error(exc)
 
-        self.add_class_docstring(cls)
+        self.add_object_docstring(cls)
 
         node = nodes.paragraph()
         node.document = self.state.document
         self.state.nested_parse(self.result, 0, node)
         return node.children
 
-    def add_class_docstring(self, cls):
-        # Added 4 spaces to align the first line with the rest of the text
-        # to be able to dedent it correctly
-        cls_docstring = textwrap.dedent("%s%s" % (" " * 4, cls.__doc__))
-        self.add_textblock(cls_docstring)
+
+class DriversDoc(BaseWatcherDirective):
+    """Directive to import an RST formatted docstring into the Watcher doc
+
+    This directive imports the RST formatted docstring of every driver declared
+    within an entry point namespace provided as argument
+
+    **How to use it**
+
+    # inside your .py file
+    class DocumentedClassReferencedInEntrypoint(object):
+        '''My *.rst* docstring'''
+
+        def foo(self):
+            '''Foo docstring'''
+
+    # Inside your .rst file
+    .. drivers-doc:: entrypoint_namespace
+       :append_methods_doc: foo
+
+    This directive will then import the docstring and then interprete it.
+
+    Note that no section/sub-section can be imported via this directive as it
+    is a Sphinx restriction.
+    """
+
+    # You need to put an import path as an argument for this directive to work
+    required_arguments = 1
+    optional_arguments = 0
+    final_argument_whitespace = True
+    has_content = False
+
+    option_spec = dict(
+        # CSV formatted list of method names whose return values will be zipped
+        # together in the given order
+        append_methods_doc=lambda opts: [
+            opt.strip() for opt in opts.split(",") if opt.strip()],
+        # By default, we always start by adding the driver object docstring
+        exclude_driver_docstring=rst.directives.flag,
+    )
+
+    def run(self):
+        ext_manager = extension.ExtensionManager(namespace=self.arguments[0])
+        extensions = ext_manager.extensions
+        # Aggregates drivers based on their module name (i.e import path)
+        classes = [(ext.name, ext.plugin) for ext in extensions]
+
+        for name, cls in classes:
+            self.add_line(".. rubric:: %s" % name)
+            self.add_line("")
+
+            if "exclude_driver_docstring" not in self.options:
+                self.add_object_docstring(cls)
+                self.add_line("")
+
+            for method_name in self.options.get("append_methods_doc", []):
+                if hasattr(cls, method_name):
+                    method = getattr(cls, method_name)
+                    method_result = inspect.cleandoc(method)
+                    self.add_textblock(method_result())
+                    self.add_line("")
+
+        node = nodes.paragraph()
+        node.document = self.state.document
+        self.state.nested_parse(self.result, 0, node)
+        return node.children
 
 
 def setup(app):
+    app.add_directive('drivers-doc', DriversDoc)
     app.add_directive('watcher-term', WatcherTerm)
     return {'version': version_info.version_string()}

watcher/locale/fr/LC_MESSAGES/watcher.po

@@ -8,7 +8,7 @@ msgid ""
 msgstr ""
 "Project-Id-Version: python-watcher 0.21.1.dev32\n"
 "Report-Msgid-Bugs-To: EMAIL@ADDRESS\n"
-"POT-Creation-Date: 2016-01-19 17:54+0100\n"
+"POT-Creation-Date: 2016-02-09 09:07+0100\n"
 "PO-Revision-Date: 2015-12-11 15:42+0100\n"
 "Last-Translator: FULL NAME <EMAIL@ADDRESS>\n"
 "Language: fr\n"
@@ -24,25 +24,29 @@ msgstr ""
 msgid "Invalid state: %(state)s"
 msgstr "État invalide : %(state)s"
 
-#: watcher/api/controllers/v1/action_plan.py:418
+#: watcher/api/controllers/v1/action_plan.py:422
 #, python-format
 msgid "State transition not allowed: (%(initial_state)s -> %(new_state)s)"
 msgstr "Transition d'état non autorisée : (%(initial_state)s -> %(new_state)s)"
 
+#: watcher/api/controllers/v1/audit.py:359
+msgid "The audit template UUID or name specified is invalid"
+msgstr "Le nom ou UUID de l'audit template est invalide"
+
 #: watcher/api/controllers/v1/types.py:148
 #, python-format
 msgid "%s is not JSON serializable"
-msgstr ""
+msgstr "%s n'est pas sérialisable en JSON"
 
 #: watcher/api/controllers/v1/types.py:184
 #, python-format
 msgid "Wrong type. Expected '%(type)s', got '%(value)s'"
-msgstr ""
+msgstr "Type incorrect. '%(type)s' attendu, '%(value)s' obtenu"
 
 #: watcher/api/controllers/v1/types.py:223
 #, python-format
 msgid "'%s' is an internal attribute and can not be updated"
-msgstr ""
+msgstr "'%s' wat un attribut interne et ne peut pas être modifié"
 
 #: watcher/api/controllers/v1/types.py:227
 #, python-format
@@ -60,7 +64,7 @@ msgstr "Limit doit être positif"
 #: watcher/api/controllers/v1/utils.py:47
 #, python-format
 msgid "Invalid sort direction: %s. Acceptable values are 'asc' or 'desc'"
-msgstr ""
+msgstr "Ordre de tri invalide : %s. Les valeurs acceptées sont 'asc' or 'desc'"
 
 #: watcher/api/controllers/v1/utils.py:57
 #, python-format
@@ -69,33 +73,42 @@ msgstr ""
 
 #: watcher/api/middleware/auth_token.py:45
 msgid "Cannot compile public API routes"
-msgstr ""
+msgstr "Ne peut pas compiler les chemins d'API publique"
 
 #: watcher/api/middleware/parsable_error.py:52
 #, python-format
 msgid "ErrorDocumentMiddleware received an invalid status %s"
 msgstr ""
 
-#: watcher/api/middleware/parsable_error.py:80
+#: watcher/api/middleware/parsable_error.py:79
 #, python-format
 msgid "Error parsing HTTP response: %s"
 msgstr ""
 
-#: watcher/applier/actions/change_nova_service_state.py:58
+#: watcher/applier/actions/change_nova_service_state.py:69
 msgid "The target state is not defined"
 msgstr ""
 
-#: watcher/applier/workflow_engine/default.py:69
+#: watcher/applier/actions/migration.py:43
+msgid "The parameter resource_id is invalid."
+msgstr "Le paramètre resource_id est invalide"
+
+#: watcher/applier/actions/migration.py:86
+#, python-format
+msgid "Migration of type %(migration_type)s is not supported."
+msgstr ""
+
+#: watcher/applier/workflow_engine/default.py:128
 #, python-format
 msgid "The WorkFlow Engine has failed to execute the action %s"
 msgstr "Le moteur de workflow a echoué lors de l'éxécution de l'action %s"
 
-#: watcher/applier/workflow_engine/default.py:77
+#: watcher/applier/workflow_engine/default.py:146
 #, python-format
 msgid "Revert action %s"
 msgstr "Annulation de l'action %s"
 
-#: watcher/applier/workflow_engine/default.py:83
+#: watcher/applier/workflow_engine/default.py:152
 msgid "Oops! We need disaster recover plan"
 msgstr "Oops! Nous avons besoin d'un plan de reprise d'activité"
 
@@ -115,191 +128,210 @@ msgstr "Sert sur 0.0.0.0:%(port)s, accessible à http://127.0.0.1:%(port)s"
 msgid "serving on http://%(host)s:%(port)s"
 msgstr "Sert sur http://%(host)s:%(port)s"
 
-#: watcher/common/exception.py:56
+#: watcher/common/clients.py:29
+msgid "Version of Nova API to use in novaclient."
+msgstr ""
+
+#: watcher/common/clients.py:34
+msgid "Version of Glance API to use in glanceclient."
+msgstr ""
+
+#: watcher/common/clients.py:39
+msgid "Version of Cinder API to use in cinderclient."
+msgstr ""
+
+#: watcher/common/clients.py:44
+msgid "Version of Ceilometer API to use in ceilometerclient."
+msgstr ""
+
+#: watcher/common/clients.py:50
+msgid "Version of Neutron API to use in neutronclient."
+msgstr ""
+
+#: watcher/common/exception.py:59
+#, python-format
+msgid "Unexpected keystone client error occurred: %s"
+msgstr ""
+
+#: watcher/common/exception.py:72
 msgid "An unknown exception occurred"
 msgstr ""
 
-#: watcher/common/exception.py:77
+#: watcher/common/exception.py:92
 msgid "Exception in string format operation"
 msgstr ""
 
-#: watcher/common/exception.py:107
+#: watcher/common/exception.py:122
 msgid "Not authorized"
 msgstr ""
 
-#: watcher/common/exception.py:112
+#: watcher/common/exception.py:127
 msgid "Operation not permitted"
 msgstr ""
 
-#: watcher/common/exception.py:116
+#: watcher/common/exception.py:131
 msgid "Unacceptable parameters"
 msgstr ""
 
-#: watcher/common/exception.py:121
+#: watcher/common/exception.py:136
 #, python-format
 msgid "The %(name)s %(id)s could not be found"
 msgstr ""
 
-#: watcher/common/exception.py:125
+#: watcher/common/exception.py:140
 #, fuzzy
 msgid "Conflict"
-msgstr "Conflit."
+msgstr "Conflit"
 
-#: watcher/common/exception.py:130
+#: watcher/common/exception.py:145
 #, python-format
 msgid "The %(name)s resource %(id)s could not be found"
-msgstr ""
+msgstr "La ressource %(name)s / %(id)s est introuvable"
 
-#: watcher/common/exception.py:135
+#: watcher/common/exception.py:150
 #, python-format
 msgid "Expected an uuid or int but received %(identity)s"
 msgstr ""
 
-#: watcher/common/exception.py:139
+#: watcher/common/exception.py:154
 #, python-format
 msgid "Goal %(goal)s is not defined in Watcher configuration file"
 msgstr ""
 
-#: watcher/common/exception.py:145
-#, python-format
-msgid "%(err)s"
-msgstr ""
-
-#: watcher/common/exception.py:149
+#: watcher/common/exception.py:158
 #, python-format
 msgid "Expected a uuid but received %(uuid)s"
 msgstr ""
 
-#: watcher/common/exception.py:153
+#: watcher/common/exception.py:162
 #, python-format
 msgid "Expected a logical name but received %(name)s"
 msgstr ""
 
-#: watcher/common/exception.py:157
+#: watcher/common/exception.py:166
 #, python-format
 msgid "Expected a logical name or uuid but received %(name)s"
 msgstr ""
 
-#: watcher/common/exception.py:161
+#: watcher/common/exception.py:170
 #, python-format
 msgid "AuditTemplate %(audit_template)s could not be found"
 msgstr ""
 
-#: watcher/common/exception.py:165
+#: watcher/common/exception.py:174
 #, python-format
 msgid "An audit_template with UUID %(uuid)s or name %(name)s already exists"
 msgstr ""
 
-#: watcher/common/exception.py:170
+#: watcher/common/exception.py:179
 #, python-format
 msgid "AuditTemplate %(audit_template)s is referenced by one or multiple audit"
 msgstr ""
 
-#: watcher/common/exception.py:175
+#: watcher/common/exception.py:184
 #, python-format
 msgid "Audit %(audit)s could not be found"
 msgstr ""
 
-#: watcher/common/exception.py:179
+#: watcher/common/exception.py:188
 #, python-format
 msgid "An audit with UUID %(uuid)s already exists"
 msgstr ""
 
-#: watcher/common/exception.py:183
+#: watcher/common/exception.py:192
 #, python-format
 msgid "Audit %(audit)s is referenced by one or multiple action plans"
 msgstr ""
 
-#: watcher/common/exception.py:188
-msgid "ActionPlan %(action plan)s could not be found"
-msgstr ""
-
-#: watcher/common/exception.py:192
+#: watcher/common/exception.py:197
 #, python-format
-msgid "An action plan with UUID %(uuid)s already exists"
-msgstr ""
-
-#: watcher/common/exception.py:196
-#, python-format
-msgid "Action Plan %(action_plan)s is referenced by one or multiple actions"
+msgid "ActionPlan %(action_plan)s could not be found"
 msgstr ""
 
 #: watcher/common/exception.py:201
 #, python-format
-msgid "Action %(action)s could not be found"
+msgid "An action plan with UUID %(uuid)s already exists"
 msgstr ""
 
 #: watcher/common/exception.py:205
 #, python-format
+msgid "Action Plan %(action_plan)s is referenced by one or multiple actions"
+msgstr ""
+
+#: watcher/common/exception.py:210
+#, python-format
+msgid "Action %(action)s could not be found"
+msgstr ""
+
+#: watcher/common/exception.py:214
+#, python-format
 msgid "An action with UUID %(uuid)s already exists"
 msgstr ""
 
-#: watcher/common/exception.py:209
+#: watcher/common/exception.py:218
 #, python-format
 msgid "Action plan %(action_plan)s is referenced by one or multiple goals"
 msgstr ""
 
-#: watcher/common/exception.py:214
+#: watcher/common/exception.py:223
 msgid "Filtering actions on both audit and action-plan is prohibited"
 msgstr ""
 
-#: watcher/common/exception.py:223
+#: watcher/common/exception.py:232
 #, python-format
 msgid "Couldn't apply patch '%(patch)s'. Reason: %(reason)s"
 msgstr ""
 
-#: watcher/common/exception.py:233
-msgid "Description must be an instance of str"
+#: watcher/common/exception.py:239
+msgid "Illegal argument"
 msgstr ""
 
 #: watcher/common/exception.py:243
-msgid "An exception occurred without a description"
-msgstr ""
-
-#: watcher/common/exception.py:251
-msgid "Description cannot be empty"
-msgstr ""
-
-#: watcher/common/exception.py:260
 msgid "No such metric"
 msgstr ""
 
-#: watcher/common/exception.py:269
+#: watcher/common/exception.py:247
 msgid "No rows were returned"
 msgstr ""
 
-#: watcher/common/exception.py:277
+#: watcher/common/exception.py:251
+#, python-format
+msgid "%(client)s connection failed. Reason: %(reason)s"
+msgstr ""
+
+#: watcher/common/exception.py:255
 msgid "'Keystone API endpoint is missing''"
 msgstr ""
 
-#: watcher/common/exception.py:281
+#: watcher/common/exception.py:259
 msgid "The list of hypervisor(s) in the cluster is empty"
 msgstr ""
 
-#: watcher/common/exception.py:285
+#: watcher/common/exception.py:263
 msgid "The metrics resource collector is not defined"
 msgstr ""
 
-#: watcher/common/exception.py:289
+#: watcher/common/exception.py:267
 msgid "the cluster state is not defined"
 msgstr ""
 
-#: watcher/common/exception.py:295
+#: watcher/common/exception.py:273
 #, python-format
 msgid "The instance '%(name)s' is not found"
 msgstr "L'instance '%(name)s' n'a pas été trouvée"
 
-#: watcher/common/exception.py:299
+#: watcher/common/exception.py:277
 msgid "The hypervisor is not found"
 msgstr ""
 
-#: watcher/common/exception.py:303
+#: watcher/common/exception.py:281
 #, fuzzy, python-format
 msgid "Error loading plugin '%(name)s'"
 msgstr "Erreur lors du chargement du module '%(name)s'"
 
-#: watcher/common/keystone.py:59
-msgid "No Keystone service catalog loaded"
+#: watcher/common/exception.py:285
+#, fuzzy, python-format
+msgid "The identifier '%(name)s' is a reserved word"
 msgstr ""
 
 #: watcher/common/service.py:83
@@ -332,7 +364,7 @@ msgstr ""
 #: watcher/common/utils.py:53
 #, python-format
 msgid ""
-"Failed to remove trailing character. Returning original object. Supplied "
+"Failed to remove trailing character. Returning original object.Supplied "
 "object is not a string: %s,"
 msgstr ""
 
@@ -350,18 +382,22 @@ msgid ""
 "template uuid instead"
 msgstr ""
 
-#: watcher/db/sqlalchemy/api.py:277
-msgid "Cannot overwrite UUID for an existing AuditTemplate."
+#: watcher/db/sqlalchemy/api.py:278
+msgid "Cannot overwrite UUID for an existing Audit Template."
 msgstr ""
 
-#: watcher/db/sqlalchemy/api.py:386 watcher/db/sqlalchemy/api.py:586
+#: watcher/db/sqlalchemy/api.py:388
 msgid "Cannot overwrite UUID for an existing Audit."
 msgstr ""
 
-#: watcher/db/sqlalchemy/api.py:477
+#: watcher/db/sqlalchemy/api.py:480
 msgid "Cannot overwrite UUID for an existing Action."
 msgstr ""
 
+#: watcher/db/sqlalchemy/api.py:590
+msgid "Cannot overwrite UUID for an existing Action Plan."
+msgstr ""
+
 #: watcher/db/sqlalchemy/migration.py:73
 msgid ""
 "Watcher database schema is already under version control; use upgrade() "
@@ -373,44 +409,44 @@ msgstr ""
 msgid "'obj' argument type is not valid"
 msgstr ""
 
-#: watcher/decision_engine/planner/default.py:75
+#: watcher/decision_engine/planner/default.py:72
 msgid "The action plan is empty"
 msgstr ""
 
-#: watcher/decision_engine/strategy/selection/default.py:59
+#: watcher/decision_engine/strategy/selection/default.py:60
 #, python-format
 msgid "Incorrect mapping: could not find associated strategy for '%s'"
 msgstr ""
 
-#: watcher/decision_engine/strategy/strategies/basic_consolidation.py:267
-#: watcher/decision_engine/strategy/strategies/basic_consolidation.py:314
+#: watcher/decision_engine/strategy/strategies/basic_consolidation.py:269
+#: watcher/decision_engine/strategy/strategies/basic_consolidation.py:316
 #, python-format
 msgid "No values returned by %(resource_id)s for %(metric_name)s"
 msgstr ""
 
-#: watcher/decision_engine/strategy/strategies/basic_consolidation.py:349
+#: watcher/decision_engine/strategy/strategies/basic_consolidation.py:426
 msgid "Initializing Sercon Consolidation"
 msgstr ""
 
-#: watcher/decision_engine/strategy/strategies/basic_consolidation.py:406
+#: watcher/decision_engine/strategy/strategies/basic_consolidation.py:470
 msgid "The workloads of the compute nodes of the cluster is zero"
 msgstr ""
 
-#: watcher/decision_engine/strategy/strategies/outlet_temp_control.py:125
+#: watcher/decision_engine/strategy/strategies/outlet_temp_control.py:127
 #, python-format
 msgid "%s: no outlet temp data"
 msgstr ""
 
-#: watcher/decision_engine/strategy/strategies/outlet_temp_control.py:149
+#: watcher/decision_engine/strategy/strategies/outlet_temp_control.py:151
 #, python-format
 msgid "VM not active, skipped: %s"
 msgstr ""
 
-#: watcher/decision_engine/strategy/strategies/outlet_temp_control.py:206
+#: watcher/decision_engine/strategy/strategies/outlet_temp_control.py:208
 msgid "No hosts under outlet temp threshold found"
 msgstr ""
 
-#: watcher/decision_engine/strategy/strategies/outlet_temp_control.py:229
+#: watcher/decision_engine/strategy/strategies/outlet_temp_control.py:231
 msgid "No proper target host could be found"
 msgstr ""
 
@@ -573,3 +609,32 @@ msgstr ""
 #~ msgid "The WorkFlow Engine has failedto execute the action %s"
 #~ msgstr ""
 
+#~ msgid "ActionPlan %(action plan)s could not be found"
+#~ msgstr ""
+
+#~ msgid "Description must be an instance of str"
+#~ msgstr ""
+
+#~ msgid "An exception occurred without a description"
+#~ msgstr ""
+
+#~ msgid "Description cannot be empty"
+#~ msgstr ""
+
+#~ msgid "The hypervisor state is invalid."
+#~ msgstr "L'état de l'hyperviseur est invalide"
+
+#~ msgid "%(err)s"
+#~ msgstr "%(err)s"
+
+#~ msgid "No Keystone service catalog loaded"
+#~ msgstr ""
+
+#~ msgid "Cannot overwrite UUID for an existing AuditTemplate."
+#~ msgstr ""
+
+#~ msgid ""
+#~ "This identifier is reserved word and "
+#~ "cannot be used as variables '%(name)s'"
+#~ msgstr ""
+

watcher/locale/watcher.pot

@@ -7,23 +7,35 @@
 #, fuzzy
 msgid ""
 msgstr ""
-"Project-Id-Version: python-watcher 0.22.1.dev49\n"
+"Project-Id-Version: python-watcher 0.25.1.dev3\n"
 "Report-Msgid-Bugs-To: EMAIL@ADDRESS\n"
-"POT-Creation-Date: 2016-01-22 10:43+0100\n"
+"POT-Creation-Date: 2016-03-30 10:10+0200\n"
 "PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
 "Last-Translator: FULL NAME <EMAIL@ADDRESS>\n"
 "Language-Team: LANGUAGE <LL@li.org>\n"
 "MIME-Version: 1.0\n"
 "Content-Type: text/plain; charset=utf-8\n"
 "Content-Transfer-Encoding: 8bit\n"
-"Generated-By: Babel 2.1.1\n"
+"Generated-By: Babel 2.2.0\n"
+
+#: watcher/api/controllers/v1/action.py:364
+msgid "Cannot create an action directly"
+msgstr ""
+
+#: watcher/api/controllers/v1/action.py:388
+msgid "Cannot modify an action directly"
+msgstr ""
+
+#: watcher/api/controllers/v1/action.py:424
+msgid "Cannot delete an action directly"
+msgstr ""
 
 #: watcher/api/controllers/v1/action_plan.py:102
 #, python-format
 msgid "Invalid state: %(state)s"
 msgstr ""
 
-#: watcher/api/controllers/v1/action_plan.py:416
+#: watcher/api/controllers/v1/action_plan.py:422
 #, python-format
 msgid "State transition not allowed: (%(initial_state)s -> %(new_state)s)"
 msgstr ""
@@ -65,7 +77,12 @@ msgstr ""
 msgid "Invalid sort direction: %s. Acceptable values are 'asc' or 'desc'"
 msgstr ""
 
-#: watcher/api/controllers/v1/utils.py:57
+#: watcher/api/controllers/v1/utils.py:58
+#, python-format
+msgid "Invalid filter: %s"
+msgstr ""
+
+#: watcher/api/controllers/v1/utils.py:65
 #, python-format
 msgid "Adding a new attribute (%s) to the root of  the resource is not allowed"
 msgstr ""
@@ -84,21 +101,37 @@ msgstr ""
 msgid "Error parsing HTTP response: %s"
 msgstr ""
 
-#: watcher/applier/actions/change_nova_service_state.py:58
+#: watcher/applier/actions/change_nova_service_state.py:90
 msgid "The target state is not defined"
 msgstr ""
 
-#: watcher/applier/workflow_engine/default.py:126
+#: watcher/applier/actions/migration.py:71
+msgid "The parameter resource_id is invalid."
+msgstr ""
+
+#: watcher/applier/actions/migration.py:124
+#, python-format
+msgid ""
+"Unexpected error occured. Migration failed forinstance %s. Leaving "
+"instance on previous host."
+msgstr ""
+
+#: watcher/applier/actions/migration.py:140
+#, python-format
+msgid "Migration of type %(migration_type)s is not supported."
+msgstr ""
+
+#: watcher/applier/workflow_engine/default.py:129
 #, python-format
 msgid "The WorkFlow Engine has failed to execute the action %s"
 msgstr ""
 
-#: watcher/applier/workflow_engine/default.py:144
+#: watcher/applier/workflow_engine/default.py:147
 #, python-format
 msgid "Revert action %s"
 msgstr ""
 
-#: watcher/applier/workflow_engine/default.py:150
+#: watcher/applier/workflow_engine/default.py:153
 msgid "Oops! We need disaster recover plan"
 msgstr ""
 
@@ -118,182 +151,223 @@ msgstr ""
 msgid "serving on http://%(host)s:%(port)s"
 msgstr ""
 
-#: watcher/common/exception.py:51
+#: watcher/common/clients.py:29
+msgid "Version of Nova API to use in novaclient."
+msgstr ""
+
+#: watcher/common/clients.py:34
+msgid "Version of Glance API to use in glanceclient."
+msgstr ""
+
+#: watcher/common/clients.py:39
+msgid "Version of Cinder API to use in cinderclient."
+msgstr ""
+
+#: watcher/common/clients.py:44
+msgid "Version of Ceilometer API to use in ceilometerclient."
+msgstr ""
+
+#: watcher/common/clients.py:50
+msgid "Version of Neutron API to use in neutronclient."
+msgstr ""
+
+#: watcher/common/exception.py:59
+#, python-format
+msgid "Unexpected keystone client error occurred: %s"
+msgstr ""
+
+#: watcher/common/exception.py:72
 msgid "An unknown exception occurred"
 msgstr ""
 
-#: watcher/common/exception.py:71
+#: watcher/common/exception.py:92
 msgid "Exception in string format operation"
 msgstr ""
 
-#: watcher/common/exception.py:101
+#: watcher/common/exception.py:122
 msgid "Not authorized"
 msgstr ""
 
-#: watcher/common/exception.py:106
+#: watcher/common/exception.py:127
 msgid "Operation not permitted"
 msgstr ""
 
-#: watcher/common/exception.py:110
+#: watcher/common/exception.py:131
 msgid "Unacceptable parameters"
 msgstr ""
 
-#: watcher/common/exception.py:115
+#: watcher/common/exception.py:136
 #, python-format
 msgid "The %(name)s %(id)s could not be found"
 msgstr ""
 
-#: watcher/common/exception.py:119
+#: watcher/common/exception.py:140
 msgid "Conflict"
 msgstr ""
 
-#: watcher/common/exception.py:124
+#: watcher/common/exception.py:145
 #, python-format
 msgid "The %(name)s resource %(id)s could not be found"
 msgstr ""
 
-#: watcher/common/exception.py:129
+#: watcher/common/exception.py:150
 #, python-format
 msgid "Expected an uuid or int but received %(identity)s"
 msgstr ""
 
-#: watcher/common/exception.py:133
+#: watcher/common/exception.py:154
 #, python-format
 msgid "Goal %(goal)s is not defined in Watcher configuration file"
 msgstr ""
 
-#: watcher/common/exception.py:139
-#, python-format
-msgid "%(err)s"
-msgstr ""
-
-#: watcher/common/exception.py:143
+#: watcher/common/exception.py:158
 #, python-format
 msgid "Expected a uuid but received %(uuid)s"
 msgstr ""
 
-#: watcher/common/exception.py:147
+#: watcher/common/exception.py:162
 #, python-format
 msgid "Expected a logical name but received %(name)s"
 msgstr ""
 
-#: watcher/common/exception.py:151
+#: watcher/common/exception.py:166
 #, python-format
 msgid "Expected a logical name or uuid but received %(name)s"
 msgstr ""
 
-#: watcher/common/exception.py:155
+#: watcher/common/exception.py:170
 #, python-format
 msgid "AuditTemplate %(audit_template)s could not be found"
 msgstr ""
 
-#: watcher/common/exception.py:159
+#: watcher/common/exception.py:174
 #, python-format
 msgid "An audit_template with UUID %(uuid)s or name %(name)s already exists"
 msgstr ""
 
-#: watcher/common/exception.py:164
+#: watcher/common/exception.py:179
 #, python-format
 msgid "AuditTemplate %(audit_template)s is referenced by one or multiple audit"
 msgstr ""
 
-#: watcher/common/exception.py:169
+#: watcher/common/exception.py:184
 #, python-format
 msgid "Audit %(audit)s could not be found"
 msgstr ""
 
-#: watcher/common/exception.py:173
+#: watcher/common/exception.py:188
 #, python-format
 msgid "An audit with UUID %(uuid)s already exists"
 msgstr ""
 
-#: watcher/common/exception.py:177
+#: watcher/common/exception.py:192
 #, python-format
 msgid "Audit %(audit)s is referenced by one or multiple action plans"
 msgstr ""
 
-#: watcher/common/exception.py:182
-msgid "ActionPlan %(action plan)s could not be found"
+#: watcher/common/exception.py:197
+#, python-format
+msgid "ActionPlan %(action_plan)s could not be found"
 msgstr ""
 
-#: watcher/common/exception.py:186
+#: watcher/common/exception.py:201
 #, python-format
 msgid "An action plan with UUID %(uuid)s already exists"
 msgstr ""
 
-#: watcher/common/exception.py:190
+#: watcher/common/exception.py:205
 #, python-format
 msgid "Action Plan %(action_plan)s is referenced by one or multiple actions"
 msgstr ""
 
-#: watcher/common/exception.py:195
+#: watcher/common/exception.py:210
 #, python-format
 msgid "Action %(action)s could not be found"
 msgstr ""
 
-#: watcher/common/exception.py:199
+#: watcher/common/exception.py:214
 #, python-format
 msgid "An action with UUID %(uuid)s already exists"
 msgstr ""
 
-#: watcher/common/exception.py:203
+#: watcher/common/exception.py:218
 #, python-format
 msgid "Action plan %(action_plan)s is referenced by one or multiple goals"
 msgstr ""
 
-#: watcher/common/exception.py:208
+#: watcher/common/exception.py:223
 msgid "Filtering actions on both audit and action-plan is prohibited"
 msgstr ""
 
-#: watcher/common/exception.py:217
+#: watcher/common/exception.py:232
 #, python-format
 msgid "Couldn't apply patch '%(patch)s'. Reason: %(reason)s"
 msgstr ""
 
-#: watcher/common/exception.py:224
+#: watcher/common/exception.py:238
+#, python-format
+msgid "Workflow execution error: %(error)s"
+msgstr ""
+
+#: watcher/common/exception.py:242
 msgid "Illegal argument"
 msgstr ""
 
-#: watcher/common/exception.py:228
+#: watcher/common/exception.py:246
 msgid "No such metric"
 msgstr ""
 
-#: watcher/common/exception.py:232
+#: watcher/common/exception.py:250
 msgid "No rows were returned"
 msgstr ""
 
-#: watcher/common/exception.py:236
-msgid "'Keystone API endpoint is missing''"
-msgstr ""
-
-#: watcher/common/exception.py:240
-msgid "The list of hypervisor(s) in the cluster is empty"
-msgstr ""
-
-#: watcher/common/exception.py:244
-msgid "The metrics resource collector is not defined"
-msgstr ""
-
-#: watcher/common/exception.py:248
-msgid "the cluster state is not defined"
-msgstr ""
-
 #: watcher/common/exception.py:254
 #, python-format
-msgid "The instance '%(name)s' is not found"
+msgid "%(client)s connection failed. Reason: %(reason)s"
 msgstr ""
 
 #: watcher/common/exception.py:258
-msgid "The hypervisor is not found"
+msgid "'Keystone API endpoint is missing''"
 msgstr ""
 
 #: watcher/common/exception.py:262
+msgid "The list of hypervisor(s) in the cluster is empty"
+msgstr ""
+
+#: watcher/common/exception.py:266
+msgid "The metrics resource collector is not defined"
+msgstr ""
+
+#: watcher/common/exception.py:270
+msgid "the cluster state is not defined"
+msgstr ""
+
+#: watcher/common/exception.py:276
+#, python-format
+msgid "The instance '%(name)s' is not found"
+msgstr ""
+
+#: watcher/common/exception.py:280
+msgid "The hypervisor is not found"
+msgstr ""
+
+#: watcher/common/exception.py:284
 #, python-format
 msgid "Error loading plugin '%(name)s'"
 msgstr ""
 
-#: watcher/common/keystone.py:59
-msgid "No Keystone service catalog loaded"
+#: watcher/common/exception.py:288
+#, python-format
+msgid "The identifier '%(name)s' is a reserved word"
+msgstr ""
+
+#: watcher/common/exception.py:292
+#, python-format
+msgid "The %(name)s resource %(id)s is not soft deleted"
+msgstr ""
+
+#: watcher/common/exception.py:296
+msgid "Limit should be positive"
 msgstr ""
 
 #: watcher/common/service.py:83
@@ -338,24 +412,105 @@ msgstr ""
 msgid "Messaging configuration error"
 msgstr ""
 
-#: watcher/db/sqlalchemy/api.py:256
+#: watcher/db/purge.py:50
+msgid "Audit Templates"
+msgstr ""
+
+#: watcher/db/purge.py:51
+msgid "Audits"
+msgstr ""
+
+#: watcher/db/purge.py:52
+msgid "Action Plans"
+msgstr ""
+
+#: watcher/db/purge.py:53
+msgid "Actions"
+msgstr ""
+
+#: watcher/db/purge.py:100
+msgid "Total"
+msgstr ""
+
+#: watcher/db/purge.py:158
+msgid "Audit Template"
+msgstr ""
+
+#: watcher/db/purge.py:206
+#, python-format
+msgid ""
+"Orphans found:\n"
+"%s"
+msgstr ""
+
+#: watcher/db/purge.py:265
+#, python-format
+msgid "There are %(count)d objects set for deletion. Continue? [y/N]"
+msgstr ""
+
+#: watcher/db/purge.py:272
+#, python-format
+msgid ""
+"The number of objects (%(num)s) to delete from the database exceeds the "
+"maximum number of objects (%(max_number)s) specified."
+msgstr ""
+
+#: watcher/db/purge.py:277
+msgid "Do you want to delete objects up to the specified maximum number? [y/N]"
+msgstr ""
+
+#: watcher/db/purge.py:340
+msgid "Deleting..."
+msgstr ""
+
+#: watcher/db/purge.py:346
+msgid "Starting purge command"
+msgstr ""
+
+#: watcher/db/purge.py:356
+msgid " (orphans excluded)"
+msgstr ""
+
+#: watcher/db/purge.py:357
+msgid " (may include orphans)"
+msgstr ""
+
+#: watcher/db/purge.py:360 watcher/db/purge.py:361
+#, python-format
+msgid "Purge results summary%s:"
+msgstr ""
+
+#: watcher/db/purge.py:364
+#, python-format
+msgid "Here below is a table containing the objects that can be purged%s:"
+msgstr ""
+
+#: watcher/db/purge.py:369
+msgid "Purge process completed"
+msgstr ""
+
+#: watcher/db/sqlalchemy/api.py:362
 msgid ""
 "Multiple audit templates exist with the same name. Please use the audit "
 "template uuid instead"
 msgstr ""
 
-#: watcher/db/sqlalchemy/api.py:277
-msgid "Cannot overwrite UUID for an existing AuditTemplate."
+#: watcher/db/sqlalchemy/api.py:384
+msgid "Cannot overwrite UUID for an existing Audit Template."
 msgstr ""
 
-#: watcher/db/sqlalchemy/api.py:386 watcher/db/sqlalchemy/api.py:586
+#: watcher/db/sqlalchemy/api.py:495
 msgid "Cannot overwrite UUID for an existing Audit."
 msgstr ""
 
-#: watcher/db/sqlalchemy/api.py:477
+#: watcher/db/sqlalchemy/api.py:588
 msgid "Cannot overwrite UUID for an existing Action."
 msgstr ""
 
+#: watcher/db/sqlalchemy/api.py:699
+msgid "Cannot overwrite UUID for an existing Action Plan."
+msgstr ""
+
 #: watcher/db/sqlalchemy/migration.py:73
 msgid ""
 "Watcher database schema is already under version control; use upgrade() "
@@ -367,47 +522,66 @@ msgstr ""
 msgid "'obj' argument type is not valid"
 msgstr ""
 
-#: watcher/decision_engine/planner/default.py:76
+#: watcher/decision_engine/planner/default.py:79
 msgid "The action plan is empty"
 msgstr ""
 
-#: watcher/decision_engine/strategy/selection/default.py:59
+#: watcher/decision_engine/strategy/selection/default.py:60
 #, python-format
 msgid "Incorrect mapping: could not find associated strategy for '%s'"
 msgstr ""
 
-#: watcher/decision_engine/strategy/strategies/basic_consolidation.py:267
-#: watcher/decision_engine/strategy/strategies/basic_consolidation.py:314
+#: watcher/decision_engine/strategy/strategies/basic_consolidation.py:288
+#: watcher/decision_engine/strategy/strategies/basic_consolidation.py:335
 #, python-format
 msgid "No values returned by %(resource_id)s for %(metric_name)s"
 msgstr ""
 
-#: watcher/decision_engine/strategy/strategies/basic_consolidation.py:424
+#: watcher/decision_engine/strategy/strategies/basic_consolidation.py:448
 msgid "Initializing Sercon Consolidation"
 msgstr ""
 
-#: watcher/decision_engine/strategy/strategies/basic_consolidation.py:468
+#: watcher/decision_engine/strategy/strategies/basic_consolidation.py:492
 msgid "The workloads of the compute nodes of the cluster is zero"
 msgstr ""
 
-#: watcher/decision_engine/strategy/strategies/outlet_temp_control.py:125
+#: watcher/decision_engine/strategy/strategies/outlet_temp_control.py:147
 #, python-format
 msgid "%s: no outlet temp data"
 msgstr ""
 
-#: watcher/decision_engine/strategy/strategies/outlet_temp_control.py:149
+#: watcher/decision_engine/strategy/strategies/outlet_temp_control.py:172
 #, python-format
 msgid "VM not active, skipped: %s"
 msgstr ""
 
-#: watcher/decision_engine/strategy/strategies/outlet_temp_control.py:206
+#: watcher/decision_engine/strategy/strategies/outlet_temp_control.py:230
 msgid "No hosts under outlet temp threshold found"
 msgstr ""
 
-#: watcher/decision_engine/strategy/strategies/outlet_temp_control.py:229
+#: watcher/decision_engine/strategy/strategies/outlet_temp_control.py:253
 msgid "No proper target host could be found"
 msgstr ""
 
+#: watcher/decision_engine/strategy/strategies/vm_workload_consolidation.py:104
+#, python-format
+msgid "Unexpexted resource state type, state=%(state)s, state_type=%(st)s."
+msgstr ""
+
+#: watcher/decision_engine/strategy/strategies/vm_workload_consolidation.py:156
+#, python-format
+msgid "Cannot live migrate: vm_uuid=%(vm_uuid)s, state=%(vm_state)s."
+msgstr ""
+
+#: watcher/decision_engine/strategy/strategies/vm_workload_consolidation.py:240
+#, python-format
+msgid "No values returned by %(resource_id)s for memory.usage or disk.root.size"
+msgstr ""
+
+#: watcher/decision_engine/strategy/strategies/vm_workload_consolidation.py:489
+msgid "Executing Smart Strategy"
+msgstr ""
+
 #: watcher/objects/base.py:70
 #, python-format
 msgid "Error setting %(attr)s"

watcher/metrics_engine/cluster_history/ceilometer.py

@@ -20,17 +20,19 @@
 
 from oslo_config import cfg
 from oslo_log import log
-from watcher.common.ceilometer import CeilometerClient
+from watcher.common import ceilometer_helper
 
-from watcher.metrics_engine.cluster_history.api import BaseClusterHistory
+from watcher.metrics_engine.cluster_history import base
 
 CONF = cfg.CONF
 LOG = log.getLogger(__name__)
 
 
-class CeilometerClusterHistory(BaseClusterHistory):
-    def __init__(self):
-        self.ceilometer = CeilometerClient()
+class CeilometerClusterHistory(base.BaseClusterHistory):
+    def __init__(self, osc=None):
+        """:param osc: an OpenStackClients instance"""
+        super(CeilometerClusterHistory, self).__init__()
+        self.ceilometer = ceilometer_helper.CeilometerHelper(osc=osc)
 
     def statistic_list(self, meter_name, query=None, period=None):
         return self.ceilometer.statistic_list(meter_name, query, period)

watcher/metrics_engine/cluster_model_collector/manager.py

@@ -20,18 +20,16 @@
 from oslo_config import cfg
 from oslo_log import log
 
-from watcher.common.keystone import KeystoneClient
-from watcher.common.nova import NovaClient
-from watcher.metrics_engine.cluster_model_collector.nova import \
-    NovaClusterModelCollector
+from watcher.common import nova_helper
+from watcher.metrics_engine.cluster_model_collector import nova as cnova
+
 
 LOG = log.getLogger(__name__)
 CONF = cfg.CONF
 
 
 class CollectorManager(object):
-    def get_cluster_model_collector(self):
-        keystone = KeystoneClient()
-        wrapper = NovaClient(keystone.get_credentials(),
-                             session=keystone.get_session())
-        return NovaClusterModelCollector(wrapper=wrapper)
+    def get_cluster_model_collector(self, osc=None):
+        """:param osc: an OpenStackClients instance"""
+        nova = nova_helper.NovaHelper(osc=osc)
+        return cnova.NovaClusterModelCollector(nova)

watcher/metrics_engine/cluster_model_collector/nova.py

@@ -17,47 +17,47 @@
 # limitations under the License.
 #
 
-
-from oslo_config import cfg
 from oslo_log import log
 
-from watcher.decision_engine.model.hypervisor import Hypervisor
-from watcher.decision_engine.model.model_root import ModelRoot
-from watcher.decision_engine.model.resource import Resource
-from watcher.decision_engine.model.resource import ResourceType
-from watcher.decision_engine.model.vm import VM
-from watcher.metrics_engine.cluster_model_collector.api import \
-    BaseClusterModelCollector
+from watcher.decision_engine.model import hypervisor as obj_hypervisor
+from watcher.decision_engine.model import model_root
+from watcher.decision_engine.model import resource
+from watcher.decision_engine.model import vm as obj_vm
+from watcher.metrics_engine.cluster_model_collector import base
 
-CONF = cfg.CONF
 LOG = log.getLogger(__name__)
 
 
-class NovaClusterModelCollector(BaseClusterModelCollector):
+class NovaClusterModelCollector(base.BaseClusterModelCollector):
     def __init__(self, wrapper):
+        super(NovaClusterModelCollector, self).__init__()
         self.wrapper = wrapper
 
     def get_latest_cluster_data_model(self):
+        LOG.debug("Getting latest cluster data model")
 
-        cluster = ModelRoot()
-        mem = Resource(ResourceType.memory)
-        num_cores = Resource(ResourceType.cpu_cores)
-        disk = Resource(ResourceType.disk)
+        cluster = model_root.ModelRoot()
+        mem = resource.Resource(resource.ResourceType.memory)
+        num_cores = resource.Resource(resource.ResourceType.cpu_cores)
+        disk = resource.Resource(resource.ResourceType.disk)
+        disk_capacity = resource.Resource(resource.ResourceType.disk_capacity)
         cluster.create_resource(mem)
         cluster.create_resource(num_cores)
         cluster.create_resource(disk)
+        cluster.create_resource(disk_capacity)
 
         flavor_cache = {}
         hypervisors = self.wrapper.get_hypervisors_list()
         for h in hypervisors:
             service = self.wrapper.nova.services.find(id=h.service['id'])
             # create hypervisor in cluster_model_collector
-            hypervisor = Hypervisor()
+            hypervisor = obj_hypervisor.Hypervisor()
             hypervisor.uuid = service.host
             hypervisor.hostname = h.hypervisor_hostname
             # set capacity
             mem.set_capacity(hypervisor, h.memory_mb)
             disk.set_capacity(hypervisor, h.free_disk_gb)
+            disk_capacity.set_capacity(hypervisor, h.local_gb)
             num_cores.set_capacity(hypervisor, h.vcpus)
             hypervisor.state = h.state
             hypervisor.status = h.status
@@ -65,7 +65,7 @@ class NovaClusterModelCollector(BaseClusterModelCollector):
             vms = self.wrapper.get_vms_by_hypervisor(str(service.host))
             for v in vms:
                 # create VM in cluster_model_collector
-                vm = VM()
+                vm = obj_vm.VM()
                 vm.uuid = v.id
                 # nova/nova/compute/vm_states.py
                 vm.state = getattr(v, 'OS-EXT-STS:vm_state')

watcher/objects/action.py

@@ -42,7 +42,6 @@ class Action(base.WatcherObject):
         'uuid': obj_utils.str_or_none,
         'action_plan_id': obj_utils.int_or_none,
         'action_type': obj_utils.str_or_none,
-        'applies_to': obj_utils.str_or_none,
         'input_parameters': obj_utils.dict_or_none,
         'state': obj_utils.str_or_none,
         # todo(jed) remove parameter alarm

watcher/objects/action_plan.py

@@ -71,13 +71,14 @@ state may be one of the following:
 from watcher.common import exception
 from watcher.common import utils
 from watcher.db import api as dbapi
+from watcher.objects import action as action_objects
 from watcher.objects import base
 from watcher.objects import utils as obj_utils
 
 
 class State(object):
     RECOMMENDED = 'RECOMMENDED'
-    TRIGGERED = 'TRIGGERED'
+    PENDING = 'PENDING'
     ONGOING = 'ONGOING'
     FAILED = 'FAILED'
     SUCCEEDED = 'SUCCEEDED'
@@ -251,6 +252,14 @@ class ActionPlan(base.WatcherObject):
                         A context should be set when instantiating the
                         object, e.g.: Audit(context)
         """
+        related_actions = action_objects.Action.list(
+            context=self._context,
+            filters={"action_plan_uuid": self.uuid})
+
+        # Cascade soft_delete of related actions
+        for related_action in related_actions:
+            related_action.soft_delete()
+
         self.dbapi.soft_delete_action_plan(self.uuid)
-        self.state = "DELETED"
+        self.state = State.DELETED
         self.save()