💾 Archived View for gemini.bortzmeyer.org › rfc-mirror › rfc8641.txt captured on 2023-09-28 at 17:25:09.
⬅️ Previous capture (2021-11-30)
-=-=-=-=-=-=-
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]
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]
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]
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]
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]
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]
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]
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]
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]
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]
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]
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]
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]
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]
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]
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]
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]
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]
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]
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]
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]
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]
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]
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]
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]
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]
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]
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]
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]
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]
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]
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]
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]
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]
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]
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]
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]
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]
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]
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]
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]
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]
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]
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]
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]
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]
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]
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]
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]
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]
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]
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]
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]
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]
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]
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]
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]
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]