module pcep-types {
	yang-version 1;
	namespace "urn:opendaylight:params:xml:ns:yang:pcep:types";
	prefix "pcep-t";

	import ieee754 { prefix ieee754; revision-date 2013-08-19; }
	import ietf-inet-types { prefix inet; revision-date 2010-09-24; }
	import rsvp { prefix rsvp; revision-date 2013-08-20; }

	organization "Cisco Systems, Inc.";
	contact "Robert Varga <rovarga@cisco.com>";

	description
		"This module contains the base data model of a PCEP message.
		It rolls up the definitions contained in RFC5440, RFC5520
		and RFC6006.

		Copyright (c)2013 Cisco Systems, Inc. All rights reserved.

		This program and the accompanying materials are made available
		under the terms of the Eclipse Public License v1.0 which
		accompanies this distribution, and is available at
		http://www.eclipse.org/legal/epl-v10.html";

	revision "2013-10-05" {
		description
			"Initial revision.";
		reference "RFC5440";
	}

	// NOTE: this model uses counts bits in fields from left to right,
	//       just as IANA does for PCEP protocol.

	// Types
	typedef protocol-version {
		type uint8 {
			range 1..7;
		}
	}

	typedef request-id {
		type uint32 {
			range 1..max;
		}
	}

	typedef plsp-id {
		type uint32 {
			range 0..1048576;
		}
	}

	typedef srp-id-number {
		type uint32 {
			range 1..4294967294;
		}
	}

	typedef of-id {
		type uint16;
	}

	typedef path-key {
		type uint16;
	}

	typedef pce-id {
		type union {
			type binary {
				length 4;
			}
			type binary {
				length 16;
			}
		}
	}

	typedef symbolic-path-name {
		type binary;
	}

	typedef operational-status {
		type enumeration {
			enum down {
				value 0;
			}
			enum up {
				value 1;
			}
			enum active {
				value 2;
			}
			enum going-down {
				value 3;
			}
			enum going-up {
				value 4;
			}
		}
	}

	// TLVs
	grouping tlv {
		description "Marker grouping for TLV groupings.";
	}

	grouping no-path-vector-tlv {
		description "NO-PATH-VECTOR TLV";
		reference "https://tools.ietf.org/html/rfc5440#section-7.5";

		uses tlv;
		leaf flags {
			type bits {
				bit p2mp-unreachable {
					position 24;
				}
				bit no-gco-solution {
					position 25;
				}
				bit no-gco-migration {
					position 26;
				}
				bit path-key {
					reference "https://tools.ietf.org/html/rfc5520#section-7.4";
					position 27;
				}
				bit chain-unavailable {
					position 28;
				}
				bit unknown-source {
					position 29;
				}
				bit unknown-destination {
					position 30;
				}
				bit pce-unavailable {
					position 31;
				}
			}
			mandatory true;
		}
	}

	grouping overload-duration-tlv {
		description "OVERLOAD-DURATION TLV";
		reference "https://tools.ietf.org/html/rfc5440#section-7.14";
		container overload-duration {
			uses tlv;
			leaf duration {
				type uint32;
				units seconds;
			}
		}
	}

	grouping req-missing-tlv {
		description "REQ-MISSING TLV";
		reference "https://tools.ietf.org/html/rfc5440#section-7.5";
		container req-missing {
			uses tlv;
			leaf request-id {
				type request-id;
			}
		}
	}
	
	grouping p2mp-capable-tlv {
		description "P2MP CAPABLE TLV";
		reference "https://tools.ietf.org/html/rfc6006#section-3.1.2";

		leaf value {
			type uint16;
			mandatory true;
		}
	}
	

	grouping stateful-capability-tlv {
		description "Stateful PCE Capability TLV";
		reference "https://tools.ietf.org/html/draft-ietf-pce-stateful-pce-05#section-7.1.1";

		uses tlv;
		leaf flags {
			type bits {
				bit lsp-update-capability {
					position 31;
				}
				bit include-db-version {
					position 30;
				}
				bit initiation {
					position 29;
				}
			}
			mandatory true;
		}
	}

