path: root/doc/rfc/rfc8641.txt

Internet Engineering Task Force (IETF)                          A. Clemm
Request for Comments: 8641                                     Futurewei
Category: Standards Track                                        E. Voit
ISSN: 2070-1721                                            Cisco Systems
                                                          September 2019


        Subscription to YANG Notifications for Datastore Updates

Abstract

   This document describes a mechanism that allows subscriber
   applications to request a continuous and customized stream of updates
   from a YANG datastore.  Providing such visibility into updates
   enables new capabilities based on the remote mirroring and monitoring
   of configuration and operational state.

Status of This Memo

   This is an Internet Standards Track document.

   This document is a product of the Internet Engineering Task Force
   (IETF).  It represents the consensus of the IETF community.  It has
   received public review and has been approved for publication by the
   Internet Engineering Steering Group (IESG).  Further information on
   Internet Standards is available in Section 2 of RFC 7841.

   Information about the current status of this document, any errata,
   and how to provide feedback on it may be obtained at
   https://www.rfc-editor.org/info/rfc8641.





















Clemm & Voit                 Standards Track                    [Page 1]
^L
RFC 8641                        YANG-Push                 September 2019


Copyright Notice

   Copyright (c) 2019 IETF Trust and the persons identified as the
   document authors.  All rights reserved.

   This document is subject to BCP 78 and the IETF Trust's Legal
   Provisions Relating to IETF Documents
   (https://trustee.ietf.org/license-info) in effect on the date of
   publication of this document.  Please review these documents
   carefully, as they describe your rights and restrictions with respect
   to this document.  Code Components extracted from this document must
   include Simplified BSD License text as described in Section 4.e of
   the Trust Legal Provisions and are provided without warranty as
   described in the Simplified BSD License.

   This document may contain material from IETF Documents or IETF
   Contributions published or made publicly available before November
   10, 2008.  The person(s) controlling the copyright in some of this
   material may not have granted the IETF Trust the right to allow
   modifications of such material outside the IETF Standards Process.
   Without obtaining an adequate license from the person(s) controlling
   the copyright in such materials, this document may not be modified
   outside the IETF Standards Process, and derivative works of it may
   not be created outside the IETF Standards Process, except to format
   it for publication as an RFC or to translate it into languages other
   than English.

























Clemm & Voit                 Standards Track                    [Page 2]
^L
RFC 8641                        YANG-Push                 September 2019


Table of Contents

   1. Introduction ....................................................4
   2. Definitions .....................................................4
   3. Solution Overview ...............................................6
      3.1. Subscription Model .........................................6
      3.2. Negotiation of Subscription Policies .......................7
      3.3. On-Change Considerations ...................................8
      3.4. Reliability Considerations .................................9
      3.5. Data Encodings ............................................10
      3.6. Defining the Selection with a Datastore ...................11
      3.7. Streaming Updates .........................................12
      3.8. Subscription Management ...................................15
      3.9. Receiver Authorization ....................................16
      3.10. On-Change Notifiable Datastore Nodes .....................18
      3.11. Other Considerations .....................................18
   4. A YANG Data Model for Management of Datastore Push
      Subscriptions ..................................................20
      4.1. Overview ..................................................20
      4.2. Subscription Configuration ................................27
      4.3. YANG Notifications ........................................28
      4.4. YANG RPCs .................................................29
   5. YANG Module for YANG-Push ......................................34
   6. IANA Considerations ............................................51
   7. Security Considerations ........................................51
   8. References .....................................................53
      8.1. Normative References ......................................53
      8.2. Informative References ....................................55
   Appendix A. Subscription Errors ...................................56
     A.1. RPC Failures ...............................................56
     A.2. Failure Notifications ......................................57
   Acknowledgments ...................................................58
   Contributors ......................................................58
   Authors' Addresses ................................................58

















Clemm & Voit                 Standards Track                    [Page 3]
^L
RFC 8641                        YANG-Push                 September 2019


1.  Introduction

   Traditional approaches for providing visibility into managed entities
   from a remote system have been built on polling.  With polling, data
   is periodically requested and retrieved by a client from a server to
   stay up to date.  However, there are issues associated with polling-
   based management:

   o  Polling incurs significant latency.  This latency prohibits many
      types of applications.

   o  Polling cycles may be missed, and requests may be delayed or get
      lost -- often when the network is under stress and the need for
      the data is the greatest.

   o  Polling requests may undergo slight fluctuations, resulting in
      intervals of different lengths.  The resulting data is difficult
      to calibrate and compare.

   o  For applications that monitor for changes, many remote polling
      cycles place unwanted and ultimately wasteful load on the network,
      devices, and applications, particularly when changes occur only
      infrequently.

   A more effective alternative to polling is for an application to
   receive automatic and continuous updates from a targeted subset of a
   datastore.  Accordingly, there is a need for a service that
   (1) allows applications to subscribe to updates from a datastore and
   (2) enables the server (also referred to as the "publisher") to push
   and, in effect, stream those updates.  The requirements for such a
   service have been documented in [RFC7923].

   This document defines a corresponding solution that is built on
   top of [RFC8639].  Supplementing that work are YANG data model
   augmentations, extended RPCs, and new datastore-specific update
   notifications.  Transport options provided in [RFC8639] will work
   seamlessly with this solution.

2.  Definitions

   The key words "MUST", "MUST NOT", "REQUIRED", "SHALL", "SHALL NOT",
   "SHOULD", "SHOULD NOT", "RECOMMENDED", "NOT RECOMMENDED", "MAY", and
   "OPTIONAL" in this document are to be interpreted as described in
   BCP 14 [RFC2119] [RFC8174] when, and only when, they appear in all
   capitals, as shown here.






Clemm & Voit                 Standards Track                    [Page 4]
^L
RFC 8641                        YANG-Push                 September 2019


   This document uses the terminology defined in [RFC7950], [RFC8341],
   [RFC8342], and [RFC8639].  In addition, this document defines the
   following terms:

   o  Datastore node: A node in the instantiated YANG data tree
      associated with a datastore.  In this document, datastore nodes
      are often also simply referred to as "objects".

   o  Datastore node update: A data item containing the current value of
      a datastore node at the time the datastore node update was
      created, as well as the path to the datastore node.

   o  Datastore subscription: A subscription to a stream of datastore
      node updates.

   o  Datastore subtree: A datastore node and all its descendant
      datastore nodes.

   o  On-change subscription: A datastore subscription with updates that
      are triggered when changes in subscribed datastore nodes are
      detected.

   o  Periodic subscription: A datastore subscription with updates that
      are triggered periodically according to some time interval.

   o  Selection filter: Evaluation and/or selection criteria that may be
      applied against a targeted set of objects.

   o  Update record: A representation of one or more datastore node
      updates.  In addition, an update record may contain which type of
      update led to the datastore node update (e.g., whether the
      datastore node was added, changed, or deleted).  Also included in
      the update record may be other metadata, such as a subscription ID
      of the subscription for which the update record was generated.  In
      this document, update records are often also simply referred to as
      "updates".

   o  Update trigger: A mechanism that determines when an update record
      needs to be generated.

   o  YANG-Push: The subscription and push mechanism for datastore
      updates that is specified in this document.









Clemm & Voit                 Standards Track                    [Page 5]
^L
RFC 8641                        YANG-Push                 September 2019


3.  Solution Overview

   This document specifies a solution that provides a subscription
   service for updates from a datastore.  This solution supports dynamic
   as well as configured subscriptions to updates of datastore nodes.
   Subscriptions specify when notification messages (also referred to as
   "push updates") should be sent and what data to include in update
   records.  Datastore node updates are subsequently pushed from the
   publisher to the receiver per the terms of the subscription.

3.1.  Subscription Model

   YANG-Push subscriptions are defined using a YANG data model.  This
   model enhances the subscription model defined in [RFC8639] with
   capabilities that allow subscribers to subscribe to datastore node
   updates -- specifically, to specify the update triggers defining when
   to generate update records as well as what to include in an update
   record.  Key enhancements include:

   o  The specification of selection filters that identify targeted YANG
      datastore nodes and/or datastore subtrees for which updates are to
      be pushed.

   o  The specification of update policies that contain conditions that
      trigger the generation and pushing of new update records.  There
      are two types of subscriptions, distinguished by how updates are
      triggered: periodic and on-change.

      *  For periodic subscriptions, the update trigger is specified by
         two parameters that define when updates are to be pushed.
         These parameters are (1) the period interval with which to
         report updates and (2) an "anchor-time", i.e., a reference
         point in time that can be used to calculate at which points in
         time periodic updates need to be assembled and sent.

      *  For on-change subscriptions, an update trigger occurs whenever
         a change in the subscribed information is detected.  The
         following additional parameters are included:

         +  "dampening-period": In an on-change subscription, detected
            object changes should be sent as quickly as possible.
            However, it may be undesirable to send a rapid series of
            object changes.  Such behavior has the potential to exhaust
            resources in the publisher or receiver.  In order to protect
            against this type of scenario, a dampening period MAY be
            used to specify the interval that has to pass before
            successive update records for the same subscription are
            generated for a receiver.  The dampening period collectively



Clemm & Voit                 Standards Track                    [Page 6]
^L
RFC 8641                        YANG-Push                 September 2019


            applies to the set of all datastore nodes selected by a
            single subscription.  This means that when there is a change
            to one or more subscribed objects, an update record
            containing those objects is created immediately (when no
            dampening period is in effect) or at the end of a dampening
            period (when a dampening period is in fact in effect).  If
            multiple changes to a single object occur during a dampening
            period, only the value that is in effect at the time when
            the update record is created is included.  The dampening
            period goes into effect every time the assembly of an update
            record is completed.

         +  "change-type": This parameter can be used to reduce the
            types of datastore changes for which updates are sent (e.g.,
            you might only send an update when an object is created or
            deleted, but not when an object value changes).

         +  "sync-on-start": This parameter defines whether or not a
            complete "push-update" (Section 3.7) of all subscribed data
            will be sent at the beginning of a subscription.  Such early
            synchronization establishes the frame of reference for
            subsequent updates.

   o  An encoding (using anydata) for the contents of periodic and
      on-change push updates.

3.2.  Negotiation of Subscription Policies

   A dynamic subscription request SHOULD be declined if a publisher
   determines that it may be unable to provide update records meeting
   the terms of an "establish-subscription" or "modify-subscription" RPC
   request.  In this case, a subscriber may quickly follow up with a new
   RPC request using different parameters.

   Random guessing of different parameters by a subscriber is to be
   discouraged.  Therefore, in order to minimize the number of
   subscription iterations between subscriber and publisher, a dynamic
   subscription supports a simple negotiation between subscribers and
   publishers for subscription parameters.  This negotiation is in the
   form of supplemental information that should be inserted into error
   responses to a failed RPC request.  This returned error response
   information, when considered, should increase the likelihood of
   success for subsequent RPC requests.  Such hints include suggested
   periodic time intervals, acceptable dampening periods, and size
   estimates for the number of objects that would be returned from a
   proposed selection filter.  However, there are no guarantees that
   subsequent requests that consider these hints will be accepted.




Clemm & Voit                 Standards Track                    [Page 7]
^L
RFC 8641                        YANG-Push                 September 2019


3.3.  On-Change Considerations

   On-change subscriptions allow receivers to receive updates whenever
   changes to targeted objects occur.  As such, on-change subscriptions
   are particularly effective for data that changes infrequently but for
   which applications need to be quickly notified, with minimal delay,
   whenever a change does occur.

   On-change subscriptions tend to be more difficult to implement than
   periodic subscriptions.  Accordingly, on-change subscriptions may not
   be supported by all implementations or for every object.

   Whether or not to accept or reject on-change subscription requests
   when the scope of the subscription contains objects for which
   on-change is not supported is up to the publisher implementation.  A
   publisher MAY accept an on-change subscription even when the scope of
   the subscription contains objects for which on-change is not
   supported.  In that case, updates are sent only for those objects
   within the scope of the subscription that do support on-change
   updates, whereas other objects are excluded from update records, even
   if their values change.  In order for a subscriber to determine
   whether objects support on-change subscriptions, objects are marked
   accordingly on a publisher.  Accordingly, when subscribing, it is the
   responsibility of the subscriber to ensure that it is aware of which
   objects support on-change and which do not.  For more on how objects
   are so marked, see Section 3.10.

   Alternatively, a publisher MAY decide to simply reject an on-change
   subscription if the scope of the subscription contains objects for
   which on-change is not supported.  In the case of a configured
   subscription, the publisher MAY suspend the subscription.

   To avoid flooding receivers with repeated updates for subscriptions
   containing fast-changing objects or objects with oscillating values,
   an on-change subscription allows for the definition of a dampening
   period.  Once an update record for a given object is generated, no
   other updates for this particular subscription will be created until
   the end of the dampening period.  Values sent at the end of the
   dampening period are the values that are current at the end of the
   dampening period of all changed objects.  Changed objects include
   those objects that were deleted or newly created during that
   dampening period.  If an object has returned to its original value
   (or even has been created and then deleted) during the dampening
   period, that value (and not the interim change) will still be sent.
   This will indicate that churn is occurring on that object.






Clemm & Voit                 Standards Track                    [Page 8]
^L
RFC 8641                        YANG-Push                 September 2019


   On-change subscriptions can be refined to let users subscribe only to
   certain types of changes.  For example, a subscriber might only want
   object creations and deletions, but not modifications of object
   values.

   Putting it all together, the conceptual process for creating an
   update record as part of an on-change subscription is as follows:

   1.  Just before a change, or at the start of a dampening period,
       evaluate any filtering and any access control rules to ensure
       that a receiver is authorized to view all subscribed datastore
       nodes (filtering out any nodes for which this is not the case).
       The result is a set "A" of datastore nodes and subtrees.

   2.  Just after a change, or at the end of a dampening period,
       evaluate any filtering and any (possibly new) access control
       rules.  The result is a set "B" of datastore nodes and subtrees.

   3.  Construct an update record, which takes the form of a YANG Patch
       record [RFC8072] for going from A to B.

   4.  If there were any changes made between A and B that canceled each
       other out, insert into the YANG Patch record the last change
       made, even if the new value is no different from the original
       value (since changes that were made in the interim were canceled
       out).  If the changes involve creating a new datastore node and
       then deleting it, the YANG Patch record will indicate the
       deletion of the datastore node.  Similarly, if the changes
       involve deleting a new datastore node and then recreating it,
       the YANG Patch record will indicate the creation of the
       datastore node.

   5.  If the resulting YANG Patch record is non-empty, send it to the
       receiver.

   Note: In cases where a subscriber wants to have separate dampening
   periods for different objects, the subscriber has the option to
   create multiple subscriptions with different selection filters.

3.4.  Reliability Considerations

   A subscription to updates from a datastore is intended to obviate the
   need for polling.  However, in order to do so, it is critical that
   subscribers can rely on the subscription and have confidence that
   they will indeed receive the subscribed updates without having to
   worry about updates being silently dropped.  In other words, a
   subscription constitutes a promise on the side of the publisher to
   provide the receivers with updates per the terms of the subscription.



Clemm & Voit                 Standards Track                    [Page 9]
^L
RFC 8641                        YANG-Push                 September 2019


   Now, there are many reasons why a publisher may at some point no
   longer be able to fulfill the terms of the subscription, even if the
   subscription had been initiated in good faith.  For example, the
   volume of datastore nodes may be larger than anticipated, the
   interval may prove too short to send full updates in rapid
   succession, or an internal problem may prevent objects from being
   collected.  For this reason, the solution defined in this document
   (1) mandates that a publisher notify receivers immediately and
   reliably whenever it encounters a situation in which it is unable to
   keep the terms of the subscription and (2) provides the publisher
   with the option to suspend the subscription in such a case.  This
   includes indicating the fact that an update is incomplete as part of
   a "push-update" or "push-change-update" notification, as well as
   emitting a "subscription-suspended" notification as applicable.  This
   is described further in Section 3.11.1.

   A publisher SHOULD reject a request for a subscription if it is
   unlikely that the publisher will be able to fulfill the terms of that
   subscription request.  In such cases, it is preferable to have a
   subscriber request a less resource-intensive subscription than to
   deal with frequently degraded behavior.

   The solution builds on [RFC8639].  As defined therein, any loss of an
   underlying transport connection will be detected and result in
   subscription termination (in the case of dynamic subscriptions) or
   suspension (in the case of configured subscriptions), ensuring that
   situations where the loss of update notifications would go unnoticed
   will not occur.

3.5.  Data Encodings

3.5.1.  Periodic Subscriptions

   In a periodic subscription, the data included as part of an update
   record corresponds to data that could have been read using a
   retrieval operation.

3.5.2.  On-Change Subscriptions

   In an on-change subscription, update records need to indicate not
   only values of changed datastore nodes but also the types of changes
   that occurred since the last update.  Therefore, encoding rules for
   data in on-change updates will generally follow YANG Patch operations
   as specified in [RFC8072].  The YANG Patch operations will describe
   what needs to be applied to the earlier state reported by the
   preceding update in order to result in the now-current state.  Note
   that objects referred to in an update are not limited to




Clemm & Voit                 Standards Track                   [Page 10]
^L
RFC 8641                        YANG-Push                 September 2019


   configuration data but can include any objects (including operational
   data), whereas [RFC8072] patches apply only to configuration data in
   configuration datastores.

   A publisher indicates the type of change to a datastore node using
   the different YANG Patch operations: the "create" operation is used
   for newly created objects (except entries in a user-ordered list),
   the "delete" operation is used for deleted objects (including in
   user-ordered lists), the "replace" operation is used when only the
   object value changes, the "insert" operation is used when a new entry
   is inserted in a list, and the "move" operation is used when an
   existing entry in a user-ordered list is moved.

   However, a patch must be able to do more than just describe the delta
   from the previous state to the current state.  As per Section 3.3, it
   must also be able to identify whether transient changes have occurred
   on an object during a dampening period.  To support this, it is valid
   to encode a YANG Patch operation so that its application would result
   in no change between the previous state and the current state.  This
   indicates that some churn has occurred on the object.  An example of
   this would be a patch that indicates a "create" operation for a
   datastore node where the receiver believes one already exists or a
   "replace" operation that replaces a previous value with the same
   value.  Note that this means that the "create" and "delete" errors as
   described in [RFC8072], Section 2.5 are not errors in the case of
   YANG-Push (i.e., they are considered valid operations for YANG-Push).

3.6.  Defining the Selection with a Datastore

   A subscription must specify both the selection filters and the
   datastore against which these selection filters will be applied.
   This information is used to choose and subsequently push data from
   the publisher's datastore to the receivers.

   Only a single selection filter can be applied to a subscription at a
   time.  An RPC request proposing a new selection filter replaces any
   existing filter.  The following selection filter types are included
   in the YANG-Push data model and may be applied against a datastore:

   o  subtree: A subtree selection filter identifies one or more
      datastore subtrees.  When specified, update records will only come
      from the datastore nodes of selected datastore subtree(s).  The
      syntax and semantics correspond to those specified in [RFC6241],
      Section 6.







Clemm & Voit                 Standards Track                   [Page 11]
^L
RFC 8641                        YANG-Push                 September 2019


   o  xpath: An "xpath" selection filter is an XPath expression that
      returns a node set.  (XPath is a query language for selecting
      nodes in an XML document; see [XPATH] for details.)  When
      specified, updates will only come from the selected datastore
      nodes.

   These filters are intended to be used as selectors that define which
   objects are within the scope of a subscription.  A publisher MUST
   support at least one type of selection filter.

   XPath itself provides powerful filtering constructs, and care must be
   used in filter definition.  Consider an XPath filter that only passes
   a datastore node when an interface is up.  It is up to the receiver
   to understand the implications of the presence or absence of objects
   in each update.

   When the set of selection-filtering criteria is applied for a
   periodic subscription, these criteria are applied whenever a periodic
   update record is constructed, and only datastore nodes that pass the
   filter and to which a receiver has access are provided to that
   receiver.  If the same filtering criteria are applied to an on-change
   subscription, only the subset of those datastore nodes supporting
   on-change is provided.  A datastore node that doesn't support
   on-change is never sent as part of an on-change subscription's
   "push-update" or "push-change-update" (Section 3.7).

3.7.  Streaming Updates

   Contrary to traditional data retrieval requests, datastore
   subscription enables an unbounded series of update records to be
   streamed over time.  Two generic YANG notifications for update
   records have been defined for this scenario: "push-update" and
   "push-change-update".

   A "push-update" notification defines a complete, filtered update of
   the datastore per the terms of a subscription.  This type of YANG
   notification is used for continuous updates of periodic
   subscriptions.  A "push-update" notification can also be used for the
   on-change subscriptions in two cases.  First, it MUST be used as the
   initial "push-update" if there is a need to synchronize the receiver
   at the start of a new subscription.  Second, it MAY be sent if the
   publisher later chooses to resync an on-change subscription.  The
   "push-update" update record contains an instantiated datastore
   subtree with all of the subscribed contents.  The content of the
   update record is equivalent to the contents that would be obtained
   had the same data been explicitly retrieved using a datastore
   retrieval operation using the same transport with the same filters
   applied.



Clemm & Voit                 Standards Track                   [Page 12]
^L
RFC 8641                        YANG-Push                 September 2019


   A "push-change-update" notification is the most common type of update
   for on-change subscriptions.  The update record in this case contains
   the set of changes that datastore nodes have undergone since the last
   notification message.  In other words, this indicates which datastore
   nodes have been created, have been deleted, or have had changes to
   their values.  In cases where multiple changes have occurred over the
   course of a dampening period and the object has not been deleted, the
   object's most current value is reported.  (In other words, for each
   object, only one change is reported, not its entire history.  Doing
   so would defeat the purpose of the dampening period.)

   "push-update" and "push-change-update" are encoded and placed in
   notification messages and are ultimately queued for egress over the
   specified transport.

   Figure 1 provides an example of a notification message for a
   subscription tracking the operational status of a single Ethernet
   interface (per [RFC8343]).  This notification message is encoded XML
   [W3C.REC-xml-20081126] over the Network Configuration Protocol
   (NETCONF) as per [RFC8640].

  <notification xmlns="urn:ietf:params:xml:ns:netconf:notification:1.0">
   <eventTime>2017-10-25T08:00:11.22Z</eventTime>
   <push-update xmlns="urn:ietf:params:xml:ns:yang:ietf-yang-push">
     <id>1011</id>
     <datastore-contents>
        <interfaces xmlns="urn:ietf:params:xml:ns:yang:ietf-interfaces">
         <interface>
           <name>eth0</name>
           <oper-status>up</oper-status>
         </interface>
       </interfaces>
     </datastore-contents>
   </push-update>
  </notification>

                          Figure 1: Push Example














