diff --git a/TODO.markdown b/TODO.markdown
index 8d3982d67c..dfe6610ab7 100644
--- a/TODO.markdown
+++ b/TODO.markdown
@@ -1,57 +1,56 @@
 # Semi-random collection of tasks we'd like to get done
 
 ## Targeted for 1.2
 - Need a way to indicate when unfencing operations need to be initiated from the host to be unfenced
 - Remove all calls to uname() and replace with get_node_name() whcih redirects to ${stack}_node_name()
  
 ## Targeted for 1.2.x
 
 - Support
   http://cgit.freedesktop.org/systemd/systemd/commit/?id=96342de68d0d6de71a062d984dafd2a0905ed9fe
 - Allow stonith_admin to optionally route fencing requests via the CIB (terminate=true)
 - Add corosync to ComponentFail cts test
 - Support 'yesterday' and 'thursday' and '24-04' as dates in crm_report 
 - Allow the N in 'give up after N failed fencing attempts' to be configurable 
 - Check for uppercase letters in node names, warn if found
 - Imply startup-failure-is-fatal from on-fail="restart" 
 - Show an english version of the config with crm_resource --rules
 - Convert cts/CIB.py into a supported Python API for the CIB
 - Reduce the amount of stonith-ng logging
 - Use dlopen for snmp in crm_mon
 - Re-implement no-quorum filter for cib updates?
 
 ## Targeted for 1.4
 
 - Support A colocated with (B || C || D)
 - Implement a truely atomic version of attrd
 - Support rolling average values in attrd
 - Support heartbeat with the mcp
 - Freeze/Thaw
 - Create Pacemaker plugin for snmpd - http://www.net-snmp.org/
 - Investigate using a DB as the back-end for the CIB
 - Decide whether to fully support or drop failover domains
 
 # Testing
 - Convert BandwidthTest CTS test into a Scenario wrapper
 - find_operations() is not covered by PE regression tests
 - no_quorum_policy==suicide is not covered by PE regression tests
 - parse_xml_duration() is not covered by PE regression tests
 - phase_of_the_moon() is not covered by PE regression tests
 - test_role_expression() is not covered by PE regression tests
 - native_parameter() is not covered by PE regression tests
 - clone_active() is not covered by PE regression tests
 - convert_non_atomic_task() in native.c is not covered by PE regression tests
 - group_rsc_colocation_lh() is not covered by PE regression tests
 - Test on-fail=standby
 
 # Documentation
 - Clusters from Scratch: Mail
 - Clusters from Scratch: MySQL
 - Document reload in Pacemaker Explained
 - Document advanced fencing logic in Pacemaker Explained
 - Use ann:defaultValue="..." instead of <optional> in the schema more often
 - Document in CFS an Appendix detailing with re-enabling firewall
-- Remove ocf:heartbeat part of resource create to demonstrate that the resource is automatically found.
 - Document implicit operation creation in CFS once pcs supports it.
 - Document use of pcs resource move command in CFS once pcs supports it.
 - Make use of --clone option in pcs resource create dlm in CFS once pcs fully supports that option.
diff --git a/doc/Clusters_from_Scratch/en-US/Ch-Shared-Storage.txt b/doc/Clusters_from_Scratch/en-US/Ch-Shared-Storage.txt
index 3ff3697d17..77cac5f42b 100644
--- a/doc/Clusters_from_Scratch/en-US/Ch-Shared-Storage.txt
+++ b/doc/Clusters_from_Scratch/en-US/Ch-Shared-Storage.txt
@@ -1,761 +1,769 @@
 = Replicated Storage with DRBD =
 
 == Background ==
 Even if you're serving up static websites, having to manually synchronize
 the contents of that website to all the machines in the cluster is not
 ideal. For dynamic websites, such as a wiki, it's not even an option. Not
 everyone care afford network-attached storage but somehow the data needs
 to be kept in sync. Enter DRBD which can be thought of as network based
 RAID-1. See http://www.drbd.org/ for more details.
 
 == Install the DRBD Packages ==
 
 Since its inclusion in the upstream 2.6.33 kernel, everything needed
 to use DRBD has shiped with Fedora since version 13. All you need to
 do is install it:
 
 [source,Bash]
 .....
 # yum install -y drbd-pacemaker drbd-udev
 Loaded plugins: langpacks, presto, refresh-packagekit
 Resolving Dependencies
 --> Running transaction check
 ---> Package drbd-pacemaker.x86_64 0:8.3.11-5.fc17 will be installed
 --> Processing Dependency: drbd-utils = 8.3.11-5.fc17 for package: drbd-pacemaker-8.3.11-5.fc17.x86_64
 ---> Package drbd-udev.x86_64 0:8.3.11-5.fc17 will be installed
 --> Running transaction check
 ---> Package drbd-utils.x86_64 0:8.3.11-5.fc17 will be installed
 --> Finished Dependency Resolution
 
 Dependencies Resolved
 
 ======================================================================================
  Package              Arch         Version                Repository             Size
 ======================================================================================
 Installing:
  drbd-pacemaker       x86_64       8.3.11-5.fc17          updates-testing        22 k
  drbd-udev            x86_64       8.3.11-5.fc17          updates-testing       6.4 k
 Installing for dependencies:
  drbd-utils           x86_64       8.3.11-5.fc17          updates-testing       183 k
 
 Transaction Summary
 ======================================================================================
 Install  2 Packages (+1 Dependent package)
 
 Total download size: 212 k
 Installed size: 473 k
 Downloading Packages:
 (1/3): drbd-pacemaker-8.3.11-5.fc17.x86_64.rpm                 |  22 kB     00:00
 (2/3): drbd-udev-8.3.11-5.fc17.x86_64.rpm                      | 6.4 kB     00:00
 (3/3): drbd-utils-8.3.11-5.fc17.x86_64.rpm                     | 183 kB     00:00
 --------------------------------------------------------------------------------------
 Total                                                 293 kB/s | 212 kB     00:00
 Running Transaction Check
 Running Transaction Test
 Transaction Test Succeeded
 Running Transaction
   Installing : drbd-utils-8.3.11-5.fc17.x86_64                                    1/3
   Installing : drbd-pacemaker-8.3.11-5.fc17.x86_64                                2/3
   Installing : drbd-udev-8.3.11-5.fc17.x86_64                                     3/3
   Verifying  : drbd-pacemaker-8.3.11-5.fc17.x86_64                                1/3
   Verifying  : drbd-udev-8.3.11-5.fc17.x86_64                                     2/3
   Verifying  : drbd-utils-8.3.11-5.fc17.x86_64                                    3/3
 
 Installed:
   drbd-pacemaker.x86_64 0:8.3.11-5.fc17        drbd-udev.x86_64 0:8.3.11-5.fc17
 
 Dependency Installed:
   drbd-utils.x86_64 0:8.3.11-5.fc17
 
 Complete!
 .....
 
 == Configure DRBD ==
 
 Before we configure DRBD, we need to set aside some disk for it to use.
 
 === Create A Partition for DRBD ===
 
 If you have more than 1Gb free, feel free to use it. For this guide
 however, 1Gb is plenty of space for a single html file and sufficient for
 later holding the GFS2 metadata.
 
 [source,Bash]
 ----
 # vgdisplay | grep -e Name - e Free
   VG Name               vg_pcmk1
   Free  PE / Size       31 / 992.00 MiB
 # lvs
   LV        VG          Attr     LSize   Pool Origin Data%  Move Log Copy%  Convert
   lv_root   vg_pcmk1 -wi-ao--   8.56g
   lv_swap   vg_pcmk1 -wi-ao-- 960.00m
 # lvcreate -n drbd-demo -L 1G vg_pcmk1
 Logical volume "drbd-demo" created
 # lvs
   LV        VG          Attr     LSize   Pool Origin Data%  Move Log Copy%  Convert
   drbd-demo vg_pcmk1 -wi-a--- 1.00G
   lv_root   vg_pcmk1 -wi-ao--   8.56g
   lv_swap   vg_pcmk1 -wi-ao-- 960.00m
 ----
 
 Repeat this on the second node, be sure to use the same size partition.
 
 [source,Bash]
 ----
 # ssh pcmk-2 -- lvs
 LV   VG    Attr  LSize  Origin Snap% Move Log Copy% Convert
   lv_root   vg_pcmk1 -wi-ao--   8.56g
   lv_swap   vg_pcmk1 -wi-ao-- 960.00m
 # ssh pcmk-2 -- lvcreate -n drbd-demo -L 1G vg_pcmk1
 Logical volume "drbd-demo" created
 # ssh pcmk-2 -- lvs
 LV    VG    Attr  LSize  Origin Snap% Move Log Copy% Convert
   drbd-demo vg_pcmk1 -wi-a--- 1.00G
   lv_root   vg_pcmk1 -wi-ao--   8.56g
   lv_swap   vg_pcmk1 -wi-ao-- 960.00m
 ----
 
 === Write the DRBD Config ===
 
 There is no series of commands for building a DRBD configuration, so simply
 copy the configuration below to /etc/drbd.conf
 
 Detailed information on the directives used in this configuration (and
 other alternatives) is available from
 http://www.drbd.org/users-guide/ch-configure.html
 
 [WARNING]
 =========
 
 Be sure to use the names and addresses of your nodes if they differ from
 the ones used in this guide.
 
 =========
 
 ....
 global {
  usage-count yes;
 }
 common {
  protocol C;
 }
 resource wwwdata {
  meta-disk internal;
  device  /dev/drbd1;
  syncer {
   verify-alg sha1;
  }
  net {
   allow-two-primaries;
  }
  on pcmk-1 {
   disk   /dev/vg_pcmk1/drbd-demo;
   address  192.168.122.101:7789;
  }
  on pcmk-2 {
   disk   /dev/vg_pcmk1/drbd-demo;
   address  192.168.122.102:7789;
  }
 }
 ....
 
 [NOTE]
 =======
 
 TODO: Explain the reason for the allow-two-primaries option
 
 =======
 
 === Initialize and Load DRBD ===
 
 With the configuration in place, we can now perform the DRBD
 initialization
 
 [source,Bash]
 ----
 # drbdadm create-md wwwdata
 Writing meta data...
 initializing activity log
 NOT initialized bitmap
 New drbd meta data block successfully created.
 success
 ----
 
 Now load the DRBD kernel module and confirm that everything is sane
 
 [source,Bash]
 ----
 # modprobe drbd
 # drbdadm up wwwdata
 # cat /proc/drbd
 version: 8.3.11 (api:88/proto:86-96)
 srcversion: 0D2B62DEDB020A425130935
 
  1: cs:Connected ro:Secondary/Secondary ds:Inconsistent/Inconsistent C r-----
     ns:0 nr:0 dw:0 dr:0 al:0 bm:0 lo:0 pe:0 ua:0 ap:0 ep:1 wo:f oos:1015740
 ----
 
 Repeat on the second node
 
 [source,Bash]
 ----
 # ssh pcmk-2 -- drbdadm --force create-md wwwdata
 Writing meta data...
 initializing activity log
 NOT initialized bitmap
 New drbd meta data block successfully created.
 success
 # ssh pcmk-2 -- modprobe drbd
 WARNING: Deprecated config file /etc/modprobe.conf, all config files belong into /etc/modprobe.d/.
 # ssh pcmk-2 -- drbdadm up wwwdata
 # ssh pcmk-2 -- cat /proc/drbd
 version: 8.3.11 (api:88/proto:86-96)
 srcversion: 0D2B62DEDB020A425130935
 
  1: cs:Connected ro:Secondary/Secondary ds:Inconsistent/Inconsistent C r-----
     ns:0 nr:0 dw:0 dr:0 al:0 bm:0 lo:0 pe:0 ua:0 ap:0 ep:1 wo:f oos:1015740
 ----
 
 Now we need to tell DRBD which set of data to use. Since both sides
 contain garbage, we can run the following on pcmk-1:
 
 [source,Bash]
 ----
 # drbdadm -- --overwrite-data-of-peer primary wwwdata
 # cat /proc/drbd
 version: 8.3.11 (api:88/proto:86-96)
 srcversion: 0D2B62DEDB020A425130935
 
  1: cs:SyncSource ro:Primary/Secondary ds:UpToDate/Inconsistent C r-----
     ns:8064 nr:0 dw:0 dr:8728 al:0 bm:0 lo:0 pe:1 ua:0 ap:0 ep:1 wo:f oos:1007804
 	[>....................] sync'ed:  0.9% (1007804/1015740)K
 	finish: 0:12:35 speed: 1,320 (1,320) K/sec
 ----
 
 After a while, the sync should finish and you'll see:
 
 [source,Bash]
 ----
 # cat /proc/drbd
 version: 8.3.11 (api:88/proto:86-96)
 srcversion: 0D2B62DEDB020A425130935
 
  1: cs:Connected ro:Primary/Secondary ds:UpToDate/UpToDate C r-----
     ns:1015740 nr:0 dw:0 dr:1016404 al:0 bm:62 lo:0 pe:0 ua:0 ap:0 ep:1 wo:f oos:0
 ----
 
 pcmk-1 is now in the Primary state which allows it to be written to.
 Which means it's a good point at which to create a filesystem and populate
 it with some data to serve up via our WebSite resource.
 
 
 === Populate DRBD with Data ===
 
 [source,Bash]
 ----
 # mkfs.ext4 /dev/drbd1
 mke2fs 1.42 (29-Nov-2011)
 Filesystem label=
 OS type: Linux
 Block size=4096 (log=2)
 Fragment size=4096 (log=2)
 Stride=0 blocks, Stripe width=0 blocks
 63488 inodes, 253935 blocks
 12696 blocks (5.00%) reserved for the super user
 First data block=0
 Maximum filesystem blocks=260046848
 8 block groups
 32768 blocks per group, 32768 fragments per group
 7936 inodes per group
 Superblock backups stored on blocks:
 	32768, 98304, 163840, 229376
 
 Allocating group tables: done
 Writing inode tables: done
 Creating journal (4096 blocks): done
 Writing superblocks and filesystem accounting information: done
 ----
 
 Now mount the newly created filesystem so we can create our index file
 
 [source,Bash]
 ----
 # mount /dev/drbd1 /mnt/
 # cat <<-END >/mnt/index.html
  <html>
   <body>My Test Site - drbd</body>
  </html>
 END
 # umount /dev/drbd1
 ----
 
 == Configure the Cluster for DRBD ==
 
 ifdef::pcs[]
 
 One handy feature pcs has is the ability to queue up several changes
 into a file and commit those changes atomically.  To do this, start by
 populating the file with the current raw xml config from the cib.  This
 can be done using the following command.
 
 [source,Bash]
 ----
 # pcs cluster cib drbd_cfg
 ----
 
 Now using the pcs -f option, make changes to the configuration saved
 in the drbd_cfg file.  These changes will not be seen by the cluster until
 the drbd_cfg file is pushed into the live cluster's cib later on.
 
 [source,Bash]
 ----
 # pcs -f drbd_cfg resource create WebData ocf:linbit:drbd \
          drbd_resource=wwwdata op monitor interval=60s
 # pcs -f drbd_cfg resource master WebDataClone WebData \
          master-max=1 master-node-max=1 clone-max=2 clone-node-max=1 \
          notify=true
 # pcs -f drbd_cfg resource show
  ClusterIP	(ocf::heartbeat:IPaddr2) Started 
  WebSite	(ocf::heartbeat:apache) Started 
  Master/Slave Set: WebDataClone [WebData]
      Stopped: [ WebData:0 WebData:1 ]
 ----
 
 After you are satisfied with all the changes, you can commit all
 the changes at once by pushing the drbd_cfg file into the live
 cib.
 
 [source,Bash]
 ----
 # pcs cluster push cib drbd_cfg 
 CIB updated
 #
 # pcs status
 
 Last updated: Fri Sep 14 12:19:49 2012
 Last change: Fri Sep 14 12:19:13 2012 via cibadmin on pcmk-1
 Stack: corosync
 Current DC: pcmk-2 (2) - partition with quorum
 Version: 1.1.8-1.el7-60a19ed12fdb4d5c6a6b6767f52e5391e447fec0
 2 Nodes configured, unknown expected votes
 4 Resources configured.
 
 Online: [ pcmk-1 pcmk-2 ]
 
 Full list of resources:
 
  ClusterIP	(ocf::heartbeat:IPaddr2):	Started pcmk-1
  WebSite	(ocf::heartbeat:apache):	Started pcmk-1
  Master/Slave Set: WebDataClone [WebData]
      Masters: [ pcmk-1 ]
      Slaves: [ pcmk-2 ]
 ----
 endif::[]
 
 ifdef::crm[]
 One handy feature of the crm shell is that you can use it in
 interactive mode to make several changes atomically.
 
 First we launch the shell. The prompt will change to indicate you're
 in interactive mode.
 
 [source,Bash]
 ----
 # crm
 crm(live) #
 ----
 
 Next we must create a working copy of the current configuration. This is
 where all our changes will go. The cluster will not see any of them until
 we say it's ok. Notice again how the prompt changes, this time to indicate
 that we're no longer looking at the live cluster.
 
 [source,Bash]
 ----
 cib crm(live) # cib new drbd
 INFO: drbd shadow CIB created
 crm(drbd) #
 ----
 
 Now we can create our DRBD clone and display the revised configuration.
 
 [source,Bash]
 ----
 crm(drbd) # configure primitive WebData ocf:linbit:drbd params drbd_resource=wwwdata \
     op monitor interval=60s
 crm(drbd) # configure ms WebDataClone WebData meta master-max=1 master-node-max=1 \
     clone-max=2 clone-node-max=1 notify=true
 crm(drbd) # configure show
 node $id="1702537408" pcmk-1
 node $id="1719314624" pcmk-2
 primitive ClusterIP ocf:heartbeat:IPaddr2 \
 	params ip="192.168.122.120" cidr_netmask="32" \
 	op monitor interval="30s"
 primitive WebData ocf:linbit:drbd \
 	params drbd_resource="wwwdata" \
 	op monitor interval="60s"
 primitive WebSite ocf:heartbeat:apache \
 	params configfile="/etc/httpd/conf/httpd.conf" \
 	op monitor interval="1min"
 ms WebDataClone WebData \
 	meta master-max="1" master-node-max="1" clone-max="2" clone-node-max="1" notify="true"
 location prefer-pcmk-1 WebSite 50: pcmk-1
 colocation website-with-ip inf: WebSite ClusterIP
 order apache-after-ip inf: ClusterIP WebSite
 property $id="cib-bootstrap-options" \
 	dc-version="1.1.7-2.fc17-ee0730e13d124c3d58f00016c3376a1de5323cff" \
 	cluster-infrastructure="corosync" \
 	stonith-enabled="false" \
 	no-quorum-policy="ignore" \
 	last-lrm-refresh="1333446866"
 rsc_defaults $id="rsc-options" \
 	resource-stickiness="100"
 op_defaults $id="op-options" \
 	timeout="240s"
 ----
 
 Once we're happy with the changes, we can tell the cluster to start using
 them and use crm_mon to check everything is functioning.
 
 [source,Bash]
 ----
 crm(drbd) # cib commit drbd
 INFO: commited 'drbd' shadow CIB to the cluster
 crm(drbd) # quit
 bye
 # crm_mon -1
 ============
 Last updated: Tue Apr  3 13:50:01 2012
 Last change: Tue Apr  3 13:49:46 2012 via crm_shadow on pcmk-1
 Stack: corosync
 Current DC: pcmk-1 (1702537408) - partition with quorum
 Version: 1.1.7-2.fc17-ee0730e13d124c3d58f00016c3376a1de5323cff
 2 Nodes configured, unknown expected votes
 4 Resources configured.
 ============
 
 Online: [ pcmk-1 pcmk-2 ]
 
  ClusterIP	(ocf::heartbeat:IPaddr2):	Started pcmk-1
  WebSite	(ocf::heartbeat:apache):	Started pcmk-1
  Master/Slave Set: WebDataClone [WebData]
      Masters: [ pcmk-1 ]
      Slaves: [ pcmk-2 ]
 ----
 endif::[]
 
 [NOTE]
 =======
 
 TODO: Include details on adding a second DRBD resource
 
 =======
 
 Now that DRBD is functioning we can configure a Filesystem resource to
 use it. In addition to the filesystem's definition, we also need to
 tell the cluster where it can be located (only on the DRBD Primary)
 and when it is allowed to start (after the Primary was promoted).
 
 ifdef::pcs[]
