commit 0fa5ce2c14fa36610630469c14c07537eb4f4807

Author: Andrew Beekhof <andrew@beekhof.net>

Date:   Wed Oct 1 16:56:59 2014 +1000

    Import: pacemaker-rollup-be1e835

diff --git a/attrd/Makefile.am b/attrd/Makefile.am

index 802a3fa..9d5e223 100644

--- a/attrd/Makefile.am

+++ b/attrd/Makefile.am

@@ -32,25 +32,12 @@ attrd_LDADD	= $(top_builddir)/lib/cluster/libcrmcluster.la 		\

 		$(top_builddir)/lib/cib/libcib.la			\

 		$(CLUSTERLIBS)

-if BUILD_HEARTBEAT_SUPPORT

-attrd_SOURCES	+= legacy.c

-else

-

-if BUILD_CS_SUPPORT

-

-if BUILD_CS_PLUGIN

-attrd_SOURCES	+= legacy.c

-else

-# Only build the new version where CPG is exclusively used for communication

+if BUILD_ATOMIC_ATTRD

 attrd_SOURCES	+= main.c commands.c

-endif

-

 else

 attrd_SOURCES	+= legacy.c

 endif

-endif

-

 clean-generic:

 	rm -f *.log *.debug *.xml *~

diff --git a/attrd/commands.c b/attrd/commands.c

index 038e7e4..c48ef1b 100644

--- a/attrd/commands.c

+++ b/attrd/commands.c

@@ -17,6 +17,8 @@

  */

 #include <crm_internal.h>

+#include <sys/types.h>

+#include <regex.h>

 #include <glib.h>

 #include <crm/msg_xml.h>

