module ietf-dmm-fpc {
yang-version 1.1;
namespace "urn:ietf:params:xml:ns:yang:ietf-dmm-fpc";
prefix fpc;
import ietf-inet-types { prefix inet;
revision-date 2013-07-15; }
import ietf-dmm-fpc-settingsext { prefix fpcbase;
revision-date 2018-05-17; }
import ietf-diam-trafficclassifier { prefix rfc5777;
revision-date 2018-05-17; }
import ietf-restconf { prefix rc;
revision-date 2017-01-26; }
import ietf-yang-patch { prefix ypatch;
revision-date 2017-02-22; }
organization "IETF Distributed Mobility Management (DMM)
Working Group";
contact
"WG Web:
WG List:
WG Chair: Dapeng Liu
WG Chair: Jouni Korhonen
Editor: Satoru Matsushima
Editor: Lyle Bertz
";
description
"This module contains YANG definition for
Forwarding Policy Configuration Protocol (FPCP).
Copyright (c) 2016 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
(http://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.";
revision 2018-05-17 {
description "Initial Revision.";
reference "draft-ietf-dmm-fpc-cpdp-10";
}
//General Structures
grouping templatedef {
leaf extensible {
type boolean;
description "Indicates if the template is extensible";
}
leaf-list static-attributes {
type string;
description "Attribute (Name) whose value cannot
change";
}
leaf-list mandatory-attributes {
type string;
description "Attribute (Name) of optional attributes
that MUST be present in instances of this tempplate.";
}
leaf entity-state {
type enumeration {
enum initial {
description "Inital Configuration";
}
enum partially-configured {
description "Partial Configuration";
}
enum configured {
description "Confgured";
}
enum active {
description "Active";
}
}
default initial;
description "Entity State";
}
leaf version {
type uint32;
description "Template Version";
}
description "Teamplate Definition";
}
typedef fpc-identity {
type union {
type uint32;
type instance-identifier;
type string;
}
description "FPC Identity";
}
grouping index {
leaf index {
type uint16;
description "Index";
}
description "Index Value";
}
// Policy Structures
grouping descriptor-template-key {
leaf descriptor-template-key {
type fpc:fpc-identity;
mandatory true;
description "Descriptor Key";
}
description "Descriptor-Template Key";
}
grouping action-template-key {
leaf action-template-key {
type fpc:fpc-identity;
mandatory true;
description "Action Key";
}
description "Action-Template Key";
}
grouping rule-template-key {
leaf rule-template-key {
type fpc:fpc-identity;
mandatory true;
description "Rule Identifier";
}
description "Rule Key";
}
grouping policy-template-key {
leaf policy-template-key {
type fpc:fpc-identity;
mandatory true;
description "Rule Identifier";
}
description "Rule Key";
}
grouping fpc-setting-value {
anydata setting;
description "FPC Setting Value";
}
// Configuration / Settings
grouping policy-configuration-choice {
choice policy-configuration-value {
case descriptor-value {
uses fpcbase:fpc-descriptor-value;
description "Descriptor Value";
}
case action-value {
uses fpcbase:fpc-action-value;
description "Action Value";
}
case setting-value {
uses fpc:fpc-setting-value;
description "Setting";
}
description "Policy Attributes";
}
description "Policy Configuration Value Choice";
}
grouping policy-configuration {
list policy-configuration {
key index;
uses fpc:index;
uses fpc:policy-configuration-choice;
description "Policy Configuration";
}
description "Policy Configuration Value";
}
grouping ref-configuration {
uses fpc:policy-template-key;
uses fpc:policy-configuration;
uses fpc:templatedef;
description "Policy-Configuration Entry";
}
// FPC Policy
grouping policy-information-model {
list action-template {
key action-template-key;
uses fpc:action-template-key;
uses fpcbase:fpc-action-value;
uses fpc:templatedef;
description "Action Template";
}
list descriptor-template {
key descriptor-template-key;
uses fpc:descriptor-template-key;
uses fpcbase:fpc-descriptor-value;
uses fpc:templatedef;
description "Descriptor Template";
}
list rule-template {
key rule-template-key;
uses fpc:rule-template-key;
leaf descriptor-match-type {
type enumeration {
enum or {
value 0;
description "OR logic";
}
enum and {
value 1;
description "AND logic";
}
}
mandatory true;
description "Type of Match (OR or AND) applied
to the descriptor-configurations";
}
list descriptor-configuration {
key "descriptor-template-key";
uses fpc:descriptor-template-key;
leaf direction {
type rfc5777:direction-type;
description "Direction";
}
list attribute-expression {
key index;
uses fpc:index;
uses fpcbase:fpc-descriptor-value;
description "Descriptor Attributes";
}
uses fpc:fpc-setting-value;
description "A set of Descriptor references";
}
list action-configuration {
key "action-order";
leaf action-order {
type uint32;
mandatory true;
description "Action Execution Order";
}
uses fpc:action-template-key;
list attribute-expression {
key index;
uses fpc:index;
uses fpcbase:fpc-action-value;
description "Action Attributes";
}
uses fpc:fpc-setting-value;
description "A set of Action references";
}
uses fpc:templatedef;
list rule-configuration {
key index;
uses fpc:index;
uses fpc:policy-configuration-choice;
description "Rule Configuration";
}
description "Rule Template";
}
list policy-template {
key policy-template-key;
uses fpc:policy-template-key;
list rule-template {
key "precedence";
unique "rule-template-key";
leaf precedence {
type uint32;
mandatory true;
description "Rule Precedence";
}
uses fpc:rule-template-key;
description "Rule Entry";
}
uses fpc:templatedef;
uses fpc:policy-configuration;
description "Policy Template";
}
description "FPC Policy Structures";
}
// Topology Information Model
identity role {
description "Role";
}
grouping dpn-key {
leaf dpn-key {
type fpc:fpc-identity;
description "DPN Key";
}
description "DPN Key";
}
grouping role-key {
leaf role-key {
type identityref {
base "fpc:role";
}
mandatory true;
description "Access Technology Role";
}
description "Access Technology Role key";
}
grouping interface-key {
leaf interface-key{
type fpc:fpc-identity;
mandatory true;
description "interface identifier";
}
description "Interface Identifier key";
}
identity interface-protocols {
description "Protocol supported by the interface";
}
identity features {
description "Protocol features";
}
// Mobility Context
grouping mobility-context {
leaf mobility-context-key {
type fpc:fpc-identity;
mandatory true;
description "Mobility Context Key";
}
leaf-list delegating-ip-prefix {
type inet:ip-prefix;
description "IP Prefix";
}
leaf parent-context {
type fpc:fpc-identity;
description "Parent Mobility Context";
}
leaf-list child-context {
type fpc:fpc-identity;
description "Child Mobility Context";
}
container mobile-node {
leaf-list ip-address {
type inet:ip-address;
description "IP Address";
}
leaf imsi {
type fpcbase:imsi-type;
description "IMSI";
}
list mn-policy-configuration {
key policy-template-key;
uses fpc:ref-configuration;
description "MN Policy Configuration";
}
description "Mobile Node";
}
container domain {
leaf domain-key {
type fpc:fpc-identity;
description "Domain Key";
}
list domain-policy-settings {
key policy-template-key;
uses fpc:ref-configuration;
description "MN Policy Configuration";
}
description "Domain";
}
list dpn {
key dpn-key;
uses fpc:dpn-key;
list dpn-policy-configuration {
key policy-template-key;
uses fpc:ref-configuration;
description "DPN Policy Configuration";
}
leaf role {
type identityref {
base "fpc:role";
}
description "Role";
}
list service-data-flow {
key identifier;
leaf identifier {
type uint32;
description "Generic Identifier";
}
leaf service-group-key {
type fpc:fpc-identity;
description "Service Group Key";
}
list interface {
key interface-key;
uses fpc:interface-key;
description "interface assigned";
}
list service-data-flow-policy-configuration {
key policy-template-key;
uses fpc:ref-configuration;
description "Flow Policy Configuration";
}
description "Service Dataflow";
}
description "DPN";
}
description "Mobility Context";
}
// Events, Probes & Notifications
identity event-type {
description "Base Event Type";
}
typedef event-type-id {
type uint32;
description "Event ID Type";
}
grouping monitor-key {
leaf monitor-key {
type fpc:fpc-identity;
mandatory true;
description "Monitor Key";
}
description "Monitor Id";
}
grouping monitor-config {
uses fpc:templatedef;
uses fpc:monitor-key;
leaf target {
type string;
description "target";
}
leaf deferrable {
type boolean;
description "Indicates reports related to this
config can be delayed.";
}
choice configuration {
mandatory true;
leaf period {
type uint32;
description "Period";
}
case threshold-config {
leaf low {
type uint32;
description "low threshold";
}
leaf hi {
type uint32;
description "high threshold";
}
description "Threshold Config Case";
}
leaf schedule {
type uint32;
description "Reporting Time";
}
leaf-list event-identities {
type identityref {
base "fpc:event-type";
}
description "Event Identities";
}
leaf-list event-ids {
type uint32;
description "Event IDs";
}
description "Event Config Value";
}
description "Monitor Configuration";
}
// Top Level Structures
list tenant {
key "tenant-key";
leaf tenant-key {
type fpc:fpc-identity;
description "Tenant Key";
}
container topology-information-model {
config false;
list service-group {
key "service-group-key role-key";
leaf service-group-key {
type fpc:fpc-identity;
mandatory true;
description "Service Group Key";
}
leaf service-group-name {
type string;
description "Service Group Name";
}
uses fpc:role-key;
leaf role-name {
type string;
mandatory true;
description "Role Name";
}
leaf-list protocol {
type identityref {
base "interface-protocols";
}
min-elements 1;
description "Supported protocols";
}
leaf-list feature {
type identityref {
base "interface-protocols";
}
description "Supported features";
}
list service-group-configuration {
key index;
uses fpc:index;
uses fpc:policy-configuration-choice;
description "Settings";
}
list dpn {
key dpn-key;
uses fpc:dpn-key;
min-elements 1;
list referenced-interface {
key interface-key;
uses fpc:interface-key;
leaf-list peer-service-group-key {
type fpc:fpc-identity;
description "Peer Service Group";
}
description "Referenced Interface";
}
description "DPN";
}
description "Service Group";
}
list dpn {
key dpn-key;
uses fpc:dpn-key;
leaf dpn-name {
type string;
description "DPN name";
}
leaf dpn-resource-mapping-reference {
type string;
description "Reference to underlying DPN resource(s)";
}
leaf domain-key {
type fpc:fpc-identity;
description "Domains";
}
leaf-list service-group-key {
type fpc:fpc-identity;
description "Service Group";
}
list interface {
key "interface-key";
uses fpc:interface-key;
leaf interface-name {
type string;
description "Service Endpoint Interface Name";
}
leaf role {
type identityref {
base "fpc:role";
}
description "Roles supported";
}
leaf-list protocol {
type identityref {
base "interface-protocols";
}
description "Supported protocols";
}
list interface-configuration {
key index;
uses fpc:index;
uses fpc:policy-configuration-choice;
description "Interface settings";
}
description "DPN interfaces";
}
list dpn-policy-configuration {
key policy-template-key;
uses fpc:ref-configuration;
description "DPN Policy Configuration";
}
description "Set of DPNs";
}
list domain {
key domain-key;
leaf domain-key {
type fpc:fpc-identity;
mandatory true;
description "Domain Key";
}
leaf domain-name {
type string;
description "Domain displayname";
}
list domain-policy-configuration {
key policy-template-key;
uses fpc:ref-configuration;
description "Domain Configuration";
}
description "List of Domains";
}
container dpn-checkpoint {
uses fpc:basename-info;
description "DPN Checkpoint information";
}
container service-group-checkpoint {
uses fpc:basename-info;
description "Service Group Checkpoint information";
}
container domain-checkpoint {
uses fpc:basename-info;
description "Domain Checkpoint information";
}
description "FPC Topology grouping";
}
container policy-information-model {
config false;
uses fpc:policy-information-model;
uses fpc:basename-info;
description "Policy";
}
list mobility-context {
key "mobility-context-key";
config false;
uses fpc:mobility-context;
description "Mobility Context";
}
list monitor {
key monitor-key;
config false;
uses fpc:monitor-config;
description "Monitor";
}
description "Tenant";
}
typedef agent-identifier {
type fpc:fpc-identity;
description "Agent Identifier";
}
typedef client-identifier {
type fpc:fpc-identity;
description "Client Identifier";
}
grouping basename-info {
leaf basename {
type fpc:fpc-identity;
description "Rules Basename";
}
leaf base-checkpoint {
type string;
description "Checkpoint";
}
description "Basename Information";
}
// RPCs
grouping client-id {
leaf client-id {
type fpc:client-identifier;
mandatory true;
description "Client Id";
}
description "Client Identifier";
}
grouping execution-delay {
leaf execution-delay {
type uint32;
description "Execution Delay (ms)";
}
description "Execution Delay";
}
typedef ref-scope {
type enumeration {
enum none {
value 0;
description "no references";
}
enum op {
value 1;
description "All references are intra-operation";
}
enum bundle {
value 2;
description "All references in exist in bundle";
}
enum storage {
value 3;
description "One or more references exist in storage.";
}
enum unknown {
value 4;
description "The location of the references are unknown.";
}
}
description "Search scope for references in the operation.";
}
rpc configure {
description "Configure RPC";
input {
uses client-id;
uses execution-delay;
uses ypatch:yang-patch;
}
output {
uses ypatch:yang-patch-status;
}
}
augment "/configure/input/yang-patch/edit" {
leaf reference-scope {
type fpc:ref-scope;
description "Reference Scope";
}
uses fpcbase:instructions;
description "yang-patch edit augments for configure rpc";
}
grouping subsequent-edits {
list subsequent-edit {
key edit-id;
ordered-by user;
description "Edit list";
leaf edit-id {
type string;
description "Arbitrary string index for the edit.";
}
leaf operation {
type enumeration {
enum create {
description "Create";
}
enum delete {
description "Delete";
}
enum insert {
description "Insert";
}
enum merge {
description "Merge";
}
enum move {
description "Move";
}
enum replace {
description "Replace";
}
enum remove {
description
"Delete the target node if it currently exists.";
}
}
mandatory true;
description
"The datastore operation requested";
}
leaf target {
type ypatch:target-resource-offset;
mandatory true;
description
"Identifies the target data node";
}
leaf point {
when "(../operation = 'insert' or ../operation = 'move')"
+ "and (../where = 'before' or ../where = 'after')" {
description
"This leaf only applies for 'insert' or 'move'
operations, before or after an existing entry.";
}
type ypatch:target-resource-offset;
description
"The absolute URL path for the data node";
}
leaf where {
when "../operation = 'insert' or ../operation = 'move'" {
description
"This leaf only applies for 'insert' or 'move'
operations.";
}
type enumeration {
enum before {
description
"Insert or move a data node before.";
}
enum after {
description
"Insert or move a data node after.";
}
enum first {
description
"Insert or move a data node so it becomes ordered
as the first entry.";
}
enum last {
description
"Insert or move a data node so it becomes ordered
as the last entry.";
}
}
default last;
description
"Identifies where a data resource will be inserted
or moved.";
}
anydata value {
when "../operation = 'create' "
+ "or ../operation = 'merge' "
+ "or ../operation = 'replace' "
+ "or ../operation = 'insert'" {
description
"The anydata 'value' is only used for 'create',
'merge', 'replace', and 'insert' operations.";
}
description
"Value used for this edit operation.";
}
}
description "Subsequent Edits";
}
augment "/configure/output/yang-patch-status/edit-status/edit/"
+ "edit-status-choice/ok" {
leaf notify-follows {
type boolean;
description "Notify Follows Indication";
}
uses fpc:subsequent-edits;
description "Configure output augments";
}
grouping op-header {
uses client-id;
uses execution-delay;
leaf operation-id {
type uint64;
mandatory true;
description "Operation Identifier";
}
description "Common Operation header";
}
grouping monitor-response {
leaf operation-id {
type uint64;
mandatory true;
description "Operation Identifier";
}
choice edit-status-choice {
description
"A choice between different types of status
responses for each 'edit' entry.";
leaf ok {
type empty;
description
"This 'edit' entry was invoked without any
errors detected by the server associated
with this edit.";
}
case errors {
uses rc:errors;
description
"The server detected errors associated with the
edit identified by the same 'edit-id' value.";
}
}
description "Monitor Response";
}
// Common RPCs
rpc register_monitor {
description "Used to register monitoring of parameters/events";
input {
uses fpc:op-header;
list monitor {
key monitor-key;
uses fpc:monitor-config;
description "Monitor Configuration";
}
}
output {
uses fpc:monitor-response;
}
}
rpc deregister_monitor {
description "Used to de-register monitoring of
parameters/events";
input {
uses fpc:op-header;
list monitor {
key monitor-key;
uses fpc:monitor-key;
min-elements 1;
leaf send_data {
type boolean;
description "Indicates if NOTIFY with final data
is desired upon deregistration";
}
description "Monitor Identifier";
}
}
output {
uses fpc:monitor-response;
}
}
rpc probe {
description "Probe the status of a registered monitor";
input {
uses fpc:op-header;
list monitor {
key monitor-key;
uses fpc:monitor-key;
min-elements 1;
description "Monitor";
}
}
output {
uses fpc:monitor-response;
}
}
// Notification Messages & Structures
notification config-result-notification {
uses ypatch:yang-patch-status;
description "Configuration Result Notification";
}
augment "/config-result-notification" {
uses fpc:subsequent-edits;
description "config-result-notificatio augment";
}
identity notification-cause {
description "Notification Cause";
}
identity subscribed-event-occurred {
base "notification-cause";
description "Subscribed Event Occurence";
}
identity low-threshold-crossed {
base "notification-cause";
description "Subscribed Event Occurence";
}
identity high-threshold-crossed {
base "notification-cause";
description "Subscribed Event Occurence";
}
identity periodic-report {
base "notification-cause";
description "Periodic Report";
}
identity scheduled-report {
base "notification-cause";
description "Scheduled Report";
}
identity probe {
base "notification-cause";
description "Probe";
}
identity deregistration-final-value {
base "notification-cause";
description "Probe";
}
identity monitoring-suspension {
base "notification-cause";
description "Indicates monitoring suspension";
}
identity monitoring-resumption {
base "notification-cause";
description "Indicates that monitoring has resumed";
}
identity dpn-available {
base "notification-cause";
description "DPN Candidate Available";
}
identity dpn-unavailable {
base "notification-cause";
description "DPN Unavailable";
}
notification notify {
leaf notification-id {
type uint32;
description "Notification Identifier";
}
leaf timestamp {
type uint32;
description "timestamp";
}
list report {
key monitor-key;
uses fpc:monitor-key;
min-elements 1;
leaf trigger {
type identityref {
base "notification-cause";
}
description "Notification Cause";
}
choice value {
case dpn-candidate-available {
leaf node-id {
type inet:uri;
description "Topology URI";
}
list supported-interface-list {
key role-key;
uses fpc:role-key;
description "Support Intefaces";
}
description "DPN Candidate Information";
}
case dpn-unavailable {
leaf dpn-id {
type fpc:fpc-identity;
description "DPN Identifier for DPN Unavailable";
}
description "DPN Unavailable";
}
anydata report-value {
description "Any non integer report";
}
description "Report Value";
}
description "Report";
}
description "Notify Message";
}
}