diff --git a/GNUmakefile b/GNUmakefile

index b17fb4c..f28dea8 100644

--- a/GNUmakefile

+++ b/GNUmakefile

@@ -58,6 +58,8 @@ BUILD_COUNTER	?= build.counter

 LAST_COUNT      = $(shell test ! -e $(BUILD_COUNTER) && echo 0; test -e $(BUILD_COUNTER) && cat $(BUILD_COUNTER))

 COUNT           = $(shell expr 1 + $(LAST_COUNT))

+SPECVERSION	?= $(COUNT)

+

 init:

 	./autogen.sh

@@ -144,7 +146,7 @@ srpm-%:	export $(PACKAGE)-%.spec

 	if [ -e $(BUILD_COUNTER) ]; then					\

 		echo $(COUNT) > $(BUILD_COUNTER);				\

 	fi

-	sed -i 's/global\ specversion.*/global\ specversion\ $(COUNT)/' $(PACKAGE).spec

+	sed -i 's/global\ specversion.*/global\ specversion\ $(SPECVERSION)/' $(PACKAGE).spec

 	sed -i 's/global\ commit.*/global\ commit\ $(TAG)/' $(PACKAGE).spec

 	case "$(WITH)" in 	\

 	  *pre_release*)	\

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

index c48ef1b..12771ee 100644

--- a/attrd/commands.c

+++ b/attrd/commands.c

@@ -202,21 +202,27 @@ attrd_client_message(crm_client_t *client, xmlNode *xml)

             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;

-            }

-            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);

+            } else {

-                if(status == 0) {

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

-                    crm_xml_add(xml, F_ATTRD_ATTRIBUTE, attr);

-                    send_attrd_message(NULL, xml);

+                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);

+                    }

                 }

             }

+

+            free(key);

+            free(set);

+            free(host);

+

+            regfree(r_patt);