Clemm & Voit                 Standards Track                   [Page 13]
^L
RFC 8641                        YANG-Push                 September 2019


   Figure 2 provides an example of an on-change notification message for
   the same subscription.

  <notification xmlns="urn:ietf:params:xml:ns:netconf:notification:1.0">
   <eventTime>2017-10-25T08:22:33.44Z</eventTime>
   <push-change-update
        xmlns="urn:ietf:params:xml:ns:yang:ietf-yang-push">
     <id>89</id>
     <datastore-changes>
       <yang-patch>
         <patch-id>0</patch-id>
         <edit>
           <edit-id>edit1</edit-id>
           <operation>replace</operation>
           <target>/ietf-interfaces:interfaces</target>
           <value>
             <interfaces
                  xmlns="urn:ietf:params:xml:ns:yang:ietf-interfaces">
               <interface>
                 <name>eth0</name>
                 <oper-status>down</oper-status>
               </interface>
             </interfaces>
           </value>
         </edit>
       </yang-patch>
     </datastore-changes>
   </push-change-update>
  </notification>

       Figure 2: Push Example for an On-Change Notification Message

   Of note in the above example is the "patch-id" with a value of "0".
   Per [RFC8072], the "patch-id" is an arbitrary string.  With
   YANG-Push, the publisher SHOULD put into the "patch-id" a counter
   starting at "0" that increments with every "push-change-update"
   generated for a subscription.  If used as a counter, this counter
   MUST be reset to "0" any time a resynchronization occurs (i.e., with
   the sending of a "push-update").  Also, if used as a counter, the
   counter MUST be reset to "0" after passing a maximum value of
   "4294967295" (i.e., the maximum value that can be represented using
   the uint32 data type).  Such a mechanism allows easy identification
   of lost or out-of-sequence update records.