	grouping lsp-db-version-tlv {
		description "LSP State Database Version TLV";
		reference "https://tools.ietf.org/html/draft-ietf-pce-stateful-pce-05#section-7.1.2";

		uses tlv;
		leaf version {
			type uint64;
			mandatory true;
		}
	}

	grouping predundancy-group-id-tlv {
		description "PCE Redundancy Group Identifier TLV";
		reference "https://tools.ietf.org/html/draft-ietf-pce-stateful-pce-05#section-7.1.3";

		uses tlv;
		leaf identifier {
			type binary;
			mandatory true;
		}
	}

	grouping lsp-identifiers-tlv {
		description "LSP Identifiers TLV";
		reference "https://tools.ietf.org/html/draft-ietf-pce-stateful-pce-05#section-7.3.1";

		uses tlv;
		leaf lsp-id {
			type rsvp:lsp-id;
			mandatory true;
		}

		leaf tunnel-id {
			type rsvp:tunnel-id;
			mandatory true;
		}

		choice address-family {
			case ipv4 {
				leaf ipv4-tunnel-sender-address {
					type inet:ipv4-address;
					mandatory true;
				}
				leaf ipv4-extended-tunnel-id {
					type rsvp:ipv4-extended-tunnel-id;
					mandatory true;
				}
			}
			case ipv6 {
				leaf ipv6-tunnel-sender-address {
					type inet:ipv6-address;
					mandatory true;
				}
				leaf ipv6-extended-tunnel-id {
					type rsvp:ipv6-extended-tunnel-id;
					mandatory true;
				}
			}
		}
		// FIXME: add tunnel endpoint (from stateful-07) 
	}

	grouping symbolic-path-name-tlv {
		description "Symbolic Path Name TLV";
		reference "https://tools.ietf.org/html/draft-ietf-pce-stateful-pce-05#section-7.3.2";

		uses tlv;
		leaf path-name {
			type symbolic-path-name;
			mandatory true;
		}
	}

	grouping lsp-error-code-tlv {
		description "LSP Error Code TLV";
		reference "https://tools.ietf.org/html/draft-ietf-pce-stateful-pce-05#section-7.3.3";

		uses tlv;
		leaf error-code {
			type uint32;
			mandatory true;
		}
	}

	grouping rsvp-error-spec-tlv {
		description "RSVP Error Spec TLV";
		reference "https://tools.ietf.org/html/draft-ietf-pce-stateful-pce-05#section-7.3.4";

		uses tlv;
		choice error-type {
			case rsvp {
				container rsvp-error {
					uses rsvp:error-spec;
				}
			}
			case user {
				container user-error {
					uses rsvp:user-error-spec;
				}
			}
		}
	}

	grouping of-list-tlv {
		description "OF-List TLV";
		reference "https://tools.ietf.org/html/rfc5541#section-2.1";

		uses tlv;
		leaf-list codes {
			type of-id;
		}
	}

	grouping order-tlv {
		description "Order TLV";
		reference "https://tools.ietf.org/html/rfc5557#section-5.4";

		uses tlv;
		leaf delete {
			type uint32;
			mandatory true;
		}

		leaf setup {
			type uint32;
			mandatory true;
		}
	}

	// Objects
	grouping object-header {
		description "Common Object Header";
		reference "https://tools.ietf.org/html/rfc5440#section-7.2";

		leaf processing-rule {
			type boolean;
			default false;
		}

		leaf ignore {
			type boolean;
			default false;
		}
	}

	grouping object {
		description "Core object structure with optional TLVs";
		uses object-header;
	}

	grouping open-object {
		description "OPEN Object";
		reference "https://tools.ietf.org/html/rfc5440#section-7.3";

		uses object;
		container "tlvs" {
			container of-list {
				uses of-list-tlv;
			}

			container p2mp {
				uses p2mp-capable-tlv;
			}

			container stateful {
				uses stateful-capability-tlv;
			}

			container predundancy-group-id {
				uses predundancy-group-id-tlv;
			}

			container lsp-db-version {
				uses lsp-db-version-tlv;
			}
		}

		leaf version {
			type protocol-version;
			default 1;
		}

		leaf keepalive {
			// Note: non-presence is equal to '0'
			type uint8 {
				range 1..255;
			}
			mandatory true;
		}

		leaf dead-timer {
			// Note: non-presence is equal to '0'
			type uint8 {
				range 1..255;
			}
			mandatory true;
		}

		leaf session-id {
			type uint8;
		}
	}

