module tailf-common {
namespace "http://tail-f.com/yang/common";
prefix tailf;
include tailf-meta-extensions {
revision-date 2013-11-07;
}
include tailf-cli-extensions {
revision-date 2015-03-19;
}
organization
"Tail-f Systems";
description
"This module defines all Tail-f YANG extensions statements
and common YANG types.";
revision 2015-05-22 {
description
"Released as part of ConfD-5.4.2 / NCS-3.4.2.
Allow tailf:export and tailf:unique-selector in
tailf:annotate-module.";
}
revision 2015-03-19 {
description
"Released as part of ConfD-5.4 / NCS-3.4.
Added if-feature as substatement to tailf:annotate.
Added tailf:no-dependency.
Updated the description for tailf:dependency.
Allow tailf:id-value as substatement to 'module',
tailf:annotate-module, 'choice', and 'case'.";
}
revision 2014-11-13 {
description
"Released as part of ConfD-5.3 / NCS-3.3.
Added tailf:export.";
}
revision 2014-06-30 {
description
"Released as part of ConfD-5.2 / NCS-3.2.
Added tailf:sha-256-digest-string and tailf:sha-512-digest-string.";
}
revision 2014-03-27 {
description
"Released as part of ConfD-5.1 / NCS-3.1.
Added tailf:actionpoint as substatement to refine.
Removed must as substatement to tailf:symlink.";
}
revision 2014-02-20 {
description
"Released as part of ConfD-5.0.2 / NCS-3.0.2.
Added tailf:snmp-ned-recreate-when-modified.";
}
revision 2013-12-23 {
description
"Released as part of ConfD-5.0.1 / NCS-3.0.1.
Allow 'unique' in tailf:annotate and tailf:annotate-statement.
Added tailf:snmp-ned-delete-before-create.";
}
revision 2013-11-07 {
description
"Released as part of ConfD-5.0 / NCS-3.0.
Allow tailf:code-name as substatement to 'bit'.
Disallow tailf:id-value as substatement to 'enum'. Use the
standard YANG 'value' statement instead.
Deprecated tailf:hex-list. Use yang:hex-string instead.
There are no plans to remove tailf:hex-list.
Added the types tailf:ipv4-address-and-prefix-length,
tailf:ipv6-address-and-prefix-length, and
tailf:ip-address-and-prefix-length,";
}
revision 2013-09-05 {
description
"Released as part of ConfD-4.3.
Added tailf:auto-compact as substatement to tailf:indexed-view.";
}
revision 2013-06-14 {
description
"Released as part of ConfD-4.3.
Deprecated tailf:symlink. Use tailf:link instead.
Allow tailf:alt-name as substatement to tailf:action and rpc.
Allow status as substatement to tailf:action.
Allow description in tailf:annotate and tailf:annotate-statement.";
}
revision 2013-05-16 {
description
"Released as part of ConfD-4.2.2.
Added tailf:link";
}
revision 2013-03-07 {
description
"Released as part of ConfD-4.2.
Allow 'pattern' in tailf:annotate-statement.";
}
revision 2012-11-08 {
description
"Released as part of ConfD-4.1.
Added tailf:unique-selector and tailf:unique-leaf.
Allow tailf:info in bit.
Allow tailf:code-name as substatement to all statements that
define data nodes in the schema tree and the 'rpc',
'notification', 'identity', and 'tailf:action' statements.
Allow status in tailf:symlink";
}
revision 2012-08-23 {
description
"Released as part of ConfD-4.0.1.
Allow tailf:cli-operational-mode and tailf:cli-configure-mode in
rpc.";
}
revision 2012-06-14 {
description
"Released as part of ConfD-4.0.
Added tailf:display-hint.";
}
revision 2012-05-24 {
description
"Released as part of ConfD-3.9.2.";
}
revision 2012-03-08 {
description
"Released as part of ConfD-3.9.
Added tailf:timeout.
Added tailf:non-strict-leafref.";
}
revision 2011-12-08 {
description
"Released as part of ConfD-3.8.
Allow validation statements in tailf:annotate and
tailf:annotate-statement.
Allow tailf:validate in must, in order to override the evaluation
of the must expression with a callback function.
Disallow tailf:info in range, length and pattern.
Added tailf:snmp-ned-* statements to control the SNMP NED
behavior in NCS.";
}
revision 2011-10-20 {
description
"Released as part of ConfD-3.7.1.
Added tailf:priority.";
}
revision 2011-09-22 {
description
"Released as part of ConfD-3.7.
Allow tailf:typepoint as substatement to leaf and leaf-list.
Allow tailf:id as substatement to tailf:annotate-module.
Allow tailf:sort-priority as substatement to tailf:symlink.
Added tailf:interruptibale.
Added tailf:error-info.
Added tailf:snmp-delete-value and tailf:snmp-send-delete-value.
Added tailf:step.
Added tailf:annotate-statement.
Clarified how tailf:display-when is evaluated for lists.";
}
revision 2011-08-25 {
description
"Released as part of ConfD-3.6.2.
Included latest tailf-cli-extension submodule.";
}
revision 2011-06-30 {
description
"Released as part of ConfD-3.6.1.
Clarified what statements are allowed in tailf:annotate and
tailf:annotate-module. Specifically, that 'symlink' and 'action'
are not allowed.";
}
revision 2011-05-26 {
description
"Released as part of ConfD-3.6.
Allow multiple tailf:snmp-name on leafs that represent MIB scalars.";
}
revision 2011-03-31 {
description
"Released as part of ConfD-3.5.1.
Allow tailf:alt-name as substatement to tailf:symlink.";
}
revision 2011-02-24 {
description
"Released as part of ConfD-3.5.
Allow tailf:info as substatement to type.
Added tailf:writable.
Removed the deprecated tailf:cli-default-order statement.
Removed the deprecated tailf:instance-info-leafs statement.";
}
revision 2010-11-04 {
description
"Released as part of ConfD-3.4.
Added tailf:snmp-exclude-object.
Allow tailf:hidden as substatement to tailf:symlink.
Allow multiple tailf:hidden statements to be specified on a node.
Allow special value '*' ar argument to tailf:annotate.";
}
revision 2010-09-16 {
description
"Released as part of ConfD-3.3.2.
Included latest tailf-cli-extension submodule.";
}
revision 2010-08-19 {
description
"Released as part of ConfD-3.3.1.
Allow multiple tailf:snmp-name statements, and expanded the
semantic meaning of this statement.";
}
revision 2010-07-21 {
description
"Released as part of ConfD-3.3.0.3.
Added tailf:sort-priority.";
}
revision 2010-06-17 {
description
"Released as part of ConfD-3.3.
Added tailf:value-length.
Added tailf:info-html.
Added tailf:display-default-order, and deprecated
tailf:cli-default-order.
Added tailf:dependency as a substatement to when.
Removed the deprecated statements tailf:constant-leaf and
tailf:constant-value.";
}
revision 2010-04-22 {
description
"Released as part of ConfD-3.2.1.
Added tailf:invocation-mode,
Fixed bug in tailf:octet-list pattern.";
}
revision 2010-03-18 {
description
"Released as part of ConfD-3.2.
Split this module into the main module and two submodules,
tailf-meta-extensions, and tailf-cli-extensions.
Added many tailf:cli- statements in the submodule
tailf-cli-extensions.
Added tailf:info.
Allow tailf:display-when in tailf:action.
Added tailf:snmp-lax-type-check.
Deprecated tailf:instance-info-leafs. Use
tailf:cli-instance-info-leafs instead.
Removed the argument in tailf:cli-show-no to better match
all the other tailf:cli- statements.";
}
revision 2010-01-28 {
description
"Released as part of ConfD-3.1.1.
Allow tailf:snmp-oid and tailf:snmp-name in tailf:symlink.
Added tailf:key-default.
Allow tailf:suppress-echo in leaf and leaf-list.";
}
revision 2009-12-17 {
description
"Released as part of ConfD-3.1.
Added tailf:dependency as a substatement to must.
Added must and tailf:display-when as children to tailf:symlink.
Added tailf:interrupt to tailf:exec.
Allow many tailf statement as substatements to 'refine'.
Allow tailf:symlink statement in 'augment' and 'case'.
Added tailf:internal to tailf:actionpoint.
Deprecated tailf:constant-leaf and tailf:constant-value.";
}
revision 2009-11-06 {
description
"Released as part of ConfD-3.0.1.
Added tailf:annotate-module statement.
Added tailf:code-name statement.
Clarified the tailf:path-filters statement, and added
tailf:no-subtree-match.";
}
revision 2009-10-01 {
description
"Released as part of ConfD-3.0.
Clarified that tailf:annotate is applied on the expanded tree.
Bugfixes in some typedef patterns.";
}
revision 2009-03-17 {
description
"Released as part of ConfD-2.8.
Changed module name from tailf-extensions to reflect the content
better.";
}
typedef size {
type string {
pattern "S(\\d+G)?(\\d+M)?(\\d+K)?(\\d+B)?";
}
description
"A value that represents a number of bytes. An example could be
S1G8M7K956B; meaning 1GB + 8MB + 7KB + 956B = 1082138556 bytes.
The value must start with an S. Any byte magnifier can be left
out, e.g. S1K1B equals 1025 bytes. The order is significant
though, i.e. S1B56G is not a valid byte size.
In ConfD, a 'size' value is represented as an uint64.";
}
typedef octet-list {
type string {
pattern "(\\d*(.\\d*)*)?";
}
description
"A list of dot-separated octets e.g. '192.168.255.1.0'.
The statement tailf:value-length can be used to restrict the number
of octets. Note that using the 'length' restriction limits the
number of characters in the lexical representation.";
}
typedef md5-digest-string {
type string;
description
"The md5-digest-string type automatically computes a MD5 digest for
a value adhering to this type.
This is best explained using an example. Suppose we have a
leaf:
leaf key {
type tailf:md5-digest-string;
}
A valid configuration is:
$0$In god we trust.
The '$0$' prefix signals that this is plain text. When a plain
text value is received by the server, an MD5 digest is
calculated, and the string '$1$$' is prepended to the
result, where is a random eight character salt used to
generate the digest. This value is stored in the configuration
data store.
When a value of this type is read, the computed MD5 value is
always returned. In the example above, the following value
could be returned:
$1$fB$ndk2z/PIS0S1SvzWLqTJb.
If a value starting with '$1$' is received, the server
knows that the value already represents an MD5 digest, and
stores it as is in the data store.
A value adhering to this type must have a '$0$' or a
'$1$$' prefix.
If a default value is specified, it must have a '$1$$' prefix.
The digest algorithm used is the same as the md5 crypt function
used for encrypting passwords for various UNIX systems, see e.g.
http://www.freebsd.org/cgi/cvsweb.cgi/~checkout/~/src/lib/libcrypt/crypt.c
";
reference
"IEEE Std 1003.1-2008 - crypt() function
RFC 1321 - The MD5 Message-Digest Algorithm";
}
typedef sha-256-digest-string {
type string {
pattern "$0$.*|$5$(rounds=\\d+$)?[a-zA-Z0-9./]{1,16}$[a-zA-Z0-9./]{43}";
}
description
"The sha-256-digest-string type automatically computes a SHA-256
digest for a value adhering to this type.
A value of this type matches one of the forms:
$0$
$5$$
$5$rounds=$$
The '$0$' prefix signals that this is plain text. When a plain
text value is received by the server, a SHA-256 digest is
calculated, and the string '$5$$' is prepended to the
result, where is a random 16 character salt used to
generate the digest. This value is stored in the configuration
data store. The algorithm can be tuned via the
/confdConfig/cryptHash/rounds parameter, which if set to a number
other than the default will cause '$5$rounds=$$' to
be prepended instead of only '$5$$'.
If a value starting with '$5$' is received, the server
knows that the value already represents a SHA-256 digest, and
stores it as is in the data store.
If a default value is specified, it must have a '$5$' prefix.
The digest algorithm used is the same as the SHA-256 crypt function
used for encrypting passwords for various UNIX systems, see e.g.
http://www.akkadia.org/drepper/SHA-crypt.txt";
reference
"IEEE Std 1003.1-2008 - crypt() function
FIPS.180-3.2008: Secure Hash Standard";
}
typedef sha-512-digest-string {
type string {
pattern "$0$.*|$6$(rounds=\\d+$)?[a-zA-Z0-9./]{1,16}$[a-zA-Z0-9./]{86}";
}
description
"The sha-512-digest-string type automatically computes a SHA-512
digest for a value adhering to this type.
A value of this type matches one of the forms:
$0$
$6$$
$6$rounds=$$
The '$0$' prefix signals that this is plain text. When a plain
text value is received by the server, a SHA-512 digest is
calculated, and the string '$6$$' is prepended to the
result, where is a random 16 character salt used to
generate the digest. This value is stored in the configuration
data store. The algorithm can be tuned via the
/confdConfig/cryptHash/rounds parameter, which if set to a number
other than the default will cause '$6$rounds=$$' to
be prepended instead of only '$6$$'.
If a value starting with '$6$' is received, the server
knows that the value already represents a SHA-512 digest, and
stores it as is in the data store.
If a default value is specified, it must have a '$6$' prefix.
The digest algorithm used is the same as the SHA-512 crypt function
used for encrypting passwords for various UNIX systems, see e.g.
http://www.akkadia.org/drepper/SHA-crypt.txt";
reference
"IEEE Std 1003.1-2008 - crypt() function
FIPS.180-3.2008: Secure Hash Standard";
}
typedef des3-cbc-encrypted-string {
type string;
description
"The des3-cbc-encrypted-string type automatically encrypts a value
adhering to this type using DES in CBC mode followed by a base64
conversion. If the value isn't encrypted already, that is.
This is best explained using an example. Suppose we have a leaf:
leaf enc {
type tailf:des3-cbc-encrypted-string;
}
A valid configuration is:
$0$In god we trust.
The '$0$' prefix signals that this is plain text. When a plain
text value is received by the server, the value is DES3/Base64
encrypted, and the string '$3$' is prepended. The resulting
string is stored in the configuration data store.
When a value of this type is read, the encrypted value is always
returned. In the example above, the following value could be
returned:
$3$lyPjszaQq4EVqK7OPOxybQ==
If a value starting with '$3$' is received, the server knows
that the value is already encrypted, and stores it as is in the
data store.
A value adhering to this type must have a '$0$' or a '$3$' prefix.
ConfD uses a configurable set of encryption keys to encrypt the
string. For details, see 'encryptedStrings' in the
confd.conf(5) manual page.";
}
typedef aes-cfb-128-encrypted-string {
type string;
description
"The aes-cfb-128-encrypted-string works exactly like
des3-cbc-encrypted-string but AES/128bits in CFB mode is used to
encrypt the string. The prefix for encrypted values is '$4$'.";
}
typedef ipv4-address-and-prefix-length {
type string {
pattern "(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])/(([0-9])|([1-2][0-9])|(3[0-2]))";
}
description
"The ipv4-address-and-prefix-length type represents a combination
of an IPv4 address and a prefix length. The prefix length is given
by the number following the slash character and must be less than
or equal to 32.";
}
typedef ipv6-address-and-prefix-length {
type string {
pattern "((:|[0-9a-fA-F]{0,4}):)([0-9a-fA-F]{0,4}:){0,5}((([0-9a-fA-F]{0,4}:)?(:|[0-9a-fA-F]{0,4}))|(((25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])\\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])))(/(([0-9])|([0-9]{2})|(1[0-1][0-9])|(12[0-8])))";
pattern "(([^:]+:){6}(([^:]+:[^:]+)|(.*\\..*)))|((([^:]+:)*[^:]+)?::(([^:]+:)*[^:]+)?)(/.+)";
}
description
"The ipv6-address-and-prefix-length type represents a combination
of an IPv6 address and a prefix length. The prefix length is given
by the number following the slash character and must be less than
or equal to 128.";
}
typedef ip-address-and-prefix-length {
type union {
type tailf:ipv4-address-and-prefix-length;
type tailf:ipv6-address-and-prefix-length;
}
description
"The ip-address-and-prefix-length type represents a combination of
an IP address and a prefix length and is IP version neutral. The
format of the textual representations implies the IP version.";
}
extension export {
argument agent {
tailf:arg-type {
type union {
type enumeration {
enum "none";
enum "netconf";
enum "rest";
enum "cli";
enum "snmp";
enum "webui";
}
type string;
}
}
}
tailf:use-in "module";
tailf:occurence "*";
description
"Makes this data model visible in the northbound interface 'agent'.
This statement makes it possible to have a data model visible
through some northbound interface but not others. For example,
if a MIB is used to generate a YANG module, the resulting YANG
module can be exposed through SNMP only.
Use the special agent 'none' to make the data model completely
hidden to all notherbound interfaces.
The agent can also be a free-form string. In this case, the data
model will be visible to maapi applications using this string as its
'context'.";
}
extension annotate {
argument target {
tailf:arg-type {
type string;
}
}
tailf:use-in "module";
tailf:use-in "submodule";
tailf:occurence "*";
tailf:substatement "tailf:annotate" {
tailf:occurence "*";
}
tailf:substatement "if-feature" {
tailf:occurence "*";
}
description
"Annotates an existing statement with a 'tailf' statement or a
validation statement. This is useful in order to add tailf
statements to a module without touching the module source.
Annotation statements can be put in a separate annotation
module, and then passed to 'confdc' (or 'pyang') when the
original module is compiled.
Any 'tailf' statement, except 'symlink' and 'action' can be
annotated. The statements 'symlink' and 'action' modifies the
data model, and are thus not allowed.
The validation statements 'must', 'min-elements',
'max-elements', 'mandatory', 'unique', and 'when' can also be
annotated.
A 'description' can also be annotated.
'tailf:annotate' can occur on the top-level in a module, or in
another 'tailf:annotate' statement.
The argument is a 'schema-nodeid', i.e. the same as for
'augment', or a '*'. It identifies a target node in the schema
tree to annotate with new statements. The special value '*' can
be used within another 'tailf:annotate' statetement, to select all
children for annotation.
The target node is searched for after 'uses' and 'augment'
expansion. All substatements to 'tailf:annotate' are treated as
if they were written inline in the target node, with the
exception of any 'tailf:annotate' substatements. These are
treated recursively. For example, the following snippet adds
one callpoint to /x and one to /x/y:
tailf:annotate /x {
tailf:callpoint xcp;
tailf:annotate y {
tailf:callpoint ycp;
}
}
";
}
extension annotate-module {
argument module-name {
tailf:arg-type {
type tailf:identifier;
}
}
tailf:use-in "module";
tailf:occurence "*";
tailf:substatement "tailf:snmp-oid";
tailf:substatement "tailf:snmp-mib-module-name";
tailf:substatement "tailf:id";
tailf:substatement "tailf:id-value";
tailf:substatement "tailf:export";
tailf:substatement "tailf:unique-selector";
tailf:substatement "tailf:annotate-statement" {
tailf:occurence "*";
}
description
"Annotates an existing module or submodule statement with a 'tailf'
statement. This is useful in order to add tailf statements to a
module without touching the module source. Annotation
statements can be put in a separate annotation module, and then
passed to 'confdc' (or 'pyang') when the original module is
compiled.
'tailf:annotate-module' can occur on the top-level in a module,
and is used to add 'tailf' statements to the module statement
itself.
The argument is a name of the module or submodule to annotate.";
}
extension annotate-statement {
argument statement-path {
tailf:arg-type {
type string;
}
}
tailf:use-in "tailf:annotate-module";
tailf:use-in "tailf:annotate-statement";
tailf:occurence "*";
tailf:substatement "tailf:annotate-statement" {
tailf:occurence "*";
}
description
"Annotates an existing statement with a 'tailf' statement, a
validation statement, or a type restrcition statement. This is
useful in order to add tailf statements to a module without
touching the module source. Annotation statements can be put in
a separate annotation module, and then passed to 'confdc' (or
'pyang') when the original module is compiled.
Any 'tailf' statement, except 'symlink' and 'action' can be
annotated. The statements 'symlink' and 'action' modifies the
data model, and are thus not allowed.
The validation statements 'must', 'min-elements',
'max-elements', 'mandatory', 'unique', and 'when' can also be
annotated.
The type restriction statement 'pattern' can also be annotated.
A 'description' can also be annotated.
The argument is an XPath-like expression that selects a
statement to annotate. The syntax is:
( '[' '=' ']' )
where is the name of the statement to annotate,
and if there are more than one such statement in the parent,
is the quoted value of the statement's argument.
All substatements to 'tailf:annotate-statement' are treated as
if they were written inline in the target node, with the
exception of any 'tailf:annotate-statement' substatements.
These are treated recursively.
For example, given the grouping:
grouping foo {
leaf bar {
type string;
}
leaf baz {
type string;
}
}
the following snippet adds a callpoint to the leaf 'baz':
tailf:annotate-statement grouping[name='foo'] {
tailf:annotate-statement leaf[name='baz'] {
tailf:callpoint xcp;
}
}
";
}
extension value-length {
argument value {
tailf:arg-type {
type string;
}
}
tailf:use-in "type";
tailf:substatement "error-message";
tailf:substatement "error-app-tag";
description
"Used only for the types:
yang:object-identifier
yang:object-identifier-128
yang:phys-address
yang:hex-string
tailf:hex-list
tailf:octet-list
xs:hexBinary
This type restriction is used to limit the length of the
value-space value of the type. Note that since all these types are
derived from 'string', the standard 'length' statement restricts the
lexical representation of the value.
The argument is a length expression string, with the same syntax as
for the standard YANG 'length' statement.";
}
extension path-filters {
argument value {
tailf:arg-type {
type string;
}
}
tailf:use-in "type";
tailf:substatement "tailf:no-subtree-match";
description
"Used for type 'instance-identifier' only.
The argument is a space separated list of absolute or relative XPath
expressions.
This statement declares that the instance-identifier value must match
one of the specified paths, according to the following rules:
1. each XPath expression is evaluated, and returns a node set.
2. if there is no 'tailf:no-subtree-match' statement, the
instance-identifier matches if it refers to a node in this
node set, or if it refers to any descendant node of this
node set.
3. if there is a 'tailf:no-subtree-match' statement, the
instance-identifier matches if it refers to a node in this
node set.
For example:
The value /a/b[key='k1']/c matches the XPath expression
/a/b[key='k1']/c.
The value /a/b[key='k1']/c matches the XPath expression /a/b/c.
The value /a/b[key='k1']/c matches the XPath expression /a/b, if
there is no 'tailf:no-subtree-match' statement.
The value /a/b[key='k1'] matches the XPath expression /a/b, if
there is a 'tailf:no-subtree-match' statement.
";
}
extension step {
argument value {
tailf:arg-type {
type string;
}
}
tailf:use-in "range";
description
"Used to further restrict the range of integer and decimal types. The
argument is a positive integer or decimal value greater than
zero. The allowed values for the type is further restricted to
only those values that matches the expression:
'low' + n * 'step'
where 'low' is the lowest allowed value in the range, n is a
non-negative integer.
For example, the following type:
type int32 {
range '-2 .. 9' {
tailf:step 3;
}
}
has the value space { -2, 1, 4, 7 }";
}
extension callpoint {
argument id {
tailf:arg-type {
type tailf:identifier;
}
}
tailf:use-in "leaf";
tailf:use-in "leaf-list";
tailf:use-in "list";
tailf:use-in "container";
tailf:use-in "refine";
tailf:use-in "grouping";
tailf:occurence "*";
tailf:substatement "description";
tailf:substatement "tailf:config";
tailf:substatement "tailf:transform";
tailf:substatement "tailf:set-hook";
tailf:substatement "tailf:transaction-hook";
tailf:substatement "tailf:cache";
tailf:substatement "tailf:opaque";
tailf:substatement "tailf:internal";
description
"Identifies a callback in a data provider. A data provider implements
access to external data, either configuration data in a database or
operational data. By default ConfD uses the embedded database
(CDB) to store all data. However, some or all of
the configuration data may be stored in an external source. In
order for ConfD to be able to manipulate external data, a data
provider registers itself using the callpoint id as described in
confd_lib_dp(3).
A callpoint is inherited to all child nodes unless another
'callpoint' or an 'cdb-oper' is defined.";
}
extension config {
argument value {
tailf:arg-type {
type boolean;
}
}
tailf:use-in "tailf:callpoint";
description
"If this statement is present, the callpoint is applied to nodes with a
matching value of their 'config' property.";
}
extension transform {
argument value {
tailf:arg-type {
type boolean;
}
}
tailf:use-in "tailf:callpoint";
description
"If set to 'true', the callpoint is a transformation callpoint. How
transformation callpoints are used is described in the
'Transformations, Hooks, Hidden Data and Symlinks' chapter
in the User's Guide.";
}
extension set-hook {
argument value {
tailf:arg-type {
type enumeration {
enum "subtree";
enum "object";
enum "node";
}
}
}
tailf:use-in "tailf:callpoint";
description
"Set hooks are a means to associate user code to the
transaction. Whenever an element gets written, created, or
deleted, user code gets invoked and can optionally write more
data into the same transaction.
The difference between set- and transaction hooks are that set
hooks are invoked immediately when an element is modified, but
transaction hooks are invoked at commit time.
The value 'subtree' means that all nodes in the configuration
below where the hook is defined are affected.
The value 'object' means that the hook only applies to the list
where it is defined, i.e. it applies to all child nodes that
are not themselves lists.
The value 'node' means that the hook only applies to
the node where it is defined and none of its children.
For more details on hooks,
see the 'Transformations, Hooks, Hidden Data and Symlinks'
chapter in the User's Guide.";
}
extension transaction-hook {
argument value {
tailf:arg-type {
type enumeration {
enum "subtree";
enum "object";
enum "node";
}
}
}
tailf:use-in "tailf:callpoint";
tailf:substatement "tailf:invocation-mode";
description
"Transaction hooks are a means to associate user code to the
transaction. Whenever an element gets written, created, or
deleted, user code gets invoked and can optionally write more
data into the same transaction.
The difference between set- and transaction hooks are that set
hooks are invoked immediately when an element is modified, but
transaction hooks are invoked at commit time.
The value 'subtree' means that all nodes in the configuration
below where the hook is defined are affected.
The value 'object' means that the hook only applies to the list
where it is defined, i.e. it applies to all child nodes that
are not themselves lists.
The value 'node' means that the hook only applies to
the node where it is defined and none of its children.
For more details on hooks,
see the 'Transformations, Hooks, Hidden Data and Symlinks'
chapter in the User's Guide.";
}
extension invocation-mode {
argument value {
tailf:arg-type {
type enumeration {
enum "per-operation";
enum "per-transaction";
}
default "per-operation";
}
}
tailf:use-in "tailf:transaction-hook";
description
"By default, the node-specific write callbacks (create(), set_elem(),
etc) for a transaction hook are invoked for the invidual data nodes
that are modified in the transaction. If 'tailf:invocation-mode' is
set to 'per-transaction', there will instead be a single invocation
of a generic write callback (write_all()).";
}
extension cache {
argument value {
tailf:arg-type {
type boolean;
}
}
tailf:use-in "tailf:callpoint";
tailf:substatement "tailf:timeout";
description
"If set to 'true', the operational data served by the callpoint will
be cached by ConfD. If set to 'true' in a node that represents
configuration data, the statement 'tailf:config' must be present
and set to 'false'. This feature is further described in the section
'Caching operational data' in the 'Operational data' chapter in
the User's Guide.";
}
extension timeout {
argument value {
tailf:arg-type {
type uint64;
}
}
tailf:use-in "tailf:cache";
description
"Specifies how long the operational data will be cached, in seconds.
This value will override the global value specified via
/confdConfig/opcache/timeout in the confd.conf(5) file.";
}
extension opaque {
argument value {
tailf:arg-type {
type string {
length "1..255";
}
}
}
tailf:use-in "tailf:callpoint";
tailf:use-in "tailf:validate";
tailf:use-in "tailf:actionpoint";
description
"Defines an opaque string which is passed to the callback function
in the context.";
}
extension id {
argument name {
tailf:arg-type {
type string;
}
}
tailf:use-in "module";
description
"This statement is used when old confspec models are translated to
YANG. It needs to be present if systems deployed with data
based on confspecs are updated to YANG based data models.
In confspec, the 'id' of a data model was a string that never
would change, even if the namespace URI would change. It is not
needed in YANG, since the namespace URi cannot change as a module
is updated.
This statement is typically present in YANG modules generated by
cs2yang. If no live upgrade needs to be done from a confspec
based system to a YANG based system, this statement can be
removed from such a generated module.";
}
extension cdb-oper {
tailf:use-in "leaf";
tailf:use-in "leaf-list";
tailf:use-in "list";
tailf:use-in "container";
tailf:use-in "refine";
tailf:substatement "description";
tailf:substatement "tailf:persistent";
description
"Indicates that operational data nodes below this node are stored in
CDB.";
}
extension persistent {
argument value {
tailf:arg-type {
type boolean;
}
}
tailf:use-in "tailf:cdb-oper";
description
"If it is set to 'true', the operational data is stored on disk. If
set to 'false', the operational data is not persistent across
ConfD restarts. The default is 'false'.";
}
extension id-value {
argument value {
tailf:arg-type {
type uint32 {
range "1..4294967294";
}
}
}
tailf:use-in "module";
tailf:use-in "leaf";
tailf:use-in "leaf-list";
tailf:use-in "list";
tailf:use-in "container";
tailf:use-in "rpc";
tailf:use-in "identity";
tailf:use-in "notification";
tailf:use-in "choice";
tailf:use-in "case";
tailf:use-in "tailf:action";
description
"This statement lets you specify a hard wired numerical id value to
associate with the parent node. This id value is normally auto
generated by confdc and is used when working with the ConfD API
to refer to a tag name, to avoid expensive string comparison.
Under certain rare circumstances this auto generated hash value
may collide with a hash value generated for a node in another
data model. Whenever such a collision occurs the ConfD daemon
fails to start and instructs the developer to use the 'id-value'
statement to resolve the collision.
A thorough discussion on id-value can be found in the section Hash
Values and the id-value Statement in the YANG chapter in the User
Guide.";
}
extension default-ref {
argument path {
tailf:arg-type {
type string;
}
}
tailf:use-in "leaf";
tailf:use-in "refine";
description
"This statement defines a dynamic default value. It is a reference to
some other leaf in the datamodel. If no value has been set for
this leaf, it defaults to the value of the leaf that the
'default-ref' argument points to.
The textual format of a 'default-ref' is an XPath location path with
no predicates.
The type of the leaf with a 'default-ref' will be set to the
type of the referred leaf. This means that the type statement in
the leaf with the 'default-ref' is ignored, but it SHOULD match the
type of the referred leaf.
Here is an example, where a group without a 'hold-time' will get as
default the value of another leaf up in the hierarchy:
leaf hold-time {
mandatory true;
type int32;
}
list group {
key 'name';
leaf name {
type string;
}
leaf hold-time {
type int32;
tailf:default-ref '../../hold-time';
}
}
";
}
extension sort-order {
argument how {
tailf:arg-type {
type enumeration {
enum "normal" {
description
"Entries are sorted on the key values.";
}
enum "snmp" {
description
"All string key values are considered to
start with a length byte for the purpose of sorting.";
}
enum "snmp-implied" {
description
"As 'snmp', but uses a length byte for all except the last key.";
}
enum "unsorted" {
description
"Entries do not have any special order. Note that it is
not possible to use the function 'find_next' on an
unsorted list. If an unsorted list is filtered (e.g.,
in the CLI, the entire list must be traversed.
If this value is given for a list stored in CDB, it
has no effect.";
}
}
default "normal";
}
}
tailf:use-in "list";
tailf:use-in "leaf-list";
tailf:use-in "tailf:secondary-index";
description
"This statement can be used for 'ordered-by system' lists and
leaf-lists only. It indicates in which way the list entries
are sorted.";
}
extension link {
argument target {
tailf:arg-type {
type string;
}
}
tailf:use-in "leaf";
tailf:use-in "leaf-list";
tailf:substatement "tailf:inherit-set-hook";
description
"This statement specifies that the data node should be
implemented as a link to another data node, called the target
data node. This means that whenever the node is modified, the
system modifies the target data node instead, and whenever the
data node is read, the system returns the value of target data
node.
Note that if the data node is a leaf, the target node MUST also
be a leaf, and if the data node is a leaf-list, the target node
MUST also be a leaf-list.
Note that the type of the data node MUST be the same as the
target data node. Currently the compiler cannot check this.
The argument is an XPath absolute location path. If
the target lies within lists, all keys must be specified.
A key either has a value, or is a reference to a key in the path of the
source node, using the function current() as starting
point for an XPath location path. For example:
/a/b[k1='paul'][k2=current()/../k]/c";
}
extension lower-case {
tailf:use-in "leaf";
tailf:use-in "leaf-list";
description
"Use for config false leafs and leaf-lists only.
This extension serves as a hint to the system that the
leaf's type has the implict pattern '[^A-Z]*', i.e., all
strings returned by the data provider are lower case (in
the 7-bit ASCII range).
The CLI uses this hint when it is run in case-insensitive mode
to optimize the lookup calls towards the data provider.";
}
extension inherit-set-hook {
argument value {
tailf:arg-type {
type boolean;
default "false";
}
}
tailf:use-in "tailf:symlink";
tailf:use-in "tailf:link";
description
"This statement specifies that a 'tailf:set-hook' statement should
survive through symlinks. If set to true a set hook gets called as
soon as the value is set via a symlink but also during commit. The
normal behaviour is to only call the set hook during commit time.";
}
extension secondary-index {
argument name {
tailf:arg-type {
type string;
}
}
tailf:use-in "list";
tailf:occurence "*";
tailf:substatement "tailf:index-leafs" {
tailf:occurence "1";
}
tailf:substatement "tailf:sort-order";
tailf:substatement "tailf:display-default-order";
description
"This statement creates a secondary index with a given name in the
parent list. The secondary index can be used to control the
displayed sort order of the instances of the list.
Read more about sort order in 'The ConfD Command-Line Interface
(CLI)' chapters in the User Guide, confd_lib_dp(3), and
confd_lib_maapi(3).
NOTE: Currently secondary-index is not supported for config false
data stored in CDB.";
}
extension index-leafs {
argument value {
tailf:arg-type {
type string;
}
}
tailf:use-in "tailf:secondary-index";
tailf:occurence "1";
description
"This statement contains a space separated list of leaf names. Each
such leaf must be a direct child to the list. The secondary
index is kept sorted according to the values of these leafs.";
}
extension typepoint {
argument id {
tailf:arg-type {
type tailf:identifier;
}
}
tailf:use-in "typedef";
tailf:use-in "leaf";
tailf:use-in "leaf-list";
tailf:occurence "*";
description
"If a typedef, leaf, or leaf-list has a 'typepoint' statement, a
user-defined type is specified, as opposed to a derivation or
specification of an existing type. The implementation of a
user-defined type must be provided in the form of a shared object
with C callback functions that is loaded into the ConfD daemon at
startup time. Read more about user-defined types in the
confd_types(3) manual page.
The argument defines the ID associated with a typepoint. This
ID is provided by the shared object, and used by the ConfD
daemon to locate the implementation of a specific user-defined
type.";
}
extension unique-selector {
argument context-path {
tailf:arg-type {
type string;
}
}
tailf:use-in "module";
tailf:use-in "submodule";
tailf:use-in "grouping";
tailf:use-in "augment";
tailf:use-in "container";
tailf:use-in "list";
tailf:occurence "*";
tailf:substatement "tailf:unique-leaf" {
tailf:occurence "+";
}
description
"The standard YANG statement 'unique' can be used to check for
uniqueness within a single list only. Specifically, it cannot
be used to check for uniqueness of leafs within a sublist.
For example:
container a {
list b {
...
unique 'server/ip server/port';
list server {
...
leaf ip { ... };
leaf port { ... };
}
}
}
The unique expression above is not legal. The intention is
that there must not be any two 'server' entries in any 'b' with
the same combination of ip and port. This would be illegal:
b1
10.0.0.1
80
b2
10.0.0.1
80
With 'tailf:unique-selector' and 'tailf:unique-leaf', this kind
of constraint can be defined.
The argument to 'tailf:unique-selector' is an XPath descendant
location path (matches the rule 'descendant-schema-nodeid' in
RFC 6020). The first node in the path MUST be a list node, and
it MUST be defined in the same module as the
tailf:unique-selector. For example, the following is illegal:
module y {
...
import x {
prefix x;
}
tailf:unique-selector '/x:server' { // illegal
...
}
}
For each instance of the node where the selector is defined, it
is evaluated, and for each node selected by the selector, a
tuple is constructed by evaluating the 'tailf:unique-leaf'
expression. All such tuples must be unique. If a
'tailf:unique-leaf' expression refers to a non-existing leaf,
the corresponding tuple is ignored.
In the example above, the unique expression can be replaced by:
container a {
tailf:unique-selector 'b/server' {
tailf:unique-leaf 'ip';
tailf:unique-leaf 'port';
}
list b {
...
}
}
For each container 'a', the XPath expression 'b/server' is
evaluated. For each such server, a 2-tuple is constructed with
the 'ip' and 'port' leafs. Each such 2-tuple is guaranteed to
be unique.";
}
extension unique-leaf {
argument leaf-expr {
tailf:arg-type {
type string;
}
}
tailf:use-in "tailf:unique-selector";
tailf:occurence "+";
description
"See 'tailf:unique-selector' for a description of how this statement
is used.
The argument is an XPath descendant location path (matches the
rule 'descendant-schema-nodeid' in RFC 6020), and it MUST refer to
a leaf.";
}
extension validate {
argument id {
tailf:arg-type {
type tailf:identifier;
}
}
tailf:use-in "leaf";
tailf:use-in "leaf-list";
tailf:use-in "list";
tailf:use-in "container";
tailf:use-in "grouping";
tailf:use-in "refine";
tailf:use-in "must";
tailf:occurence "*";
tailf:substatement "description";
tailf:substatement "tailf:call-once";
tailf:substatement "tailf:dependency" {
tailf:occurence "*";
}
tailf:substatement "tailf:opaque";
tailf:substatement "tailf:internal";
tailf:substatement "tailf:priority";
description
"Identifies a validation callback which is invoked when a configuration
value is to be validated. The callback validates a value and
typically checks it towards other values in the data store.
Validation callbacks are used when the YANG built-in validation
constructs ('must', 'unique') are not expressive enough.
Callbacks use the API described in confd_lib_maapi(3) to
access whatever other configuration values needed to perform the
validation.
Validation callbacks are typically assigned to individual nodes
in the data model, but it may be feasible to use a single
validation callback on a root node. In that case the callback
is responsible for validation of all values and their
relationships throughout the data store.
The 'validate' statment should in almost all cases have a
'tailf:dependency' substatement. If such a statement is not
given, the validate function is evaluated at every commit,
leading to overall performance degradation.
If the 'validate' statement is defined in a 'must' statement,
validation callback is called instead of evaluating the must
expression. This is useful if the evaluation of the must statement
uses too much resources, and the condition expressed with the must
statement is easier to check with a validation callback function.";
}
extension call-once {
argument value {
tailf:arg-type {
type boolean;
}
}
tailf:use-in "tailf:validate";
description
"This optional statement can be used only if the parent statement is
a list. If 'call-once' is 'true'. the validation callback is
only called once even though there exists many list entries in
the data store. This is useful if we have a huge amount of
instances or if values assigned to each instance have to be
validated in comparison with its siblings.";
}
extension dependency {
argument path {
tailf:arg-type {
type string;
}
}
tailf:use-in "must";
tailf:use-in "when";
tailf:use-in "tailf:validate";
tailf:substatement "tailf:xpath-root";
tailf:occurence "*";
description
"This statement is used to specify that the must or when expression
or validation function depends on a set of subtrees in the data
store. Whenever a node in one of those subtrees are modified,
the must or when expression is evaluated, or validation code executed.
The textual format of a 'dependency' is an XPath location path with
no predicates.
If the node that declares the dependency is a leaf, there is an
implicit dependency to the leaf itself.
For example, with the leafs below, the validation code for'vp'
will be called whenever 'a' or 'b' is modified.
leaf a {
type int32;
tailf:validate vp {
tailf:dependency '../b';
}
}
leaf b {
type int32;
}
For 'when' and 'must' expressions, the compiler can derive the
dependencies automatically from the XPath expression in most
cases. The exception is if any wildcards are used in the expression.
For 'when' expressions to work, a 'tailf:dependency' statement
must be given, unless the compiler can figure out the dependency
by itself.
Note that having 'must' expressions or a 'tailf:validate'
statement without dependencies impacts the overall performance
of the system, since all such 'must' expressions or validation
functions are evaluated at every commit.";
}
extension no-dependency {
tailf:use-in "must";
tailf:use-in "tailf:validate";
tailf:occurence "?";
description
"This optional statements can be used to explicitly say that a 'must'
expression or a validation function is evaluated at every
commit. Use this with care, since the overall performance of
the system is impacted if this statement is used.";
}
extension priority {
tailf:use-in "tailf:validate";
argument value {
tailf:arg-type {
type uint32;
}
}
description
"This extension takes an integer parameter specifying the order
validation code will be evaluated, in order of increasing
priority.
The default priority is 0.";
}
extension no-subtree-match {
tailf:use-in "tailf:path-filters";
description
"See tailf:path-filters.";
}
extension info {
argument text {
yin-element true;
tailf:arg-type {
type string;
}
}
tailf:use-in "typedef";
tailf:use-in "leaf";
tailf:use-in "leaf-list";
tailf:use-in "list";
tailf:use-in "container";
tailf:use-in "rpc";
tailf:use-in "identity";
tailf:use-in "type";
tailf:use-in "enum";
tailf:use-in "bit";
tailf:use-in "length";
tailf:use-in "pattern";
tailf:use-in "range";
tailf:use-in "refine";
tailf:use-in "tailf:action";
tailf:use-in "tailf:symlink";
tailf:use-in "tailf:cli-exit-command";
description
"Contains a textual description of the definition, suitable for
being presented to the CLI and WebUI users.
The first sentence of this textual description is used in the
CLI as a summary, and displayed to the user when a short
explanation is presented.
The 'description' statement is related, but targeted to the module
reader, rather than the CLI or WebUI user.
The info string may contain a ';;' keyword. It is used in type
descriptions for leafs when the builtin type info needs to be
customized. A 'normal' info string describing a type is assumed
to contain a short textual description. When ';;' is present it
works as a delimiter where the text before the keyword is
assumed to contain a short description and the text after the
keyword a long(er) description. In the context of completion in
the CLI the text will be nicely presented in two columns where
both descriptions are aligned when displayed.";
}
extension info-html {
argument text {
yin-element true;
tailf:arg-type {
type string;
}
}
tailf:use-in "leaf";
tailf:use-in "leaf-list";
tailf:use-in "list";
tailf:use-in "container";
tailf:use-in "rpc";
tailf:use-in "identity";
tailf:use-in "tailf:action";
tailf:use-in "tailf:symlink";
tailf:use-in "refine";
description
"This statement works exactly as 'tailf:info', with the exception
that it can contain HTML markup. The WebUI will display the
string with the HTML markup, but the CLI will remove all HTML markup
before displaying the string to the user. In most cases,
using this statement avoids using special descriptions in webspecs
and clispecs.
If this statement is present, 'tailf:info' cannot be given at the same
time.";
}
extension sort-priority {
argument value {
tailf:arg-type {
type int32;
}
}
tailf:use-in "leaf";
tailf:use-in "leaf-list";
tailf:use-in "list";
tailf:use-in "container";
tailf:use-in "refine";
description
"This extension takes an integer parameter specifying the order and
can be placed on leafs, containers, lists and leaf-lists.
When showing, or getting configuration, leaf values will be returned
in order of increasing sort-priority.
The default sort-priority is 0.";
}
extension writable {
argument value {
tailf:arg-type {
type boolean;
}
}
tailf:use-in "leaf";
description
"This extension makes operational data (i.e., config false data)
writable. Only valid for leafs.";
}
extension suppress-echo {
argument value {
tailf:arg-type {
type boolean;
}
}
tailf:use-in "typedef";
tailf:use-in "leaf";
tailf:use-in "leaf-list";
description
"If this statetement is set to 'true', leafs of this type will not have
their values echoed when input in the webui or when the CLI prompts
for the value. The value will also not be included in the audit
log in clear text but will appear as ***.";
}
extension hidden {
argument tag {
tailf:arg-type {
type string {
pattern "[^\\*].*|..+";
}
}
}
tailf:use-in "leaf";
tailf:use-in "leaf-list";
tailf:use-in "list";
tailf:use-in "container";
tailf:use-in "tailf:action";
tailf:use-in "refine";
tailf:use-in "tailf:symlink";
tailf:use-in "rpc";
tailf:occurence "*";
description
"This statement can be used to hide a node from some, or all,
northbound interfaces. All nodes with the same value are
considered a hide group and are treated the same with regards to
being visible or not in a northbound interface.
A node with an hidden property is not shown in the northbound
user interfaces (CLI and Web UI) unless an 'unhide' operation has
been performed in the user interface.
The hidden value 'full' indicates that the node should be hidden
from all northbound interfaces, including programmatical interfaces
such as NETCONF.
The value '*' is not valid.
A hide group can be unhidden only if this has been explicitly
allowed in the confd.conf(5) daemon configuration.
Multiple hide groups can be specified by giving this statement
multiple times. The node is shown if any of the specified hide groups
has been given in the 'unhide' operation.
Note that if a mandatory node is hidden, a hook callback
function (or similar) might be needed in order to set the
element.";
}
extension display-when {
argument condition {
tailf:arg-type {
type string;
}
}
tailf:use-in "leaf";
tailf:use-in "leaf-list";
tailf:use-in "list";
tailf:use-in "container";
tailf:use-in "refine";
tailf:substatement "tailf:xpath-root";
description
"The argument contains an XPath expression which specifies when
the node should be displayed in the CLI and WebUI. For example,
when the CLI performs completion, and one of the candidates is
a node with a 'display-when' expression, the expression is
evaluated by the CLI. If the XPath expression evaluates to
true, the node is shown as a possible completion candidate,
otherwise not.
For a list, the display-when expression is evaluated once for the
entire list. In this case, the XPath context node is the list's parent
node.
This feature is further described in the 'Transformations, Hooks,
Hidden Data and Symlinks' chapter in the User Guide.";
}
extension display-groups {
argument value {
tailf:arg-type {
type string;
}
}
tailf:use-in "leaf";
tailf:use-in "leaf-list";
tailf:use-in "list";
tailf:use-in "container";
tailf:use-in "refine";
description
"This property is used in the CLI when 'enableDisplayGroups' has been
set to true in the confd.conf(5) file. Display groups are used
to control which elements should be displayed by the show command.
The argument is a space-separated string of tags.
In the J-style CLI the 'show status', 'show table' and 'show
all' commands use display groups. In the C- and I-style
CLIs the 'show ' command uses display groups.
If no display groups are specified when running the commands, the
node will be displayed if it does not have the 'display-groups'
property, or if the property value includes the special value 'none'.
If display groups are specified when running the command, then
the node will be displayed only if its 'display-group'
property contains one of the specified display groups.";
}
extension display-default-order {
tailf:use-in "tailf:secondary-index";
description
"Specifies that the list should be displayed sorted according
to this secondary index in the show command.
If the list has more than one secondary index,
'display-default-order' must be present in one index only.
Used in J-, I- and C-style CLIs and WebUI.";
}
extension alt-name {
argument name {
tailf:arg-type {
type string;
}
}
tailf:use-in "rpc";
tailf:use-in "leaf";
tailf:use-in "leaf-list";
tailf:use-in "list";
tailf:use-in "container";
tailf:use-in "refine";
description
"This property is used to specify an alternative name for the
node in the CLI. It is used instead of the node name in the CLI,
both for input and output.";
}
extension display-status-name {
argument name {
tailf:arg-type {
type string;
}
}
tailf:use-in "leaf";
tailf:use-in "leaf-list";
tailf:use-in "list";
tailf:use-in "container";
tailf:use-in "refine";
description
"This property is used to specify an alternative name for the
element in the CLI. It is used when displaying status
information in the C- and I-style CLIs.";
}
extension display-column-name {
argument name {
tailf:arg-type {
type string;
}
}
tailf:use-in "leaf";
tailf:use-in "leaf-list";
tailf:use-in "refine";
description
"This property is used to specify an alternative column name for the
leaf in the CLI. It is used when displaying the leaf in a
table in the CLI.";
}
extension display-hint {
argument hint {
tailf:arg-type {
type string;
}
}
tailf:use-in "leaf";
tailf:use-in "typedef";
description
"This statement can be used to add a display-hint to a leaf or
typedef of type binary. The display-hint is used in the CLI
and WebUI instead of displaying the binary as a base64-encoded
string. It is also used for input.
The value of a 'display-hint' is defined in RFC 2579.
For example, with the display-hint value '1x:', the value is
printed and inputted as a colon-separated hex list.";
}
extension snmp-oid {
argument oid {
tailf:arg-type {
type tailf:tailf-oid;
}
}
tailf:use-in "leaf";
tailf:use-in "leaf-list";
tailf:use-in "list";
tailf:use-in "container";
tailf:use-in "tailf:symlink";
tailf:use-in "module";
tailf:use-in "refine";
description
"Used when the YANG module is mapped to an SNMP module.
If this statement is present as a direct child to 'module',
it indicates the top level OID for the module.
When the parent node is mapped to an SNMP object, this statement
specifies the OID of the SNMP object. It may be either a full
OID or just a suffix (a period, followed by an integer). In the
latter case, a full OID must be given for some ancestor element.
NOTE: when this statement is set in a list, it refers to the OID of
the correspondig table, not the table entry.";
}
extension snmp-name {
argument name {
tailf:arg-type {
type tailf:snmp-identifier;
}
}
tailf:use-in "leaf";
tailf:use-in "leaf-list";
tailf:use-in "list";
tailf:use-in "container";
tailf:use-in "tailf:symlink";
tailf:use-in "enum";
tailf:use-in "refine";
tailf:occurence "*";
description
"Used when the YANG module is mapped to an SNMP module.
When the parent node is mapped to an SNMP object, this statement
specifies the name of the SNMP object.
If the parent node is mapped to multiple SNMP objects, this
statement can be given multiple times. The first statement
specifies the primary table.
In a list, the argument is interpreted as:
[MIB-MODULE-NAME:]TABLE-NAME
For a leaf representing a table column, it is interpreted as:
[[MIB-MODULE-NAME:]TABLE-NAME:]NAME
For a leaf representing a scalar variable, it is interpreted as:
[MIB-MODULE-NAME:]NAME
If a YANG list is mapped to multiple SNMP tables, each such SNMP
table must be specified with a 'tailf:snmp-name' statement. If
the table is defined in another MIB than the MIB specified in
'tailf:snmp-mib-module-name', the MIB name must be specified in this
argument.
A leaf in a list that is mapped to multiple SNMP tables must specify
the name of the table it is mapped to if it is different from the
primary table.
In the following example, a single YANG list 'interface' is mapped
to the MIB tables ifTable, ifXTable, and ipv4InterfaceTable:
list interface {
key index;
tailf:snmp-name 'ifTable'; // primary table
tailf:snmp-name 'ifXTable';
tailf:snmp-name 'IP-MIB:ipv4InterfaceTable';
leaf index {
type int32;
}
leaf description {
type string;
tailf:snmp-name 'ifDescr'; // mapped to primary table
}
leaf name {
type string;
tailf:snmp-name 'ifXTable:ifName';
}
leaf ipv4-enable {
type boolean;
tailf:snmp-name
'IP-MIB:ipv4InterfaceTable:ipv4InterfaceEnableStatus';
}
...
}
When emitting a mib from yang, enum labels are used as-is if they
follow the SMI rules for labels (no '.' or '_' characters and beginning
with a lowercase letter). Any label that doesn't satisfy the SMI rules
will be converted as follows:
An initial uppercase character will be downcased.
If the initial character is not a letter it will be prepended with
an 'a'.
Any '.' or '_' characters elsewhere in the label will be substituted
with '-' characters.
In the resulting label, any multiple '-' character sequence will be
replaced with a single '-' character.
If this automatic conversion is not suitable, snmp-name can be used
to specify the label to use when emitting a MIB.";
}
extension snmp-mib-module-name {
argument name {
tailf:arg-type {
type tailf:identifier;
}
}
tailf:use-in "leaf";
tailf:use-in "leaf-list";
tailf:use-in "list";
tailf:use-in "container";
tailf:use-in "module";
tailf:use-in "refine";
description
"Used when the YANG module is mapped to an SNMP module.
Specifies the name of the SNMP MIB module where the SNMP objects
are defined.
This property is inherited by all child nodes.";
}
extension snmp-row-status-column {
argument value {
tailf:arg-type {
type uint32 {
range "1..max";
}
}
}
tailf:use-in "list";
tailf:use-in "refine";
description
"Used when an SNMP module is generated from the YANG module.
When the parent list node is mapped to an SNMP table, this
statement specifies the column number of the generated RowStatus
column. If it is not specified, the generated RowStatus column
will be the last in the table.";
}
extension snmp-lax-type-check {
argument value {
tailf:arg-type {
type boolean;
}
}
tailf:use-in "leaf";
description
"Normally, the ConfD MIB compiler checks that the data type of an SNMP
object matches the data type of the corresponding YANG leaf. If
both objects are writeble, the data types need to precisely
match, but if the SNMP object is read-only, or if
snmp-lax-type-check is set to 'true', the compiler accepts the
object if the SNMP type's value space is a superset of the YANG
type's value space.
If snmp-lax-type-check is true and the MIB object is writable, the SNMP
agent will reject values outside the YANG data type range in runtime.";
}
extension snmp-exclude-object {
tailf:use-in "leaf";
tailf:use-in "leaf-list";
tailf:use-in "list";
tailf:use-in "container";
tailf:use-in "tailf:symlink";
tailf:use-in "refine";
description
"Used when an SNMP MIB is generated from a YANG module, using
the --generate-oids option to confdc.
If this statement is present, confdc will exclude this object
from the resulting MIB.";
}
extension snmp-delete-value {
argument value {
tailf:arg-type {
type string;
}
}
tailf:use-in "leaf";
tailf:substatement "tailf:snmp-send-delete-value";
description
"This statement is used to define a value to be used in SNMP
to delete an optional leaf. The argument to this statement is the
special value. This special value must not be part of the value
space for the YANG leaf.
If the optional leaf does not exists, reading it over SNMP returns
'noSuchInstance', unless the statement 'tailf:snmp-send-delete-value'
is used, in which case the same value as used to delete the node
is returned.
For example, the YANG leaf:
leaf opt-int {
type int32 {
range '1..255';
}
tailf:snmp-delete-value 0 {
tailf:snmp-send-delete-value;
}
}
can be mapped to a SMI object with syntax:
SYNTAX Integer32 (0..255)
Setting such an object to '0' over SNMP will delete the node
from the datastore. If the node does not exsist, reading it over
SNMP will return '0'.";
}
extension snmp-send-delete-value {
tailf:use-in "tailf:snmp-delete-value";
description
"See tailf:snmp-delete-value.";
}
extension snmp-ned-set-before-row-modification {
argument value {
tailf:arg-type {
type string;
}
}
tailf:use-in "leaf";
description
"If this statement is present on a leaf, it tells the SNMP NED
that if a column in the row is modified, and it is marked with
'tailf:snmp-ned-modification-dependent', then the column marked
with 'tailf:snmp-ned-set-before-modification' needs to be set to
before the other column is modified. After all such
columns have been modified, the column marked with
'tailf:snmp-ned-set-before-modification' is reset to its initial
value.";
}
extension snmp-ned-modification-dependent {
tailf:use-in "leaf";
description
"This statement is used on all columns in a table that
require the usage of the column marked with
tailf:snmp-ned-set-before-row-modification.
This statement can be used on any column in a table where one
leaf is marked with tailf:snmp-ned-set-before-row-modification,
or a table that AUGMENTS such a table, or a table with a
foreign index in such a table.";
}
extension snmp-ned-accessible-column {
argument leaf-name {
tailf:arg-type {
type union {
type tailf:identifier;
type int32;
}
}
}
tailf:use-in "list";
description
"The name or subid number of an accessible column that is
instantiated in all table entries in a table. The column does
not have to be writable. The SNMP NED will use this column
when it uses GET-NEXT to loop through the list entries, and
when doing existence tests.
If this column is not given, the SNMP NED uses the following
algorithm:
1. If there is a RowStatus column, it will be used.
2. If an INDEX leaf is accessible, it will be used.
3. Otherwise, use the first accessible column returned
by the SNMP agent.";
}
extension snmp-ned-delete-before-create {
tailf:use-in "list";
description
"This statement is used in a list to make the SNMP NED always send
deletes before creates. Normally, creates are sent before deletes.";
}
extension snmp-ned-recreate-when-modified {
tailf:use-in "list";
description
"This statement is used in a list to make the SNMP NED delete
and recreate the row when a column in the row is modified.";
}
extension java-class-name {
argument name {
tailf:arg-type {
type string;
}
}
tailf:use-in "leaf";
tailf:use-in "leaf-list";
tailf:use-in "list";
tailf:use-in "container";
tailf:use-in "refine";
description
"Used to give another name than the default name to generated Java
classes. This statemement is typically used to avoid name conflicts
in the Java classes.";
}
extension code-name {
argument name {
tailf:arg-type {
type string;
}
}
tailf:use-in "enum";
tailf:use-in "bit";
tailf:use-in "leaf";
tailf:use-in "leaf-list";
tailf:use-in "list";
tailf:use-in "container";
tailf:use-in "rpc";
tailf:use-in "identity";
tailf:use-in "notification";
tailf:use-in "tailf:action";
description
"Used to give another name to the enum or node name in generated
header files. This statement is typically used to avoid name
conflicts if there is a data node with the same name as the
enumeration, if there are multiple enumerations in different
types with the same name but different values, or if there are
multiple node names that are mapped to the same name in the
header file.";
}
extension action {
argument name {
tailf:arg-type {
type tailf:identifier;
}
}
tailf:use-in "augment";
tailf:use-in "list";
tailf:use-in "container";
tailf:use-in "grouping";
tailf:occurence "*";
tailf:substatement "description";
tailf:substatement "input";
tailf:substatement "output";
tailf:substatement "status";
tailf:substatement "tailf:actionpoint";
tailf:substatement "tailf:alt-name";
tailf:substatement "tailf:cli-mount-point";
tailf:substatement "tailf:cli-configure-mode";
tailf:substatement "tailf:cli-operational-mode";
tailf:substatement "tailf:cli-oper-info";
tailf:substatement "tailf:code-name";
tailf:substatement "tailf:confirm-text";
tailf:substatement "tailf:display-when";
tailf:substatement "tailf:exec";
tailf:substatement "tailf:hidden";
tailf:substatement "tailf:info";
tailf:substatement "tailf:info-html";
description
"Defines an action (method) in the data model.
When the action is invoked, the instance on which the action is
invoked is explicitly identified by an hierarchy of
configuration or state data.
The action statement can have either a 'tailf:actionpoint' or a
'tailf:exec' substatement. If the action is implemented as a
callback in an application daemon, 'tailf:actionpoint' is used,
whereas 'tailf:exec' is used for an action implemented as a
standalone executable (program or script). Additionally, 'action'
can have the same substatements as the standard YANG 'rpc'
statement, e.g., 'description', 'input', and 'output'.
For example:
container sys {
list interface {
key name;
leaf name {
type string;
}
tailf:action reset {
tailf:actionpoint my-ap;
input {
leaf after-seconds {
mandatory false;
type int32;
}
}
}
}
}
We can also add a 'tailf:confirm-text', which defines a string to
be used in the user interfaces to prompt the user for
confirmation before the action is executed. The optional
'tailf:confirm-default' and 'tailf:cli-batch-confirm-default' can be set
to control if the default is to proceed or to abort. The latter will only
be used during batch processing in the CLI (e.g. non-interactive mode).
tailf:action reset {
tailf:actionpoint my-ap;
input {
leaf after-seconds {
mandatory false;
type int32;
}
}
tailf:confirm-text 'Really want to do this?' {
tailf:confirm-default true;
}
}
The 'tailf:actionpoint' statement can have a 'tailf:opaque'
substatement, to define an opaque string that is passed to the
callback function.
tailf:action reset {
tailf:actionpoint my-ap {
tailf:opaque 'reset-interface';
}
input {
leaf after-seconds {
mandatory false;
type int32;
}
}
}
When we use the 'tailf:exec' substatement, the argument to exec
specifies the program or script that should be executed. For
example:
tailf:action reboot {
tailf:exec '/opt/sys/reboot.sh' {
tailf:args '-c $(context) -p $(path)';
}
input {
leaf when {
type enumeration {
enum now;
enum 10secs;
enum 1min;
}
}
}
}";
}
extension actionpoint {
argument name {
tailf:arg-type {
type tailf:identifier;
}
}
tailf:use-in "rpc";
tailf:use-in "tailf:action";
tailf:use-in "refine";
tailf:substatement "tailf:opaque";
tailf:substatement "tailf:internal";
description
"Identifies the callback in a data provider that implements the
action. See confd_lib_dp(3) for details on the API.";
}
extension confirm-text {
argument text {
yin-element true;
tailf:arg-type {
type string;
}
}
tailf:use-in "rpc";
tailf:use-in "tailf:action";
tailf:substatement "tailf:confirm-default";
tailf:substatement "tailf:cli-batch-confirm-default";
description
"A string which is used in the user interfaces to prompt the user for
confirmation before the action is executed. The optional
'confirm-default' and 'cli-batch-confirm-default' can be set to control
if the default is to proceed or to abort. The latter will only
be used during batch processing in the CLI (e.g. non-interactive mode).";
}
extension confirm-default {
argument name {
tailf:arg-type {
type boolean;
}
}
tailf:use-in "tailf:confirm-text";
description
"Specifies if the default is to proceed or abort the action when a
confirm-text is set. If this value is not specified, a ConfD
global default value can be set in clispec(5).";
}
extension indexed-view {
tailf:use-in "list";
tailf:substatement "tailf:auto-compact";
description
"This element can only be used if the list has a single key of
an integer type.
It is used to signal that lists instances uses an indexed view,
i.e., making it possible to insert a new list entry at a certain
position. If a list entry is inserted at a certain position, list
entries following this position are automatically renumbered by the
system, if needed, to make room for the new entry.
This statement is mainly provided for backwards compatibility with
confspecs. New data models should consider using YANG's ordered-by
user statement instead.";
}
extension auto-compact {
tailf:use-in "tailf:indexed-view";
description
"If an indexed-view list is marked with this statement, it means that
the server will automatically renumber entires after a delete
operation so that the list entries are strictly monotonically
increasing, starting from 1, with no holes. New list entries
can either be insterted anywhere in the list, or created at the
end; but it is an error to try to create a list entry with a
key that would result in a hole in the sequence.
For example, if the list has entries 1,2,3 it is an error to
create entry 5, but correct to create 4.";
}
extension key-default {
argument value {
tailf:arg-type {
type string;
}
}
tailf:use-in "leaf";
description
"Must be used for key leafs only.
Specifies a value that the CLI and WebUI will use when a list entry is
created, and this key leaf is not given a value.
If one key leaf has a key-default value, all key leafs that
follow this key leaf must also have key-default values.";
}
extension error-info {
tailf:use-in "module";
tailf:use-in "submodule";
tailf:occurence "?";
tailf:substatement "description";
tailf:substatement "leaf" {
tailf:occurence "*";
}
tailf:substatement "leaf-list" {
tailf:occurence "*";
}
tailf:substatement "list" {
tailf:occurence "*";
}
tailf:substatement "container" {
tailf:occurence "*";
}
tailf:substatement "choice" {
tailf:occurence "*";
}
tailf:substatement "uses" {
tailf:occurence "*";
}
description
"Declares a set of data nodes to be used in the NETCONF
element.
A data provider can use one of the
confd_*_seterr_extended_info() functions (see confd_lib_dp(3))
to set these data nodes on errors.
This statement may be used multiple times.
For example:
tailf:error-info {
leaf severity {
type enumeration {
enum info;
enum error;
enum critical;
}
}
container detail {
leaf class {
type uint8;
}
leaf code {
type uint8;
}
}
}";
}
extension non-strict-leafref {
tailf:use-in "leaf";
tailf:use-in "leaf-list";
tailf:substatement "path" {
tailf:occurence "1";
}
description
"This statement can be used in leafs and leaf-lists similar
to 'leafref', but allows reference to non-existing leafs,
and allows reference from config to non-config.
This statement takes no argument, but expects the core YANG
statement 'path' as a substatement. The function 'deref' cannot
be used in the path, since it works on nodes of type leafref
only.
The type of the leaf or leaf-list must be exactly the same
as the type of the target.
This statement can be viewed as a substitute for a standard
'require-instance false' on leafrefs, which isn't allowed.
The CLI uses this statement to provide completion with
existing values, and the WebUI uses it to provide a
drop-down box with existing values.";
}
extension exec {
argument cmd {
tailf:arg-type {
type string;
}
}
tailf:use-in "rpc";
tailf:use-in "tailf:action";
tailf:substatement "tailf:args";
tailf:substatement "tailf:uid";
tailf:substatement "tailf:gid";
tailf:substatement "tailf:wd";
tailf:substatement "tailf:global-no-duplicate";
tailf:substatement "tailf:raw-xml";
tailf:substatement "tailf:interruptible";
tailf:substatement "tailf:interrupt";
description
"Specifies that the rpc or action is implemented as an OS executable.
The argument 'cmd' is the path to the executable file. If the
command is in the $PATH of ConfD, the 'cmd' can be just the name
of the executable.";
}
extension args {
argument value {
tailf:arg-type {
type string;
}
}
tailf:use-in "tailf:exec";
description
"Specifies arguments to send to the executable when it is invoked by
ConfD. The argument 'value' is a space separated list of
argument strings. It may contain variables on the form
$(variablename). These variables will be expanded before the
command is executed. The following variables are always available:
$(user) The name of the user which runs the operation.
$(groups) A comma separated string of the names of the groups
the user belongs to.
$(ip) The source ip address of the user session.
$(uid) The user id of the user.
$(gid) The group id of the user.
When the parent 'exec' statement is a substatement of 'action', the
following additional variablenames are available:
$(keypath) The path that identifies the parent container of 'action'
in string keypath form, e.g.,
'/sys:host{earth}/interface{eth0}'.
$(path) The path that identifies the parent container of 'action'
in CLI path form, e.g., 'host earth interface eth0'.
$(context) cli | webui | netconf | any string provided by MAAPI
For example:
args '-user $(user) $(uid)';
might expand to:
-user bob 500
";
}
extension raw-xml {
tailf:use-in "tailf:exec";
tailf:substatement "tailf:batch";
description
"Specifies that ConfD should not convert the RPC XML parameters to
command line arguments. Instead, ConfD just passes the raw XML on
stdin to the program.
This statement is not allowed in 'tailf:action'.";
}
extension interruptible {
argument value {
tailf:arg-type {
type boolean;
default "true";
}
}
tailf:use-in "tailf:exec";
description
"Specifies whether the client can abort the
execution of the executable.";
}
extension interrupt {
argument signal {
tailf:arg-type {
type enumeration {
enum "sigkill";
enum "sigint";
enum "sigterm";
}
default "sigkill";
}
}
tailf:use-in "tailf:exec";
description
"This statement specifies which signal is sent to executable by ConfD
in case the client terminates or aborts the execution.
If not specified, 'sigkill' is sent.";
}
extension uid {
argument value {
tailf:arg-type {
type union {
type enumeration {
enum "confd" {
description
"The command is run as the same user id as the ConfD daemon.";
}
enum "user" {
description
"The command is run as the same user id as the user logged
in to ConfD. This user id MUST exist as an actual user id
in the underlying operating system.";
}
enum "root" {
description
"The command is run as root.";
}
}
type uint32;
}
}
}
tailf:use-in "tailf:exec";
description
"Specifies which user id to use when executing the command.
If 'uid' is an integer value, the command is run as the user with
this user id.
If 'uid' is set to either 'user', 'root' or an integer user id, the
ConfD daemon must have been started as root (or setuid), or the
ConfD executable program 'cmdwrapper' must have setuid root
permissions.";
}
extension gid {
argument value {
tailf:arg-type {
type union {
type enumeration {
enum "confd" {
description
"The command is run as the same group id as the ConfD daemon.";
}
enum "user" {
description
"The command is run as the same group id as the user logged
in to ConfD. This group id MUST exist as an actual group id
in the underlying operating system.";
}
enum "root" {
description
"The command is run as root.";
}
}
type uint32;
}
}
}
tailf:use-in "tailf:exec";
description
"Specifies which group id to use when executing the command.
If 'gid' is an integer value, the command is run as the group with
this group id.
If 'gid' is set to either 'user', 'root' or an integer group id, the
ConfD daemon must have been started as root (or setuid), or the
ConfD executable program 'cmdwrapper' must have setuid root
permissions.";
}
extension wd {
argument value {
tailf:arg-type {
type string;
}
}
tailf:use-in "tailf:exec";
description
"Specifies which working directory to use when executing the
command. If not given the command is executed from the homedir
of the user logged in to ConfD.";
}
extension global-no-duplicate {
argument value {
tailf:arg-type {
type string;
}
}
tailf:use-in "tailf:exec";
description
"Specifies that only one instance with the same name can be run at any
one time in the system. The command can be started either from
the CLI, the WebUI or through NETCONF. If a client tries to
execute this command while another operation with the same
'global-no-duplicate' name is running, a 'resource-denied' error is
generated.";
}
extension batch {
tailf:use-in "tailf:raw-xml";
description
"Specifies that the command returns immediately, but still runs in the
background.";
}
typedef hex-list {
type string {
pattern "(([0-9a-fA-F]){2}(:([0-9a-fA-F]){2})*)?";
}
status deprecated;
description
"DEPRECATED: Use yang:hex-string instead. There are no plans to remove
tailf:hex-list.
A list of colon-separated hexa-decimal octets e.g. '4F:4C:41:71'.
The statement tailf:value-length can be used to restrict the number
of octets. Note that using the 'length' restriction limits the
number of characters in the lexical representation.";
}
extension symlink {
argument name {
tailf:arg-type {
type tailf:identifier;
}
}
status deprecated;
tailf:use-in "list";
tailf:use-in "container";
tailf:use-in "module";
tailf:use-in "submodule";
tailf:use-in "augment";
tailf:use-in "case";
tailf:occurence "*";
tailf:substatement "status";
tailf:substatement "tailf:alt-name";
tailf:substatement "tailf:cli-add-mode";
tailf:substatement "tailf:cli-allow-join-with-key";
tailf:substatement "tailf:cli-allow-join-with-value";
tailf:substatement "tailf:cli-allow-key-abbreviation";
tailf:substatement "tailf:cli-allow-range";
tailf:substatement "tailf:cli-allow-wildcard";
tailf:substatement "tailf:cli-autowizard";
tailf:substatement "tailf:cli-boolean-no";
tailf:substatement "tailf:cli-break-sequence-commands";
tailf:substatement "tailf:cli-column-align";
tailf:substatement "tailf:cli-column-stats";
tailf:substatement "tailf:cli-column-width";
tailf:substatement "tailf:cli-compact-stats";
tailf:substatement "tailf:cli-compact-syntax";
tailf:substatement "tailf:cli-completion-actionpoint";
tailf:substatement "tailf:cli-custom-error";
tailf:substatement "tailf:cli-custom-range";
tailf:substatement "tailf:cli-custom-range-actionpoint";
tailf:substatement "tailf:cli-custom-range-enumerator";
tailf:substatement "tailf:cli-delayed-auto-commit";
tailf:substatement "tailf:cli-delete-container-on-delete";
tailf:substatement "tailf:cli-delete-when-empty";
tailf:substatement "tailf:cli-diff-dependency" {
tailf:occurence "*";
}
tailf:substatement "tailf:cli-disabled-info";
tailf:substatement "tailf:cli-disallow-value";
tailf:substatement "tailf:cli-display-empty-config";
tailf:substatement "tailf:cli-display-separated";
tailf:substatement "tailf:cli-drop-node-name";
tailf:substatement "tailf:cli-no-keyword";
tailf:substatement "tailf:cli-enforce-table";
tailf:substatement "tailf:cli-embed-no-on-delete";
tailf:substatement "tailf:cli-exit-command";
tailf:substatement "tailf:cli-explicit-exit";
tailf:substatement "tailf:cli-expose-key-name";
tailf:substatement "tailf:cli-expose-ns-prefix";
tailf:substatement "tailf:cli-flat-list-syntax";
tailf:substatement "tailf:cli-flatten-container";
tailf:substatement "tailf:cli-full-command";
tailf:substatement "tailf:cli-full-no";
tailf:substatement "tailf:cli-full-show-path";
tailf:substatement "tailf:cli-hide-in-submode";
tailf:substatement "tailf:cli-ignore-modified";
tailf:substatement "tailf:cli-incomplete-command";
tailf:substatement "tailf:cli-incomplete-no";
tailf:substatement "tailf:cli-incomplete-show-path";
tailf:substatement "tailf:cli-instance-info-leafs";
tailf:substatement "tailf:cli-key-format";
tailf:substatement "tailf:cli-list-syntax";
tailf:substatement "tailf:cli-min-column-width";
tailf:substatement "tailf:cli-mode-name";
tailf:substatement "tailf:cli-mode-name-actionpoint";
tailf:substatement "tailf:cli-multi-value";
tailf:substatement "tailf:cli-multi-word-key";
tailf:substatement "tailf:cli-multi-line-prompt";
tailf:substatement "tailf:cli-no-key-completion";
tailf:substatement "tailf:cli-no-match-completion";
tailf:substatement "tailf:cli-no-name-on-delete";
tailf:substatement "tailf:cli-no-value-on-delete";
tailf:substatement "tailf:cli-oper-info";
tailf:substatement "tailf:cli-optional-in-sequence";
tailf:substatement "tailf:cli-prefix-key";
tailf:substatement "tailf:cli-preformatted";
tailf:substatement "tailf:cli-range-delimiters";
tailf:substatement "tailf:cli-range-list-syntax";
tailf:substatement "tailf:cli-recursive-delete";
tailf:substatement "tailf:cli-remove-before-change";
tailf:substatement "tailf:cli-reset-container";
tailf:substatement "tailf:cli-run-template";
tailf:substatement "tailf:cli-run-template-enter";
tailf:substatement "tailf:cli-run-template-footer";
tailf:substatement "tailf:cli-run-template-legend";
tailf:substatement "tailf:cli-sequence-commands";
tailf:substatement "tailf:cli-show-config";
tailf:substatement "tailf:cli-show-no";
tailf:substatement "tailf:cli-show-order-tag";
tailf:substatement "tailf:cli-show-order-taglist";
tailf:substatement "tailf:cli-show-template";
tailf:substatement "tailf:cli-show-template-enter";
tailf:substatement "tailf:cli-show-template-footer";
tailf:substatement "tailf:cli-show-template-legend";
tailf:substatement "tailf:cli-show-with-default";
tailf:substatement "tailf:cli-strict-leafref";
tailf:substatement "tailf:cli-suppress-key-abbreviation";
tailf:substatement "tailf:cli-suppress-key-sort";
tailf:substatement "tailf:cli-suppress-list-no";
tailf:substatement "tailf:cli-suppress-mode";
tailf:substatement "tailf:cli-suppress-no";
tailf:substatement "tailf:cli-suppress-range";
tailf:substatement "tailf:cli-suppress-shortenabled";
tailf:substatement "tailf:cli-suppress-show-conf-path";
tailf:substatement "tailf:cli-suppress-show-match";
tailf:substatement "tailf:cli-suppress-show-path";
tailf:substatement "tailf:cli-suppress-silent-no";
tailf:substatement "tailf:cli-suppress-validation-warning-prompt";
tailf:substatement "tailf:cli-suppress-wildcard";
tailf:substatement "tailf:cli-table-footer";
tailf:substatement "tailf:cli-table-legend";
tailf:substatement "tailf:cli-trim-default";
tailf:substatement "tailf:cli-value-display-template";
tailf:substatement "tailf:display-when";
tailf:substatement "tailf:hidden" {
tailf:occurence "*";
}
tailf:substatement "tailf:inherit-set-hook";
tailf:substatement "tailf:info";
tailf:substatement "tailf:info-html";
tailf:substatement "tailf:path" {
tailf:occurence "1";
}
tailf:substatement "tailf:snmp-exclude-object";
tailf:substatement "tailf:snmp-name" {
tailf:occurence "*";
}
tailf:substatement "tailf:snmp-oid";
tailf:substatement "tailf:sort-priority";
description
"DEPRECATED: Use tailf:link instead. There are no plans to remove
tailf:symlink.
This statement defines a 'symbolic link' from a node to some other node.
The argument is the name of the new node, and the mandatory substatement
'tailf:path' points to the node which is linked to.";
}
extension path {
argument path {
tailf:arg-type {
type string;
}
}
status deprecated;
tailf:occurence "1";
tailf:use-in "tailf:symlink";
description
"This statement specifies which node a symlink points to.
The textual format of a symlink is an XPath absolute location path. If
the target lies within lists, all keys must be specified.
A key either has a value, or is a reference to a key in the path of the
source node, using the function current() as starting
point for an XPath location path. For example:
/a/b[k1='paul'][k2=current()/../k]/c
";
}
extension internal {
tailf:use-in "tailf:callpoint";
tailf:use-in "tailf:validate";
tailf:use-in "tailf:actionpoint";
description
"For internal ConfD / NCS use only.";
}
extension junos-val-as-xml-tag {
tailf:use-in "leaf";
description
"Internal extension to handle non-YANG JUNOS data models.
Use only for key enumeration leafs.";
}
extension junos-val-with-prev-xml-tag {
tailf:use-in "leaf";
description
"Internal extension to handle non-YANG JUNOS data models.
Use only for keys where previous key is marked with
'tailf:junos-val-as-xml-tag'.";
}
extension xpath-root {
argument value {
tailf:arg-type {
type uint8;
}
}
tailf:use-in "must";
tailf:use-in "when";
tailf:use-in "path";
tailf:use-in "tailf:display-when";
tailf:use-in "tailf:cli-diff-dependency";
description
"Internal extension to 'chroot' XPath expressions";
}
extension ncs-device-type {
argument type {
tailf:arg-type {
type string;
}
}
tailf:use-in "container";
tailf:use-in "list";
tailf:use-in "leaf";
tailf:use-in "leaf-list";
tailf:use-in "refine";
description
"Internal extension to tell NCS what type of device the data model
is used for.";
}
extension structure {
argument name {
tailf:arg-type {
type tailf:identifier;
}
}
tailf:use-in "module";
tailf:use-in "submodule";
tailf:occurence "*";
tailf:substatement "description";
tailf:substatement "leaf" {
tailf:occurence "*";
}
tailf:substatement "leaf-list" {
tailf:occurence "*";
}
tailf:substatement "list" {
tailf:occurence "*";
}
tailf:substatement "container" {
tailf:occurence "*";
}
tailf:substatement "choice" {
tailf:occurence "*";
}
tailf:substatement "uses" {
tailf:occurence "*";
}
description
"Internal extension to define a data structure without any semantics
attached.";
}
}