RFC 8242

Interface to the Routing System (I2RS) Ephemeral State Requirements

📅 published September 2017, from ietf

Interface to the Routing System (I2RS) Ephemeral State Requirements 🦋✨

okay bestie, let me set the scene 💅 this one is RFC 8242, and it's an Informational doc (so it's not a Standards Track spec, it's published just to share info) 🎀

The author squad is J. Haas (Juniper) and S. Hares (Huawei) 👑, and it came out in September 2017. It's part of the I2RS stuff, which is all about injecting info into and pulling info out of the routing system 🌈. The ISSN is 2070-1721, and it doesn't obsolete or update anything else, so it's its own little main character 💜

Abstract

The abstract basically says that RFC 7921 (the I2RS architecture doc) lists a bunch of abstract requirements for ephemeral state (the stuff that gets wiped on reboot) 🌸. This RFC is the detailed, nitty-gritty version of those requirements for anyone building the I2RS protocol 🔥

Status of This Memo

This is not a Standards Track spec, it's just published for info 🍓. It's an IETF product with IESG approval and community consensus ✨. Not everything the IESG approves ends up being a candidate for an Internet Standard, so check Section 2 of RFC 7841 if you want the deets 🙈. For the latest status, errata, or to send feedback, the page is https://www.rfc-editor.org/info/rfc8242 💖

Copyright Notice

Copyright (c) 2017 IETF Trust and the persons identified as the document authors. All rights reserved 🫶. This doc is subject to BCP 78 and the IETF Trust's Legal Provisions (https://trustee.ietf.org/license-info) as of the publication date, so read those if you're unsure about your rights 💅. Any Code Components pulled from this doc must include Simplified BSD License text (Section 4.e of the Trust Legal Provisions) and come without warranty 🧚

Table of Contents

   1. Introduction ....................................................3
      1.1. Requirements Language ......................................4
   2. Architectural Requirements for Ephemeral State ..................4
   3. Ephemeral State Requirements ....................................5
      3.1. Persistence ................................................5
      3.2. Constraints ................................................6
      3.3. Hierarchy ..................................................6
      3.4. Ephemeral Configuration Overlapping Local Configuration ....6
   4. YANG Features for Ephemeral State ...............................7
   5. NETCONF Features for Ephemeral State ............................7
   6. RESTCONF Features for Ephemeral State ...........................7
   7. Requirements regarding Supporting Multi-Head Control via
      Client ..........................................................7
   8. Multiple Message Transactions ...................................9
   9. Pub/Sub Requirements Expanded for Ephemeral State ...............9
   10. IANA Considerations ...........................................10
   11. Security Considerations .......................................10
   12. Normative References ..........................................10
   Acknowledgements ..................................................12
   Authors' Addresses ................................................12

1. Introduction 🌸

okay so the I2RS WG (Working Group) got chartered to come up with architecture and mechanisms for shoving info into the routing system and grabbing it back out 🦋. The I2RS architecture doc [RFC7921] lays out a bunch of abstract requirements and defines ephemeral state as "state that does not survive the reboot of a routing device or the reboot of the software handling the I2RS software on a routing device" (see Section 1.1 of [RFC7921]) 💀. Section 2 of this doc takes those abstract requirements and turns them into specific ones, and Section 3 makes them concrete for the ephemeral state of any IETF network management system ✨

The I2RS WG picked the YANG data modeling language [RFC7950] as the foundation for its mechanisms 💜

They also decided to reuse two existing protocols as the carriers for I2RS: NETCONF [RFC6241] and its lighter-weight cousin RESTCONF [RFC8040] 🎀

So what does "reuse" actually mean? 🤔 It means YANG plus NETCONF and RESTCONF is a solid starting point for the I2RS data modeling language and protocol, BUT the requirements for I2RS protocol implementations should:

  1. select features from YANG, NETCONF, and RESTCONF per version of the I2RS protocol (see Sections 4, 5, and 6), and
  2. propose additions to YANG, NETCONF, and RESTCONF per version of the I2RS protocol for key functions (ephemeral state, protocol security, publication/subscription service, traceability) 🫶

The whole point is to keep things clear while the I2RS protocol is being created 🌈

Support for ephemeral state is an I2RS protocol requirement that needs datastore changes (see Section 3), YANG additions (see Section 4), NETCONF additions (see Section 5), and RESTCONF additions (see Section 6) 🔥

