diff --git a/crm/crm-1.0.dtd b/crm/crm-1.0.dtd
index a3f2ead607..a4db41b33d 100644
--- a/crm/crm-1.0.dtd
+++ b/crm/crm-1.0.dtd
@@ -1,825 +1,825 @@
 <?xml version="1.0" encoding="UTF-8" ?>
 <!--
 GLOBAL TODOs:
 
 Versionize DTD so we can validate against a specific version
 
 Background
  The CIB is described quite well in section 5 of the crm.txt (checked into CVS in the crm directory) so it is not repeated here.
  Suffice to say that it stores the configuration and runtime data required for cluster-wide resource management in XML format.
 
 CIB: Information Structure
  The CIB is divided into two main sections: The "static" configuration part and the "dynamic" status.
 
  The configuration contains - surprisingly - the configuration of the cluster, namely node attributes, resource instance configuration, and the constraints which describe the dependencies between all these.
  To identify the most recent configuration available in the cluster, this section is time-stamped with the unique timestamp of the last update.
 
  The status part is dynamically generated / updated by the CRM system and represents the current status of the cluster; which nodes are up, down or crashed, which resources are running where etc.
 
  Every information carrying object has an "id" tag, which is basically the UUID of it, should we ever need to access it directly.
  Unless otherwise stated, the id field is a short name consisting simple ascii characters [a-zA-Z0-9_\-]
  The exception is for resources because the LRM can support only id's of up to 64 characters.
 
 Other Notes
  The description field in all elements is opaque to the CRM and is for administrative comments.
 
 TODO
  * Figure out a sane way to version the DTD
  * Do we need to know about ping nodes...?
  * The integer comparison type really should be number
 -->
 <!ELEMENT cib (configuration, status)>
 <!ATTLIST cib
           cib-last-written CDATA        #IMPLIED
 
           admin_epoch  CDATA        #REQUIRED
           epoch        CDATA        #REQUIRED
           num_updates  CDATA        #REQUIRED
           num_peers    CDATA        #IMPLIED        
 
           cib_feature_revision  CDATA   #IMPLIED
           crm_feature_set       CDATA   #IMPLIED
 
           dc_uuid        CDATA             #IMPLIED
           ccm_transition CDATA             #IMPLIED
           have_quorum    (true|1|false|0)  'false'
           ignore_dtd     (true|1|false|0)  #IMPLIED
 
           generated    CDATA    #IMPLIED        
           crm-debug-origin CDATA    #IMPLIED>
 
 <!--
 The CIB's version is a tuple of admin_epoch, epoch and num_updates (in that order).
 
 This is used when applying updates from the master CIB instance.
 
 Additionally, num_peers and have_quorum are used during the election process to determin who has the latest configuration.
  * num_updates is incremented every time the CIB changes.
  * epoch is incremented after every DC election.
  * admin_epoch is exclusivly for the admin to change.
  * num_peers is the number of CIB instances that we can talk to
  * have_quorum is derived from the ConsensusClusterMembership layer
  * dc_uuid stored the UUID of the current DesignatedController
  * ccm_transition stores the membership instance from the ConsensusClusterMembership layer.
  * cib_feature_revision is the feature set that this configuration requires
 -->
 <!ELEMENT configuration (crm_config, nodes, resources, constraints)>
 
 <!--
 crm_config
 
 Used to specify cluster-wide options.
 
 The use of multiple cluster_property_set sections and time-based rule expressions allows the the cluster to behave differently (for example) during buisness hours than it does overnight.
 -->
 <!ELEMENT crm_config (cluster_property_set)*>
 
 <!--
 Current crm_config options:
 
  * transition_idle_timeout (interval, default=60s):
    If no activity is recorded in this time, the transition is deemed failed as are all sent actions that have not yet been confirmed complete.
    If any operation initiated has an explicit higher timeout, the higher value applies.
 
  * symmetric_cluster (boolean, default=TRUE):
    If true, resources are permitted to run anywhere by default.
    Otherwise, explicit constraints must be created to specify where they can run.
 
  * stonith_enabled (boolean, default=FALSE):
    If true, failed nodes will be fenced.
 
  * no_quorum_policy (enum, default=stop)
    * ignore - Pretend we have quorum
    * freeze - Do not start any resources not currently in our partition.
      Resources in our partition may be moved to another node within the partition
      Fencing is disabled
    * stop - Stop all running resources in our partition
      Fencing is disabled
 
  * default_resource_stickiness
    Do we prefer to run on the existing node or be moved to a "better" one?
    * 0 : resources will be placed optimally in the system.
      This may mean they are moved when a "better" or less loaded node becomes available.
      This option is almost equivalent to auto_failback on except that the resource may be moved to other nodes than the one it was previously active on.
    * value > 0 : resources will prefer to remain in their current location but may be moved if a more suitable node is available.
      Higher values indicate a stronger preference for resources to stay where they are.
    * value < 0 : resources prefer to move away from their current location.
      Higher absolute values indicate a stronger preference for resources to be moved.
    * INFINITY : resources will always remain in their current locations until forced off because the node is no longer eligible to run the resource (node shutdown, node standby or configuration change).
      This option is almost equivalent to auto_failback off except that the resource may be moved to other nodes than the one it was previously active on.
    * -INFINITY : resources will always move away from their current location.
 
  * is_managed_default (boolean, default=TRUE)
    Unless the resource's definition says otherwise,
    * TRUE : resources will be started, stopped, monitored and moved as necessary/required
    * FALSE : resources will not started if stopped, stopped if started nor have any recurring actions scheduled.
 
  * stop_orphan_resources (boolean, default=TRUE (as of release 2.0.6))
    If a resource is found for which we have no definition for;
    * TRUE : Stop the resource
    * FALSE : Ignore the resource
    This mostly effects the CRM's behavior when a resource is deleted by an admin without it first being stopped.
 
  * stop_orphan_actions (boolean, default=TRUE)
    If a recurring action is found for which we have no definition for;
    * TRUE : Stop the action
    * FALSE : Ignore the action
    This mostly effects the CRM's behavior when the interval for a recurring action is changed.
 -->
 <!ELEMENT cluster_property_set (rule*, attributes)>
 <!ATTLIST cluster_property_set
           id                CDATA        #REQUIRED
           score             CDATA        #IMPLIED>
 
 <!ELEMENT nodes       (node*)>
 
 <!--
  * id    : the node's UUID.
  * uname : the result of uname -n
  * type  : should either be "normal" or "member" for nodes you with to run resources 
    "normal" is preferred as of version 2.0.4
 
 Each node can also have additional "instance" attributes.
 These attributes are completely arbitrary and can be used later in constraints.
 In this way it is possible to define groups of nodes to which a constraint can apply.
 
 It is also theoretically possible to have a process on each node which updates these values automatically.
 This would make it possible to have an attribute that represents "connected to SAN subsystem" or perhaps "system_load (low|medium|high)".
 
 Ideally it would be possible to have the CRMd on each node gather some of this information and automatically populate things like architecture and OS/kernel version.
 -->
 <!ELEMENT node (instance_attributes*)>
 <!ATTLIST node
           id            CDATA         #REQUIRED
           uname         CDATA         #REQUIRED
           description   CDATA         #IMPLIED
           type          (normal|member|ping) #REQUIRED>
 
 <!ELEMENT resources   (primitive|group|clone|master_slave)*>
 
 <!--
  * class
    Specifies the location and standard the resource script conforms to
    * ocf
      Most OCF RAs started out life as v1 Heartbeat resource agents.
      These have all been ported to meet the OCF specifications.
      As an added advantage, in accordance with the OCF spec, they also describe the parameters they take and what their defaults are.
      It is also easier to configure them as each part of the configuration is passed as its own parameter.
      In accordance with the OCF spec, each parameter is passed to the RA with an OCF_RESKEY_ prefix.
      So ip=192.168.1.1 in the CIB would be passed as OCF_RESKEY_ip=192.168.1.1.
      Located under /usr/lib/ocf/resource.d/heartbeat/.
    * lsb
      Most Linux init scripts conform to the LSB specification.
      The class allows you to use those that do as resource agents controlled by Heartbeat.
      Located in /etc/init.d/.
    * heartbeat
      This class gives you access to the v1 Heartbeat resource agents and allows you to reuse any custom agents you may have written.
      Located at /etc/heartbeat/resource.d/ or /etc/ha.d/resource.d.
 
  * type : The name of the ResourceAgent you wish to use.
 
  * provider
    The OCF spec allows multiple vendors to supply the same ResourceAgent.
    To use the OCF resource agents supplied with Heartbeat, you should specify heartbeat here
 
  * is_managed : Is the ClusterResourceManager in control of this resource.
    * true : (default) the resource will be started, stopped, monitored and moved as necessary/required
    * false : the resource will not started if stopped, stopped if started nor have any recurring actions scheduled.
      The resource may still be referenced in colocation constraints and ordering constraints (though obviously if no actions are performed on it then it will prevent the action on the other resource too)
 
  * restart_type
    Used when the other side of an ordering dependency is restarted/moved.
    * ignore : the default.
      Don't do anything extra.
    * restart
      Use this for example to have a restart of your database also trigger a restart of your web-server.
    * multiple_active
      Used when a resource is detected as being active on more than one machine.
      The default value, stop_start, will stop all instances and start only 1
    * block : don't do anything, wait for the administrator
    * stop_only : stop all the active instances
    * stop_start : start the resource on one node after having stopped all the active instances
 
  * resource_stickiness
    See the description of the default_resource_stickiness cluster attribute.
    resource_stickiness allows you to override the cluster's default for the individual resource.
 
 NOTE: primitive resources may contain at most one "operations" object.
       The CRM will complain about your configuration if this criteria is not met.
       Please use crm_verify to ensure your configuration is valid.
       The DTD is written this way to be order in-sensitive.
 -->
 <!ELEMENT primitive (operations|meta_attributes|instance_attributes)*>
 <!ATTLIST primitive
           id                CDATA        #REQUIRED
           description       CDATA        #IMPLIED
           class             (ocf|lsb|heartbeat|stonith) #REQUIRED
           type              CDATA        #REQUIRED
           provider          CDATA        #IMPLIED
 
           is_managed            CDATA                            #IMPLIED
           restart_type          (ignore|restart)                 'ignore'
           multiple_active       (stop_start|stop_only|block)     'stop_start'
           resource_stickiness   CDATA                             #IMPLIED>
 <!--
 This allows us to specify how long an action can take
 
  * name : the name of the operation.
    Supported operations are start, stop, & monitor
 
  * timeout : the maximum period of time before considering the action failed.
    By default this value is in milliseconds, however you can also specify a value in seconds like so timeout="5s".
 
  * interval : This currently only applies to monitor operations and specifies how often the LRM should check the resource is active.
    The same notation for timeout applies.
 
  * prereq : What conditions need to be met before this action can be run
    * nothing : This action can be performed at any time
    * quorum : This action requires the partition to have quorum
    * fencing : This action requires the partition to have quorum and any fencing operations to have completed before it can be executed
 
  * on_fail : The action to take if this action ever fails.
    * nothing : Pretend the action didnt actually fail
    * block : Take no further action on the resource - wait for the administrator to resolve the issue
    * restart : Stop the resource and re-allocate it elsewhere
    * stop : Stop the resource and DO NOT re-allocate it elsewhere
    * fence : Currently this means fence the node on which the resource is running.
      Any other resources currently active on the machine will be migrated away before fencing occurs.
 
 Only one entry per supported action+interval is currently permitted.
 Parameters specific to each operation can be passed using the instance_attributes section.
 -->
 <!ELEMENT operations (op*)>
 <!ELEMENT op (meta_attributes|instance_attributes)*>
 <!ATTLIST op
           id            CDATA         #REQUIRED
           name          CDATA         #REQUIRED
           description   CDATA         #IMPLIED
           interval      CDATA         #IMPLIED
           timeout       CDATA         #IMPLIED
           disabled      (true|1|false|0)               'false'
           role          (Master|Slave|Started|Stopped) 'Started'
           prereq        (nothing|quorum|fencing)       #IMPLIED
           on_fail       (ignore|block|stop|restart|fence)     #IMPLIED>
 <!--
 Use this to emulate v1 type Heartbeat groups.
 Defining a resource group is a quick way to make sure that the resources:
  * are all started on the same node, and
  * are started and stopped in the correct (sequential) order
 though either or both of these properties can be disabled.
 
 NOTE: Do not create empty groups.  
       They are temporarily supported because the GUI requires it but will be removed as soon as possible.
       The DTD is written this way to be order in-sensitive.
 -->
 <!ELEMENT group (meta_attributes|instance_attributes|primitive)*>
 <!ATTLIST group
           id            CDATA               #REQUIRED
           description   CDATA               #IMPLIED
 
           is_managed            CDATA                         #IMPLIED
           restart_type          (ignore|restart)              'ignore'
           multiple_active       (stop_start|stop_only|block)  'stop_start'
           resource_stickiness   (0|INFINITY|-INFINITY)        #IMPLIED
 
           ordered               (true|1|false|0)              'true'
           collocated            (true|1|false|0)              'true'>
 <!--
 Clones are intended as a mechanism for easily starting a number of resources (such as a web-server) with the same configuration.
 As an added benefit, the number that should be started is an instance parameter and when combined with time-based constraints, allows the administrator to run more instances during peak times and save on resources during idle periods.
 
  * ordered
    Start (or stop) each clone only after the operation on the previous clone completed.
 
  * interleaved
    If a colocation constraint is created between two clone resources and interleaved is true, then clone N from one resource will be assigned the same location as clone N from the other resource.
    If the number of runnable clones differs, then the leftovers can be located anywhere.
 Using a cloned group is a much better way of achieving the same result.
 
  * notify
    If true, inform peers before and after any clone is stopped or started.
    If an action failed, you will (currently) not recieve a post-notification.
    Instead you can next expect to see a pre-notification for a stop.
    If a stop fails, and you have fencing you will get a post-notification for the stop after the fencing operation has completed.
    In order to use the notification service ALL decendants of the clone MUST support the notify action.
    Currently this action is not permitted to fail, though depending on your configuration, can block almost indefinitly.
    Behaviour in response to a failed action or notificaiton is likely to be improved in future releases.
 
    See http://linux-ha.org/v2/Concepts/Clones for more information on notify actions
 
 
 NOTE: Clones must contain exactly one primitive or one group resource. 
       The CRM will complain about your configuration if this criteria is not met.
       Please use crm_verify to ensure your configuration is valid.
       The DTD is written this way to be order in-sensitive.
 -->
 
 <!ELEMENT clone (meta_attributes|instance_attributes|primitive|group)*>
 <!ATTLIST clone
           id            CDATA               #REQUIRED
           description   CDATA               #IMPLIED
 
           is_managed            CDATA                         #IMPLIED
           restart_type          (ignore|restart)              'ignore'
           multiple_active       (stop_start|stop_only|block)  'stop_start'
           resource_stickiness   CDATA                         #IMPLIED
 
           notify                (true|1|false|0)              'false'
           globally_unique       (true|1|false|0)              'true'
           ordered               (true|1|false|0)              'false'
           interleave            (true|1|false|0)              'false'>
 <!--
 Master/Slave resources are a superset of Clones in that instances can also be in one of two states.
 The meaning of the states is specific to the resource.
 
 NOTE: master_slave must contain exactly one primitive resource OR one group resource.
       It may not contain both, nor may it contain neither.
       The CRM will complain about your configuration if this criteria is not met.
       Please use crm_verify to ensure your configuration is valid.
       The DTD is written this way to be order in-sensitive.
 -->
 <!ELEMENT master_slave (meta_attributes|instance_attributes|primitive|group)*>
 <!ATTLIST master_slave
           id            CDATA       #REQUIRED
           description   CDATA       #IMPLIED
 
           is_managed            CDATA                         #IMPLIED
           restart_type          (ignore|restart)              'ignore'
           multiple_active       (stop_start|stop_only|block)  'stop_start'
           resource_stickiness   CDATA                         #IMPLIED
 
           notify                (true|1|false|0)              'false'
           globally_unique       (true|1|false|0)              'true'
           ordered               (true|1|false|0)              'false'
           interleave            (true|1|false|0)              'false'>
 
 <!--
 Most resource options are configured as instance attributes.
 Some of the built-in options can be configured directly on the resource or as an instance attribute.
 The advantage of using instance attributes is the added flexibility that can be achieved through conditional ?<rule/>s (see below).
 
 You can have multiple sets of 'instance attributes', they are first sorted by score and then processed.
 The first to have its ?<rule/> satisfied and define an attribute wins.
 Subsequent values for the attribute will be ignored.
 
 Note that:
  * instance_attributes sets with id equal to cib-bootstrap-options are treated as if they have a score of INFINITY.
  * instance_attributes sets with no score implicitly have a score of zero.
  * instance_attributes sets with no rule implicitly have a rule that evaluates to true.
 
 The addition of conditional <rule/>s to the instance_attributes object allows for an infinite variety of configurations.
 Just some of the possibilities are:
  * Specify different resource parameters
    * depending on the node it is allocated to (a resource may need to use eth1 on host1 but eth0 on host2)
    * depending on the time of day (run 10 web-servers at night an 100 during the day)
  * Allow nodes to have different attributes depending on the time-of-day
    * Set resource_stickiness to avoid failback during business hours but allow resources to be moved to a more preferred node on the weekend
    * Switch a node between a "front-end" processing group during the day to a "back-end" group at night.
 
 Common instance attributes for all resource types:
  * priority (integer, default=0):
    dictates the order in which resources will be processed.
    If there is an insufficient number of nodes to run all resources, the lower priority resources will be stopped to make sure the higher priority resources remain active.
 
  * is_managed: See previous description.
 
  * resource_stickiness: See previous description.
 
  * target_role: (Started|Stopped|Master|Slave|default, default=#default)
    * #default : Let the cluster decide what to do with the resource
    * Started : Ignore any specified value of is_managed or is_managed_default and attempt to start the resource
    * Stopped : Ignore any specified value of is_managed or is_managed_default and attempt to stop the resource
    * Master : Ignore any specified value of is_managed, is_managed_default or promotion preferences and attempt to put all instances of a cloned resource into Master mode.
    * Slave : Ignore any specified value of is_managed, is_managed_default or promotion preferences and attempt to put all instances of a cloned resource into Slave mode.
 
 Common instance attributes for clones:
  * clone_max (integer, default=1):
    the number of clones to be run
 
 * clone_node_max (integer, default=1):
   the maximum number of clones to be run on a single node
 
 Common instance attributes for nodes:
  * standby (boolean, default=FALSE)
    if TRUE, indicates that resources can not be run on the node
 -->
 <!ELEMENT instance_attributes (rule*, attributes)>
 <!ATTLIST instance_attributes
           id                CDATA        #REQUIRED
           score             CDATA        #IMPLIED>
 
 <!ELEMENT meta_attributes (rule*, attributes)>
 <!ATTLIST meta_attributes
           id                CDATA        #REQUIRED
           score             CDATA        #IMPLIED>
 
 <!--
 Every constraint entry also has a 'lifetime' attribute, which expresses when this constraint is applicable.
 For example, a constraint may only be valid during certain times of the day, or days of the week.
 Eventually, we would like to be able to support constraints that only last until events such as the next reboot or the next transition.
 -->
 <!ELEMENT constraints (rsc_order|rsc_colocation|rsc_location)*>
 
 <!--
 rsc_ordering constraints express dependencies between the actions on two resources.
  * from : A resource id
  * action : What action does this constraint apply to.
  * type : Should the action on from occur before or after action on to
  * to : A resource id
  * symmetrical : If TRUE, create the reverse constraint for the other action also.
 -->
 <!ELEMENT rsc_order (lifetime?)>
 <!ATTLIST rsc_order
           id        CDATA #REQUIRED
           from      CDATA #REQUIRED
           to        CDATA #REQUIRED
           action    (start|stop)         'start'
           type      (before|after)       'after'
           score     CDATA                '0'
           symmetrical    (true|1|false|0) 'true'>
 
 <!--
 Specify where a resource should run relative to another resource
 
 NOTE: Currently, only values of + and - INFINITY are permitted for the score.
 This may change in the future.
 -->
 <!ELEMENT rsc_colocation (lifetime?)>
 <!ATTLIST rsc_colocation
           id        CDATA #REQUIRED
           from      CDATA #REQUIRED
           to        CDATA #REQUIRED
-          score     (INFINITY|-INFINITY) #REQUIRED>
+          score     CDATA #REQUIRED>
 
 <!--
 Specify which nodes are eligible for running a given resource.
 
 During processing, all rsc_location for a given rsc are evaluated.
 
 All nodes start out with their base weight (which defaults to zero).
 This can then be modified (up or down) using any number of rsc_location constraints.
 
 Then the highest non-zero available node is determined to place the resource.
 If multiple nodes have the same weighting, the node with the fewest running resources is chosen.
 
 The rsc field is, surprisingly, a resource id.
 -->
 <!ELEMENT rsc_location (lifetime?,rule*)>
 <!ATTLIST rsc_location
           id          CDATA #REQUIRED
           description CDATA #IMPLIED
           rsc         CDATA #REQUIRED>
 <!ELEMENT lifetime (rule+)>
 <!ATTLIST lifetime id  CDATA     #REQUIRED>
 
 <!--
  * boolean_op
    determines how the results of multiple expressions are combined.
 
  * role
    limits this rule to applying to Multi State resources with the named role.
    Roles include Started, Stopped, Slave, Master though only the last two are considered useful.
    NOTE: A rule with role="Master" can not determin the initial location of a clone instance.
    It will only affect which of the active instances will be promoted.
 
  * score
    adjusts the preference for running on the matched nodes.
    NOTE: Nodes that end up with a negative score will never run the resource.
    Two special values of "score" exist: INFINITY and -INFINITY.
    Processing of these special values is as follows:
 
       INFINITY +/- -INFINITY : -INFINITY
       INFINITY +/-  int      :  INFINITY
      -INFINITY +/-  int      : -INFINITY
   
  * score_attribute 
    an alternative to the score attribute that provides extra flexibility.
   Each node matched by the rule has its score adjusted differently, according to its value for the named node attribute.
   Thus in the example below, if score_attribute="installed_ram" and nodeA would have its preference to run "the resource" increased by 1024 whereas nodeB would have its preference increased only by half as much.
 
     <nodes>
       <node id="uuid1" uname="nodeA" type="normal">
         <instance_attributes id="uuid1:custom_attrs">
           <attributes>
             <nvpair id="uuid1:installed_ram" name="installed_ram" value="1024"/>
             <nvpair id="uuid1:my_other_attr" name="my_other_attr" value="bob"/>
           </attributes>
         </instance_attributes>
       </node>
       <node id="uuid2" uname="nodeB" type="normal">
         <instance_attributes id="uuid2:custom_attrs">
           <attributes>
             <nvpair id="uuid2:installed_ram" name="installed_ram" value="512"/>
           </attributes>
         </instance_attributes>
       </node>
     </nodes>
 -->
 <!ELEMENT rule (expression|date_expression|rule)*>
 <!ATTLIST rule
           id                  CDATA          #REQUIRED
           role                CDATA          #IMPLIED
           score               CDATA          #IMPLIED
           score_attribute     CDATA          #IMPLIED
           boolean_op          (or|and)      'and'>
 
 <!--
 Returns TRUE or FALSE depending on the properties of the object being tested.
 
  * type determines how the values being tested.
    * integer Values are converted to floats before being compared.
    * version The "version" type is intended to solve the problem of comparing 1.2 and 1.10
    * string Uses strcmp
 
 Two built-in attributes are node id #id and node uname #uname so that:
       attribute=#id value=8C05CA5C-C9E3-11D8-BEE6-000A95B71D78 operation=eq, and
       attribute=#uname value=test1 operation=eq
 would both be valid tests.
 
 An extra built-in attribute called #is_dc will be set to true or false depending on whether the node is operating as the DC for the cluster.
 Valid tests using this test would be of the form:
 
         attribute=#is_dc operation=eq value=true,  and
         attribute=#is_dc operation=eq value=false, and
         attribute=#is_dc operation=ne value=false
                         (for those liking double negatives :))
 -->
 <!ELEMENT expression EMPTY>
 <!ATTLIST expression
           id         CDATA                    #REQUIRED
           attribute  CDATA                    #REQUIRED
           operation  (lt|gt|lte|gte|eq|ne|defined|not_defined) #REQUIRED
           value      CDATA                    #IMPLIED
           type       (integer|string|version) 'string'>
 
 <!--
  * start : A date-time conforming to the ISO8601 specification.
  * end : A date-time conforming to the ISO8601 specification.
    A value for end may, for any usage, be omitted and instead inferred using start and duration.
  * operation
    * gt : Compares the current date-time with start date.
      Checks now > start.
    * lt : Compares the current date-time with end date.
      Checks end > now
    * in_range : Compares the current date-time with start and end.
      Checks now > start and end > now.
      If either start or end is omitted, then that part of the comparision is not performed.
    * date_spec : Performs a cron-like comparision between the contents of date_spec and now.
      If values for start and/or end are included, now must also be within that range.
      Or in other words, the date_spec operation can also be made to perform an extra in_range check.
 
 NOTE: Because the comparisions (except for date_spec) include the time, the eq, neq, gte and lte operators have not been implemented.
 -->
 <!ELEMENT date_expression (date_spec?,duration?)>
 <!ATTLIST date_expression
         id         CDATA  #REQUIRED
         operation  (in_range|date_spec|gt|lt) 'in_range'
         start      CDATA  #IMPLIED
         end        CDATA  #IMPLIED>
 
 <!--
 date_spec is used for (surprisingly  ) date_spec operations.
 
 Fields that are not supplied are ignored.
 
 Fields can contain a single number or a single range.
 Eg.
 monthdays="1" (Matches the first day of every month) and hours="09-17" (Matches hours between 9am and 5pm inclusive) are both valid values.
 weekdays="1,2" and weekdays="1-2,5-6" are NOT valid ranges.
 This may change in a future release.
 
  * seconds : Value range 0-59
  * minutes : Value range 0-59
  * hours : Value range 0-23
  * monthdays : Value range 0-31 (depending on current month and year)
  * weekdays : Value range 1-7 (1=Monday, 7=Sunday)
  * yeardays : Value range 1-366 (depending on current year)
  * months : Value range 1-12
  * weeks : Value range 1-53 (depending on weekyear)
  * weekyears : Value range 0...
   (NOTE: weekyears may differ from Gregorian years.
   Eg. 2005-001 Ordinal == 2005-01-01 Gregorian == 2004-W53-6 Weekly )
  * years : Value range 0...
  * moon : Value range 0..7 - 0 is new, 4 is full moon.
    Because we can(tm)
 -->
 
 <!ELEMENT date_spec EMPTY>
 <!ATTLIST date_spec
         id         CDATA  #REQUIRED
         monthdays  CDATA  #IMPLIED
         weekdays   CDATA  #IMPLIED
         yeardays   CDATA  #IMPLIED
         months     CDATA  #IMPLIED
         weeks      CDATA  #IMPLIED
         weekyears  CDATA  #IMPLIED
         years      CDATA  #IMPLIED
         moon       CDATA  #IMPLIED>
 
 <!--
 duration is optionally used for calculating a value for end.
 Any field not supplied is assumed to be zero and ignored.
 Negative values might work.
 Eg. months=11 should be equivalent to writing years=1, months=-1 but is not encouraged.
 -->
 <!ELEMENT duration EMPTY>
 <!ATTLIST duration
         id         CDATA  #REQUIRED
         monthdays  CDATA  #IMPLIED
         weekdays   CDATA  #IMPLIED
         yeardays   CDATA  #IMPLIED
         months     CDATA  #IMPLIED
         weeks      CDATA  #IMPLIED
         years      CDATA  #IMPLIED>
 <!--
 Example 1: True if now is any time in the year 2005.
 
 <rule id="rule1">
   <date_expression id="date_expr1" start="2005-001" operation="in_range">
     <duration years="1"/>
   </date_expression>
 </rule>
 Example 2: Equivalent expression.
 
 <rule id="rule2">
   <date_expression id="date_expr2" operation="date_spec">
     <date_spec years="2005"/>
   </date_expression>
 </rule>
 Example 3: 9am-5pm, Mon-Friday
 
 <rule id="rule3">
   <date_expression id="date_expr3" operation="date_spec">
     <date_spec hours="9-16" days="1-5"/>
   </date_expression>
 </rule>
 Example 4: 9am-5pm, Mon-Friday, or all day saturday
 
 <rule id="rule4" boolean_op="or">
   <date_expression id="date_expr4-1" operation="date_spec">
     <date_spec hours="9-16" days="1-5"/>
   </date_expression>
   <date_expression id="date_expr4-2" operation="date_spec">
     <date_spec days="6"/>
   </date_expression>
 </rule>
 Example 5: 9am-5pm or 9pm-12pm, Mon-Friday
 
 <rule id="rule5" boolean_op="and">
   <rule id="rule5-nested1" boolean_op="or">
     <date_expression id="date_expr5-1" operation="date_spec">
       <date_spec hours="9-16"/>
     </date_expression>
     <date_expression id="date_expr5-2" operation="date_spec">
       <date_spec hours="21-23"/>
     </date_expression>
   </rule>
   <date_expression id="date_expr5-3" operation="date_spec">
     <date_spec days="1-5"/>
   </date_expression>
 </rule>
 Example 6: Mondays in March 2005
 
 <rule id="rule6" boolean_op="and">
   <date_expression id="date_expr6" operation="date_spec" start="2005-03-01" end="2005-04-01">
     <date_spec weekdays="1"/>
   </date_expression>
 </rule>
 NOTE: Because no time is specified, 00:00:00 is implied.
 This means that the range includes all of 2005-03-01 but none of 2005-04-01.
 You may wish to write end="2005-03-31T23:59:59" to avoid confusion.
 
 Example 7: Friday the 13th if it is a full moon
 
 <rule id="rule7" boolean_op="and">
   <date_expression id="date_expr7" operation="date_spec">
     <date_spec weekdays="5" monthdays="13" moon="4"/>
   </date_expression>
 </rule>
 -->
 
 <!--
 You don't have to give a value.
 There's a difference between a key not being present and a key not having a value.
 -->
 <!ELEMENT nvpair EMPTY>
 <!ATTLIST nvpair
           id     CDATA  #REQUIRED
           name   CDATA  #REQUIRED
           value  CDATA  #IMPLIED>
 
 <!ELEMENT attributes (nvpair*)>
 
 <!--
 These attributes take effect only if no value has previously been applied as part of the node's definition.
 Additionally, when the node reboots all settings made here are erased.
 
 id must be the UUID of the node.
 -->
 <!ELEMENT transient_attributes (instance_attributes*)>
 <!ATTLIST transient_attributes id CDATA #IMPLIED>
 
 <!--=========== Status - Advanced Use Only ===========-->
 
 <!--
 Details about the status of each node configured.
 
 HERE BE DRAGONS
 
 Never, ever edit this section directly or using cibadmin.
 The consequences of doing so are many and varied but rarely ever good or what you anticipated.
 To discourage this, the status section is no longer even written to disk, and is always discarded at startup.
 
 To avoid duplication of data, state entries only carry references to nodes and resources.
 -->
 <!ELEMENT status (node_state*)>
 
 <!--
 The state of a given node.
 
 This information is updated by the DC based on inputs from sources such as the CCM, status messages from remote LRMs and requests from other nodes.
  * id       -  is the node's UUID.
  * uname    - is the result of uname -n for the node.
  * crmd     - records whether the crmd process is running on the node
  * in_ccm   - records whether the node is part of our membership partition
  * join     - is the node's membership status with the current DC.
  * expected - is the DC's expectation of whether the node is up or not.
  * shutdown - is set to the time at which the node last asked to be shut down
 
 Ideally, there should be a node_state entry for every entry in the <nodes> list.
 
 -->
 <!ELEMENT node_state (transient_attributes|lrm)*>
 <!ATTLIST node_state
         id              CDATA                   #REQUIRED
         uname           CDATA                   #REQUIRED
         ha              (active|dead)           #IMPLIED
         crmd            (online|offline)        'offline'
         join            (pending|member|down)   'down'
         expected        (pending|member|down)   'down'
         in_ccm          (true|1|false|0)        'false'
         crm-debug-origin CDATA                  #IMPLIED
         shutdown        CDATA                   #IMPLIED
         clear_shutdown  CDATA                   #IMPLIED>
 
 <!--
 Information from the Local Resource Manager of the node.
 It contains a list of all resource's added (but not necessarily still active) on the node.
 -->
 <!ELEMENT lrm (lrm_resources)>
 <!ATTLIST lrm id CDATA #REQUIRED>
 
 <!ELEMENT lrm_resources (lrm_resource*)>
 <!ELEMENT lrm_resource (lrm_rsc_op*)>
 <!ATTLIST lrm_resource
           id            CDATA #REQUIRED
           class             (lsb|ocf|heartbeat|stonith) #REQUIRED
           type              CDATA        #REQUIRED
           provider          CDATA        #IMPLIED>
 <!--
 lrm_rsc_op (Resource Status)
 
 id: Set to [operation] +"_"+ [operation] +"_"+ [an_interval_in_milliseconds]
 
 operation typically start, stop, or monitor
 
 call_id: Supplied by the LRM, determins the order of in which lrm_rsc_op objects should be processed in order to determin the resource's true state
 
 rc_code is the last return code from the resource
 
 rsc_state is the state of the resource after the action completed and should be used as a guide only.
 
 transition_key contains an identifier and seqence number for the transition.
 
 At startup, the TEngine registers the identifier and starts the sequence at zero.
 It is used to identify the source of resource actions.
 
 transition_magic contains an identifier containing call_id, rc_code, and {{transition_key}}}.
 
 As the name suggests, it is a piece of magic that allows the TE to always identify the action from the stream of xml-diffs it subscribes to from the CIB.
 
 op_status is supplied by the LRM and conforms to this enum:
 
 typedef enum {
         LRM_OP_PENDING = -1,
         LRM_OP_DONE,
         LRM_OP_CANCELLED,
         LRM_OP_TIMEOUT,
         LRM_OP_NOTSUPPORTED,
         LRM_OP_ERROR,
 } op_status_t;
 The parameters section allows us to detect when a resource's definition has changed and the needs to be restarted (so the changes take effect).
 -->
 <!ELEMENT lrm_rsc_op EMPTY>
 <!ATTLIST lrm_rsc_op
           id                    CDATA #REQUIRED
           operation             CDATA #REQUIRED
           op_status             CDATA #REQUIRED
           rc_code               CDATA #REQUIRED
           call_id               CDATA #REQUIRED
           crm_feature_set       CDATA #REQUIRED
           crm-debug-origin      CDATA #IMPLIED
           transition_key        CDATA #IMPLIED
           op_digest             CDATA #IMPLIED
           interval              CDATA #REQUIRED
           transition_magic      CDATA #REQUIRED>