+We are going to take a shortcut when creating the resource this time though.
+Instead of explicitly saying we want the 'ocf:heartbeat:Filesystem' script, we
+are only going to ask for 'Filesystem'. We can do this because we know there is only
+one resource script named 'Filesystem' available to pacemaker, and that pcs is smart
+enough to fill in the 'ocf:heartbeat' portion for us correctly in the configuration.
+If there were multiple 'Filesystem' scripts from different ocf providers, we would need
+to specify the exact one we wanted to use.
+
 Once again we will queue up our changes to a file and then push the
 new configuration to the cluster as the final step.
 
 [source,Bash]
 ----
 # pcs cluster cib fs_cfg
-# pcs -f fs_cfg resource create WebFS ocf:heartbeat:Filesystem \
+# pcs -f fs_cfg resource create WebFS Filesystem \
          device="/dev/drbd/by-res/wwwdata" directory="/var/www/html" \
          fstype="ext4"
 # pcs -f fs_cfg constraint colocation add WebFS WebDataClone INFINITY with-rsc-role=Master
 # pcs -f fs_cfg constraint order promote WebDataClone then start WebFS
 Adding WebDataClone WebFS (kind: Mandatory) (Options: first-action=promote then-action=start)
 ----
 
 We also need to tell the cluster that Apache needs to run on the same
 machine as the filesystem and that it must be active before Apache can
 start.
 
 [source,Bash]
 ----
 # pcs -f fs_cfg constraint colocation add WebSite WebFS INFINITY
 # pcs -f fs_cfg constraint order WebFS then WebSite
 ----
 
 Now review the updated configuration.
 
 [source,Bash]
 ----
 # pcs -f fs_cfg constraint
 Location Constraints:
 Ordering Constraints:
   start ClusterIP then start WebSite
   WebFS then WebSite
   promote WebDataClone then start WebFS
 Colocation Constraints:
   WebSite with ClusterIP
   WebFS with WebDataClone (with-rsc-role:Master)
   WebSite with WebFS
 #
 # pcs -f fs_cfg resource show
  ClusterIP	(ocf::heartbeat:IPaddr2) Started 
  WebSite	(ocf::heartbeat:apache) Started 
  Master/Slave Set: WebDataClone [WebData]
      Masters: [ pcmk-1 ]
      Slaves: [ pcmk-2 ]
  WebFS	(ocf::heartbeat:Filesystem) Stopped 
 ----
 
 endif::[]
 
 ifdef::crm[]
 Once again we'll use the shell's interactive mode
 
 [source,Bash]
 ----
 # crm
 crm(live) # cib new fs
 INFO: fs shadow CIB created
 crm(fs) # configure primitive WebFS ocf:heartbeat:Filesystem \
     params device="/dev/drbd/by-res/wwwdata" directory="/var/www/html" fstype="ext4"
 crm(fs) # configure colocation fs_on_drbd inf: WebFS WebDataClone:Master
 crm(fs) # configure order WebFS-after-WebData inf: WebDataClone:promote WebFS:start
 ----
 
 We also need to tell the cluster that Apache needs to run on the same
 machine as the filesystem and that it must be active before Apache can
 start.
 
 [source,Bash]
 ----
 crm(fs) # configure colocation WebSite-with-WebFS inf: WebSite WebFS
 crm(fs) # configure order WebSite-after-WebFS inf: WebFS WebSite
 ----
 
 Time to review the updated configuration:
 
 [source,Bash]
 ----
 crm(fs) # configure show
 node $id="1702537408" pcmk-1
 node $id="1719314624" pcmk-2
 primitive ClusterIP ocf:heartbeat:IPaddr2 \
 	params ip="192.168.122.120" cidr_netmask="32" \
 	op monitor interval="30s"
 primitive WebData ocf:linbit:drbd \
 	params drbd_resource="wwwdata" \
 	op monitor interval="60s"
 primitive WebFS ocf:heartbeat:Filesystem \
 	params device="/dev/drbd/by-res/wwwdata" directory="/var/www/html" fstype="ext4"
 primitive WebSite ocf:heartbeat:apache \
 	params configfile="/etc/httpd/conf/httpd.conf" \
 	op monitor interval="1min"
 ms WebDataClone WebData \
 	meta master-max="1" master-node-max="1" clone-max="2" clone-node-max="1" notify="true"
 location prefer-pcmk-1 WebSite 50: pcmk-1
 colocation WebSite-with-WebFS inf: WebSite WebFS
 colocation fs_on_drbd inf: WebFS WebDataClone:Master
 colocation website-with-ip inf: WebSite ClusterIP
 order WebFS-after-WebData inf: WebDataClone:promote WebFS:start
 order WebSite-after-WebFS inf: WebFS WebSite
 order apache-after-ip inf: ClusterIP WebSite
 property $id="cib-bootstrap-options" \
 	dc-version="1.1.7-2.fc17-ee0730e13d124c3d58f00016c3376a1de5323cff" \
 	cluster-infrastructure="corosync" \
 	stonith-enabled="false" \
 	no-quorum-policy="ignore" \
 	last-lrm-refresh="1333446866"
 rsc_defaults $id="rsc-options" \
 	resource-stickiness="100"
 op_defaults $id="op-options" \
 	timeout="240s"
 ----
 endif::[]
 
 After reviewing the new configuration, we again upload it and watch the
 cluster put it into effect.
 
 ifdef::pcs[]
 [source,Bash]
 ----
 # pcs cluster push cib fs_cfg
 CIB updated
 # pcs status
  Last updated: Fri Aug 10 12:47:01 2012
 
  Last change: Fri Aug 10 12:46:55 2012 via cibadmin on pcmk-1
  Stack: corosync
  Current DC: pcmk-1 (1) - partition with quorum
  Version: 1.1.8-1.el7-60a19ed12fdb4d5c6a6b6767f52e5391e447fec0
  2 Nodes configured, unknown expected votes
  5 Resources configured.
 
 Online: [ pcmk-1 pcmk-2 ]
 
 Full list of resources:
 
  ClusterIP	(ocf::heartbeat:IPaddr2):	Started pcmk-1
  WebSite	(ocf::heartbeat:apache):	Started pcmk-1
  Master/Slave Set: WebDataClone [WebData]
      Masters: [ pcmk-1 ]
      Slaves: [ pcmk-2 ]
  WebFS	(ocf::heartbeat:Filesystem):	Started pcmk-1
 ----
 endif::[]
 
 ifdef::crm[]
 [source,Bash]
 ----
 crm(fs) # cib commit fs
 INFO: commited 'fs' shadow CIB to the cluster
 crm(fs) # quit
 bye
 # crm_mon -1
 ============
 Last updated: Tue Apr  3 13:52:21 2012
 Last change: Tue Apr  3 13:52:06 2012 via crm_shadow on pcmk-1
 Stack: corosync
 Current DC: pcmk-1 (1702537408) - partition with quorum
 Version: 1.1.7-2.fc17-ee0730e13d124c3d58f00016c3376a1de5323cff
 2 Nodes configured, unknown expected votes
 5 Resources configured.
 ============
 
 Online: [ pcmk-1 pcmk-2 ]
 
  ClusterIP	(ocf::heartbeat:IPaddr2):	Started pcmk-1
  WebSite	(ocf::heartbeat:apache):	Started pcmk-1
  Master/Slave Set: WebDataClone [WebData]
      Masters: [ pcmk-1 ]
      Slaves: [ pcmk-2 ]
  WebFS	(ocf::heartbeat:Filesystem):	Started pcmk-1
 ----
 endif::[]
 
 === Testing Migration ===
 
 We could shut down the active node again, but another way to safely
 simulate recovery is to put the node into what is called "standby
 mode".  Nodes in this state tell the cluster that they are not allowed
 to run resources. Any resources found active there will be moved
 elsewhere. This feature can be particularly useful when updating the
 resources' packages.
 
 Put the local node into standby mode and observe the cluster move all
 the resources to the other node. Note also that the node's status will
 change to indicate that it can no longer host resources.
 
 ifdef::pcs[]
 [source,Bash]
 ----
 # pcs cluster standby pcmk-1
 # pcs status
 
 Last updated: Fri Sep 14 12:41:12 2012
 Last change: Fri Sep 14 12:41:08 2012 via crm_attribute on pcmk-1
 Stack: corosync
 Current DC: pcmk-1 (1) - partition with quorum
 Version: 1.1.8-1.el7-60a19ed12fdb4d5c6a6b6767f52e5391e447fec0
 2 Nodes configured, unknown expected votes
 5 Resources configured.
 
 Node pcmk-1 (1): standby
 Online: [ pcmk-2 ]
 
 Full list of resources:
 
 ClusterIP	(ocf::heartbeat:IPaddr2):	Started pcmk-2
 WebSite (ocf::heartbeat:apache):        Started pcmk-2
  Master/Slave Set: WebDataClone [WebData]
      Masters: [ pcmk-2 ]
      Stopped: [ WebData:1 ]
 WebFS   (ocf::heartbeat:Filesystem):    Started pcmk-2
 ----
 endif::[]
 
 ifdef::crm[]
 [source,Bash]
 ----
 # crm node standby
 # crm_mon -1
 ============
 Last updated: Tue Apr  3 13:59:14 2012
 Last change: Tue Apr  3 13:52:36 2012 via crm_attribute	on pcmk-1
 Stack: corosync
 Current DC: pcmk-1 (1702537408)	- partition with quorum
 Version: 1.1.7-2.fc17-ee0730e13d124c3d58f00016c3376a1de5323cff
 2 Nodes configured, unknown expected votes
 5 Resources configured.
 ============
 
 Node pcmk-1 (1702537408): standby
 Online: [ pcmk-2 ]
 
 ClusterIP	(ocf::heartbeat:IPaddr2):	Started pcmk-2
 WebSite (ocf::heartbeat:apache):        Started pcmk-2
  Master/Slave Set: WebDataClone [WebData]
      Masters: [ pcmk-2 ]
      Stopped: [ WebData:1 ]
 WebFS   (ocf::heartbeat:Filesystem):    Started pcmk-2
 ----
 endif::[]
 
 Once we've done everything we needed to on pcmk-1 (in this case nothing,
 we just wanted to see the resources move), we can allow the node to be a
 full cluster member again.
 
 ifdef::pcs[]
 [source,Bash]
 ----
 # pcs cluster unstandby pcmk-1
 # pcs status
 
 Last updated: Fri Sep 14 12:43:02 2012
 Last change: Fri Sep 14 12:42:57 2012 via crm_attribute on pcmk-1
 Stack: corosync
 Current DC: pcmk-1 (1) - partition with quorum
 Version: 1.1.8-1.el7-60a19ed12fdb4d5c6a6b6767f52e5391e447fec0
 2 Nodes configured, unknown expected votes
 5 Resources configured.
 
 Online: [ pcmk-1 pcmk-2 ]
 
 Full list of resources:
 
  ClusterIP	(ocf::heartbeat:IPaddr2):	Started pcmk-2
  WebSite	(ocf::heartbeat:apache):	Started pcmk-2
  Master/Slave Set: WebDataClone [WebData]
      Masters: [ pcmk-2 ]
      Slaves: [ pcmk-1 ]
  WebFS	(ocf::heartbeat:Filesystem):	Started pcmk-2
 ----
 endif::[]
 
 ifdef::crm[]
 [source,Bash]
 ----
 # crm node online
 # crm_mon -1
 ============
 Last updated: Tue Apr  3 14:00:06 2012
 Last change: Tue Apr  3 14:00:00 2012 via crm_attribute on pcmk-1
 Stack: corosync
 Current DC: pcmk-1 (1702537408) - partition with quorum
 Version: 1.1.7-2.fc17-ee0730e13d124c3d58f00016c3376a1de5323cff
 2 Nodes configured, unknown expected votes
 5 Resources configured.
 ============
 
 Online: [ pcmk-1 pcmk-2 ]
 
  ClusterIP	(ocf::heartbeat:IPaddr2):	Started pcmk-2
  WebSite	(ocf::heartbeat:apache):	Started pcmk-2
  Master/Slave Set: WebDataClone [WebData]
      Masters: [ pcmk-2 ]
      Slaves: [ pcmk-1 ]
  WebFS	(ocf::heartbeat:Filesystem):	Started pcmk-2
 ----
 endif::[]
 
 Notice that our resource stickiness settings prevent the services from
 migrating back to pcmk-1.
 