Sections 7 through 9 add details that expand on the changes in Sections 3 through 6, clarifying stuff the I2RS and NETCONF WGs talked about 💅. Section 7 covers how write-conflicts should be resolved when two I2RS clients write the same data 👑. Section 8 describes I2RS requirements for multiple message transactions 🧚. Section 9 highlights two requirements for I2RS publication/subscription [RFC7923] that must be expanded for ephemeral state 🦋

1.1. Requirements Language 💖

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 🫶

2. Architectural Requirements for Ephemeral State ✨

The I2RS architecture [RFC7921] and the I2RS problem statement [RFC7920] define the big-picture requirements for the I2RS protocol in abstract terms 🌸. This section boils that high-level guidance down into specific requirements for the I2RS protocol 💅. There are references back to the abstract descriptions to help you follow along, but heads up: the requirements below are NOT explicitly stated in the I2RS architecture document or the I2RS problem statement 💀

Requirements:

  1. The I2RS protocol SHOULD support an asynchronous programmatic interface with properties described in Section 5 of [RFC7920] (e.g., high throughput) with support for target information streams, filtered events, and thresholded events (real-time events) sent by an I2RS agent to an I2RS client (from Section 1.1 of [RFC7921]) 🔥
  2. An I2RS agent MUST record the client identity when a node is created or modified. The I2RS agent SHOULD be able to read the client identity of a node and use the client identity's associated priority to resolve conflicts. The secondary identity is useful for traceability and may also be recorded (from Section 4 of [RFC7921]) 🎀
  3. An I2RS client identity MUST have only one priority for the client's identifier. A collision on writes is considered an error, but the priority associated with each client identifier is utilized to compare requests from two different clients in order to modify an existing node entry. Only an entry from a client that is higher priority can modify an existing entry (first entry wins). Priority only has meaning at the time of use (from Section 7.8 of [RFC7921]) 👑
  4. An I2RS client's secondary identity data is read-only metadata that is recorded by the I2RS agent associated with a data model's node when the data node is written. Just like the primary client identity, the secondary identity SHOULD only be recorded when the data node is written (from Sections 7.4 of [RFC7921].) 🧚
  5. An I2RS agent MAY have a lower-priority I2RS client attempting to modify a higher-priority client's entry in a data model. The filtering out of lower-priority clients attempting to write or modify a higher-priority client's entry in a data model SHOULD be effectively handled and SHOULD not put an undue strain on the I2RS agent. (See Section 7.8 of [RFC7921] augmented by the resource limitation language in Section 8 [RFC7921].) 🦋

3. Ephemeral State Requirements 🌈

In requirements Ephemeral-REQ-01 to Ephemeral-REQ-15, ephemeral state is defined as potentially including, in a data model, ephemeral configuration and operational state that is flagged as ephemeral 💜

3.1. Persistence 🌸

Ephemeral-REQ-01: I2RS requires ephemeral state, i.e., state that does not persist across reboots. If state must be restored, it should be done solely by replay actions from the I2RS client via the I2RS agent 🍓

At first glance, I2RS ephemeral state might seem equivalent to the writable-running datastore in NETCONF (e.g., running-config), which can be copied to a datastore that persists across a reboot (software or hardware) 🙈. BUT, I2RS ephemeral state MUST NOT persist across a reboot (software or hardware) 💀🔥

Part 1 is done, bestie 🫶 Part 2 is coming next, so stay tuned 💖

3.2. Constraints ✨

okay so constraints, let's gooo 💅

Ephemeral-REQ-02: non-ephemeral state is MUST NOT leaning on ephemeral state for its constraints 🙅‍♀️ (no exceptions, bestie). if it does anyway, it SHALL be considered a validation error. not cute.

Ephemeral-REQ-03: ephemeral state MUST be able to have constraints that point at operational state 👀 and that includes the fast-changing, short-lived stuff too, like MPLS LSP-ID (label-switched path ID) or a BGP Adj-RIB-IN (Adjacent RIB Inbound). constraints on ephemeral state should be checked when the ephemeral state gets written 📝. and if any constraint changes and stops being valid after that, the I2RS agent SHOULD notify the I2RS client 🔔 (it's giving communication, it's giving care).

Ephemeral-REQ-04: ephemeral state MUST be able to refer to non-ephemeral state as a constraint 🌸. and non-ephemeral state can be configuration state or operational state, either one works.