Clemm & Voit                 Standards Track                   [Page 14]
^L
RFC 8641                        YANG-Push                 September 2019


3.8.  Subscription Management

   The RPCs defined in [RFC8639] have been enhanced to support datastore
   subscription negotiation.  Also, new error codes have been added that
   are able to indicate why a datastore subscription attempt has failed,
   along with new yang-data that MAY be used to include details on input
   parameters that might result in a successful subsequent RPC
   invocation.

   The establishment or modification of a datastore subscription can be
   rejected for multiple reasons, including a subtree request that is
   too large or the inability of the publisher to push update records as
   frequently as requested.  In such cases, no subscription is
   established.  Instead, a subscription result that includes the reason
   for the failure is returned as part of the RPC response.  As part of
   this response, a set of alternative subscription parameters MAY be
   returned that would likely have resulted in acceptance of the
   subscription request.  The subscriber may consider including such
   parameters in future subscription attempts.

   In the case of a rejected request for establishment of a datastore
   subscription, if there are hints, the hints SHOULD be transported in
   a yang-data "establish-subscription-datastore-error-info" container
   inserted into the RPC error response, in lieu of the "establish-
   subscription-stream-error-info" that is inserted in the case of a
   stream subscription.

   Figure 3 shows a tree diagram for "establish-subscription-datastore-
   error-info".  All tree diagrams used in this document follow the
   notation defined in [RFC8340].

          yang-data establish-subscription-datastore-error-info
            +--ro establish-subscription-datastore-error-info
               +--ro reason?                identityref
               +--ro period-hint?           centiseconds
               +--ro filter-failure-hint?   string
               +--ro object-count-estimate? uint32
               +--ro object-count-limit?    uint32
               +--ro kilobytes-estimate?    uint32
               +--ro kilobytes-limit?       uint32

   Figure 3: "establish-subscription-datastore-error-info" Tree Diagram









Clemm & Voit                 Standards Track                   [Page 15]
^L
RFC 8641                        YANG-Push                 September 2019


   Similarly, in the case of a rejected request for modification of a
   datastore subscription, if there are hints, the hints SHOULD be
   transported in a yang-data "modify-subscription-datastore-error-info"
   container inserted into the RPC error response, in lieu of the
   "modify-subscription-stream-error-info" that is inserted in the case
   of a stream subscription.

   Figure 4 shows a tree diagram for "modify-subscription-datastore-
   error-info".

          yang-data modify-subscription-datastore-error-info
            +--ro modify-subscription-datastore-error-info
               +--ro reason?                identityref
               +--ro period-hint?           centiseconds
               +--ro filter-failure-hint?   string
               +--ro object-count-estimate? uint32
               +--ro object-count-limit?    uint32
               +--ro kilobytes-estimate?    uint32
               +--ro kilobytes-limit?       uint32

     Figure 4: "modify-subscription-datastore-error-info" Tree Diagram

3.9.  Receiver Authorization

   A receiver of subscription data MUST only be sent updates for which
   it has proper authorization.  A publisher MUST ensure that no
   unauthorized data is included in push updates.  To do so, it needs to
   apply all corresponding checks applicable at the time of a specific
   pushed update and, if necessary, silently remove any unauthorized
   data from datastore subtrees.  This enables YANG data that is pushed
   based on subscriptions to be authorized in a way that is equivalent
   to a regular data retrieval ("get") operation.

   Each "push-update" and "push-change-update" MUST have access control
   applied, as depicted in Figure 5.  This includes validating that read
   access is permitted for any new objects selected since the last
   notification message was sent to a particular receiver.  A publisher
   MUST silently omit data nodes from the results that the client is not
   authorized to see.  To accomplish this, implementations SHOULD apply
   the conceptual authorization model of [RFC8341], specifically
   Section 3.2.4, extended to apply analogously to data nodes included
   in notifications, not just <rpc-reply> messages sent in response to
   <get> and <get-config> requests.








Clemm & Voit                 Standards Track                   [Page 16]
^L
RFC 8641                        YANG-Push                 September 2019


                         +-----------------+      +--------------------+
     push-update or -->  | datastore node  |  yes | add datastore node |
    push-change-update   | access allowed? | ---> | to update record   |
                         +-----------------+      +--------------------+

                 Figure 5: Access Control for Push Updates

   A publisher MUST allow for the possibility that a subscription's
   selection filter references nonexistent data or data that a receiver
   is not allowed to access.  Such support permits a receiver the
   ability to monitor the entire lifecycle of some datastore tree
   without needing to explicitly enumerate every individual datastore
   node.  If, after access control has been applied, there are no
   objects remaining in an update record, then the effect varies given
   if the subscription is a periodic or on-change subscription.  For a
   periodic subscription, an empty "push-update" notification MUST be
   sent, so that clients do not get confused into thinking that an
   update was lost.  For an on-change subscription, a "push-update"
   notification MUST NOT be sent, so that clients remain unaware of
   changes made to nodes they don't have read-access for.  By the same
   token, changes to objects that are filtered MUST NOT affect any
   dampening intervals.

   A publisher MAY choose to reject an "establish-subscription" request
   that selects nonexistent data or data that a receiver is not allowed
   to access.  The error identity "unchanging-selection" SHOULD be
   returned as the reason for the rejection.  In addition, a publisher
   MAY choose to terminate a dynamic subscription or suspend a
   configured receiver when the authorization privileges of a receiver
   change or the access controls for subscribed objects change.  In that
   case, the publisher SHOULD include the error identity "unchanging-
   selection" as the reason when sending the "subscription-terminated"
   or "subscription-suspended" notification, respectively.  Such a
   capability enables the publisher to avoid having to support
   continuous and total filtering of a subscription's content for every
   update record.  It also reduces the possibility of leakage of
   access-controlled objects.

   If read access into previously accessible nodes has been lost due to
   a receiver permissions change, this SHOULD be reported as a patch
   "delete" operation for on-change subscriptions.  If not capable of
   handling such receiver permission changes with such a "delete",
   publisher implementations MUST force dynamic subscription
   re-establishment or configured subscription reinitialization so that
   appropriate filtering is installed.






Clemm & Voit                 Standards Track                   [Page 17]
^L
RFC 8641                        YANG-Push                 September 2019


3.10.  On-Change Notifiable Datastore Nodes

   In some cases, a publisher supporting on-change notifications may not
   be able to push on-change updates for some object types.  Reasons for
   this might be that the value of the datastore node changes frequently
   (e.g., the in-octets counter as defined in [RFC8343]), small object
   changes are frequent and meaningless (e.g., a temperature gauge
   changing 0.1 degrees), or the implementation is not capable of
   on-change notification for a particular object.

   In those cases, it will be important for client applications to have
   a way to identify for which objects on-change notifications are
   supported and for which ones they are not supported.  Otherwise,
   client applications will have no way of knowing whether they can
   indeed rely on their on-change subscription to provide them with the
   change updates that they are interested in.  In other words, if
   implementations do not provide a solution and do not support
   comprehensive on-change notifiability, clients of those
   implementations will have no way of knowing what their on-change
   subscription actually covers.

   Implementations are therefore strongly advised to provide a solution
   to this problem.  One solution might involve making discoverable to
   clients which objects are on-change notifiable, specified using
   another YANG data model.  Such a solution is specified in
   [Yang-Push-Notif-Cap].  Until this solution is standardized,
   implementations SHOULD provide their own solution.

3.11.  Other Considerations

3.11.1.  Robustness and Reliability

   It is important that updates as discussed in this document, and
   on-change updates in particular, do not get lost.  If the loss of an
   update is unavoidable, it is critical that the receiver be notified
   accordingly.

   Update records for a single subscription MUST NOT be resequenced
   prior to transport.












Clemm & Voit                 Standards Track                   [Page 18]
^L
RFC 8641                        YANG-Push                 September 2019


   It is conceivable that, under certain circumstances, a publisher will
   recognize that it is unable to include in an update record the full
   set of objects desired per the terms of a subscription.  In this
   case, the publisher MUST act as follows.

   o  The publisher MUST set the "incomplete-update" flag on any update
      record that is known to be missing information.

   o  The publisher MAY choose to suspend the subscription as per
      [RFC8639].  If the publisher does not create an update record at
      all, it MUST suspend the subscription.

   o  When resuming an on-change subscription, the publisher SHOULD
      generate a complete patch from the previous update record.  If
      this is not possible and the "sync-on-start" option is set to
      "true" for the subscription, then the full datastore contents MAY
      be sent via a "push-update" instead (effectively replacing the
      previous contents).  If neither scenario above is possible, then
      an "incomplete-update" flag MUST be included on the next
      "push-change-update".

   Note: It is perfectly acceptable to have a series of "push-change-
   update" notifications (and even "push-update" notifications) serially
   queued at the transport layer awaiting transmission.  It is not
   required for the publisher to merge pending update records sent at
   the same time.

   On the receiver side, what action to take when a record with an
   "incomplete-update" flag is received depends on the application.  It
   could simply choose to wait and do nothing.  It could choose to
   resync, actively retrieving all subscribed information.  It could
   also choose to tear down the subscription and start a new one,
   perhaps with a smaller scope that contains fewer objects.

3.11.2.  Publisher Capacity

   It is far preferable to decline a subscription request than to accept
   such a request when it cannot be met.

   Whether or not a subscription can be supported will be determined by
   a combination of several factors, such as the subscription update
   trigger (on-change or periodic), the period in which to report
   changes (one-second periods will consume more resources than one-hour
   periods), the amount of data in the datastore subtree that is being
   subscribed to, and the number and combination of other subscriptions
   that are concurrently being serviced.





Clemm & Voit                 Standards Track                   [Page 19]
^L
RFC 8641                        YANG-Push                 September 2019


4.  A YANG Data Model for Management of Datastore Push Subscriptions

4.1.  Overview

   The YANG data model for datastore push subscriptions is depicted in
   Figures 6 through 9.  The tree diagram that is used follows the
   notation defined in [RFC8340].  New schema objects defined here
   (i.e., beyond those from [RFC8639]) are identified with "yp".  For
   the reader's convenience, in order to compact the tree
   representation, some nodes that are defined in the ietf-subscribed-
   notifications YANG module [RFC8639] and therefore are not essential
   to the understanding of the data model defined here have been
   removed.  This is indicated by "..." in the diagram where applicable.

   Because the tree diagram is quite large, its depiction is broken up
   into four figures.  Figure 6 depicts the augmentations that are
   introduced in YANG module ietf-yang-push to the subscription
   configuration specified in YANG module ietf-subscribed-notifications.

































Clemm & Voit                 Standards Track                   [Page 20]
^L
RFC 8641                        YANG-Push                 September 2019


   module: ietf-subscribed-notifications
     ...
     +--rw filters
     |  ...
     |  +--rw yp:selection-filter* [filter-id]
     |     +--rw yp:filter-id                   string
     |     +--rw (yp:filter-spec)?
     |        +--:(yp:datastore-subtree-filter)
     |        |  +--rw yp:datastore-subtree-filter?   <anydata>
     |        |          {sn:subtree}?
     |        +--:(yp:datastore-xpath-filter)
     |           +--rw yp:datastore-xpath-filter?     yang:xpath1.0
     |                   {sn:xpath}?
     +--rw subscriptions
        +--rw subscription* [id]
           |  ...
           +--rw (target)
           |  +--:(stream)
           |  |   ...
           |  +--:(yp:datastore)
           |     +--rw yp:datastore                     identityref
           |     +--rw (yp:selection-filter)?
           |        +--:(yp:by-reference)
           |        |  +--rw yp:selection-filter-ref
           |        |          selection-filter-ref
           |        +--:(yp:within-subscription)
           |           +--rw (yp:filter-spec)?
           |              +--:(yp:datastore-subtree-filter)
           |              |  +--rw yp:datastore-subtree-filter?
           |              |          <anydata> {sn:subtree}?
           |              +--:(yp:datastore-xpath-filter)
           |                 +--rw yp:datastore-xpath-filter?
           |                         yang:xpath1.0 {sn:xpath}?
           | ...
           +--rw (yp:update-trigger)
              +--:(yp:periodic)
              |  +--rw yp:periodic!
              |     +--rw yp:period         centiseconds
              |     +--rw yp:anchor-time?   yang:date-and-time
              +--:(yp:on-change) {on-change}?
                 +--rw yp:on-change!
                    +--rw yp:dampening-period?   centiseconds
                    +--rw yp:sync-on-start?      boolean
                    +--rw yp:excluded-change*    change-type

        Figure 6: Data Model Structure: Subscription Configuration