diff --git a/fencing/internal.h b/fencing/internal.h
index 3c67ac021c..004988e214 100644
--- a/fencing/internal.h
+++ b/fencing/internal.h
@@ -1,112 +1,113 @@
 #include <crm/common/mainloop.h>
 
 typedef struct stonith_device_s {
     char *id;
     char *agent;
     char *namespace;
 
     GListPtr targets;
     time_t targets_age;
     gboolean has_attr_map;
     guint priority;
     guint active_pid;
 
     GHashTable *params;
     GHashTable *aliases;
     GList *pending_ops;
     crm_trigger_t *work;
 
 } stonith_device_t;
 
 typedef struct stonith_client_s {
     char *id;
     char *name;
 
     int pid;
     int request_id;
 
     char *channel_name;
     qb_ipcs_connection_t *channel;
 
     long long flags;
 
 } stonith_client_t;
 
 typedef struct remote_fencing_op_s {
     char *id;
     char *target;
     char *action;
     guint replies;
 
     gint op_timer_total;
     gint op_timer_one;
     gint query_timer;
     gint base_timeout;
     gint total_timeout;
 
     char *delegate;
     time_t completed;
     long long call_options;
 
     enum op_state state;
     char *originator;
     char *client_id;
     char *client_name;
     GListPtr query_results;
     xmlNode *request;
 
     guint level;
     int topology_device_number;
 
     GListPtr devices;
     GListPtr duplicates;
 
+    gboolean notify_sent;
 } remote_fencing_op_t;
 
 typedef struct stonith_topology_s {
     char *node;
     GListPtr levels[ST_LEVEL_MAX];
 
 } stonith_topology_t;
 
 extern long long get_stonith_flag(const char *name);
 
 extern void stonith_command(stonith_client_t * client, uint32_t id, uint32_t flags, xmlNode * op_request, const char *remote);
 
 extern int stonith_device_register(xmlNode * msg, const char **desc);
 
 extern int stonith_level_register(xmlNode * msg, char **desc);
 
 extern int stonith_level_remove(xmlNode * msg, char **desc);
 
 extern void do_local_reply(xmlNode * notify_src, const char *client_id, gboolean sync_reply,
                            gboolean from_peer);
 
 extern xmlNode *stonith_construct_reply(xmlNode * request, char *output, xmlNode * data, int rc);
 
 void
 do_stonith_async_timeout_update(const char *client, const char *call_id, int timeout);
 
 extern void do_stonith_notify(int options, const char *type, int result, xmlNode * data, const char *remote);
 
 extern remote_fencing_op_t *initiate_remote_stonith_op(stonith_client_t * client, xmlNode * request,
                                                        gboolean manual_ack);
 
 extern int process_remote_stonith_exec(xmlNode * msg);
 
 extern int process_remote_stonith_query(xmlNode * msg);
 
 extern void *create_remote_stonith_op(const char *client, xmlNode * request, gboolean peer);
 
 extern int stonith_fence_history(xmlNode * msg, xmlNode ** output);
 
 extern void free_device(gpointer data);
 
 extern void free_topology_entry(gpointer data);
 
 
 extern char *stonith_our_uname;
 extern gboolean stand_alone;
 extern GHashTable *device_list;
 extern GHashTable *topology;
 extern GHashTable *client_list;
diff --git a/fencing/regression.py.in b/fencing/regression.py.in
index 7b9a1bc88a..eac438e209 100644
--- a/fencing/regression.py.in
+++ b/fencing/regression.py.in
@@ -1,697 +1,785 @@
 #!/usr/bin/python
 
 #
 # This program is free software; you can redistribute it and/or
 # modify it under the terms of the GNU General Public License
 # as published by the Free Software Foundation; either version 2
 # of the License, or (at your option) any later version.
 #
 # This program is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU General Public License for more details.
 #
 # You should have received a copy of the GNU General Public License
 # along with this program; if not, write to the Free Software
 # Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA.
 
 
 import os
 import sys
 import subprocess
 import shlex
 import time
 
 def output_from_command(command):
 	test = subprocess.Popen(shlex.split(command), stdout=subprocess.PIPE, stderr=subprocess.PIPE)
 	test.wait()
 
 	return test.communicate()[0].split("\n")
 
 class Test:
 	def __init__(self, name, description, verbose = 0, with_cpg = 0):
 		self.name = name
 		self.description = description
 		self.cmds = []
 		self.verbose = verbose
 
 		self.result_txt = ""
 		self.cmd_tool_output = ""
 		self.result_exitcode = 0;
 
 		self.stonith_options = "-s"
 		self.enable_corosync = 0
 
 		if with_cpg:
 			self.stonith_options = "-c"
 			self.enable_corosync = 1
 
 		self.stonith_process = None
 		self.stonith_output = ""
 		self.stonith_patterns = []
 		self.negative_stonith_patterns = []
 
 		self.executed = 0
 
 		rsc_classes = output_from_command("crm_resource --list-standards")
 
 	def __new_cmd(self, cmd, args, exitcode, stdout_match = "", no_wait = 0, stdout_negative_match = "", kill=None):
 		self.cmds.append(
 			{
 				"cmd" : cmd,
 				"kill" : kill,
 				"args" : args,
 				"expected_exitcode" : exitcode,
 				"stdout_match" : stdout_match,
 				"stdout_negative_match" : stdout_negative_match,
 				"no_wait" : no_wait,
 			}
 		)
 
-	def start_corosync(self):
-		if self.enable_corosync == 0:
-			return
-
-		if self.verbose:
-			print "Starting corosync"
-
-		test = subprocess.Popen("corosync", stdout=subprocess.PIPE)
-		test.wait()
-		time.sleep(10)
-
-	def stop_corosync(self):
-		if self.enable_corosync == 0:
-			return
-
-		cmd = shlex.split("killall -9 -q corosync")
-		test = subprocess.Popen(cmd, stdout=subprocess.PIPE)
-		test.wait()
-
 	def stop_pacemaker(self):
 		cmd = shlex.split("killall -9 -q pacemakerd")
 		test = subprocess.Popen(cmd, stdout=subprocess.PIPE)
 		test.wait()
 
 	def start_environment(self):
 		### make sure we are in full control here ###
 		self.stop_pacemaker()
-		self.stop_corosync()
 
 		cmd = shlex.split("killall -9 -q stonithd")
 		test = subprocess.Popen(cmd, stdout=subprocess.PIPE)
 		test.wait()
 
-		self.start_corosync()
 		if self.verbose:
 			print "Starting stonithd with %s" % self.stonith_options
 
 		self.stonith_process = subprocess.Popen(
 			shlex.split("@CRM_DAEMON_DIR@/stonithd %s -V" % self.stonith_options),
 			stdout=subprocess.PIPE,
 			stderr=subprocess.PIPE)
 
 		time.sleep(1)
 
 	def clean_environment(self):
 		if self.stonith_process:
 			self.stonith_process.terminate()
 
 		self.stonith_output = self.stonith_process.communicate()[1]
 		self.stonith_process = None
 
 		if self.verbose:
 			print self.stonith_output
 
-			if os.path.exists('/var/log/corosync.log'):
-				print "Daemon output"
-				f = open('/var/log/corosync.log', 'r')
-				for line in f.readlines():
-					print line.strip()
-				os.remove('/var/log/corosync.log')
-
-		self.stop_corosync()
-
 	def add_stonith_log_pattern(self, pattern):
 		self.stonith_patterns.append(pattern)
 
 	def add_stonith_negative_log_pattern(self, pattern):
 		self.negative_stonith_patterns.append(pattern)
 
 	def add_cmd(self, cmd, args):
 		self.__new_cmd(cmd, args, 0, "")
 
 	def add_cmd_no_wait(self, cmd, args):
 		self.__new_cmd(cmd, args, 0, "", 1)
 
 	def add_cmd_check_stdout(self, cmd, args, match, no_match = ""):
 		self.__new_cmd(cmd, args, 0, match, 0, no_match)
 
 	def add_expected_fail_cmd(self, cmd, args, exitcode = 255):
 		self.__new_cmd(cmd, args, exitcode, "")
 
 	def get_exitcode(self):
 		return self.result_exitcode
 
 	def print_result(self, filler):
 		print "%s%s" % (filler, self.result_txt)
 
 	def run_cmd(self, args):
 		cmd = shlex.split(args['args'])
 		cmd.insert(0, args['cmd'])
 
 		if self.verbose:
 			print "\n\nRunning: "+" ".join(cmd)
 		test = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
 
 		if args['kill']:
 			if self.verbose:
 				print "Also running: "+args['kill']
 			subprocess.Popen(shlex.split(args['kill']))
 
 		if args['no_wait'] == 0:
 			test.wait()
 		else:
 			return 0
 
 		output = test.communicate()[0]
 		if self.verbose:
 			print output
 
 		if args['stdout_match'] != "" and output.count(args['stdout_match']) == 0:
 			test.returncode = -2
 			print "STDOUT string '%s' was not found in cmd output: %s" % (args['stdout_match'], output)
 
 		if args['stdout_negative_match'] != "" and output.count(args['stdout_negative_match']) != 0:
 			test.returncode = -2
 			print "STDOUT string '%s' was found in cmd output: %s" % (args['stdout_negative_match'], output)
 
 		return test.returncode;
 
 
 	def count_negative_matches(self, outline):
 		count = 0
 		for line in self.negative_stonith_patterns:
 			if outline.count(line):
 				count = 1
 				if self.verbose:
 					print "This pattern should not have matched = '%s" % (line)
 		return count
 
 	def match_stonith_patterns(self):
 		negative_matches = 0
 		cur = 0
 		pats = self.stonith_patterns
 		total_patterns = len(self.stonith_patterns)
 
 		if len(self.stonith_patterns) == 0:
 			return
 
 		for line in self.stonith_output.split("\n"):
 			negative_matches = negative_matches + self.count_negative_matches(line)
 			if len(pats) == 0:
 				continue
 			cur = -1
 			for p in pats:
 				cur = cur + 1
 				if line.count(pats[cur]):
 					del pats[cur]