Ephemeral-REQ-05: okay real talk, I2RS pub-sub [RFC7923], tracing [RFC7922], RPC, or other mechanisms may lead to undesirable or unsustainable resource consumption on a system running an I2RS agent 😭. so it is RECOMMENDED that mechanisms be made available to permit prioritization of I2RS operations, when appropriate, so implementations can shed work load when they're running on constrained resources 🦋. one example of a work-shedding mechanism is rate-limiting, very main character of it.

3.3. Hierarchy 🧚

Ephemeral-REQ-06: YANG MUST have the ability to do the following:

  1. define a YANG module or submodule schema that only contains data nodes with the property of being ephemeral, and
  2. augment a YANG module with additional YANG schema nodes that have the property of being ephemeral.

3.4. Ephemeral Configuration Overlapping Local Configuration 💜

Ephemeral-REQ-07: local configuration MUST have a priority that is comparable with individual I2RS client priorities for making changes. that priority decides whether local configuration changes or individual ephemeral configuration changes take precedence, as described in [RFC7921]. and the I2RS protocol MUST support this mechanism. it's the tiebreaker energy we need 👑

4. YANG Features for Ephemeral State ✨

Ephemeral-REQ-08: in addition to config true/false, there MUST be a way to indicate that YANG schema nodes represent ephemeral state 🎀. it's also desirable to allow for, and have a way to indicate, config false YANG schema nodes that are writable operational state. so many options, I'm obsessed.

5. NETCONF Features for Ephemeral State 🌈

Ephemeral-REQ-09: the changes to NETCONF must include:

  1. Support for communication mechanisms to enable an I2RS client to determine that an I2RS agent supports the mechanisms needed for I2RS operation.
  2. The ephemeral state MUST support notification of write conflicts using the priority requirements defined in Section 7 (see requirements Ephemeral-REQ-11 through Ephemeral-REQ-14).

6. RESTCONF Features for Ephemeral State 🦋

Ephemeral-REQ-10: the conceptual changes to RESTCONF are:

  1. Support for communication mechanisms to enable an I2RS client to determine that an I2RS agent supports the mechanisms needed for I2RS operation.
  2. The ephemeral state MUST support notification of write conflicts using the priority requirements defined in Section 7 (see requirements Ephemeral-REQ-11 through Ephemeral-REQ-14).

7. Requirements regarding Supporting Multi-Head Control via Client Priority 👑

okay this section is the drama, and I'm here for it 🍿. to support multi-headed control, I2RS requires that there be a decidable means of arbitrating the correct state of data when multiple clients attempt to manipulate the same piece of data. it's done via a priority mechanism with the highest priority winning, and this priority is per client. main character priority, only one winner 💅

Ephemeral-REQ-11: the following requirements must be supported by the I2RS protocol in order to support I2RS client identity and priority:

  • the data nodes MUST store I2RS client identity and MAY store the effective priority at the time the data node is stored.
  • Per SEC-REQ-07 in Section 4.3 of [RFC8241], an I2RS Identifier MUST have just one priority. the I2RS protocol MUST support the ability to have data nodes store I2RS client identity and not the effective priority of the I2RS client at the time the data node is stored. one identity, one priority, periodt 💖
  • the priority MAY be dynamically changed by AAA, but the exact actions are part of the protocol definition, as long as collisions are handled as described in Ephemeral-REQ-12, Ephemeral-REQ-13, and Ephemeral-REQ-14.

Ephemeral-REQ-12: when a collision occurs, as two I2RS clients are trying to write the same data node, this collision is considered an error 🙈. the I2RS priorities are used to provide a deterministic resolution to the conflict. when there is a collision and the data node is changed, a notification (which includes indicating the data node the collision occurred on) MUST be sent to the original client, so the original client gets a chance to deal with the issues surrounding the collision. the original client may need to fix their state, and that's okay, we all have those moments 🫶

Explanation: RESTCONF and NETCONF updates can come in concurrently from alternative sources. so the collision detection and comparison of priority needs to occur for any type of update, no skipping 🌸

