附录C. 用于NETCONF协议操作的YANG模块

本部分是规范性的。

这个ietf-netconf YANG模块是从RFC6021中导入的typedef。

<CODE BEGINS> file “ietf-netconf@2011-06-01.yang”

  1. module ietf-netconf {
  3.     // the namespace for NETCONF XML definitions is unchanged
  4.     // from RFC 4741, which this document replaces
  5.     namespace "urn:ietf:params:xml:ns:netconf:base:1.0";
  7.     prefix nc;
  9.     import ietf-inet-types {
  10.         prefix inet;
  11.     }
  13.     organization "IETF NETCONF (Network Configuration) Working Group";
  15.     contact
  16.       "WG Web:   <http://tools.ietf.org/wg/netconf/>
  17.        WG List:  <netconf@ietf.org>
  19.        WG Chair: Bert Wijnen
  20.                  <bertietf@bwijnen.net>
  22.        WG Chair: Mehmet Ersue
  23.                  <mehmet.ersue@nsn.com>
  25.        Editor:   Martin Bjorklund
  26.                  <mbj@tail-f.com>
  28.        Editor:   Juergen Schoenwaelder
  29.                  <j.schoenwaelder@jacobs-university.de>
  31.        Editor:   Andy Bierman
  32.                  <andy.bierman@brocade.com>";
  33.                  description
  34.                    "NETCONF Protocol Data Types and Protocol Operations.
  36.                     Copyright (c) 2011 IETF Trust and the persons identified as
  37.                     the document authors.  All rights reserved.
  39.                     Redistribution and use in source and binary forms, with or
  40.                     without modification, is permitted pursuant to, and subject
  41.                     to the license terms contained in, the Simplified BSD License
  42.                     set forth in Section 4.c of the IETF Trust's Legal Provisions
  43.                     Relating to IETF Documents
  44.                     (http://trustee.ietf.org/license-info).
  46.                     This version of this YANG module is part of RFC 6241; see
  47.                     the RFC itself for full legal notices.";
  48.     revision 2011-06-01 {
  49.         description
  50.         "Initial revision";
  51.         reference
  52.         "RFC 6241: Network Configuration Protocol";
  53.     }
  55.     extension get-filter-element-attributes {
  56.         description
  57.             "If this extension is present within an 'anyxml'
  58.             statement named 'filter', which must be conceptually
  59.             defined within the RPC input section for the <get>
  60.             and <get-config> protocol operations, then the
  61.             following unqualified XML attribute is supported
  62.             within the <filter> element, within a <get> or
  63.             <get-config> protocol operation:
  65.             type : optional attribute with allowed
  66.                value strings 'subtree' and 'xpath'.
  67.                If missing, the default value is 'subtree'.
  69.             If the 'xpath' feature is supported, then the
  70.             following unqualified XML attribute is
  71.             also supported:
  73.             select: optional attribute containing a
  74.                 string representing an XPath expression.
  75.                 The 'type' attribute must be equal to 'xpath'
  76.                 if this attribute is present.";
  77.         }
  79.          // NETCONF capabilities defined as features
  80.         feature writable-running {
  81.              description
  82.                "NETCONF :writable-running capability;
  83.                 If the server advertises the :writable-running
  84.                 capability for a session, then this feature must
  85.                 also be enabled for that session.  Otherwise,
  86.                 this feature must not be enabled.";
  87.              reference "RFC 6241, Section 8.2";
  88.         }
  90.         feature candidate {
  91.             description
  92.                 "NETCONF :candidate capability;
  93.                 If the server advertises the :candidate
  94.                 capability for a session, then this feature must
  95.                 also be enabled for that session.  Otherwise,
  96.                 this feature must not be enabled.";
  97.             reference "RFC 6241, Section 8.3";
  98.         }
  100.         feature confirmed-commit {
  101.             if-feature candidate;
  102.             description
  103.                 "NETCONF :confirmed-commit:1.1 capability;
  104.                 If the server advertises the :confirmed-commit:1.1
  105.                 capability for a session, then this feature must
  106.                 also be enabled for that session.  Otherwise,
  107.                 this feature must not be enabled.";
  109.             reference "RFC 6241, Section 8.4";
  110.         }
  112.         feature rollback-on-error {
  113.             description
  114.                 "NETCONF :rollback-on-error capability;
  115.                 If the server advertises the :rollback-on-error
  116.                 capability for a session, then this feature must
  117.                 also be enabled for that session.  Otherwise,
  118.                 this feature must not be enabled.";
  119.             reference "RFC 6241, Section 8.5";
  120.         }
  122.         feature validate {
  123.             description
  124.                 "NETCONF :validate:1.1 capability;
  125.                 If the server advertises the :validate:1.1
  126.                 capability for a session, then this feature must
  127.                 also be enabled for that session.  Otherwise,
  128.                 this feature must not be enabled.";
  129.             reference "RFC 6241, Section 8.6";
  130.         }
  132.         feature startup {
  133.             description
  134.               "NETCONF :startup capability;
  135.                If the server advertises the :startup
  136.                capability for a session, then this feature must
  137.                also be enabled for that session.  Otherwise,
  138.                this feature must not be enabled.";
  139.             reference "RFC 6241, Section 8.7";
  140.         }
  142.         feature url {
  143.             description
  144.                 "NETCONF :url capability;
  145.                 If the server advertises the :url
  146.                 capability for a session, then this feature must
  147.                 also be enabled for that session.  Otherwise,
  148.                 this feature must not be enabled.";
  149.             reference "RFC 6241, Section 8.8";
  150.         }
  152.         feature xpath {
  153.             description
  154.                 "NETCONF :xpath capability;
  155.                 If the server advertises the :xpath
  156.                 capability for a session, then this feature must
  157.                 also be enabled for that session.  Otherwise,
  158.                 this feature must not be enabled.";
  159.             reference "RFC 6241, Section 8.9";
  160.         }
  162.         // NETCONF Simple Types
  163.         typedef session-id-type {
  164.             type uint32 {
  165.                 range "1..max";
  166.             }
  167.             description
  168.                 "NETCONF Session Id";
  169.         }
  171.         typedef session-id-or-zero-type {
  172.             type uint32;
  173.             description
  174.                 "NETCONF Session Id or Zero to indicate none";
  175.         }
  177.         typedef error-tag-type {
  178.             type enumeration {
  179.                 enum in-use {
  180.                     description
  181.                         "The request requires a resource that
  182.                         already is in use.";
  183.                 }
  184.                 enum invalid-value {
  185.                     description
  186.                         "The request specifies an unacceptable value for one
  187.                         or more parameters.";
  188.                 }
  189.                 enum too-big {
  190.                     description
  191.                         "The request or response (that would be generated) is
  192.                         too large for the implementation to handle.";
  193.                 }
  194.                 enum missing-attribute {
  195.                     description
  196.                         "An expected attribute is missing.";
  197.                 }
  198.                 enum bad-attribute {
  199.                     description
  200.                         "An attribute value is not correct; e.g., wrong type,
  201.                         out of range, pattern mismatch.";
  202.                 }
  203.                 enum unknown-attribute {
  204.                     description
  205.                         "An unexpected attribute is present.";
  206.                 }
  207.                 enum missing-element {
  208.                     description
  209.                         "An expected element is missing.";
  210.                 }
  211.                 enum bad-element {
  212.                     description
  213.                         "An element value is not correct; e.g., wrong type,
  214.                         out of range, pattern mismatch.";
  215.                 }
  216.                 enum unknown-element {
  217.                     description
  218.                         "An unexpected element is present.";
  219.                 }
  220.                 enum unknown-namespace {
  221.                     description
  222.                         "An unexpected namespace is present.";
  223.                 }
  224.                 enum access-denied {
  225.                     description
  226.                         "Access to the requested protocol operation or
  227.                         data model is denied because authorization failed.";
  228.                 }
  229.                 enum lock-denied {
  230.                     description
  231.                         "Access to the requested lock is denied because the
  232.                         lock is currently held by another entity.";
  233.                 }
  234.                 enum resource-denied {
  235.                     description
  236.                         "Request could not be completed because of
  237.                         insufficient resources.";
  238.                 }
  239.                 enum rollback-failed {
  240.                     description
  241.                         "Request to roll back some configuration change (via
  242.                         rollback-on-error or <discard-changes> operations)
  243.                         was not completed for some reason.";
  245.                 }
  246.                 enum data-exists {
  247.                     description
  248.                         "Request could not be completed because the relevant
  249.                         data model content already exists.  For example,
  250.                         a 'create' operation was attempted on data that
  251.                         already exists.";
  252.                 }
  253.                 enum data-missing {
  254.                     description
  255.                         "Request could not be completed because the relevant
  256.                         data model content does not exist.  For example,
  257.                         a 'delete' operation was attempted on
  258.                         data that does not exist.";
  259.                 }
  260.                 enum operation-not-supported {
  261.                     description
  262.                         "Request could not be completed because the requested
  263.                         operation is not supported by this implementation.";
  264.                 }
  265.                 enum operation-failed {
  266.                     description
  267.                         "Request could not be completed because the requested
  268.                         operation failed for some reason not covered by
  269.                         any other error condition.";
  270.                 }
  271.                 enum partial-operation {
  272.                     description
  273.                         "This error-tag is obsolete, and SHOULD NOT be sent
  274.                         by servers conforming to this document.";
  275.                 }
  276.                 enum malformed-message {
  277.                     description
  278.                         "A message could not be handled because it failed to
  279.                         be parsed correctly.  For example, the message is not
  280.                         well-formed XML or it uses an invalid character set.";
  281.                 }
  282.             }
  283.             description "NETCONF Error Tag";
  284.             reference "RFC 6241, Appendix A";
  285.         }
  287.         typedef error-severity-type {
  288.             type enumeration {
  289.                 enum error {
  290.                     description "Error severity";
  291.                 }
  292.                 enum warning {
  293.                     description "Warning severity";
  294.                 }
  295.             }
  296.             description "NETCONF Error Severity";
  297.             reference "RFC 6241, Section 4.3";
  298.         }
  300.         typedef edit-operation-type {
  301.             type enumeration {
  302.                 enum merge {
  303.                     description
  304.                         "The configuration data identified by the
  305.                         element containing this attribute is merged
  306.                         with the configuration at the corresponding
  307.                         level in the configuration datastore identified
  308.                         by the target parameter.";
  309.                 }
  310.                 enum replace {
  311.                     description
  312.                         "The configuration data identified by the element
  313.                         containing this attribute replaces any related
  314.                         configuration in the configuration datastore
  315.                         identified by the target parameter.  If no such
  316.                         configuration data exists in the configuration
  317.                         datastore, it is created.  Unlike a
  318.                         <copy-config> operation, which replaces the
  319.                         entire target configuration, only the configuration
  320.                         actually present in the config parameter is affected.";
  321.                 }
  322.                 enum create {
  323.                     description
  324.                         "The configuration data identified by the element
  325.                         containing this attribute is added to the
  326.                         configuration if and only if the configuration
  327.                         data does not already exist in the configuration
  328.                         datastore.  If the configuration data exists, an
  329.                         <rpc-error> element is returned with an
  330.                         <error-tag> value of 'data-exists'.";
  331.                 }
  332.                 enum delete {
  333.                     description
  334.                         "The configuration data identified by the element
  335.                         containing this attribute is deleted from the
  336.                         configuration if and only if the configuration
  337.                         data currently exists in the configuration
  338.                         datastore.  If the configuration data does not
  339.                         exist, an <rpc-error> element is returned with
  340.                         an <error-tag> value of 'data-missing'.";
  341.                 }
  342.                 enum remove {
  343.                     description
  344.                         "The configuration data identified by the element
  345.                         containing this attribute is deleted from the
  346.                         configuration if the configuration
  347.                         data currently exists in the configuration
  348.                         datastore.  If the configuration data does not
  349.                         exist, the 'remove' operation is silently ignored
  350.                         by the server.";
  351.                 }
  352.             }
  353.             default "merge";
  354.             description "NETCONF 'operation' attribute values";
  355.             reference "RFC 6241, Section 7.2";
  356.         }
  358.         // NETCONF Standard Protocol Operations
  360.         rpc get-config {
  361.             description
  362.                 "Retrieve all or part of a specified configuration.";
  364.             reference "RFC 6241, Section 7.1";
  366.             input {
  367.                 container source {
  368.                     description
  369.                         "Particular configuration to retrieve.";
  371.                     choice config-source {
  372.                         mandatory true;
  373.                         description
  374.                             "The configuration to retrieve.";
  375.                         leaf candidate {
  376.                             if-feature candidate;
  377.                             type empty;
  378.                             description
  379.                                 "The candidate configuration is the config source.";
  380.                         }
  381.                         leaf running {
  382.                             type empty;
  383.                             description
  384.                                 "The running configuration is the config source.";
  385.                         }
  386.                         leaf startup {
  387.                             if-feature startup;
  388.                             type empty;
  389.                             description
  390.                                 "The startup configuration is the config source.
  391.                                 This is optional-to-implement on the server because
  392.                                 not all servers will support filtering for this
  393.                                 datastore.";
  394.                         }
  395.                     }
  396.                 }
  398.                 anyxml filter {
  399.                     description
  400.                         "Subtree or XPath filter to use.";
  401.                         nc:get-filter-element-attributes;
  402.                 }
  403.             }
  405.             output {
  406.                 anyxml data {
  407.                     description
  408.                         "Copy of the source datastore subset that matched
  409.                         the filter criteria (if any).  An empty data container
  410.                         indicates that the request did not produce any results.";
  411.                 }
  412.             }
  413.         }
  415.         rpc edit-config {
  416.             description
  417.                 "The <edit-config> operation loads all or part of a specified
  418.                 configuration to the specified target configuration.";
  420.             reference "RFC 6241, Section 7.2";
  422.             input {
  423.                 container target {
  424.                     description
  425.                         "Particular configuration to edit.";
  427.                     choice config-target {
  428.                         mandatory true;
  429.                         description
  430.                             "The configuration target.";
  432.                         leaf candidate {
  433.                             if-feature candidate;
  434.                             type empty;
  435.                             description
  436.                                 "The candidate configuration is the config target.";
  437.                         }
  438.                         leaf running {
  439.                             if-feature writable-running;
  440.                             type empty;
  441.                             description
  442.                                 "The running configuration is the config source.";
  443.                         }
  444.                     }
  445.                 }
  447.                 leaf default-operation {
  448.                 type enumeration {
  449.                     enum merge {
  450.                         description
  451.                             "The default operation is merge.";
  452.                     }
  453.                     enum replace {
  454.                         description
  455.                             "The default operation is replace.";
  456.                     }
  457.                     enum none {
  458.                         description
  459.                             "There is no default operation.";
  460.                     }
  461.                 }
  462.                 default "merge";
  463.                 description
  464.                     "The default operation to use.";
  465.             }
  467.             leaf test-option {
  468.                 if-feature validate;
  469.                 type enumeration {
  470.                     enum test-then-set {
  471.                         description
  472.                             "The server will test and then set if no errors.";
  473.                     }
  474.                     enum set {
  475.                         description
  476.                             "The server will set without a test first.";
  477.                     }
  479.                     enum test-only {
  480.                         description
  481.                             "The server will only test and not set, even
  482.                             if there are no errors.";
  483.                     }
  484.                 }
  485.                 default "test-then-set";
  486.                 description
  487.                     "The test option to use.";
  488.             }
  490.             leaf error-option {
  491.                 type enumeration {
  492.                     enum stop-on-error {
  493.                         description
  494.                             "The server will stop on errors.";
  495.                     }
  496.                     enum continue-on-error {
  497.                         description
  498.                             "The server may continue on errors.";
  499.                     }
  500.                     enum rollback-on-error {
  501.                         description
  502.                             "The server will roll back on errors.
  503.                             This value can only be used if the 'rollback-on-error'
  504.                             feature is supported.";
  505.                     }
  506.                 }
  507.                 default "stop-on-error";
  508.                     description
  509.                         "The error option to use.";
  510.             }
  512.             choice edit-content {
  513.                 mandatory true;
  514.                 description
  515.                     "The content for the edit operation.";
  517.                 anyxml config {
  518.                     description
  519.                         "Inline Config content.";
  520.                 }
  521.                 leaf url {
  522.                     if-feature url;
  523.                     type inet:uri;
  524.                     description
  525.                         "URL-based config content.";
  526.                 }
  527.             }
  528.         }
  529.     }
  531.     rpc copy-config {
  532.         description
  533.         "Create or replace an entire configuration datastore with the
  534.         contents of another complete configuration datastore.";
  536.         reference "RFC 6241, Section 7.3";
  538.         input {
  539.             container target {
  540.                 description
  541.                     "Particular configuration to copy to.";
  543.                 choice config-target {
  544.                     mandatory true;
  545.                     description
  546.                         "The configuration target of the copy operation.";
  548.                     leaf candidate {
  549.                         if-feature candidate;
  550.                         type empty;
  551.                         description
  552.                             "The candidate configuration is the config target.";
  553.                     }
  554.                     leaf running {
  555.                         if-feature writable-running;
  556.                         type empty;
  557.                         description
  558.                             "The running configuration is the config target.
  559.                             This is optional-to-implement on the server.";
  560.                     }
  561.                     leaf startup {
  562.                         if-feature startup;
  563.                         type empty;
  564.                         description
  565.                             "The startup configuration is the config target.";
  566.                     }
  567.                     leaf url {
  568.                         if-feature url;
  569.                         type inet:uri;
  570.                         description
  571.                             "The URL-based configuration is the config target.";
  572.                     }
  573.                 }
  574.             }
  576.             container source {
  577.                 description
  578.                     "Particular configuration to copy from.";
  580.                 choice config-source {
  581.                     mandatory true;
  582.                     description
  583.                         "The configuration source for the copy operation.";
  585.                     leaf candidate {
  586.                         if-feature candidate;
  587.                         type empty;
  588.                         description
  589.                             "The candidate configuration is the config source.";
  590.                     }
  591.                     leaf running {
  592.                         type empty;
  593.                         description
  594.                             "The running configuration is the config source.";
  595.                     }
  596.                     leaf startup {
  597.                         if-feature startup;
  598.                         type empty;
  599.                         description
  600.                             "The startup configuration is the config source.";
  601.                     }
  602.                     leaf url {
  603.                         if-feature url;
  604.                         type inet:uri;
  605.                         description
  606.                             "The URL-based configuration is the config source.";
  607.                     }
  608.                     anyxml config {
  609.                         description
  610.                             "Inline Config content: <config> element.  Represents
  611.                             an entire configuration datastore, not
  612.                             a subset of the running datastore.";
  613.                     }
  614.                 }
  615.             }
  616.         }
  617.     }
  619.     rpc delete-config {
  620.         description
  621.             "Delete a configuration datastore.";
  623.         reference "RFC 6241, Section 7.4";
  625.         input {
  626.             container target {
  627.                 description
  628.                     "Particular configuration to delete.";
  630.                 choice config-target {
  631.                     mandatory true;
  632.                     description
  633.                         "The configuration target to delete.";
  635.                     leaf startup {
  636.                         if-feature startup;
  637.                         type empty;
  638.                         description
  639.                             "The startup configuration is the config target.";
  640.                     }
  641.                     leaf url {
  642.                         if-feature url;
  643.                         type inet:uri;
  644.                         description
  645.                             "The URL-based configuration is the config target.";
  646.                     }
  647.                 }
  648.             }
  649.         }
  650.     }
  652.     rpc lock {
  653.         description
  654.             "The lock operation allows the client to lock the configuration
  655.             system of a device.";
  656.         reference "RFC 6241, Section 7.5";
  658.         input {
  659.             container target {
  660.                 description
  661.                     "Particular configuration to lock.";
  663.                 choice config-target {
  664.                     mandatory true;
  665.                     description
  666.                         "The configuration target to lock.";
  668.                     leaf candidate {
  669.                         if-feature candidate;
  670.                         type empty;
  671.                         description
  672.                             "The candidate configuration is the config target.";
  673.                     }
  674.                     leaf running {
  675.                         type empty;
  676.                         description
  677.                             "The running configuration is the config target.";
  678.                     }
  679.                     leaf startup {
  680.                         if-feature startup;
  681.                         type empty;
  682.                         description
  683.                             "The startup configuration is the config target.";
  684.                     }
  685.                 }
  686.             }
  687.         }
  688.     }
  690.     rpc unlock {
  691.         description
  692.             "The unlock operation is used to release a configuration lock,
  693.             previously obtained with the 'lock' operation.";
  695.         reference "RFC 6241, Section 7.6";
  697.         input {
  698.             container target {
  699.                 description
  700.                     "Particular configuration to unlock.";
  702.                 choice config-target {
  703.                     mandatory true;
  704.                     description
  705.                         "The configuration target to unlock.";
  707.                     leaf candidate {
  708.                         if-feature candidate;
  709.                         type empty;
  710.                         description
  711.                             "The candidate configuration is the config target.";
  712.                     }
  713.                     leaf running {
  714.                         type empty;
  715.                         description
  716.                             "The running configuration is the config target.";
  717.                     }
  718.                     leaf startup {
  719.                         if-feature startup;
  720.                         type empty;
  721.                         description
  722.                             "The startup configuration is the config target.";
  723.                     }
  724.                 }
  725.             }
  726.         }
  727.     }
  729.     rpc get {
  730.         description
  731.             "Retrieve running configuration and device state information.";
  733.         reference "RFC 6241, Section 7.7";
  735.         input {
  736.             anyxml filter {
  737.                 description
  738.                     "This parameter specifies the portion of the system
  739.                     configuration and state data to retrieve.";
  740.                 nc:get-filter-element-attributes;
  741.             }
  742.         }
  744.         output {
  745.             anyxml data {
  746.                 description
  747.                     "Copy of the running datastore subset and/or state
  748.                     data that matched the filter criteria (if any).
  749.                     An empty data container indicates that the request did not
  750.                     produce any results.";
  751.             }
  753.         }
  754.     }
  756.     rpc close-session {
  757.         description
  758.             "Request graceful termination of a NETCONF session.";
  760.         reference "RFC 6241, Section 7.8";
  761.     }
  763.     rpc kill-session {
  764.         description
  765.             "Force the termination of a NETCONF session.";
  767.         reference "RFC 6241, Section 7.9";
  769.         input {
  770.             leaf session-id {
  771.                 type session-id-type;
  772.                 mandatory true;
  773.                 description
  774.                     "Particular session to kill.";
  775.             }
  776.         }
  777.     }
  779.     rpc commit {
  780.         if-feature candidate;
  782.         description
  783.             "Commit the candidate configuration as the device's new
  784.             current configuration.";
  786.         reference "RFC 6241, Section 8.3.4.1";
  788.         input {
  789.             leaf confirmed {
  790.                 if-feature confirmed-commit;
  791.                 type empty;
  792.                 description
  793.                     "Requests a confirmed commit.";
  794.                     reference "RFC 6241, Section 8.3.4.1";
  795.             }
  797.             leaf confirm-timeout {
  798.                 if-feature confirmed-commit;
  799.                 type uint32 {
  800.                     range "1..max";
  801.                 }
  802.                 units "seconds";
  803.                 default "600";   // 10 minutes
  804.                 description
  805.                     "The timeout interval for a confirmed commit.";
  806.                     reference "RFC 6241, Section 8.3.4.1";
  807.             }
  809.             leaf persist {
  810.                 if-feature confirmed-commit;
  811.                 type string;
  812.                 description
  813.                     "This parameter is used to make a confirmed commit
  814.                     persistent.  A persistent confirmed commit is not aborted
  815.                     if the NETCONF session terminates.  The only way to abort
  816.                     a persistent confirmed commit is to let the timer expire,
  817.                     or to use the <cancel-commit> operation.
  819.                     The value of this parameter is a token that must be given
  820.                     in the 'persist-id' parameter of <commit> or
  821.                     <cancel-commit> operations in order to confirm or cancel
  822.                     the persistent confirmed commit.
  824.                     The token should be a random string.";
  825.                 reference "RFC 6241, Section 8.3.4.1";
  826.             }
  828.             leaf persist-id {
  829.                 if-feature confirmed-commit;
  830.                 type string;
  831.                 description
  832.                     "This parameter is given in order to commit a persistent
  833.                     confirmed commit.  The value must be equal to the value
  834.                     given in the 'persist' parameter to the <commit> operation.
  835.                     If it does not match, the operation fails with an
  836.                     'invalid-value' error.";
  837.                 reference "RFC 6241, Section 8.3.4.1";
  838.             }
  840.         }
  841.     }
  843.     rpc discard-changes {
  844.         if-feature candidate;
  846.         description
  847.             "Revert the candidate configuration to the current
  848.             running configuration.";
  849.             reference "RFC 6241, Section 8.3.4.2";
  850.     }
  852.     rpc cancel-commit {
  853.         if-feature confirmed-commit;
  854.         description
  855.             "This operation is used to cancel an ongoing confirmed commit.
  856.             If the confirmed commit is persistent, the parameter
  857.             'persist-id' must be given, and it must match the value of the
  858.             'persist' parameter.";
  859.         reference "RFC 6241, Section 8.4.4.1";
  861.         input {
  862.             leaf persist-id {
  863.                 type string;
  864.                 description
  865.                     "This parameter is given in order to cancel a persistent
  866.                     confirmed commit.  The value must be equal to the value
  867.                     given in the 'persist' parameter to the <commit> operation.
  868.                     If it does not match, the operation fails with an
  869.                     'invalid-value' error.";
  870.             }
  871.         }
  872.     }
  874.     rpc validate {
  875.         if-feature validate;
  877.         description
  878.             "Validates the contents of the specified configuration.";
  880.         reference "RFC 6241, Section 8.6.4.1";
  882.         input {
  883.             container source {
  884.                 description
  885.                     "Particular configuration to validate.";
  887.                 choice config-source {
  888.                     mandatory true;
  889.                     description
  890.                         "The configuration source to validate.";
  892.                     leaf candidate {
  893.                         if-feature candidate;
  894.                         type empty;
  895.                         description
  896.                             "The candidate configuration is the config source.";
  897.                     }
  898.                     leaf running {
  899.                         type empty;
  900.                         description
  901.                             "The running configuration is the config source.";
  902.                     }
  903.                     leaf startup {
  904.                         if-feature startup;
  905.                         type empty;
  906.                         description
  907.                             "The startup configuration is the config source.";
  908.                     }
  909.                     leaf url {
  910.                         if-feature url;
  911.                         type inet:uri;
  912.                         description
  913.                             "The URL-based configuration is the config source.";
  914.                     }
  915.                     anyxml config {
  916.                         description
  917.                             "Inline Config content: <config> element.  Represents
  918.                             an entire configuration datastore, not
  919.                             a subset of the running datastore.";
  920.                     }
  921.                 }
  922.             }
  923.         }
  924.     }
  925. }

<CODE ENDS>