+					break
 
 		if len(pats) > 0 or negative_matches:
 			if self.verbose:
 				for p in pats:
 					print "Pattern Not Matched = '%s'" % p
 
 			self.result_txt = "FAILURE - '%s' failed. %d patterns out of %d not matched. %d negative matches." % (self.name, len(pats), total_patterns, negative_matches)
 			self.result_exitcode = -1
 
 	def run(self):
 		res = 0
 		i = 1
 		self.start_environment()
 
 		if self.verbose:
 			print "\n--- START TEST - %s" % self.name
 
 		self.result_txt = "SUCCESS - '%s'" % (self.name)
 		self.result_exitcode = 0
 		for cmd in self.cmds:
 			res = self.run_cmd(cmd)
 			if res != cmd['expected_exitcode']:
 				print "Step %d FAILED - command returned %d, expected %d" % (i, res, cmd['expected_exitcode'])
 				self.result_txt = "FAILURE - '%s' failed at step %d. Command: lrmd_test %s" % (self.name, i, cmd['args'])
 				self.result_exitcode = -1
 				break
 			else:
 				if self.verbose:
 					print "Step %d SUCCESS" % (i)
 			i = i + 1
 		self.clean_environment()
 
 		if self.result_exitcode == 0:
 			self.match_stonith_patterns()
 
 		print self.result_txt
 		if self.verbose:
 			print "--- END TEST - %s\n" % self.name
 
 		self.executed = 1
 		return res
 
 class Tests:
 	def __init__(self, verbose = 0):
 		self.tests = []
 		self.verbose = verbose
 		self.autogen_corosync_cfg = 0
 		if not os.path.exists("/etc/corosync/corosync.conf"):
 			self.autogen_corosync_cfg = 1
 
 	def new_test(self, name, description, with_cpg = 0):
 		test = Test(name, description, self.verbose, with_cpg)
 		self.tests.append(test)
 		return test
 
 	def print_list(self):
 		print "\n==== %d TESTS FOUND ====" % (len(self.tests))
 		print "%35s - %s" % ("TEST NAME", "TEST DESCRIPTION")
 		print "%35s - %s" % ("--------------------", "--------------------")
 		for test in self.tests:
 			print "%35s - %s" % (test.name, test.description)
 		print "==== END OF LIST ====\n"
 
+
+	def start_corosync(self):
+		if self.verbose:
+			print "Starting corosync"
+
+		test = subprocess.Popen("corosync", stdout=subprocess.PIPE)
+		test.wait()
+		time.sleep(10)
+
+	def stop_corosync(self):
+		cmd = shlex.split("killall -9 -q corosync")
+		test = subprocess.Popen(cmd, stdout=subprocess.PIPE)
+		test.wait()
+
 	def run_single(self, name):
 		for test in self.tests:
 			if test.name == name:
 				test.run()
 				break;
 
 	def run_tests_matching(self, pattern):
 		for test in self.tests:
 			if test.name.count(pattern) != 0:
 				test.run()
 
 	def run_cpg_only(self):
 		for test in self.tests:
 			if test.enable_corosync:
 				test.run()
 
 	def run_no_cpg(self):
 		for test in self.tests:
 			if not test.enable_corosync:
 				test.run()
 
 	def run_tests(self):
 		for test in self.tests:
 			test.run()
 
 	def exit(self):
 		for test in self.tests:
 			if test.executed == 0:
 				continue
 
 			if test.get_exitcode() != 0:
 				sys.exit(-1)
 
 		sys.exit(0)
 
 	def print_results(self):
 		failures = 0;
 		success = 0;
 		print "\n\n======= FINAL RESULTS =========="
 		print "\n--- FAILURE RESULTS:"
 		for test in self.tests:
 			if test.executed == 0:
 				continue
 
 			if test.get_exitcode() != 0:
 				failures = failures + 1
 				test.print_result("    ")
 			else:
 				success = success + 1
 
 		if failures == 0:
 			print "    None"
 
 		print "\n--- TOTALS\n    Pass:%d\n    Fail:%d\n" % (success, failures)
 	def build_api_sanity_tests(self):
 		verbose_arg = ""
 		if self.verbose:
 			verbose_arg = "-V"
 
 		test = self.new_test("standalone_low_level_api_test", "Sanity test client api in standalone mode.")
 		test.add_cmd("@CRM_DAEMON_DIR@/stonith-test", "-t %s" % (verbose_arg))
 
 		test = self.new_test("cpg_low_level_api_test", "Sanity test client api using mainloop and cpg.", 1)
 		test.add_cmd("@CRM_DAEMON_DIR@/stonith-test", "-m %s" % (verbose_arg))
 
 	def build_custom_timeout_tests(self):
 		# custom timeout without topology
 		test = self.new_test("cpg_custom_timeout_1",
 				"Verify per device timeouts work as expected without using topology.", 1)
 		test.add_cmd("stonith_admin", "-R false1 -a fence_false -o \"pcmk_host_list=node1 node2 node3\"")
 		test.add_cmd("stonith_admin", "-R true1  -a fence_true -o \"pcmk_host_list=node3\" -o \"pcmk_off_timeout=1\"")
 		test.add_cmd("stonith_admin", "-R false2 -a fence_false -o \"pcmk_host_list=node3\" -o \"pcmk_off_timeout=4\"")
 		test.add_cmd("stonith_admin", "-F node3 -t 2")
 		# timeout is 2+1+4 = 7
 		test.add_stonith_log_pattern("remote op timeout set to 7")
 
 		# custom timeout _WITH_ topology
 		test = self.new_test("cpg_custom_timeout_2",
 				"Verify per device timeouts work as expected _WITH_ topology.", 1)
 		test.add_cmd("stonith_admin", "-R false1 -a fence_false -o \"pcmk_host_list=node1 node2 node3\"")
 		test.add_cmd("stonith_admin", "-R true1  -a fence_true -o \"pcmk_host_list=node3\" -o \"pcmk_off_timeout=1\"")
 		test.add_cmd("stonith_admin", "-R false2 -a fence_false -o \"pcmk_host_list=node3\" -o \"pcmk_off_timeout=4000\"")
 		test.add_cmd("stonith_admin", "-r node3 -i 1 -v false1")
 		test.add_cmd("stonith_admin", "-r node3 -i 2 -v true1")
 		test.add_cmd("stonith_admin", "-r node3 -i 3 -v false2")
 		test.add_cmd("stonith_admin", "-F node3 -t 2")
 		# timeout is 2+1+4000 = 4003
 		test.add_stonith_log_pattern("remote op timeout set to 4003")
 