	grouping rp-object {
		description "RP Object";
		reference "https://tools.ietf.org/html/rfc5440#section-7.4";

		uses object;
		container "tlvs" {
			container order {
				uses order-tlv;
			}
		}

		leaf priority {
			type uint8 {
				range 1..7;
			}
		}

		leaf request-id {
			type request-id;
			mandatory true;
		}

		leaf reoptimization {
			type boolean;
			default false;
		}

		leaf bi-directional {
			type boolean;
			default false;
		}

		leaf loose {
			type boolean;
			default false;
		}

		leaf path-key {
			type boolean;
			default false;
			reference "https://tools.ietf.org/html/rfc5520#section-3.2.1";
		}

		leaf fragmentation {
			type boolean;
			default false;
			reference "https://tools.ietf.org/html/rfc6006#section-3.3.1";
		}

		leaf p2mp {
			type boolean;
			default false;
			reference "https://tools.ietf.org/html/rfc6006#section-3.3.1";
		}

		leaf ero-compression {
			type boolean;
			default false;
			reference "https://tools.ietf.org/html/rfc6006#section-3.3.1";
		}

		leaf supply-of {
			type boolean;
			default false;
			reference "https://tools.ietf.org/html/rfc5541#section-3.3";
		}

		leaf order {
			type boolean;
			default false;
			reference "https://tools.ietf.org/html/rfc5557#section-5.3";
		}

		leaf make-before-break {
			type boolean;
			default false;
			reference "https://tools.ietf.org/html/rfc5557#section-5.3";
		}
	}

	grouping no-path-object {
		description "NO-PATH Object";
		reference "https://tools.ietf.org/html/rfc5440#section-7.5";

		uses object;

		leaf nature-of-issue {
			type uint8;
			mandatory true;
		}

		leaf unsatisfied-constraints {
			when "nature-of-issue = 0" {
				description
					"The C flag has no meaning
					and is ignored unless the NI
					field is set to 0x00.";
			}
			type boolean;
			default false;
		}
	}

	grouping endpoints-object {
		description "END-POINTS Object";
		reference "https://tools.ietf.org/html/rfc5440#section-7.6";

		uses object;

		choice address-family {
			case ipv4 {
				leaf source-ipv4-address {
					type inet:ipv4-address;
					mandatory true;
				}

				leaf destination-ipv4-address {
					type inet:ipv4-address;
					mandatory true;
				}
			}
			case ipv6 {
				leaf source-ipv6-address {
					type inet:ipv6-address;
					mandatory true;
				}

				leaf destination-ipv6-address {
					type inet:ipv6-address;
					mandatory true;
				}
			}
		}
	}

	grouping bandwidth-object {
		description "BANDWIDTH Object";
		reference "https://tools.ietf.org/html/rfc5440#section-7.7";
		
		uses object;

		// No possibility to carry TLVs
		leaf bandwidth {
			type ieee754:float32;
		}
	}

	grouping metric-object {
		description "METRIC Object";
		reference "https://tools.ietf.org/html/rfc5440#section-7.8";

		uses object;

		leaf metric-type {
			type uint8;
			mandatory true;
		}

		leaf bound {
			type boolean;
			default false;
		}

		leaf computed {
			type boolean;
			default false;
		}

		leaf value {
			type ieee754:float32;
		}
	}

	grouping exclude-route-object {
		description "Exclude Route Object";
		reference "https://tools.ietf.org/html/rfc5521#section-2.1.1";

		uses object;

		leaf flags {
			type bits {
				bit fail {
					position 31;
				}
			}
			mandatory true;
		}

		list subobjects {
			uses rsvp:exclude-route-subobjects;
		}
	}

