Next: Parameters and Arguments, Up: Group configuration   [Contents][Index]

3.1 Dependencies ¶

Groups declare their load and remove dependencies as child nodes inside pull and replace nodes respectively. Each node representing a dependency must have the respective group name as node name and may optionally have group as node type. For example:

def-group Group3 {}
def-group "Group 4" {
    pull {
        (group)Group3
    }
}
def-group Group5 {
    pull {
        (group) Group3
        "Group 4"
    }
}
def-group Group6 {
    pull {
        "Group 4"
    }
    replace {
        Group3
    }
}

A group listed as load dependency can still be prevented to be loaded if another group lists the same group as a remove dependency. On the contrary, groups listed as remove dependencies cannot be included by any mean because it is not possible to revert a remove dependency. The only way to load a group declared as remove dependency is to prevent the group that specifies it as a remove dependency to be loaded.

A group may appear in both pull and replace. In this case, the group itself is excluded while its dependencies remain included. Dependencies are transitive by default:

1. load dependencies propagate both load and remove dependencies;
2. remove dependencies propagate only remove dependencies.

Transitive behaviour can be disabled with the inherit=#false property in group nodes:

def-group Group7 {
    pull {
        // Group4 is loaded as a pull dependency
        // Group3 is loaded as a replace dependency
        Group6
    }
}
def-group Group8 {
    pull {
        // No further groups are loaded as dependency
        Group6 inherit=#false
    }
}

You can also assign the string values "true", "false" to inherit property in place of boolean values #true, #false (double quotes " are mandatory for "true", "false" as specified by KDL specifications). For remove dependencies, the inherit also accepts the string pulls as value. With this property, all the transitive pull dependencies are loaded as replace dependencies.

def-group Group9 {
    replace {
        // Group3 and Group4 are loaded as replace dependencies
        Group6 inherit=pulls
    }
}

Groups can declare dependencies also inside a merge node the same way you declare them in pull or replace node. Groups specified inside a merge are loaded as remove dependencies but with the following differences from usual remove dependencies:

• transitive load dependencies are transitively loaded as load dependencies, unless inherit=#false or inherit=deep are specified;
• all the fields specifications are loaded in the current group as their own specifications that can still be modified in its own sd node, for example

  
  def-group GroupA {
      sd {
          (section) Unit {
              (set) StopWhenUnneeded #true
              (set) RefuseManualStart #true
          }
      }
  }
  def-group GroupB {
      merge {
          GroupA
      }
      sd {
          (section) Unit {
              (reset) RefuseManualStart
          }
      }
      // Now GroupA is listed as a remove dependency, GroupB sets the
      // StopWhenUnneeded field in [Unit] to true when loaded but resets the
      // RefuseManualStart field.
  }
  
  

The inherit property of a dependency specified inside a merge node accepts the special value deep other than #true and #false. For each dependency inside merge with inherit=deep:

• all load transitive dependencies are imported as remove dependencies instead;
• all the fields specified in these load transitive dependencies are loaded in the current group as its own specifications.

Loading multiple groups inside merge node may generate conflits when one or more fields are modified by different groups. Section Conflicts explains how to manage and resolve conflicts.