+	def build_fence_merge_tests(self):
+
+		### Simple test that overlapping fencing operations get merged
+		test = self.new_test("cpg_custom_merge_single",
+				"Verify overlapping identical fencing operations are merged, no fencing levels used.", 1)
+		test.add_cmd("stonith_admin", "-R false1 -a fence_false -o \"pcmk_host_list=node3\"")
+		test.add_cmd("stonith_admin", "-R true1  -a fence_true -o \"pcmk_host_list=node3\" ")
+		test.add_cmd("stonith_admin", "-R false2 -a fence_false -o \"pcmk_host_list=node3\"")
+		test.add_cmd_no_wait("stonith_admin", "-F node3 -t 10")
+		test.add_cmd("stonith_admin", "-F node3 -t 10")
+		### one merger will happen
+		test.add_stonith_log_pattern("Merging stonith action off for node node3 originating from client")
+		### the pattern below signifies that both the original and duplicate operation completed
+		test.add_stonith_log_pattern("Operation off of node3 by")
+		test.add_stonith_log_pattern("Operation off of node3 by")
+
+		### Test that multiple mergers occur
+		test = self.new_test("cpg_custom_merge_multiple",
+				"Verify multiple overlapping identical fencing operations are merged", 1)
+		test.add_cmd("stonith_admin", "-R false1 -a fence_false -o \"pcmk_host_list=node3\"")
+		test.add_cmd("stonith_admin", "-R true1  -a fence_true -o \"pcmk_host_list=node3\" ")
+		test.add_cmd("stonith_admin", "-R false2 -a fence_false -o \"pcmk_host_list=node3\"")
+		test.add_cmd_no_wait("stonith_admin", "-F node3 -t 10")
+		test.add_cmd_no_wait("stonith_admin", "-F node3 -t 10")
+		test.add_cmd_no_wait("stonith_admin", "-F node3 -t 10")
+		test.add_cmd_no_wait("stonith_admin", "-F node3 -t 10")
+		test.add_cmd("stonith_admin", "-F node3 -t 10")
+		### 4 mergers should occur
+		test.add_stonith_log_pattern("Merging stonith action off for node node3 originating from client")
+		test.add_stonith_log_pattern("Merging stonith action off for node node3 originating from client")
+		test.add_stonith_log_pattern("Merging stonith action off for node node3 originating from client")
+		test.add_stonith_log_pattern("Merging stonith action off for node node3 originating from client")
+		### the pattern below signifies that both the original and duplicate operation completed
+		test.add_stonith_log_pattern("Operation off of node3 by")
+		test.add_stonith_log_pattern("Operation off of node3 by")
+		test.add_stonith_log_pattern("Operation off of node3 by")
+		test.add_stonith_log_pattern("Operation off of node3 by")
+		test.add_stonith_log_pattern("Operation off of node3 by")
+
+		### Test that multiple mergers occur with topologies used
+		test = self.new_test("cpg_custom_merge_with_topology",
+				"Verify multiple overlapping identical fencing operations are merged with fencing levels.", 1)
+		test.add_cmd("stonith_admin", "-R false1 -a fence_false -o \"pcmk_host_list=node3\"")
+		test.add_cmd("stonith_admin", "-R true1  -a fence_true -o \"pcmk_host_list=node3\" ")
+		test.add_cmd("stonith_admin", "-R false2 -a fence_false -o \"pcmk_host_list=node3\"")
+		test.add_cmd("stonith_admin", "-r node3 -i 1 -v false1")
+		test.add_cmd("stonith_admin", "-r node3 -i 1 -v false2")
+		test.add_cmd("stonith_admin", "-r node3 -i 2 -v true1")
+		test.add_cmd_no_wait("stonith_admin", "-F node3 -t 10")
+		test.add_cmd_no_wait("stonith_admin", "-F node3 -t 10")
+		test.add_cmd_no_wait("stonith_admin", "-F node3 -t 10")
+		test.add_cmd_no_wait("stonith_admin", "-F node3 -t 10")
+		test.add_cmd("stonith_admin", "-F node3 -t 10")
+		### 4 mergers should occur
+		test.add_stonith_log_pattern("Merging stonith action off for node node3 originating from client")
+		test.add_stonith_log_pattern("Merging stonith action off for node node3 originating from client")
+		test.add_stonith_log_pattern("Merging stonith action off for node node3 originating from client")
+		test.add_stonith_log_pattern("Merging stonith action off for node node3 originating from client")
+		### the pattern below signifies that both the original and duplicate operation completed
+		test.add_stonith_log_pattern("Operation off of node3 by")
+		test.add_stonith_log_pattern("Operation off of node3 by")
+		test.add_stonith_log_pattern("Operation off of node3 by")
+		test.add_stonith_log_pattern("Operation off of node3 by")
+		test.add_stonith_log_pattern("Operation off of node3 by")
+
+
+		test = self.new_test("cpg_custom_no_merge",
+				"Verify differing fencing operations are not merged", 1)
+		test.add_cmd("stonith_admin", "-R false1 -a fence_false -o \"pcmk_host_list=node3 node2\"")
+		test.add_cmd("stonith_admin", "-R true1  -a fence_true -o \"pcmk_host_list=node3 node2\" ")
+		test.add_cmd("stonith_admin", "-R false2 -a fence_false -o \"pcmk_host_list=node3 node2\"")
+		test.add_cmd("stonith_admin", "-r node3 -i 1 -v false1")
+		test.add_cmd("stonith_admin", "-r node3 -i 1 -v false2")
+		test.add_cmd("stonith_admin", "-r node3 -i 2 -v true1")
+		test.add_cmd_no_wait("stonith_admin", "-F node2 -t 10")
+		test.add_cmd("stonith_admin", "-F node3 -t 10")
+		test.add_stonith_negative_log_pattern("Merging stonith action off for node node3 originating from client")
+
 	def build_standalone_tests(self):
 		test_types = [
 			{
 				"prefix" : "standalone" ,
 				"use_cpg" : 0,
 			},
 			{
 				"prefix" : "cpg" ,
 				"use_cpg" : 1,
 			},
 		]
 
 		# test what happens when all devices timeout
 		for test_type in test_types:
 			test = self.new_test("%s_fence_multi_device_failure" % test_type["prefix"],
 					"Verify that all devices timeout, a fencing failure is returned.", test_type["use_cpg"])
 			test.add_cmd("stonith_admin", "-R false1 -a fence_false -o \"pcmk_host_list=node1 node2 node3\"")
 			test.add_cmd("stonith_admin", "-R false2  -a fence_false -o \"pcmk_host_list=node1 node2 node3\"")
 			test.add_cmd("stonith_admin", "-R false3 -a fence_false -o \"pcmk_host_list=node1 node2 node3\"")
 			test.add_expected_fail_cmd("stonith_admin", "-F node3 -t 2", 194)
 
 			if test_type["use_cpg"] == 1:
 				test.add_stonith_log_pattern("remote op timeout set to 6")
 
 			test.add_stonith_log_pattern("for host 'node3' with device 'false1' returned: -62")
 			test.add_stonith_log_pattern("for host 'node3' with device 'false2' returned: -62")
 			test.add_stonith_log_pattern("for host 'node3' with device 'false3' returned: -62")
 
 		# test what happens when multiple devices can fence a node, but the first device fails.
 		for test_type in test_types:
 			test = self.new_test("%s_fence_device_failure_rollover" % test_type["prefix"],
 					"Verify that when one fence device fails for a node, the others are tried.", test_type["use_cpg"])
 			test.add_cmd("stonith_admin", "-R false1 -a fence_false -o \"pcmk_host_list=node1 node2 node3\"")
 			test.add_cmd("stonith_admin", "-R true1  -a fence_true -o \"pcmk_host_list=node1 node2 node3\"")
 			test.add_cmd("stonith_admin", "-R false2 -a fence_false -o \"pcmk_host_list=node1 node2 node3\"")
 			test.add_cmd("stonith_admin", "-F node3 -t 2")
 
 			if test_type["use_cpg"] == 1:
 				test.add_stonith_log_pattern("remote op timeout set to 6")
 
 		# simple topology test for one device
 		for test_type in test_types:
 			if test_type["use_cpg"] == 0:
 				continue
 
 			test = self.new_test("%s_topology_simple" % test_type["prefix"],
 					"Verify all fencing devices at a level are used.", test_type["use_cpg"])
 			test.add_cmd("stonith_admin", "-R true  -a fence_true -o \"pcmk_host_list=node1 node2 node3\"")
 
 			test.add_cmd("stonith_admin", "-r node3 -i 1 -v true")
 			test.add_cmd("stonith_admin", "-F node3 -t 2")
 
 			test.add_stonith_log_pattern("remote op timeout set to 2")
 			test.add_stonith_log_pattern("for host 'node3' with device 'true' returned: 0")
 
 		# test what happens when the first fencing level has multiple devices.
 		for test_type in test_types:
 			if test_type["use_cpg"] == 0:
 				continue
 
 			test = self.new_test("%s_topology_device_fails" % test_type["prefix"],
 					"Verify if one device in a level fails, the other is tried.", test_type["use_cpg"])
 			test.add_cmd("stonith_admin", "-R false  -a fence_false -o \"pcmk_host_list=node1 node2 node3\"")
 			test.add_cmd("stonith_admin", "-R true  -a fence_true -o \"pcmk_host_list=node1 node2 node3\"")
 
 			test.add_cmd("stonith_admin", "-r node3 -i 1 -v false")
 			test.add_cmd("stonith_admin", "-r node3 -i 2 -v true")
 			test.add_cmd("stonith_admin", "-F node3 -t 20")
 
 			test.add_stonith_log_pattern("remote op timeout set to 4")
 			test.add_stonith_log_pattern("for host 'node3' with device 'false' returned: -62")
 			test.add_stonith_log_pattern("for host 'node3' with device 'true' returned: 0")
 
 		# test what happens when the first fencing level fails.
 		for test_type in test_types:
 			if test_type["use_cpg"] == 0:
 				continue
 
 			test = self.new_test("%s_topology_multi_level_fails" % test_type["prefix"],
 					"Verify if one level fails, the next leve is tried.", test_type["use_cpg"])
 			test.add_cmd("stonith_admin", "-R true1  -a fence_true -o \"pcmk_host_list=node1 node2 node3\"")
 			test.add_cmd("stonith_admin", "-R true2  -a fence_true -o \"pcmk_host_list=node1 node2 node3\"")
 			test.add_cmd("stonith_admin", "-R true3  -a fence_true -o \"pcmk_host_list=node1 node2 node3\"")
 			test.add_cmd("stonith_admin", "-R true4  -a fence_true -o \"pcmk_host_list=node1 node2 node3\"")
 			test.add_cmd("stonith_admin", "-R false1 -a fence_false -o \"pcmk_host_list=node1 node2 node3\"")
 			test.add_cmd("stonith_admin", "-R false2 -a fence_false -o \"pcmk_host_list=node1 node2 node3\"")
 
 			test.add_cmd("stonith_admin", "-r node3 -i 1 -v false1")
 			test.add_cmd("stonith_admin", "-r node3 -i 1 -v true1")
 			test.add_cmd("stonith_admin", "-r node3 -i 2 -v true2")
 			test.add_cmd("stonith_admin", "-r node3 -i 2 -v false2")
 			test.add_cmd("stonith_admin", "-r node3 -i 3 -v true3")
 			test.add_cmd("stonith_admin", "-r node3 -i 3 -v true4")
 
 			test.add_cmd("stonith_admin", "-F node3 -t 2")
 
 			test.add_stonith_log_pattern("remote op timeout set to 12")
 			test.add_stonith_log_pattern("for host 'node3' with device 'false1' returned: -62")
 			test.add_stonith_log_pattern("for host 'node3' with device 'false2' returned: -62")
 			test.add_stonith_log_pattern("for host 'node3' with device 'true3' returned: 0")
 			test.add_stonith_log_pattern("for host 'node3' with device 'true4' returned: 0")
 
 		# Test what happens if multiple fencing levels are defined, and then the first one is removed.
 		for test_type in test_types:
 			if test_type["use_cpg"] == 0:
 				continue
 
 			test = self.new_test("%s_topology_level_removal" % test_type["prefix"],
 					"Verify level removal works.", test_type["use_cpg"])
 			test.add_cmd("stonith_admin", "-R true1  -a fence_true -o \"pcmk_host_list=node1 node2 node3\"")
 			test.add_cmd("stonith_admin", "-R true2  -a fence_true -o \"pcmk_host_list=node1 node2 node3\"")
 			test.add_cmd("stonith_admin", "-R true3  -a fence_true -o \"pcmk_host_list=node1 node2 node3\"")
 			test.add_cmd("stonith_admin", "-R true4  -a fence_true -o \"pcmk_host_list=node1 node2 node3\"")
 			test.add_cmd("stonith_admin", "-R false1 -a fence_false -o \"pcmk_host_list=node1 node2 node3\"")
 			test.add_cmd("stonith_admin", "-R false2 -a fence_false -o \"pcmk_host_list=node1 node2 node3\"")
 
 			test.add_cmd("stonith_admin", "-r node3 -i 1 -v false1")
 			test.add_cmd("stonith_admin", "-r node3 -i 1 -v true1")
 
 			test.add_cmd("stonith_admin", "-r node3 -i 2 -v true2")
 			test.add_cmd("stonith_admin", "-r node3 -i 2 -v false2")
 
 			test.add_cmd("stonith_admin", "-r node3 -i 3 -v true3")
 			test.add_cmd("stonith_admin", "-r node3 -i 3 -v true4")
 
 			# Now remove level 2, verify none of the devices in level two are hit.
 			test.add_cmd("stonith_admin", "-d node3 -i 2")
 
 			test.add_cmd("stonith_admin", "-F node3 -t 20")
 
 			test.add_stonith_log_pattern("remote op timeout set to 8")
 			test.add_stonith_log_pattern("for host 'node3' with device 'false1' returned: -62")
 			test.add_stonith_negative_log_pattern("for host 'node3' with device 'false2' returned: -62")
 			test.add_stonith_negative_log_pattern("for host 'node3' with device 'false2' returned: -1001")
 			test.add_stonith_log_pattern("for host 'node3' with device 'true3' returned: 0")
 			test.add_stonith_log_pattern("for host 'node3' with device 'true4' returned: 0")
 
 		# test the stonith builds the correct list of devices that can fence a node.
 		for test_type in test_types:
 			test = self.new_test("%s_list_devices" % test_type["prefix"],
 					"Verify list of devices that can fence a node is correct", test_type["use_cpg"])
 			test.add_cmd("stonith_admin", "-R true1  -a fence_true -o \"pcmk_host_list=node3\"")
 			test.add_cmd("stonith_admin", "-R true2 -a fence_true -o \"pcmk_host_list=node1 node2 node3\"")
 			test.add_cmd("stonith_admin", "-R true3 -a fence_true -o \"pcmk_host_list=node1 node2 node3\"")
 
 			test.add_cmd_check_stdout("stonith_admin", "-l node1 -V", "true2", "true1")
 			test.add_cmd_check_stdout("stonith_admin", "-l node1 -V", "true3", "true1")
 
 		# simple test of device monitor
 		for test_type in test_types:
 			test = self.new_test("%s_monitor" % test_type["prefix"],
 					"Verify device is reachable", test_type["use_cpg"])
 			test.add_cmd("stonith_admin", "-R true1  -a fence_true -o \"pcmk_host_list=node3\"")
 			test.add_cmd("stonith_admin", "-R false1  -a fence_false -o \"pcmk_host_list=node3\"")
 
 			test.add_cmd("stonith_admin", "-Q true1")
 			test.add_cmd("stonith_admin", "-Q false1")
 			test.add_expected_fail_cmd("stonith_admin", "-Q true2", 237)
 
 		# simple register test
 		for test_type in test_types:
 			test = self.new_test("%s_register" % test_type["prefix"],
 					"Verify devices can be registered and un-registered", test_type["use_cpg"])
 			test.add_cmd("stonith_admin", "-R true1  -a fence_true -o \"pcmk_host_list=node3\"")
 
 			test.add_cmd("stonith_admin", "-Q true1")
 
 			test.add_cmd("stonith_admin", "-D true1")
 
 			test.add_expected_fail_cmd("stonith_admin", "-Q true1", 237)
 
 
 		# simple reboot test
 		for test_type in test_types:
 			test = self.new_test("%s_reboot" % test_type["prefix"],
 					"Verify devices can be rebooted", test_type["use_cpg"])
 			test.add_cmd("stonith_admin", "-R true1  -a fence_true -o \"pcmk_host_list=node3\"")
 
 			test.add_cmd("stonith_admin", "-B node3 -t 2")
 
 			test.add_cmd("stonith_admin", "-D true1")
 
 			test.add_expected_fail_cmd("stonith_admin", "-Q true1", 237)
 
 		# test fencing history.
 		for test_type in test_types:
 			if test_type["use_cpg"] == 0:
 				continue
 			test = self.new_test("%s_fence_history" % test_type["prefix"],
 					"Verify last fencing operation is returned.", test_type["use_cpg"])
 			test.add_cmd("stonith_admin", "-R true1  -a fence_true -o \"pcmk_host_list=node3\"")
 
 			test.add_cmd("stonith_admin", "-F node3 -t 2 -V")
 
 			test.add_cmd_check_stdout("stonith_admin", "-H node3", "was able to turn off node node3", "")
 
-	def setup_environment(self):
-		if self.autogen_corosync_cfg:
+	def setup_environment(self, use_corosync):
+		if self.autogen_corosync_cfg and use_corosync:
 			corosync_conf = ("""
 totem {
         version: 2
         crypto_cipher: none
         crypto_hash: none
 
         nodeid:         101
         secauth:        off
 
         interface {
                 ttl: 1
                 ringnumber: 0
                 mcastport: 6666
                 mcastaddr: 226.94.1.1
                 bindnetaddr: 127.0.0.1
         }
 }
 
 logging {
         debug: off
         fileline: off
         to_syslog: no
         to_stderr: no
         syslog_facility: daemon
         timestamp: on
         to_logfile: yes
         logfile: /var/log/corosync.log
         logfile_priority: info
 }
 """)
 
 			os.system("cat <<-END >>/etc/corosync/corosync.conf\n%s\nEND" % (corosync_conf))
 
+
+		if use_corosync:
+			### make sure we are in control ###
+			self.stop_corosync()
+			self.start_corosync()
+
 		os.system("cp /usr/share/pacemaker/tests/cts/fence_false /usr/sbin/fence_false")
 		os.system("cp /usr/share/pacemaker/tests/cts/fence_true /usr/sbin/fence_true")
 
-	def cleanup_environment(self):
+	def cleanup_environment(self, use_corosync):
+		if use_corosync:
+			self.stop_corosync()
+
+			if self.verbose and os.path.exists('/var/log/corosync.log'):
+				print "Daemon output"
+				f = open('/var/log/corosync.log', 'r')
+				for line in f.readlines():
+					print line.strip()
+				os.remove('/var/log/corosync.log')
+
 		if self.autogen_corosync_cfg:
 			os.system("rm -f /etc/corosync/corosync.conf")
 
 class TestOptions:
 	def __init__(self):
 		self.options = {}
 		self.options['list-tests'] = 0
 		self.options['run-all'] = 1
 		self.options['run-only'] = ""
 		self.options['run-only-pattern'] = ""
 		self.options['verbose'] = 0
 		self.options['invalid-arg'] = ""
 		self.options['cpg-only'] = 0
 		self.options['no-cpg'] = 0
 		self.options['show-usage'] = 0
 
 	def build_options(self, argv):
 		args = argv[1:]
 		skip = 0
 		for i in range(0, len(args)):
 			if skip:
 				skip = 0
 				continue
 			elif args[i] == "-h" or args[i] == "--help":
 				self.options['show-usage'] = 1
 			elif args[i] == "-l" or args[i] == "--list-tests":
 				self.options['list-tests'] = 1
 			elif args[i] == "-V" or args[i] == "--verbose":
 				self.options['verbose'] = 1
 			elif args[i] == "-n" or args[i] == "--no-cpg":
 				self.options['no-cpg'] = 1
 			elif args[i] == "-c" or args[i] == "--cpg-only":
 				self.options['cpg-only'] = 1
 			elif args[i] == "-r" or args[i] == "--run-only":
 				self.options['run-only'] = args[i+1]
 				skip = 1
 			elif args[i] == "-p" or args[i] == "--run-only-pattern":
 				self.options['run-only-pattern'] = args[i+1]
 				skip = 1
 
 	def show_usage(self):
 		print "usage: " + sys.argv[0] + " [options]"
 		print "If no options are provided, all tests will run"
 		print "Options:"
 		print "\t [--help | -h]                        Show usage"
 		print "\t [--list-tests | -l]                  Print out all registered tests."
 		print "\t [--cpg-only | -c]                    Only run tests that require corosync."
 		print "\t [--no-cpg | -n]                      Only run tests that do not require corosync"
 		print "\t [--run-only | -r 'testname']         Run a specific test"
 		print "\t [--verbose | -V]                     Verbose output"
 		print "\t [--run-only-pattern | -p 'string']   Run only tests containing the string value"
 		print "\n\tExample: Run only the test 'start_top'"
 		print "\t\t python ./regression.py --run-only start_stop"
 		print "\n\tExample: Run only the tests with the string 'systemd' present in them"
 		print "\t\t python ./regression.py --run-only-pattern systemd"
 
 def main(argv):
 	o = TestOptions()
 	o.build_options(argv)
 
+	use_corosync = 1
+
 	tests = Tests(o.options['verbose'])
 	tests.build_standalone_tests()
 	tests.build_custom_timeout_tests()
 	tests.build_api_sanity_tests()
-
-	print "Starting ..."
-
-	tests.setup_environment()
+	tests.build_fence_merge_tests()
 
 	if o.options['list-tests']:
 		tests.print_list()
+		sys.exit(0)
 	elif o.options['show-usage']:
 		o.show_usage()
-	elif o.options['run-only-pattern'] != "":
+		sys.exit(0)
+
+	print "Starting ..."
+
+	if o.options['no-cpg']:
+		use_corosync = 0
+
+	tests.setup_environment(use_corosync)
+
+	if o.options['run-only-pattern'] != "":
 		tests.run_tests_matching(o.options['run-only-pattern'])
 		tests.print_results()
 	elif o.options['run-only'] != "":
 		tests.run_single(o.options['run-only'])
 		tests.print_results()
 	elif o.options['no-cpg']:
 		tests.run_no_cpg()
 		tests.print_results()
 	elif o.options['cpg-only']:
 		tests.run_cpg_only()
 		tests.print_results()
 	else:
 		tests.run_tests()
 		tests.print_results()
 
-	tests.cleanup_environment()
+	tests.cleanup_environment(use_corosync)
 	tests.exit()
 if __name__=="__main__":
 	main(sys.argv)
