packetcable-policy-model/src/main/yang/packetcable.yang

   1 module packetcable
   2 {
   3     namespace "urn:packetcable";
   4     prefix "pcmm";
   5
   6     import ietf-yang-types     { prefix yang;  revision-date "2013-07-15"; }
   7     import ietf-inet-types     { prefix inet; revision-date "2013-07-15"; }
   8     import yang-ext { prefix ext; revision-date "2013-07-09"; }
   9
  10     description "This module contains the PCMM Converged Cable Access Platform (CCAP) definitions";
  11     organization "OpenDaylight Project";
  12
  13     revision 2017-02-24 {
  14         description "Added RPC operations for set/delete/info on gates";
  15     }
  16     revision 2017-01-25 {
  17         description "Added support for UGS and RTP traffic profiles";
  18     }
  19     revision 2016-12-19 {
  20         description "Added support for flow-spec traffic profile";
  21     }
  22     revision 2016-11-28 {
  23         description "Added support for activation-state, session-class-id and inactivity-timer";
  24     }
  25     revision 2016-11-07 {
  26         description "Added priority field to all classifiers";
  27     }
  28     revision 2016-10-17 {
  29         description "Modified service-flow-direction values to match the PCMM Spec";
  30     }
  31     revision 2015-11-01 {
  32         description "Extended gates to support multiple classifiers.";
  33     }
  34     revision 2015-10-26 {
  35         description "Corrected pluralization of containers/lists and added containers around lists where needed";
  36     }
  37     revision 2015-03-27 {
  38         description "Initial revision of PCMM CCAP definitions";
  39     }
  40
  41     // Global typedefs
  42
  43     typedef s-type {
  44         type uint8;
  45         description "RSVP sub-type per PCMM specification.";
  46     }
  47
  48     typedef service-class-name {
  49         type string { length "2..16"; }
  50         description "The Service Class Name is MUST be 2-16 bytes.";
  51     }
  52     typedef service-flow-direction {
  53         type enumeration {
  54             enum ds {
  55                 value "0";
  56                 description "Downstream service flow.";
  57             }
  58             enum us {
  59                 value "1";
  60                 description "Upstream service flow.";
  61             }
  62         }
  63         description "This value represents the service flow direction.";
  64     }
  65
  66     typedef classifier-activation-state {
  67         type enumeration {
  68             enum inactive {
  69                 value 0;
  70                 description "Inactive";
  71             }
  72             enum active {
  73                 value 1;
  74                 description "Active";
  75             }
  76         }
  77         description "Instructs the CMTS to either activate or inactivate the classifier";
  78     }
  79
  80     typedef classifier-action {
  81         type enumeration {
  82             enum add {
  83                 value 0;
  84                 description "Add classifier";
  85             }
  86             enum replace {
  87                 value 1;
  88                 description "Replace classifier";
  89             }
  90             enum delete {
  91                 value 2;
  92                 description "Delete classifier";
  93             }
  94             enum nochange {
  95                 value 3;
  96                 description "No change to classifier";
  97             }
  98         }
  99         description "Instructs the CMTS to add,replace,delete or leave the classifier";
 100     }
 101
 102     typedef tp-protocol {
 103         type uint16 {range "0..257";}
 104         description "This value represents the IP transport protocol (or Next Header) where 256 is any protocol and 257 is TCP or UDP";
 105     }
 106     typedef tos-byte {
 107         type uint8;
 108         description "TOS/TC byte or mask";
 109     }
 110
 111     identity ccap-context {
 112         description "Identity used to mark ccap context";
 113     }
 114
 115     // CCAP devices
 116     container ccaps {
 117         list ccap {
 118             description "
 119                 CCAP devices are known by their network name which is any string.
 120                 Each CCAP device has a network address:port, a list of subscriber IP subnets,
 121                 and a list of available Service Class Names.
 122                 ";
 123             key "ccapId";
 124             ext:context-instance "ccap-context";
 125             leaf ccapId {
 126                 type string;
 127                 description "CCAP Identity";
 128                 mandatory true;
 129             }
 130             uses ccap-attributes;
 131         }
 132     }
 133
 134     identity app-context {
 135         description "Identity used to mark app context";
 136     }
 137
 138     container apps {
 139         list app {
 140             key "id";
 141             ext:context-instance "app-context";
 142             leaf "id" {
 143                 type string;
 144                 mandatory true;
 145             }
 146         }
 147     }
 148
 149     grouping ccap-connection {
 150         leaf ipAddress {
 151             type inet:ip-address;
 152             description "IP Address of CCAP";
 153             mandatory true;
 154         }
 155         leaf port {
 156             type inet:port-number;
 157             description "COPS session TCP port number";
 158             default 3918;
 159         }
 160         leaf connected {
 161             config false;
 162             type boolean;
 163             description "COPS session state";
 164             mandatory true;
 165         }
 166         leaf-list error {
 167             config false;
 168             type string;
 169             description "Operational errors";
 170         }
 171         leaf timestamp {
 172             config false;
 173             type yang:date-and-time;
 174             description "Last update timestamp";
 175             mandatory true;
 176         }
 177     }
 178
 179     grouping ccap-attributes {
 180         description "
 181             Each CCAP device has a COPS connection address:port,
 182             a list of subscriber IP subnets, and
 183             a list of available Service Class Names.
 184             ";
 185         container connection {
 186             uses ccap-connection;
 187         }
 188         container amId {
 189             leaf am-tag {
 190                 type uint16;
 191                 description "Application Manager Tag -- unique for this operator";
 192                 mandatory true;
 193             }
 194             leaf am-type {
 195                 type uint16;
 196                 description "Application Manager Type -- unique for this AM tag";
 197                 mandatory true;
 198             }
 199         }
 200         leaf-list subscriber-subnets {
 201             type inet:ip-prefix;
 202         }
 203         leaf-list upstream-scns {
 204             type service-class-name;
 205         }
 206         leaf-list downstream-scns {
 207             type service-class-name;
 208         }
 209         leaf-list error {
 210             config false;
 211             type string;
 212             description "ccap data errors";
 213         }
 214     }
 215
 216     // PCMM QoS Gates
 217     container qos {
 218         description "
 219             PCMM QoS Gates are organized as a tree by Application/Subscriber/Gate:
 220                 Each Application is known by its appId which is any string.
 221                 Each Subscriber is known by its subscriberId which is a CPE IP address in either IPv4 or IPv6 format.
 222                 Each Gate is known by its gateId which is any string.
 223
 224             The subscriber's CPE IP address is used to locate the CCAP device that is currently hosting the
 225             the Cable Modem that is connected to the subscriber's device. Therefore, it is not necessary
 226             for the PCMM applications to know the topology of the CCAP devices and CMs in the network path
 227             to their subscriber devices.
 228
 229             Note that each CCAP entry contains a list of connected subscriber IP subnets as well as a list
 230             of all Service Class Names (SCNs) available on the CCAP device.
 231             ";
 232         uses pcmm-qos-gates;
 233     }
 234
 235     grouping pcmm-qos-gates {
 236         container apps {
 237             list app {
 238                 key "appId";
 239                 ext:context-instance "app-context";
 240                 leaf appId {
 241                     type string;
 242                     description "Application Identity";
 243                 }
 244                 container subscribers {
 245                     list subscriber {
 246                         key "subscriberId";
 247                         leaf subscriberId {
 248                             type string;
 249                             description "Subscriber Identity -- must be a CM or CPE IP address";
 250                             mandatory true;
 251                         }
 252                         container gates {
 253                             list gate {
 254                                 key "gateId";
 255                                 leaf gateId {
 256                                     type string;
 257                                     description "Qos Gate Identity";
 258                                     mandatory true;
 259                                 }
 260                                 uses gate-operational-attributes;
 261                                 uses pcmm-qos-gate-attributes;
 262                             }
 263                         }
 264                     }
 265                 }
 266             }
 267         }
 268     }
 269
 270     grouping gate-operational-attributes {
 271         leaf gatePath {
 272             config false;
 273             type string;
 274             description "FQ Gate path app/subscriber/gate";
 275             mandatory true;
 276         }
 277         leaf ccapId {
 278             config false;
 279             type string;
 280             description "CCAP Identity";
 281             mandatory true;
 282         }
 283         leaf cops-gate-state {
 284             config false;
 285             type string;
 286             description "Operational COPS Gate state";
 287             mandatory true;
 288         }
 289         leaf cops-gate-time-info {
 290             config false;
 291             type string;
 292             description "Operational COPS Gate time info";
 293             mandatory true;
 294         }
 295         leaf cops-gate-usage-info {
 296             config false;
 297             type string;
 298             description "Operational COPS gate usage info";
 299             mandatory true;
 300         }
 301         leaf cops-gateId {
 302             config false;
 303             type string;
 304             description "Gate operational COPS Id";
 305             mandatory true;
 306         }
 307         leaf-list error {
 308             config false;
 309             type string;
 310             description "Gate operational error";
 311         }
 312         leaf timestamp {
 313             config false;
 314             type yang:date-and-time;
 315             description "Gate operational attributes timestamp";
 316             mandatory true;
 317         }
 318     }
 319
 320
 321     grouping classifier-attributes {
 322         container classifiers {
 323             list classifier-container {
 324                 key "classifier-id";
 325                 leaf classifier-id {
 326                     type uint8;
 327                     description "Classifier ID and Gate classifier priority";
 328                 }
 329                 choice classifier-choice {
 330                     case qos-classifier-choice {
 331                         uses pcmm-qos-classifier;
 332                     }
 333                     case ext-classifier-choice {
 334                         uses pcmm-qos-ext-classifier;
 335                     }
 336                     case ipv6-classifier-choice {
 337                         uses pcmm-qos-ipv6-classifier;
 338                     }
 339                 }
 340             }
 341         }
 342     }
 343
 344     grouping pcmm-qos-gate-attributes {
 345         uses pcmm-qos-gate-spec;
 346         uses pcmm-qos-traffic-profile;
 347         uses classifier-attributes;
 348     }
 349
 350     grouping pcmm-qos-gate-spec {
 351         container gate-spec {
 352             leaf direction {
 353                 type service-flow-direction;
 354                 description "Gate Direction (ignored for traffic profile SCN)";
 355             }
 356             leaf dscp-tos-overwrite {
 357                 type tos-byte;
 358                 description "Optional DSCP/TOS overwrite value";
 359             }
 360             leaf dscp-tos-mask {
 361                 type tos-byte;
 362                 description "Optional DSCP/TOS overwrite AND mask";
 363             }
 364             leaf inactivity-timer {
 365                 type uint32;
 366                 description "Service Flow inactivity timeout";
 367             }
 368             leaf session-class-id {
 369                 type uint8;
 370                 description "Identifies the proper admission control policy or parameters to be applied for this Gate";
 371                 default 0;
 372             }
 373         }
 374     }
 375
 376     grouping pcmm-qos-traffic-profile {
 377         container traffic-profile {
 378             choice traffic-profile-choice {
 379                 case ugs-choice {
 380                     uses pcmm-ugs-profile;
 381                 }
 382                 case rtp-choice {
 383                     uses pcmm-rtp-profile;
 384                 }
 385                 case service-class-name-choice {
 386                     uses pcmm-serviceclass-name-profile;
 387                 }
 388                 case flow-spec-choice {
 389                     uses pcmm-flow-spec-profile;
 390                 }
 391             }
 392         }
 393     }
 394
 395     grouping pcmm-serviceclass-name-profile {
 396         container service-class-name-profile {
 397             leaf service-class-name {
 398                 type service-class-name;
 399                 description "The Service Class Name (SCN). This SCN must be pre-provisioned on the target CCAP";
 400                 mandatory true;
 401             }
 402         }
 403     }
 404
 405     grouping pcmm-flow-spec-profile {
 406         container flow-spec-profile {
 407             leaf token-bucket-rate {
 408                 type int32;
 409                 description "Token Bucket Rate value [r]";
 410                 mandatory true;
 411             }
 412             leaf token-bucket-size {
 413                 type int32;
 414                 description "Token Bucket Size value [b]";
 415                 mandatory true;
 416             }
 417             leaf peak-data-rate {
 418                 type int32;
 419                 description "Peak Data Rate value [p]";
 420                 mandatory true;
 421             }
 422             leaf minimum-policed-unit {
 423                 type int32;
 424                 description "Minimum Policed Unit value [m]";
 425                 mandatory true;
 426             }
 427             leaf maximum-packet-size {
 428                 type int32;
 429                 description "Maximum Packet Size value [M]";
 430                 mandatory true;
 431             }
 432             leaf rate {
 433                 type int32;
 434                 description "Rate value [R]";
 435                 mandatory true;
 436             }
 437             leaf slack-term {
 438                 type int32;
 439                 description "Slack Term value [S]";
 440                 mandatory true;
 441             }
 442         }
 443     }
 444
 445     grouping pcmm-ugs-profile {
 446         container ugs-profile {
 447             leaf request-transmission-policy {
 448                 type uint32;
 449                 description "Request Transmission Policy";
 450                 mandatory true;
 451             }
 452             leaf unsolicited-grant-size {
 453                 type uint32;
 454                 description "Unsolicited Grant Size";
 455                 mandatory true;
 456             }
 457             leaf grants-per-interval {
 458                 type uint8;
 459                 description "Grants per Interval";
 460                 mandatory true;
 461             }
 462             leaf nominal-grant-interval {
 463                 type uint32;
 464                 description "Nominal Grant Interval";
 465                 mandatory true;
 466             }
 467             leaf tolerated-grant-jitter {
 468                 type uint32;
 469                 description "Tolerated Grant Jitter";
 470                 mandatory true;
 471             }
 472             leaf upstream-peak-traffic-rate {
 473                 type uint32;
 474                 description "Upstream Peak Traffic Interval";
 475                 mandatory true;
 476             }
 477             leaf required-attribute-mask {
 478                 type uint32;
 479                 description "Required Attribute Mask";
 480                 mandatory true;
 481             }
 482             leaf forbidden-attribute-mask {
 483                 type uint32;
 484                 description "Forbidden Attribute Mask";
 485                 mandatory true;
 486             }
 487             leaf attribute-aggregation-rule-mask {
 488                 type uint32;
 489                 description "Attribute Aggregation Rule Mask";
 490                 mandatory true;
 491             }
 492             leaf minimum-buffer {
 493                 type uint32;
 494                 description "Minimum Buffer";
 495             }
 496             leaf target-buffer {
 497                 type uint32;
 498                 description "Forbidden Attribute Mask";
 499             }
 500             leaf maximum-buffer {
 501                 type uint32;
 502                 description "Forbidden Attribute Mask";
 503             }
 504         }
 505     }
 506
 507     grouping pcmm-rtp-profile {
 508         container rtp-profile {
 509             leaf request-transmission-policy {
 510                 type uint32;
 511                 description "Request Transmission Policy";
 512                 mandatory true;
 513             }
 514             leaf maximum-sustained-traffic-rate {
 515                 type uint32;
 516                 description "Maximum Sustained Traffic Rate";
 517                 default 0;
 518             }
 519             leaf maximum-traffic-burst {
 520                 type uint32;
 521                 description "Maximum Traffic Burst";
 522                 default 3044;
 523             }
 524             leaf minimum-reserved-traffic-rate {
 525                 type uint32;
 526                 description "Minimum Reserved Traffic Rate";
 527                 default 0;
 528             }
 529             leaf amrtr-packet-size {
 530                 type uint16;
 531                 description "Assumed Minimum Reserved Traffic Rate Packet Size";
 532                 default 0;
 533             }
 534             leaf maximum-concatenated-burst {
 535                 type uint16;
 536                 description "Maximum Concatenated Burst";
 537                 default 1522;
 538             }
 539             leaf nominal-polling-interval {
 540                 type uint32;
 541                 description "Nominal Polling Interval";
 542                 mandatory true;
 543             }
 544             leaf tolerated-poll-jitter {
 545                 type uint32;
 546                 description "Tolerated Poll Jitter";
 547                 default 0;
 548             }
 549             leaf upstream-peak-traffic-rate {
 550                 type uint32;
 551                 description "Upstream Peak Traffic Rate";
 552                 mandatory true;
 553             }
 554             leaf required-attribute-mask {
 555                 type uint32;
 556                 description "Required Attribute Mask";
 557                 mandatory true;
 558             }
 559             leaf forbidden-attribute-mask {
 560                 type uint32;
 561                 description "Forbidden Attribute Mask";
 562                 mandatory true;
 563             }
 564             leaf attribute-aggregation-rule-mask {
 565                 type uint32;
 566                 description "Attribute Aggregation Rule Mask";
 567                 mandatory true;
 568             }
 569             leaf minimum-buffer {
 570                 type uint32;
 571                 description "Minimum Buffer";
 572             }
 573             leaf target-buffer {
 574                 type uint32;
 575                 description "Forbidden Attribute Mask";
 576             }
 577             leaf maximum-buffer {
 578                 type uint32;
 579                 description "Forbidden Attribute Mask";
 580             }
 581         }
 582     }
 583
 584     grouping tp-port-match-ranges {
 585         leaf srcPort-start {
 586             type inet:port-number;
 587             description "TCP/UDP source port range start.";
 588             mandatory true;
 589         }
 590         leaf srcPort-end {
 591             type inet:port-number;
 592             description "TCP/UDP source port range end.";
 593             mandatory true;
 594         }
 595         leaf dstPort-start {
 596             type inet:port-number;
 597             description "TCP/UDP destination port range start.";
 598             mandatory true;
 599         }
 600         leaf dstPort-end {
 601             type inet:port-number;
 602             description "TCP/UDP destination port range end.";
 603             mandatory true;
 604         }
 605     }
 606
 607     grouping pcmm-qos-classifier {
 608         container classifier {
 609             leaf srcIp {
 610                 type inet:ipv4-address;
 611                 description "Source IPv4 address (exact match)";
 612                 mandatory true;
 613             }
 614             leaf dstIp {
 615                 type inet:ipv4-address;
 616                 description "Destination IPv4 address (exact match)";
 617                 mandatory true;
 618             }
 619             leaf tos-byte {
 620                 type tos-byte;
 621                 description "TOS/DSCP match";
 622                 mandatory true;
 623             }
 624             leaf tos-mask {
 625                 type tos-byte;
 626                 description "TOS/DSCP mask";
 627                 mandatory true;
 628             }
 629             leaf protocol {
 630                 type tp-protocol;
 631                 description "IPv4 transport protocol";
 632                 mandatory true;
 633             }
 634             leaf srcPort {
 635                 type inet:port-number;
 636                 description "TCP/UDP source port (exact match).";
 637                 mandatory true;
 638             }
 639             leaf dstPort {
 640                 type inet:port-number;
 641                 description "TCP/UDP destination port (exact match).";
 642                 mandatory true;
 643             }
 644             leaf priority {
 645                 type uint8;
 646                 description "Priority";
 647                 default 64;
 648             }
 649         }
 650     }
 651
 652     grouping pcmm-qos-ext-classifier {
 653         container ext-classifier {
 654             leaf srcIp {
 655                 type inet:ipv4-address;
 656                 description "Source IPv4 address match";
 657                 mandatory true;
 658             }
 659             leaf srcIpMask {
 660                 type inet:ipv4-address;
 661                 description "Source IPv4 mask";
 662                 mandatory true;
 663             }
 664             leaf dstIp {
 665                 type inet:ipv4-address;
 666                 description "Destination IPv4 address match";
 667                 mandatory true;
 668             }
 669             leaf dstIpMask {
 670                 type inet:ipv4-address;
 671                 description "Destination IPv4 mask";
 672                 mandatory true;
 673             }
 674             leaf tos-byte {
 675                 type tos-byte;
 676                 description "TOS/DSCP match";
 677                 mandatory true;
 678             }
 679             leaf tos-mask {
 680                 type tos-byte;
 681                 description "TOS/DSCP mask";
 682                 mandatory true;
 683             }
 684             leaf protocol {
 685                 type tp-protocol;
 686                 description "IPv4 transport protocol";
 687                 mandatory true;
 688             }
 689             leaf priority {
 690                 type uint8;
 691                 description "Priority";
 692                 default 64;
 693             }
 694             uses tp-port-match-ranges;
 695             leaf activation-state {
 696                 type classifier-activation-state;
 697                 description "Activation state";
 698                 default active;
 699             }
 700             leaf action {
 701                 type classifier-action;
 702                 description "Action";
 703                 default add;
 704             }
 705         }
 706     }
 707
 708     grouping pcmm-qos-ipv6-classifier {
 709         container ipv6-classifier {
 710             leaf srcIp6 {
 711                 type inet:ipv6-prefix;
 712                 description "Source IPv6 prefix match in  'address/len' notation";
 713                 mandatory true;
 714             }
 715             leaf dstIp6 {
 716                 type inet:ipv6-prefix;
 717                 description "Destination IPv6 prefix match in 'address/len' notation";
 718                 mandatory true;
 719             }
 720             leaf tc-low {
 721                 type tos-byte;
 722                 description "TC low range match";
 723                 mandatory true;
 724             }
 725             leaf tc-high {
 726                 type tos-byte;
 727                 description "TC high range match";
 728                 mandatory true;
 729             }
 730             leaf tc-mask {
 731                 type tos-byte;
 732                 description "TC mask";
 733                 mandatory true;
 734             }
 735             leaf next-hdr {
 736                 type tp-protocol;
 737                 description "IPv6 Next Header";
 738                 mandatory true;
 739             }
 740             leaf flow-label {
 741                 type uint32 {
 742                     range "0 .. 1048575";
 743                 }
 744                 description "IPv6 Flow Label (20 bits)";
 745                 mandatory true;
 746             }
 747             leaf priority {
 748                 type uint8;
 749                 description "Priority";
 750                 default 64;
 751             }
 752             uses tp-port-match-ranges;
 753             leaf activation-state {
 754                 type classifier-activation-state;
 755                 description "Activation state";
 756                 default active;
 757             }
 758             leaf action {
 759                 type classifier-action;
 760                 description "Action";
 761                 default add;
 762             }
 763         }
 764     }
 765
 766     typedef failure-type {
 767         description "Enumeration of the distinct types of operational failure modes
 768                  that can occur while servicing a southbound PCMM request";
 769         type enumeration {
 770             enum unsent {
 771                 description "The request failed before it was sent to the CMTS.";
 772             }
 773             enum no-ack {
 774                 description "The request was not acknowledged by the CMTS.";
 775             }
 776             enum failed {
 777                 description "The request was sent to the CMTS and an error response was returned";
 778             }
 779         }
 780     }
 781
 782
 783     grouping failure-response {
 784         description "The structure of a failure response from a PCMM request";
 785         leaf failure {
 786             type failure-type;
 787         }
 788         leaf message {
 789             type string;
 790         }
 791     }
 792
 793     grouping qos-set-gate-response {
 794         choice set-response-type {
 795             case set-failure {
 796                 uses failure-response;
 797             }
 798             case set-successful {
 799                 leaf cops-gateId {
 800                     type uint32;
 801                     description "Unique identifier assigned by CMTS for the requested gate";
 802                 }
 803             }
 804         }
 805     }
 806
 807     grouping qos-delete-gate-response {
 808         choice delete-response-type {
 809             case delete-failure {
 810                 uses failure-response;
 811             }
 812             case delete-successful {
 813                 leaf cops-gateId {
 814                     type uint32;
 815                     description "Unique identifier assigned by CMTS for the requested gate";
 816                 }
 817             }
 818         }
 819     }
 820
 821     //RPCs
 822     rpc ccap-set-connection {
 823         input {
 824             leaf ccapId {
 825                 type "instance-identifier";
 826                 ext:context-reference "ccap-context";
 827             }
 828             container connection {
 829                 leaf connected {
 830                     type boolean;
 831                     description "COPS session state";
 832                 }
 833             }
 834         }
 835         output {
 836             container ccap {
 837                 leaf ccapId {
 838                     type string;
 839                 }
 840                 container connection {
 841                     uses ccap-connection;
 842                 }
 843             }
 844             leaf response {
 845                 type string;
 846             }
 847             leaf timestamp {
 848                 type yang:date-and-time;
 849                 description "RPC timestamp";
 850             }
 851         }
 852     }
 853
 854     rpc ccap-poll-connection {
 855         input {
 856             leaf ccapId {
 857                 type "instance-identifier";
 858                 ext:context-reference "ccap-context";
 859             }
 860         }
 861         output {
 862             container ccap {
 863                 leaf ccapId {
 864                     type string;
 865                 }
 866                 container connection {
 867                     uses ccap-connection;
 868                 }
 869             }
 870             leaf response {
 871                 type string;
 872             }
 873             leaf timestamp {
 874                 type yang:date-and-time;
 875                 description "RPC timestamp";
 876             }
 877         }
 878     }
 879
 880     rpc qos-poll-gates {
 881         input {
 882             leaf appId {
 883                 type instance-identifier;
 884                 ext:context-reference app-context;
 885             }
 886             leaf subscriberId {
 887                 type string;
 888                 description "Subscriber Identity -- must be a CM or CPE IP address";
 889             }
 890             leaf gateId {
 891                 type string;
 892                 description "Qos Gate Identity";
 893             }
 894         }
 895         output {
 896             container gate {
 897                 uses gate-operational-attributes;
 898             }
 899             leaf response {
 900                 type string;
 901             }
 902             leaf timestamp {
 903                 type yang:date-and-time;
 904                 description "RPC timestamp";
 905             }
 906         }
 907     }
 908
 909     rpc qos-set-gate {
 910         input {
 911             leaf "appId" {
 912                 type string;
 913                 description "Application Identity";
 914                 mandatory true;
 915             }
 916             leaf subscriberId {
 917                 type string;
 918                 description "Subscriber Identity -- must be a CM or CPE IP address";
 919                 mandatory true;
 920             }
 921             container gates {
 922                 list gate {
 923                     key "gateId";
 924                     leaf gateId {
 925                         type string;
 926                         description "Qos Gate Identity";
 927                         mandatory true;
 928                     }
 929                     uses gate-operational-attributes;
 930                     uses pcmm-qos-gate-attributes;
 931                 }
 932             }
 933         }
 934         output {
 935             uses qos-set-gate-response;
 936         }
 937     }
 938
 939     rpc qos-delete-gate {
 940         input {
 941             leaf "appId" {
 942                 type string;
 943                 description "Application Identity";
 944                 mandatory true;
 945             }
 946             leaf subscriberId {
 947                 type string;
 948                 description "Subscriber Identity -- must be a CM or CPE IP address";
 949                 mandatory true;
 950             }
 951             leaf gateId {
 952                 type string;
 953                 description "Qos Gate Identity";
 954                 mandatory true;
 955             }
 956         }
 957         output {
 958             uses qos-delete-gate-response;
 959         }
 960     }
 961
 962     rpc qos-gate-info {
 963         input {
 964             leaf "appId" {
 965                 type string;
 966                 description "Application Identity";
 967                 mandatory true;
 968             }
 969             leaf subscriberId {
 970                 type string;
 971                 description "Subscriber Identity -- must be a CM or CPE IP address";
 972                 mandatory true;
 973             }
 974             leaf gateId {
 975                 type string;
 976                 description "Qos Gate Identity";
 977                 mandatory true;
 978             }
 979         }
 980         output {
 981             uses qos-gate-info-response;
 982         }
 983     }
 984
 985     grouping qos-gate-info-response {
 986         choice info-response-type {
 987             case info-failure {
 988                 uses failure-response;
 989             }
 990             case info-successful {
 991                 container gates {
 992                     list gate {
 993                         key "gateId";
 994                         leaf gateId {
 995                             type string;
 996                             description "Qos Gate Identity";
 997                         }
 998                         uses gate-operational-attributes;
 999                         uses pcmm-qos-gate-attributes;
1000                     }
1001                 }
1002             }
1003         }
1004     }
1005 }