Clemm & Voit                 Standards Track                   [Page 21]
^L
RFC 8641                        YANG-Push                 September 2019


   Figure 7 depicts the augmentations of YANG module ietf-yang-push made
   to RPCs specified in YANG module ietf-subscribed-notifications
   [RFC8639].  Specifically, these augmentations concern the "establish-
   subscription" and "modify-subscription" RPCs, which are augmented
   with parameters that are needed to specify datastore push
   subscriptions.

     rpcs:
       +---x establish-subscription
       |  +---w input
       |  |  ...
       |  |  +---w (target)
       |  |  |  +--:(stream)
       |  |  |  |  ...
       |  |  |  +--:(yp:datastore)
       |  |  |     +---w yp:datastore                   identityref
       |  |  |     +---w (yp:selection-filter)?
       |  |  |        +--:(yp:by-reference)
       |  |  |        |  +---w yp:selection-filter-ref
       |  |  |        |          selection-filter-ref
       |  |  |        +--:(yp:within-subscription)
       |  |  |           +---w (yp:filter-spec)?
       |  |  |              +--:(yp:datastore-subtree-filter)
       |  |  |              |  +---w yp:datastore-subtree-filter?
       |  |  |              |          <anydata> {sn:subtree}?
       |  |  |              +--:(yp:datastore-xpath-filter)
       |  |  |                 +---w yp:datastore-xpath-filter?
       |  |  |                         yang:xpath1.0 {sn:xpath}?
       |  |  | ...
       |  |  +---w (yp:update-trigger)
       |  |     +--:(yp:periodic)
       |  |     |  +---w yp:periodic!
       |  |     |     +---w yp:period         centiseconds
       |  |     |     +---w yp:anchor-time?   yang:date-and-time
       |  |     +--:(yp:on-change) {on-change}?
       |  |        +---w yp:on-change!
       |  |           +---w yp:dampening-period?   centiseconds
       |  |           +---w yp:sync-on-start?      boolean
       |  |           +---w yp:excluded-change*    change-type
       |  +--ro output
       |     +--ro id                            subscription-id
       |     +--ro replay-start-time-revision?   yang:date-and-time
       |             {replay}?








Clemm & Voit                 Standards Track                   [Page 22]
^L
RFC 8641                        YANG-Push                 September 2019


       +---x modify-subscription
       |  +---w input
       |     ...
       |     +---w (target)
       |     |  ...
       |     |  +--:(yp:datastore)
       |     |     +---w yp:datastore                   identityref
       |     |     +---w (yp:selection-filter)?
       |     |        +--:(yp:by-reference)
       |     |        |  +---w yp:selection-filter-ref
       |     |        |          selection-filter-ref
       |     |        +--:(yp:within-subscription)
       |     |           +---w (yp:filter-spec)?
       |     |              +--:(yp:datastore-subtree-filter)
       |     |              |  +---w yp:datastore-subtree-filter?
       |     |              |          <anydata> {sn:subtree}?
       |     |              +--:(yp:datastore-xpath-filter)
       |     |                 +---w yp:datastore-xpath-filter?
       |     |                         yang:xpath1.0 {sn:xpath}?
       |     | ...
       |     +---w (yp:update-trigger)
       |        +--:(yp:periodic)
       |        |  +---w yp:periodic!
       |        |     +---w yp:period         centiseconds
       |        |     +---w yp:anchor-time?   yang:date-and-time
       |        +--:(yp:on-change) {on-change}?
       |           +---w yp:on-change!
       |              +---w yp:dampening-period?   centiseconds
       +---x delete-subscription
       |  ...
       +---x kill-subscription
          ...

     yang-data (for placement into RPC error responses)
       ...

                   Figure 7: Data Model Structure: RPCs














Clemm & Voit                 Standards Track                   [Page 23]
^L
RFC 8641                        YANG-Push                 September 2019


   Figure 8 depicts augmentations of YANG module ietf-yang-push to the
   notifications that are specified in YANG module ietf-subscribed-
   notifications.  The augmentations allow the inclusion of subscription
   configuration parameters that are specific to datastore push
   subscriptions as part of "subscription-started" and "subscription-
   modified" notifications.

     notifications:
       +---n replay-completed {replay}?
       |  ...
       +---n subscription-completed
       |  ...
       +---n subscription-started {configured}?
       |  |  ...
       |  +--ro (target)
       |  |  ...
       |  |  +--:(yp:datastore)
       |  |     +--ro yp:datastore                   identityref
       |  |     +--ro (yp:selection-filter)?
       |  |        +--:(yp:by-reference)
       |  |        |  +--ro yp:selection-filter-ref
       |  |        |          selection-filter-ref
       |  |        +--:(yp:within-subscription)
       |  |           +--ro (yp:filter-spec)?
       |  |              +--:(yp:datastore-subtree-filter)
       |  |              |  +--ro yp:datastore-subtree-filter?
       |  |              |          <anydata> {sn:subtree}?
       |  |              +--:(yp:datastore-xpath-filter)
       |  |                 +--ro yp:datastore-xpath-filter?
       |  |                         yang:xpath1.0 {sn:xpath}?
       |  ...
       |  +--ro (yp:update-trigger)
       |     +--:(yp:periodic)
       |     |  +--ro yp:periodic!
       |     |     +--ro yp:period         centiseconds
       |     |     +--ro yp:anchor-time?   yang:date-and-time
       |     +--:(yp:on-change) {on-change}?
       |        +--ro yp:on-change!
       |           +--ro yp:dampening-period?   centiseconds
       |           +--ro yp:sync-on-start?      boolean
       |           +--ro yp:excluded-change*    change-type
       +---n subscription-resumed
       |  ...








Clemm & Voit                 Standards Track                   [Page 24]
^L
RFC 8641                        YANG-Push                 September 2019


       +---n subscription-modified
       |  ...
       |  +--ro (target)
       |  |  |  ...
       |  |  +--:(yp:datastore)
       |  |     +--ro yp:datastore                   identityref
       |  |     +--ro (yp:selection-filter)?
       |  |        +--:(yp:by-reference)
       |  |        |  +--ro yp:selection-filter-ref
       |  |        |          selection-filter-ref
       |  |        +--:(yp:within-subscription)
       |  |           +--ro (yp:filter-spec)?
       |  |              +--:(yp:datastore-subtree-filter)
       |  |              |  +--ro yp:datastore-subtree-filter?
       |  |              |          <anydata> {sn:subtree}?
       |  |              +--:(yp:datastore-xpath-filter)
       |  |                 +--ro yp:datastore-xpath-filter?
       |  |                         yang:xpath1.0 {sn:xpath}?
       |  ...
       |  +--ro (yp:update-trigger)?
       |     +--:(yp:periodic)
       |     |  +--ro yp:periodic!
       |     |     +--ro yp:period         centiseconds
       |     |     +--ro yp:anchor-time?   yang:date-and-time
       |     +--:(yp:on-change) {on-change}?
       |        +--ro yp:on-change!
       |           +--ro yp:dampening-period?    centiseconds
       |           +--ro yp:sync-on-start?       boolean
       |           +--ro yp:excluded-change*     change-type
       +---n subscription-terminated
       |  ...
       +---n subscription-suspended
          ...

               Figure 8: Data Model Structure: Notifications
















Clemm & Voit                 Standards Track                   [Page 25]
^L
RFC 8641                        YANG-Push                 September 2019


   Finally, Figure 9 depicts the parts of YANG module ietf-yang-push
   that are newly introduced in this document (i.e., that are not simply
   augmentations of another YANG module).

   module: ietf-yang-push

     rpcs:
       +---x resync-subscription {on-change}?
          +---w input
             +---w id    sn:subscription-id

     yang-data (for placement into RPC error responses):
       +-- resync-subscription-error
       |  +--ro reason?                   identityref
       |  +--ro period-hint?              centiseconds
       |  +--ro filter-failure-hint?      string
       |  +--ro object-count-estimate?    uint32
       |  +--ro object-count-limit?       uint32
       |  +--ro kilobytes-estimate?       uint32
       |  +--ro kilobytes-limit?          uint32
       +-- establish-subscription-error-datastore
       |  +--ro reason?                   identityref
       |  +--ro period-hint?              centiseconds
       |  +--ro filter-failure-hint?      string
       |  +--ro object-count-estimate?    uint32
       |  +--ro object-count-limit?       uint32
       |  +--ro kilobytes-estimate?       uint32
       |  +--ro kilobytes-limit?          uint32
       +-- modify-subscription-error-datastore
          +--ro reason?                   identityref
          +--ro period-hint?              centiseconds
          +--ro filter-failure-hint?      string
          +--ro object-count-estimate?    uint32
          +--ro object-count-limit?       uint32
          +--ro kilobytes-estimate?       uint32
          +--ro kilobytes-limit?          uint32















Clemm & Voit                 Standards Track                   [Page 26]
^L
RFC 8641                        YANG-Push                 September 2019


        notifications:
          +---n push-update
          |  +--ro id?                   sn:subscription-id
          |  +--ro datastore-contents?   <anydata>
          |  +--ro incomplete-update?    empty
          +---n push-change-update {on-change}?
             +--ro id?                   sn:subscription-id
             +--ro datastore-changes
             |  +--ro yang-patch
             |     +--ro patch-id    string
             |     +--ro comment?    string
             |     +--ro edit* [edit-id]
             |        +--ro edit-id      string
             |        +--ro operation    enumeration
             |        +--ro target       target-resource-offset
             |        +--ro point?       target-resource-offset
             |        +--ro where?       enumeration
             |        +--ro value?       <anydata>
             +--ro incomplete-update?    empty

         Figure 9: Data Model Structure: Non-augmentation Portions

   Selected components of the data model are summarized below.

4.2.  Subscription Configuration

   Both configured and dynamic subscriptions are represented in the list
   "subscription".  New parameters extending the basic subscription data
   model in [RFC8639] include:

   o  The targeted datastore from which the selection is being made.
      The potential datastores include those from [RFC8342].  A platform
      may also choose to support a custom datastore.

   o  A selection filter identifying YANG nodes of interest in a
      datastore.  Filter contents are specified via a reference to an
      existing filter or via an in-line definition for only that
      subscription.  Referenced filters allow an implementation to avoid
      evaluating filter acceptability during a dynamic subscription
      request.  The "case" statement differentiates the options.











Clemm & Voit                 Standards Track                   [Page 27]
^L
RFC 8641                        YANG-Push                 September 2019


   o  For periodic subscriptions, triggered updates will occur at the
      boundaries of a specified time interval.  These boundaries can be
      calculated from the periodic parameters:

      *  a "period" that defines the duration between push updates.

      *  an "anchor-time"; update intervals fall on the points in time
         that are a multiple of a "period" from an "anchor-time".  If an
         "anchor-time" is not provided, then the "anchor-time" MUST be
         set with the creation time of the initial update record.

   o  For on-change subscriptions, assuming that any dampening period
      has completed, triggering occurs whenever a change in the
      subscribed information is detected.  On-change subscriptions have
      more-complex semantics that are guided by their own set of
      parameters:

      *  a "dampening-period" that specifies the interval that must pass
         before a successive update for the subscription is sent.  If no
         dampening period is in effect, the update is sent immediately.
         If a subsequent change is detected, another update is only sent
         once the dampening period has passed for this subscription.

      *  an "excluded-change" that allows the restriction of the types
         of changes for which updates should be sent (e.g., only add to
         an update record on object creation).

      *  a "sync-on-start" that specifies whether a complete update with
         all the subscribed data is to be sent at the beginning of a
         subscription.