	grouping explicit-route-object {
		description "Explicit Route Object";
		reference "https://tools.ietf.org/html/rfc5440#section-7.9";

		// No possibility of TLVs
		uses object;

		list subobjects {
			leaf loose {
				type boolean;
				mandatory true;
			}

			uses rsvp:explicit-route-subobjects {
				augment "subobject-type" {
					case path-key {
						container path-key {
							uses path-key-subobject;
						}
					}
				}
			}
		}
	}

	grouping include-route-object {
		description "Include Route Object";
		reference "https://tools.ietf.org/html/rfc5440#section-7.12";

		// No possibility of TLVs
		uses object;

		list subobjects {
			uses rsvp:explicit-route-subobjects;
		}
	}

	grouping reported-route-object {
		description "Reported Route Object";
		reference "https://tools.ietf.org/html/rfc5440#section-7.10";

		// No possibility of TLVs
		uses object;

		list subobjects {
			uses rsvp:record-route-subobjects {
				augment "subobject-type" {
					case path-key {
						container path-key {
							uses path-key-subobject;
						}
					}
				}
			}
		}
	}

	grouping lspa-object {
		description "LSPA Object";
		reference "https://tools.ietf.org/html/rfc5440#section-7.11";

		uses object;

		leaf hold-priority {
			type uint8;
			mandatory true;
		}

		leaf setup-priority {
			type uint8;
			mandatory true;
		}

		leaf local-protection-desired {
			type boolean;
			default false;
		}

		uses rsvp:attribute-filters;
	}

	grouping svec-object {
		description "Synchronization Vector Object";
		reference "https://tools.ietf.org/html/rfc5440#section-7.13";

		// No possibility of TLVs
		uses object;

		leaf link-diverse {
			type boolean;
			default false;
		}

		leaf node-diverse {
			type boolean;
			default false;
		}

		leaf srlg-diverse {
			type boolean;
			default false;
		}

		leaf-list requests-ids {
			type request-id;
		}
	}

	grouping notification-object {
		description "NOTIFICATION Object";
		reference "https://tools.ietf.org/html/rfc5440#section-7.14";

		uses object;
		container "tlvs" {
			when "../type = 2 and ../value = 1";

			uses overload-duration-tlv;
		}

		leaf type {
			type uint8;
			mandatory true;
		}

		leaf value {
			type uint8;
			mandatory true;
		}
	}

	grouping pcep-error-object {
		description "PCEP-ERROR Object";
		reference "https://tools.ietf.org/html/rfc5440#section-7.15";

		uses object;
		container "tlvs" {
			when "../type = 7";
			uses req-missing-tlv;
		}

		leaf type {
			type uint8;
			mandatory true;
		}

		leaf value {
			type uint8;
			mandatory true;
		}
	}

	grouping load-balancing-object {
		description "LOAD-BALANCING Object";
		reference "https://tools.ietf.org/html/rfc5440#section-7.16";

		// No possibility of TLVs
		uses object;

		leaf max-lsp {
			type uint8;
			mandatory true;
		}

		leaf min-bandwidth {
			type ieee754:float32;
		}
	}

	grouping close-object {
		description "CLOSE Object";
		reference "https://tools.ietf.org/html/rfc5440#section-7.17";

		uses object;

		leaf reason {
			type uint8;
			mandatory true;
		}
		
		container tlvs {

		}
	}

	grouping path-key-subobject {
		reference "https://tools.ietf.org/html/rfc5520#section-3.1";
		uses rsvp:c-subobject;

		leaf pce-id {
			type pce-id;
			mandatory true;
		}

		leaf path-key {
			type path-key;
			mandatory true;
		}
	}

	grouping path-key-object {
		description "PATH-KEY Object";
		reference "https://tools.ietf.org/html/rfc5520#section-3.2.2";

		uses object;

		list path-keys {
			min-elements 1;

			leaf loose {
				type boolean;
				default false;
			}

			uses path-key-subobject;
		}
	}