diff --git a/crm/pengine/allocate.c b/crm/pengine/allocate.c
index 35e92c6c04..b3e33550ac 100644
--- a/crm/pengine/allocate.c
+++ b/crm/pengine/allocate.c
@@ -1,1333 +1,1330 @@
 /* $Id: allocate.c,v 1.12 2006/08/14 09:06:31 andrew Exp $ */
 /* 
  * Copyright (C) 2004 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.1 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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  */
 
 #include <portability.h>
 
 #include <sys/param.h>
 
 #include <crm/crm.h>
 #include <crm/cib.h>
 #include <crm/msg_xml.h>
 #include <crm/common/xml.h>
 #include <crm/common/msg.h>
 #include <clplumbing/cl_misc.h>
 
 #include <glib.h>
 
 #include <crm/pengine/status.h>
 #include <pengine.h>
 #include <allocate.h>
 #include <utils.h>
 #include <lib/crm/pengine/utils.h>
 
 void set_alloc_actions(pe_working_set_t *data_set);
 
 resource_alloc_functions_t resource_class_alloc_functions[] = {
 	{
 		native_set_cmds,
 		native_num_allowed_nodes,
 		native_color,
 		native_create_actions,
 		native_create_probe,
 		native_internal_constraints,
 		native_agent_constraints,
 		native_rsc_colocation_lh,
 		native_rsc_colocation_rh,
 		native_rsc_order_lh,
 		native_rsc_order_rh,
 		native_rsc_location,
 		native_expand,
 		native_stonith_ordering,
 		native_create_notify_element,
 	},
 	{
  		group_set_cmds,
 		group_num_allowed_nodes,
 		group_color,
 		group_create_actions,
 		group_create_probe,
 		group_internal_constraints,
 		group_agent_constraints,
 		group_rsc_colocation_lh,
 		group_rsc_colocation_rh,
 		group_rsc_order_lh,
 		group_rsc_order_rh,
 		group_rsc_location,
 		group_expand,
 		group_stonith_ordering,
 		group_create_notify_element,
 	},
 	{
  		clone_set_cmds,
 		clone_num_allowed_nodes,
 		clone_color,
 		clone_create_actions,
 		clone_create_probe,
 		clone_internal_constraints,
 		clone_agent_constraints,
 		clone_rsc_colocation_lh,
 		clone_rsc_colocation_rh,
 		clone_rsc_order_lh,
 		clone_rsc_order_rh,
 		clone_rsc_location,
 		clone_expand,
 		clone_stonith_ordering,
 		clone_create_notify_element,
 	},
 	{
  		clone_set_cmds,
 		clone_num_allowed_nodes,
 		clone_color,
 		master_create_actions,
 		clone_create_probe,
 		master_internal_constraints,
 		clone_agent_constraints,
 		clone_rsc_colocation_lh,
 		clone_rsc_colocation_rh,
 		clone_rsc_order_lh,
 		clone_rsc_order_rh,
 		clone_rsc_location,
 		clone_expand,
 		clone_stonith_ordering,
 		clone_create_notify_element,
 	}
 };
 
 static gboolean
 check_rsc_parameters(resource_t *rsc, node_t *node, crm_data_t *rsc_entry,
 		     pe_working_set_t *data_set) 
 {
 	int attr_lpc = 0;
 	gboolean force_restart = FALSE;
 	gboolean delete_resource = FALSE;
 	
 	const char *value = NULL;
 	const char *old_value = NULL;
 	const char *attr_list[] = {
 		XML_ATTR_TYPE, 
 		XML_AGENT_ATTR_CLASS,
  		XML_AGENT_ATTR_PROVIDER
 	};
 
 	for(; attr_lpc < DIMOF(attr_list); attr_lpc++) {
 		value = crm_element_value(rsc->xml, attr_list[attr_lpc]);
 		old_value = crm_element_value(rsc_entry, attr_list[attr_lpc]);
 		if(safe_str_eq(value, old_value)) {
 			continue;
 		}
 		
 		force_restart = TRUE;
 		crm_notice("Forcing restart of %s on %s, %s changed: %s -> %s",
 			   rsc->id, node->details->uname, attr_list[attr_lpc],
 			   crm_str(old_value), crm_str(value));
 	}
 	if(force_restart) {
 		/* make sure the restart happens */
 		stop_action(rsc, node, FALSE);
 		rsc->start_pending = TRUE;
 		delete_resource = TRUE;
 	}
 	return delete_resource;
 }
 
 static gboolean
 check_action_definition(resource_t *rsc, node_t *active_node, crm_data_t *xml_op,
 			pe_working_set_t *data_set)
 {
 	char *key = NULL;
 	int interval = 0;
 	const char *interval_s = NULL;
 	
 	gboolean did_change = FALSE;
 
 	crm_data_t *pnow = NULL;
 	GHashTable *local_rsc_params = NULL;
 	
 	char *pnow_digest = NULL;
 	const char *param_digest = NULL;
 	char *local_param_digest = NULL;
 
 #if CRM_DEPRECATED_SINCE_2_0_4
 	crm_data_t *params = NULL;
 #endif
 
 	action_t *action = NULL;
 	const char *task = crm_element_value(xml_op, XML_LRM_ATTR_TASK);
 	const char *op_version = crm_element_value(xml_op, XML_ATTR_CRM_VERSION);
 
 	CRM_CHECK(active_node != NULL, return FALSE);
 
 	interval_s = get_interval(xml_op);
 	interval = crm_parse_int(interval_s, "0");
 	key = generate_op_key(rsc->id, task, interval);
 
 	if(interval > 0) {
 		crm_data_t *op_match = NULL;
 
 		crm_debug_2("Checking parameters for %s %s", key, task);
 		op_match = find_rsc_op_entry(rsc, key);
 
 		if(op_match == NULL && data_set->stop_action_orphans) {
 			/* create a cancel action */
 			action_t *cancel = NULL;
 			char *cancel_key = NULL;
 			
 			crm_info("Orphan action will be stopped: %s on %s",
 				 key, active_node->details->uname);
 
 			cancel_key = generate_op_key(rsc->id, CRMD_ACTION_CANCEL, interval);
 
 			cancel = custom_action(
 				rsc, cancel_key, CRMD_ACTION_CANCEL,
 				active_node, FALSE, TRUE, data_set);
 
 			add_hash_param(cancel->meta, XML_LRM_ATTR_TASK, task);
 			add_hash_param(cancel->meta,
 				       XML_LRM_ATTR_INTERVAL, interval_s);
 
 			custom_action_order(
 				rsc, NULL, cancel,
 				rsc, stop_key(rsc), NULL,
 				pe_ordering_optional, data_set);
 		}
 		if(op_match == NULL) {
 			crm_debug("Orphan action detected: %s on %s",
 				  key, active_node->details->uname);
 			crm_free(key); key = NULL;
 			return TRUE;
 		}
 	}
 
 	action = custom_action(rsc, key, task, active_node, TRUE, FALSE, data_set);
 	
 	local_rsc_params = g_hash_table_new_full(
 		g_str_hash, g_str_equal,
 		g_hash_destroy_str, g_hash_destroy_str);
 	
 	unpack_instance_attributes(
 		rsc->xml, XML_TAG_ATTR_SETS, active_node->details->attrs,
 		local_rsc_params, NULL, data_set->now);
 	
 	pnow = create_xml_node(NULL, XML_TAG_PARAMS);
 	g_hash_table_foreach(action->extra, hash2field, pnow);
 	g_hash_table_foreach(rsc->parameters, hash2field, pnow);
 	g_hash_table_foreach(local_rsc_params, hash2field, pnow);
 
 	filter_action_parameters(pnow, op_version);
 	pnow_digest = calculate_xml_digest(pnow, TRUE);
 	param_digest = crm_element_value(xml_op, XML_LRM_ATTR_OP_DIGEST);
 
 #if CRM_DEPRECATED_SINCE_2_0_4
 	if(param_digest == NULL) {
 		params = find_xml_node(xml_op, XML_TAG_PARAMS, TRUE);
 	}
 	if(params != NULL) {
 		crm_data_t *local_params = copy_xml(params);
 
 		crm_warn("Faking parameter digest creation for %s", ID(xml_op));		
 		filter_action_parameters(local_params, op_version);
 		xml_remove_prop(local_params, "interval");
 		xml_remove_prop(local_params, "timeout");
 		crm_log_xml_warn(local_params, "params:used");
 
 		local_param_digest = calculate_xml_digest(local_params, TRUE);
 		param_digest = local_param_digest;
 		
 		free_xml(local_params);
 	}
 #endif
 
 	if(safe_str_neq(pnow_digest, param_digest)) {
 		did_change = TRUE;
 		crm_log_xml_info(pnow, "params:calc");
  		crm_warn("Parameters to %s on %s changed: recorded %s vs. calculated %s",
 			 ID(xml_op), active_node->details->uname,
 			 crm_str(param_digest), pnow_digest);
 
 		key = generate_op_key(rsc->id, task, interval);
 		custom_action(rsc, key, task, NULL, FALSE, TRUE, data_set);
 	}
 
 	free_xml(pnow);
 	crm_free(pnow_digest);
 	crm_free(local_param_digest);
 	g_hash_table_destroy(local_rsc_params);
 
 	pe_free_action(action);
 	
 	return did_change;
 }
 
 extern gboolean DeleteRsc(resource_t *rsc, node_t *node, pe_working_set_t *data_set);
 
 static void
 check_actions_for(crm_data_t *rsc_entry, node_t *node, pe_working_set_t *data_set)
 {
 	const char *id = NULL;
 	const char *task = NULL;
 	int interval = 0;
 	const char *interval_s = NULL;
 	GListPtr op_list = NULL;
 	GListPtr sorted_op_list = NULL;
 	const char *rsc_id = ID(rsc_entry);
 	gboolean is_probe = FALSE;
 	resource_t *rsc = pe_find_resource(data_set->resources, rsc_id);
 
 	CRM_CHECK(rsc_id != NULL, return);
 	if(rsc == NULL) {
 		crm_warn("Skipping param check for resource with no actions");
 		return;
 
 	} else if(rsc->orphan) {
 		crm_debug_2("Skipping param check for orphan: %s %s",
 			    rsc->id, task);
 		return;
 	}
 
 	crm_debug_2("Processing %s on %s", rsc->id, node->details->uname);
 	
 	if(check_rsc_parameters(rsc, node, rsc_entry, data_set)) {
 		DeleteRsc(rsc, node, data_set);
 	}
 	
 	xml_child_iter_filter(
 		rsc_entry, rsc_op, XML_LRM_TAG_RSC_OP,
 		op_list = g_list_append(op_list, rsc_op);
 		);
 
 	sorted_op_list = g_list_sort(op_list, sort_op_by_callid);
 	slist_iter(
 		rsc_op, crm_data_t, sorted_op_list, lpc,
 
 		id   = ID(rsc_op);
 		is_probe = FALSE;
 		task = crm_element_value(rsc_op, XML_LRM_ATTR_TASK);
 
 		interval_s = get_interval(rsc_op);
 		interval = crm_parse_int(interval_s, "0");
 		
 		if(interval == 0 && safe_str_eq(task, CRMD_ACTION_STATUS)) {
 			is_probe = TRUE;
 		}
 		
 		if(is_probe || safe_str_eq(task, CRMD_ACTION_START) || interval > 0) {
 			crm_debug_2("Checking resource definition: %s", rsc->id);
 			check_action_definition(rsc, node, rsc_op, data_set);
 		}
 		crm_debug_3("Ignoring %s params: %s", task, id);
 		);
 
 	g_list_free(sorted_op_list);
 	
 }
 
 static void
 check_actions(pe_working_set_t *data_set)
 {
 	const char *id = NULL;
 	node_t *node = NULL;
 	crm_data_t *lrm_rscs = NULL;
 	crm_data_t *status = get_object_root(XML_CIB_TAG_STATUS, data_set->input);
 
 	xml_child_iter_filter(
 		status, node_state, XML_CIB_TAG_STATE,
 
 		id       = crm_element_value(node_state, XML_ATTR_ID);
 		lrm_rscs = find_xml_node(node_state, XML_CIB_TAG_LRM, FALSE);
 		lrm_rscs = find_xml_node(lrm_rscs, XML_LRM_TAG_RESOURCES, FALSE);
 
 		node = pe_find_node_id(data_set->nodes, id);
 
 		if(node == NULL) {
 			continue;
 		}
 		crm_debug("Processing node %s", node->details->uname);
 		if(node->details->online || data_set->stonith_enabled) {
 			xml_child_iter_filter(
 				lrm_rscs, rsc_entry, XML_LRM_TAG_RESOURCE,
 				check_actions_for(rsc_entry, node, data_set);
 				);
 		}
 		);
 }
 
 static gboolean 
 apply_placement_constraints(pe_working_set_t *data_set)
 {
 	crm_debug_3("Applying constraints...");
 	slist_iter(
 		cons, rsc_to_node_t, data_set->placement_constraints, lpc,
 
 		cons->rsc_lh->cmds->rsc_location(cons->rsc_lh, cons);
 		);
 	
 	return TRUE;
 	
 }
 
 void
 set_alloc_actions(pe_working_set_t *data_set) 
 {
 	slist_iter(
 		rsc, resource_t, data_set->resources, lpc,
 		rsc->cmds = &resource_class_alloc_functions[rsc->variant];
 		rsc->cmds->set_cmds(rsc);
 		);
 }
 
 gboolean
 stage0(pe_working_set_t *data_set)
 {
 	crm_data_t * cib_constraints = get_object_root(
 		XML_CIB_TAG_CONSTRAINTS, data_set->input);
 
 	if(data_set->input == NULL) {
 		return FALSE;
 	}
 
 	cluster_status(data_set);
 	
 	set_alloc_actions(data_set);
 
 	unpack_constraints(cib_constraints, data_set);
 	return TRUE;
 }
 
 /*
  * Check nodes for resources started outside of the LRM
  */
 gboolean
 stage1(pe_working_set_t *data_set)
 {
 	action_t *probe_complete = NULL;
 	action_t *probe_node_complete = NULL;
 
 	slist_iter(
 		node, node_t, data_set->nodes, lpc,
 		gboolean force_probe = FALSE;
 		const char *probed = g_hash_table_lookup(
 			node->details->attrs, CRM_OP_PROBED);
 
 		crm_debug_2("%s probed: %s", node->details->uname, probed);
 		if(node->details->online == FALSE) {
 			continue;
 			
 		} else if(node->details->unclean) {
 			continue;
 
 		} else if(probe_complete == NULL) {
 			probe_complete = custom_action(
 				NULL, crm_strdup(CRM_OP_PROBED),
 				CRM_OP_PROBED, NULL, FALSE, TRUE,
 				data_set);
 
 			probe_complete->pseudo = TRUE;
 			probe_complete->optional = TRUE;
 		}
 
 		if(probed != NULL && crm_is_true(probed) == FALSE) {
 			force_probe = TRUE;
 		}
 		
 		probe_node_complete = custom_action(
 			NULL, crm_strdup(CRM_OP_PROBED),
 			CRM_OP_PROBED, node, FALSE, TRUE, data_set);
 		probe_node_complete->optional = crm_is_true(probed);
 		probe_node_complete->priority = INFINITY;
 		add_hash_param(probe_node_complete->meta,
 			       XML_ATTR_TE_NOWAIT, XML_BOOLEAN_TRUE);
 		
 		custom_action_order(NULL, NULL, probe_node_complete,
 				    NULL, NULL, probe_complete,
 				    pe_ordering_optional, data_set);
 		
 		slist_iter(
 			rsc, resource_t, data_set->resources, lpc2,
 			
 			if(rsc->cmds->create_probe(
 				   rsc, node, probe_node_complete,
 				   force_probe, data_set)) {
 
 				probe_complete->optional = FALSE;
 				probe_node_complete->optional = FALSE;
 				custom_action_order(
 					NULL, NULL, probe_complete,
 					rsc, start_key(rsc), NULL,
 					pe_ordering_manditory, data_set);
 			}
 			);
 		);
 
 	return TRUE;
 }
 
 
 /*
  * Count how many valid nodes we have (so we know the maximum number of
  *  colors we can resolve).
  *
  * Apply node constraints (ie. filter the "allowed_nodes" part of resources
  */
 gboolean
 stage2(pe_working_set_t *data_set)
 {
 	crm_debug_3("Applying placement constraints");	
 	
 	slist_iter(
 		node, node_t, data_set->nodes, lpc,
 		if(node == NULL) {
 			/* error */
 
 		} else if(node->weight >= 0.0 /* global weight */
 			  && node->details->online
 			  && node->details->type == node_member) {
 			data_set->max_valid_nodes++;
 		}
 		);
 
 	apply_placement_constraints(data_set);
 
 	return TRUE;
 }
 
 
 /*
  * Choose a color for all resources from highest priority and XML_STRENGTH_VAL_MUST
  *  dependencies to lowest, creating new colors as necessary (returned
  *  as "colors").
  *
  * Some nodes may be colored as a "no_color" meaning that it was unresolvable
  *  given the current node stati and constraints.
  */
 gboolean
 stage3(pe_working_set_t *data_set)
 {
 	
 	/* Take (next) highest resource */
 	slist_iter(
 		rsc, resource_t, data_set->resources, lpc,
 		rsc->cmds->internal_constraints(rsc, data_set);
 		rsc->cmds->color(rsc, data_set);
 		);
 	
 	return TRUE;
 }
 
 /*
  * Choose a node for each (if possible) color
  */
 gboolean
 stage4(pe_working_set_t *data_set)
 {
 	return TRUE;
 }
 
 
 
 /*
  * Attach nodes to the actions that need to be taken
  *
  * Mark actions XML_LRM_ATTR_OPTIONAL if possible (Ie. if the start and stop are
  *  for the same node)
  *
  * Mark unrunnable actions
  */
 gboolean
 stage5(pe_working_set_t *data_set)
 {
 	crm_debug_3("Creating actions and internal ording constraints");
 	
 	check_actions(data_set);
 	slist_iter(
 		rsc, resource_t, data_set->resources, lpc,
 		rsc->cmds->create_actions(rsc, data_set);
 		);
 	return TRUE;
 }
 
 
 /*
  * Create dependacies for stonith and shutdown operations
  */
 gboolean
 stage6(pe_working_set_t *data_set)
 {
 	action_t *dc_down = NULL;
 	action_t *stonith_op = NULL;
 	action_t *last_stonith = NULL;
 	gboolean integrity_lost = FALSE;
 	
 	crm_debug_3("Processing fencing and shutdown cases");
 	
 	slist_iter(
 		node, node_t, data_set->nodes, lpc,
 
 		stonith_op = NULL;
 		if(node->details->unclean && data_set->stonith_enabled
 		   && (data_set->have_quorum
 		       || data_set->no_quorum_policy == no_quorum_ignore)) {
 			pe_warn("Scheduling Node %s for STONITH",
 				 node->details->uname);
 
 			stonith_op = custom_action(
 				NULL, crm_strdup(CRM_OP_FENCE),
 				CRM_OP_FENCE, node, FALSE, TRUE, data_set);
 
 			add_hash_param(
 				stonith_op->meta, XML_LRM_ATTR_TARGET,
 				node->details->uname);
 
 			add_hash_param(
 				stonith_op->meta, XML_LRM_ATTR_TARGET_UUID,
 				node->details->id);
 
 			add_hash_param(
 				stonith_op->meta, "stonith_action",
 				data_set->stonith_action);
 			
 			stonith_constraints(node, stonith_op, data_set);
 
 			if(node->details->is_dc) {
 				dc_down = stonith_op;
 
 			} else {
 				if(last_stonith) {
 					order_actions(last_stonith, stonith_op, pe_ordering_manditory);
 				}
 				last_stonith = stonith_op;			
 			}
 
 		} else if(node->details->online && node->details->shutdown) {			
 			action_t *down_op = NULL;	
 			crm_info("Scheduling Node %s for shutdown",
 				 node->details->uname);
 
 			down_op = custom_action(
 				NULL, crm_strdup(CRM_OP_SHUTDOWN),
 				CRM_OP_SHUTDOWN, node, FALSE, TRUE, data_set);
 
 			shutdown_constraints(node, down_op, data_set);
 
 			if(node->details->is_dc) {
 				dc_down = down_op;
 			}
 		}
 
 		if(node->details->unclean && stonith_op == NULL) {
 			integrity_lost = TRUE;
 			pe_warn("Node %s is unclean!", node->details->uname);
 		}
 		);
 
 	if(integrity_lost) {
 		if(data_set->have_quorum == FALSE) {
 			crm_notice("Cannot fence unclean nodes until quorum is"
 				   " attained (or no_quorum_policy is set to ignore)");
 
 		} else if(data_set->stonith_enabled == FALSE) {
 			pe_warn("YOUR RESOURCES ARE NOW LIKELY COMPROMISED");
 			pe_err("ENABLE STONITH TO KEEP YOUR RESOURCES SAFE");
 		}
 	}
 	
 	if(dc_down != NULL) {
 		GListPtr shutdown_matches = find_actions(
 			data_set->actions, CRM_OP_SHUTDOWN, NULL);
 		crm_debug_2("Ordering shutdowns before %s on %s (DC)",
 			dc_down->task, dc_down->node->details->uname);
 
 		add_hash_param(dc_down->meta, XML_ATTR_TE_NOWAIT,
 			       XML_BOOLEAN_TRUE);
 		
 		slist_iter(
 			node_stop, action_t, shutdown_matches, lpc,
 			if(node_stop->node->details->is_dc) {
 				continue;
 			}
 			crm_debug("Ordering shutdown on %s before %s on %s",
 				node_stop->node->details->uname,
 				dc_down->task, dc_down->node->details->uname);
 
 			order_actions(node_stop, dc_down, pe_ordering_manditory);
 			);
 
 		if(last_stonith && dc_down != last_stonith) {
 			order_actions(last_stonith, dc_down, pe_ordering_manditory);
 		}
 	}
 
 	return TRUE;
 }
 
 /*
  * Determin the sets of independant actions and the correct order for the
  *  actions in each set.
  *
  * Mark dependencies of un-runnable actions un-runnable
  *
  */
 gboolean
 stage7(pe_working_set_t *data_set)
 {
 	crm_debug_3("Applying ordering constraints");
 
 	slist_iter(
 		order, order_constraint_t, data_set->ordering_constraints, lpc,
 
 		/* try rsc_action-to-rsc_action */
 		resource_t *rsc = order->lh_rsc;
 		if(rsc == NULL && order->lh_action) {
 			rsc = order->lh_action->rsc;
 		}
 		
 		if(rsc != NULL) {
 			rsc->cmds->rsc_order_lh(rsc, order);
 			continue;
 		}
 
 		/* try action-to-rsc_action */
 		
 		/* que off the rh resource */
 		rsc = order->rh_rsc;
 		if(rsc == NULL && order->rh_action) {
 			rsc = order->rh_action->rsc;
 		}
 		
 		if(rsc != NULL) {
 			rsc->cmds->rsc_order_rh(order->lh_action, rsc, order);
 		} else {
 			/* fall back to action-to-action */
 			order_actions(
 				order->lh_action, order->rh_action, order->type);
 		}
 		
 		);
 
 	update_action_states(data_set->actions);
 
 	return TRUE;
 }
 
 int transition_id = -1;
 /*
  * Create a dependency graph to send to the transitioner (via the CRMd)
  */
 gboolean
 stage8(pe_working_set_t *data_set)
 {
 	const char *value = NULL;
 	char *transition_id_s = NULL;
 
 	transition_id++;
 	transition_id_s = crm_itoa(transition_id);
 	value = pe_pref(data_set->config_hash, "network-delay");
 	crm_debug("Creating transition graph %d.", transition_id);
 	
 	data_set->graph = create_xml_node(NULL, XML_TAG_GRAPH);
 	crm_xml_add(data_set->graph, "network-delay", value);
 	crm_xml_add(data_set->graph, "transition_id", transition_id_s);
 	crm_free(transition_id_s);
 	
 /* errors...
 	slist_iter(action, action_t, action_list, lpc,
 		   if(action->optional == FALSE && action->runnable == FALSE) {
 			   print_action("Ignoring", action, TRUE);
 		   }
 		);
 */
 	slist_iter(
 		rsc, resource_t, data_set->resources, lpc,
 
 		crm_debug_4("processing actions for rsc=%s", rsc->id);
 		rsc->cmds->expand(rsc, data_set);
 		);
 	crm_log_xml_debug_3(
 		data_set->graph, "created resource-driven action list");
 
 	/* catch any non-resource specific actions */
 	crm_debug_4("processing non-resource actions");
 	slist_iter(
 		action, action_t, data_set->actions, lpc,
 
 		graph_element_from_action(action, data_set);
 		);
 
 	crm_log_xml_debug_3(data_set->graph, "created generic action list");
 	crm_notice("Created transition graph %d.", transition_id);
 	
 	return TRUE;
 }
 
 void
 cleanup_alloc_calculations(pe_working_set_t *data_set)
 {
 	if(data_set == NULL) {
 		return;
 	}
 
 	crm_debug_3("deleting order cons: %p", data_set->ordering_constraints);
 	pe_free_ordering(data_set->ordering_constraints);
 	data_set->ordering_constraints = NULL;
 	
 	crm_debug_3("deleting node cons: %p", data_set->placement_constraints);
 	pe_free_rsc_to_node(data_set->placement_constraints);
 	data_set->placement_constraints = NULL;
 	
 	cleanup_calculations(data_set);
 }
 
 gboolean 
 unpack_constraints(crm_data_t * xml_constraints, pe_working_set_t *data_set)
 {
 	crm_data_t *lifetime = NULL;
 	crm_debug_2("Begining unpack... %s",
 		    xml_constraints?crm_element_name(xml_constraints):"<none>");
 	xml_child_iter(
 		xml_constraints, xml_obj, 
 
 		const char *id = crm_element_value(xml_obj, XML_ATTR_ID);
 		if(id == NULL) {
 			crm_config_err("Constraint <%s...> must have an id",
 				crm_element_name(xml_obj));
 			continue;
 		}
 
 		crm_debug_3("Processing constraint %s %s",
 			    crm_element_name(xml_obj),id);
 
 		lifetime = cl_get_struct(xml_obj, "lifetime");
 
 		if(test_ruleset(lifetime, NULL, data_set->now) == FALSE) {
 			crm_info("Constraint %s %s is not active",
 				 crm_element_name(xml_obj), id);
 
 		} else if(safe_str_eq(XML_CONS_TAG_RSC_ORDER,
 				      crm_element_name(xml_obj))) {
 			unpack_rsc_order(xml_obj, data_set);
 
 		} else if(safe_str_eq(XML_CONS_TAG_RSC_DEPEND,
 				      crm_element_name(xml_obj))) {
 			unpack_rsc_colocation(xml_obj, data_set);
 
 		} else if(safe_str_eq(XML_CONS_TAG_RSC_LOCATION,
 				      crm_element_name(xml_obj))) {
 			unpack_rsc_location(xml_obj, data_set);
 
 		} else {
 			pe_err("Unsupported constraint type: %s",
 				crm_element_name(xml_obj));
 		}
 		);
 
 	return TRUE;
 }
 
 static const char *
 invert_action(const char *action) 
 {
 	if(safe_str_eq(action, CRMD_ACTION_START)) {
 		return CRMD_ACTION_STOP;
 
 	} else if(safe_str_eq(action, CRMD_ACTION_STOP)) {
 		return CRMD_ACTION_START;
 		
 	} else if(safe_str_eq(action, CRMD_ACTION_PROMOTE)) {
 		return CRMD_ACTION_DEMOTE;
 		
 	} else if(safe_str_eq(action, CRMD_ACTION_DEMOTE)) {
 		return CRMD_ACTION_PROMOTE;
 
 	} else if(safe_str_eq(action, CRMD_ACTION_STARTED)) {
 		return CRMD_ACTION_STOPPED;
 		
 	} else if(safe_str_eq(action, CRMD_ACTION_STOPPED)) {
 		return CRMD_ACTION_STARTED;
 		
 	}
 	pe_err("Unknown action: %s", action);
 	return NULL;
 }
 
 gboolean
 unpack_rsc_order(crm_data_t * xml_obj, pe_working_set_t *data_set)
 {
 	gboolean symmetrical_bool = TRUE;
 	enum pe_ordering cons_weight = pe_ordering_optional;
 	
 	const char *id     = crm_element_value(xml_obj, XML_ATTR_ID);
 	const char *type   = crm_element_value(xml_obj, XML_ATTR_TYPE);
 	const char *id_rh  = crm_element_value(xml_obj, XML_CONS_ATTR_TO);
 	const char *id_lh  = crm_element_value(xml_obj, XML_CONS_ATTR_FROM);
 	const char *score  = crm_element_value(xml_obj, XML_RULE_ATTR_SCORE);
 	const char *action = crm_element_value(xml_obj, XML_CONS_ATTR_ACTION);
 	const char *action_rh = crm_element_value(xml_obj, XML_CONS_ATTR_TOACTION);
 
 	const char *symmetrical = crm_element_value(
 		xml_obj, XML_CONS_ATTR_SYMMETRICAL);
 
 	resource_t *rsc_lh   = NULL;
 	resource_t *rsc_rh   = NULL;
 
 	if(xml_obj == NULL) {
 		crm_config_err("No constraint object to process.");
 		return FALSE;
 
 	} else if(id == NULL) {
 		crm_config_err("%s constraint must have an id",
 			crm_element_name(xml_obj));
 		return FALSE;
 		
 	} else if(id_lh == NULL || id_rh == NULL) {
 		crm_config_err("Constraint %s needs two sides lh: %s rh: %s",
 			      id, crm_str(id_lh), crm_str(id_rh));
 		return FALSE;
 	}
 
 	if(action == NULL) {
 		action = CRMD_ACTION_START;
 	}
 	if(action_rh == NULL) {
 		action_rh = action;
 	}
 	CRM_CHECK(action != NULL, return FALSE);
 	CRM_CHECK(action_rh != NULL, return FALSE);
 	
 	if(safe_str_eq(type, "before")) {
 		id_lh  = crm_element_value(xml_obj, XML_CONS_ATTR_TO);
 		id_rh  = crm_element_value(xml_obj, XML_CONS_ATTR_FROM);
 		action = crm_element_value(xml_obj, XML_CONS_ATTR_TOACTION);
 		action_rh = crm_element_value(xml_obj, XML_CONS_ATTR_ACTION);
 		if(action_rh == NULL) {
 			action_rh = CRMD_ACTION_START;
 		}
 		if(action == NULL) {
 			action = action_rh;
 		}
 	}
 
 	CRM_CHECK(action != NULL, return FALSE);
 	CRM_CHECK(action_rh != NULL, return FALSE);
 	
 	rsc_lh   = pe_find_resource(data_set->resources, id_rh);
 	rsc_rh   = pe_find_resource(data_set->resources, id_lh);
 
 	if(rsc_lh == NULL) {
 		crm_config_err("Constraint %s: no resource found for LHS of %s", id, id_lh);
 		return FALSE;
 	
 	} else if(rsc_rh == NULL) {
 		crm_config_err("Constraint %s: no resource found for RHS of %s", id, id_rh);
 		return FALSE;
 	}
 
 	if(crm_atoi(score, "0") > 0) {
 		/* the name seems weird but the effect is correct */
 		cons_weight = pe_ordering_restart;
 	}
 	
 	custom_action_order(
 		rsc_lh, generate_op_key(rsc_lh->id, action, 0), NULL,
 		rsc_rh, generate_op_key(rsc_rh->id, action_rh, 0), NULL,
 		cons_weight, data_set);
 
 	if(rsc_rh->restart_type == pe_restart_restart
 	   && safe_str_eq(action, action_rh)) {
 		if(safe_str_eq(action, CRMD_ACTION_START)) {
 			crm_debug_2("Recover start-start: %s-%s",
 				rsc_lh->id, rsc_rh->id);
   			order_start_start(rsc_lh, rsc_rh, pe_ordering_recover);
  		} else if(safe_str_eq(action, CRMD_ACTION_STOP)) {
 			crm_debug_2("Recover stop-stop: %s-%s",
 				rsc_rh->id, rsc_lh->id);
   			order_stop_stop(rsc_rh, rsc_lh, pe_ordering_recover); 
 		}
 	}
 
 	cl_str_to_boolean(symmetrical, &symmetrical_bool);
 	if(symmetrical_bool == FALSE) {
 		return TRUE;
 	}
 	
 	action = invert_action(action);
 	action_rh = invert_action(action_rh);
 	
 	custom_action_order(
 		rsc_rh, generate_op_key(rsc_rh->id, action_rh, 0), NULL,
 		rsc_lh, generate_op_key(rsc_lh->id, action, 0), NULL,
 		cons_weight, data_set);
 
 	if(rsc_lh->restart_type == pe_restart_restart
 	   && safe_str_eq(action, action_rh)) {
 		if(safe_str_eq(action, CRMD_ACTION_START)) {
 			crm_debug_2("Recover start-start (2): %s-%s",
 				rsc_lh->id, rsc_rh->id);
   			order_start_start(rsc_lh, rsc_rh, pe_ordering_recover);
 		} else if(safe_str_eq(action, CRMD_ACTION_STOP)) { 
 			crm_debug_2("Recover stop-stop (2): %s-%s",
 				rsc_rh->id, rsc_lh->id);
   			order_stop_stop(rsc_rh, rsc_lh, pe_ordering_recover); 
 		}
 	}
 	
 	return TRUE;
 }
 
 gboolean
 unpack_rsc_location(crm_data_t * xml_obj, pe_working_set_t *data_set)
 {
 	gboolean empty = TRUE;
 	const char *id_lh   = crm_element_value(xml_obj, "rsc");
 	const char *id      = crm_element_value(xml_obj, XML_ATTR_ID);
 	resource_t *rsc_lh  = pe_find_resource(data_set->resources, id_lh);
 	
 	if(rsc_lh == NULL) {
 		/* only a warn as BSC adds the constraint then the resource */
 		crm_config_warn("No resource (con=%s, rsc=%s)", id, id_lh);
 		return FALSE;
 
 	} else if(rsc_lh->is_managed == FALSE) {
 		crm_debug_2("Ignoring constraint %s: resource %s not managed",
 			    id, id_lh);
 		return FALSE;
 	}
 
 	xml_child_iter_filter(
 		xml_obj, rule_xml, XML_TAG_RULE,
 		empty = FALSE;
 		crm_debug_2("Unpacking %s/%s", id, ID(rule_xml));
 		generate_location_rule(rsc_lh, rule_xml, data_set);
 		);
 
 	if(empty) {
 		crm_config_err("Invalid location constraint %s:"
 			      " rsc_location must contain at least one rule",
 			      ID(xml_obj));
 	}
 	return TRUE;
 }
 
 rsc_to_node_t *
 generate_location_rule(
 	resource_t *rsc, crm_data_t *rule_xml, pe_working_set_t *data_set)
 {	
 	const char *rule_id = NULL;
 	const char *score   = NULL;
 	const char *boolean = NULL;
 	const char *role    = NULL;
 	const char *attr_score = NULL;
 
 	GListPtr match_L  = NULL;
 	
 	int score_f   = 0;
 	gboolean do_and = TRUE;
 	gboolean accept = TRUE;
 	gboolean raw_score = TRUE;
 	
 	rsc_to_node_t *location_rule = NULL;
 	
 	rule_id = crm_element_value(rule_xml, XML_ATTR_ID);
 	boolean = crm_element_value(rule_xml, XML_RULE_ATTR_BOOLEAN_OP);
 	role = crm_element_value(rule_xml, XML_RULE_ATTR_ROLE);
 
 	crm_debug_2("Processing rule: %s", rule_id);
 
 	if(role != NULL && text2role(role) == RSC_ROLE_UNKNOWN) {
 		pe_err("Bad role specified for %s: %s", rule_id, role);
 		return NULL;
 	}
 	
 	score = crm_element_value(rule_xml, XML_RULE_ATTR_SCORE);
 	if(score != NULL) {
 		score_f = char2score(score);
 		
 	} else {
 		score = crm_element_value(
 			rule_xml, XML_RULE_ATTR_SCORE_ATTRIBUTE);
 		if(score == NULL) {
 			score = crm_element_value(
 				rule_xml, XML_RULE_ATTR_SCORE_MANGLED);
 		}
 		if(score != NULL) {
 			raw_score = FALSE;
 		}
 	}
 	if(safe_str_eq(boolean, "or")) {
 		do_and = FALSE;
 	}
 	
 	location_rule = rsc2node_new(rule_id, rsc, 0, NULL, data_set);
 	
 	if(location_rule == NULL) {
 		return NULL;
 	}
 	if(role != NULL) {
 		crm_debug_2("Setting role filter: %s", role);
 		location_rule->role_filter = text2role(role);
 	}
 	if(do_and) {
 		match_L = node_list_dup(data_set->nodes, TRUE, FALSE);
 		slist_iter(
 			node, node_t, match_L, lpc,
 			node->weight = score_f;
 			);
 	}
 
 	xml_child_iter(
 		rule_xml, expr, 		
 
 		enum expression_type type = find_expression_type(expr);
 		if(type == not_expr) {
 			pe_err("Expression <%s id=%s...> is not valid",
 			       crm_element_name(expr), crm_str(ID(expr)));
 			continue;	
 		}	
 		
 		slist_iter(
 			node, node_t, data_set->nodes, lpc,
 
 			if(type == nested_rule) {
 				accept = test_rule(
 					expr, node->details->attrs,
 					RSC_ROLE_UNKNOWN, data_set->now);
 			} else {
 				accept = test_expression(
 					expr, node->details->attrs,
 					RSC_ROLE_UNKNOWN, data_set->now);
 			}
 			
 			if(raw_score == FALSE) {
 				attr_score = g_hash_table_lookup(
 					node->details->attrs, score);
 				if(attr_score == NULL) {
 					accept = FALSE;
 					pe_warn("node %s did not have a value"
 						" for %s",
 						node->details->uname, score);
 				} else {
 					crm_debug("Rule %s: node %s had value %s for %s",
 						  rule_id, node->details->uname, attr_score, score);
 					score_f = char2score(attr_score);
 				}
 			}
 			
 			if(accept) {
 				node_t *local = pe_find_node_id(
 					match_L, node->details->id);
 				if(local == NULL && do_and) {
 					continue;
 					
 				} else if(local == NULL) {
 					local = node_copy(node);
 					match_L = g_list_append(match_L, local);
 				}
 				
 				local->weight = merge_weights(
 					local->weight, score_f);
 				crm_debug_3("node %s now has weight %d",
 					    node->details->uname,local->weight);
 				
 			} else if(do_and && !accept) {
 				/* remove it */
 				node_t *delete = pe_find_node_id(
 					match_L, node->details->id);
 				if(delete != NULL) {
 					match_L = g_list_remove(match_L,delete);
 					crm_debug_5("node %s did not match",
 						    node->details->uname);
 				}
 				crm_free(delete);
 			}
 			);
 		);
 	
 	location_rule->node_list_rh = match_L;
 	if(location_rule->node_list_rh == NULL) {
 		crm_debug_2("No matching nodes for rule %s", rule_id);
 		return NULL;
 	} 
 
 	crm_debug_3("%s: %d nodes matched",
 		    rule_id, g_list_length(location_rule->node_list_rh));
 	crm_action_debug_3(print_rsc_to_node("Added", location_rule, FALSE));
 	return location_rule;
 }
 
 gboolean