+            free(r_patt);

             return;

         } else if(host == NULL) {

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

index 610aa0a..9fb2de9 100644

--- a/cib/callbacks.c

+++ b/cib/callbacks.c

@@ -382,6 +382,9 @@ do_local_notify(xmlNode * notify_src, const char *client_id,

     /* send callback to originating child */

     crm_client_t *client_obj = NULL;

     int local_rc = pcmk_ok;

+    int call_id = 0;

+

+    crm_element_value_int(notify_src, F_CIB_CALLID, &call_id);

     if (client_id != NULL) {

         client_obj = crm_client_get_by_id(client_id);

@@ -389,7 +392,7 @@ do_local_notify(xmlNode * notify_src, const char *client_id,

     if (client_obj == NULL) {

         local_rc = -ECONNRESET;

-        crm_trace("No client to sent the response to. F_CIB_CLIENTID not set.");

+        crm_trace("No client to sent response %d to, F_CIB_CLIENTID not set.", call_id);

     } else {

         int rid = 0;

@@ -405,13 +408,13 @@ do_local_notify(xmlNode * notify_src, const char *client_id,

                           rid, client_obj->name,

                           from_peer ? "(originator of delegated request)" : "");

             } else {

-                crm_trace("Sending response to %s %s",

-                          client_obj->name, from_peer ? "(originator of delegated request)" : "");

+                crm_trace("Sending response [call %d] to %s %s",

+                          call_id, client_obj->name, from_peer ? "(originator of delegated request)" : "");

             }

         } else {

-            crm_trace("Sending an event to %s %s",

-                      client_obj->name, from_peer ? "(originator of delegated request)" : "");

+            crm_trace("Sending event %d to %s %s",

+                      call_id, client_obj->name, from_peer ? "(originator of delegated request)" : "");

         }

         switch (client_obj->kind) {

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

index 99ef659..8989859 100644

--- a/crmd/control.c

+++ b/crmd/control.c

@@ -945,17 +945,23 @@ config_query_callback(xmlNode * msg, int call_id, int rc, xmlNode * output, void

         throttle_load_target = strtof(value, NULL) / 100;

     }

+    value = getenv("SBD_WATCHDOG_TIMEOUT");

+

+    if(value == NULL) {

+        value = crmd_pref(config_hash, "stonith-watchdog-timeout");

+    }

+

     value = crmd_pref(config_hash, "stonith-watchdog-timeout");

-    if(crm_get_msec(value) > 0 && daemon_option("watchdog") == NULL) {

+    if(crm_get_msec(value) > 0 && !daemon_option_enabled(crm_system_name, "watchdog")) {

         do_crm_log_always(LOG_EMERG, "Shutting down pacemaker, no watchdog device configured");

         crmd_exit(DAEMON_RESPAWN_STOP);

-    } else if(crm_get_msec(value) <= 0 && daemon_option("watchdog")) {

+    } else if(crm_get_msec(value) <= 0 && daemon_option_enabled(crm_system_name, "watchdog")) {

         crm_warn("Watchdog enabled but no stonith-watchdog-timeout configured");

     }

     value = crmd_pref(config_hash, "no-quorum-policy");

-    if (safe_str_eq(value, "suicide") && daemon_option("watchdog")) {

+    if (safe_str_eq(value, "suicide") && daemon_option_enabled(crm_system_name, "watchdog")) {

         no_quorum_suicide_escalation = TRUE;

     }

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

index e0bd6c4..a4f2e99 100644

--- a/crmd/election.c

+++ b/crmd/election.c

@@ -208,6 +208,9 @@ do_dc_takeover(long long action,

     fsa_register_cib_callback(rc, FALSE, NULL, feature_update_callback);

     update_attr_delegate(fsa_cib_conn, cib_none, XML_CIB_TAG_CRMCONFIG, NULL, NULL, NULL, NULL,

+                         XML_ATTR_HAVE_WATCHDOG, daemon_option("watchdog"), FALSE, NULL, NULL);

+

+    update_attr_delegate(fsa_cib_conn, cib_none, XML_CIB_TAG_CRMCONFIG, NULL, NULL, NULL, NULL,

                          "dc-version", VERSION "-" BUILD_VERSION, FALSE, NULL, NULL);

     update_attr_delegate(fsa_cib_conn, cib_none, XML_CIB_TAG_CRMCONFIG, NULL, NULL, NULL, NULL,

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

index ab426be..2f7513f 100644

--- a/crmd/pengine.c

+++ b/crmd/pengine.c

@@ -237,6 +237,48 @@ do_pe_invoke(long long action,

     fsa_register_cib_callback(fsa_pe_query, FALSE, NULL, do_pe_invoke_callback);

 }

+static void

+force_local_option(xmlNode *xml, const char *attr_name, const char *attr_value)

+{

+    int max = 0;

+    int lpc = 0;

+    int xpath_max = 1024;

+    char *xpath_string = NULL;

+    xmlXPathObjectPtr xpathObj = NULL;

+

+    xpath_string = calloc(1, xpath_max);

+    lpc = snprintf(xpath_string, xpath_max, "%.128s//%s//nvpair[@name='%.128s']",

+                       get_object_path(XML_CIB_TAG_CRMCONFIG), XML_CIB_TAG_PROPSET, attr_name);

+    CRM_LOG_ASSERT(lpc > 0);

+

+    xpathObj = xpath_search(xml, xpath_string);

+    max = numXpathResults(xpathObj);

+    free(xpath_string);

+

+    for (lpc = 0; lpc < max; lpc++) {

+        xmlNode *match = getXpathResult(xpathObj, lpc);

+        crm_trace("Forcing %s/%s = %s", ID(match), attr_name, attr_value);

+        crm_xml_add(match, XML_NVPAIR_ATTR_VALUE, attr_value);

+    }

+

+    if(max == 0) {

+        char *attr_id = crm_concat(CIB_OPTIONS_FIRST, attr_name, '-');

+

+        crm_trace("Creating %s/%s = %s", attr_id, attr_name, attr_value);

+        xml = create_xml_node(xml, XML_CIB_TAG_CRMCONFIG);

+        xml = create_xml_node(xml, XML_CIB_TAG_PROPSET);

+        crm_xml_add(xml, XML_ATTR_ID, CIB_OPTIONS_FIRST);

+

+        xml = create_xml_node(xml, XML_CIB_TAG_NVPAIR);

+

+        crm_xml_add(xml, XML_ATTR_ID, attr_id);

+        crm_xml_add(xml, XML_NVPAIR_ATTR_NAME, attr_name);

+        crm_xml_add(xml, XML_NVPAIR_ATTR_VALUE, attr_value);

+

+        free(attr_id);

+    }

+}

+

 void

 do_pe_invoke_callback(xmlNode * msg, int call_id, int rc, xmlNode * output, void *user_data)

 {

@@ -279,6 +321,7 @@ do_pe_invoke_callback(xmlNode * msg, int call_id, int rc, xmlNode * output, void

     crm_xml_add(output, XML_ATTR_DC_UUID, fsa_our_uuid);

     crm_xml_add_int(output, XML_ATTR_HAVE_QUORUM, fsa_has_quorum);

+    force_local_option(output, XML_ATTR_HAVE_WATCHDOG, daemon_option("watchdog"));

     if (ever_had_quorum && crm_have_quorum == FALSE) {

         crm_xml_add_int(output, XML_ATTR_QUORUM_PANIC, 1);

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

index f3dedeb..2f658ee 100644

--- a/crmd/remote_lrmd_ra.c

+++ b/crmd/remote_lrmd_ra.c

@@ -140,8 +140,6 @@ recurring_helper(gpointer data)

         ra_data->recurring_cmds = g_list_remove(ra_data->recurring_cmds, cmd);

-        cmd->call_id = generate_callid();

-

         ra_data->cmds = g_list_append(ra_data->cmds, cmd);

         mainloop_set_trigger(ra_data->work);

     }

@@ -177,6 +175,24 @@ report_remote_ra_result(remote_ra_cmd_t * cmd)

     op.interval = cmd->interval;

     op.rc = cmd->rc;

     op.op_status = cmd->op_status;

+    op.t_run = cmd->start_time;

+    op.t_rcchange = cmd->start_time;

+    if (cmd->reported_success && cmd->rc != PCMK_OCF_OK) {

+        op.t_rcchange = time(NULL);

+        /* This edge case will likely never ever occur, but if it does the

+         * result is that a failure will not be processed correctly. This is only

+         * remotely possible because we are able to detect a connection resource's tcp

+         * connection has failed at any moment after start has completed. The actual

+         * recurring operation is just a connectivity ping.

+         *

+         * basically, we are not guaranteed that the first successful monitor op and

+         * a subsequent failed monitor op will not occur in the same timestamp. We have to

+         * make it look like the operations occurred at separate times though. */

+        if (op.t_rcchange == op.t_run) {

+            op.t_rcchange++;

+        }

+    }

+

     if (cmd->params) {

         lrmd_key_value_t *tmp;

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

index 66ed1da..69c22e3 100644

--- a/crmd/te_utils.c

+++ b/crmd/te_utils.c

@@ -126,19 +126,19 @@ tengine_stonith_notify(stonith_t * st, stonith_event_t * st_event)

     if (st_event->result == pcmk_ok && safe_str_eq("on", st_event->action)) {

         crm_notice("%s was successfully unfenced by %s (at the request of %s)",

-                   st_event->target, st_event->executioner, st_event->origin);

+                   st_event->target, st_event->executioner ? st_event->executioner : "<anyone>", st_event->origin);

                 /* TODO: Hook up st_event->device */

         return;

     } else if (safe_str_eq("on", st_event->action)) {

         crm_err("Unfencing of %s by %s failed: %s (%d)",

-                st_event->target, st_event->executioner,

+                st_event->target, st_event->executioner ? st_event->executioner : "<anyone>",

                 pcmk_strerror(st_event->result), st_event->result);

         return;

     } else if (st_event->result == pcmk_ok && crm_str_eq(st_event->target, fsa_our_uname, TRUE)) {

         crm_crit("We were allegedly just fenced by %s for %s!",

-                 st_event->executioner, st_event->origin); /* Dumps blackbox if enabled */

+                 st_event->executioner ? st_event->executioner : "<anyone>", st_event->origin); /* Dumps blackbox if enabled */

         qb_log_fini(); /* Try to get the above log message to disk - somehow */

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

index 6ce38e9..d26efdb 100644

--- a/cts/CIB.py

+++ b/cts/CIB.py

@@ -177,6 +177,8 @@ class CIB11(ConfigBase):

                 for node in self.CM.Env["nodes"]:

                     ftype = self.CM.Env.RandomGen.choice(["levels-and", "levels-or ", "broadcast "])

                     self.CM.log(" - Using %s fencing for node: %s" % (ftype, node))

+                    # for baremetal remote node tests

+                    stt_nodes.append("remote_%s" % node)

                     if ftype == "levels-and":

                         stl.level(1, node, "FencingPass,Fencing")

                         stt_nodes.append(node)

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

index cd5b7ce..d2b7668 100644

--- a/cts/CTStests.py

+++ b/cts/CTStests.py

@@ -453,8 +453,8 @@ class StonithdTest(CTSTest):

         is_dc = self.CM.is_node_dc(node)

         watchpats = []

-        watchpats.append("Operation .* for host '%s' with device .* returned: 0" % node)

-        watchpats.append("tengine_stonith_notify:.*Peer %s was terminated .*: OK" % node)

+        watchpats.append(self.templates["Pat:FenceOpOK"] % node)

+        watchpats.append(self.templates["Pat:NodeFenced"] % node)

         if self.Env["at-boot"] == 0:

             self.debug("Expecting %s to stay down" % node)

@@ -2634,11 +2634,11 @@ AllTestClasses.append(RemoteLXC)

 ###################################################################

-class RemoteBaremetal(CTSTest):

+class RemoteDriver(CTSTest):

 ###################################################################

     def __init__(self, cm):

         CTSTest.__init__(self,cm)

-        self.name = "RemoteBaremetal"

+        self.name = "RemoteDriver"

         self.is_docker_unsafe = 1

         self.start = StartTest(cm)

         self.startall = SimulStartLite(cm)

@@ -2647,9 +2647,8 @@ class RemoteBaremetal(CTSTest):

         self.failed = 0

         self.fail_string = ""

         self.remote_node_added = 0

-        self.remote_node = "remote1"

         self.remote_rsc_added = 0

-        self.remote_rsc = "remote1-rsc"

+        self.remote_rsc = "remote-rsc"

         self.cib_cmd = """cibadmin -C -o %s -X '%s' """

     def del_rsc(self, node, rsc):

@@ -2679,10 +2678,11 @@ class RemoteBaremetal(CTSTest):

     def add_primitive_rsc(self, node):

         rsc_xml = """

-<primitive class="ocf" id="%s" provider="pacemaker" type="Dummy">

+<primitive class="ocf" id="%s" provider="heartbeat" type="Dummy">

     <operations>

-      <op id="remote1-rsc-monitor-interval-10s" interval="10s" name="monitor"/>

+      <op id="remote-rsc-monitor-interval-10s" interval="10s" name="monitor"/>

     </operations>

+    <meta_attributes id="remote-meta_attributes"/>

 </primitive>""" % (self.remote_rsc)

         self.add_rsc(node, rsc_xml)

         if self.failed == 0:

@@ -2691,21 +2691,38 @@ class RemoteBaremetal(CTSTest):

     def add_connection_rsc(self, node):

         rsc_xml = """

 <primitive class="ocf" id="%s" provider="pacemaker" type="remote">

-    <instance_attributes id="remote1-instance_attributes"/>

-        <instance_attributes id="remote1-instance_attributes">

-          <nvpair id="remote1-instance_attributes-server" name="server" value="%s"/>

+    <instance_attributes id="remote-instance_attributes"/>

+        <instance_attributes id="remote-instance_attributes">

+          <nvpair id="remote-instance_attributes-server" name="server" value="%s"/>

         </instance_attributes>

     <operations>

-      <op id="remote1-monitor-interval-60s" interval="60s" name="monitor"/>

-          <op id="remote1-name-start-interval-0-timeout-60" interval="0" name="start" timeout="60"/>

+      <op id="remote-monitor-interval-60s" interval="60s" name="monitor"/>

+      <op id="remote-name-start-interval-0-timeout-120" interval="0" name="start" timeout="120"/>

     </operations>

-    <meta_attributes id="remote1-meta_attributes"/>

 </primitive>""" % (self.remote_node, node)

         self.add_rsc(node, rsc_xml)

         if self.failed == 0:

             self.remote_node_added = 1

-    def step1_start_metal(self, node):

+    def stop_pcmk_remote(self, node):

+        # disable pcmk remote

+        for i in range(10):

+            rc = self.rsh(node, "service pacemaker_remote stop")

+            if rc != 0:

+                time.sleep(6)

+            else:

+                break

+

+    def start_pcmk_remote(self, node):

+        for i in range(10):

+            rc = self.rsh(node, "service pacemaker_remote start")

+            if rc != 0:

+                time.sleep(6)

+            else:

+                self.pcmk_started = 1

+                break

+

+    def start_metal(self, node):

         pcmk_started = 0

         # make sure the resource doesn't already exist for some reason

@@ -2717,13 +2734,7 @@ class RemoteBaremetal(CTSTest):

             self.fail_string = "Failed to shutdown cluster node %s" % (node)

             return

-        for i in range(10):

-            rc = self.rsh(node, "service pacemaker_remote start")

-            if rc != 0:

-                time.sleep(6)

-            else:

-                self.pcmk_started = 1

-                break

+        self.start_pcmk_remote(node)

         if self.pcmk_started == 0:

             self.failed = 1

@@ -2735,6 +2746,7 @@ class RemoteBaremetal(CTSTest):

         watch = self.create_watch(pats, 120)

         watch.setwatch()

         pats.append(self.templates["Pat:RscOpOK"] % (self.remote_node, "start"))

+        pats.append(self.templates["Pat:DC_IDLE"])

         self.add_connection_rsc(node)

@@ -2745,7 +2757,112 @@ class RemoteBaremetal(CTSTest):

             self.fail_string = "Unmatched patterns: %s" % (repr(watch.unmatched))

             self.failed = 1

-    def step2_add_rsc(self, node):

+    def migrate_connection(self, node):

+        if self.failed == 1:

+            return

+

+        pats = [ ]

+        pats.append(self.templates["Pat:RscOpOK"] % (self.remote_node, "migrate_to"))

+        pats.append(self.templates["Pat:RscOpOK"] % (self.remote_node, "migrate_from"))

+        pats.append(self.templates["Pat:DC_IDLE"])

+        watch = self.create_watch(pats, 120)

+        watch.setwatch()

+

+        (rc, lines) = self.rsh(node, "crm_resource -M -r %s" % (self.remote_node), None)

+        if rc != 0:

+            self.fail_string = "failed to move remote node connection resource"

+            self.logger.log(self.fail_string)

+            self.failed = 1

+            return

+

+        self.set_timer("remoteMetalMigrate")

+        watch.lookforall()

+        self.log_timer("remoteMetalMigrate")

+

+        if watch.unmatched:

+            self.fail_string = "Unmatched patterns: %s" % (repr(watch.unmatched))

+            self.logger.log(self.fail_string)

+            self.failed = 1

+            return

+

+    def fail_rsc(self, node):

+        if self.failed == 1:

+            return

+

+        watchpats = [ ]

+        watchpats.append(self.templates["Pat:RscRemoteOpOK"] % (self.remote_rsc, "stop", self.remote_node))

+        watchpats.append(self.templates["Pat:RscRemoteOpOK"] % (self.remote_rsc, "start", self.remote_node))

+        watchpats.append(self.templates["Pat:DC_IDLE"])

+

+        watch = self.create_watch(watchpats, 120)

+        watch.setwatch()

+

+        self.debug("causing dummy rsc to fail.")

+

+        rc = self.rsh(node, "rm -f /var/run/resource-agents/Dummy*")

+

+        self.set_timer("remoteRscFail")

+        watch.lookforall()

+        self.log_timer("remoteRscFail")

+        if watch.unmatched:

+            self.fail_string = "Unmatched patterns during rsc fail: %s" % (repr(watch.unmatched))

+            self.logger.log(self.fail_string)

+            self.failed = 1

+

+    def fail_connection(self, node):

+        if self.failed == 1:

+            return

+

+        watchpats = [ ]

+        watchpats.append(self.templates["Pat:FenceOpOK"] % self.remote_node)

+        watchpats.append(self.templates["Pat:NodeFenced"] % self.remote_node)

+

+        watch = self.create_watch(watchpats, 120)

+        watch.setwatch()

+

+        # force stop the pcmk remote daemon. this will result in fencing

+        self.debug("Force stopped active remote node")

+        self.stop_pcmk_remote(node)

+

+        self.debug("Waiting for remote node to be fenced.")

+        self.set_timer("remoteMetalFence")

+        watch.lookforall()

+        self.log_timer("remoteMetalFence")

+        if watch.unmatched:

+            self.fail_string = "Unmatched patterns: %s" % (repr(watch.unmatched))

+            self.logger.log(self.fail_string)

+            self.failed = 1

+            return

+

+        self.debug("Waiting for the remote node to come back up")

+        self.CM.ns.WaitForNodeToComeUp(node, 120);

+

+        pats = [ ]

+        watch = self.create_watch(pats, 120)

+        watch.setwatch()

+        pats.append(self.templates["Pat:RscOpOK"] % (self.remote_node, "start"))

+        if self.remote_rsc_added == 1:

+            pats.append(self.templates["Pat:RscOpOK"] % (self.remote_rsc, "monitor"))

+

+        # start the remote node again watch it integrate back into cluster.

+        self.start_pcmk_remote(node)

+        if self.pcmk_started == 0:

+            self.failed = 1

+            self.fail_string = "Failed to start pacemaker_remote on node %s" % (node)

+            self.logger.log(self.fail_string)

+            return

+

+        self.debug("Waiting for remote node to rejoin cluster after being fenced.")

+        self.set_timer("remoteMetalRestart")

+        watch.lookforall()

+        self.log_timer("remoteMetalRestart")

+        if watch.unmatched:

+            self.fail_string = "Unmatched patterns: %s" % (repr(watch.unmatched))

+            self.failed = 1

+            self.logger.log(self.fail_string)

+            return

+

+    def add_dummy_rsc(self, node):

         if self.failed == 1:

             return

@@ -2753,33 +2870,19 @@ class RemoteBaremetal(CTSTest):

         pats = [ ]

         watch = self.create_watch(pats, 120)

         watch.setwatch()

-        pats.append("process_lrm_event:.*Operation %s_start_0.*node=%s, .*confirmed.*true" % (self.remote_rsc, self.remote_node))

+        pats.append(self.templates["Pat:RscRemoteOpOK"] % (self.remote_rsc, "start", self.remote_node))

+        pats.append(self.templates["Pat:DC_IDLE"])

         # Add a resource that must live on remote-node

         self.add_primitive_rsc(node)

-        # this crm_resource command actually occurs on the remote node

-        # which verifies that the ipc proxy works

-        time.sleep(1)

-        (rc, lines) = self.rsh(node, "crm_resource -W -r remote1-rsc --quiet", None)

+        # force that rsc to prefer the remote node. 

+        (rc, line) = self.CM.rsh(node, "crm_resource -M -r %s -N %s -f" % (self.remote_rsc, self.remote_node), None)

         if rc != 0:

-            self.fail_string = "Failed to get location of resource remote1-rsc"

+            self.fail_string = "Failed to place remote resource on remote node."

             self.failed = 1

             return

-        find = 0

-        for line in lines:

-            if self.remote_node in line.split():

-                find = 1

-                break

-

-        if find == 0:

-            rc = self.rsh(node, "crm_resource -M -r remote1-rsc -N %s" % (self.remote_node))

-            if rc != 0:

-                self.fail_string = "Failed to place primitive on remote-node"

-                self.failed = 1

-                return

-

         self.set_timer("remoteMetalRsc")

         watch.lookforall()

         self.log_timer("remoteMetalRsc")

@@ -2787,7 +2890,7 @@ class RemoteBaremetal(CTSTest):

             self.fail_string = "Unmatched patterns: %s" % (repr(watch.unmatched))

             self.failed = 1

-    def step3_test_attributes(self, node):

+    def test_attributes(self, node):

         if self.failed == 1:

             return

@@ -2827,9 +2930,10 @@ class RemoteBaremetal(CTSTest):

         self.set_timer("remoteMetalCleanup")

         if self.remote_rsc_added == 1:

-            self.rsh(node, "crm_resource -U -r remote1-rsc -N %s" % (self.remote_node))

+            self.rsh(node, "crm_resource -U -r %s -N %s" % (self.remote_rsc, self.remote_node))

             self.del_rsc(node, self.remote_rsc)

         if self.remote_node_added == 1:

+            self.rsh(node, "crm_resource -U -r %s" % (self.remote_node))

             self.del_rsc(node, self.remote_node)

         watch.lookforall()

         self.log_timer("remoteMetalCleanup")

@@ -2838,15 +2942,11 @@ class RemoteBaremetal(CTSTest):

             self.fail_string = "Unmatched patterns: %s" % (repr(watch.unmatched))

             self.failed = 1

-        # disable pcmk remote

-        for i in range(10):

-            rc = self.rsh(node, "service pacemaker_remote stop")

-            if rc != 0:

-                time.sleep(6)

-            else:

-                break

+        self.stop_pcmk_remote(node)

-    def setup_env(self):

+    def setup_env(self, node):

+

+        self.remote_node = "remote_%s" % (node)

         sync_key = 0

         # we are assuming if all nodes have a key, that it is

@@ -2887,10 +2987,10 @@ class RemoteBaremetal(CTSTest):

         if not ret:

             return self.failure("Setup failed, start all nodes failed.")

-        self.setup_env()

-        self.step1_start_metal(node)

-        self.step2_add_rsc(node)

-        self.step3_test_attributes(node)

+        self.setup_env(node)

+        self.start_metal(node)

+        self.add_dummy_rsc(node)

+        self.test_attributes(node)

         self.cleanup_metal(node)

         self.debug("Waiting for the cluster to recover")

@@ -2902,11 +3002,201 @@ class RemoteBaremetal(CTSTest):

     def errorstoignore(self):

         '''Return list of errors which should be ignored'''

-        return [ """is running on remote1 which isn't allowed""",

+        return [ """is running on remote.*which isn't allowed""",

                  """Connection terminated""",

                  """Failed to send remote""",

                 ]

-AllTestClasses.append(RemoteBaremetal)

+# Remote driver is called by other tests.

+

+###################################################################

+class RemoteBasic(CTSTest):

+###################################################################

+    def __init__(self, cm):

+        CTSTest.__init__(self,cm)

+        self.name = "RemoteBasic"

+        self.start = StartTest(cm)

+        self.startall = SimulStartLite(cm)

+        self.driver = RemoteDriver(cm)

+        self.is_docker_unsafe = 1

+

+    def __call__(self, node):

+        '''Perform the 'RemoteBaremetal' test. '''

+        self.incr("calls")

+

+        ret = self.startall(None)

+        if not ret:

+            return self.failure("Setup failed, start all nodes failed.")

+

+        self.driver.setup_env(node)

+        self.driver.start_metal(node)

+        self.driver.add_dummy_rsc(node)

+        self.driver.test_attributes(node)

+        self.driver.cleanup_metal(node)

+

+        self.debug("Waiting for the cluster to recover")

+        self.CM.cluster_stable()

+        if self.driver.failed == 1:

+            return self.failure(self.driver.fail_string)

+

+        return self.success()

+

+    def is_applicable(self):

+        return self.driver.is_applicable()

+

+    def errorstoignore(self):

+        return self.driver.errorstoignore()

+

+AllTestClasses.append(RemoteBasic)

+

+###################################################################

+class RemoteStonithd(CTSTest):

+###################################################################

+    def __init__(self, cm):

+        CTSTest.__init__(self,cm)

+        self.name = "RemoteStonithd"

+        self.start = StartTest(cm)

+        self.startall = SimulStartLite(cm)

+        self.driver = RemoteDriver(cm)

+        self.is_docker_unsafe = 1

+

+    def __call__(self, node):

+        '''Perform the 'RemoteStonithd' test. '''

+        self.incr("calls")

+

+        ret = self.startall(None)

+        if not ret:

+            return self.failure("Setup failed, start all nodes failed.")

+

+        self.driver.setup_env(node)

+        self.driver.start_metal(node)

+        self.driver.add_dummy_rsc(node)

+

+        self.driver.fail_connection(node)

+        self.driver.cleanup_metal(node)

+

+        self.debug("Waiting for the cluster to recover")

+        self.CM.cluster_stable()

+        if self.driver.failed == 1:

+            return self.failure(self.driver.fail_string)

+

+        return self.success()

+

+    def is_applicable(self):

+        if not self.driver.is_applicable():

+            return False

+

+        if self.Env.has_key("DoFencing"):

+            return self.Env["DoFencing"]

+

+        return True

+

+    def errorstoignore(self):

+        ignore_pats = [