4.3.  YANG Notifications

4.3.1.  State Change Notifications

   Subscription state notifications and mechanisms are reused from
   [RFC8639].  Notifications "subscription-started" and "subscription-
   modified" have been augmented to include the datastore-specific
   objects.












Clemm & Voit                 Standards Track                   [Page 28]
^L
RFC 8641                        YANG-Push                 September 2019


4.3.2.  Notifications for Subscribed Content

   Along with the subscribed content, there are other objects that might
   be part of a "push-update" or "push-change-update" notification.

   o  An "id" (that identifies the subscription).  This object MUST be
      transported along with the subscribed contents.  It allows a
      receiver to determine which subscription resulted in a particular
      update record.

   o  An "incomplete-update" leaf.  This leaf indicates that not all
      changes that have occurred since the last update are actually
      included with this update.  In other words, the publisher has
      failed to fulfill its full subscription obligations.  (For
      example, a datastore was unable to provide the full set of
      datastore nodes to a publisher process.)  To facilitate the
      resynchronization of on-change subscriptions, a publisher MAY
      subsequently send a "push-update" containing a full selection
      snapshot of subscribed data.

4.4.  YANG RPCs

   YANG-Push subscriptions are established, modified, and deleted using
   RPCs augmented from [RFC8639].

4.4.1.  "establish-subscription" RPC

   The subscriber sends an "establish-subscription" RPC with the
   parameters listed in Section 3.1.  An example might look like:






















Clemm & Voit                 Standards Track                   [Page 29]
^L
RFC 8641                        YANG-Push                 September 2019


 <netconf:rpc message-id="101"
     xmlns:netconf="urn:ietf:params:xml:ns:netconf:base:1.0">
   <establish-subscription
       xmlns="urn:ietf:params:xml:ns:yang:ietf-subscribed-notifications"
       xmlns:yp="urn:ietf:params:xml:ns:yang:ietf-yang-push">
     <yp:datastore
          xmlns:ds="urn:ietf:params:xml:ns:yang:ietf-datastores">
       ds:operational
     </yp:datastore>
     <yp:datastore-xpath-filter
         xmlns:ex="https://example.com/sample-data/1.0">
       /ex:foo
     </yp:datastore-xpath-filter>
     <yp:periodic>
       <yp:period>500</yp:period>
     </yp:periodic>
   </establish-subscription>
 </netconf:rpc>

                  Figure 10: "establish-subscription" RPC

   A positive response includes the "id" of the accepted subscription.
   In that case, a publisher may respond as follows:

 <rpc-reply message-id="101"
    xmlns="urn:ietf:params:xml:ns:netconf:base:1.0">
    <id
      xmlns="urn:ietf:params:xml:ns:yang:ietf-subscribed-notifications">
       52
    </id>
 </rpc-reply>

         Figure 11: "establish-subscription" Positive RPC Response

   A subscription can be rejected for multiple reasons, including the
   lack of authorization to establish a subscription, no capacity to
   serve the subscription at the publisher, or the inability of the
   publisher to select datastore content at the requested cadence.

   If a request is rejected because the publisher is not able to serve
   it, the publisher SHOULD include in the returned error hints that
   help a subscriber understand what subscription parameters might have
   been accepted for the request.  These hints would be included in the
   yang-data structure "establish-subscription-error-datastore".
   However, even with these hints, there are no guarantees that
   subsequent requests will in fact be accepted.





Clemm & Voit                 Standards Track                   [Page 30]
^L
RFC 8641                        YANG-Push                 September 2019


   The specific parameters to be returned as part of the RPC error
   response depend on the specific transport that is used to manage the
   subscription.  For NETCONF, those parameters are defined in
   [RFC8640].  For example, for the following NETCONF request:

     <rpc message-id="101"
          xmlns="urn:ietf:params:xml:ns:netconf:base:1.0">
       <establish-subscription
           xmlns=
             "urn:ietf:params:xml:ns:yang:ietf-subscribed-notifications"
           xmlns:yp="urn:ietf:params:xml:ns:yang:ietf-yang-push">
         <yp:datastore
             xmlns:ds="urn:ietf:params:xml:ns:yang:ietf-datastores">
           ds:operational
         </yp:datastore>
         <yp:datastore-xpath-filter
             xmlns:ex="https://example.com/sample-data/1.0">
           /ex:foo
         </yp:datastore-xpath-filter>
         <yp:on-change>
           <yp:dampening-period>100</yp:dampening-period>
         </yp:on-change>
       </establish-subscription>
     </rpc>

          Figure 12: "establish-subscription" Request: Example 2

   A publisher that cannot serve on-change updates but can serve
   periodic updates might return the following NETCONF response:

 <rpc-reply message-id="101"
   xmlns="urn:ietf:params:xml:ns:netconf:base:1.0"
   xmlns:yp="urn:ietf:params:xml:ns:yang:ietf-subscribed-notifications">
   <rpc-error>
     <error-type>application</error-type>
     <error-tag>operation-failed</error-tag>
     <error-severity>error</error-severity>
     <error-path>/yp:periodic/yp:period</error-path>
     <error-info>
       <yp:establish-subscription-error-datastore>
         <yp:reason>yp:on-change-unsupported</yp:reason>
       </yp:establish-subscription-error-datastore>
     </error-info>
   </rpc-error>
 </rpc-reply>

       Figure 13: "establish-subscription" Error Response: Example 2




Clemm & Voit                 Standards Track                   [Page 31]
^L
RFC 8641                        YANG-Push                 September 2019


4.4.2.  "modify-subscription" RPC

   The subscriber MAY invoke the "modify-subscription" RPC for a
   subscription it previously established.  The subscriber will include
   newly desired values in the "modify-subscription" RPC.  Parameters
   not included MUST remain unmodified.  Figure 14 provides an example
   where a subscriber attempts to modify the period and datastore XPath
   filter of a subscription using NETCONF.

     <rpc message-id="102"
          xmlns="urn:ietf:params:xml:ns:netconf:base:1.0">
       <modify-subscription
           xmlns=
             "urn:ietf:params:xml:ns:yang:ietf-subscribed-notifications"
           xmlns:yp="urn:ietf:params:xml:ns:yang:ietf-yang-push">
         <id>1011</id>
         <yp:datastore
             xmlns:ds="urn:ietf:params:xml:ns:yang:ietf-datastores">
           ds:operational
         </yp:datastore>
         <yp:datastore-xpath-filter
             xmlns:ex="https://example.com/sample-data/1.0">
           /ex:bar
         </yp:datastore-xpath-filter>
         <yp:periodic>
           <yp:period>250</yp:period>
         </yp:periodic>
        </modify-subscription>
     </rpc>

                 Figure 14: "modify-subscription" Request

   The publisher MUST respond to the subscription modification request.
   If the request is rejected, the existing subscription is left
   unchanged, and the publisher MUST send an RPC error response.  This
   response might have hints encapsulated in the yang-data structure
   "modify-subscription-error-datastore".  A subscription MAY be
   modified multiple times.

   The specific parameters to be returned as part of the RPC error
   response depend on the specific transport that is used to manage the
   subscription.  For NETCONF, those parameters are specified in
   [RFC8640].

   A configured subscription cannot be modified using a
   "modify-subscription" RPC.  Instead, the configuration needs to be
   edited as needed.




Clemm & Voit                 Standards Track                   [Page 32]
^L
RFC 8641                        YANG-Push                 September 2019


4.4.3.  "delete-subscription" RPC

   To stop receiving updates from a subscription and effectively delete
   a subscription that had previously been established using an
   "establish-subscription" RPC, a subscriber can send a
   "delete-subscription" RPC, which takes as its only input the
   subscription's "id".  This RPC is unmodified from [RFC8639].

4.4.4.  "resync-subscription" RPC

   This RPC is supported only for on-change subscriptions previously
   established using an "establish-subscription" RPC.  For example:

      <rpc message-id="103"
           xmlns="urn:ietf:params:xml:ns:netconf:base:1.0">
        <resync-subscription
            xmlns="urn:ietf:params:xml:ns:yang:ietf-yang-push">
          <id>1011</id>
        </resync-subscription>
      </rpc>

                     Figure 15: "resync-subscription"

   On receipt, a publisher must either (1) accept the request and
   quickly follow with a "push-update" or (2) send an appropriate error
   in an RPC error response.  In its error response, the publisher MAY
   include, in the yang-data structure "resync-subscription-error",
   supplemental information about the reasons for the error.

4.4.5.  YANG Module Synchronization

   To make subscription requests, the subscriber needs to know the YANG
   datastore schemas used by the publisher.  These schemas are available
   in the YANG library module ietf-yang-library.yang as defined in
   [RFC8525].  The receiver is expected to know the YANG library
   information before starting a subscription.

   The set of modules, revisions, features, and deviations can change at
   runtime (if supported by the publisher implementation).  For this
   purpose, the YANG library provides a simple "yang-library-change"
   notification that informs the subscriber that the library has
   changed.  In this case, a subscription may need to be updated to take
   the updates into account.  The receiver may also need to be informed
   of module changes in order to process updates regarding datastore
   nodes from changed modules correctly.






Clemm & Voit                 Standards Track                   [Page 33]
^L
RFC 8641                        YANG-Push                 September 2019