@@ -63,7 +65,7 @@ typedef struct attribute_value_s {

 void write_attribute(attribute_t *a);

 void write_or_elect_attribute(attribute_t *a);

-void attrd_peer_update(crm_node_t *peer, xmlNode *xml, bool filter);

+void attrd_peer_update(crm_node_t *peer, xmlNode *xml, const char *host, bool filter);

 void attrd_peer_sync(crm_node_t *peer, xmlNode *xml);

 void attrd_peer_remove(uint32_t nodeid, const char *host, gboolean uncache, const char *source);

@@ -191,16 +193,41 @@ attrd_client_message(crm_client_t *client, xmlNode *xml)

         char *host = crm_element_value_copy(xml, F_ATTRD_HOST);

         const char *attr = crm_element_value(xml, F_ATTRD_ATTRIBUTE);

         const char *value = crm_element_value(xml, F_ATTRD_VALUE);

+        const char *regex = crm_element_value(xml, F_ATTRD_REGEX);

-        a = g_hash_table_lookup(attributes, attr);

+        if(attr == NULL && regex) {

+            GHashTableIter aIter;

+            regex_t *r_patt = calloc(1, sizeof(regex_t));

+

+            crm_debug("Setting %s to %s", regex, value);

+            if (regcomp(r_patt, regex, REG_EXTENDED)) {

+                crm_err("Bad regex '%s' for update", regex);

+                regfree(r_patt);

+                free(r_patt);

+                return;

+            }

-        if(host == NULL) {

+            g_hash_table_iter_init(&aIter, attributes);

+            while (g_hash_table_iter_next(&aIter, (gpointer *) & attr, NULL)) {

+                int status = regexec(r_patt, attr, 0, NULL, 0);

+

+                if(status == 0) {

+                    crm_trace("Matched %s with %s", attr, regex);

+                    crm_xml_add(xml, F_ATTRD_ATTRIBUTE, attr);

+                    send_attrd_message(NULL, xml);

+                }

+            }

+            return;

+

+        } else if(host == NULL) {

             crm_trace("Inferring host");

             host = strdup(attrd_cluster->uname);

             crm_xml_add(xml, F_ATTRD_HOST, host);

             crm_xml_add_int(xml, F_ATTRD_HOST_ID, attrd_cluster->nodeid);

         }

+        a = g_hash_table_lookup(attributes, attr);

+

         if (value) {

             int offset = 1;

             int int_value = 0;

@@ -254,6 +281,7 @@ attrd_client_message(crm_client_t *client, xmlNode *xml)

     }

     if(broadcast) {

+        /* Ends up at attrd_peer_message() */

         send_attrd_message(NULL, xml);

     }

 }

@@ -265,6 +293,7 @@ attrd_peer_message(crm_node_t *peer, xmlNode *xml)

     const char *v = crm_element_value(xml, F_ATTRD_VERSION);

     const char *op = crm_element_value(xml, F_ATTRD_TASK);

     const char *election_op = crm_element_value(xml, F_CRM_TASK);

+    const char *host = crm_element_value(xml, F_ATTRD_HOST);

     if(election_op) {

         enum election_result rc = 0;

@@ -293,7 +322,7 @@ attrd_peer_message(crm_node_t *peer, xmlNode *xml)

             const char *name = crm_element_value(xml, F_ATTRD_ATTRIBUTE);

             crm_trace("Compatibility update of %s from %s", name, peer->uname);

-            attrd_peer_update(peer, xml, FALSE);

+            attrd_peer_update(peer, xml, host, FALSE);

         } else if(safe_str_eq(op, "flush")) {

             const char *name = crm_element_value(xml, F_ATTRD_ATTRIBUTE);

@@ -336,13 +365,12 @@ attrd_peer_message(crm_node_t *peer, xmlNode *xml)

     }

     if(safe_str_eq(op, "update")) {

-        attrd_peer_update(peer, xml, FALSE);

+        attrd_peer_update(peer, xml, host, FALSE);

     } else if(safe_str_eq(op, "sync")) {

         attrd_peer_sync(peer, xml);

     } else if(safe_str_eq(op, "peer-remove")) {

-        const char *host = crm_element_value(xml, F_ATTRD_HOST);

         attrd_peer_remove(0, host, TRUE, peer->uname);

     } else if(safe_str_eq(op, "sync-response")

@@ -351,7 +379,8 @@ attrd_peer_message(crm_node_t *peer, xmlNode *xml)

         crm_notice("Processing %s from %s", op, peer->uname);

         for (child = __xml_first_child(xml); child != NULL; child = __xml_next(child)) {

-            attrd_peer_update(peer, child, TRUE);

+            host = crm_element_value(child, F_ATTRD_HOST);

+            attrd_peer_update(peer, child, host, TRUE);

         }

     }

 }

@@ -409,12 +438,11 @@ attrd_peer_remove(uint32_t nodeid, const char *host, gboolean uncache, const cha

 }

 void

-attrd_peer_update(crm_node_t *peer, xmlNode *xml, bool filter)

+attrd_peer_update(crm_node_t *peer, xmlNode *xml, const char *host, bool filter)

 {

     bool changed = FALSE;

     attribute_value_t *v = NULL;

-    const char *host = crm_element_value(xml, F_ATTRD_HOST);

     const char *attr = crm_element_value(xml, F_ATTRD_ATTRIBUTE);

     const char *value = crm_element_value(xml, F_ATTRD_VALUE);

@@ -424,6 +452,19 @@ attrd_peer_update(crm_node_t *peer, xmlNode *xml, bool filter)

         a = create_attribute(xml);

     }

+    if(host == NULL) {

+        GHashTableIter vIter;

+        g_hash_table_iter_init(&vIter, a->values);

+

+        crm_debug("Setting %s for all hosts to %s", attr, value);

+

+        xml_remove_prop(xml, F_ATTRD_HOST_ID);

+        while (g_hash_table_iter_next(&vIter, (gpointer *) & host, NULL)) {

+            attrd_peer_update(peer, xml, host, filter);

+        }

+        return;

+    }