diff --git a/fencing/remote.c b/fencing/remote.c
index d564a90896..2a982bc2b1 100644
--- a/fencing/remote.c
+++ b/fencing/remote.c
@@ -1,981 +1,1029 @@
 /* 
  * Copyright (C) 2009 Andrew Beekhof <andrew@beekhof.net>
  * 
  * This program is free software; you can redistribute it and/or
  * modify it under the terms of the GNU General Public
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) any later version.
  * 
  * This software is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * General Public License for more details.
  * 
  * You should have received a copy of the GNU General Public
  * License along with this library; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  */
 
 #include <crm_internal.h>
 
 #include <sys/param.h>
 #include <stdio.h>
 #include <sys/types.h>
 #include <sys/wait.h>
 #include <sys/stat.h>
 #include <unistd.h>
 #include <sys/utsname.h>
 
 #include <stdlib.h>
 #include <errno.h>
 #include <fcntl.h>
 #include <ctype.h>
 
 #include <crm/crm.h>
 #include <crm/msg_xml.h>
 #include <crm/common/ipc.h>
 #include <crm/cluster/internal.h>
 
 #include <crm/stonith-ng.h>
 #include <crm/fencing/internal.h>
 #include <crm/common/xml.h>
 
 #include <crm/common/util.h>
 #include <internal.h>
 
+#define TIMEOUT_MULTIPLY_FACTOR 1.2
 
 typedef struct st_query_result_s
 {
     char *host;
     int devices;
     GListPtr device_list;
     GHashTable *custom_action_timeouts;
 
 } st_query_result_t;
 
 GHashTable *remote_op_list = NULL;
 void call_remote_stonith(remote_fencing_op_t *op, st_query_result_t *peer);
+static void remote_op_done(remote_fencing_op_t *op, xmlNode *data, int rc, int dup);
 extern xmlNode *stonith_create_op(
     int call_id, const char *token, const char *op, xmlNode *data, int call_options);
 
 static void report_timeout_period(remote_fencing_op_t *op, int op_timeout);
 static int get_op_total_timeout(remote_fencing_op_t *op, st_query_result_t *chosen_peer, int default_timeout);
 
 static void free_remote_query(gpointer data)
 {
     if(data) {
         st_query_result_t *query = data;
         crm_trace("Free'ing query result from %s", query->host);
         free(query->host);
         g_hash_table_destroy(query->custom_action_timeouts);
         free(query);
     }
 }
 
+static void
+clear_remote_op_timers(remote_fencing_op_t *op)
+{
+    if(op->query_timer > 0) {
+        g_source_remove(op->query_timer);
+        op->query_timer = 0;
+    }
+    if(op->op_timer_total > 0) {
+        g_source_remove(op->op_timer_total);
+        op->op_timer_total = 0;
+    }
+    if(op->op_timer_one > 0) {
+        g_source_remove(op->op_timer_one);
+        op->op_timer_one = 0;
+    }
+}
+
 static void free_remote_op(gpointer data)
 {
     remote_fencing_op_t *op = data;
 
     crm_trace("Free'ing op %s for %s", op->id, op->target);
     crm_log_xml_debug(op->request, "Destroying");
 
+    clear_remote_op_timers(op);
+
     free(op->id);
     free(op->action);
     free(op->target);
     free(op->client_id);
     free(op->client_name);
     free(op->originator);
 
-    if(op->query_timer > 0) {
-        g_source_remove(op->query_timer);
-    }
-    if(op->op_timer_total > 0) {
-        g_source_remove(op->op_timer_total);
-    }
-    if(op->op_timer_one > 0) {
-        g_source_remove(op->op_timer_one);
-    }
     if(op->query_results) {
         g_list_free_full(op->query_results, free_remote_query);
     }
     if(op->request) {
         free_xml(op->request);
         op->request = NULL;
     }
     free(op);
 }
 