For example, RESTCONF tracks the source of configuration change via the entity-tag (see Section 3.5.2 of [RFC8040]), which the server returns to the client along with the value in GET or HEAD methods. RESTCONF requires that this resource entity-tag be updated whenever a resource or configuration resource within the resource is altered. in the RESTCONF processing, when the resource or a configuration resource within the resource is altered, the processing of the configuration change for two I2RS clients must detect an I2RS collision and resolve the collision using the priority mechanism. it's giving detective, it's giving fairness ⭐

Ephemeral-REQ-13: multi-headed control is required for collisions and the priority resolution of collisions. multi-headed control is not tied to ephemeral state, so no mixing those up 🙅‍♀️. the I2RS protocol MUST NOT mandate the internal mechanism for how AAA protocols (e.g., Radius or Diameter) or mechanisms distribute priority per identity, except that any AAA protocols MUST operate over a secure transport layer (see Radius [RFC6614] and Diameter [RFC6733]). the mechanisms that prevent collisions of two clients trying to modify the same node of data are the focus, bestie 🔥

Ephemeral-REQ-14: a deterministic conflict resolution mechanism MUST be provided to handle the error scenario in which two clients, with the same priority, update the same configuration data node. the I2RS architecture gives one way this could be achieved: by specifying that the first update wins 🥇. other solutions that prevent oscillation of the config data node are also acceptable, so there's room to be creative 🌈

8. Multiple Message Transactions 🧚‍♀️

Ephemeral-REQ-15: okay so Section 7.9 of the [RFC7921] says the I2RS architecture does not include multi-message atomicity and roll-back mechanisms 🤷‍♀️. the I2RS protocol implementation MUST NOT require the support of these features. as part of this requirement, the I2RS protocol should support:

  • multiple operations in one message. an error in one operation MUST NOT stop additional operations from being carried out, nor can it cause previous operations to be rolled back. one bad apple doesn't spoil the whole batch 🍎
  • multiple operations in multiple messages, but multiple message-command error handling MUST NOT insert errors into the I2RS ephemeral state. no sneaky errors, no cap 🫠

9. Pub/Sub Requirements Expanded for Ephemeral State 💌

I2RS clients need the ability to monitor changes to ephemeral state 👀. subscriptions are well defined for receiving notifications, but creating a notification set for all ephemeral configuration state may be overly burdensome to the user, and nobody wants that energy 😩

so, there's a need for a general subscription mechanism that can provide notification of changed state, with enough information for the client to retrieve the impacted nodes. this should be doable without requiring the notifications to be created as part of every single I2RS module. gentle, efficient, iconic ✨

The publication/subscription requirements for I2RS are in [RFC7923], and the following general requirements SHOULD be understood to be expanded to include ephemeral state:

  • Pub-Sub-REQ-01: the subscription service MUST support subscriptions against ephemeral state in operational datastores, configuration datastores, or both.
  • Pub-Sub-REQ-02: the subscription service MUST support filtering so that subscribed updates under a target node might publish either:
    1. only ephemeral state in operational data or configuration data, or
    2. both ephemeral and operational data.
  • Pub-Sub-REQ-03: the subscription service MUST support subscriptions that are ephemeral. (For example, an ephemeral data model that has ephemeral subscriptions.) ephemeral subscriptions, living their best temporary life 🦋

10. IANA Considerations 🌸

This document does not require any IANA actions. nothing to register here, so we're all good 💅

11. Security Considerations 🔐

Okay, bestie, pay attention, this part is serious 😭🚨. The security requirements for the I2RS protocol are covered in [RFC8241]. go read that one before you touch anything, because it's the whole security story and you do not want to miss a single plot point 💀

12. Normative References ✨

okay bestie, here are the normative references 📚🎀 these are the docs this one leans on so hard it literally can't be read without them 💅

Acknowledgements

this doc is basically the distilled version of sooo many long chats on the I2RS mailing list 💬🌸 the architecture was a total moving target for ages, so big love to these people for helping build the foundation:

  • Alia Atlas
  • Andy Bierman
  • Martin Bjorklund
  • Dean Bogdanavic
  • Rex Fernando
  • Joel Halpern
  • Thomas Nadeau
  • Juergen Schoenwaelder
  • Kent Watsen
  • Robert Wilton
  • Joe Clarke

you all are literally iconic 🫶💜

Authors' Addresses

Jeff Haas Juniper

Email: jhaas@juniper.net

Susan Hares Huawei Saline United States of America

Email: shares@ndzh.com

that's the whole thing, bestie! 🦋✨

📦 where this page comes from