-rsc_colocation_new(const char *id, enum con_strength strength,
+rsc_colocation_new(const char *id, int score,
 		   resource_t *rsc_lh, resource_t *rsc_rh,
 		   const char *state_lh, const char *state_rh)
 {
 	rsc_colocation_t *new_con      = NULL;
  	rsc_colocation_t *inverted_con = NULL; 
 
 	if(rsc_lh == NULL){
 		crm_config_err("No resource found for LHS %s", id);
 		return FALSE;
 
 	} else if(rsc_rh == NULL){
 		crm_config_err("No resource found for RHS of %s", id);
 		return FALSE;
 	}
 
 	crm_malloc0(new_con, sizeof(rsc_colocation_t));
 	if(new_con == NULL) {
 		return FALSE;
 	}
 	if(safe_str_eq(state_lh, CRMD_ACTION_STARTED)) {
 		state_lh = NULL;
 	}
 	if(safe_str_eq(state_rh, CRMD_ACTION_STARTED)) {
 		state_rh = NULL;
 	}
 
 	new_con->id       = id;
 	new_con->rsc_lh   = rsc_lh;
 	new_con->rsc_rh   = rsc_rh;
-	new_con->strength = strength;
+	new_con->score = score;
 	new_con->state_lh = state_lh;
 	new_con->state_rh = state_rh;
 
 	
 	crm_debug_4("Adding constraint %s (%p) to %s",
 		  new_con->id, new_con, rsc_lh->id);
 	
 	rsc_lh->rsc_cons = g_list_insert_sorted(
 		rsc_lh->rsc_cons, new_con, sort_cons_strength);
 
-	/* colocation constraints are not bi-directional anymore */
-	return TRUE;
+	/* +ve colocation constraints are not bi-directional anymore */
+	if(score > 0) {
+		return TRUE;
+	}
 	
 	inverted_con = invert_constraint(new_con);
 
 	crm_debug_4("Adding constraint %s (%p) to %s",
 		  inverted_con->id, inverted_con, rsc_rh->id);
 	
 	rsc_rh->rsc_cons = g_list_insert_sorted(
 		rsc_rh->rsc_cons, inverted_con, sort_cons_strength);
 	
 	return TRUE;
 }
 
 /* LHS before RHS */
 gboolean
 custom_action_order(
 	resource_t *lh_rsc, char *lh_action_task, action_t *lh_action,
 	resource_t *rh_rsc, char *rh_action_task, action_t *rh_action,
 	enum pe_ordering type, pe_working_set_t *data_set)
 {
 	order_constraint_t *order = NULL;
 
 	if((lh_action == NULL && lh_rsc == NULL)
 	   || (rh_action == NULL && rh_rsc == NULL)){
 		crm_config_err("Invalid inputs lh_rsc=%p, lh_a=%p,"
 			      " rh_rsc=%p, rh_a=%p",
 			      lh_rsc, lh_action, rh_rsc, rh_action);
 		crm_free(lh_action_task);
 		crm_free(rh_action_task);
 		return FALSE;
 	}
 
 	crm_malloc0(order, sizeof(order_constraint_t));
 	if(order == NULL) { return FALSE; }
 	
 	order->id             = data_set->order_id++;
 	order->type           = type;
 	order->lh_rsc         = lh_rsc;
 	order->rh_rsc         = rh_rsc;
 	order->lh_action      = lh_action;
 	order->rh_action      = rh_action;
 	order->lh_action_task = lh_action_task;
 	order->rh_action_task = rh_action_task;
 	
 	data_set->ordering_constraints = g_list_append(
 		data_set->ordering_constraints, order);
 	
 	if(lh_rsc != NULL && rh_rsc != NULL) {
 		crm_debug_4("Created ordering constraint %d (%s):"
 			 " %s/%s before %s/%s",
 			 order->id, ordering_type2text(order->type),
 			 lh_rsc->id, lh_action_task,
 			 rh_rsc->id, rh_action_task);
 		
 	} else if(lh_rsc != NULL) {
 		crm_debug_4("Created ordering constraint %d (%s):"
 			 " %s/%s before action %d (%s)",
 			 order->id, ordering_type2text(order->type),
 			 lh_rsc->id, lh_action_task,
 			 rh_action->id, rh_action_task);
 		
 	} else if(rh_rsc != NULL) {
 		crm_debug_4("Created ordering constraint %d (%s):"
 			 " action %d (%s) before %s/%s",
 			 order->id, ordering_type2text(order->type),
 			 lh_action->id, lh_action_task,
 			 rh_rsc->id, rh_action_task);
 		
 	} else {
 		crm_debug_4("Created ordering constraint %d (%s):"
 			 " action %d (%s) before action %d (%s)",
 			 order->id, ordering_type2text(order->type),
 			 lh_action->id, lh_action_task,
 			 rh_action->id, rh_action_task);
 	}
 	
 	return TRUE;
 }
 
 gboolean
 unpack_rsc_colocation(crm_data_t * xml_obj, pe_working_set_t *data_set)
 {
-	enum con_strength strength_e = pecs_ignore;
-
+	int score_i = 0;
 	const char *id    = crm_element_value(xml_obj, XML_ATTR_ID);
 	const char *id_rh = crm_element_value(xml_obj, XML_CONS_ATTR_TO);
 	const char *id_lh = crm_element_value(xml_obj, XML_CONS_ATTR_FROM);
 	const char *score = crm_element_value(xml_obj, XML_RULE_ATTR_SCORE);
 	const char *state_lh = crm_element_value(xml_obj, XML_RULE_ATTR_FROMSTATE);
 	const char *state_rh = crm_element_value(xml_obj, XML_RULE_ATTR_TOSTATE);
 
 	resource_t *rsc_lh = pe_find_resource(data_set->resources, id_lh);
 	resource_t *rsc_rh = pe_find_resource(data_set->resources, id_rh);
  
 	if(rsc_lh == NULL) {
 		crm_config_err("No resource (con=%s, rsc=%s)", id, id_lh);
 		return FALSE;
 		
 	} else if(rsc_rh == NULL) {
 		crm_config_err("No resource (con=%s, rsc=%s)", id, id_rh);
 		return FALSE;
 	}
 
 	/* the docs indicate that only +/- INFINITY are allowed,
 	 *   but no-one ever reads the docs so all positive values will
 	 *   count as "must" and negative values as "must not"
 	 */
-	if(score == NULL || score[0] != '-') {
-		strength_e = pecs_must;
-	} else {
-		strength_e = pecs_must_not;
-	}
-	return rsc_colocation_new(id, strength_e, rsc_lh, rsc_rh,
-				  state_lh, state_rh);
+	score_i = crm_parse_int(score, "0");
+	return rsc_colocation_new(
+		id, score_i, rsc_lh, rsc_rh, state_lh, state_rh);
 }
 
 gboolean is_active(rsc_to_node_t *cons)
 {
 	return TRUE;
 }
diff --git a/crm/pengine/clone.c b/crm/pengine/clone.c
index 8b7c35449c..6f76003ad2 100644
--- a/crm/pengine/clone.c
+++ b/crm/pengine/clone.c
@@ -1,1309 +1,1304 @@
 /* $Id: clone.c,v 1.6 2006/07/18 06:19:33 andrew Exp $ */
 /* 
  * Copyright (C) 2004 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.1 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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  */
 
 #include <portability.h>
 
 #include <crm/msg_xml.h>
 #include <allocate.h>
 #include <utils.h>
 #include <lib/crm/pengine/utils.h>
 
 void clone_create_notifications(
 	resource_t *rsc, action_t *action, action_t *action_complete,
 	pe_working_set_t *data_set);
 
-extern gboolean rsc_colocation_new(
-	const char *id, enum con_strength strength,
-	resource_t *rsc_lh, resource_t *rsc_rh,
-	const char *state_lh, const char *state_rh);
-
 typedef struct clone_variant_data_s
 {
 		resource_t *self;
 
 		int clone_max;
 		int clone_node_max;
 
 		int active_clones;
 		int max_nodes;
 		
 		gboolean interleave;
 		gboolean ordered;
 
 		crm_data_t *xml_obj_child;
 		
 		gboolean notify_confirm;
 		
 		GListPtr child_list; /* resource_t* */
 		
 } clone_variant_data_t;
 
 void child_stopping_constraints(
 	clone_variant_data_t *clone_data, enum pe_ordering type,
 	resource_t *child, resource_t *last, pe_working_set_t *data_set);
 
 void child_starting_constraints(
 	clone_variant_data_t *clone_data, enum pe_ordering type,
 	resource_t *child, resource_t *last, pe_working_set_t *data_set);
 
 
 #define get_clone_variant_data(data, rsc)				\
 	CRM_ASSERT(rsc->variant == pe_clone || rsc->variant == pe_master); \
 	data = (clone_variant_data_t *)rsc->variant_opaque;
 
 
 
 void clone_set_cmds(resource_t *rsc)
 {
 	clone_variant_data_t *clone_data = NULL;
 	get_clone_variant_data(clone_data, rsc);
 	clone_data->self->cmds = &resource_class_alloc_functions[clone_data->self->variant];
 	slist_iter(
 		child_rsc, resource_t, clone_data->child_list, lpc,
 		child_rsc->cmds = &resource_class_alloc_functions[child_rsc->variant];
 		child_rsc->cmds->set_cmds(child_rsc);
 		);
 }
 
 int clone_num_allowed_nodes(resource_t *rsc)
 {
 	int num_nodes = 0;
 	clone_variant_data_t *clone_data = NULL;
 	get_clone_variant_data(clone_data, rsc);
 
 	/* what *should* we return here? */
 	slist_iter(
 		child_rsc, resource_t, clone_data->child_list, lpc,
 		int tmp_num_nodes = child_rsc->cmds->num_allowed_nodes(child_rsc);
 		if(tmp_num_nodes > num_nodes) {
 			num_nodes = tmp_num_nodes;
 		}
 		);
 
 	return num_nodes;
 }
 
 #if 0
 static gint sort_rsc_provisional(gconstpointer a, gconstpointer b)
 {
 	const resource_t *resource1 = (const resource_t*)a;
 	const resource_t *resource2 = (const resource_t*)b;
 
 	CRM_ASSERT(resource1 != NULL);
 	CRM_ASSERT(resource2 != NULL);
 
 	if(resource1->provisional == resource2->provisional) {
 		return 0;
 
 	} else if(resource1->provisional) {
 		return 1;
 
 	} else if(resource2->provisional) {
 		return -1;
 	}
 	CRM_CHECK(FALSE, return 0);
 	return 0;
 }
 
 static GListPtr
 next_color(GListPtr head, GListPtr iter, int max)
 {
 	color_t *color = NULL;
 	GListPtr local_iter = iter;
 	crm_debug_4("Checking iter: %p", iter);
 	if(local_iter != NULL) {
 		local_iter = local_iter->next;
 	}	
 	for(; local_iter != NULL; local_iter = local_iter->next) {
 		color = local_iter->data;
 		crm_debug_5("Color %d: %d",
 			  color->details->id, color->details->num_resources);
 		if(color->details->num_resources < max) {
 			return local_iter;
 		}
 	}
 	
 	local_iter = head;
 	crm_debug_4("Now checking head: %p", head);
 	for(; local_iter != NULL; local_iter = local_iter->next) {
 		color = local_iter->data;
 		crm_debug_5("Color %d: %d",
 			  color->details->id, color->details->num_resources);
 		if(color->details->num_resources < max) {
 			return local_iter;
 		}
 	}	
 
 	crm_debug_3("Nothing available: %p", head);
 	return NULL;
 }
 #endif		
 
 node_t *
 clone_color(resource_t *rsc, pe_working_set_t *data_set)
 {
 #if 0
 	GListPtr color_ptr = NULL;
 	GListPtr child_colors = NULL;
 	int local_node_max = 0;
 	int reverse_pointer = 0;
 	clone_variant_data_t *clone_data = NULL;
 	get_clone_variant_data(clone_data, rsc);
 
 	if(clone_data->self->provisional == FALSE) {
 		return NULL;
 	}
 	local_node_max = clone_data->clone_node_max; 
 	clone_data->max_nodes = rsc->cmds->num_allowed_nodes(rsc);
 	
 	/* give already allocated resources every chance to run on the node
 	 *   specified.  other resources can be moved/started where we want
 	 *   as required
 	 */
 	clone_data->child_list = g_list_sort(
  		clone_data->child_list, sort_rsc_provisional);
 
 	crm_debug_2("Coloring children of: %s", rsc->id);
 	
 	if(rsc->stickiness <= 0) {
 		while(local_node_max > 1
 		      && clone_data->max_nodes * (local_node_max -1)
 		      >= clone_data->clone_max) {			
 			local_node_max--;
 			crm_debug("Dropped the effective value of"
 				  " clone_node_max to: %d",
 				  local_node_max);
 		}
 	}
 
 	clone_data->self->allowed_nodes = g_list_sort(
 		clone_data->self->allowed_nodes, sort_node_weight);
 	
 	slist_iter(a_node, node_t, clone_data->self->allowed_nodes, lpc,
 		   color_t *new_color = NULL;
 		   if(can_run_resources(a_node) == FALSE) {
 			   crm_debug_2("Node cant run resources: %s",
 				       a_node->details->uname);
 			   continue;
 		   }
 		   crm_debug_3("Processing node %s for: %s",
 			       a_node->details->uname, rsc->id);
 
 		   new_color = create_color(data_set, NULL, NULL);
 		   new_color->local_weight = a_node->weight;
 		   new_color->details->candidate_nodes = g_list_append(
 			   NULL, node_copy(a_node));
 		   child_colors = g_list_append(child_colors, new_color);
 		   crm_debug_3("Created color %d for node %s (score = %d): %s",
 			       new_color->id, a_node->details->uname, a_node->weight, rsc->id);
 
 		   slist_iter(child, resource_t, clone_data->child_list, lpc2,
 			      node_t *current = NULL;
 			      if(child->provisional == FALSE) {
 				      CRM_CHECK(child->color != NULL, continue);
 				      current = child->color->details->chosen_node;
 
 			      } else if(child->running_on != NULL) {
 				      current = child->running_on->data;
 			      }
 			      
 			      if(current == NULL) {
 				      crm_debug_2("Not active: %s", child->id);
 				      continue;
 
 			      } else if(current->details->online == FALSE
 					|| current->details->unclean
 					|| current->details->shutdown) {
 				      crm_debug_2("Unavailable node: %s", child->id);
 				      continue;
 
 			      } else if(current->details != a_node->details) {
 				      crm_debug_2("Wrong node: %s", child->id);
 				      continue;
 
 			      } else if(child->provisional == FALSE) {
 				      /* make sure it shows up */
 				      native_assign_color(child, new_color);
 				      crm_debug("Previously colored: %s",
 						child->id);
 				      
 				      continue;
 				      
 			      } else if(g_list_length(child->running_on) != 1) {
 				      crm_debug("active != 1: %s", child->id);
 				      
 				      continue;
 
 			      } else if(new_color->details->num_resources
 					>= local_node_max) {
 				      crm_warn("Node %s too full for: %s",
 					       a_node->details->uname,
 					       child->id);
 				      continue;
 			      }
 
 			      a_node->weight = merge_weights(a_node->weight, child->stickiness);
 			      new_color->local_weight = a_node->weight;
 
 			      crm_debug_2("Assigning color: %s", child->id);
 			      native_assign_color(child, new_color);
 			   );
 		   
 		   native_assign_color(rsc, new_color);
 		);
 
 	while(local_node_max > 1
 	      && clone_data->max_nodes * (local_node_max -1)
 	      >= clone_data->clone_max) {
 		local_node_max--;
 		crm_debug("Dropped the effective value of clone_node_max to: %d",
 			  local_node_max);
 	}
 	
 
 	child_colors = g_list_sort(child_colors, sort_color_weight);
 	
 	/* allocate the rest */
 	slist_iter(child, resource_t, clone_data->child_list, lpc2,
 		   if(child->provisional == FALSE) {
 			   crm_debug_2("Skipping allocated resource: %s", child->id);
 			   continue;
 		   }
 		   crm_debug_2("Processing unalloc'd resource: %s", child->id);
 		   color_ptr = next_color(
 			   child_colors, color_ptr, local_node_max);
 		   if(child->variant == pe_native) {
 			   native_assign_color(child, color_ptr?color_ptr->data:data_set->no_color);
 		   } else if(child->variant == pe_group) {
 			   group_assign_color(child, color_ptr?color_ptr->data:data_set->no_color);
 		   } else {
 			   crm_err("Bad variant: %d", child->variant);
 		   }
 		);
 
 	clone_data->self->provisional = FALSE;
 	if(rsc->stickiness >= INFINITY) {
 		return NULL;
 	}
 	
 	reverse_pointer = g_list_length(child_colors) - 1;
 	slist_iter(color, color_t, child_colors, lpc,
 		   color_t *replace_color = NULL;
 		   resource_t *replace_rsc = NULL;
 		   
 		   CRM_CHECK(color != NULL, continue);
 		   if(color->details->num_resources != 0) {
 			   crm_debug_4("color %d has %d resources",
 				       color->id, color->details->num_resources);
 			   break;
 
 		   } else if(lpc >= reverse_pointer) {
 			   crm_debug_3("lpc %d, reverse lpc %d", lpc, reverse_pointer);
 			   break;
 		   }
 
 		   crm_debug_3("Color %d has %d resources, stealing one from...",
 			       color->id, color->details->num_resources);
 		   
 		   do {
 			   crm_debug_3("lpc %d, reverse lpc %d", lpc, reverse_pointer);
 			   if(lpc >= reverse_pointer) {
 				   return NULL;
 			   }
 			   replace_color = g_list_nth_data(child_colors, reverse_pointer);
 			   reverse_pointer--;
 
 			   CRM_CHECK(replace_color != NULL, continue);
 			   CRM_CHECK(replace_color->details->num_resources >= 0, continue);
 			   if(replace_color->details->num_resources == 0) {
 				   continue;
 			   }
 
 			   CRM_CHECK(replace_color->details->allocated_resources != NULL, continue);
 			   replace_rsc = replace_color->details->allocated_resources->data;
 
 			   crm_debug_3("\tColor %d with %d resources (index = %d, rsc = %s)",
 				       replace_color->id, replace_color->details->num_resources,
 				       reverse_pointer+1, replace_rsc?replace_rsc->id:"none");
 
 		   } while(replace_color == NULL
 			   || replace_color->id == 0
 			   || replace_color->details->num_resources == 0);
 
 		   if(replace_rsc->variant == pe_native) {
 			   native_assign_color(replace_rsc, color);
 
 		   } else if(replace_rsc->variant == pe_group) {
 			   group_assign_color(replace_rsc, color);
 
 		   } else {
 			   crm_err("Bad variant: %d", replace_rsc->variant);
 		   }
 		);
 #endif		
 	return NULL;
 }
 
 static void
 clone_update_pseudo_status(
 	resource_t *child, gboolean *stopping, gboolean *starting) 
 {
 	CRM_ASSERT(stopping != NULL);
 	CRM_ASSERT(starting != NULL);
 
 	slist_iter(
 		action, action_t, child->actions, lpc,
 
 		if(*starting && *stopping) {
 			return;
 
 		} else if(action->optional) {
 			crm_debug_3("Skipping optional: %s", action->uuid);
 			continue;
 
 		} else if(action->pseudo == FALSE && action->runnable == FALSE){
 			crm_debug_3("Skipping unrunnable: %s", action->uuid);
 			continue;
 
 		} else if(safe_str_eq(CRMD_ACTION_STOP, action->task)) {
 			crm_debug_2("Stopping due to: %s", action->uuid);
 			*stopping = TRUE;
 
 		} else if(safe_str_eq(CRMD_ACTION_START, action->task)) {
 			if(action->runnable == FALSE) {
 				crm_debug_3("Skipping pseduo-op: %s run=%d, pseudo=%d",
 					    action->uuid, action->runnable, action->pseudo);
 			} else {
 				crm_debug_2("Starting due to: %s", action->uuid);
 				crm_debug_3("%s run=%d, pseudo=%d",
 					    action->uuid, action->runnable, action->pseudo);
 				*starting = TRUE;
 			}
 		}
 		);
 
 }
 
 void clone_create_actions(resource_t *rsc, pe_working_set_t *data_set)
 {
 	gboolean child_starting = FALSE;
 	gboolean child_stopping = FALSE;
 	action_t *stop = NULL;
 	action_t *start = NULL;
 	action_t *action_complete = NULL;
 	resource_t *last_start_rsc = NULL;
 	resource_t *last_stop_rsc = NULL;
 	clone_variant_data_t *clone_data = NULL;
 
 	get_clone_variant_data(clone_data, rsc);
 	
 	slist_iter(
 		child_rsc, resource_t, clone_data->child_list, lpc,
 		child_rsc->cmds->create_actions(child_rsc, data_set);
 		clone_update_pseudo_status(
 			child_rsc, &child_stopping, &child_starting);
 		
 		if(child_rsc->starting) {
 			last_start_rsc = child_rsc;
 		}
 		if(child_rsc->stopping) {
 			last_stop_rsc = child_rsc;
 		}
 		);
 
 	/* start */
 	start = start_action(clone_data->self, NULL, !child_starting);
 	action_complete = custom_action(
 		clone_data->self, started_key(rsc),
 		CRMD_ACTION_STARTED, NULL, !child_starting, TRUE, data_set);
 
 	start->pseudo = TRUE;
 	action_complete->pseudo = TRUE;
 	action_complete->priority = INFINITY;
 	
 	child_starting_constraints(clone_data, pe_ordering_optional, 
 				   NULL, last_start_rsc, data_set);
 
 	clone_create_notifications(
 		rsc, start, action_complete, data_set);	
 
 
 	/* stop */
 	stop = stop_action(clone_data->self, NULL, !child_stopping);
 	action_complete = custom_action(
 		clone_data->self, stopped_key(rsc),
 		CRMD_ACTION_STOPPED, NULL, !child_stopping, TRUE, data_set);
 
 	stop->pseudo = TRUE;
 	action_complete->pseudo = TRUE;
 	action_complete->priority = INFINITY;
 	
 	child_stopping_constraints(clone_data, pe_ordering_optional,
 				   NULL, last_stop_rsc, data_set);
 
 	
 	clone_create_notifications(rsc, stop, action_complete, data_set);	
 	rsc->actions = clone_data->self->actions;	
 
 	if(stop->post_notified != NULL && start->pre_notify != NULL) {
 		order_actions(stop->post_notified, start->pre_notify, pe_ordering_optional);	
 	}
 }
 
 void
 clone_create_notifications(
 	resource_t *rsc, action_t *action, action_t *action_complete,
 	pe_working_set_t *data_set)
 {
 	/*
 	 * pre_notify -> pre_notify_complete -> pseudo_action
 	 *   -> (real actions) -> pseudo_action_complete
 	 *   -> post_notify -> post_notify_complete
 	 *
 	 * if the pre_noitfy requires confirmation,
 	 *   then a list of confirmations will be added as triggers
 	 *   to pseudo_action in clone_expand()
 	 */
 	action_t *notify = NULL;
 	action_t *notify_complete = NULL;
 	enum action_tasks task;
 	char *notify_key = NULL;
 	clone_variant_data_t *clone_data = NULL;
 	get_clone_variant_data(clone_data, rsc);
 	
 	if(rsc->notify == FALSE) {
 		return;
 	}
 	
 	task = text2task(action->task);
 
 	/* create pre_notify */
 	notify_key = generate_notify_key(
 		clone_data->self->id, "pre", action->task);
 	notify = custom_action(clone_data->self, notify_key,
 			       CRMD_ACTION_NOTIFY, NULL,
 			       action->optional, TRUE, data_set);
 	
 	add_hash_param(notify->meta, "notify_type", "pre");
 	add_hash_param(notify->meta, "notify_operation", action->task);
 	if(clone_data->notify_confirm) {
 		add_hash_param(notify->meta, "notify_confirm", "yes");
 	} else {
 		add_hash_param(notify->meta, "notify_confirm", "no");
 	}
 	notify->pseudo = TRUE;
 
 	/* create pre_notify_complete */
 	notify_key = generate_notify_key(
 		clone_data->self->id, "confirmed-pre", action->task);
 	notify_complete = custom_action(clone_data->self, notify_key,
 			       CRMD_ACTION_NOTIFIED, NULL,
 			       action->optional, TRUE, data_set);
 	add_hash_param(notify_complete->meta, "notify_type", "pre");
 	add_hash_param(notify_complete->meta, "notify_operation", action->task);
 	if(clone_data->notify_confirm) {
 		add_hash_param(notify->meta, "notify_confirm", "yes");
 	} else {
 		add_hash_param(notify->meta, "notify_confirm", "no");
 	}
 	notify->pseudo = TRUE;
 	notify_complete->pseudo = TRUE;
 
 	/* pre_notify before pre_notify_complete */
 	custom_action_order(
 		clone_data->self, NULL, notify,
 		clone_data->self, NULL, notify_complete,
 		pe_ordering_manditory, data_set);
 	
 	/* pre_notify_complete before action */
 	custom_action_order(
 		clone_data->self, NULL, notify_complete,
 		clone_data->self, NULL, action,
 		pe_ordering_manditory, data_set);
 
 	action->pre_notify = notify;
 	action->pre_notified = notify_complete;
 	
 	/* create post_notify */
 	notify_key = generate_notify_key
 		(clone_data->self->id, "post", action->task);
 	notify = custom_action(clone_data->self, notify_key,
 			       CRMD_ACTION_NOTIFY, NULL,
 			       action_complete->optional, TRUE, data_set);
 	add_hash_param(notify->meta, "notify_type", "post");
 	add_hash_param(notify->meta, "notify_operation", action->task);
 	if(clone_data->notify_confirm) {
 		add_hash_param(notify->meta, "notify_confirm", "yes");
 	} else {
 		add_hash_param(notify->meta, "notify_confirm", "no");
 	}
 	notify->pseudo = TRUE;
 
 	/* action_complete before post_notify */
 	custom_action_order(
 		clone_data->self, NULL, action_complete,
 		clone_data->self, NULL, notify, 
 		pe_ordering_postnotify, data_set);
 	
 	/* create post_notify_complete */
 	notify_key = generate_notify_key(
 		clone_data->self->id, "confirmed-post", action->task);
 	notify_complete = custom_action(clone_data->self, notify_key,
 			       CRMD_ACTION_NOTIFIED, NULL,
 			       action->optional, TRUE, data_set);
 	add_hash_param(notify_complete->meta, "notify_type", "pre");
 	add_hash_param(notify_complete->meta, "notify_operation", action->task);
 	if(clone_data->notify_confirm) {
 		add_hash_param(notify->meta, "notify_confirm", "yes");
 	} else {
 		add_hash_param(notify->meta, "notify_confirm", "no");
 	}
 	notify_complete->pseudo = TRUE;
 
 	/* post_notify before post_notify_complete */
 	custom_action_order(
 		clone_data->self, NULL, notify,
 		clone_data->self, NULL, notify_complete,
 		pe_ordering_manditory, data_set);
 
 	action->post_notify = notify;
 	action->post_notified = notify_complete;
 
 
 	if(safe_str_eq(action->task, CRMD_ACTION_STOP)) {
 		/* post_notify_complete before start */
 		custom_action_order(
 			clone_data->self, NULL, notify_complete,
 			clone_data->self, start_key(clone_data->self), NULL,
 			pe_ordering_optional, data_set);
 
 	} else if(safe_str_eq(action->task, CRMD_ACTION_START)) {
 		/* post_notify_complete before promote */
 		custom_action_order(
 			clone_data->self, NULL, notify_complete,
 			clone_data->self, promote_key(clone_data->self), NULL,
 			pe_ordering_optional, data_set);
 
 	} else if(safe_str_eq(action->task, CRMD_ACTION_DEMOTE)) {
 		/* post_notify_complete before promote */
 		custom_action_order(
 			clone_data->self, NULL, notify_complete,
 			clone_data->self, stop_key(clone_data->self), NULL,
 			pe_ordering_optional, data_set);
 	}
 }
 
 void
 child_starting_constraints(
 	clone_variant_data_t *clone_data, enum pe_ordering type,
 	resource_t *child, resource_t *last, pe_working_set_t *data_set)
 {
 	if(clone_data->ordered
 	   || clone_data->self->restart_type == pe_restart_restart) {
 		type = pe_ordering_manditory;
 	}
 	if(child == NULL) {
 		if(clone_data->ordered && last != NULL) {
 			crm_debug_4("Ordered version (last node)");
 			/* last child start before global started */
 			custom_action_order(
 				last, start_key(last), NULL,
 				clone_data->self, started_key(clone_data->self), NULL,
 				type, data_set);
 		}
 		
 	} else if(clone_data->ordered) {
 		crm_debug_4("Ordered version");
 		if(last == NULL) {
 			/* global start before first child start */
 			last = clone_data->self;
 
 		} /* else: child/child relative start */
 
 		order_start_start(last, child, type);
 
 	} else {
 		crm_debug_4("Un-ordered version");
 		
 		/* child start before global started */
 		custom_action_order(
 			child, start_key(child), NULL,
 			clone_data->self, started_key(clone_data->self), NULL,
 			type, data_set);
                 
 		/* global start before child start */
 /* 		order_start_start(clone_data->self, child, type); */
 		order_start_start(
 			clone_data->self, child, pe_ordering_manditory);
 	}
 }
 
 void
 child_stopping_constraints(
 	clone_variant_data_t *clone_data, enum pe_ordering type,
 	resource_t *child, resource_t *last, pe_working_set_t *data_set)
 {
 	if(clone_data->ordered
 	   || clone_data->self->restart_type == pe_restart_restart) {
 		type = pe_ordering_manditory;
 	}
 	
 	if(child == NULL) {
 		if(clone_data->ordered && last != NULL) {
 			crm_debug_4("Ordered version (last node)");
 			/* global stop before first child stop */
 			order_stop_stop(clone_data->self, last,
 					pe_ordering_manditory);
 		}
 		
 	} else if(clone_data->ordered && last != NULL) {
 		crm_debug_4("Ordered version");
 
 		/* child/child relative stop */
 		order_stop_stop(child, last, type);
 
 	} else if(clone_data->ordered) {
 		crm_debug_4("Ordered version (1st node)");
 		/* first child stop before global stopped */
 		custom_action_order(
 			child, stop_key(child), NULL,
 			clone_data->self, stopped_key(clone_data->self), NULL,
 			type, data_set);
 
 	} else {
 		crm_debug_4("Un-ordered version");
 
 		/* child stop before global stopped */
 		custom_action_order(
 			child, stop_key(child), NULL,
 			clone_data->self, stopped_key(clone_data->self), NULL,
 			type, data_set);
                         
 		/* global stop before child stop */
 		order_stop_stop(clone_data->self, child, type);
 	}
 }
 
 
 void
 clone_internal_constraints(resource_t *rsc, pe_working_set_t *data_set)
 {
 	resource_t *last_rsc = NULL;	
 	clone_variant_data_t *clone_data = NULL;
 	get_clone_variant_data(clone_data, rsc);
 
 	clone_data->self->cmds->internal_constraints(clone_data->self, data_set);
 	
 	/* global stop before stopped */
 	custom_action_order(
 		clone_data->self, stop_key(clone_data->self), NULL,
 		clone_data->self, stopped_key(clone_data->self), NULL,
 		pe_ordering_optional, data_set);
 
 	/* global start before started */
 	custom_action_order(
 		clone_data->self, start_key(clone_data->self), NULL,
 		clone_data->self, started_key(clone_data->self), NULL,
 		pe_ordering_optional, data_set);
 	
 	/* global stopped before start */
 	custom_action_order(
 		clone_data->self, stopped_key(clone_data->self), NULL,
 		clone_data->self, start_key(clone_data->self), NULL,
 		pe_ordering_optional, data_set);
 	
 	slist_iter(
 		child_rsc, resource_t, clone_data->child_list, lpc,
 
 		child_rsc->cmds->internal_constraints(child_rsc, data_set);
 
 		child_starting_constraints(
 			clone_data, pe_ordering_optional,
 			child_rsc, last_rsc, data_set);
 
 		child_stopping_constraints(
 			clone_data, pe_ordering_optional,
 			child_rsc, last_rsc, data_set);
 
 		last_rsc = child_rsc;
 		
 		);
 
 	child_starting_constraints(
 		clone_data, pe_ordering_optional,
 		NULL, last_rsc, data_set);
 	
 	child_stopping_constraints(
 		clone_data, pe_ordering_optional,
 		NULL, last_rsc, data_set);
 }
 
 static resource_t*
 find_compatible_child(resource_t *local_child, resource_t *rsc)
 {
 #if 0
 	node_t *local_node = NULL;
 	node_t *node = NULL;
 	clone_variant_data_t *clone_data = NULL;
 	get_clone_variant_data(clone_data, rsc);
 	CRM_ASSERT(local_child->color != NULL);
 	
 	local_node = local_child->color->details->candidate_nodes->data;
 	if(local_node == NULL) {
 		crm_debug("Can't colocate unrunnable child %s with %s",
 			 local_child->id, rsc->id);
 		return NULL;
 	}
 	
 	slist_iter(
 		child_rsc, resource_t, clone_data->child_list, lpc,
 		CRM_ASSERT(child_rsc->color != NULL);
 		node = child_rsc->color->details->candidate_nodes->data;
 		if(node->details == local_node->details) {
 			crm_info("Colocating %s with %s on %s",
 				 local_child->id, child_rsc->id, node->details->uname);
 			return child_rsc;
 		}
 		);
 	crm_debug("Can't colocate child %s with %s",
 		 local_child->id, rsc->id);
 #endif
 	return NULL;
 }
 
 void clone_rsc_colocation_lh(
 	resource_t *rsc_lh, resource_t *rsc_rh, rsc_colocation_t *constraint)
 {
 	gboolean do_interleave = FALSE;
 	resource_t *rsc = constraint->rsc_lh;
 	clone_variant_data_t *clone_data = NULL;
 	clone_variant_data_t *clone_data_rh = NULL;
 	
 	if(rsc == NULL) {
 		pe_err("rsc_lh was NULL for %s", constraint->id);
 		return;
 
 	} else if(constraint->rsc_rh == NULL) {
 		pe_err("rsc_rh was NULL for %s", constraint->id);
 		return;
 		
 	} else {
 		crm_debug_4("Processing constraints from %s", rsc->id);
 	}
 	
 	get_clone_variant_data(clone_data, rsc);
 
 	if(constraint->rsc_rh->variant == pe_clone) {
 		get_clone_variant_data(
 			clone_data_rh, constraint->rsc_rh);
 		if(clone_data->clone_node_max
 		   != clone_data_rh->clone_node_max) {
 			pe_err("Cannot interleave "XML_CIB_TAG_INCARNATION
 			       " %s and %s because"
 			       " they do not support the same number of"
 			       " resources per node",
 			       constraint->rsc_lh->id, constraint->rsc_rh->id);
 			
 		/* only the LHS side needs to be labeled as interleave */
 		} else if(clone_data->interleave) {
 			do_interleave = TRUE;
 
-		} else if(constraint->strength != pecs_must_not) {
+		} else if(constraint->score != INFINITY) {
 			pe_warn("rsc_colocations other than \"-INFINITY\""
 				" are not supported for non-interleaved "
 				XML_CIB_TAG_INCARNATION" resources");
 			return;
 		}
 
-	} else if(constraint->strength != pecs_must_not) {
+	} else if(constraint->score != -INFINITY) {
 		pe_warn("Co-location scores other than \"-INFINITY\" are not "
 			" allowed for non-"XML_CIB_TAG_INCARNATION" resources");
 		return;
 	}
 	
 	if(do_interleave) {
 		resource_t *rh_child = NULL;
 		
 		slist_iter(lh_child, resource_t, clone_data->child_list, lpc,
 
 			   CRM_ASSERT(lh_child != NULL);
 			   rh_child = find_compatible_child(lh_child, rsc_rh);
 			   if(rh_child == NULL) {
 				   continue;
 			   }
 			   lh_child->cmds->rsc_colocation_lh(
 				   lh_child, rh_child, constraint);
 			);
 		return;
 	}
 	
 	slist_iter(
 		child_rsc, resource_t, clone_data->child_list, lpc,
 		
 		child_rsc->cmds->rsc_colocation_lh(child_rsc, constraint->rsc_rh, constraint);
 		);
 }
 
 
 
 void clone_rsc_colocation_rh(
 	resource_t *rsc_lh, resource_t *rsc_rh, rsc_colocation_t *constraint)
 {
 	clone_variant_data_t *clone_data = NULL;
 	CRM_CHECK(rsc_lh != NULL, return);
 	CRM_CHECK(rsc_lh->variant == pe_native, return);
 	
 	crm_debug_3("Processing RH of constraint %s", constraint->id);
 
 	if(rsc_rh == NULL) {
 		pe_err("rsc_rh was NULL for %s", constraint->id);
 		return;
 		
-	} else if(constraint->strength != pecs_must_not) {
+	} else if(constraint->score != -INFINITY) {
 		pe_warn("rsc_dependencies other than \"must_not\" "
 			"are not supported for clone resources");
 		return;
 		
 	} else {
 		print_resource(LOG_DEBUG_3, "LHS", rsc_lh, FALSE);
 	}
 	
 	get_clone_variant_data(clone_data, rsc_rh);
 
 	slist_iter(
 		child_rsc, resource_t, clone_data->child_list, lpc,
 		
 		print_resource(LOG_DEBUG_3, "RHS", child_rsc, FALSE);
 		child_rsc->cmds->rsc_colocation_rh(rsc_lh, child_rsc, constraint);
 		);
 }
 
 
 void clone_rsc_order_lh(resource_t *rsc, order_constraint_t *order)
 {
 	char *stop_id = NULL;
 	char *start_id = NULL;
 	clone_variant_data_t *clone_data = NULL;
 	get_clone_variant_data(clone_data, rsc);
 
 	crm_debug_3("Processing LH of ordering constraint %d", order->id);
 
 	stop_id = stop_key(rsc);
 	start_id = start_key(rsc);
 	
 	if(safe_str_eq(order->lh_action_task, start_id)) {
 		crm_free(order->lh_action_task);
 		order->lh_action_task = started_key(rsc);
 
 	} else if(safe_str_eq(order->lh_action_task, stop_id)) {
 		crm_free(order->lh_action_task);
 		order->lh_action_task = stopped_key(rsc);
 	}
 
 	crm_free(start_id);
 	crm_free(stop_id);
 	
 	clone_data->self->cmds->rsc_order_lh(clone_data->self, order);
 }
 
 void clone_rsc_order_rh(
 	action_t *lh_action, resource_t *rsc, order_constraint_t *order)
 {
 	clone_variant_data_t *clone_data = NULL;
 	get_clone_variant_data(clone_data, rsc);
 
 	crm_debug_3("Processing RH of ordering constraint %d", order->id);
 
  	clone_data->self->cmds->rsc_order_rh(lh_action, clone_data->self, order);
 
 }
 
 void clone_rsc_location(resource_t *rsc, rsc_to_node_t *constraint)
 {
 	clone_variant_data_t *clone_data = NULL;
 	get_clone_variant_data(clone_data, rsc);
 
 	crm_debug_3("Processing location constraint %s for %s", constraint->id, rsc->id);
 
 	clone_data->self->cmds->rsc_location(clone_data->self, constraint);
 	slist_iter(
 		child_rsc, resource_t, clone_data->child_list, lpc,
 
 		child_rsc->cmds->rsc_location(child_rsc, constraint);
 		);
 }
 
 static gint
 sort_notify_entries(gconstpointer a, gconstpointer b)
 {
 	int tmp;
 	const notify_entry_t *entry_a = a;
 	const notify_entry_t *entry_b = b;
 
 	if(entry_a == NULL && entry_b == NULL) { return 0; }
 	if(entry_a == NULL) { return 1; }
 	if(entry_b == NULL) { return -1; }
 
 	if(entry_a->rsc == NULL && entry_b->rsc == NULL) { return 0; }
 	if(entry_a->rsc == NULL) { return 1; }
 	if(entry_b->rsc == NULL) { return -1; }
 
 	tmp = strcmp(entry_a->rsc->id, entry_b->rsc->id);
 	if(tmp != 0) {
 		return tmp;
 	}
 
 	if(entry_a->node == NULL && entry_b->node == NULL) { return 0; }
 	if(entry_a->node == NULL) { return 1; }
 	if(entry_b->node == NULL) { return -1; }
 
 	return strcmp(entry_a->node->details->id, entry_b->node->details->id);
 }
 
 static void
 expand_list(GListPtr list, int clones,
 	    char **rsc_list, char **node_list, char **uuid_list)
 {
 	const char *uname = NULL;
 	const char *rsc_id = NULL;
 	const char *last_rsc_id = NULL;
 	
 	CRM_CHECK(list != NULL, return);
 	if(rsc_list) {
 		CRM_CHECK(*rsc_list == NULL, *rsc_list = NULL);
 	}
 	if(node_list) {
 		CRM_CHECK(*node_list == NULL, *node_list = NULL);
 	}
 	
 	slist_iter(entry, notify_entry_t, list, lpc,
 
 		   CRM_CHECK(entry != NULL, continue);
 		   rsc_id = entry->rsc->id;
 		   CRM_CHECK(rsc_id != NULL, rsc_id = "__none__");
 		   uname = NULL;
 		   if(entry->node) {
 			   uname = entry->node->details->uname;
 		   }
 		   CRM_CHECK(uname != NULL, uname = "__none__");
 
 		   /* filter dups */
 		   if(safe_str_eq(rsc_id, last_rsc_id)) {
 			   continue;
 		   }
 		   last_rsc_id = rsc_id;
 
 		   if(rsc_list != NULL) {
 			   int existing_len = 0;
 			   int len = 2 + strlen(rsc_id); /* +1 space, +1 EOS */
 			   if(rsc_list && *rsc_list) {
 				   existing_len = strlen(*rsc_list);
 			   }
 
 			   crm_debug_5("Adding %s (%dc) at offset %d",
 				       rsc_id, len-2, existing_len);
 			   crm_realloc(*rsc_list, len + existing_len);
 			   sprintf(*rsc_list + existing_len, "%s ", rsc_id);
 		   }
 		   
 		   if(node_list != NULL) {
 			   int existing_len = 0;
 			   int len = 2 + strlen(uname);
 			   if(node_list && *node_list) {
 				   existing_len = strlen(*node_list);
 			   }
 			   
 			   crm_debug_5("Adding %s (%dc) at offset %d",
 				       uname, len-2, existing_len);
 			   crm_realloc(*node_list, len + existing_len);
 			   sprintf(*node_list + existing_len, "%s ", uname);
 		   }
 		   );
 }
 
 void clone_expand(resource_t *rsc, pe_working_set_t *data_set)
 {
 	char *rsc_list = NULL;
 	char *node_list = NULL;
 	char *uuid_list = NULL;	
 
 	notify_data_t *n_data = NULL;
 	clone_variant_data_t *clone_data = NULL;
 	get_clone_variant_data(clone_data, rsc);
 
 	crm_malloc0(n_data, sizeof(notify_data_t));
 	n_data->keys = g_hash_table_new_full(
 		g_str_hash, g_str_equal,
 		g_hash_destroy_str, g_hash_destroy_str);
 	
 	crm_debug_2("Processing actions from %s", rsc->id);
 
 	
 	if(rsc->notify) {
 		slist_iter(
 			child_rsc, resource_t, clone_data->child_list, lpc,
 			
 			slist_iter(
 				op, action_t, clone_data->self->actions, lpc2,
 			
 				child_rsc->cmds->create_notify_element(
 					child_rsc, op, n_data, data_set);
 				);
 			);
 	}
 	
 	/* expand the notify data */		
 	if(rsc->notify && n_data->stop) {
 		n_data->stop = g_list_sort(
 			n_data->stop, sort_notify_entries);
 		rsc_list = NULL; node_list = NULL;
 		expand_list(n_data->stop, clone_data->clone_max,
 			    &rsc_list, &node_list, &uuid_list);
 		g_hash_table_insert(
 			n_data->keys,
 			crm_strdup("notify_stop_resource"), rsc_list);
 		g_hash_table_insert(
 			n_data->keys,
 			crm_strdup("notify_stop_uname"), node_list);
 	}
 
 	if(rsc->notify && n_data->start) {
 		n_data->start = g_list_sort(
 			n_data->start, sort_notify_entries);
 		rsc_list = NULL; node_list = NULL; 
 		expand_list(n_data->start, clone_data->clone_max,
 			    &rsc_list, &node_list, &uuid_list);
 		g_hash_table_insert(
 			n_data->keys,
 			crm_strdup("notify_start_resource"), rsc_list);
 		g_hash_table_insert(
 			n_data->keys,
 			crm_strdup("notify_start_uname"), node_list);
 	}
 	
 	if(rsc->notify && n_data->demote) {
 		n_data->demote = g_list_sort(
 			n_data->demote, sort_notify_entries);
 		rsc_list = NULL; node_list = NULL;
 		expand_list(n_data->demote, clone_data->clone_max,
 			    &rsc_list, &node_list, &uuid_list);
 		g_hash_table_insert(
 			n_data->keys,
 			crm_strdup("notify_demote_resource"), rsc_list);
 		g_hash_table_insert(
 			n_data->keys,
 			crm_strdup("notify_demote_uname"), node_list);
 	}
 	
 	if(rsc->notify && n_data->promote) {
 		n_data->promote = g_list_sort(
 			n_data->promote, sort_notify_entries);
 		rsc_list = NULL; node_list = NULL; uuid_list = NULL;
 		expand_list(n_data->promote, clone_data->clone_max,
 			    &rsc_list, &node_list, &uuid_list);
 		g_hash_table_insert(
 			n_data->keys,
 			crm_strdup("notify_promote_resource"), rsc_list);
 		g_hash_table_insert(
 			n_data->keys,
 			crm_strdup("notify_promote_uname"), node_list);
 	}
 	
 	if(rsc->notify && n_data->active) {
 		n_data->active = g_list_sort(
 			n_data->active, sort_notify_entries);
 		rsc_list = NULL; node_list = NULL; uuid_list = NULL;
 		expand_list(n_data->active, clone_data->clone_max,
 			    &rsc_list, &node_list, &uuid_list);
 		g_hash_table_insert(
 			n_data->keys,
 			crm_strdup("notify_active_resource"), rsc_list);
 		g_hash_table_insert(
 			n_data->keys,
 			crm_strdup("notify_active_uname"), node_list);
 	}
 
 	if(rsc->notify && n_data->slave) {
 		n_data->slave = g_list_sort(
 			n_data->slave, sort_notify_entries);
 		rsc_list = NULL; node_list = NULL; uuid_list = NULL;
 		expand_list(n_data->slave, clone_data->clone_max,
 			    &rsc_list, &node_list, &uuid_list);
 		g_hash_table_insert(
 			n_data->keys,
 			crm_strdup("notify_slave_resource"), rsc_list);
 		g_hash_table_insert(
 			n_data->keys,
 			crm_strdup("notify_slave_uname"), node_list);
 	}
 
 	if(rsc->notify && n_data->master) {
 		n_data->master = g_list_sort(
 			n_data->master, sort_notify_entries);
 		rsc_list = NULL; node_list = NULL; uuid_list = NULL;
 		expand_list(n_data->master, clone_data->clone_max,
 			    &rsc_list, &node_list, &uuid_list);
 		g_hash_table_insert(
 			n_data->keys,
 			crm_strdup("notify_master_resource"), rsc_list);
 		g_hash_table_insert(
 			n_data->keys,
 			crm_strdup("notify_master_uname"), node_list);
 	}
 
 	if(rsc->notify && n_data->inactive) {
 		n_data->inactive = g_list_sort(
 			n_data->inactive, sort_notify_entries);
 		rsc_list = NULL; node_list = NULL; uuid_list = NULL;
 		expand_list(n_data->inactive, clone_data->clone_max,
 			    &rsc_list, &node_list, &uuid_list);
 		g_hash_table_insert(
 			n_data->keys,
 			crm_strdup("notify_inactive_resource"), rsc_list);
 		g_hash_table_insert(
 			n_data->keys,
 			crm_strdup("notify_inactive_uname"), node_list);
 	}
 	
 	/* yes, we DO need this second loop */
 	slist_iter(
 		child_rsc, resource_t, clone_data->child_list, lpc,
 		
 		child_rsc->cmds->expand(child_rsc, data_set);
 
 		);
 	
 /* 	slist_iter( */
 /* 		action, action_t, clone_data->self->actions, lpc2, */
 
 /* 		if(safe_str_eq(action->task, CRMD_ACTION_NOTIFY)) { */
 /* 			action->meta_xml = notify_xml; */
 /* 		} */
 /* 		); */
 	
 	clone_data->self->cmds->expand(clone_data->self, data_set);
 
 	/* destroy the notify_data */
 	pe_free_shallow(n_data->stop);
 	pe_free_shallow(n_data->start);
 	pe_free_shallow(n_data->demote);
 	pe_free_shallow(n_data->promote);
 	pe_free_shallow(n_data->master);
 	pe_free_shallow(n_data->slave);
 	pe_free_shallow(n_data->active);
 	pe_free_shallow(n_data->inactive);
 	g_hash_table_destroy(n_data->keys);
 	crm_free(n_data);
 }
 
 
 void
 clone_agent_constraints(resource_t *rsc)
 {
 	clone_variant_data_t *clone_data = NULL;
 	get_clone_variant_data(clone_data, rsc);
 
 	slist_iter(
 		child_rsc, resource_t, clone_data->child_list, lpc,
 		
 		child_rsc->cmds->agent_constraints(child_rsc);
 		);
 }
 
 void
 clone_create_notify_element(resource_t *rsc, action_t *op,
 			    notify_data_t *n_data, pe_working_set_t *data_set)
 {
 	clone_variant_data_t *clone_data = NULL;
 	get_clone_variant_data(clone_data, rsc);
 
 	slist_iter(
 		child_rsc, resource_t, clone_data->child_list, lpc,
 		
 		child_rsc->cmds->create_notify_element(
 			child_rsc, op, n_data, data_set);
 		);
 }
 
 static gint sort_rsc_id(gconstpointer a, gconstpointer b)
 {
 	const resource_t *resource1 = (const resource_t*)a;
 	const resource_t *resource2 = (const resource_t*)b;
 
 	CRM_ASSERT(resource1 != NULL);
 	CRM_ASSERT(resource2 != NULL);
 
 	return strcmp(resource1->id, resource2->id);
 }
 
 gboolean
 clone_create_probe(resource_t *rsc, node_t *node, action_t *complete,
 		    gboolean force, pe_working_set_t *data_set) 
 {
 	gboolean any_created = FALSE;
 	clone_variant_data_t *clone_data = NULL;
 	get_clone_variant_data(clone_data, rsc);
 
 	clone_data->child_list = g_list_sort(
 		clone_data->child_list, sort_rsc_id);
 
 	if(rsc->globally_unique == FALSE && clone_data->clone_node_max == 1) {
 		/* only look for one copy */	 
 		slist_iter(	 
 			child_rsc, resource_t, clone_data->child_list, lpc,	 
 
 			if(pe_find_node_id(child_rsc->running_on, node->details->id)) {	 
 				return child_rsc->cmds->create_probe(
 					child_rsc, node, complete, force, data_set);
 			}
 			);
 	}
 	slist_iter(
 		child_rsc, resource_t, clone_data->child_list, lpc,
 
 		if(child_rsc->cmds->create_probe(
 			   child_rsc, node, complete, force, data_set)) {
 			any_created = TRUE;
 		}
 		
 		if(any_created
 		   && rsc->globally_unique == FALSE
 		   && clone_data->clone_node_max == 1) {
 			/* only look for one copy (clone :0) */	 
 			break;
 		}
 		);
 
 	return any_created;
 }
 
 void
 clone_stonith_ordering(
 	resource_t *rsc,  action_t *stonith_op, pe_working_set_t *data_set)
 {
 	clone_variant_data_t *clone_data = NULL;
 	get_clone_variant_data(clone_data, rsc);
 
 	slist_iter(
 		child_rsc, resource_t, clone_data->child_list, lpc,
 
 		child_rsc->cmds->stonith_ordering(
 			child_rsc, stonith_op, data_set);
 		);
 }
diff --git a/crm/pengine/group.c b/crm/pengine/group.c
index b8e7c133d3..19db9cbeb7 100644
--- a/crm/pengine/group.c
+++ b/crm/pengine/group.c
@@ -1,462 +1,457 @@
 /* $Id: group.c,v 1.69 2006/08/14 09:06:31 andrew Exp $ */
 /* 
  * Copyright (C) 2004 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.1 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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  */
 
 #include <portability.h>
 
 #include <pengine.h>
 #include <lib/crm/pengine/utils.h>
 #include <crm/msg_xml.h>
 #include <clplumbing/cl_misc.h>
 #include <allocate.h>
-
-extern gboolean rsc_colocation_new(
-	const char *id, enum con_strength strength,
-	resource_t *rsc_lh, resource_t *rsc_rh,
-	const char *state_lh, const char *state_rh);
-	
+#include <utils.h>
 
 typedef struct group_variant_data_s
 {
 		int num_children;
 		GListPtr child_list; /* resource_t* */
 		resource_t *self;
 		resource_t *first_child;
 		resource_t *last_child;
 
 		gboolean colocated;
 		gboolean ordered;
 		
 		gboolean child_starting;
 		gboolean child_stopping;
 		
 } group_variant_data_t;
 
 
 #define get_group_variant_data(data, rsc)				\
 	CRM_ASSERT(rsc != NULL);					\
 	CRM_ASSERT(rsc->variant == pe_group);				\
 	CRM_ASSERT(rsc->variant_opaque != NULL);			\
 	data = (group_variant_data_t *)rsc->variant_opaque;		\
 
 void group_set_cmds(resource_t *rsc)
 {
 	group_variant_data_t *group_data = NULL;
 	get_group_variant_data(group_data, rsc);
 	group_data->self->cmds = &resource_class_alloc_functions[group_data->self->variant];
 	slist_iter(
 		child_rsc, resource_t, group_data->child_list, lpc,
 		child_rsc->cmds = &resource_class_alloc_functions[child_rsc->variant];
 		child_rsc->cmds->set_cmds(child_rsc);
 		);
 }
 
 int group_num_allowed_nodes(resource_t *rsc)
 {
 	group_variant_data_t *group_data = NULL;
 	get_group_variant_data(group_data, rsc);
 	if(group_data->colocated == FALSE) {
 		crm_config_err("Cannot clone non-colocated group: %s", rsc->id);
 		return 0;
 	}
  	return group_data->self->cmds->num_allowed_nodes(group_data->self);
 }
 
 node_t *
 group_color(resource_t *rsc, pe_working_set_t *data_set)
 {
 	node_t *group_node = NULL;
 	group_variant_data_t *group_data = NULL;
 	get_group_variant_data(group_data, rsc);
 
 	crm_debug_3("Coloring children of: %s", rsc->id);
 
 	slist_iter(
 		coloc, rsc_colocation_t, rsc->rsc_cons, lpc,
 		crm_debug_3("Pre-Processing %s for %s", coloc->id, rsc->id);
 		group_data->first_child->cmds->rsc_colocation_lh(
 			group_data->first_child, coloc->rsc_rh, coloc);
 		);
 	
 	slist_iter(
 		child_rsc, resource_t, group_data->child_list, lpc,
 		group_node = child_rsc->cmds->color(child_rsc, data_set);
 		CRM_CHECK(group_node != NULL, continue);
 		);
 	
 	return group_node;
 }
 
 void group_update_pseudo_status(resource_t *parent, resource_t *child);
 
 void group_create_actions(resource_t *rsc, pe_working_set_t *data_set)
 {
 	action_t *op = NULL;
 	group_variant_data_t *group_data = NULL;
 	get_group_variant_data(group_data, rsc);
 
 	slist_iter(
 		child_rsc, resource_t, group_data->child_list, lpc,
 		child_rsc->cmds->create_actions(child_rsc, data_set);
 		group_update_pseudo_status(rsc, child_rsc);
 		);
 
 	op = start_action(group_data->self, NULL, !group_data->child_starting);
 	op->pseudo   = TRUE;
 
 	op = custom_action(group_data->self, started_key(group_data->self),
 			   CRMD_ACTION_STARTED, NULL,
 			   !group_data->child_starting, TRUE, data_set);
 	op->pseudo   = TRUE;
 
 	op = stop_action(group_data->self, NULL, !group_data->child_stopping);
 	op->pseudo   = TRUE;
 	
 	op = custom_action(group_data->self, stopped_key(group_data->self),
 			   CRMD_ACTION_STOPPED, NULL,
 			   !group_data->child_stopping, TRUE, data_set);
 	op->pseudo   = TRUE;
 
 	rsc->actions = group_data->self->actions;
 }
 
 void
 group_update_pseudo_status(resource_t *parent, resource_t *child) 
 {
 	group_variant_data_t *group_data = NULL;
 	get_group_variant_data(group_data, parent);
 
 	if(group_data->child_stopping && group_data->child_starting) {
 		return;
 	}
 	slist_iter(
 		action, action_t, child->actions, lpc,
 
 		if(action->optional) {
 			continue;
 		}
 		if(safe_str_eq(CRMD_ACTION_STOP, action->task) && action->runnable) {
 			group_data->child_stopping = TRUE;
 		} else if(safe_str_eq(CRMD_ACTION_START, action->task) && action->runnable) {
 			group_data->child_starting = TRUE;
 		}
 		
 		);
 }
 
 void group_internal_constraints(resource_t *rsc, pe_working_set_t *data_set)
 {
 	resource_t *last_rsc = NULL;
 	group_variant_data_t *group_data = NULL;
 	get_group_variant_data(group_data, rsc);
 
 	group_data->self->cmds->internal_constraints(group_data->self, data_set);
 	
 	custom_action_order(
 		group_data->self, stopped_key(group_data->self), NULL,
 		group_data->self, start_key(group_data->self), NULL,
 		pe_ordering_optional, data_set);
 
 	custom_action_order(
 		group_data->self, stop_key(group_data->self), NULL,
 		group_data->self, stopped_key(group_data->self), NULL,
 		pe_ordering_optional, data_set);
 
 	custom_action_order(
 		group_data->self, start_key(group_data->self), NULL,
 		group_data->self, started_key(group_data->self), NULL,
 		pe_ordering_optional, data_set);
 	
 	slist_iter(
 		child_rsc, resource_t, group_data->child_list, lpc,
 
 		child_rsc->cmds->internal_constraints(child_rsc, data_set);
 
 		if(group_data->colocated && child_rsc != group_data->first_child) {
 			rsc_colocation_new(
-				"group:internal_colocation", pecs_must,
+				"group:internal_colocation", INFINITY,
 				group_data->first_child, child_rsc,
 				NULL, NULL);
 		}
 	
 		if(group_data->ordered == FALSE) {
 			order_start_start(
 				group_data->self, child_rsc, pe_ordering_optional);
 
 			custom_action_order(
 				child_rsc, start_key(child_rsc), NULL,
 				group_data->self, started_key(group_data->self), NULL,
 				pe_ordering_optional, data_set);
 
 			order_stop_stop(
 				group_data->self, child_rsc, pe_ordering_optional);
 
 			custom_action_order(
 				child_rsc, stop_key(child_rsc), NULL,
 				group_data->self, stopped_key(group_data->self), NULL,
 				pe_ordering_optional, data_set);
 
 			continue;
 		}
 		
 		if(last_rsc != NULL) {
 			order_start_start(
 				last_rsc, child_rsc, pe_ordering_optional);
 			order_stop_stop(
 				child_rsc, last_rsc, pe_ordering_optional);
 
 			/* recovery */
 			child_rsc->restart_type = pe_restart_restart;
 			order_start_start(
 				last_rsc, child_rsc, pe_ordering_recover);
 			order_stop_stop(
 				child_rsc, last_rsc, pe_ordering_recover);
 
 		} else {
 			custom_action_order(
 				child_rsc, stop_key(child_rsc), NULL,
 				group_data->self, stopped_key(group_data->self), NULL,
 				pe_ordering_optional, data_set);
 
 			order_start_start(group_data->self, child_rsc,
 					  pe_ordering_optional);
 		}
 		
 		last_rsc = child_rsc;
 		);
 
 	if(group_data->ordered && last_rsc != NULL) {
 		custom_action_order(
 			last_rsc, start_key(last_rsc), NULL,
 			group_data->self, started_key(group_data->self), NULL,
 			pe_ordering_optional, data_set);
 
 		order_stop_stop(
 			group_data->self, last_rsc, pe_ordering_optional);
 	}
 		
 }
 
 
 void group_rsc_colocation_lh(
 	resource_t *rsc_lh, resource_t *rsc_rh, rsc_colocation_t *constraint)
 {
 	group_variant_data_t *group_data = NULL;
 	
 	if(rsc_lh == NULL) {
 		pe_err("rsc_lh was NULL for %s", constraint->id);
 		return;
 
 	} else if(rsc_rh == NULL) {
 		pe_err("rsc_rh was NULL for %s", constraint->id);
 		return;
 	}
 		
 	crm_debug_4("Processing constraints from %s", rsc_lh->id);
 
 	get_group_variant_data(group_data, rsc_lh);
 
 	if(group_data->colocated) {
 		group_data->first_child->cmds->rsc_colocation_lh(
 			group_data->first_child, rsc_rh, constraint); 
 		return;
 	}
 	
-	if(constraint->strength != pecs_must_not) {
+	if(constraint->score > 0) {
 		crm_config_err("Cannot colocate resources with"
 			      " non-colocated group: %s", rsc_lh->id);
 		return;
 	} 
 
 	slist_iter(
 		child_rsc, resource_t, group_data->child_list, lpc,
 		child_rsc->cmds->rsc_colocation_lh(
 			child_rsc, rsc_rh, constraint); 
 		);
 }
 
 void group_rsc_colocation_rh(
 	resource_t *rsc_lh, resource_t *rsc_rh, rsc_colocation_t *constraint)
 {
 	group_variant_data_t *group_data = NULL;
 	get_group_variant_data(group_data, rsc_rh);
 	CRM_CHECK(rsc_lh->variant == pe_native, return);
 
 	crm_debug_3("Processing RH of constraint %s", constraint->id);
 	print_resource(LOG_DEBUG_3, "LHS", rsc_lh, TRUE);
 	
 	if(group_data->colocated) {
 		group_data->first_child->cmds->rsc_colocation_rh(
 			rsc_lh, group_data->first_child, constraint); 
 		return;
 	}
 	
-	if(constraint->strength != pecs_must_not) {
+	if(constraint->score > 0) {
 		crm_config_err("Cannot colocate resources with"
 			      " non-colocated group: %s", rsc_rh->id);
 		return;
 	} 
 
 	slist_iter(
 		child_rsc, resource_t, group_data->child_list, lpc,
 		child_rsc->cmds->rsc_colocation_rh(
 			rsc_lh, child_rsc, constraint); 
 		);
 }
 
 
 void group_rsc_order_lh(resource_t *rsc, order_constraint_t *order)
 {
 	char *stop_id = NULL;
 	char *start_id = NULL;
 	group_variant_data_t *group_data = NULL;
 	get_group_variant_data(group_data, rsc);
 
 	crm_debug_3("Processing LH of ordering constraint %d", order->id);
 
 	if(group_data->self == NULL) {
 		return;
 	}
 
 	stop_id = stop_key(group_data->self);
 	start_id = start_key(group_data->self);
 	
 	if(safe_str_eq(order->lh_action_task, start_id)) {
 		crm_free(order->lh_action_task);
 		order->lh_action_task = started_key(group_data->self);
 
 	} else if(safe_str_eq(order->lh_action_task, stop_id)) {
 		crm_free(order->lh_action_task);
 		order->lh_action_task = stopped_key(group_data->self);
 	}
 
 	crm_free(start_id);
 	crm_free(stop_id);
 	
 	group_data->self->cmds->rsc_order_lh(group_data->self, order);
 }
 
 void group_rsc_order_rh(
 	action_t *lh_action, resource_t *rsc, order_constraint_t *order)
 {
 	group_variant_data_t *group_data = NULL;
 	get_group_variant_data(group_data, rsc);
 
 	crm_debug_3("Processing RH of ordering constraint %d", order->id);
 
 	if(group_data->self == NULL) {
 		return;
 	}
 
 	group_data->self->cmds->rsc_order_rh(lh_action, group_data->self, order);
 }
 
 void group_rsc_location(resource_t *rsc, rsc_to_node_t *constraint)
 {
 	group_variant_data_t *group_data = NULL;
 	get_group_variant_data(group_data, rsc);
 
 	crm_debug_3("Processing actions from %s", group_data->self->id);
 
 	group_data->self->cmds->rsc_location(group_data->self, constraint);
 
 	slist_iter(
 		child_rsc, resource_t, group_data->child_list, lpc,
 		child_rsc->cmds->rsc_location(child_rsc, constraint);
 		);
 }
 
 void group_expand(resource_t *rsc, pe_working_set_t *data_set)
 {
 	group_variant_data_t *group_data = NULL;
 	get_group_variant_data(group_data, rsc);
 
 	crm_debug_3("Processing actions from %s", rsc->id);
 
 	CRM_CHECK(group_data->self != NULL, return);
 	group_data->self->cmds->expand(group_data->self, data_set);
 	
 	slist_iter(
 		child_rsc, resource_t, group_data->child_list, lpc,
 
 		child_rsc->cmds->expand(child_rsc, data_set);
 		);
 
 }
 
 void
 group_agent_constraints(resource_t *rsc)
 {
 	group_variant_data_t *group_data = NULL;
 	get_group_variant_data(group_data, rsc);
 
 	slist_iter(
 		child_rsc, resource_t, group_data->child_list, lpc,
 		
 		child_rsc->cmds->agent_constraints(child_rsc);
 		);
 }
 
 void
 group_create_notify_element(resource_t *rsc, action_t *op,
 			    notify_data_t *n_data, pe_working_set_t *data_set)
 {
 	group_variant_data_t *group_data = NULL;
 	get_group_variant_data(group_data, rsc);
 
 	slist_iter(
 		child_rsc, resource_t, group_data->child_list, lpc,
 		
 		child_rsc->cmds->create_notify_element(
 			child_rsc, op, n_data, data_set);
 		);
 }
 
 gboolean
 group_create_probe(resource_t *rsc, node_t *node, action_t *complete,
 		    gboolean force, pe_working_set_t *data_set) 
 {
 	gboolean any_created = FALSE;
 	group_variant_data_t *group_data = NULL;
 	get_group_variant_data(group_data, rsc);
 
 	slist_iter(
 		child_rsc, resource_t, group_data->child_list, lpc,
 		
 		any_created = child_rsc->cmds->create_probe(
 			child_rsc, node, complete, force, data_set) || any_created;
 		);
 	return any_created;
 }
 
 void
 group_stonith_ordering(
 	resource_t *rsc,  action_t *stonith_op, pe_working_set_t *data_set)
 {
 	group_variant_data_t *group_data = NULL;
 	get_group_variant_data(group_data, rsc);
 
 	slist_iter(
 		child_rsc, resource_t, group_data->child_list, lpc,
 		
 		child_rsc->cmds->stonith_ordering(
 			child_rsc, stonith_op, data_set);
 		);
 }
 
 		
diff --git a/crm/pengine/native.c b/crm/pengine/native.c
index e25828bd48..156682f107 100644
--- a/crm/pengine/native.c
+++ b/crm/pengine/native.c
@@ -1,1533 +1,1526 @@
 /* $Id: native.c,v 1.161 2006/08/17 07:17:15 andrew Exp $ */
 /* 
  * Copyright (C) 2004 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.1 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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  */
 
 #include <portability.h>
 
 #include <pengine.h>
 #include <crm/pengine/rules.h>
 #include <lib/crm/pengine/utils.h>
 #include <crm/msg_xml.h>
 #include <allocate.h>
 #include <utils.h>
 
 #define DELETE_THEN_REFRESH 1
 
 void node_list_update(GListPtr list1, GListPtr list2);
 
 void native_rsc_colocation_rh_must(resource_t *rsc_lh, gboolean update_lh,
 				   resource_t *rsc_rh, gboolean update_rh);
 
 void native_rsc_colocation_rh_mustnot(resource_t *rsc_lh, gboolean update_lh,
 				      resource_t *rsc_rh, gboolean update_rh);
 
 void filter_nodes(resource_t *rsc);
 
 void create_notifications(resource_t *rsc, pe_working_set_t *data_set);
 void Recurring(resource_t *rsc, action_t *start, node_t *node,
 			      pe_working_set_t *data_set);
 void pe_pre_notify(
 	resource_t *rsc, node_t *node, action_t *op, 
 	notify_data_t *n_data, pe_working_set_t *data_set);
 void pe_post_notify(
 	resource_t *rsc, node_t *node, action_t *op, 
 	notify_data_t *n_data, pe_working_set_t *data_set);
 
 gboolean DeleteRsc(resource_t *rsc, node_t *node, pe_working_set_t *data_set);
 void NoRoleChange(resource_t *rsc, node_t *current, node_t *next, pe_working_set_t *data_set);
 gboolean StopRsc(resource_t *rsc, node_t *next, pe_working_set_t *data_set);
 gboolean StartRsc(resource_t *rsc, node_t *next, pe_working_set_t *data_set);
 extern gboolean DemoteRsc(resource_t *rsc, node_t *next, pe_working_set_t *data_set);
 gboolean PromoteRsc(resource_t *rsc, node_t *next, pe_working_set_t *data_set);
 gboolean RoleError(resource_t *rsc, node_t *next, pe_working_set_t *data_set);
 gboolean NullOp(resource_t *rsc, node_t *next, pe_working_set_t *data_set);
 
 enum rsc_role_e rsc_state_matrix[RSC_ROLE_MAX][RSC_ROLE_MAX] = {
 /* Current State */	
 /*    Next State:  Unknown 	    Stopped	      Started	        Slave	          Master */
 /* Unknown */	{ RSC_ROLE_UNKNOWN, RSC_ROLE_STOPPED, RSC_ROLE_STOPPED, RSC_ROLE_STOPPED, RSC_ROLE_STOPPED, },
 /* Stopped */	{ RSC_ROLE_STOPPED, RSC_ROLE_STOPPED, RSC_ROLE_STARTED, RSC_ROLE_SLAVE,   RSC_ROLE_SLAVE, },
 /* Started */	{ RSC_ROLE_STOPPED, RSC_ROLE_STOPPED, RSC_ROLE_STARTED, RSC_ROLE_SLAVE,   RSC_ROLE_MASTER, },
 /* Slave */	{ RSC_ROLE_STOPPED, RSC_ROLE_STOPPED, RSC_ROLE_UNKNOWN, RSC_ROLE_SLAVE,   RSC_ROLE_MASTER, },
 /* Master */	{ RSC_ROLE_STOPPED, RSC_ROLE_SLAVE,   RSC_ROLE_UNKNOWN, RSC_ROLE_SLAVE,   RSC_ROLE_MASTER, },
 };
 
 gboolean (*rsc_action_matrix[RSC_ROLE_MAX][RSC_ROLE_MAX])(resource_t*,node_t*,pe_working_set_t*) = {
 /* Current State */	
 /*    Next State: Unknown	Stopped		Started		Slave		Master */
 /* Unknown */	{ RoleError,	StopRsc,	RoleError,	RoleError,	RoleError,  },
 /* Stopped */	{ RoleError,	NullOp,		StartRsc,	StartRsc,	RoleError,  },
 /* Started */	{ RoleError,	StopRsc,	NullOp,		NullOp,	        PromoteRsc,  },
 /* Slave */	{ RoleError,	StopRsc,	RoleError,	NullOp,		PromoteRsc, },
 /* Master */	{ RoleError,	RoleError,	RoleError,	DemoteRsc,	NullOp,     },
 };
 
 
 typedef struct native_variant_data_s
 {
 /* 		GListPtr allowed_nodes;    /\* node_t*   *\/ */
 
 } native_variant_data_t;
 
 #define get_native_variant_data(data, rsc)				\
 	CRM_ASSERT(rsc->variant == pe_native);				\
 	CRM_ASSERT(rsc->variant_opaque != NULL);			\
 	data = (native_variant_data_t *)rsc->variant_opaque;
 
 
 static gboolean
 native_choose_node(resource_t *rsc)
 {
 	/*
 	  1. Sort by weight
 	  2. color.chosen_node = the node (of those with the highest wieght)
 				   with the fewest resources
 	  3. remove color.chosen_node from all other colors
 	*/
 	GListPtr nodes = NULL;
 	node_t *chosen = NULL;
 	int multiple = 0;
 
 	crm_debug_3("Choosing node for %s from %d candidates",
 		    rsc->id, g_list_length(rsc->allowed_nodes));
 
 	if(rsc->allowed_nodes) {
 		rsc->allowed_nodes = g_list_sort(
 			rsc->allowed_nodes, sort_node_weight);
 		nodes = rsc->allowed_nodes;
 		chosen = g_list_nth_data(nodes, 0);
 	}
 	
 	if(chosen == NULL) {
 		crm_debug("Could not allocate a node for %s", rsc->id);
 		rsc->next_role = RSC_ROLE_STOPPED;
 		return FALSE;
 
 	} else if(chosen->details->unclean
 		  || chosen->details->standby
 		  || chosen->details->shutdown) {
 		crm_debug("All nodes for color %s are unavailable"
 			  ", unclean or shutting down", rsc->id);
 		rsc->next_role = RSC_ROLE_STOPPED;
 		return FALSE;
 		
 	} else if(chosen->weight < 0) {
 		crm_debug_2("Even highest ranked node for color %s, had weight %d",
 			  rsc->id, chosen->weight);
 		rsc->next_role = RSC_ROLE_STOPPED;
 		return FALSE;
 	}
 
 	if(rsc->next_role == RSC_ROLE_UNKNOWN) {
 		rsc->next_role = RSC_ROLE_STARTED;
 	}
 	
 	slist_iter(candidate, node_t, nodes, lpc, 
 		   crm_debug("Color %s, Node[%d] %s: %d", rsc->id, lpc,
 			       candidate->details->uname, candidate->weight);
 		   if(chosen->weight > 0
 		      && candidate->details->unclean == FALSE
 		      && candidate->weight == chosen->weight) {
 			   multiple++;
 		   } else {
 			   break;
 		   }
 		);
 
 	if(multiple > 1) {
 		int log_level = LOG_INFO;
 		char *score = score2char(chosen->weight);
 		if(chosen->weight >= INFINITY) {
 			log_level = LOG_WARNING;
 		}
 		
 		crm_log_maybe(log_level, "%d nodes with equal score (%s) for"
 			      " running the listed resources (chose %s):",
 			      multiple, score, chosen->details->uname);
 		crm_free(score);
 	}
 	
 	/* todo: update the old node for each resource to reflect its
 	 * new resource count
 	 */
 
 	crm_debug("Assigning %s to %s", chosen->details->uname, rsc->id);
 	rsc->allocated_to = node_copy(chosen);
 	chosen->details->num_resources++;
 	
 	return TRUE;
 }
 
 void native_set_cmds(resource_t *rsc)
 {
 }
 
 int native_num_allowed_nodes(resource_t *rsc)
 {
 	int num_nodes = 0;
 
 	if(rsc->next_role == RSC_ROLE_STOPPED) {
 		return 0;
 	}
 	
 	crm_debug_4("Default case");
 	slist_iter(
 		this_node, node_t, rsc->allowed_nodes, lpc,
 		crm_debug_3("Rsc %s Checking %s: %d",
 			    rsc->id, this_node->details->uname,
 			    this_node->weight);
 		if(this_node->details->shutdown
 		   || this_node->details->online == FALSE) {
 			this_node->weight = -INFINITY;
 		}
 		if(this_node->weight < 0) {				
 			continue;
 /* 			} else if(this_node->details->unclean) { */
 /* 				continue; */
 		}
 		
 		num_nodes++;
 		);
 
 	crm_debug_2("Resource %s can run on %d nodes", rsc->id, num_nodes);
 	return num_nodes;
 }
 
 
 node_t *
 native_color(resource_t *rsc, pe_working_set_t *data_set)
 {
 	print_resource(LOG_DEBUG_2, "Allocating: ", rsc, FALSE);
 	
 	if(rsc->provisional == FALSE) {
 		return rsc->allocated_to;
 	}
 	if(rsc->is_allocating) {
 		crm_err("Dependancy loop detected involving %s", rsc->id);
 		return NULL;
 	}
 	
 	rsc->is_allocating = TRUE;
 	rsc->rsc_cons = g_list_sort(rsc->rsc_cons, sort_cons_strength);
 
 	/*------ Pre-processing ------*/
 	slist_iter(
 		constraint, rsc_colocation_t, rsc->rsc_cons, lpc,
 
 		crm_debug_3("Pre-Processing %s", constraint->id);		
 
-		rsc->cmds->rsc_colocation_lh(
-			rsc, constraint->rsc_rh, constraint);
-
-		if(constraint->strength == pecs_must) {
-			/* or use ordering constraints */
-			constraint->rsc_rh->cmds->color(constraint->rsc_rh, data_set);
-		}
-
+		/* or use ordering constraints? */
+		constraint->rsc_rh->cmds->color(
+			constraint->rsc_rh, data_set);
 		rsc->cmds->rsc_colocation_lh(
 			rsc, constraint->rsc_rh, constraint);
 		
 		);
 
 	if(native_choose_node(rsc) ) {
-		crm_debug_3("Allocated resource %s to %s",
+		crm_debug("Allocated resource %s to %s",
 			    rsc->id, rsc->allocated_to->details->uname);
 	} else {
 		pe_warn("Resource %s cannot run anywhere", rsc->id);
 	}
 	rsc->provisional = FALSE;
 	rsc->is_allocating = FALSE;
 
 	/*------ Post-processing ------*/
 	slist_iter(
 		constraint, rsc_colocation_t, rsc->rsc_cons, lpc,
 		crm_debug_3("Post-Processing %s", constraint->id);
 		rsc->cmds->rsc_colocation_lh(
 			rsc, constraint->rsc_rh, constraint);
 		);
 	print_resource(LOG_DEBUG_3, "Allocated ", rsc, TRUE);
 
 	return rsc->allocated_to;
 }
 
 void
 Recurring(resource_t *rsc, action_t *start, node_t *node,
 			 pe_working_set_t *data_set) 
 {
 	char *key = NULL;
 	const char *name = NULL;
 	const char *value = NULL;
 	const char *interval = NULL;
 	const char *node_uname = NULL;
 
 	int interval_ms = 0;
 	action_t *mon = NULL;
 	gboolean is_optional = TRUE;
 	GListPtr possible_matches = NULL;
 	
 	crm_debug_2("Creating recurring actions for %s", rsc->id);
 	if(node != NULL) {
 		node_uname = node->details->uname;
 	}
 	
 	xml_child_iter_filter(
 		rsc->ops_xml, operation, "op",
 		
 		is_optional = TRUE;
 		name = crm_element_value(operation, "name");
 		interval = crm_element_value(operation, XML_LRM_ATTR_INTERVAL);
 		interval_ms = crm_get_msec(interval);
 
 		if(interval_ms <= 0) {
 			continue;
 		}
 
 		value = crm_element_value(operation, "disabled");
 		if(crm_is_true(value)) {
 			continue;
 		}
 		
 		key = generate_op_key(rsc->id, name, interval_ms);
 		if(start != NULL) {
 			crm_debug_3("Marking %s %s due to %s",
 				    key, start->optional?"optional":"manditory",
 				    start->uuid);
 			is_optional = start->optional;
 		} else {
 			crm_debug_2("Marking %s optional", key);
 			is_optional = TRUE;
 		}
 		
 		/* start a monitor for an already active resource */
 		possible_matches = find_actions_exact(rsc->actions, key, node);
 		if(possible_matches == NULL) {
 			is_optional = FALSE;
 			crm_debug_3("Marking %s manditory: not active", key);
 		}
 
 		value = crm_element_value(operation, "role");
 		if((rsc->next_role == RSC_ROLE_MASTER && value == NULL)
 		   || (value != NULL && text2role(value) != rsc->next_role)) {
 			int log_level = LOG_DEBUG_2;
 			const char *foo = "Ignoring";
 			if(is_optional) {
 				log_level = LOG_INFO;
 				foo = "Cancelling";
 				/* its running : cancel it */
 
 				mon = custom_action(
 					rsc, crm_strdup(key), CRMD_ACTION_CANCEL, node,
 					FALSE, TRUE, data_set);
 
 				mon->task = CRMD_ACTION_CANCEL;
 				add_hash_param(mon->meta, XML_LRM_ATTR_INTERVAL, interval);
 				add_hash_param(mon->meta, XML_LRM_ATTR_TASK, name);
 				
 				custom_action_order(
 					rsc, NULL, mon,
 					rsc, promote_key(rsc), NULL,
 					pe_ordering_optional, data_set);
 
 				mon = NULL;
 			}
 			
 			crm_log_maybe(log_level, "%s action %s (%s vs. %s)",
 				      foo , key, value?value:role2text(RSC_ROLE_SLAVE),
 				      role2text(rsc->next_role));
 			crm_free(key);
 			key = NULL;
 			continue;
 		}		
 		
 		mon = custom_action(rsc, key, name, node,
 				    is_optional, TRUE, data_set);
 
 		if(is_optional) {
 			crm_debug("%s\t   %s (optional)",
 				  crm_str(node_uname), mon->uuid);
 		}
 		
 		if(start == NULL || start->runnable == FALSE) {
 			crm_debug("%s\t   %s (cancelled : start un-runnable)",
 				  crm_str(node_uname), mon->uuid);
 			mon->runnable = FALSE;
 
 		} else if(node == NULL
 			  || node->details->online == FALSE
 			  || node->details->unclean) {
 			crm_debug("%s\t   %s (cancelled : no node available)",
 				  crm_str(node_uname), mon->uuid);
 			mon->runnable = FALSE;
 		
 		} else if(mon->optional == FALSE) {
 			crm_notice("%s\t   %s", crm_str(node_uname),mon->uuid);
 		}
 
 		custom_action_order(rsc, start_key(rsc), NULL,
 				    NULL, crm_strdup(key), mon,
 				    pe_ordering_restart, data_set);
 
 		if(rsc->next_role == RSC_ROLE_MASTER) {
 			char *running_master = crm_itoa(EXECRA_RUNNING_MASTER);
 			add_hash_param(mon->meta, XML_ATTR_TE_TARGET_RC, running_master);
 			custom_action_order(
 				rsc, promote_key(rsc), NULL,
 				rsc, NULL, mon,
 				pe_ordering_optional, data_set);
 			crm_free(running_master);
 		}		
 		);	
 }
 
 void native_create_actions(resource_t *rsc, pe_working_set_t *data_set)
 {
 	action_t *start = NULL;
 	node_t *chosen = NULL;
 	enum rsc_role_e role = RSC_ROLE_UNKNOWN;
 	enum rsc_role_e next_role = RSC_ROLE_UNKNOWN;
 
 	chosen = rsc->allocated_to;
 	if(chosen != NULL) {
 		CRM_CHECK(rsc->next_role != RSC_ROLE_UNKNOWN, rsc->next_role = RSC_ROLE_STARTED);
 	}
 
 	unpack_instance_attributes(
 		rsc->xml, XML_TAG_ATTR_SETS,
 		chosen?chosen->details->attrs:NULL,
 		rsc->parameters, NULL, data_set->now);
 
 	crm_debug_2("%s: %s->%s", rsc->id,
 		    role2text(rsc->role), role2text(rsc->next_role));
 	
 	if(g_list_length(rsc->running_on) > 1) {
  		if(rsc->recovery_type == recovery_stop_start) {
 			pe_proc_err("Attempting recovery of resource %s", rsc->id);
 			StopRsc(rsc, NULL, data_set);
 			rsc->role = RSC_ROLE_STOPPED;
 		}
 		
 	} else if(rsc->running_on != NULL) {
 		node_t *current = rsc->running_on->data;
 		NoRoleChange(rsc, current, chosen, data_set);
 
 	} else if(rsc->role == RSC_ROLE_STOPPED && rsc->next_role == RSC_ROLE_STOPPED) {
 		char *key = start_key(rsc);
 		GListPtr possible_matches = find_actions(rsc->actions, key, NULL);
 		slist_iter(
 			action, action_t, possible_matches, lpc,
 			action->optional = TRUE;
 /*			action->pseudo = TRUE; */
 			);
 		crm_debug_2("Stopping a stopped resource");
 		crm_free(key);
 		return;
 	} 
 
 	role = rsc->role;
 
 	while(role != rsc->next_role) {
 		next_role = rsc_state_matrix[role][rsc->next_role];
 		crm_debug_2("Executing: %s->%s (%s)",
 			  role2text(role), role2text(next_role), rsc->id);
 		if(rsc_action_matrix[role][next_role](
 			   rsc, chosen, data_set) == FALSE) {
 			break;
 		}
 		role = next_role;
 	}
 
 	if(rsc->next_role != RSC_ROLE_STOPPED && rsc->is_managed) {
 		start = start_action(rsc, chosen, TRUE);
 		Recurring(rsc, start, chosen, data_set);
 	}
 }
 
 void native_internal_constraints(resource_t *rsc, pe_working_set_t *data_set)
 {
 	order_restart(rsc);
 	custom_action_order(rsc, demote_key(rsc), NULL,
 			    rsc, stop_key(rsc), NULL,
 			    pe_ordering_manditory, data_set);
 	custom_action_order(rsc, start_key(rsc), NULL,
 			    rsc, promote_key(rsc), NULL,
 			    pe_ordering_optional, data_set);
 
 	custom_action_order(
 		rsc, stop_key(rsc), NULL, rsc, delete_key(rsc), NULL, 
 		pe_ordering_optional, data_set);
 
 	custom_action_order(
 		rsc, delete_key(rsc), NULL, rsc, start_key(rsc), NULL, 
 		pe_ordering_manditory, data_set);	
 }
 
 void native_rsc_colocation_lh(
 	resource_t *rsc_lh, resource_t *rsc_rh, rsc_colocation_t *constraint)
 {
 	if(rsc_lh == NULL) {
 		pe_err("rsc_lh was NULL for %s", constraint->id);
 		return;
 
 	} else if(constraint->rsc_rh == NULL) {
 		pe_err("rsc_rh was NULL for %s", constraint->id);
 		return;
 	}
 	
 	crm_debug_2("Processing colocation constraint between %s and %s",
 		    rsc_lh->id, rsc_rh->id);
 	
 	rsc_rh->cmds->rsc_colocation_rh(rsc_lh, rsc_rh, constraint);		
 }
 
 static gboolean
 filter_colocation_constraint(
 	resource_t *rsc_lh, resource_t *rsc_rh, rsc_colocation_t *constraint)
 {
-	if(constraint->strength == pecs_ignore
-		|| constraint->strength == pecs_startstop){
-		crm_debug_4("Skipping constraint type %d", constraint->strength);
+	if(constraint->score == 0){
 		return FALSE;
 	}
 
 	if(constraint->state_lh != NULL
 	   && text2role(constraint->state_lh) != rsc_lh->next_role) {
 		crm_debug_4("RH: Skipping constraint: \"%s\" state filter",
 			    constraint->state_rh);
 		return FALSE;
 	}
 	
 	if(constraint->state_rh != NULL
 	   && text2role(constraint->state_rh) != rsc_rh->next_role) {
 		crm_debug_4("RH: Skipping constraint: \"%s\" state filter",
 			    constraint->state_rh);
 		return FALSE;
 	}
 	return TRUE;
 }
 
 static void
 native_update_node_weight(
 	resource_t *rsc, const char *id, node_t *node, int score)
 {
 	node_t *node_rh = NULL;
 	CRM_CHECK(node != NULL, return);
 	
 	node_rh = pe_find_node_id(
 		rsc->allowed_nodes, node->details->id);
 
 	if(node_rh == NULL) {
 		pe_err("Node not found - adding %s to %s",
 		       node->details->id, rsc->id);
 		node_rh = node_copy(node);
 		rsc->allowed_nodes = g_list_append(
 			rsc->allowed_nodes, node_rh);
 
 		node_rh = pe_find_node_id(
 			rsc->allowed_nodes, node->details->id);
 
 		CRM_CHECK(node_rh != NULL, return);
 		return;
 	}
 
 	CRM_CHECK(node_rh != NULL, return);
 	
 	if(node_rh == NULL) {
 		pe_err("Node not found - cant update");
 		return;
 	}
 
 	if(node_rh->weight >= INFINITY && score <= -INFINITY) {
 		pe_err("Constraint \"%s\" mixes +/- INFINITY (%s)",
 		       id, rsc->id);
 		
 	} else if(node_rh->details->shutdown == TRUE
 		  || node_rh->details->online == FALSE
 		  || node_rh->details->unclean == TRUE) {
 
 	} else if(node_rh->weight <= -INFINITY && score >= INFINITY) {
 		pe_err("Constraint \"%s\" mixes +/- INFINITY (%s)",
 			 id, rsc->id);
 	}
 
 	if(node_rh->fixed) {
 		/* warning */
 		crm_debug_2("Constraint %s is irrelevant as the"
 			 " weight of node %s is fixed as %d (%s).",
 			 id, node_rh->details->uname,
 			 node_rh->weight, rsc->id);
 		return;
 	}	
 	
 	crm_debug_3("Constraint %s, node %s, rsc %s: %d + %d",
 		   id, node_rh->details->uname, rsc->id,
 		   node_rh->weight, score);
 	node_rh->weight = merge_weights(node_rh->weight, score);
 	if(node_rh->weight <= -INFINITY) {
 		crm_debug_3("Constraint %s (-INFINITY): node %s weight %d (%s).",
 			    id, node_rh->details->uname,
 			    node_rh->weight, rsc->id);
 		
 	} else if(node_rh->weight >= INFINITY) {
 		crm_debug_3("Constraint %s (+INFINITY): node %s weight %d (%s).",
 			    id, node_rh->details->uname,
 			    node_rh->weight, rsc->id);
 
 	} else {
 		crm_debug_3("Constraint %s (%d): node %s weight %d (%s).",
 			    id, score, node_rh->details->uname,
 			    node_rh->weight, rsc->id);
 	}
 
 	if(node_rh->weight < 0) {
 		node_rh->fixed = TRUE;
 	}
 
 	crm_action_debug_3(print_node("Updated", node_rh, FALSE));
 
 	return;
 }
 
 void native_rsc_colocation_rh(
 	resource_t *rsc_lh, resource_t *rsc_rh, rsc_colocation_t *constraint)
 {
-	crm_debug_2("%sColocating %s with %s (%s)",
-		    constraint->strength == pecs_must?"":"Anti-",
-		    rsc_lh->id, rsc_rh->id, constraint->id);
+	crm_debug_2("%sColocating %s with %s (%s, weight=%d)",
+		    constraint->score >= 0?"":"Anti-",
+		    rsc_lh->id, rsc_rh->id, constraint->id, constraint->score);
 	
 	if(filter_colocation_constraint(rsc_lh, rsc_rh, constraint) == FALSE) {
 		return;
 	}
 	
 	if(rsc_lh->provisional && rsc_rh->provisional) {
 #if 0
 		/* should we do this? */
 		crm_debug("combine priorities of %s and %s",
 			  rsc_lh->id, rsc_rh->id);
 		node_list_update(rsc_lh->allowed_nodes, rsc_rh->allowed_nodes);
 #endif
 		return;
 
 	} else if( (!rsc_lh->provisional) && (!rsc_rh->provisional) ) {
 		/* error check */
-		if(rsc_lh->allocated_to == rsc_rh->allocated_to) {
+		if(constraint->score != INFINITY) {
+			return;
+			
+		} else if(rsc_lh->allocated_to == rsc_rh->allocated_to) {
 			return;
 
 		} else if(rsc_lh->allocated_to && rsc_rh->allocated_to
 		   && rsc_lh->allocated_to->details
 			  == rsc_rh->allocated_to->details) {
 			return;
 		}
 		
 		crm_err("%s and %s are both allocated"
 			" but to different nodes: %s vs. %s",
 			rsc_lh->id, rsc_rh->id,
 			rsc_lh->allocated_to?rsc_lh->allocated_to->details->uname:"n/a",
 			rsc_rh->allocated_to?rsc_rh->allocated_to->details->uname:"n/a");
 		return;
 		
-	} else if(rsc_lh->provisional == FALSE) {
-		/* update _them_    : postproc color version */
+	} else if(rsc_lh->provisional == FALSE && rsc_lh->allocated_to) {
+		crm_debug_3("update _them_    : postproc color version");
 		native_update_node_weight(
 			rsc_rh, constraint->id, rsc_lh->allocated_to,
-			constraint->strength==pecs_must?INFINITY:-INFINITY);
+			constraint->score);
 		
-	} else if(rsc_rh->provisional == FALSE) {
-		/* update _us_  : postproc color alt version */
+	} else if(rsc_rh->provisional == FALSE && rsc_rh->allocated_to) {
+		crm_debug_3("update _us_  : postproc color alt version ");
 		native_update_node_weight(
 			rsc_lh, constraint->id, rsc_rh->allocated_to,
-			constraint->strength==pecs_must?INFINITY:-INFINITY);
-
-	} else {
-		pe_warn("Un-expected combination of inputs");
+			constraint->score);
 	}
 }
 
 void
 node_list_update(GListPtr list1, GListPtr list2)
 {
 	node_t *other_node = NULL;
 
 	slist_iter(
 		node, node_t, list1, lpc,
 
 		if(node == NULL) {
 			continue;
 		}
 
 		other_node = (node_t*)pe_find_node_id(
 			list2, node->details->id);
 
 		if(other_node != NULL) {
 			crm_debug_4("%s + %s: %d + %d",
 				    node->details->uname, 
 				    other_node->details->uname, 
 				    node->weight, other_node->weight);
 			node->weight = merge_weights(
 				other_node->weight, node->weight);
 		}
 		);	
 }
 
 void native_rsc_order_lh(resource_t *lh_rsc, order_constraint_t *order)
 {
 	GListPtr lh_actions = NULL;
 	action_t *lh_action = order->lh_action;
 
 	crm_debug_3("Processing LH of ordering constraint %d", order->id);
 
 	if(lh_action != NULL) {
 		lh_actions = g_list_append(NULL, lh_action);
 
 	} else if(lh_action == NULL && lh_rsc != NULL) {
 		lh_actions = find_actions(
 			lh_rsc->actions, order->lh_action_task, NULL);
 
 		if(lh_actions == NULL) {
 			crm_debug_4("No LH-Side (%s/%s) found for constraint",
 				  lh_rsc->id, order->lh_action_task);
 
 			if(lh_rsc->next_role == RSC_ROLE_STOPPED) {
 				resource_t *rh_rsc = order->rh_rsc;
 				if(order->rh_action && order->type == pe_ordering_restart) {
 					crm_debug_3("No LH(%s/%s) found for RH(%s)...",
 						    lh_rsc->id, order->lh_action_task,
 						    order->rh_action->uuid);
 					order->rh_action->runnable = FALSE;
 					return;
 				
 				} else if(rh_rsc != NULL) {
 					crm_debug_3("No LH(%s/%s) found for RH(%s/%s)...",
 						    lh_rsc->id, order->lh_action_task,
 						    rh_rsc->id, order->rh_action_task);
 					rh_rsc->cmds->rsc_order_rh(NULL, rh_rsc, order);
 					return;
 				}
 			}
 			
 			return;
 		}
 
 	} else {
 		pe_warn("No LH-Side (%s) specified for constraint",
 			 order->lh_action_task);
 		if(order->rh_rsc != NULL) {
 			crm_debug_4("RH-Side was: (%s/%s)",
 				  order->rh_rsc->id,
 				  order->rh_action_task);
 				  
 		} else if(order->rh_action != NULL
 			  && order->rh_action->rsc != NULL) {
 			crm_debug_4("RH-Side was: (%s/%s)",
 				  order->rh_action->rsc->id,
 				  order->rh_action_task);
 				  
 		} else if(order->rh_action != NULL) {
 			crm_debug_4("RH-Side was: %s",
 				  order->rh_action_task);
 		} else {
 			crm_debug_4("RH-Side was NULL");
 		}		
 		
 		return;
 	}
 
 	slist_iter(
 		lh_action_iter, action_t, lh_actions, lpc,
 
 		resource_t *rh_rsc = order->rh_rsc;
 		if(rh_rsc == NULL && order->rh_action) {
 			rh_rsc = order->rh_action->rsc;
 		}
 		
 		if(rh_rsc) {
 			rh_rsc->cmds->rsc_order_rh(
 				lh_action_iter, rh_rsc, order);
 
 		} else if(order->rh_action) {
 			order_actions(lh_action_iter, order->rh_action, order->type); 
 
 		}
 		);
 
 	pe_free_shallow_adv(lh_actions, FALSE);
 }
 
 void native_rsc_order_rh(
 	action_t *lh_action, resource_t *rsc, order_constraint_t *order)
 {
 	GListPtr rh_actions = NULL;
 	action_t *rh_action = order->rh_action;
 
 	crm_debug_3("Processing RH of ordering constraint %d", order->id);
 
 	if(rh_action != NULL) {
 		rh_actions = g_list_append(NULL, rh_action);
 
 	} else if(rh_action == NULL && rsc != NULL) {
 		rh_actions = find_actions(
 			rsc->actions, order->rh_action_task, NULL);
 		
 		if(rh_actions == NULL) {
 			crm_debug_4("No RH-Side (%s/%s) found for constraint..."
 				  " ignoring",
 				  rsc->id, order->rh_action_task);
 			crm_debug_4("LH-Side was: (%s/%s)",
 				  order->lh_rsc?order->lh_rsc->id:order->lh_action?order->lh_action->rsc->id:"<NULL>",
 				  order->lh_action_task);
 			return;
 		}
 			
 	}  else if(rh_action == NULL) {
 		crm_debug_4("No RH-Side (%s) specified for constraint..."
 			  " ignoring", order->rh_action_task);
 		crm_debug_4("LH-Side was: (%s/%s)",
 			  order->lh_rsc?order->lh_rsc->id:order->lh_action?order->lh_action->rsc->id:"<NULL>",
 			  order->lh_action_task);
 		return;
 	} 
 
 	slist_iter(
 		rh_action_iter, action_t, rh_actions, lpc,
 
 		if(lh_action) {
 		order_actions(lh_action, rh_action_iter, order->type); 
 
 		} else if(order->type == pe_ordering_restart) {
 			rh_action_iter->runnable = FALSE;
 		}
 		
 		);
 
 	pe_free_shallow_adv(rh_actions, FALSE);
 }
 
 void native_rsc_location(resource_t *rsc, rsc_to_node_t *constraint)
 {
 	GListPtr or_list;
 
 	crm_debug_2("Applying %s (%s) to %s", constraint->id,
 		    role2text(constraint->role_filter), rsc->id);
 
 	/* take "lifetime" into account */
 	if(constraint == NULL) {
 		pe_err("Constraint is NULL");
 		return;
 
 	} else if(rsc == NULL) {
 		pe_err("LHS of rsc_to_node (%s) is NULL", constraint->id);
 		return;
 
 	} else if(constraint->role_filter > 0
 		  && constraint->role_filter != rsc->next_role) {
 		crm_debug("Constraint (%s) is not active (role : %s)",
 			    constraint->id, role2text(constraint->role_filter));
 		return;
 		
 	} else if(is_active(constraint) == FALSE) {
 		crm_debug_2("Constraint (%s) is not active", constraint->id);
 		return;
 	}
     
 	if(constraint->node_list_rh == NULL) {
 		crm_debug_2("RHS of constraint %s is NULL", constraint->id);
 		return;
 	}
 	or_list = node_list_or(
 		rsc->allowed_nodes, constraint->node_list_rh, FALSE);
 		
 	pe_free_shallow(rsc->allowed_nodes);
 	rsc->allowed_nodes = or_list;
 	slist_iter(node, node_t, or_list, lpc,
 		   crm_debug_3("%s + %s : %d", rsc->id, node->details->uname, node->weight);
 		);
 }
 
 void native_expand(resource_t *rsc, pe_working_set_t *data_set)
 {
 	slist_iter(
 		action, action_t, rsc->actions, lpc,
 		crm_debug_4("processing action %d for rsc=%s",
 			  action->id, rsc->id);
 		graph_element_from_action(action, data_set);
 		);
 }
 
 
 
 void
 native_agent_constraints(resource_t *rsc)
 {
 }
 
 
 
 
 
 /*
  * Remove any nodes with a -ve weight
  */
 void
 filter_nodes(resource_t *rsc)
 {
 	print_resource(LOG_DEBUG_3, "Filtering nodes for: ", rsc, FALSE);
 	slist_iter(
 		node, node_t, rsc->allowed_nodes, lpc,
 		if(node == NULL) {
 			pe_err("Invalid NULL node");
 			
 		} else if(node->weight < 0.0
 			  || node->details->shutdown
 			  || node->details->online == FALSE
 			  || node->details->type == node_ping) {
 			crm_action_debug_3(print_node("Removing", node, FALSE));
 			rsc->allowed_nodes =
 				g_list_remove(rsc->allowed_nodes, node);
 			crm_free(node);
 			lpc = -1; /* restart the loop */
 		}
 		);
 }
 
 void
 create_notifications(resource_t *rsc, pe_working_set_t *data_set)
 {
 	if(rsc->notify == FALSE) {
 		return;
 	}
 	
 /* 	slist_iter( */
 /* 		action, action_t, rsc->actions, lpc, */
 		
 /* 		); */
 
 }
 
 static void
 register_activity(resource_t *rsc, enum action_tasks task, node_t *node, notify_data_t *n_data)
 {
 	notify_entry_t *entry = NULL;
 	crm_malloc0(entry, sizeof(notify_entry_t));
 	entry->rsc = rsc;
 	entry->node = node;
 	switch(task) {
 		case start_rsc:
 			n_data->start = g_list_append(n_data->start, entry);
 			break;
 		case stop_rsc:
 			n_data->stop = g_list_append(n_data->stop, entry);
 			break;
 		case action_promote:
 			n_data->promote = g_list_append(n_data->promote, entry);
 			break;
 		case action_demote:
 			n_data->demote = g_list_append(n_data->demote, entry);
 			break;
 		default:
 			crm_err("Unsupported notify action: %s", task2text(task));
 			break;
 	}
 	
 }
 
 
 static void
 register_state(resource_t *rsc, node_t *on_node, notify_data_t *n_data)
 {
 	notify_entry_t *entry = NULL;
 	crm_malloc0(entry, sizeof(notify_entry_t));
 	entry->rsc = rsc;
 	entry->node = on_node;
 
 	crm_debug_2("%s state: %s", rsc->id, role2text(rsc->next_role));
 
 	switch(rsc->next_role) {
 		case RSC_ROLE_STOPPED:
 /* 			n_data->inactive = g_list_append(n_data->inactive, entry); */
 			crm_free(entry);
 			break;
 		case RSC_ROLE_STARTED:
 			n_data->active = g_list_append(n_data->active, entry);
 			break;
 		case RSC_ROLE_SLAVE:
  			n_data->slave = g_list_append(n_data->slave, entry); 
 			break;
 		case RSC_ROLE_MASTER:
 			n_data->master = g_list_append(n_data->master, entry);
 			break;
 		default:
 			crm_err("Unsupported notify role");
 			break;
 	}
 }
 
 void
 native_create_notify_element(resource_t *rsc, action_t *op,
 			     notify_data_t *n_data, pe_working_set_t *data_set)
 {
 	node_t *next_node = NULL;
 	gboolean registered = FALSE;
 	char *op_key = NULL;
 	GListPtr possible_matches = NULL;
 	enum action_tasks task = text2task(op->task);
 	
 	if(op->pre_notify == NULL || op->post_notify == NULL) {
 		/* no notifications required */
 		crm_debug_4("No notificaitons required for %s", op->task);
 		return;
 	}
 	next_node = rsc->allocated_to;
 	op_key = generate_op_key(rsc->id, op->task, 0);
 	possible_matches = find_actions(rsc->actions, op_key, NULL);
 	
 	crm_debug_2("Creating notificaitons for: %s (%s->%s)",
 		    op->uuid, role2text(rsc->role), role2text(rsc->next_role));
 
 	if(rsc->role == rsc->next_role) {
 		register_state(rsc, next_node, n_data);
 	}
 	
 	slist_iter(
 		local_op, action_t, possible_matches, lpc,
 
 		local_op->notify_keys = n_data->keys;
 		if(local_op->optional == FALSE) {
 			registered = TRUE;
 			register_activity(rsc, task, local_op->node, n_data);
 		}		
 		);
 
 	/* stop / demote */
 	if(rsc->role != RSC_ROLE_STOPPED) {
 		if(task == stop_rsc || task == action_demote) {
 			slist_iter(
 				current_node, node_t, rsc->running_on, lpc,
 				pe_pre_notify(rsc, current_node, op, n_data, data_set);
 				if(task == action_demote || registered == FALSE) {
 					pe_post_notify(rsc, current_node, op, n_data, data_set);
 				}
 				);
 		}
 	}
 	
 	/* start / promote */
 	if(rsc->next_role != RSC_ROLE_STOPPED) {	
 		CRM_CHECK(next_node != NULL,;);
 
 		if(next_node == NULL) {
 			pe_proc_err("next role: %s", role2text(rsc->next_role));
 			
 		} else if(task == start_rsc || task == action_promote) {
 			if(task != start_rsc || registered == FALSE) {
 				pe_pre_notify(rsc, next_node, op, n_data, data_set);
 			}
 			pe_post_notify(rsc, next_node, op, n_data, data_set);
 		}
 	}
 	
 	crm_free(op_key);
 	pe_free_shallow_adv(possible_matches, FALSE);
 }
 
 
 static void dup_attr(gpointer key, gpointer value, gpointer user_data)
 {
 	char *meta_key = crm_concat(CRM_META, key, '_');
 	g_hash_table_replace(user_data, meta_key, crm_strdup(value));
 }
 
 static action_t *
 pe_notify(resource_t *rsc, node_t *node, action_t *op, action_t *confirm,
 	  notify_data_t *n_data, pe_working_set_t *data_set)
 {
 	char *key = NULL;
 	action_t *trigger = NULL;
 	const char *value = NULL;
 	const char *task = NULL;
 	
 	if(op == NULL || confirm == NULL) {
 		crm_debug_2("Op=%p confirm=%p", op, confirm);
 		return NULL;
 	}
 
 	CRM_CHECK(node != NULL, return NULL);
 
 	if(node->details->online == FALSE) {
 		crm_info("Skipping notification for %s", rsc->id);
 		return NULL;
 	}
 	
 	value = g_hash_table_lookup(op->meta, "notify_type");
 	task = g_hash_table_lookup(op->meta, "notify_operation");
 
 	crm_debug_2("Creating actions for %s: %s (%s-%s)",
 		    op->uuid, rsc->id, value, task);
 	
 	key = generate_notify_key(rsc->id, value, task);
 	trigger = custom_action(rsc, key, op->task, node,
 				op->optional, TRUE, data_set);
 	g_hash_table_foreach(op->meta, dup_attr, trigger->extra);
 	trigger->notify_keys = n_data->keys;
 
 	/* pseudo_notify before notify */
 	crm_debug_3("Ordering %s before %s (%d->%d)",
 		op->uuid, trigger->uuid, trigger->id, op->id);
 
 	order_actions(op, trigger, pe_ordering_manditory);
 	
 	value = g_hash_table_lookup(op->meta, "notify_confirm");
 	if(crm_is_true(value)) {
 		/* notify before pseudo_notified */
 		crm_debug_3("Ordering %s before %s (%d->%d)",
 			    trigger->uuid, confirm->uuid,
 			    confirm->id, trigger->id);
 
 		order_actions(trigger, confirm, pe_ordering_manditory);
 	}	
 	return trigger;
 }
 
 void
 pe_pre_notify(resource_t *rsc, node_t *node, action_t *op,
 	      notify_data_t *n_data, pe_working_set_t *data_set)
 {
 	crm_debug_2("%s: %s", rsc->id, op->uuid);
 	pe_notify(rsc, node, op->pre_notify, op->pre_notified,
 		  n_data, data_set);
 }
 
 void
 pe_post_notify(resource_t *rsc, node_t *node, action_t *op, 
 	       notify_data_t *n_data, pe_working_set_t *data_set)
 {
 	action_t *notify = NULL;
 
 	CRM_CHECK(op != NULL, return);
 	CRM_CHECK(rsc != NULL, return);
 	
 	crm_debug_2("%s: %s", rsc->id, op->uuid);
 	notify = pe_notify(rsc, node, op->post_notify, op->post_notified,
 			   n_data, data_set);
 
 	if(notify != NULL) {
 		notify->priority = INFINITY;
 	}
 	
 	notify = op->post_notified;
 	if(notify != NULL) {
 		notify->priority = INFINITY;
 		slist_iter(
 			mon, action_t, rsc->actions, lpc,
 
 			const char *interval = g_hash_table_lookup(mon->meta, "interval");
 			if(interval == NULL || safe_str_eq(interval, "0")) {
 				crm_debug_3("Skipping %s: interval", mon->uuid); 
 				continue;
 			} else if(safe_str_eq(mon->task, "cancel")) {
 				crm_debug_3("Skipping %s: cancel", mon->uuid); 
 				continue;
 			}
 
 			order_actions(notify, mon, pe_ordering_optional);
 			);
 	}
 }
 
 
 void
 NoRoleChange(resource_t *rsc, node_t *current, node_t *next,
 	     pe_working_set_t *data_set)
 {
 	action_t *start = NULL;
 	action_t *stop = NULL;
 	GListPtr possible_matches = NULL;
 
 	crm_debug("Executing: %s (role=%s)",rsc->id, role2text(rsc->next_role));
 
 	if(current == NULL || next == NULL) {
 		return;
 	}
 
 	/* use StartRsc/StopRsc */
 	
 	if(safe_str_neq(current->details->id, next->details->id)) {
 		crm_notice("Move  resource %s\t(%s -> %s)", rsc->id,
 			   current->details->uname, next->details->uname);
 
 		stop = stop_action(rsc, current, FALSE);
 		start = start_action(rsc, next, FALSE);
 
 		possible_matches = find_recurring_actions(rsc->actions, next);
 		slist_iter(match, action_t, possible_matches, lpc,
 			   if(match->optional == FALSE) {
 				   crm_err("Found bad recurring action: %s",
 					   match->uuid);
 				   match->optional = TRUE;
 			   }
 			);
 			
 		if(data_set->remove_after_stop) {
 			DeleteRsc(rsc, current, data_set);
 		}
 		
 	} else {
 		if(rsc->failed) {
 			crm_notice("Recover resource %s\t(%s)",
 				   rsc->id, next->details->uname);
 			stop = stop_action(rsc, current, FALSE);
 			start = start_action(rsc, next, FALSE);
 /* 			/\* make the restart required *\/ */
 /* 			order_stop_start(rsc, rsc, pe_ordering_manditory); */
 			
 		} else if(rsc->start_pending) {
 			start = start_action(rsc, next, TRUE);
 			if(start->runnable) {
 				/* wait for StartRsc() to be called */
 				rsc->role = RSC_ROLE_STOPPED;
 			} else {
 				/* wait for StopRsc() to be called */
 				rsc->next_role = RSC_ROLE_STOPPED;
 			}
 			
 		} else {
 			stop = stop_action(rsc, current, TRUE);
 			start = start_action(rsc, next, TRUE);
 			stop->optional = start->optional;
 			
 			if(start->runnable == FALSE) {
 				rsc->next_role = RSC_ROLE_STOPPED;
 
 			} else if(start->optional) {
 				crm_notice("Leave resource %s\t(%s)",
 					   rsc->id, next->details->uname);
 
 			} else {
 				crm_notice("Restart resource %s\t(%s)",
 					   rsc->id, next->details->uname);
 			}
 		}
 	}
 }
 
 
 gboolean
 StopRsc(resource_t *rsc, node_t *next, pe_working_set_t *data_set)
 {
 	action_t *stop = NULL;
 	
 	crm_debug_2("Executing: %s", rsc->id);
 	
 	slist_iter(
 		current, node_t, rsc->running_on, lpc,
 		crm_notice("  %s\tStop %s", current->details->uname, rsc->id);
 		stop = stop_action(rsc, current, FALSE);
 
 		if(data_set->remove_after_stop) {
 			DeleteRsc(rsc, current, data_set);
 		}
 		);
 	
 	return TRUE;
 }
 
 
 gboolean
 StartRsc(resource_t *rsc, node_t *next, pe_working_set_t *data_set)
 {
 	action_t *start = NULL;
 	
 	crm_debug_2("Executing: %s", rsc->id);
 	start = start_action(rsc, next, TRUE);
 	if(start->runnable) {
 		crm_notice(" %s\tStart %s", next->details->uname, rsc->id);
 		start->optional = FALSE;
 	}		
 	return TRUE;
 }
 
 gboolean
 PromoteRsc(resource_t *rsc, node_t *next, pe_working_set_t *data_set)
 {
 	char *key = NULL;
 	gboolean runnable = TRUE;
 	GListPtr action_list = NULL;
 	crm_debug_2("Executing: %s", rsc->id);
 
 	CRM_CHECK(rsc->next_role == RSC_ROLE_MASTER, return FALSE);
 
 	key = start_key(rsc);
 	action_list = find_actions_exact(rsc->actions, key, next);
 	crm_free(key);
 
 	slist_iter(start, action_t, action_list, lpc,
 		   if(start->runnable == FALSE) {
 			   runnable = FALSE;
 		   }
 		);
 
 	if(runnable) {
 		promote_action(rsc, next, FALSE);
 		crm_notice("%s\tPromote %s", next->details->uname, rsc->id);
 		return TRUE;
 	} 
 
 	crm_debug("%s\tPromote %s (canceled)", next->details->uname, rsc->id);
 
 	key = promote_key(rsc);
 	action_list = find_actions_exact(rsc->actions, key, next);
 	crm_free(key);
 
 	slist_iter(promote, action_t, action_list, lpc,
 		   promote->runnable = FALSE;
 		);
 	
 	return TRUE;
 }
 
 gboolean
 DemoteRsc(resource_t *rsc, node_t *next, pe_working_set_t *data_set)
 {
 	crm_debug_2("Executing: %s", rsc->id);
 
 /* 	CRM_CHECK(rsc->next_role == RSC_ROLE_SLAVE, return FALSE); */
 	slist_iter(
 		current, node_t, rsc->running_on, lpc,
 		crm_notice("%s\tDeomote %s", current->details->uname, rsc->id);
 		demote_action(rsc, current, FALSE);
 		);
 	return TRUE;
 }
 
 gboolean
 RoleError(resource_t *rsc, node_t *next, pe_working_set_t *data_set)
 {
 	crm_debug("Executing: %s", rsc->id);
 	CRM_CHECK(FALSE, return FALSE);
 	return FALSE;
 }
 
 gboolean
 NullOp(resource_t *rsc, node_t *next, pe_working_set_t *data_set)
 {
 	crm_debug("Executing: %s", rsc->id);
 	return FALSE;
 }
 
 
 gboolean
 native_create_probe(resource_t *rsc, node_t *node, action_t *complete,
 		    gboolean force, pe_working_set_t *data_set) 
 {
 	char *key = NULL;
 	char *target_rc = NULL;
 	action_t *probe = NULL;
 	node_t *running = NULL;
 
 	CRM_CHECK(node != NULL, return FALSE);
 
 	if(rsc->orphan) {
 		crm_debug_2("Skipping orphan: %s", rsc->id);
 		return FALSE;
 	}
 	
 	running = pe_find_node_id(rsc->known_on, node->details->id);
 	if(force == FALSE && running != NULL) {
 		/* we already know the status of the resource on this node */
 		crm_debug_3("Skipping active: %s", rsc->id);
 		return FALSE;
 	}
 
 	key = generate_op_key(rsc->id, CRMD_ACTION_STATUS, 0);
 	probe = custom_action(rsc, key, CRMD_ACTION_STATUS, node,
 			      FALSE, TRUE, data_set);
 	probe->priority = INFINITY;
 
 	running = pe_find_node_id(rsc->running_on, node->details->id);
 	if(running == NULL) {
 		target_rc = crm_itoa(EXECRA_NOT_RUNNING);
 		add_hash_param(probe->meta, XML_ATTR_TE_TARGET_RC, target_rc);
 		crm_free(target_rc);
 	}
 	
 	crm_notice("%s: Created probe for %s", node->details->uname, rsc->id);
 	
 	custom_action_order(rsc, NULL, probe, rsc, NULL, complete,
 			    pe_ordering_manditory, data_set);
 
 	return TRUE;
 }
 
 static void
 native_start_constraints(
 	resource_t *rsc,  action_t *stonith_op, gboolean is_stonith,
 	pe_working_set_t *data_set)
 {
 	gboolean is_unprotected = FALSE;
 	gboolean run_unprotected = TRUE;
 
 	if(is_stonith) {
 		char *key = start_key(rsc);
 		crm_debug_2("Ordering %s action before stonith events", key);
 		custom_action_order(
 			rsc, key, NULL,
 			NULL, crm_strdup(CRM_OP_FENCE), stonith_op,
 			pe_ordering_optional, data_set);
 
 	} else {
 		slist_iter(action, action_t, rsc->actions, lpc2,
 			   if(action->needs != rsc_req_stonith) {
 				   crm_debug_3("%s doesnt need to wait for stonith events", action->uuid);
 				   continue;
 			   }
 			   crm_debug_2("Ordering %s after stonith events", action->uuid);
 			   if(stonith_op != NULL) {
 				   custom_action_order(
 					   NULL, crm_strdup(CRM_OP_FENCE), stonith_op,
 					   rsc, NULL, action,
 					   pe_ordering_manditory, data_set);
 				   
 			   } else if(run_unprotected == FALSE) {
 				   /* mark the start unrunnable */
 				   action->runnable = FALSE;
 				   
 			   } else {
 				   is_unprotected = TRUE;
 			   }   
 			);
 	}
 	
 	if(is_unprotected) {
 		pe_err("SHARED RESOURCE %s IS NOT PROTECTED:"
 		       " Stonith disabled", rsc->id);
 	}
 
 }
 
 static void
 native_stop_constraints(
 	resource_t *rsc,  action_t *stonith_op, gboolean is_stonith,
 	pe_working_set_t *data_set)
 {
 	char *key = NULL;
 	GListPtr action_list = NULL;
 	node_t *node = stonith_op->node;
 
 	key = stop_key(rsc);
 	action_list = find_actions(rsc->actions, key, node);
 	crm_free(key);
 
 	/* add the stonith OP as a stop pre-req and the mark the stop
 	 * as a pseudo op - since its now redundant
 	 */
 	
 	slist_iter(
 		action, action_t, action_list, lpc2,
 		if(node->details->online == FALSE || rsc->failed) {
 			resource_t *parent = NULL;
 			crm_warn("Stop of failed resource %s is"
 				 " implict after %s is fenced",
 				 rsc->id, node->details->uname);
 			/* the stop would never complete and is
 			 * now implied by the stonith operation
 			 */
 			action->pseudo = TRUE;
 			action->runnable = TRUE;
 			if(is_stonith) {
 				/* do nothing */
 				
 			} else {
 				custom_action_order(
 					NULL, crm_strdup(CRM_OP_FENCE),stonith_op,
 					rsc, start_key(rsc), NULL,
 					pe_ordering_manditory, data_set);
 			}
 			
 			/* find the top-most resource */
 			parent = rsc->parent;
 			while(parent != NULL && parent->parent != NULL) {
 				parent = parent->parent;
 			}
 			
 			if(parent) {
 				crm_info("Re-creating actions for %s",
 					 parent->id);
 				parent->cmds->create_actions(parent, data_set);
 			}
 			
 		} else if(is_stonith == FALSE) {
 			crm_info("Moving healthy resource %s"
 				 " off %s before fencing",
 				 rsc->id, node->details->uname);
 			
 			/* stop healthy resources before the
 			 * stonith op
 			 */
 			custom_action_order(
 				rsc, stop_key(rsc), NULL,
 				NULL,crm_strdup(CRM_OP_FENCE),stonith_op,
 				pe_ordering_manditory, data_set);
 		}
 		);
 	
 	key = demote_key(rsc);
 	action_list = find_actions(rsc->actions, key, node);
 	crm_free(key);
 	
 	slist_iter(
 		action, action_t, action_list, lpc2,
 		if(node->details->online == FALSE || rsc->failed) {
 			crm_info("Demote of failed resource %s is"
 				 " implict after %s is fenced",
 				 rsc->id, node->details->uname);
 			/* the stop would never complete and is
 			 * now implied by the stonith operation
 			 */
 			action->pseudo = TRUE;
 			action->runnable = TRUE;
 			if(is_stonith == FALSE) {
 				custom_action_order(
 					NULL, crm_strdup(CRM_OP_FENCE), stonith_op,
 					rsc, demote_key(rsc), NULL,
 					pe_ordering_manditory, data_set);
 			}
 		}
 		);	
 }
 
 void
 native_stonith_ordering(
 	resource_t *rsc,  action_t *stonith_op, pe_working_set_t *data_set)
 {
 	gboolean is_stonith = FALSE;
 	const char *class = crm_element_value(rsc->xml, XML_AGENT_ATTR_CLASS);
 
 	if(rsc->is_managed == FALSE) {
 		crm_debug_3("Skipping fencing constraints for unmanaged resource: %s", rsc->id);
 		return;
 	} 
 
 	if(stonith_op != NULL && safe_str_eq(class, "stonith")) {
 		is_stonith = TRUE;
 	}
 	
 	/* Start constraints */
 	native_start_constraints(rsc,  stonith_op, is_stonith, data_set);
  
 	/* Stop constraints */
 	native_stop_constraints(rsc,  stonith_op, is_stonith, data_set);
 }
 
diff --git a/crm/pengine/pengine.h b/crm/pengine/pengine.h
index 5c1900b8ed..59821d6dc8 100644
--- a/crm/pengine/pengine.h
+++ b/crm/pengine/pengine.h
@@ -1,159 +1,151 @@
 /* $Id: pengine.h,v 1.115 2006/06/09 06:42:16 andrew Exp $ */
 /* 
  * Copyright (C) 2004 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.1 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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  */
 #ifndef PENGINE__H
 #define PENGINE__H
 
 #include <clplumbing/ipc.h>
 
 typedef struct rsc_to_node_s rsc_to_node_t;
 typedef struct rsc_colocation_s rsc_colocation_t;
 typedef struct lrm_agent_s lrm_agent_t;
 typedef struct order_constraint_s order_constraint_t;
 
 #include <glib.h>
 #include <crm/crm.h>
 #include <crm/common/msg.h>
 #include <crm/common/iso8601.h>
 #include <crm/pengine/rules.h>
 #include <crm/pengine/common.h>
 #include <crm/pengine/status.h>
 
 #include <linux-ha/config.h>
 
 #include <crm/pengine/complex.h>
 
-enum con_strength {
-	pecs_ignore,
-	pecs_must,
-	pecs_must_not,
-	pecs_startstop
-};
-
-
 enum pe_stop_fail {
 	pesf_block,
 	pesf_stonith,
 	pesf_ignore
 };
 
 
 struct rsc_colocation_s { 
 		const char	*id;
 		resource_t	*rsc_lh;
 		resource_t	*rsc_rh;
 
 		const char *state_lh;
 		const char *state_rh;
 		
-		enum con_strength strength;
+		int score;
 };
 
 struct rsc_to_node_s { 
 		const char *id;
 		resource_t *rsc_lh; 
 
 		enum rsc_role_e role_filter;
 		GListPtr    node_list_rh; /* node_t* */
 };
 
 
 struct order_constraint_s 
 {
 		int id;
 		enum pe_ordering type;
 
 		void *lh_opaque;
 		resource_t *lh_rsc;
 		action_t   *lh_action;
 		char *lh_action_task;
 		
 		void *rh_opaque;
 		resource_t *rh_rsc;
 		action_t   *rh_action;
 		char *rh_action_task;
 
 		/* (soon to be) variant specific */
 /* 		int   lh_rsc_incarnation; */
 /* 		int   rh_rsc_incarnation; */
 };
 
 extern gboolean stage0(pe_working_set_t *data_set);
 extern gboolean stage1(pe_working_set_t *data_set);
 extern gboolean stage2(pe_working_set_t *data_set);
 extern gboolean stage3(pe_working_set_t *data_set);
 extern gboolean stage4(pe_working_set_t *data_set);
 extern gboolean stage5(pe_working_set_t *data_set);
 extern gboolean stage6(pe_working_set_t *data_set);
 extern gboolean stage7(pe_working_set_t *data_set);
 extern gboolean stage8(pe_working_set_t *data_set);
 
 extern gboolean summary(GListPtr resources);
 
 extern gboolean pe_msg_dispatch(IPC_Channel *sender, void *user_data);
 
 extern gboolean process_pe_message(
 	HA_Message *msg, crm_data_t *xml_data, IPC_Channel *sender);
 
 extern gboolean unpack_constraints(
 	crm_data_t *xml_constraints, pe_working_set_t *data_set);
 
 extern gboolean update_action_states(GListPtr actions);
 
 extern gboolean shutdown_constraints(
 	node_t *node, action_t *shutdown_op, pe_working_set_t *data_set);
 
 extern gboolean stonith_constraints(
 	node_t *node, action_t *stonith_op, pe_working_set_t *data_set);
 
 extern gboolean custom_action_order(
 	resource_t *lh_rsc, char *lh_task, action_t *lh_action,
 	resource_t *rh_rsc, char *rh_task, action_t *rh_action,
 	enum pe_ordering type, pe_working_set_t *data_set);
 
 #define order_start_start(rsc1,rsc2, type)				\
 	custom_action_order(rsc1, start_key(rsc1), NULL,		\
 			    rsc2, start_key(rsc2) ,NULL,		\
 			    type, data_set)
 #define order_stop_stop(rsc1, rsc2, type)				\
 	custom_action_order(rsc1, stop_key(rsc1), NULL,		\
 			    rsc2, stop_key(rsc2) ,NULL,		\
 			    type, data_set)
 
 #define order_restart(rsc1)						\
 	custom_action_order(rsc1, stop_key(rsc1), NULL,		\
 			    rsc1, start_key(rsc1), NULL,	\
 			    pe_ordering_restart, data_set)
 
 #define order_stop_start(rsc1, rsc2, type)				\
 	custom_action_order(rsc1, stop_key(rsc1), NULL,		\
 			    rsc2, start_key(rsc2) ,NULL,		\
 			    type, data_set)
 
 #define order_start_stop(rsc1, rsc2, type)				\
 	custom_action_order(rsc1, start_key(rsc1), NULL,		\
 			    rsc2, stop_key(rsc2) ,NULL,		\
 			    type, data_set)
 
 extern void graph_element_from_action(
 	action_t *action, pe_working_set_t *data_set);
 
 extern const char* transition_idle_timeout;
 
 #endif
 
diff --git a/crm/pengine/utils.c b/crm/pengine/utils.c
index c48a4540d4..424bb03e5e 100644
--- a/crm/pengine/utils.c
+++ b/crm/pengine/utils.c
@@ -1,323 +1,300 @@
 /* $Id: utils.c,v 1.147 2006/07/05 14:20:02 andrew Exp $ */
 /* 
  * Copyright (C) 2004 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.1 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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  */
 
 #include <crm/msg_xml.h>
 #include <allocate.h>
 #include <utils.h>
 #include <lib/crm/pengine/utils.h>
 
 /* only for rsc_colocation constraints */
 rsc_colocation_t *
 invert_constraint(rsc_colocation_t *constraint) 
 {
 	rsc_colocation_t *inverted_con = NULL;
 
 	crm_debug_3("Inverting constraint");
 	if(constraint == NULL) {
 		pe_err("Cannot invert NULL constraint");
 		return NULL;
 	}
 
 	crm_malloc0(inverted_con, sizeof(rsc_colocation_t));
 
 	if(inverted_con == NULL) {
 		return NULL;
 	}
 	
 	inverted_con->id = constraint->id;
-	inverted_con->strength = constraint->strength;
+	inverted_con->score = constraint->score;
 
 	/* swap the direction */
 	inverted_con->rsc_lh = constraint->rsc_rh;
 	inverted_con->rsc_rh = constraint->rsc_lh;
 	inverted_con->state_lh = constraint->state_rh;
 	inverted_con->state_rh = constraint->state_lh;
 
 	crm_action_debug_3(
 		print_rsc_colocation("Inverted constraint", inverted_con, FALSE));
 	
 	return inverted_con;
 }
 
 
 gint sort_cons_strength(gconstpointer a, gconstpointer b)
 {
 	const rsc_colocation_t *rsc_constraint1 = (const rsc_colocation_t*)a;
 	const rsc_colocation_t *rsc_constraint2 = (const rsc_colocation_t*)b;
 
 	if(a == NULL) { return 1; }
 	if(b == NULL) { return -1; }
   
-	if(rsc_constraint1->strength > rsc_constraint2->strength) {
+	if(rsc_constraint1->score > rsc_constraint2->score) {
 		return 1;
 	}
 	
-	if(rsc_constraint1->strength < rsc_constraint2->strength) {
+	if(rsc_constraint1->score < rsc_constraint2->score) {
 		return -1;
 	}
 	return 0;
 }
 
 void
 print_rsc_to_node(const char *pre_text, rsc_to_node_t *cons, gboolean details)
 { 
 	if(cons == NULL) {
 		crm_debug_4("%s%s: <NULL>",
 		       pre_text==NULL?"":pre_text,
 		       pre_text==NULL?"":": ");
 		return;
 	}
 	crm_debug_4("%s%s%s Constraint %s (%p) - %d nodes:",
 		    pre_text==NULL?"":pre_text,
 		    pre_text==NULL?"":": ",
 		    "rsc_to_node",
 		    cons->id, cons,
 		    g_list_length(cons->node_list_rh));
 
 	if(details == FALSE) {
 		crm_debug_4("\t%s (node placement rule)",
 			  safe_val3(NULL, cons, rsc_lh, id));
 
 		slist_iter(
 			node, node_t, cons->node_list_rh, lpc,
 			print_node("\t\t-->", node, FALSE)
 			);
 	}
 }
 
 void
 print_rsc_colocation(const char *pre_text, rsc_colocation_t *cons, gboolean details)
 { 
 	if(cons == NULL) {
 		crm_debug_4("%s%s: <NULL>",
 		       pre_text==NULL?"":pre_text,
 		       pre_text==NULL?"":": ");
 		return;
 	}
 	crm_debug_4("%s%s%s Constraint %s (%p):",
 	       pre_text==NULL?"":pre_text,
 	       pre_text==NULL?"":": ",
 	       XML_CONS_TAG_RSC_DEPEND, cons->id, cons);
 
 	if(details == FALSE) {
 
-		crm_debug_4("\t%s --> %s, %s",
+		crm_debug_4("\t%s --> %s, %d",
 			  safe_val3(NULL, cons, rsc_lh, id), 
 			  safe_val3(NULL, cons, rsc_rh, id), 
-			  strength2text(cons->strength));
+			  cons->score);
 	}
 } 
 
 void
 pe_free_ordering(GListPtr constraints) 
 {
 	GListPtr iterator = constraints;
 	while(iterator != NULL) {
 		order_constraint_t *order = iterator->data;
 		iterator = iterator->next;
 
 		crm_free(order->lh_action_task);
 		crm_free(order->rh_action_task);
 		crm_free(order);
 	}
 	if(constraints != NULL) {
 		g_list_free(constraints);
 	}
 }
 
 
 void
 pe_free_rsc_to_node(GListPtr constraints)
 {
 	GListPtr iterator = constraints;
 	while(iterator != NULL) {
 		rsc_to_node_t *cons = iterator->data;
 		iterator = iterator->next;
 
 		pe_free_shallow(cons->node_list_rh);
 		crm_free(cons);
 	}
 	if(constraints != NULL) {
 		g_list_free(constraints);
 	}
 }
 
 
 rsc_to_node_t *
 rsc2node_new(const char *id, resource_t *rsc,
 	     int node_weight, node_t *foo_node, pe_working_set_t *data_set)
 {
 	rsc_to_node_t *new_con = NULL;
 
 	if(rsc == NULL || id == NULL) {
 		pe_err("Invalid constraint %s for rsc=%p", crm_str(id), rsc);
 		return NULL;
 	}
 
 	crm_malloc0(new_con, sizeof(rsc_to_node_t));
 	if(new_con != NULL) {
 		new_con->id           = id;
 		new_con->rsc_lh       = rsc;
 		new_con->node_list_rh = NULL;
 		new_con->role_filter = RSC_ROLE_UNKNOWN;
 		
 		if(foo_node != NULL) {
 			node_t *copy = node_copy(foo_node);
 			copy->weight = node_weight;
 			new_con->node_list_rh = g_list_append(NULL, copy);
 		} else {
 			CRM_CHECK(node_weight == 0, return NULL);
 		}
 		
 		data_set->placement_constraints = g_list_append(
 			data_set->placement_constraints, new_con);
 		rsc->rsc_location = g_list_append(
 			rsc->rsc_location, new_con);
 	}
 	
 	return new_con;
 }
 
 
-
-const char *
-strength2text(enum con_strength strength)
-{
-	const char *result = "<unknown>";
-	switch(strength)
-	{
-		case pecs_ignore:
-			result = "ignore";
-			break;
-		case pecs_must:
-			result = XML_STRENGTH_VAL_MUST;
-			break;
-		case pecs_must_not:
-			result = XML_STRENGTH_VAL_MUSTNOT;
-			break;
-		case pecs_startstop:
-			result = "start/stop";
-			break;
-	}
-	return result;
-}
-
 const char *
 ordering_type2text(enum pe_ordering type)
 {
 	const char *result = "<unknown>";
 	switch(type)
 	{
 		case pe_ordering_manditory:
 			result = "manditory";
 			break;
 		case pe_ordering_restart:
 			result = "restart";
 			break;
 		case pe_ordering_recover:
 			result = "recover";
 			break;
 		case pe_ordering_optional:
 			result = "optional";
 			break;
 		case pe_ordering_postnotify:
 			result = "post_notify";
 			break;
 	}
 	return result;
 }
 
 
 gboolean
 can_run_resources(const node_t *node)
 {
 	if(node->details->online == FALSE
 	   || node->details->shutdown
 	   || node->details->unclean
 	   || node->details->standby) {
 		crm_debug_2("%s: online=%d, unclean=%d, standby=%d",
 			    node->details->uname, node->details->online,
 			    node->details->unclean, node->details->standby);
 		return FALSE;
 	}
 	return TRUE;
 }
 
 /* return -1 if 'a' is more preferred
  * return  1 if 'b' is more preferred
  */
 gint sort_node_weight(gconstpointer a, gconstpointer b)
 {
 	const node_t *node1 = (const node_t*)a;
 	const node_t *node2 = (const node_t*)b;
 
 	int node1_weight = 0;
 	int node2_weight = 0;
 	
 	if(a == NULL) { return 1; }
 	if(b == NULL) { return -1; }
 
 	node1_weight = node1->weight;
 	node2_weight = node2->weight;
 	
 	if(can_run_resources(node1) == FALSE) {
 		node1_weight  = -INFINITY; 
 	}
 	if(can_run_resources(node2) == FALSE) {
 		node2_weight  = -INFINITY; 
 	}
 
 	if(node1_weight > node2_weight) {
 		crm_debug_3("%s (%d) > %s (%d) : weight",
 			    node1->details->uname, node1_weight,
 			    node2->details->uname, node2_weight);
 		return -1;
 	}
 	
 	if(node1_weight < node2_weight) {
 		crm_debug_3("%s (%d) < %s (%d) : weight",
 			    node1->details->uname, node1_weight,
 			    node2->details->uname, node2_weight);
 		return 1;
 	}
 
 	crm_debug_3("%s (%d) == %s (%d) : weight",
 		    node1->details->uname, node1_weight,
 		    node2->details->uname, node2_weight);
 	
 	/* now try to balance resources across the cluster */
 	if(node1->details->num_resources
 	   < node2->details->num_resources) {
 		crm_debug_3("%s (%d) < %s (%d) : resources",
 			    node1->details->uname, node1->details->num_resources,
 			    node2->details->uname, node2->details->num_resources);
 		return -1;
 		
 	} else if(node1->details->num_resources
 		  > node2->details->num_resources) {
 		crm_debug_3("%s (%d) > %s (%d) : resources",
 			    node1->details->uname, node1->details->num_resources,
 			    node2->details->uname, node2->details->num_resources);
 		return 1;
 	}
 	
 	crm_debug_4("%s = %s", node1->details->uname, node2->details->uname);
 	return 0;
 }
 
diff --git a/crm/pengine/utils.h b/crm/pengine/utils.h
index 55833ce67f..639f288996 100644
--- a/crm/pengine/utils.h
+++ b/crm/pengine/utils.h
@@ -1,60 +1,55 @@
 /* $Id: utils.h,v 1.3 2006/07/05 14:20:02 andrew Exp $ */
 /* 
  * Copyright (C) 2004 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.1 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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  */
 #ifndef PENGINE_AUTILS__H
 #define PENGINE_AUTILS__H
 
 /* Constraint helper functions */
 extern rsc_colocation_t *invert_constraint(rsc_colocation_t *constraint);
 
 extern rsc_to_node_t *copy_constraint(rsc_to_node_t *constraint);
 
 extern void print_rsc_to_node(
 	const char *pre_text, rsc_to_node_t *cons, gboolean details);
 
 extern void print_rsc_colocation(
 	const char *pre_text, rsc_colocation_t *cons, gboolean details);
 
 extern rsc_to_node_t *rsc2node_new(
 	const char *id, resource_t *rsc, int weight, node_t *node,
 	pe_working_set_t *data_set);
 
 extern void pe_free_rsc_to_node(GListPtr constraints);
 extern void pe_free_ordering(GListPtr constraints);
 
-extern const char *strength2text(enum con_strength strength);
 extern const char *ordering_type2text(enum pe_ordering type);
 
 extern gboolean rsc_colocation_new(
-	const char *id, enum con_strength strength,
+	const char *id, int score,
 	resource_t *rsc_lh, resource_t *rsc_rh,
 	const char *state_lh, const char *state_rh);
 
-extern gboolean create_ordering(
-	const char *id, enum con_strength strength,
-	resource_t *rsc_lh, resource_t *rsc_rh, pe_working_set_t *data_set);
-
 extern rsc_to_node_t *generate_location_rule(
 	resource_t *rsc, crm_data_t *location_rule, pe_working_set_t *data_set);
 
 extern gint sort_cons_strength(gconstpointer a, gconstpointer b);
 extern gint sort_node_weight(gconstpointer a, gconstpointer b);
 
 extern gboolean can_run_resources(const node_t *node);
 
 #endif