| module openconfig-bgp-policy { |
| |
| yang-version "1"; |
| |
| // namespace |
| namespace "http://openconfig.net/yang/bgp-policy"; |
| |
| prefix "oc-bgp-pol"; |
| |
| // import some basic types |
| import openconfig-inet-types { prefix oc-inet; } |
| import openconfig-routing-policy {prefix oc-rpol; } |
| import openconfig-policy-types { prefix oc-pol-types; } |
| import openconfig-bgp-types { prefix oc-bgp-types; } |
| import openconfig-extensions { prefix oc-ext; } |
| |
| |
| // meta |
| organization |
| "OpenConfig working group"; |
| |
| contact |
| "OpenConfig working group |
| netopenconfig@googlegroups.com"; |
| |
| description |
| "This module contains data definitions for BGP routing policy. |
| It augments the base routing-policy module with BGP-specific |
| options for conditions and actions."; |
| |
| oc-ext:openconfig-version "4.0.1"; |
| |
| revision "2017-07-30" { |
| description |
| "Clarification of add-paths send-max leaf"; |
| reference "4.0.1"; |
| } |
| |
| revision "2017-07-10" { |
| description |
| "Add error notifications; moved add-paths config; add AS |
| prepend policy features; removed unneeded config leaves"; |
| reference "4.0.0"; |
| } |
| |
| revision "2017-02-02" { |
| description |
| "Bugfix to remove remaining global-level policy data"; |
| reference "3.0.1"; |
| } |
| |
| revision "2017-01-26" { |
| description |
| "Add dynamic neighbor support, migrate to OpenConfig types"; |
| reference "3.0.0"; |
| } |
| |
| revision "2016-06-21" { |
| description |
| "OpenConfig BGP refactor"; |
| reference "2.1.1"; |
| } |
| |
| |
| // typedef statements |
| |
| typedef bgp-set-community-option-type { |
| type enumeration { |
| enum ADD { |
| description |
| "add the specified communities to the existing |
| community attribute"; |
| } |
| enum REMOVE { |
| description |
| "remove the specified communities from the |
| existing community attribute"; |
| } |
| enum REPLACE { |
| description |
| "replace the existing community attribute with |
| the specified communities. If an empty set is |
| specified, this removes the community attribute |
| from the route."; |
| } |
| } |
| description |
| "Type definition for options when setting the community |
| attribute in a policy action"; |
| } |
| |
| typedef bgp-next-hop-type { |
| type union { |
| type oc-inet:ip-address; |
| type enumeration { |
| enum SELF { |
| description "special designation for local router's own |
| address, i.e., next-hop-self"; |
| } |
| } |
| } |
| description |
| "type definition for specifying next-hop in policy actions"; |
| } |
| |
| typedef bgp-set-med-type { |
| type union { |
| type uint32; |
| type string { |
| pattern '^[+-][0-9]+$'; |
| } |
| type enumeration { |
| enum IGP { |
| description "set the MED value to the IGP cost toward the |
| next hop for the route"; |
| } |
| } |
| } |
| description |
| "Type definition for specifying how the BGP MED can |
| be set in BGP policy actions. The three choices are to set |
| the MED directly, increment/decrement using +/- notation, |
| and setting it to the IGP cost (predefined value)."; |
| } |
| |
| // grouping statements |
| |
| grouping match-community-config { |
| description |
| "Configuration data for match conditions on communities"; |
| |
| leaf community-set { |
| type leafref { |
| path "/oc-rpol:routing-policy/oc-rpol:defined-sets/" + |
| "oc-bgp-pol:bgp-defined-sets/oc-bgp-pol:community-sets/" + |
| "oc-bgp-pol:community-set/oc-bgp-pol:community-set-name"; |
| } |
| description |
| "References a defined community set"; |
| } |
| |
| uses oc-rpol:match-set-options-group; |
| } |
| |
| grouping match-community-state { |
| description |
| "Operational state data for match conditions on communities"; |
| } |
| |
| grouping match-community-top { |
| description |
| "Top-level grouping for match conditions on communities"; |
| |
| container match-community-set { |
| description |
| "Top-level container for match conditions on communities. |
| Match a referenced community-set according to the logic |
| defined in the match-set-options leaf"; |
| |
| container config { |
| description |
| "Configuration data for match conditions on communities"; |
| |
| uses match-community-config; |
| } |
| |
| container state { |
| |
| config false; |
| |
| description |
| "Operational state data "; |
| |
| uses match-community-config; |
| uses match-community-state; |
| } |
| } |
| } |
| |
| grouping match-ext-community-config { |
| description |
| "Configuration data for match conditions on extended |
| communities"; |
| |
| leaf ext-community-set { |
| type leafref { |
| path "/oc-rpol:routing-policy/oc-rpol:defined-sets/" + |
| "oc-bgp-pol:bgp-defined-sets/oc-bgp-pol:ext-community-sets/" + |
| "oc-bgp-pol:ext-community-set/" + |
| "oc-bgp-pol:ext-community-set-name"; |
| } |
| description "References a defined extended community set"; |
| } |
| |
| uses oc-rpol:match-set-options-group; |
| } |
| |
| grouping match-ext-community-state { |
| description |
| "Operational state data for match conditions on extended |
| communities"; |
| } |
| |
| grouping match-ext-community-top { |
| description |
| "Top-level grouping for match conditions on extended |
| communities"; |
| |
| container match-ext-community-set { |
| description |
| "Match a referenced extended community-set according to the |
| logic defined in the match-set-options leaf"; |
| |
| container config { |
| description |
| "Configuration data for match conditions on extended |
| communities"; |
| |
| uses match-ext-community-config; |
| } |
| |
| container state { |
| |
| config false; |
| |
| description |
| "Operational state data for match conditions on extended |
| communities"; |
| |
| uses match-ext-community-config; |
| uses match-ext-community-state; |
| } |
| } |
| } |
| |
| grouping match-as-path-config { |
| description |
| "Configuration data for match conditions on AS path set"; |
| |
| leaf as-path-set { |
| type leafref { |
| path "/oc-rpol:routing-policy/oc-rpol:defined-sets/" + |
| "oc-bgp-pol:bgp-defined-sets/oc-bgp-pol:as-path-sets/" + |
| "oc-bgp-pol:as-path-set/oc-bgp-pol:as-path-set-name"; |
| } |
| description "References a defined AS path set"; |
| } |
| uses oc-rpol:match-set-options-group; |
| } |
| |
| grouping match-as-path-state { |
| description |
| "Operational state data for match conditions on AS path set"; |
| } |
| |
| grouping match-as-path-top { |
| description |
| "Top-level grouping for match conditions on AS path set"; |
| |
| container match-as-path-set { |
| description |
| "Match a referenced as-path set according to the logic |
| defined in the match-set-options leaf"; |
| |
| container config { |
| description |
| "Configuration data for match conditions on AS path set"; |
| |
| uses match-as-path-config; |
| } |
| |
| container state { |
| |
| config false; |
| |
| description |
| "Operational state data for match conditions on AS |
| path set"; |
| |
| uses match-as-path-config; |
| uses match-as-path-state; |
| } |
| } |
| } |
| |
| grouping bgp-match-set-conditions { |
| description |
| "Condition statement definitions for checking membership in a |
| defined set"; |
| |
| uses match-community-top; |
| uses match-ext-community-top; |
| uses match-as-path-top; |
| } |
| |
| grouping community-count-config { |
| description |
| "Configuration data for community count condition"; |
| |
| uses oc-pol-types:attribute-compare-operators; |
| } |
| |
| grouping community-count-state { |
| description |
| "Operational state data for community count condition"; |
| } |
| |
| grouping community-count-top { |
| description |
| "Top-level grouping for community count condition"; |
| |
| container community-count { |
| description |
| "Value and comparison operations for conditions based on the |
| number of communities in the route update"; |
| |
| container config { |
| description |
| "Configuration data for community count condition"; |
| |
| uses community-count-config; |
| } |
| |
| container state { |
| |
| config false; |
| |
| description |
| "Operational state data for community count condition"; |
| |
| uses community-count-config; |
| uses community-count-state; |
| } |
| } |
| } |
| |
| grouping as-path-length-config { |
| description |
| "Configuration data for AS path length condition"; |
| |
| uses oc-pol-types:attribute-compare-operators; |
| } |
| |
| grouping as-path-length-state { |
| description |
| "Operational state data for AS path length condition"; |
| } |
| |
| grouping as-path-length-top { |
| description |
| "Top-level grouping for AS path length condition"; |
| |
| container as-path-length { |
| description |
| "Value and comparison operations for conditions based on the |
| length of the AS path in the route update"; |
| |
| container config { |
| description |
| "Configuration data for AS path length condition"; |
| |
| uses as-path-length-config; |
| } |
| |
| container state { |
| |
| config false; |
| |
| description |
| "Operational state data for AS path length condition"; |
| |
| uses as-path-length-config; |
| uses as-path-length-state; |
| } |
| } |
| } |
| |
| grouping bgp-conditions-config { |
| description |
| "Configuration data for BGP-specific policy conditions"; |
| |
| leaf med-eq { |
| type uint32; |
| description |
| "Condition to check if the received MED value is equal to |
| the specified value"; |
| } |
| |
| leaf origin-eq { |
| type oc-bgp-types:bgp-origin-attr-type; |
| description |
| "Condition to check if the route origin is equal to the |
| specified value"; |
| } |
| |
| leaf-list next-hop-in { |
| type oc-inet:ip-address; |
| description |
| "List of next hop addresses to check for in the route |
| update"; |
| } |
| |
| leaf-list afi-safi-in { |
| type identityref { |
| base oc-bgp-types:AFI_SAFI_TYPE; |
| } |
| description |
| "List of address families which the NLRI may be |
| within"; |
| } |
| |
| leaf local-pref-eq { |
| type uint32; |
| // TODO: add support for other comparisons if needed |
| description |
| "Condition to check if the local pref attribute is equal to |
| the specified value"; |
| } |
| |
| leaf route-type { |
| // TODO: verify extent of vendor support for this comparison |
| type enumeration { |
| enum INTERNAL { |
| description "route type is internal"; |
| } |
| enum EXTERNAL { |
| description "route type is external"; |
| } |
| } |
| description |
| "Condition to check the route type in the route update"; |
| } |
| } |
| |
| grouping bgp-conditions-state { |
| description |
| "Operational state data for BGP-specific policy conditions"; |
| } |
| |
| grouping bgp-conditions-top { |
| description |
| "Top-level grouping for BGP-specific policy conditions"; |
| |
| container bgp-conditions { |
| description |
| "Top-level container "; |
| |
| container config { |
| description |
| "Configuration data for BGP-specific policy conditions"; |
| |
| uses bgp-conditions-config; |
| } |
| |
| container state { |
| |
| config false; |
| |
| description |
| "Operational state data for BGP-specific policy |
| conditions"; |
| |
| uses bgp-conditions-config; |
| uses bgp-conditions-state; |
| } |
| |
| uses community-count-top; |
| uses as-path-length-top; |
| uses bgp-match-set-conditions; |
| } |
| } |
| |
| grouping community-set-config { |
| description |
| "Configuration data for BGP community sets"; |
| |
| leaf community-set-name { |
| type string; |
| mandatory true; |
| description |
| "name / label of the community set -- this is used to |
| reference the set in match conditions"; |
| } |
| |
| leaf-list community-member { |
| type union { |
| type oc-bgp-types:bgp-std-community-type; |
| type oc-bgp-types:bgp-community-regexp-type; |
| type oc-bgp-types:bgp-well-known-community-type; |
| } |
| description |
| "members of the community set"; |
| } |
| } |
| |
| grouping community-set-state { |
| description |
| "Operational state data for BGP community sets"; |
| } |
| |
| grouping community-set-top { |
| description |
| "Top-level grouping for BGP community sets"; |
| |
| container community-sets { |
| description |
| "Enclosing container for list of defined BGP community sets"; |
| |
| list community-set { |
| key "community-set-name"; |
| description |
| "List of defined BGP community sets"; |
| |
| leaf community-set-name { |
| type leafref { |
| path "../config/community-set-name"; |
| } |
| description |
| "Reference to list key"; |
| } |
| |
| container config { |
| description |
| "Configuration data for BGP community sets"; |
| |
| uses community-set-config; |
| } |
| |
| container state { |
| |
| config false; |
| |
| description |
| "Operational state data for BGP community sets"; |
| |
| uses community-set-config; |
| uses community-set-state; |
| } |
| } |
| } |
| } |
| |
| grouping ext-community-set-config { |
| description |
| "Configuration data for extended BGP community sets"; |
| |
| leaf ext-community-set-name { |
| type string; |
| description |
| "name / label of the extended community set -- this is |
| used to reference the set in match conditions"; |
| } |
| |
| leaf-list ext-community-member { |
| type union { |
| type oc-bgp-types:bgp-ext-community-type; |
| type oc-bgp-types:bgp-community-regexp-type; |
| } |
| description |
| "members of the extended community set"; |
| } |
| } |
| |
| grouping ext-community-set-state { |
| description |
| "Operational state data for extended BGP community sets"; |
| } |
| |
| grouping ext-community-set-top { |
| description |
| "Top-level grouping for extended BGP community sets"; |
| |
| container ext-community-sets { |
| description |
| "Enclosing container for list of extended BGP community |
| sets"; |
| |
| list ext-community-set { |
| key "ext-community-set-name"; |
| description |
| "List of defined extended BGP community sets"; |
| |
| leaf ext-community-set-name { |
| type leafref { |
| path "../config/ext-community-set-name"; |
| } |
| description |
| "Reference to list key"; |
| } |
| |
| container config { |
| description |
| "Configuration data for extended BGP community sets"; |
| |
| uses ext-community-set-config; |
| } |
| |
| container state { |
| |
| config false; |
| |
| description |
| "Operational state data for extended BGP community sets"; |
| |
| uses ext-community-set-config; |
| uses ext-community-set-state; |
| } |
| } |
| } |
| } |
| |
| grouping as-path-set-config { |
| description |
| "Configuration data for AS path sets"; |
| |
| leaf as-path-set-name { |
| type string; |
| description |
| "name of the AS path set -- this is used to reference |
| the set in match conditions"; |
| } |
| |
| leaf-list as-path-set-member { |
| // TODO: need to refine typedef for AS path expressions |
| type string; |
| description |
| "AS path expression -- list of ASes in the set"; |
| } |
| } |
| |
| grouping as-path-set-state { |
| description |
| "Operational state data for AS path sets"; |
| } |
| |
| grouping as-path-set-top { |
| description |
| "Top-level grouping for AS path sets"; |
| |
| container as-path-sets { |
| description |
| "Enclosing container for list of define AS path sets"; |
| |
| list as-path-set { |
| key "as-path-set-name"; |
| description |
| "List of defined AS path sets"; |
| |
| leaf as-path-set-name { |
| type leafref { |
| path "../config/as-path-set-name"; |
| } |
| description |
| "Reference to list key"; |
| } |
| |
| container config { |
| description |
| "Configuration data for AS path sets"; |
| |
| uses as-path-set-config; |
| } |
| |
| container state { |
| |
| config false; |
| |
| description |
| "Operational state data for AS path sets"; |
| |
| uses as-path-set-config; |
| uses as-path-set-state; |
| } |
| } |
| } |
| } |
| |
| // augment statements |
| |
| augment "/oc-rpol:routing-policy/oc-rpol:defined-sets" { |
| description "adds BGP defined sets container to routing policy |
| model"; |
| |
| container bgp-defined-sets { |
| description |
| "BGP-related set definitions for policy match conditions"; |
| |
| uses community-set-top; |
| uses ext-community-set-top; |
| uses as-path-set-top; |
| } |
| } |
| |
| grouping as-path-prepend-config { |
| description |
| "Configuration data for the AS path prepend action"; |
| |
| leaf repeat-n { |
| type uint8 { |
| range 1..max; |
| } |
| description |
| "Number of times to prepend the value specified in the asn |
| leaf to the AS path. If no value is specified by the asn |
| leaf, the local AS number of the system is used. The value |
| should be between 1 and the maximum supported by the |
| implementation."; |
| } |
| |
| leaf asn { |
| type oc-inet:as-number; |
| description |
| "The AS number to prepend to the AS path. If this leaf is |
| not specified and repeat-n is set, then the local AS |
| number will be used for prepending."; |
| } |
| } |
| |
| grouping as-path-prepend-state { |
| description |
| "Operational state data for the AS path prepend action"; |
| } |
| |
| grouping as-path-prepend-top { |
| description |
| "Top-level grouping for the AS path prepend action"; |
| |
| container set-as-path-prepend { |
| description |
| "Action to prepend the specified AS number to the AS-path a |
| specified number of times"; |
| |
| container config { |
| description |
| "Configuration data for the AS path prepend action"; |
| |
| uses as-path-prepend-config; |
| } |
| |
| container state { |
| |
| config false; |
| |
| description |
| "Operational state data for the AS path prepend action"; |
| |
| uses as-path-prepend-config; |
| uses as-path-prepend-state; |
| } |
| } |
| } |
| |
| grouping set-community-action-common { |
| description |
| "Common leaves for set-community and set-ext-community |
| actions"; |
| |
| leaf method { |
| type enumeration { |
| enum INLINE { |
| description |
| "The extended communities are specified inline as a |
| list"; |
| } |
| enum REFERENCE { |
| description |
| "The extended communities are specified by referencing a |
| defined ext-community set"; |
| } |
| } |
| description |
| "Indicates the method used to specify the extended |
| communities for the set-ext-community action"; |
| } |
| |
| leaf options { |
| type bgp-set-community-option-type; |
| description |
| "Options for modifying the community attribute with |
| the specified values. These options apply to both |
| methods of setting the community attribute."; |
| } |
| } |
| |
| grouping set-community-inline-config { |
| description |
| "Configuration data for inline specification of set-community |
| action"; |
| |
| leaf-list communities { |
| type union { |
| type oc-bgp-types:bgp-std-community-type; |
| type oc-bgp-types:bgp-well-known-community-type; |
| } |
| description |
| "Set the community values for the update inline with |
| a list."; |
| } |
| } |
| |
| grouping set-community-inline-state { |
| description |
| "Operational state data or inline specification of |
| set-community action"; |
| } |
| |
| grouping set-community-inline-top { |
| description |
| "Top-level grouping or inline specification of set-community |
| action"; |
| |
| container inline { |
| when "../config/method=INLINE" { |
| description |
| "Active only when the set-community method is INLINE"; |
| } |
| description |
| "Set the community values for the action inline with |
| a list."; |
| |
| container config { |
| description |
| "Configuration data or inline specification of set-community |
| action"; |
| |
| uses set-community-inline-config; |
| } |
| |
| container state { |
| |
| config false; |
| |
| description |
| "Operational state data or inline specification of |
| set-community action"; |
| |
| uses set-community-inline-config; |
| uses set-community-inline-state; |
| } |
| } |
| } |
| |
| grouping set-community-reference-config { |
| description |
| "Configuration data for referening a community-set in the |
| set-community action"; |
| |
| leaf community-set-ref { |
| type leafref { |
| path "/oc-rpol:routing-policy/oc-rpol:defined-sets/" + |
| "oc-bgp-pol:bgp-defined-sets/" + |
| "oc-bgp-pol:community-sets/oc-bgp-pol:community-set/" + |
| "oc-bgp-pol:community-set-name"; |
| } |
| description |
| "References a defined community set by name"; |
| } |
| } |
| |
| grouping set-community-reference-state { |
| description |
| "Operational state data for referening a community-set in the |
| set-community action"; |
| } |
| |
| grouping set-community-reference-top { |
| description |
| "Top-level grouping for referening a community-set in the |
| set-community action"; |
| |
| container reference { |
| when "../config/method=REFERENCE" { |
| description |
| "Active only when the set-community method is REFERENCE"; |
| } |
| description |
| "Provide a reference to a defined community set for the |
| set-community action"; |
| |
| container config { |
| description |
| "Configuration data for referening a community-set in the |
| set-community action"; |
| |
| uses set-community-reference-config; |
| } |
| |
| container state { |
| |
| config false; |
| |
| description |
| "Operational state data for referening a community-set |
| in the set-community action"; |
| |
| uses set-community-reference-config; |
| uses set-community-reference-state; |
| } |
| } |
| } |
| |
| grouping set-community-action-config { |
| description |
| "Configuration data for the set-community action"; |
| |
| uses set-community-action-common; |
| } |
| |
| grouping set-community-action-state { |
| description |
| "Operational state data for the set-community action"; |
| } |
| |
| grouping set-community-action-top { |
| description |
| "Top-level grouping for the set-community action"; |
| |
| container set-community { |
| description |
| "Action to set the community attributes of the route, along |
| with options to modify how the community is modified. |
| Communities may be set using an inline list OR |
| reference to an existing defined set (not both)."; |
| |
| container config { |
| description |
| "Configuration data for the set-community action"; |
| |
| uses set-community-action-config; |
| } |
| |
| container state { |
| |
| config false; |
| |
| description |
| "Operational state data for the set-community action"; |
| |
| uses set-community-action-config; |
| uses set-community-action-state; |
| } |
| |
| uses set-community-inline-top; |
| uses set-community-reference-top; |
| } |
| } |
| |
| grouping set-ext-community-inline-config { |
| description |
| "Configuration data for inline specification of |
| set-ext-community action"; |
| |
| leaf-list communities { |
| type union { |
| type oc-bgp-types:bgp-ext-community-type; |
| type oc-bgp-types:bgp-well-known-community-type; |
| } |
| description |
| "Set the extended community values for the update inline |
| with a list."; |
| } |
| } |
| |
| grouping set-ext-community-inline-state { |
| description |
| "Operational state data or inline specification of |
| set-ext-community action"; |
| } |
| |
| grouping set-ext-community-inline-top { |
| description |
| "Top-level grouping or inline specification of set-ext-community |
| action"; |
| |
| container inline { |
| when "../config/method=INLINE" { |
| description |
| "Active only when the set-community method is INLINE"; |
| } |
| description |
| "Set the extended community values for the action inline with |
| a list."; |
| |
| container config { |
| description |
| "Configuration data or inline specification of |
| set-ext-community action"; |
| |
| uses set-ext-community-inline-config; |
| } |
| |
| container state { |
| |
| config false; |
| |
| description |
| "Operational state data or inline specification of |
| set-ext-community action"; |
| |
| uses set-ext-community-inline-config; |
| uses set-ext-community-inline-state; |
| } |
| } |
| } |
| |
| grouping set-ext-community-reference-config { |
| description |
| "Configuration data for referening a extended community-set |
| in the set-ext-community action"; |
| |
| leaf ext-community-set-ref { |
| type leafref { |
| path "/oc-rpol:routing-policy/oc-rpol:defined-sets/" + |
| "oc-bgp-pol:bgp-defined-sets/" + |
| "oc-bgp-pol:ext-community-sets/" + |
| "oc-bgp-pol:ext-community-set/" + |
| "oc-bgp-pol:ext-community-set-name"; |
| } |
| description |
| "References a defined extended community set by |
| name"; |
| } |
| } |
| |
| grouping set-ext-community-reference-state { |
| description |
| "Operational state data for referening an extended |
| community-set in the set-ext-community action"; |
| } |
| |
| grouping set-ext-community-reference-top { |
| description |
| "Top-level grouping for referening an extended community-set |
| in the set-community action"; |
| |
| container reference { |
| when "../config/method=REFERENCE" { |
| description |
| "Active only when the set-community method is REFERENCE"; |
| } |
| description |
| "Provide a reference to an extended community set for the |
| set-ext-community action"; |
| |
| container config { |
| description |
| "Configuration data for referening an extended |
| community-set in the set-ext-community action"; |
| |
| uses set-ext-community-reference-config; |
| } |
| |
| container state { |
| |
| config false; |
| |
| description |
| "Operational state data for referening an extended |
| community-set in the set-ext-community action"; |
| |
| uses set-ext-community-reference-config; |
| uses set-ext-community-reference-state; |
| } |
| } |
| } |
| |
| grouping set-ext-community-action-config { |
| description |
| "Configuration data for the set-ext-community action"; |
| |
| uses set-community-action-common; |
| } |
| |
| grouping set-ext-community-action-state { |
| description |
| "Operational state data for the set-ext-community action"; |
| } |
| |
| grouping set-ext-community-action-top { |
| description |
| "Top-level grouping for the set-ext-community action"; |
| |
| container set-ext-community { |
| description |
| "Action to set the extended community attributes of the |
| route, along with options to modify how the community is |
| modified. Extended communities may be set using an inline |
| list OR a reference to an existing defined set (but not |
| both)."; |
| |
| container config { |
| description |
| "Configuration data for the set-ext-community action"; |
| |
| uses set-ext-community-action-config; |
| } |
| |
| container state { |
| |
| config false; |
| |
| description |
| "Operational state data for the set-ext-community action"; |
| |
| uses set-ext-community-action-config; |
| uses set-ext-community-action-state; |
| } |
| uses set-ext-community-inline-top; |
| uses set-ext-community-reference-top; |
| } |
| } |
| |
| grouping bgp-actions-config { |
| description |
| "Configuration data for BGP-specific actions"; |
| |
| leaf set-route-origin { |
| type oc-bgp-types:bgp-origin-attr-type; |
| description "set the origin attribute to the specified |
| value"; |
| } |
| |
| leaf set-local-pref { |
| type uint32; |
| description "set the local pref attribute on the route |
| update"; |
| } |
| |
| leaf set-next-hop { |
| type bgp-next-hop-type; |
| description "set the next-hop attribute in the route update"; |
| } |
| |
| leaf set-med { |
| type bgp-set-med-type; |
| description "set the med metric attribute in the route |
| update"; |
| } |
| } |
| |
| grouping bgp-actions-state { |
| description |
| "Operational state data for BGP-specific actions"; |
| } |
| |
| grouping bgp-actions-top { |
| description |
| "Top-level grouping for BGP-specific actions"; |
| |
| container bgp-actions { |
| description |
| "Top-level container for BGP-specific actions"; |
| |
| container config { |
| description |
| "Configuration data for BGP-specific actions"; |
| |
| uses bgp-actions-config; |
| } |
| |
| container state { |
| |
| config false; |
| |
| description |
| "Operational state data for BGP-specific actions"; |
| |
| uses bgp-actions-config; |
| uses bgp-actions-state; |
| } |
| uses as-path-prepend-top; |
| uses set-community-action-top; |
| uses set-ext-community-action-top; |
| } |
| } |
| |
| augment "/oc-rpol:routing-policy/oc-rpol:policy-definitions/" + |
| "oc-rpol:policy-definition/oc-rpol:statements/oc-rpol:statement/" + |
| "oc-rpol:conditions" { |
| description |
| "BGP policy conditions added to routing policy module"; |
| |
| uses bgp-conditions-top; |
| } |
| |
| augment "/oc-rpol:routing-policy/oc-rpol:policy-definitions/" + |
| "oc-rpol:policy-definition/oc-rpol:statements/oc-rpol:statement/" + |
| "oc-rpol:actions" { |
| description "BGP policy actions added to routing policy |
| module"; |
| |
| uses bgp-actions-top; |
| } |
| |
| // rpc statements |
| |
| // notification statements |
| } |