	grouping srp-object {
		description "SRP Object";
		reference "https://tools.ietf.org/html/draft-ietf-pce-stateful-pce-05#section-7.2";

		uses object;

		leaf operation-id {
			type srp-id-number;
			mandatory true;
		}

		leaf flags {
			type bits {
				bit lsp-remove {
					position 31;
				}
			}
		}
	}

	grouping lsp-object {
		description "LSP Object";
		reference "https://tools.ietf.org/html/draft-ietf-pce-stateful-pce-05#section-7.3";

		uses object;
		container "tlvs" {
			container lsp-error-code {
				uses lsp-error-code-tlv;
			}

			container lsp-identifiers {
				uses lsp-identifiers-tlv;
			}

			container rsvp-error-spec {
				uses rsvp-error-spec-tlv;
			}

			container symbolic-path-name {
				uses symbolic-path-name-tlv;
			}
		}

		leaf plsp-id {
			type plsp-id;
			mandatory true;
		}

		leaf delegate {
			type boolean;
			default false;
		}

		leaf sync {
			type boolean;
			default false;
		}

		leaf remove {
			type boolean;
			default false;
		}

		leaf administrative {
			type boolean;
			default false;
		}

		leaf operational {
			type operational-status;
			mandatory true;
		}

		leaf signaling-type {
			type uint8;
			mandatory true;
		}
	}

	grouping of-object {
		description "OF Object";
		reference "https://tools.ietf.org/html/rfc5541#section-3.1";

		uses object;

		leaf code {
			type of-id;
			mandatory true;
		}
	}

	typedef class-type {
		type uint8 {
			range 1..7;
		}
	}

	grouping classtype-object {
		description "CLASSTYPE Object";
		reference "https://tools.ietf.org/html/rfc5455#section-3";

		uses object;

		leaf class-type {
			type class-type;
			mandatory true;
		}
	}

	grouping gc-object {
		description "GLOBAL CONSTRAINTS (GC) Object";
		reference "https://tools.ietf.org/html/rfc5557#section-5.5";

		uses object;

		leaf max-hop {
			type uint8;
			mandatory true;
		}

		leaf max-utilization {
			type uint8 {
				range 0..100;
			}
			units percent;
			mandatory true;
		}

		leaf min-utilization {
			type uint8 {
				range 0..100;
			}
			units percent;
			mandatory true;
		}

		leaf over-booking-factor {
			type uint8 {
				range 0..100;
			}
			units percent;
			mandatory true;
		}
	}

	// Messages
	grouping message {
		description "Marker grouping for message groupings.";
	}

	grouping message-header {
		description "Common Header";
		reference "https://tools.ietf.org/html/rfc5440#section-6.1";

		leaf version {
			type protocol-version;
			default 1;
		}
	}

	grouping open-message {
		uses message;

		container open-message {
			description "Open Message";
			reference "https://tools.ietf.org/html/rfc5440#section-6.2";

			uses message-header;

			container open {
				uses open-object;
			}
		}
	}

	grouping keepalive-message {
		uses message;

		container keepalive-message {
			description "Keepalive Message";
			reference "https://tools.ietf.org/html/rfc5440#section-6.3";

			uses message-header;
		}
	}

	grouping lsp-attributes {
		container lspa {
			uses lspa-object;
		}

		container bandwidth {
			uses bandwidth-object;
		}

		list metrics {
			uses metric-object;
		}

		container exclude-route {
			uses exclude-route-object;
		}

		container include-route {
			uses include-route-object;
		}

		container of {
			uses of-object;
		}

		container class-type {
			uses classtype-object;
		}
	}