5.  YANG Module for YANG-Push

   This YANG module imports typedefs from [RFC6991], identities from
   [RFC8342], the "yang-data" extension from [RFC8040], and the
   "yang-patch" grouping from [RFC8072].  In addition, it imports and
   augments many definitions from [RFC8639].  It also references
   [RFC6241], [XPATH] ("XML Path Language (XPath) Version 1.0"), and
   [RFC7950].

   <CODE BEGINS> file "ietf-yang-push@2019-09-09.yang"
   module ietf-yang-push {
     yang-version 1.1;
     namespace "urn:ietf:params:xml:ns:yang:ietf-yang-push";
     prefix yp;

     import ietf-yang-types {
       prefix yang;
       reference
         "RFC 6991: Common YANG Data Types";
     }
     import ietf-subscribed-notifications {
       prefix sn;
       reference
         "RFC 8639: Subscription to YANG Notifications";
     }
     import ietf-datastores {
       prefix ds;
       reference
         "RFC 8342: Network Management Datastore Architecture (NMDA)";
     }
     import ietf-restconf {
       prefix rc;
       reference
         "RFC 8040: RESTCONF Protocol";
     }
     import ietf-yang-patch {
       prefix ypatch;
       reference
         "RFC 8072: YANG Patch Media Type";
     }

     organization
       "IETF NETCONF (Network Configuration) Working Group";
     contact
       "WG Web:  <https:/datatracker.ietf.org/wg/netconf/>
        WG List: <mailto:netconf@ietf.org>

        Author:  Alexander Clemm



Clemm & Voit                 Standards Track                   [Page 34]
^L
RFC 8641                        YANG-Push                 September 2019


                 <mailto:ludwig@clemm.org>

        Author:  Eric Voit
                 <mailto:evoit@cisco.com>";

     description
       "This module contains YANG specifications for YANG-Push.

        The key words 'MUST', 'MUST NOT', 'REQUIRED', 'SHALL', 'SHALL
        NOT', 'SHOULD', 'SHOULD NOT', 'RECOMMENDED', 'NOT RECOMMENDED',
        'MAY', and 'OPTIONAL' in this document are to be interpreted as
        described in BCP 14 (RFC 2119) (RFC 8174) when, and only when,
        they appear in all capitals, as shown here.

        Copyright (c) 2019 IETF Trust and the persons identified as
        authors of the code.  All rights reserved.

        Redistribution and use in source and binary forms, with or
        without modification, is permitted pursuant to, and subject to
        the license terms contained in, the Simplified BSD License set
        forth in Section 4.c of the IETF Trust's Legal Provisions
        Relating to IETF Documents
        (https://trustee.ietf.org/license-info).

        This version of this YANG module is part of RFC 8641; see the
        RFC itself for full legal notices.";

     revision 2019-09-09 {
       description
         "Initial revision.";
       reference
         "RFC 8641: Subscriptions to YANG Datastores";
     }

     /*
      * FEATURES
      */

     feature on-change {
       description
         "This feature indicates that on-change triggered subscriptions
          are supported.";
     }

     /*
      * IDENTITIES
      */




Clemm & Voit                 Standards Track                   [Page 35]
^L
RFC 8641                        YANG-Push                 September 2019


     /* Error type identities for datastore subscription */

     identity resync-subscription-error {
       description
         "Problem found while attempting to fulfill a
          'resync-subscription' RPC request.";
     }

     identity cant-exclude {
       base sn:establish-subscription-error;
       description
         "Unable to remove the set of 'excluded-change' parameters.
          This means that the publisher is unable to restrict
          'push-change-update' notifications to just the change types
          requested for this subscription.";
     }

     identity datastore-not-subscribable {
       base sn:establish-subscription-error;
       base sn:subscription-terminated-reason;
       description
         "This is not a subscribable datastore.";
     }

     identity no-such-subscription-resync {
       base resync-subscription-error;
       description
         "The referenced subscription doesn't exist.  This may be as a
          result of a nonexistent subscription ID, an ID that belongs to
          another subscriber, or an ID for a configured subscription.";
     }

     identity on-change-unsupported {
       base sn:establish-subscription-error;
       description
         "On-change is not supported for any objects that are
          selectable by this filter.";
     }

     identity on-change-sync-unsupported {
       base sn:establish-subscription-error;
       description
         "Neither 'sync-on-start' nor resynchronization is supported for
          this subscription.  This error will be used for two reasons:
          (1) if an 'establish-subscription' RPC includes
          'sync-on-start' but the publisher can't support sending a
          'push-update' for this subscription for reasons other than
          'on-change-unsupported' or 'sync-too-big'



Clemm & Voit                 Standards Track                   [Page 36]
^L
RFC 8641                        YANG-Push                 September 2019


          (2) if the 'resync-subscription' RPC is invoked for either an
          existing periodic subscription or an on-change subscription
          that can't support resynchronization.";
     }

     identity period-unsupported {
       base sn:establish-subscription-error;
       base sn:modify-subscription-error;
       base sn:subscription-suspended-reason;
       description
         "The requested time period or 'dampening-period' is too short.
          This can be for both periodic and on-change subscriptions
          (with or without dampening).  Hints suggesting alternative
          periods may be returned as supplemental information.";
     }

     identity update-too-big {
       base sn:establish-subscription-error;
       base sn:modify-subscription-error;
       base sn:subscription-suspended-reason;
       description
         "Periodic or on-change push update data trees exceed a maximum
          size limit.  Hints on the estimated size of what was too big
          may be returned as supplemental information.";
     }

     identity sync-too-big {
       base sn:establish-subscription-error;
       base sn:modify-subscription-error;
       base resync-subscription-error;
       base sn:subscription-suspended-reason;
       description
         "The 'sync-on-start' or resynchronization data tree exceeds a
          maximum size limit.  Hints on the estimated size of what was
          too big may be returned as supplemental information.";
     }

     identity unchanging-selection {
       base sn:establish-subscription-error;
       base sn:modify-subscription-error;
       base sn:subscription-terminated-reason;
       description
         "The selection filter is unlikely to ever select data tree
          nodes.  This means that based on the subscriber's current
          access rights, the publisher recognizes that the selection
          filter is unlikely to ever select data tree nodes that change.
          Examples for this might be that the node or subtree doesn't
          exist, read access is not permitted for a receiver, or static



Clemm & Voit                 Standards Track                   [Page 37]
^L
RFC 8641                        YANG-Push                 September 2019


          objects that only change at reboot have been chosen.";
     }

     /*
      * TYPE DEFINITIONS
      */

     typedef change-type {
       type enumeration {
         enum create {
           description
             "A change that refers to the creation of a new
              datastore node.";
         }
         enum delete {
           description
             "A change that refers to the deletion of a
              datastore node.";
         }
         enum insert {
           description
             "A change that refers to the insertion of a new
              user-ordered datastore node.";
         }
         enum move {
           description
             "A change that refers to a reordering of the target
              datastore node.";
         }
         enum replace {
           description
             "A change that refers to a replacement of the target
              datastore node's value.";
         }
       }
       description
         "Specifies different types of datastore changes.

          This type is based on the edit operations defined for
          YANG Patch, with the difference that it is valid for a
          receiver to process an update record that performs a
          'create' operation on a datastore node the receiver believes
          exists or to process a delete on a datastore node the
          receiver believes is missing.";
       reference
         "RFC 8072: YANG Patch Media Type, Section 2.5";
     }




Clemm & Voit                 Standards Track                   [Page 38]
^L
RFC 8641                        YANG-Push                 September 2019


     typedef selection-filter-ref {
       type leafref {
         path "/sn:filters/yp:selection-filter/yp:filter-id";
       }
       description
         "This type is used to reference a selection filter.";
     }

     typedef centiseconds {
       type uint32;
       description
         "A period of time, measured in units of 0.01 seconds.";
     }

     /*
      * GROUP DEFINITIONS
      */

     grouping datastore-criteria {
       description
         "A grouping to define criteria for which selected objects from
          a targeted datastore should be included in push updates.";
       leaf datastore {
         type identityref {
           base ds:datastore;
         }
         mandatory true;
         description
           "Datastore from which to retrieve data.";
       }
       uses selection-filter-objects;
     }

     grouping selection-filter-types {
       description
         "This grouping defines the types of selectors for objects
          from a datastore.";
       choice filter-spec {
         description
           "The content filter specification for this request.";
         anydata datastore-subtree-filter {
           if-feature "sn:subtree";
           description
             "This parameter identifies the portions of the
              target datastore to retrieve.";
           reference
             "RFC 6241: Network Configuration Protocol (NETCONF),
                        Section 6";



Clemm & Voit                 Standards Track                   [Page 39]
^L
RFC 8641                        YANG-Push                 September 2019


         }
         leaf datastore-xpath-filter {
           if-feature "sn:xpath";
           type yang:xpath1.0;
           description
             "This parameter contains an XPath expression identifying
              the portions of the target datastore to retrieve.

              If the expression returns a node set, all nodes in the
              node set are selected by the filter.  Otherwise, if the
              expression does not return a node set, the filter
              doesn't select any nodes.

              The expression is evaluated in the following XPath
              context:

              o  The set of namespace declarations is the set of prefix
                 and namespace pairs for all YANG modules implemented
                 by the server, where the prefix is the YANG module
                 name and the namespace is as defined by the
                 'namespace' statement in the YANG module.

                 If the leaf is encoded in XML, all namespace
                 declarations in scope on the 'stream-xpath-filter'
                 leaf element are added to the set of namespace
                 declarations.  If a prefix found in the XML is
                 already present in the set of namespace declarations,
                 the namespace in the XML is used.

              o  The set of variable bindings is empty.

              o  The function library is comprised of the core
                 function library and the XPath functions defined in
                 Section 10 in RFC 7950.

              o  The context node is the root node of the target
                 datastore.";
           reference
             "XML Path Language (XPath) Version 1.0
              (https://www.w3.org/TR/1999/REC-xpath-19991116)
              RFC 7950: The YANG 1.1 Data Modeling Language,
                        Section 10";
         }
       }
     }

     grouping selection-filter-objects {
       description



Clemm & Voit                 Standards Track                   [Page 40]
^L
RFC 8641                        YANG-Push                 September 2019


         "This grouping defines a selector for objects from a
          datastore.";
       choice selection-filter {
         description
           "The source of the selection filter applied to the
            subscription.  This will either (1) come referenced from a
            global list or (2) be provided in the subscription itself.";
         case by-reference {
           description
             "Incorporates a filter that has been configured
              separately.";
           leaf selection-filter-ref {
             type selection-filter-ref;
             mandatory true;
             description
               "References an existing selection filter that is to be
                applied to the subscription.";
           }
         }
         case within-subscription {
           description
             "A local definition allows a filter to have the same
              lifecycle as the subscription.";
           uses selection-filter-types;
         }
       }
     }

     grouping update-policy-modifiable {
       description
         "This grouping describes the datastore-specific subscription
          conditions that can be changed during the lifetime of the
          subscription.";
       choice update-trigger {
         description
           "Defines necessary conditions for sending an event record to
            the subscriber.";
         case periodic {
           container periodic {
             presence "indicates a periodic subscription";
             description
               "The publisher is requested to periodically notify the
                receiver regarding the current values of the datastore
                as defined by the selection filter.";
             leaf period {
               type centiseconds;
               mandatory true;
               description



Clemm & Voit                 Standards Track                   [Page 41]
^L
RFC 8641                        YANG-Push                 September 2019


                 "Duration of time that should occur between periodic
                  push updates, in units of 0.01 seconds.";
             }
             leaf anchor-time {
               type yang:date-and-time;
               description
                 "Designates a timestamp before or after which a series
                  of periodic push updates are determined.  The next
                  update will take place at a point in time that is a
                  multiple of a period from the 'anchor-time'.
                  For example, for an 'anchor-time' that is set for the
                  top of a particular minute and a period interval of a
                  minute, updates will be sent at the top of every
                  minute that this subscription is active.";
             }
           }
         }
         case on-change {
           if-feature "on-change";
           container on-change {
             presence "indicates an on-change subscription";
             description
               "The publisher is requested to notify the receiver
                regarding changes in values in the datastore subset as
                defined by a selection filter.";
             leaf dampening-period {
               type centiseconds;
               default "0";
               description
                 "Specifies the minimum interval between the assembly of
                  successive update records for a single receiver of a
                  subscription.  Whenever subscribed objects change and
                  a dampening-period interval (which may be zero) has
                  elapsed since the previous update record creation for
                  a receiver, any subscribed objects and properties
                  that have changed since the previous update record
                  will have their current values marshalled and placed
                  in a new update record.";
             }
           }
         }
       }
     }

     grouping update-policy {
       description
         "This grouping describes the datastore-specific subscription
          conditions of a subscription.";



Clemm & Voit                 Standards Track                   [Page 42]
^L
RFC 8641                        YANG-Push                 September 2019


       uses update-policy-modifiable {
         augment "update-trigger/on-change/on-change" {
           description
             "Includes objects that are not modifiable once a
              subscription is established.";
           leaf sync-on-start {
             type boolean;
             default "true";
             description
               "When this object is set to 'false', (1) it restricts an
                on-change subscription from sending 'push-update'
                notifications and (2) pushing a full selection per the
                terms of the selection filter MUST NOT be done for
                this subscription.  Only updates about changes
                (i.e., only 'push-change-update' notifications)
                are sent.  When set to 'true' (the default behavior),
                in order to facilitate a receiver's synchronization,
                a full update is sent, via a 'push-update' notification,
                when the subscription starts.  After that,
                'push-change-update' notifications are exclusively sent,
                unless the publisher chooses to resync the subscription
                via a new 'push-update' notification.";
           }
           leaf-list excluded-change {
             type change-type;
             description
               "Used to restrict which changes trigger an update.  For
                example, if a 'replace' operation is excluded, only the
                creation and deletion of objects are reported.";
           }
         }
       }
     }

     grouping hints {
       description
         "Parameters associated with an error for a subscription
          made upon a datastore.";
       leaf period-hint {
         type centiseconds;
         description
           "Returned when the requested time period is too short.  This
            hint can assert a viable period for either a periodic push
            cadence or an on-change dampening interval.";
       }
       leaf filter-failure-hint {
         type string;
         description



Clemm & Voit                 Standards Track                   [Page 43]
^L
RFC 8641                        YANG-Push                 September 2019


           "Information describing where and/or why a provided filter
            was unsupportable for a subscription.";
       }
       leaf object-count-estimate {
         type uint32;
         description
           "If there are too many objects that could potentially be
            returned by the selection filter, this identifies the
            estimate of the number of objects that the filter would
            potentially pass.";
       }
       leaf object-count-limit {
         type uint32;
         description
           "If there are too many objects that could be returned by
            the selection filter, this identifies the upper limit of
            the publisher's ability to service this subscription.";
       }
       leaf kilobytes-estimate {
         type uint32;
         description
           "If the returned information could be beyond the capacity
            of the publisher, this would identify the estimated
            data size that could result from this selection filter.";
       }
       leaf kilobytes-limit {
         type uint32;
         description
           "If the returned information would be beyond the capacity
            of the publisher, this identifies the upper limit of the
            publisher's ability to service this subscription.";
       }
     }

     /*
      * RPCs
      */

     rpc resync-subscription {
       if-feature "on-change";
       description
         "This RPC allows a subscriber of an active on-change
          subscription to request a full push of objects.

          A successful invocation results in a 'push-update' of all
          datastore nodes that the subscriber is permitted to access.
          This RPC can only be invoked on the same session on which the
          subscription is currently active.  In the case of an error, a



Clemm & Voit                 Standards Track                   [Page 44]
^L
RFC 8641                        YANG-Push                 September 2019


          'resync-subscription-error' is sent as part of an error
          response.";
       input {
         leaf id {
           type sn:subscription-id;
           mandatory true;
           description
             "Identifier of the subscription that is to be resynced.";
         }
       }
     }

     rc:yang-data resync-subscription-error {
       container resync-subscription-error {
         description
           "If a 'resync-subscription' RPC fails, the subscription is
            not resynced and the RPC error response MUST indicate the
            reason for this failure.  This yang-data MAY be inserted as
            structured data in a subscription's RPC error response
            to indicate the reason for the failure.";
         leaf reason {
           type identityref {
             base resync-subscription-error;
           }
           mandatory true;
           description
             "Indicates the reason why the publisher has declined a
              request for subscription resynchronization.";
         }
         uses hints;
       }
     }

     augment "/sn:establish-subscription/sn:input" {
       description
         "This augmentation adds additional subscription parameters
          that apply specifically to datastore updates to RPC input.";
       uses update-policy;
     }

     augment "/sn:establish-subscription/sn:input/sn:target" {
       description
         "This augmentation adds the datastore as a valid target
          for the subscription to RPC input.";
       case datastore {
         description
           "Information specifying the parameters of a request for a
            datastore subscription.";



Clemm & Voit                 Standards Track                   [Page 45]
^L
RFC 8641                        YANG-Push                 September 2019


         uses datastore-criteria;
       }
     }

     rc:yang-data establish-subscription-datastore-error-info {
       container establish-subscription-datastore-error-info {
         description
           "If any 'establish-subscription' RPC parameters are
            unsupportable against the datastore, a subscription is not
            created and the RPC error response MUST indicate the reason
            why the subscription failed to be created.  This yang-data
            MAY be inserted as structured data in a subscription's
            RPC error response to indicate the reason for the failure.
            This yang-data MUST be inserted if hints are to be provided
            back to the subscriber.";
         leaf reason {
           type identityref {
             base sn:establish-subscription-error;
           }
           description
             "Indicates the reason why the subscription has failed to
              be created to a targeted datastore.";
         }
         uses hints;
       }
     }

     augment "/sn:modify-subscription/sn:input" {
       description
         "This augmentation adds additional subscription parameters
          specific to datastore updates.";
       uses update-policy-modifiable;
     }

     augment "/sn:modify-subscription/sn:input/sn:target" {
       description
         "This augmentation adds the datastore as a valid target
          for the subscription to RPC input.";
       case datastore {
         description
           "Information specifying the parameters of a request for a
            datastore subscription.";
         uses datastore-criteria;
       }
     }

     rc:yang-data modify-subscription-datastore-error-info {
       container modify-subscription-datastore-error-info {



Clemm & Voit                 Standards Track                   [Page 46]
^L
RFC 8641                        YANG-Push                 September 2019


         description
           "This yang-data MAY be provided as part of a subscription's
            RPC error response when there is a failure of a
            'modify-subscription' RPC that has been made against a
            datastore.  This yang-data MUST be used if hints are to be
            provided back to the subscriber.";
         leaf reason {
           type identityref {
             base sn:modify-subscription-error;
           }
           description
             "Indicates the reason why the subscription has failed to
              be modified.";
         }
         uses hints;
       }
     }

     /*
      * NOTIFICATIONS
      */

     notification push-update {
       description
         "This notification contains a push update that in turn contains
          data subscribed to via a subscription.  In the case of a
          periodic subscription, this notification is sent for periodic
          updates.  It can also be used for synchronization updates of
          an on-change subscription.  This notification shall only be
          sent to receivers of a subscription.  It does not constitute
          a general-purpose notification that would be subscribable as
          part of the NETCONF event stream by any receiver.";
       leaf id {
         type sn:subscription-id;
         description
           "This references the subscription that drove the
            notification to be sent.";
       }
       anydata datastore-contents {
         description
           "This contains the updated data.  It constitutes a snapshot
            at the time of update of the set of data that has been
            subscribed to.  The snapshot corresponds to the same
            snapshot that would be returned in a corresponding 'get'
            operation with the same selection filter parameters
            applied.";
       }
       leaf incomplete-update {



Clemm & Voit                 Standards Track                   [Page 47]
^L
RFC 8641                        YANG-Push                 September 2019


         type empty;
         description
           "This is a flag that indicates that not all datastore
            nodes subscribed to are included with this update.  In
            other words, the publisher has failed to fulfill its full
            subscription obligations and, despite its best efforts, is
            providing an incomplete set of objects.";
       }
     }

     notification push-change-update {
       if-feature "on-change";
       description
         "This notification contains an on-change push update.  This
          notification shall only be sent to the receivers of a
          subscription.  It does not constitute a general-purpose
          notification that would be subscribable as part of the
          NETCONF event stream by any receiver.";
       leaf id {
         type sn:subscription-id;
         description
           "This references the subscription that drove the
            notification to be sent.";
       }
       container datastore-changes {
         description
           "This contains the set of datastore changes of the target
            datastore, starting at the time of the previous update, per
            the terms of the subscription.";
         uses ypatch:yang-patch;
       }
       leaf incomplete-update {
         type empty;
         description
           "The presence of this object indicates that not all changes
            that have occurred since the last update are included with
            this update.  In other words, the publisher has failed to
            fulfill its full subscription obligations -- for example,
            in cases where it was not able to keep up with a burst of
            changes.";
       }
     }

     augment "/sn:subscription-started" {
       description
         "This augmentation adds datastore-specific objects to
          the notification that a subscription has started.";
       uses update-policy;



Clemm & Voit                 Standards Track                   [Page 48]
^L
RFC 8641                        YANG-Push                 September 2019


     }

     augment "/sn:subscription-started/sn:target" {
       description
         "This augmentation allows the datastore to be included as
          part of the notification that a subscription has started.";
       case datastore {
         uses datastore-criteria {
           refine "selection-filter/within-subscription" {
             description
               "Specifies the selection filter and where it originated
                from.  If the 'selection-filter-ref' is populated, the
                filter in the subscription came from the 'filters'
                container.  Otherwise, it is populated in-line as part
                of the subscription itself.";
           }
         }
       }
     }

     augment "/sn:subscription-modified" {
       description
         "This augmentation adds datastore-specific objects to
          the notification that a subscription has been modified.";
       uses update-policy;
     }

     augment "/sn:subscription-modified/sn:target" {
       description
         "This augmentation allows the datastore to be included as
          part of the notification that a subscription has been
          modified.";
       case datastore {
         uses datastore-criteria {
           refine "selection-filter/within-subscription" {
             description
               "Specifies the selection filter and where it originated
                from.  If the 'selection-filter-ref' is populated, the
                filter in the subscription came from the 'filters'
                container.  Otherwise, it is populated in-line as part
                of the subscription itself.";
           }
         }
       }
     }

     /*
      * DATA NODES



Clemm & Voit                 Standards Track                   [Page 49]
^L
RFC 8641                        YANG-Push                 September 2019


      */

     augment "/sn:filters" {
       description
         "This augmentation allows the datastore to be included as part
          of the selection-filtering criteria for a subscription.";
       list selection-filter {
         key "filter-id";
         description
           "A list of preconfigured filters that can be applied
            to datastore subscriptions.";
         leaf filter-id {
           type string;
           description
             "An identifier to differentiate between selection
              filters.";
         }
         uses selection-filter-types;
       }
     }

     augment "/sn:subscriptions/sn:subscription" {
       when 'yp:datastore';
       description
         "This augmentation adds objects to a subscription that are
          specific to a datastore subscription, i.e., a subscription to
          a stream of datastore node updates.";
       uses update-policy;
     }

     augment "/sn:subscriptions/sn:subscription/sn:target" {
       description
         "This augmentation allows the datastore to be included as
          part of the selection-filtering criteria for a subscription.";
       case datastore {
         uses datastore-criteria;
       }
     }
   }

   <CODE ENDS>










Clemm & Voit                 Standards Track                   [Page 50]
^L
RFC 8641                        YANG-Push                 September 2019


6.  IANA Considerations

   This document registers the following namespace URI in the "IETF XML
   Registry" [RFC3688]:

   URI: urn:ietf:params:xml:ns:yang:ietf-yang-push

   Registrant Contact: The IESG.

   XML: N/A; the requested URI is an XML namespace.

   This document registers the following YANG module in the "YANG Module
   Names" registry [RFC6020]:

   Name: ietf-yang-push

   Namespace: urn:ietf:params:xml:ns:yang:ietf-yang-push

   Prefix: yp

   Reference: RFC 8641

7.  Security Considerations

   The YANG module specified in this document defines a schema for data
   that is designed to be accessed via network management protocols such
   as NETCONF [RFC6241] or RESTCONF [RFC8040].  The lowest NETCONF layer
   is the secure transport layer, and the mandatory-to-implement secure
   transport is Secure Shell (SSH) [RFC6242].  The lowest RESTCONF layer
   is HTTPS, and the mandatory-to-implement secure transport is TLS
   [RFC8446].

   The Network Configuration Access Control Model (NACM) [RFC8341]
   provides the means to restrict access for particular NETCONF or
   RESTCONF users to a preconfigured subset of all available NETCONF or
   RESTCONF protocol operations and content.

   There are a number of data nodes defined in this YANG module that are
   writable/creatable/deletable (i.e., config true, which is the
   default).  These data nodes may be considered sensitive or vulnerable
   in some network environments.  Write operations (e.g., edit-config)
   to these data nodes without proper protection can have a negative
   effect on network operations.  These are the subtrees and data nodes
   and their sensitivity/vulnerability.  (It should be noted that the
   YANG module defined in this document augments the YANG module defined
   in [RFC8639].  All security considerations that are listed in





Clemm & Voit                 Standards Track                   [Page 51]
^L
RFC 8641                        YANG-Push                 September 2019


   [RFC8639] are also relevant for datastore subscriptions.  In the
   following list, we focus on the new data nodes that are introduced in
   this document.)

   o  Subtree "selection-filter" under container "filters": This subtree
      allows a subscriber to specify which objects or subtrees to
      include in a datastore subscription.  An attacker could attempt to
      modify the filter.  For example, the filter might be modified to
      result in very few objects being filtered in order to attempt to
      overwhelm the receiver.  Alternatively, the filter might be
      modified to result in certain objects being excluded from updates,
      in which case certain changes would go unnoticed.

   o  Subtree "datastore" in choice "target" in list "subscription":
      Analogous to "selection filter", an attacker might attempt to
      modify the objects being filtered in order to overwhelm a receiver
      with a larger volume of object updates than expected or cause
      certain changes to go unnoticed.

   o  Choice "update-trigger" in list "subscription": By modifying the
      update trigger, an attacker might alter the updates that are being
      sent in order to confuse a receiver, withhold certain updates to
      be sent to the receiver, and/or overwhelm a receiver.  For
      example, an attacker might modify the period with which updates
      are reported for a periodic subscription, or it might modify the
      dampening period for an on-change subscription, resulting in a
      greater delay for successive updates (potentially affecting the
      responsiveness of applications that depend on the updates) or in a
      high volume of updates (to exhaust receiver resources).

   The NACM provides one means to mitigate these threats on the
   publisher side.  In order to address those threats as a subscriber,
   the subscriber could monitor the subscription configuration for any
   unexpected changes and subscribe to updates to the YANG datastore
   nodes that represent its datastore subscriptions.  As this volume of
   data is small, a paranoid subscriber could even revert to occasional
   polling to guard against a compromised subscription against
   subscription configuration updates itself.

   Some of the readable data nodes in this YANG module may be considered
   sensitive or vulnerable in some network environments.  It is thus
   important to control read access (e.g., via get, get-config, or
   notification) to these data nodes.  These are the subtrees and data
   nodes and their sensitivity/vulnerability:

   o  Subtree "selection-filter" under container "filters": If access
      control is not properly configured, can expose system internals to
      those who should not have access to this information.



Clemm & Voit                 Standards Track                   [Page 52]
^L
RFC 8641                        YANG-Push                 September 2019


   o  Subtree "datastore" in choice "target" in list "subscription": If
      access control is not properly configured, can expose system
      internals to those who should not have access to this information.

   o  Choice "update-trigger" in list "subscription": If access control
      is not properly configured, can expose system internals to those
      who should not have access to this information.

   Some of the RPC operations in this YANG module may be considered
   sensitive or vulnerable in some network environments.  It is thus
   important to control access to these operations.  These are the
   operations and their sensitivity/vulnerability:

   o  RPC "resync-subscription": This RPC allows a subscriber of an
      on-change subscription to request a full push of objects in the
      subscription's scope.  This can result in a large volume of data.
      An attacker could attempt to use this RPC to exhaust resources on
      the server to generate the data and could then attempt to
      overwhelm a receiver with the resulting large volume of data.

8.  References

8.1.  Normative References

   [RFC2119]  Bradner, S., "Key words for use in RFCs to Indicate
              Requirement Levels", BCP 14, RFC 2119,
              DOI 10.17487/RFC2119, March 1997,
              <https://www.rfc-editor.org/info/rfc2119>.

   [RFC3688]  Mealling, M., "The IETF XML Registry", BCP 81, RFC 3688,
              DOI 10.17487/RFC3688, January 2004,
              <https://www.rfc-editor.org/info/rfc3688>.

   [RFC6020]  Bjorklund, M., Ed., "YANG - A Data Modeling Language for
              the Network Configuration Protocol (NETCONF)", RFC 6020,
              DOI 10.17487/RFC6020, October 2010,
              <https://www.rfc-editor.org/info/rfc6020>.

   [RFC6991]  Schoenwaelder, J., Ed., "Common YANG Data Types",
              RFC 6991, DOI 10.17487/RFC6991, July 2013,
              <https://www.rfc-editor.org/info/rfc6991>.

   [RFC7950]  Bjorklund, M., Ed., "The YANG 1.1 Data Modeling Language",
              RFC 7950, DOI 10.17487/RFC7950, August 2016,
              <https://www.rfc-editor.org/info/rfc7950>.






Clemm & Voit                 Standards Track                   [Page 53]
^L
RFC 8641                        YANG-Push                 September 2019


   [RFC8040]  Bierman, A., Bjorklund, M., and K. Watsen, "RESTCONF
              Protocol", RFC 8040, DOI 10.17487/RFC8040, January 2017,
              <https://www.rfc-editor.org/info/rfc8040>.

   [RFC8072]  Bierman, A., Bjorklund, M., and K. Watsen, "YANG Patch
              Media Type", RFC 8072, DOI 10.17487/RFC8072,
              February 2017, <https://www.rfc-editor.org/info/rfc8072>.

   [RFC8174]  Leiba, B., "Ambiguity of Uppercase vs Lowercase in
              RFC 2119 Key Words", BCP 14, RFC 8174,
              DOI 10.17487/RFC8174, May 2017,
              <https://www.rfc-editor.org/info/rfc8174>.

   [RFC8341]  Bierman, A. and M. Bjorklund, "Network Configuration
              Access Control Model", STD 91, RFC 8341,
              DOI 10.17487/RFC8341, March 2018,
              <https://www.rfc-editor.org/info/rfc8341>.

   [RFC8342]  Bjorklund, M., Schoenwaelder, J., Shafer, P., Watsen, K.,
              and R. Wilton, "Network Management Datastore Architecture
              (NMDA)", RFC 8342, DOI 10.17487/RFC8342, March 2018,
              <https://www.rfc-editor.org/info/rfc8342>.

   [RFC8446]  Rescorla, E., "The Transport Layer Security (TLS) Protocol
              Version 1.3", RFC 8446, DOI 10.17487/RFC8446, August 2018,
              <https://www.rfc-editor.org/info/rfc8446>.

   [RFC8525]  Bierman, A., Bjorklund, M., Schoenwaelder, J., Watsen, K.,
              and R. Wilton, "YANG Library", RFC 8525,
              DOI 10.17487/RFC8525, March 2019,
              <https://www.rfc-editor.org/info/rfc8525>.

   [RFC8639]  Voit, E., Clemm, A., Gonzalez Prieto, A., Nilsen-Nygaard,
              E., and A. Tripathy, "Subscription to YANG Notifications",
              RFC 8639, DOI 10.17487/RFC8639, September 2019,
              <https://www.rfc-editor.org/info/rfc8639>.

   [W3C.REC-xml-20081126]
              Bray, T., Paoli, J., Sperberg-McQueen, M., Maler, E., and
              F. Yergeau, "Extensible Markup Language (XML) 1.0 (Fifth
              Edition)", World Wide Web Consortium Recommendation
              REC-xml-20081126, November 2008,
              <https://www.w3.org/TR/2008/REC-xml-20081126>.

   [XPATH]    Clark, J. and S. DeRose, "XML Path Language (XPath)
              Version 1.0", November 1999,
              <https://www.w3.org/TR/1999/REC-xpath-19991116>.




Clemm & Voit                 Standards Track                   [Page 54]
^L
RFC 8641                        YANG-Push                 September 2019


8.2.  Informative References

   [RFC6241]  Enns, R., Ed., Bjorklund, M., Ed., Schoenwaelder, J., Ed.,
              and A. Bierman, Ed., "Network Configuration Protocol
              (NETCONF)", RFC 6241, DOI 10.17487/RFC6241, June 2011,
              <https://www.rfc-editor.org/info/rfc6241>.

   [RFC6242]  Wasserman, M., "Using the NETCONF Protocol over Secure
              Shell (SSH)", RFC 6242, DOI 10.17487/RFC6242, June 2011,
              <https://www.rfc-editor.org/info/rfc6242>.

   [RFC7923]  Voit, E., Clemm, A., and A. Gonzalez Prieto, "Requirements
              for Subscription to YANG Datastores", RFC 7923,
              DOI 10.17487/RFC7923, June 2016,
              <https://www.rfc-editor.org/info/rfc7923>.

   [RFC8340]  Bjorklund, M. and L. Berger, Ed., "YANG Tree Diagrams",
              BCP 215, RFC 8340, DOI 10.17487/RFC8340, March 2018,
              <https://www.rfc-editor.org/info/rfc8340>.

   [RFC8343]  Bjorklund, M., "A YANG Data Model for Interface
              Management", RFC 8343, DOI 10.17487/RFC8343, March 2018,
              <https://www.rfc-editor.org/info/rfc8343>.

   [RFC8640]  Voit, E., Clemm, A., Gonzalez Prieto, A., Nilsen-Nygaard,
              E., and A. Tripathy, "Dynamic Subscription to YANG Events
              and Datastores over NETCONF", RFC 8640,
              DOI 10.17487/RFC8640, September 2019,
              <https://www.rfc-editor.org/info/rfc8640>.

   [Yang-Push-Notif-Cap]
              Lengyel, B., Clemm, A., and B. Claise, "Yang-Push
              Notification Capabilities", Work in Progress,
              draft-ietf-netconf-notification-capabilities-04,
              September 2019.
















Clemm & Voit                 Standards Track                   [Page 55]
^L
RFC 8641                        YANG-Push                 September 2019


Appendix A.  Subscription Errors

A.1.  RPC Failures

   Rejection of an RPC for any reason is indicated via an RPC error
   response from the publisher.  Valid RPC errors returned include both
   (1) existing transport-layer RPC error codes, such as those seen with
   NETCONF in [RFC6241] and (2) subscription-specific errors, such as
   those defined in the YANG data model.  As a result, how subscription
   errors are encoded in an RPC error response is transport dependent.

   References to specific identities in the ietf-subscribed-
   notifications YANG module [RFC8639] or the ietf-yang-push YANG module
   may be returned as part of the error responses resulting from failed
   attempts at datastore subscription.  For errors defined as part of
   the ietf-subscribed-notifications YANG module, please refer to
   [RFC8639].  The errors defined in this document, grouped per RPC, are
   as follows:

      establish-subscription          modify-subscription
      ---------------------------     ---------------------
       cant-exclude                    period-unsupported
       datastore-not-subscribable      update-too-big
       on-change-unsupported           sync-too-big
       on-change-sync-unsupported      unchanging-selection
       period-unsupported
       update-too-big                 resync-subscription
       sync-too-big                   ----------------------------
       unchanging-selection            no-such-subscription-resync
                                       sync-too-big

   There is one final set of transport-independent RPC error elements
   included in the YANG data model.  These are the four yang-data
   structures for failed datastore subscriptions:

   1.  yang-data "establish-subscription-error-datastore": This MUST be
       returned if information identifying the reason for an RPC error
       has not been placed elsewhere in the transport portion of a
       failed "establish-subscription" RPC response.  This MUST be sent
       if hints are included.

   2.  yang-data "modify-subscription-error-datastore": This MUST be
       returned if information identifying the reason for an RPC error
       has not been placed elsewhere in the transport portion of a
       failed "modify-subscription" RPC response.  This MUST be sent if
       hints are included.





Clemm & Voit                 Standards Track                   [Page 56]
^L
RFC 8641                        YANG-Push                 September 2019


   3.  yang-data "sn:delete-subscription-error": This MUST be returned
       if information identifying the reason for an RPC error has not
       been placed elsewhere in the transport portion of a failed
       "delete-subscription" or "kill-subscription" RPC response.

   4.  yang-data "resync-subscription-error": This MUST be returned if
       information identifying the reason for an RPC error has not been
       placed elsewhere in the transport portion of a failed
       "resync-subscription" RPC response.

A.2.  Failure Notifications

   A subscription may be unexpectedly terminated or suspended
   independently of any RPC or configuration operation.  In such cases,
   indications of such a failure MUST be provided.  To accomplish this,
   a number of errors can be returned as part of the corresponding
   subscription state change notification.  For this purpose, the
   following error identities are introduced in this document, in
   addition to those that were already defined in [RFC8639]:

   subscription-terminated        subscription-suspended
   ---------------------------    ----------------------
    datastore-not-subscribable     period-unsupported
    unchanging-selection           update-too-big
                                   synchronization-size


























Clemm & Voit                 Standards Track                   [Page 57]
^L
RFC 8641                        YANG-Push                 September 2019


Acknowledgments

   For their valuable comments, discussions, and feedback, we wish to
   acknowledge Tim Jenkins, Martin Bjorklund, Kent Watsen, Susan Hares,
   Yang Geng, Peipei Guo, Michael Scharf, Guangying Zheng, Tom Petch,
   Henk Birkholz, Reshad Rahman, Qin Wu, Rohit Ranade, and Rob Wilton.

Contributors

   The following individuals made substantial contributions to this
   document and should be considered coauthors.  Their contributions
   include information contained in the YANG module provided in
   Section 5 of this document.

   Alberto Gonzalez Prieto
   Microsoft
   Email: alberto.gonzalez@microsoft.com

   Ambika Prasad Tripathy
   Cisco Systems
   Email: ambtripa@cisco.com

   Einar Nilsen-Nygaard
   Cisco Systems
   Email: einarnn@cisco.com

   Andy Bierman
   YumaWorks
   Email: andy@yumaworks.com

   Balazs Lengyel
   Ericsson
   Email: balazs.lengyel@ericsson.com

Authors' Addresses

   Alexander Clemm
   Futurewei

   Email: ludwig@clemm.org


   Eric Voit
   Cisco Systems

   Email: evoit@cisco.com





Clemm & Voit                 Standards Track                   [Page 58]
^L