-static void remote_op_done(remote_fencing_op_t *op, xmlNode *data, int rc, int dup) 
+static xmlNode *
+create_op_done_notify(remote_fencing_op_t *op, int rc)
 {
-    GListPtr iter = NULL;
-    const char *subt = NULL;
-
-    xmlNode *local_data = NULL;
-    xmlNode *notify_data = NULL;
-
-    op->completed = time(NULL);
-
-    if(op->query_timer > 0) {
-        g_source_remove(op->query_timer);
-        op->query_timer = 0;
-    }
-    if(op->op_timer_total > 0) {
-        g_source_remove(op->op_timer_total);
-        op->op_timer_total = 0;
-    }
-    if(op->op_timer_one > 0) {
-        g_source_remove(op->op_timer_one);
-        op->op_timer_one = 0;
-    }
-
-    if(op->request == NULL) {
-        crm_err("Already sent notifications for '%s of %s by %s' (for=%s@%s.%.8s, state=%d): %s",
-                op->action, op->target, op->delegate?op->delegate:"<no-one>",
-                op->client_name, op->originator, op->id, op->state, pcmk_strerror(rc));
-        return;
-    }
-
-    if(data == NULL) {
-        data = create_xml_node(NULL, "remote-op");
-        local_data = data;
-
-    } else if(op->delegate == NULL) {
-        op->delegate = crm_element_value_copy(data, F_ORIG);
-    }
-
-    /* Do notification with a clean data object */
-    notify_data = create_xml_node(NULL, T_STONITH_NOTIFY_FENCE);
+    xmlNode *notify_data = create_xml_node(NULL, T_STONITH_NOTIFY_FENCE);
     crm_xml_add_int(notify_data, "state", op->state);
     crm_xml_add_int(notify_data, F_STONITH_RC,    rc);
     crm_xml_add(notify_data, F_STONITH_TARGET,    op->target);
     crm_xml_add(notify_data, F_STONITH_ACTION,    op->action); 
     crm_xml_add(notify_data, F_STONITH_DELEGATE,  op->delegate);
     crm_xml_add(notify_data, F_STONITH_REMOTE,    op->id);
     crm_xml_add(notify_data, F_STONITH_ORIGIN,    op->originator);
     crm_xml_add(notify_data, F_STONITH_CLIENTID,  op->client_id);
     crm_xml_add(notify_data, F_STONITH_CLIENTNAME,op->client_name);
 
-    subt = crm_element_value(data, F_SUBTYPE);
-    if(dup == FALSE && safe_str_neq(subt, "broadcast")) {
-        static int count = 0;
-        xmlNode *bcast = create_xml_node(NULL, T_STONITH_REPLY);
-
-        count++;
-        crm_trace("Broadcasting result to peers");
-        crm_xml_add(bcast, F_TYPE, T_STONITH_NOTIFY);
-        crm_xml_add(bcast, F_SUBTYPE, "broadcast");
-        crm_xml_add(bcast, F_STONITH_OPERATION, T_STONITH_NOTIFY);
-        crm_xml_add_int(bcast, "count", count);
-        add_message_xml(bcast, F_STONITH_CALLDATA, notify_data);
-        send_cluster_message(NULL, crm_msg_stonith_ng, bcast, FALSE);
-        free_xml(notify_data);
-        free_xml(local_data);
-        free_xml(bcast);
+    return notify_data;
+}
 
-        /* Defer notification until the bcast message arrives */
+static void
+bcast_result_to_peers(remote_fencing_op_t *op, int rc)
+{
+    static int count = 0;
+    xmlNode *bcast = create_xml_node(NULL, T_STONITH_REPLY);
+    xmlNode *notify_data = create_op_done_notify(op, rc);
+
+    count++;
+    crm_trace("Broadcasting result to peers");
+    crm_xml_add(bcast, F_TYPE, T_STONITH_NOTIFY);
+    crm_xml_add(bcast, F_SUBTYPE, "broadcast");
+    crm_xml_add(bcast, F_STONITH_OPERATION, T_STONITH_NOTIFY);
+    crm_xml_add_int(bcast, "count", count);
+    add_message_xml(bcast, F_STONITH_CALLDATA, notify_data);
+    send_cluster_message(NULL, crm_msg_stonith_ng, bcast, FALSE);
+    free_xml(notify_data);
+    free_xml(bcast);
+
+    return;
+}
+
+static void
+handle_local_reply_and_notify(remote_fencing_op_t *op, xmlNode *data, int rc)
+{
+    xmlNode *notify_data = NULL;
+    xmlNode *reply = NULL;
+
+    if (op->notify_sent == TRUE) {
+        /* nothing to do */
         return;
     }
-    
-    {
-        int level = LOG_ERR;
-        xmlNode *reply = NULL;
-
-        crm_xml_add_int(data, "state", op->state);
-        crm_xml_add(data, F_STONITH_TARGET,    op->target);
-        crm_xml_add(data, F_STONITH_OPERATION, op->action); 
 
-        reply = stonith_construct_reply(op->request, NULL, data, rc);
-        crm_xml_add(reply, F_STONITH_DELEGATE,  op->delegate);
+    /* Do notification with a clean data object */
+    notify_data = create_op_done_notify(op, rc);
+    crm_xml_add_int(data, "state", op->state);
+    crm_xml_add(data, F_STONITH_TARGET,    op->target);
+    crm_xml_add(data, F_STONITH_OPERATION, op->action); 
 
-        if(rc == pcmk_ok || dup) {
-            level = LOG_NOTICE;
-        } else if(safe_str_neq(op->originator, stonith_our_uname)) {
-            level = LOG_NOTICE;
-        }
-        
-        do_crm_log(level,
-                   "Operation %s of %s by %s for %s@%s.%.8s: %s",
-                   op->action, op->target, op->delegate?op->delegate:"<no-one>",
-                   op->client_name, op->originator, op->id, pcmk_strerror(rc));
+    reply = stonith_construct_reply(op->request, NULL, data, rc);
+    crm_xml_add(reply, F_STONITH_DELEGATE,  op->delegate);
 
-        do_local_reply(reply, op->client_id, op->call_options & st_opt_sync_call, FALSE);
-        free_xml(reply);
-    }
+    /* Send fencing OP reply to local client that initiated fencing */
+    do_local_reply(reply, op->client_id, op->call_options & st_opt_sync_call, FALSE);
 
+    /* bcast to all local clients that the fencing operation happend */
     do_stonith_notify(0, T_STONITH_NOTIFY_FENCE, rc, notify_data, NULL);
 
+    /* mark this op as having notify's already sent */
+    op->notify_sent = TRUE;
+    free_xml(reply);
+    free_xml(notify_data);
+}
+
+static void
+handle_duplicates(remote_fencing_op_t *op, xmlNode *data, int rc)
+{
+    GListPtr iter = NULL;
     for(iter = op->duplicates; iter != NULL; iter = iter->next) {
         remote_fencing_op_t *other = iter->data;
 
         if(other->state == st_duplicate) {
             /* Ie. it hasn't timed out already */
             other->state = op->state;
             crm_debug("Peforming duplicate notification for %s@%s.%.8s = %s", other->client_name, other->originator, other->id, pcmk_strerror(rc));
             remote_op_done(other, data, rc, TRUE);
 
         } else {
             crm_err("Skipping duplicate notification for %s@%s - %d", other->client_name, other->originator, other->state);
         }
     }
-    
-    free_xml(notify_data);
-    free_xml(local_data);
+}
+
+static void
+remote_op_done(remote_fencing_op_t *op, xmlNode *data, int rc, int dup)
+{
+    int level = LOG_ERR;
+    const char *subt = NULL;
+    xmlNode *local_data = NULL;
+
+    op->completed = time(NULL);
+    clear_remote_op_timers(op);
+
+    if(op->notify_sent == TRUE) {
+        crm_err("Already sent notifications for '%s of %s by %s' (for=%s@%s.%.8s, state=%d): %s",
+                op->action, op->target, op->delegate?op->delegate:"<no-one>",
+                op->client_name, op->originator, op->id, op->state, pcmk_strerror(rc));
+        goto remote_op_done_cleanup;
+    }
+
+    if(data == NULL) {
+        data = create_xml_node(NULL, "remote-op");
+        local_data = data;
+
+    } else if(op->delegate == NULL) {
+        op->delegate = crm_element_value_copy(data, F_ORIG);
+    }
+
+    /* Tell everyone the operation is done, we will continue
+     * with doing the local notifications once we receive
+     * the broadcast back. */
+    subt = crm_element_value(data, F_SUBTYPE);
+    if(dup == FALSE && safe_str_neq(subt, "broadcast")) {
+        /* Defer notification until the bcast message arrives */
+        bcast_result_to_peers(op, rc);
+        goto remote_op_done_cleanup;
+    }
+
+    if(rc == pcmk_ok || dup) {
+        level = LOG_NOTICE;
+    } else if(safe_str_neq(op->originator, stonith_our_uname)) {
+        level = LOG_NOTICE;
+    }
+
+    do_crm_log(level,
+               "Operation %s of %s by %s for %s@%s.%.8s: %s",
+               op->action, op->target, op->delegate?op->delegate:"<no-one>",
+               op->client_name, op->originator, op->id, pcmk_strerror(rc));
+
+    handle_local_reply_and_notify(op, data, rc);
+
+    if (dup == FALSE) {
+        handle_duplicates(op, data, rc);
+    }
 
     /* Free non-essential parts of the record
      * Keep the record around so we can query the history
      */
     if(op->query_results) {
         g_list_free_full(op->query_results, free_remote_query);
         op->query_results = NULL;
     }
 
     if(op->request) {
         free_xml(op->request);
         op->request = NULL;
     }
 
+remote_op_done_cleanup:
+    free_xml(local_data);
 }
 
 static gboolean remote_op_timeout_one(gpointer userdata)
 {
     remote_fencing_op_t *op = userdata;
     op->op_timer_one = 0;
 
     crm_notice("Remote %s operation on %s for %s.%8s timed out",
                op->action, op->target, op->client_name, op->id);
     call_remote_stonith(op, NULL);
     return FALSE;
 }
 
 static gboolean remote_op_timeout(gpointer userdata)
 {
     remote_fencing_op_t *op = userdata;
     op->op_timer_total = 0;
 
     if(op->state == st_done) {
         crm_debug("Action %s (%s) for %s (%s) already completed",
                   op->action, op->id, op->target, op->client_name);
         return FALSE;
     }
 
     crm_debug("Action %s (%s) for %s (%s) timed out",
               op->action, op->id, op->target, op->client_name);
     op->state = st_failed;
     remote_op_done(op, NULL, -ETIME, FALSE);
 
     return FALSE;
 }
 
 static gboolean remote_op_query_timeout(gpointer data)
 {
     remote_fencing_op_t *op = data;
 
     op->query_timer = 0;
     if(op->state == st_done) {
         crm_debug("Operation %s for %s already completed", op->id, op->target);
     } else if(op->state == st_exec) {
         crm_debug("Operation %s for %s already in progress", op->id, op->target);
     } else if(op->query_results) {
         crm_debug("Query %s for %s complete: %d", op->id, op->target, op->state);
         call_remote_stonith(op, NULL);
     } else {
         crm_debug("Query %s for %s timed out: %d", op->id, op->target, op->state);
         if(op->op_timer_total) {
             g_source_remove(op->op_timer_total);
             op->op_timer_total = 0;
         }
         remote_op_timeout(op);
     }
 
     return FALSE;
 }
 
 static int stonith_topology_next(remote_fencing_op_t *op) 
 {
     stonith_topology_t *tp = NULL;
     if(op->target) {
         /* Queries don't have a target set */
         tp = g_hash_table_lookup(topology, op->target);
     }
     if(tp == NULL) {
         return pcmk_ok;
     }
 
     set_bit(op->call_options, st_opt_topology);
 
     do {
         op->level++;
 
     } while(op->level < ST_LEVEL_MAX && tp->levels[op->level] == NULL);
 
     if(op->level < ST_LEVEL_MAX) {
         crm_trace("Attempting fencing level %d for %s (%d devices) - %s@%s.%.8s",
                   op->level, op->target, g_list_length(tp->levels[op->level]),
                   op->client_name, op->originator, op->id);
         op->devices = tp->levels[op->level];
         return pcmk_ok;
     }
 
     crm_notice("All fencing options to fence %s for %s@%s.%.8s failed",
                op->target, op->client_name, op->originator, op->id);
     return -EINVAL;
 }
 
+/*!
+ * \brief Check to see if this operation is a duplicate of another in flight
+ * operation. If so merge this operation into the inflight operation, and mark
+ * it as a duplicate.
+ */
+static void
+merge_duplicates(remote_fencing_op_t *op)
+{
+    GHashTableIter iter;
+    remote_fencing_op_t *other = NULL;
+    g_hash_table_iter_init(&iter, remote_op_list);
+    while(g_hash_table_iter_next(&iter, NULL, (void**)&other)) {
+        if(other->state > st_exec) {
+            /* Must be in-progress */
+            continue;
+        } else if (safe_str_neq(op->target, other->target)) {
+            /* Must be for the same node */
+            continue;
+        } else if(safe_str_neq(op->action, other->action)) {
+            crm_trace("Must be for the same action: %s vs. ", op->action, other->action);
+            continue;
+        } else if(safe_str_eq(op->client_name, other->client_name)) {
+            crm_trace("Must be for different clients: %s", op->client_name);
+            continue;
+        } else if(safe_str_eq(other->target, other->originator)) {
+            crm_trace("Can't be a suicide operation: %s", other->target);
+            continue;
+        }
+
+        /* There is another in-flight request to fence the same host
+         * Piggyback on that instead.  If it fails, so do we.
+         */
+        other->duplicates = g_list_append(other->duplicates, op);
+        if(other->total_timeout == 0) {
+            crm_trace("Making a best-guess as to the timeout used");
+            other->total_timeout = op->total_timeout = TIMEOUT_MULTIPLY_FACTOR * get_op_total_timeout(op, NULL, op->base_timeout);
+        }
+        crm_notice("Merging stonith action %s for node %s originating from client %s.%.8s with identical request from %s@%s.%.8s (%ds)",
+                   op->action, op->target, op->client_name, op->id, other->client_name, other->originator, other->id, other->total_timeout);
+        report_timeout_period(op, other->total_timeout);
+        op->state = st_duplicate;
+    }
+}
+
 void *create_remote_stonith_op(const char *client, xmlNode *request, gboolean peer)
 {
     remote_fencing_op_t *op = NULL;
     xmlNode *dev = get_xpath_object("//@"F_STONITH_TARGET, request, LOG_TRACE);
 
     if(remote_op_list == NULL) {
         remote_op_list = g_hash_table_new_full(
         crm_str_hash, g_str_equal, NULL, free_remote_op);
     }
 
     if(peer && dev) {
         const char *peer_id = crm_element_value(dev, F_STONITH_REMOTE);
         CRM_CHECK(peer_id != NULL, return NULL);
 
         op = g_hash_table_lookup(remote_op_list, peer_id);
         if(op) {
             crm_debug("%s already exists", peer_id);
             return op;
         }
     }
 
     op = calloc(1, sizeof(remote_fencing_op_t));
 
     op->op_timer_total = -1;
     op->query_timer = -1;
 
     crm_element_value_int(request, F_STONITH_TIMEOUT, (int*)&(op->base_timeout));
 
     if(peer && dev) {
         op->id = crm_element_value_copy(dev, F_STONITH_REMOTE);
     } else {
         op->id = crm_generate_uuid();
     }
 
     g_hash_table_replace(remote_op_list, op->id, op);
     CRM_LOG_ASSERT(g_hash_table_lookup(remote_op_list, op->id) != NULL);
 
     op->state = st_query;
     op->action = crm_element_value_copy(dev, F_STONITH_ACTION);
     op->originator = crm_element_value_copy(dev, F_STONITH_ORIGIN);
 
     if(op->originator == NULL) {
         /* Local request */
         op->originator = strdup(stonith_our_uname);
     }
 
     if(client) {
         op->client_id = strdup(client);
     }
 
     op->client_name = crm_element_value_copy(request, F_STONITH_CLIENTNAME);
 
     op->target = crm_element_value_copy(dev, F_STONITH_TARGET);
     op->request = copy_xml(request); /* TODO: Figure out how to avoid this */
     crm_element_value_int(request, F_STONITH_CALLOPTS, (int*)&(op->call_options));
 
     crm_trace("%s new stonith op: %s - %s of %s for %s",
               (peer && dev)?"Recorded":"Generated", op->id, op->action, op->target, op->client_name);
 
     if(op->call_options & st_opt_cs_nodeid) {
         int nodeid = crm_atoi(op->target, NULL);
         crm_node_t *node = crm_get_peer(nodeid, NULL);
 
         /* Ensure the conversion only happens once */
         op->call_options &= ~st_opt_cs_nodeid;
 
         if(node && node->uname) {
             free(op->target);
             op->target = strdup(node->uname);
         } else {
             crm_warn("Could not expand nodeid '%s' into a host name (%p)", op->target, node);
         }
     }
 
-    {
-        GHashTableIter iter;
-        remote_fencing_op_t *other = NULL;
-        g_hash_table_iter_init(&iter, remote_op_list); 
-        while(g_hash_table_iter_next(&iter, NULL, (void**)&other)) {
-            if(other->state > st_exec) {
-                /* Must be in-progress */
-                continue;
-            } else if (safe_str_neq(op->target, other->target)) {
-                /* Must be for the same node */
-                continue;
-            } else if(safe_str_neq(op->action, other->action)) {
-                crm_trace("Must be for the same action: %s vs. ", op->action, other->action);
-                continue;
-            } else if(safe_str_eq(op->client_name, other->client_name)) {
-                crm_trace("Must be for different clients: %s", op->client_name);
-                continue;
-            } else if(safe_str_eq(other->target, other->originator)) {
-                crm_trace("Can't be a suicide operation: %s", other->target);
-                continue;
-            }
-
-            /* There is another in-flight request to fence the same host
-             * Piggyback on that instead.  If it fails, so do we.
-             */
-            other->duplicates = g_list_append(other->duplicates, op);
-            if(other->total_timeout == 0) {
-                crm_trace("Making a best-guess as to the timeout used");
-                other->total_timeout = op->total_timeout = 1.2 * get_op_total_timeout(op, NULL, op->base_timeout);
-            }
-            crm_notice("Merging stonith action %s for node %s originating from client %s.%.8s with identical request from %s@%s.%.8s (%ds)",
-                       op->action, op->target, op->client_name, op->id, other->client_name, other->originator, other->id, other->total_timeout);
-            report_timeout_period(op, other->total_timeout);
-            op->state = st_duplicate;
-            return op;
-        }
-    }
+	/* check to see if this is a duplicate operation of another in-flight operation */
+	merge_duplicates(op);
 
     return op;
 }
 
 remote_fencing_op_t *initiate_remote_stonith_op(stonith_client_t *client, xmlNode *request, gboolean manual_ack)
 {
     xmlNode *query = NULL;
     const char *client_id = NULL;
     remote_fencing_op_t *op = NULL;
 
     if(client) {
         client_id = client->id;
     } else {
         client_id = crm_element_value(request, F_STONITH_CLIENTID);
     }
 
     CRM_LOG_ASSERT(client_id != NULL);
     op = create_remote_stonith_op(client_id, request, FALSE);    
 
     CRM_CHECK(op->action, return NULL);
 
     if(stonith_topology_next(op) != pcmk_ok) {
         op->state = st_failed;
     }
 
     switch(op->state) {
         case st_failed:
             crm_warn("Initiation of remote operation %s for %s: failed (%s)", op->action, op->target, op->id);
             return op;
 
         case st_duplicate:
             crm_info("Initiating remote operation %s for %s: %s (duplicate)", op->action, op->target, op->id);
             return op;
 
         default:
             crm_notice("Initiating remote operation %s for %s: %s (%d)", op->action, op->target, op->id, op->state);
     }
 
     query = stonith_create_op(0, op->id, STONITH_OP_QUERY, NULL, 0);
 
     if(!manual_ack) {
         op->query_timer = g_timeout_add(100*op->base_timeout, remote_op_query_timeout, op);
 
     } else {
         crm_xml_add(query, F_STONITH_DEVICE, "manual_ack");
     }
 
     crm_xml_add(query, F_STONITH_REMOTE, op->id);
     crm_xml_add(query, F_STONITH_TARGET, op->target);
     crm_xml_add(query, F_STONITH_ACTION, op->action);
     crm_xml_add(query, F_STONITH_ORIGIN,  op->originator);
     crm_xml_add(query, F_STONITH_CLIENTID, op->client_id);
     crm_xml_add(query, F_STONITH_CLIENTNAME, op->client_name);
     crm_xml_add_int(query, F_STONITH_TIMEOUT, op->base_timeout);
 
     send_cluster_message(NULL, crm_msg_stonith_ng, query, FALSE);
 
     free_xml(query);
     return op;
 }
 
 static gint sort_strings(gconstpointer a, gconstpointer b)
 {
     return strcmp(a, b);
 }
 
 static st_query_result_t *stonith_choose_peer(remote_fencing_op_t *op)
 {
     GListPtr iter = NULL;
     do {
         if(op->devices) {
             crm_trace("Checking for someone to fence %s with %s", op->target, (char*)op->devices->data);
         } else {
             crm_trace("Checking for someone to fence %s", op->target);
         }
         for(iter = op->query_results; iter != NULL; iter = iter->next) {
             st_query_result_t *peer = iter->data;
             if(is_set(op->call_options, st_opt_topology)) {
                 /* Do they have the next device of the current fencing level? */
                 GListPtr match = NULL;
                 if(op->devices) {
                     match = g_list_find_custom(peer->device_list, op->devices->data, sort_strings);
                 }
                 if(match) {
                     crm_trace("Removing %s from %s (%d remaining)", (char*)match->data, peer->host, g_list_length(peer->device_list));
                     peer->device_list = g_list_remove(peer->device_list, match->data);
                     return peer;
                 }
 
             } else if(peer && peer->devices > 0) {
                 /* No topology: Use the current best peer */
                 crm_trace("Simple fencing");
                 return peer;
             }
         }
 
         /* Try the next fencing level if there is one */
     } while(is_set(op->call_options, st_opt_topology)
             && stonith_topology_next(op) == pcmk_ok);
 
     if(op->devices) {
         crm_trace("Couldn't find anyone to fence %s with %s", op->target, (char*)op->devices->data);
     } else {
         crm_trace("Couldn't find anyone to fence %s", op->target);
     }
 
     return NULL;
 }
 
 static int
 get_device_timeout(st_query_result_t *peer, const char *device, int default_timeout)
 {
     gpointer res;
 
     if (!peer || !device) {
         return default_timeout;
     }
 
     res = g_hash_table_lookup(peer->custom_action_timeouts, device);
 
     return res ? GPOINTER_TO_INT(res) : default_timeout;
 }
 
 static int
 get_op_total_timeout(remote_fencing_op_t *op, st_query_result_t *chosen_peer, int default_timeout)
 {
     stonith_topology_t *tp = g_hash_table_lookup(topology, op->target);
     int total_timeout = 0;
 
     if (is_set(op->call_options, st_opt_topology) && tp) {
         int i;
         GListPtr device_list = NULL;
         GListPtr iter = NULL;
 
         /* Yep, this looks scary, nested loops all over the place.
          * Here is what is going on.
          * Loop1: Iterate through fencing levels.
          * Loop2: If a fencing level has devices, loop through each device
          * Loop3: For each device in a fencing level, see what peer owns it
          *        and what that peer has reported the timeout is for the device.
          */
         for (i = 0; i < ST_LEVEL_MAX; i++) {
             if (!tp->levels[i]) {
                 continue;
             }
             for (device_list = tp->levels[i]; device_list; device_list = device_list->next) {
                 for(iter = op->query_results; iter != NULL; iter = iter->next) {
                     st_query_result_t *peer = iter->data;
                     if (g_list_find_custom(peer->device_list, device_list->data, sort_strings)) {
                         total_timeout += get_device_timeout(peer, device_list->data, default_timeout);
                         break;
                     }
                 } /* End Loop3: match device with peer that owns device, find device's timeout period */
             } /* End Loop2: iterate through devices at a specific level */
         } /*End Loop1: iterate through fencing levels */
 
     } else if (chosen_peer) {
         GListPtr cur = NULL;
         for (cur = chosen_peer->device_list; cur; cur = cur->next) {
             total_timeout += get_device_timeout(chosen_peer, cur->data, default_timeout);
         }
     } else {
         total_timeout = default_timeout;
     }
 
     return total_timeout ? total_timeout : default_timeout;
 }
 
 static void
 report_timeout_period(remote_fencing_op_t *op, int op_timeout)
 {
     GListPtr iter = NULL;
     xmlNode *update = NULL;
     const char *client_node = NULL;
     const char *client_id = NULL;
     const char *call_id = NULL;
 
     if (op->call_options & st_opt_sync_call) {
         /* There is no reason to report the timeout for a syncronous call. It
          * is impossible to use the reported timeout to do anything when the client
          * is blocking for the response.  This update is only important for
          * async calls that require a callback to report the results in. */
         return;
     } else if (!op->request) {
         return;
     }
 
     crm_trace("Reporting timeout for %s.%.8s", op->client_name, op->id);
     client_node = crm_element_value(op->request, F_STONITH_CLIENTNODE);
     call_id = crm_element_value(op->request, F_STONITH_CALLID);
     client_id = crm_element_value(op->request, F_STONITH_CLIENTID);
     if (!client_node || !call_id || !client_id) {
         return;
     }
 
     if (safe_str_eq(client_node, stonith_our_uname)) {
         /* The client is connected to this node, send the update direclty to them */
         do_stonith_async_timeout_update(client_id, call_id, op_timeout);
         return;
     }
 
     /* The client is connected to another node, relay this update to them */
     update = stonith_create_op(0, op->id, STONITH_OP_TIMEOUT_UPDATE, NULL, 0);
     crm_xml_add(update, F_STONITH_REMOTE, op->id);
     crm_xml_add(update, F_STONITH_CLIENTID, client_id);
     crm_xml_add(update, F_STONITH_CALLID, call_id);
     crm_xml_add_int(update, F_STONITH_TIMEOUT, op_timeout);
 
     send_cluster_message(crm_get_peer(0, client_node), crm_msg_stonith_ng, update, FALSE);
 
     free_xml(update);
 
     for(iter = op->duplicates; iter != NULL; iter = iter->next) {
         remote_fencing_op_t *dup = iter->data;
 
         crm_trace("Reporting timeout for duplicate %s.%.8s", dup->client_name, dup->id);
         report_timeout_period(iter->data, op_timeout);
     }
 }
 
 void call_remote_stonith(remote_fencing_op_t *op, st_query_result_t *peer) 
 {
     const char *device = NULL;
     int timeout = op->base_timeout;
 
     if(peer == NULL && !is_set(op->call_options, st_opt_topology)) {
         peer = stonith_choose_peer(op);
     }
 
     if(op->op_timer_total <= 0) {
         int t = get_op_total_timeout(op, peer, op->base_timeout);
-        op->total_timeout = 1.2 * t;
+        op->total_timeout = TIMEOUT_MULTIPLY_FACTOR * t;
         op->op_timer_total = g_timeout_add(1000 * op->total_timeout, remote_op_timeout, op);
         report_timeout_period(op, op->total_timeout);
         crm_info("Total remote op timeout set to %d for fencing of node %s for %s.%.8s",
                  t, op->target, op->client_name, op->id);
     }
 
     if(is_set(op->call_options, st_opt_topology) && op->devices) {
         /* Ignore any preference, they might not have the device we need */
         /* When using topology, the stonith_choose_peer function pops off
          * the peer from the op's query results.  Make sure to calculate
          * the op_timeout before calling this function when topology is in use */
         peer = stonith_choose_peer(op);
         device = op->devices->data;
         timeout = get_device_timeout(peer, device, op->base_timeout);
     }
 
     if(peer) {
-        int t = 1.2 * get_device_timeout(peer, device, op->base_timeout);
+        int t = TIMEOUT_MULTIPLY_FACTOR * get_device_timeout(peer, device, op->base_timeout);
         xmlNode *query = stonith_create_op(0, op->id, STONITH_OP_FENCE, NULL, 0);
 
         crm_xml_add(query, F_STONITH_REMOTE, op->id);
         crm_xml_add(query, F_STONITH_TARGET, op->target);
         crm_xml_add(query, F_STONITH_ACTION, op->action);
         crm_xml_add(query, F_STONITH_ORIGIN,  op->originator);
         crm_xml_add(query, F_STONITH_CLIENTID, op->client_id);
         crm_xml_add(query, F_STONITH_CLIENTNAME, op->client_name);
         crm_xml_add_int(query, F_STONITH_TIMEOUT, timeout);
 
         if(device) {
             crm_info("Requesting that %s perform op %s %s with %s for %s (%ds)",
                      peer->host, op->action, op->target, device, op->client_name, t);
             crm_xml_add(query, F_STONITH_DEVICE, device);
             crm_xml_add(query, F_STONITH_MODE, "slave");
 
         } else {
             crm_info("Requesting that %s perform op %s %s for %s (%ds)",
                      peer->host, op->action, op->target, op->client_name, t);
             crm_xml_add(query, F_STONITH_MODE, "smart");
         }
 
         op->state = st_exec;
         if(op->op_timer_one > 0) {
             g_source_remove(op->op_timer_one);
         }
         op->op_timer_one = g_timeout_add((1000 * t), remote_op_timeout_one, op);
 
         send_cluster_message(crm_get_peer(0, peer->host), crm_msg_stonith_ng, query, FALSE);
         free_xml(query);
         return;
 
     } else if(op->query_timer < 0) {
         crm_err("The termination of %s for %s is not ours to control", op->target, op->client_name);
 
     } else if(op->query_timer == 0) {
         CRM_LOG_ASSERT(op->state < st_done);
 
         /* We've exhausted all available peers */
         crm_info("No remaining peers capable of terminating %s for %s", op->target, op->client_name, op->state);
         remote_op_timeout(op);
 
     } else if(device) {
         crm_info("Waiting for additional peers capable of terminating %s with %s for %s.%.8s",
                  op->target, device, op->client_name, op->id);
     } else {
         crm_info("Waiting for additional peers capable of terminating %s for %s%.8s",
                  op->target, op->client_name, op->id);
     }
 
     free_remote_query(peer);
 }
 
 static gint sort_peers(gconstpointer a, gconstpointer b)
 {
     const st_query_result_t *peer_a = a;
     const st_query_result_t *peer_b = a;
 
     if(peer_a->devices > peer_b->devices) {
         return -1;
     } else if(peer_a->devices > peer_b->devices) {
         return 1;
     }
     return 0;
 }
 
 int process_remote_stonith_query(xmlNode *msg) 
 {
     int devices = 0;
     const char *id = NULL;
     const char *host = NULL;
     remote_fencing_op_t *op = NULL;
     st_query_result_t *result = NULL;
     xmlNode *dev = get_xpath_object("//@"F_STONITH_REMOTE, msg, LOG_ERR);
     xmlNode *child = NULL;
 
     CRM_CHECK(dev != NULL, return -EPROTO);
 
     id = crm_element_value(dev, F_STONITH_REMOTE);
     CRM_CHECK(id != NULL, return -EPROTO);
 
     dev = get_xpath_object("//@st-available-devices", msg, LOG_ERR);
     CRM_CHECK(dev != NULL, return -EPROTO);
     crm_element_value_int(dev, "st-available-devices", &devices);
 
     op = g_hash_table_lookup(remote_op_list, id);
     if(op == NULL) {
         crm_debug("Unknown or expired remote op: %s", id);
         return -EOPNOTSUPP;
     }
 
     op->replies++;
     host = crm_element_value(msg, F_ORIG);
 
     if(devices <= 0) {
         /* If we're doing 'known' then we might need to fire anyway */
         crm_trace("Query result from %s (%d devices)", host, devices);
         return pcmk_ok;
 
     } else if(op->call_options & st_opt_allow_suicide) {
         crm_trace("Allowing %s to potentialy fence itself", op->target);
 
     } else if(safe_str_eq(host, op->target)) {
         crm_info("Ignoring reply from %s, hosts are not permitted to commit suicide", op->target);
         return pcmk_ok;
     }
 
     crm_debug("Query result from %s (%d devices)", host, devices);
     result = calloc(1, sizeof(st_query_result_t));
     result->host = strdup(host);
     result->devices = devices;
     result->custom_action_timeouts = g_hash_table_new_full(
         crm_str_hash, g_str_equal, free, NULL);
 
     for (child = __xml_first_child(dev); child != NULL; child = __xml_next(child)) {
         const char *device = ID(child);
         int action_timeout = 0;
         if(device) {
             result->device_list = g_list_prepend(result->device_list, strdup(device));
             crm_element_value_int(child, F_STONITH_ACTION_TIMEOUT, &action_timeout);
             if (action_timeout) {
                 crm_trace("Peer %s with device %s returned action timeout %d",
                     result->host, device, action_timeout);
                 g_hash_table_insert(result->custom_action_timeouts,
                     strdup(device),
                     GINT_TO_POINTER(action_timeout));
             }
         }
     }
 
     CRM_CHECK(devices == g_list_length(result->device_list),
               crm_err("Mis-match: Query claimed to have %d devices but %d found", devices, g_list_length(result->device_list)));
 
     op->query_results = g_list_insert_sorted(op->query_results, result, sort_peers);
 
     if(op->state == st_query && is_set(op->call_options, st_opt_all_replies) == FALSE) {
         call_remote_stonith(op, result);
 
     } else if(op->state == st_done) {
         crm_info("Discarding query result from %s (%d devices): Operation is in state %d",
                  result->host, result->devices, op->state);
     }
 
     return pcmk_ok;
 }
 
 int process_remote_stonith_exec(xmlNode *msg) 
 {
     int rc = 0;
     const char *id = NULL;
     const char *device = NULL;
     remote_fencing_op_t *op = NULL;
     xmlNode *dev = get_xpath_object("//@"F_STONITH_REMOTE, msg, LOG_ERR);
 
     CRM_CHECK(dev != NULL, return -EPROTO);
 
     id = crm_element_value(dev, F_STONITH_REMOTE);
     CRM_CHECK(id != NULL, return -EPROTO);
 
     dev = get_xpath_object("//@"F_STONITH_RC, msg, LOG_ERR);
     CRM_CHECK(dev != NULL, return -EPROTO);
 
     crm_element_value_int(dev, F_STONITH_RC, &rc);
 
     device = crm_element_value(dev, F_STONITH_DEVICE);
 
     if(remote_op_list) {
         op = g_hash_table_lookup(remote_op_list, id);
     }
 
     if(op == NULL && rc == pcmk_ok) {
         /* Record successful fencing operations */
         const char *client_id = crm_element_value(msg, F_STONITH_CLIENTID);
 
         op = create_remote_stonith_op(client_id, msg, TRUE);
     }
 
     if(op == NULL) {
         /* Could be for an event that began before we started */
         /* TODO: Record the op for later querying */
         crm_info("Unknown or expired remote op: %s", id);
         return -EOPNOTSUPP;
     }
 
     if (op->devices && device && safe_str_neq(op->devices->data, device)) {
         crm_err("Received outdated reply for device %s to %s node %s. Operation already timed out at remote level.",
             device, op->action, op->target);
         return rc;
     }
 
     if(safe_str_eq(crm_element_value(msg, F_SUBTYPE), "broadcast")) {
         crm_debug("Marking call to %s for %s on behalf of %s@%s.%.8s: %s (%d)",
                   op->action, op->target, op->client_name, op->id, op->originator,
                   rc == pcmk_ok?"passed":"failed", rc);
         if(rc == pcmk_ok) {
             op->state = st_done;
         } else {
             op->state = st_failed;
         }
         remote_op_done(op, msg, rc, FALSE);
         return pcmk_ok;
     }
     
     if(is_set(op->call_options, st_opt_topology)) {
         const char *device = crm_element_value(msg, F_STONITH_DEVICE);
 
         crm_notice("Call to %s for %s on behalf of %s@%s: %s (%d)",
                    device, op->target, op->client_name, op->originator,
                    rc == pcmk_ok?"passed":"failed", rc);
 
         if(safe_str_eq(op->originator, stonith_our_uname)) {
             if(op->state == st_done) {
                 remote_op_done(op, msg, rc, FALSE);
                 return rc;
 
             } else if(rc == pcmk_ok && op->devices) {
                 /* Success, are there any more? */
                 op->devices = op->devices->next;
             }
 
             if(op->devices == NULL) {
                 crm_trace("Marking complex fencing op for %s as complete", op->target);
                 if(rc == pcmk_ok) {
                     op->state = st_done;
                 } else {
                     op->state = st_failed;
                 }
                 remote_op_done(op, msg, rc, FALSE);
                 return rc;
             }
 
         } else {
             op->state = st_done;
             remote_op_done(op, msg, rc, FALSE);
             return rc;
         }
 
     } else if(rc == pcmk_ok && op->devices == NULL) {
         crm_trace("All done for %s", op->target);
 
         op->state = st_done;
         remote_op_done(op, msg, rc, FALSE);
         return rc;
     }
 
     /* Retry on failure or execute the rest of the topology */
     crm_trace("Next for %s on behalf of %s@%s (rc was %d)", op->target, op->originator, op->client_name, rc);
     call_remote_stonith(op, NULL);
     return rc;
 }
 
 int stonith_fence_history(xmlNode *msg, xmlNode **output) 
 {
     int rc = 0;
     const char *target = NULL;
     xmlNode *dev = get_xpath_object("//@"F_STONITH_TARGET, msg, LOG_TRACE);
 
     if(dev) {
         int options = 0;
 
         target = crm_element_value(dev, F_STONITH_TARGET);
         crm_element_value_int(msg, F_STONITH_CALLOPTS, &options);
         if(target && (options & st_opt_cs_nodeid)) {
             int nodeid = crm_atoi(target, NULL);
             crm_node_t *node = crm_get_peer(nodeid, NULL);
             if(node) {
                 target = node->uname;
             }
         }
     }
     *output = create_xml_node(NULL, F_STONITH_HISTORY_LIST);
 
     if (remote_op_list) {
         GHashTableIter iter;
         remote_fencing_op_t *op = NULL;
 
         g_hash_table_iter_init(&iter, remote_op_list); 
         while(g_hash_table_iter_next(&iter, NULL, (void**)&op)) {
             xmlNode *entry = NULL;
             if (target && strcmp(op->target, target) != 0) {
                 continue;
             }
 
             rc = 0;
             entry = create_xml_node(*output, STONITH_OP_EXEC);
             crm_xml_add(entry, F_STONITH_TARGET, op->target);
             crm_xml_add(entry, F_STONITH_ACTION, op->action);
             crm_xml_add(entry, F_STONITH_ORIGIN, op->originator);
             crm_xml_add(entry, F_STONITH_DELEGATE, op->delegate);
             crm_xml_add_int(entry, F_STONITH_DATE, op->completed);
             crm_xml_add_int(entry, F_STONITH_STATE, op->state);
         }
     }
 
     return rc;
 }