	grouping pcreq-message {
		uses message;

		container pcreq-message {
			description "Path Computation Request Message";
			reference "https://tools.ietf.org/html/rfc5440#section-6.4";

			uses message-header;

			list requests {
				container rp {
					uses rp-object;
				}

				container path-key-expansion {
					when "rp/path-key = true";
					container path-key {
						uses path-key-object;
					}
				}

				container segment-computation {
					when "rp/path-key = false";

					container p2p {
						when "../rp/p2mp = false";

						container endpoints {
							uses endpoints-object;
						}

						container reported-route {
							uses reported-route-object;

							container bandwidth {
								uses bandwidth-object;
							}
						}

						container load-balancing {
							uses load-balancing-object;
						}

						uses lsp-attributes;

						container lsp {
							reference "https://tools.ietf.org/html/draft-ietf-pce-stateful-pce-05#section-6.4";
							uses lsp-object;
						}
					}
				}
			}

			list svec {
				uses svec-object;

				container of {
					uses of-object;
				}
				container gc {
					uses gc-object;
				}
				container xro {
					uses exclude-route-object;
				}
				list metric {
					uses metric-object;
				}
			}
		}
	}

	grouping path-definition {
		container explicit-route {
			uses explicit-route-object;
		}

		uses lsp-attributes;
	}

	grouping pcrep-message {
		uses message;

		container pcrep-message {
			description "Path Computation Reply Message";
			reference "https://tools.ietf.org/html/rfc5440#section-6.5";

			uses message-header;

			list replies {
				container rp {
					uses rp-object;
				}

				container lsp {
					reference "https://tools.ietf.org/html/draft-ietf-pce-stateful-pce-05#section-6.5";
					uses lsp-object;
				}

				choice result {
					case success {
						uses lsp-attributes;

						list paths {
							uses path-definition;
						}
					}
					case failure {
						container no-path {
							uses no-path-object;
							container "tlvs" {
								container no-path-vector {
									uses no-path-vector-tlv;
								}
							}
						}
					}
				}
			}
		}
	}

	grouping pcntf-message {
		uses message;

		container pcntf-message {
			description "Notification Message";
			reference "https://tools.ietf.org/html/rfc5440#section-6.6";

			uses message-header;

			list notifications {
				list rps {
					uses rp-object;
				}

				list notifications {
					uses notification-object;
				}
			}
		}
	}

	grouping pcerr-message {
		uses message;

		container pcerr-message {
			description "Error Message";
			reference "https://tools.ietf.org/html/rfc5440#section-6.7";

			uses message-header;

			list errors {
				uses pcep-error-object;
			}

			choice error-type {
				case request {
					list rps {
						uses rp-object;
					}
				}

				case session {
					container open {
						uses open-object;
					}
				}

				case stateful {
					container srp {
						reference "https://tools.ietf.org/html/draft-ietf-pce-stateful-pce-05#section-6.3";
						uses srp-object;
					}
				}
			}
		}
	}

	grouping close-message {
		uses message;

		container c-close-message {
			description "Close Message";
			reference "https://tools.ietf.org/html/rfc5440#section-6.8";

			uses message-header;

			container c-close {
				uses close-object;
			}
		}
	}

	grouping pcupd-message {
		uses message;

		container pcupd-message {
			description "State Update Request Message";
			reference "https://tools.ietf.org/html/draft-ietf-pce-stateful-pce-05#section-6.2";

			uses message-header;

			list updates {
				container srp {
					uses srp-object;
				}

				container lsp {
					uses lsp-object;
				}

				container path {
					uses path-definition;
				}
			}
		}
	}

	grouping pcrpt-message {
		uses message;

		container pcrpt-message {
			description "State Report Message";
			reference "https://tools.ietf.org/html/draft-ietf-pce-stateful-pce-05#section-6.1";

			uses message-header;

			list reports {
				container srp {
					uses srp-object;
				}

				container lsp {
					uses lsp-object;
				}

				container path {
					uses path-definition;
				}
			}
		}
	}

	grouping pcinitiate-message {
		uses message;

		container pcinitiate-message {
			description "LSP Initiate Message";
			reference "https://tools.ietf.org/html/draft-crabbe-pce-pce-initiated-lsp-02#section-5.1";

			uses message-header;

			list requests {
				container srp {
					uses srp-object;
				}

				container lsp {
					uses lsp-object;
				}

				container endpoints {
					uses endpoints-object;
				}

				container ero {
					uses explicit-route-object;
				}

				uses lsp-attributes;
			}
		}
	}
}