+

     v = g_hash_table_lookup(a->values, host);

     if(v == NULL) {

diff --git a/cib/messages.c b/cib/messages.c

index 4b79912..9c66349 100644

--- a/cib/messages.c

+++ b/cib/messages.c

@@ -292,6 +292,11 @@ cib_process_upgrade_server(const char *op, int options, const char *section, xml

             crm_xml_add(up, F_TYPE, "cib");

             crm_xml_add(up, F_CIB_OPERATION, CIB_OP_UPGRADE);

             crm_xml_add(up, F_CIB_SCHEMA_MAX, get_schema_name(new_version));

+            crm_xml_add(up, F_CIB_DELEGATED, host);

+            crm_xml_add(up, F_CIB_CLIENTID, crm_element_value(req, F_CIB_CLIENTID));

+            crm_xml_add(up, F_CIB_CALLOPTS, crm_element_value(req, F_CIB_CALLOPTS));

+            crm_xml_add(up, F_CIB_CALLID, crm_element_value(req, F_CIB_CALLID));

+

             send_cluster_message(NULL, crm_msg_cib, up, FALSE);

             free_xml(up);

diff --git a/configure.ac b/configure.ac

index 40adffe..1edff40 100644

--- a/configure.ac

+++ b/configure.ac

@@ -75,6 +75,7 @@ CC_IN_CONFIGURE=yes

 export CC_IN_CONFIGURE

 LDD=ldd

+BUILD_ATOMIC_ATTRD=1

 dnl ========================================================================

 dnl Compiler characteristics

@@ -1260,6 +1261,7 @@ case $SUPPORT_HEARTBEAT in

 	dnl objdump -x ${libdir}/libccmclient.so | grep SONAME | awk '{print $2}'

 	AC_DEFINE_UNQUOTED(CCM_LIBRARY, "libccmclient.so.1", Library to load for ccm support)

 	AC_DEFINE_UNQUOTED(HEARTBEAT_LIBRARY, "libhbclient.so.1", Library to load for heartbeat support)

+	BUILD_ATOMIC_ATTRD=0

    else

 	SUPPORT_HEARTBEAT=0

    fi

@@ -1341,6 +1343,7 @@ SUPPORT_PLUGIN=0

 if test $SUPPORT_CS = 1 -a x$HAVE_confdb = x1; then

     dnl Need confdb to support cman and the plugins

     SUPPORT_PLUGIN=1

+    BUILD_ATOMIC_ATTRD=0

     LCRSODIR=`$PKGCONFIG corosync --variable=lcrsodir`

     STACKS="$STACKS corosync-plugin"

     COROSYNC_LIBS="$COROSYNC_LIBS $confdb_LIBS"

@@ -1382,6 +1385,9 @@ AM_CONDITIONAL(BUILD_CS_SUPPORT, test $SUPPORT_CS = 1)

 AM_CONDITIONAL(BUILD_CS_PLUGIN, test $SUPPORT_PLUGIN = 1)

 AM_CONDITIONAL(BUILD_CMAN, test $SUPPORT_CMAN = 1)

+AM_CONDITIONAL(BUILD_ATOMIC_ATTRD, test $BUILD_ATOMIC_ATTRD = 1)

+AC_DEFINE_UNQUOTED(HAVE_ATOMIC_ATTRD, $BUILD_ATOMIC_ATTRD, Support the new atomic attrd)

+

 AC_SUBST(SUPPORT_CMAN)

 AC_SUBST(SUPPORT_CS)

@@ -1401,6 +1407,9 @@ else

     PCMK_FEATURES="$PCMK_FEATURES $STACKS"

 fi

+if test ${BUILD_ATOMIC_ATTRD} = 1; then

+    PCMK_FEATURES="$PCMK_FEATURES atomic-attrd"

+fi

 AC_SUBST(CLUSTERLIBS)

 AC_SUBST(LCRSODIR)

@@ -1871,6 +1880,7 @@ tools/Makefile							\

 	tools/crm_report					\

         tools/report.common                                     \

 	tools/cibsecret						\

+	tools/crm_mon.upstart					\

 xml/Makefile							\

 lib/gnu/Makefile						\

 		)

diff --git a/crmd/lrm.c b/crmd/lrm.c

index db0bffb..44634fb 100644

--- a/crmd/lrm.c

+++ b/crmd/lrm.c

@@ -1162,7 +1162,7 @@ get_lrm_resource(lrm_state_t * lrm_state, xmlNode * resource, xmlNode * op_msg,

         if (!rsc) {

             fsa_data_t *msg_data = NULL;

-            crm_err("Could not add resource %s to LRM", id);

+            crm_err("Could not add resource %s to LRM %s", id, lrm_state->node_name);

             register_fsa_error(C_FSA_INTERNAL, I_FAIL, NULL);

         }

     }

@@ -1175,13 +1175,17 @@ delete_resource(lrm_state_t * lrm_state,

                 const char *id,

                 lrmd_rsc_info_t * rsc,

                 GHashTableIter * gIter,

-                const char *sys, const char *host, const char *user, ha_msg_input_t * request)

+                const char *sys,

+                const char *host,

+                const char *user,

+                ha_msg_input_t * request,

+                gboolean unregister)

 {

     int rc = pcmk_ok;

     crm_info("Removing resource %s for %s (%s) on %s", id, sys, user ? user : "internal", host);

-    if (rsc) {

+    if (rsc && unregister) {

         rc = lrm_state_unregister_rsc(lrm_state, id, 0);

     }

@@ -1224,6 +1228,7 @@ do_lrm_invoke(long long action,

     const char *user_name = NULL;

     const char *target_node = NULL;

     gboolean is_remote_node = FALSE;

+    gboolean crm_rsc_delete = FALSE;

     if (input->xml != NULL) {

         /* Remote node operations are routed here to their remote connections */

@@ -1259,6 +1264,8 @@ do_lrm_invoke(long long action,

     crm_trace("LRM command from: %s", from_sys);

     if (safe_str_eq(crm_op, CRM_OP_LRM_DELETE)) {

+        /* remember this delete op came from crm_resource */

+        crm_rsc_delete = TRUE;

         operation = CRMD_ACTION_DELETE;

     } else if (safe_str_eq(crm_op, CRM_OP_LRM_REFRESH)) {

@@ -1370,13 +1377,17 @@ do_lrm_invoke(long long action,

     } else if (safe_str_eq(operation, CRM_OP_REPROBE) || safe_str_eq(crm_op, CRM_OP_REPROBE)) {

         GHashTableIter gIter;

         rsc_history_t *entry = NULL;

+        gboolean unregister = is_remote_lrmd_ra(NULL, NULL, entry->id) ? FALSE : TRUE;

         crm_notice("Forcing the status of all resources to be redetected");

         g_hash_table_iter_init(&gIter, lrm_state->resource_history);

         while (g_hash_table_iter_next(&gIter, NULL, (void **)&entry)) {

+            /* only unregister the resource during a reprobe if it is not a remote connection

+             * resource. otherwise unregistering the connection will terminate remote-node

+             * membership */

             delete_resource(lrm_state, entry->id, &entry->rsc, &gIter, from_sys, from_host,

-                            user_name, NULL);

+                            user_name, NULL, unregister);

         }

         /* Now delete the copy in the CIB */

@@ -1499,6 +1510,7 @@ do_lrm_invoke(long long action,

             free(op_key);

         } else if (rsc != NULL && safe_str_eq(operation, CRMD_ACTION_DELETE)) {

+            gboolean unregister = TRUE;

 #if ENABLE_ACL

             int cib_rc = delete_rsc_status(lrm_state, rsc->id, cib_dryrun | cib_sync_call, user_name);

@@ -1523,7 +1535,11 @@ do_lrm_invoke(long long action,

                 return;

             }

 #endif

-            delete_resource(lrm_state, rsc->id, rsc, NULL, from_sys, from_host, user_name, input);

+            if (crm_rsc_delete == TRUE && is_remote_lrmd_ra(NULL, NULL, rsc->id)) {

+                unregister = FALSE;

+            }

+

+            delete_resource(lrm_state, rsc->id, rsc, NULL, from_sys, from_host, user_name, input, unregister);

         } else if (rsc != NULL) {

             do_lrm_rsc_op(lrm_state, rsc, operation, input->xml, input->msg);

diff --git a/crmd/remote_lrmd_ra.c b/crmd/remote_lrmd_ra.c

index 98f59c8..f3dedeb 100644

--- a/crmd/remote_lrmd_ra.c

+++ b/crmd/remote_lrmd_ra.c

@@ -251,6 +251,8 @@ connection_takeover_timeout_cb(gpointer data)

     crm_debug("takeover event timed out for node %s", cmd->rsc_id);

     cmd->takeover_timeout_id = 0;

+    lrm_state = lrm_state_find(cmd->rsc_id);

+

     handle_remote_ra_stop(lrm_state, cmd);

     free_cmd(cmd);

@@ -379,6 +381,11 @@ remote_lrm_op_callback(lrmd_event_data_t * op)

             cmd->rc = PCMK_OCF_UNKNOWN_ERROR;

         } else {

+

+            if (safe_str_eq(cmd->action, "start")) {

+                /* clear PROBED value if it happens to be set after start completes. */

+                update_attrd(lrm_state->node_name, CRM_OP_PROBED, NULL, NULL, TRUE);

+            }

             lrm_state_reset_tables(lrm_state);

             cmd->rc = PCMK_OCF_OK;

             cmd->op_status = PCMK_LRM_OP_DONE;

diff --git a/crmd/te_actions.c b/crmd/te_actions.c

index 926996b..a3aa78b 100644

--- a/crmd/te_actions.c

+++ b/crmd/te_actions.c

@@ -546,17 +546,26 @@ te_update_job_count(crm_action_t * action, int offset)

         return;

     }

-    if (safe_str_eq(task, CRMD_ACTION_MIGRATE) || safe_str_eq(task, CRMD_ACTION_MIGRATED)) {

+    /* if we have a router node, this means the action is performing

+     * on a remote node. For now, we count all action occuring on a

+     * remote node against the job list on the cluster node hosting

+     * the connection resources */

+    target = crm_element_value(action->xml, XML_LRM_ATTR_ROUTER_NODE);

+

+    if ((target == NULL) &&

+        (safe_str_eq(task, CRMD_ACTION_MIGRATE) || safe_str_eq(task, CRMD_ACTION_MIGRATED))) {

+

         const char *t1 = crm_meta_value(action->params, XML_LRM_ATTR_MIGRATE_SOURCE);

         const char *t2 = crm_meta_value(action->params, XML_LRM_ATTR_MIGRATE_TARGET);

         te_update_job_count_on(t1, offset, TRUE);

         te_update_job_count_on(t2, offset, TRUE);

-

-    } else {

-

-        te_update_job_count_on(target, offset, FALSE);

+        return;

+    } else if (target == NULL) {

+        target = crm_element_value(action->xml, XML_LRM_ATTR_TARGET);

     }

+

+    te_update_job_count_on(target, offset, FALSE);

 }

 static gboolean

@@ -597,6 +606,8 @@ te_should_perform_action_on(crm_graph_t * graph, crm_action_t * action, const ch

         }

     }

+    crm_trace("Peer %s has not hit their limit yet. current jobs = %d limit= %d limit", target, r->jobs, limit);

+

     return TRUE;

 }

@@ -611,7 +622,15 @@ te_should_perform_action(crm_graph_t * graph, crm_action_t * action)

         return TRUE;

     }

-    if (safe_str_eq(task, CRMD_ACTION_MIGRATE) || safe_str_eq(task, CRMD_ACTION_MIGRATED)) {

+    /* if we have a router node, this means the action is performing

+     * on a remote node. For now, we count all action occuring on a

+     * remote node against the job list on the cluster node hosting

+     * the connection resources */

+    target = crm_element_value(action->xml, XML_LRM_ATTR_ROUTER_NODE);

+

+    if ((target == NULL) &&

+        (safe_str_eq(task, CRMD_ACTION_MIGRATE) || safe_str_eq(task, CRMD_ACTION_MIGRATED))) {

+

         target = crm_meta_value(action->params, XML_LRM_ATTR_MIGRATE_SOURCE);

         if(te_should_perform_action_on(graph, action, target) == FALSE) {

             return FALSE;

@@ -619,7 +638,7 @@ te_should_perform_action(crm_graph_t * graph, crm_action_t * action)

         target = crm_meta_value(action->params, XML_LRM_ATTR_MIGRATE_TARGET);

-    } else {

+    } else if (target == NULL) {

         target = crm_element_value(action->xml, XML_LRM_ATTR_TARGET);

     }

diff --git a/crmd/te_events.c b/crmd/te_events.c

index afe3072..b81a13e 100644

--- a/crmd/te_events.c

+++ b/crmd/te_events.c

@@ -161,10 +161,6 @@ update_failcount(xmlNode * event, const char *event_node_uuid, int rc, int targe

         do_update = TRUE;

         value = failed_stop_offset;

-    } else if (safe_str_eq(task, CRMD_ACTION_STOP)) {

-        do_update = TRUE;

-        value = failed_stop_offset;

-

     } else if (safe_str_eq(task, CRMD_ACTION_PROMOTE)) {

         do_update = TRUE;

diff --git a/crmd/throttle.c b/crmd/throttle.c

index 04a3cf1..6e853ae 100644

--- a/crmd/throttle.c

+++ b/crmd/throttle.c

@@ -430,7 +430,7 @@ throttle_mode(void)

     unsigned int blocked = 0;

     enum throttle_state_e mode = throttle_none;

-#ifndef ON_SOLARIS

+#ifdef ON_SOLARIS

     return throttle_none;

 #endif

@@ -508,44 +508,41 @@ static void

 throttle_send_command(enum throttle_state_e mode)

 {

     xmlNode *xml = NULL;

+    static enum throttle_state_e last = -1;

-    xml = create_request(CRM_OP_THROTTLE, NULL, NULL, CRM_SYSTEM_CRMD, CRM_SYSTEM_CRMD, NULL);

-    crm_xml_add_int(xml, F_CRM_THROTTLE_MODE, mode);

-    crm_xml_add_int(xml, F_CRM_THROTTLE_MAX, throttle_job_max);

+    if(mode != last) {

+        crm_info("New throttle mode: %.4x (was %.4x)", mode, last);

+        last = mode;

-    send_cluster_message(NULL, crm_msg_crmd, xml, TRUE);

-    free_xml(xml);

+        xml = create_request(CRM_OP_THROTTLE, NULL, NULL, CRM_SYSTEM_CRMD, CRM_SYSTEM_CRMD, NULL);

+        crm_xml_add_int(xml, F_CRM_THROTTLE_MODE, mode);

+        crm_xml_add_int(xml, F_CRM_THROTTLE_MAX, throttle_job_max);

-    crm_info("Updated throttle state to %.4x", mode);

+        send_cluster_message(NULL, crm_msg_crmd, xml, TRUE);

+        free_xml(xml);

+    }

 }

 static gboolean

 throttle_timer_cb(gpointer data)

 {

     static bool send_updates = FALSE;

-    static enum throttle_state_e last = -1;

-

     enum throttle_state_e now = throttle_none;

-    if(send_updates == FALSE) {

-        /* Optimize for the true case */

-        if(compare_version(fsa_our_dc_version, "3.0.8") < 0) {

-            crm_trace("DC version %s doesn't support throttling", fsa_our_dc_version);

-

-        } else {

-            send_updates = TRUE;

-        }

-    }

-

     if(send_updates) {

         now = throttle_mode();

-    }

+        throttle_send_command(now);

+

+    } else if(compare_version(fsa_our_dc_version, "3.0.8") < 0) {

+        /* Optimize for the true case */

+        crm_trace("DC version %s doesn't support throttling", fsa_our_dc_version);

-    if(send_updates && now != last) {

-        crm_debug("New throttle mode: %.4x (was %.4x)", now, last);

+    } else {

+        send_updates = TRUE;

+        now = throttle_mode();

         throttle_send_command(now);

-        last = now;

     }

+

     return TRUE;

 }

@@ -595,9 +592,11 @@ throttle_update_job_max(const char *preference)

 void

 throttle_init(void)

 {

-    throttle_records = g_hash_table_new_full(

-        crm_str_hash, g_str_equal, NULL, throttle_record_free);

-    throttle_timer = mainloop_timer_add("throttle", 30* 1000, TRUE, throttle_timer_cb, NULL);

+    if(throttle_records == NULL) {

+        throttle_records = g_hash_table_new_full(

+            crm_str_hash, g_str_equal, NULL, throttle_record_free);

+        throttle_timer = mainloop_timer_add("throttle", 30 * 1000, TRUE, throttle_timer_cb, NULL);

+    }

     throttle_update_job_max(NULL);

     mainloop_timer_start(throttle_timer);

diff --git a/cts/CTS.py b/cts/CTS.py

index 04189f2..f4198c4 100644

--- a/cts/CTS.py

+++ b/cts/CTS.py

@@ -225,10 +225,13 @@ class CtsLab:

 class NodeStatus:

     def __init__(self, env):

-        pass

+        self.Env = env

     def IsNodeBooted(self, node):

         '''Return TRUE if the given node is booted (responds to pings)'''

+        if self.Env["docker"]:

+            return RemoteFactory().getInstance()("localhost", "docker inspect --format {{.State.Running}} %s | grep -q true" % node, silent=True) == 0

+

         return RemoteFactory().getInstance()("localhost", "ping -nq -c1 -w1 %s" % node, silent=True) == 0

     def IsSshdUp(self, node):

@@ -442,6 +445,9 @@ class ClusterManager(UserDict):

             self.debug("Quorum: %d Len: %d" % (q, len(self.Env["nodes"])))

             return peer_list

+        for n in self.Env["nodes"]:

+            peer_state[n] = "unknown"

+

         # Now see if any states need to be updated

         self.debug("looking for: " + repr(stonith.regexes))

         shot = stonith.look(0)

@@ -457,7 +463,8 @@ class ClusterManager(UserDict):

                     peer_state[peer] = "complete"

                     self.__instance_errorstoignore.append(self.templates["Pat:Fencing_ok"] % peer)

-                elif re.search(self.templates["Pat:Fencing_start"] % n, shot):

+                elif peer_state[n] != "complete" and re.search(self.templates["Pat:Fencing_start"] % n, shot):

+                    # TODO: Correctly detect multiple fencing operations for the same host

                     peer = n

                     peer_state[peer] = "in-progress"

                     self.__instance_errorstoignore.append(self.templates["Pat:Fencing_start"] % peer)

diff --git a/cts/CTSlab.py b/cts/CTSlab.py

index 314c347..9b336a5 100755

--- a/cts/CTSlab.py

+++ b/cts/CTSlab.py

@@ -107,9 +107,9 @@ if __name__ == '__main__':

     if Environment["ListTests"] == 1:

         Tests = TestList(cm, Audits)

-        Environment.log("Total %d tests"%len(Tests))

+        LogFactory().log("Total %d tests"%len(Tests))

         for test in Tests :

-            Environment.log(str(test.name));

+            LogFactory().log(str(test.name));

         sys.exit(0)

     elif len(Environment["tests"]) == 0:

diff --git a/cts/CTStests.py b/cts/CTStests.py

index 918dff0..cd5b7ce 100644

--- a/cts/CTStests.py

+++ b/cts/CTStests.py

@@ -83,6 +83,7 @@ class CTSTest:

         self.passed = 1

         self.is_loop = 0

         self.is_unsafe = 0

+        self.is_docker_unsafe = 0

         self.is_experimental = 0

         self.is_container = 0

         self.is_valgrind = 0

@@ -224,6 +225,8 @@ class CTSTest:

             return 0

         elif self.is_experimental and not self.Env["experimental-tests"]:

             return 0

+        elif self.is_docker_unsafe and self.Env["docker"]:

+            return 0

         elif self.is_container and not self.Env["container-tests"]:

             return 0

         elif self.Env["benchmark"] and self.benchmark == 0:

@@ -1359,6 +1362,8 @@ class ComponentFail(CTSTest):

     def __init__(self, cm):

         CTSTest.__init__(self,cm)

         self.name = "ComponentFail"

+        # TODO make this work correctly in docker.

+        self.is_docker_unsafe = 1

         self.startall = SimulStartLite(cm)

         self.complist = cm.Components()

         self.patterns = []

@@ -1419,6 +1424,15 @@ class ComponentFail(CTSTest):

                 self.okerrpatterns.append(self.templates["Pat:ChildRespawn"] %(node, chosen.name))

                 self.okerrpatterns.append(self.templates["Pat:ChildExit"])

+        if chosen.name == "stonith":

+            # Ignore actions for STONITH resources

+            (rc, lines) = self.rsh(node, "crm_resource -c", None)

+            for line in lines:

+                if re.search("^Resource", line):

+                    r = AuditResource(self.CM, line)

+                    if r.rclass == "stonith":

+                        self.okerrpatterns.append(self.templates["LogActions: Recover.*%s"] % r.id)

+

         # supply a copy so self.patterns doesnt end up empty

         tmpPats = []

         tmpPats.extend(self.patterns)

@@ -2512,6 +2526,7 @@ class RemoteLXC(CTSTest):

         self.startall = SimulStartLite(cm)

         self.num_containers = 2

         self.is_container = 1

+        self.is_docker_unsafe = 1

         self.failed = 0

         self.fail_string = ""

@@ -2624,6 +2639,7 @@ class RemoteBaremetal(CTSTest):

     def __init__(self, cm):

         CTSTest.__init__(self,cm)

         self.name = "RemoteBaremetal"

+        self.is_docker_unsafe = 1

         self.start = StartTest(cm)

         self.startall = SimulStartLite(cm)

         self.stop = StopTest(cm)

diff --git a/cts/environment.py b/cts/environment.py

index de1d099..d741452 100644

--- a/cts/environment.py

+++ b/cts/environment.py

@@ -71,6 +71,7 @@ class Environment:

         self["loop-tests"] = 1

         self["scenario"] = "random"

         self["stats"] = 0

+        self["docker"] = 0

         self.RandomGen = random.Random()

         self.logger = LogFactory()

@@ -143,7 +144,9 @@ class Environment:

                 # GoodThing(tm).

                 try:

                     n = node.strip()

-                    gethostbyname_ex(n)

+                    if self.data["docker"] == 0:

+                        gethostbyname_ex(n)

+

                     self.Nodes.append(n) 

                 except:

                     self.logger.log(node+" not found in DNS... aborting")

@@ -191,7 +194,10 @@ class Environment:

             return "crm-lha"

         elif self.data["Stack"] == "corosync 2.x":

-            return "crm-mcp"

+            if self["docker"]:

+                return "crm-mcp-docker"

+            else:

+                return "crm-mcp"

         elif self.data["Stack"] == "corosync (cman)":

             return "crm-cman"

@@ -342,6 +348,10 @@ class Environment:

             elif args[i] == "--qarsh":

                 RemoteFactory().enable_qarsh()

+            elif args[i] == "--docker":

+                self["docker"] = 1

+                RemoteFactory().enable_docker()

+

             elif args[i] == "--stonith" or args[i] == "--fencing":

                 skipthis=1

                 if args[i+1] == "1" or args[i+1] == "yes":

@@ -352,6 +362,9 @@ class Environment:

                     self["DoStonith"]=1

                     self["stonith-type"] = "fence_xvm"

                     self["stonith-params"] = "pcmk_arg_map=domain:uname,delay=0"