From e0b697a204b7f590f5b11a956a5d4486b0350500 Mon Sep 17 00:00:00 2001 From: Michal Rehak Date: Tue, 17 May 2016 15:01:15 +0200 Subject: [PATCH] ios-xe renderer - initial push - config subsystem binding - bootstrap provider - ned.yang - artifacts involved Change-Id: Ib8d0afe1d4922404f91081ed80bb20124d76b996 Signed-off-by: Michal Rehak Signed-off-by: Vladimir Lavor --- artifacts/pom.xml | 5 + renderers/ios-xe/pom.xml | 77 + .../api/IosXeRendererProvider.java | 18 + .../impl/IosXeRendererProviderImpl.java | 48 + .../impl/config/IosXeProviderModule.java | 32 + .../config/IosXeProviderModuleFactory.java | 12 + .../IpAddressAndPrefixLengthBuilder.java | 19 + .../inet/types/rev130715/HostBuilder.java | 19 + .../types/rev130715/IpAddressBuilder.java | 19 + .../rev130715/IpAddressNoZoneBuilder.java | 19 + .../inet/types/rev130715/IpPrefixBuilder.java | 19 + .../ios/rev160516/ClassNameTypeBuilder.java | 19 + .../ios/rev160516/CosValueTypeBuilder.java | 19 + .../v1/urn/ios/rev160516/DscpTypeBuilder.java | 19 + .../ios/rev160516/ExpValueTypeBuilder.java | 19 + .../ios/rev160516/PrecValueTypeBuilder.java | 19 + .../ios/rev160516/PrecedenceType2Builder.java | 19 + .../ios/rev160516/PrecedenceTypeBuilder.java | 19 + .../ios/rev160516/QosValueTypeBuilder.java | 19 + .../mls/qos/MapPolicedDscpBuilder.java | 20 + .../metric/rtp/ClockRateNumberBuilder.java | 20 + .../src/main/yang/ios-xe-provider-impl.yang | 68 + .../ios-xe/src/main/yang/ios-xe-provider.yang | 29 + .../main/yang/netconf/ietf-inet-types.yang | 461 ++ .../ios-xe/src/main/yang/netconf/ned.yang | 5844 +++++++++++++++++ .../yang/netconf/tailf-cli-extensions.yang | 2611 ++++++++ .../src/main/yang/netconf/tailf-common.yang | 3219 +++++++++ .../yang/netconf/tailf-meta-extensions.yang | 133 + renderers/pom.xml | 20 +- 29 files changed, 12860 insertions(+), 4 deletions(-) create mode 100755 renderers/ios-xe/pom.xml create mode 100644 renderers/ios-xe/src/main/java/org/opendaylight/groupbasedpolicy/renderer/ios_xe_provider/api/IosXeRendererProvider.java create mode 100644 renderers/ios-xe/src/main/java/org/opendaylight/groupbasedpolicy/renderer/ios_xe_provider/impl/IosXeRendererProviderImpl.java create mode 100644 renderers/ios-xe/src/main/java/org/opendaylight/groupbasedpolicy/renderer/ios_xe_provider/impl/config/IosXeProviderModule.java create mode 100644 renderers/ios-xe/src/main/java/org/opendaylight/groupbasedpolicy/renderer/ios_xe_provider/impl/config/IosXeProviderModuleFactory.java create mode 100644 renderers/ios-xe/src/main/java/org/opendaylight/yang/gen/v1/http/tail/f/com/yang/common/rev150522/IpAddressAndPrefixLengthBuilder.java create mode 100644 renderers/ios-xe/src/main/java/org/opendaylight/yang/gen/v1/urn/ietf/params/xml/ns/yang/ietf/inet/types/rev130715/HostBuilder.java create mode 100644 renderers/ios-xe/src/main/java/org/opendaylight/yang/gen/v1/urn/ietf/params/xml/ns/yang/ietf/inet/types/rev130715/IpAddressBuilder.java create mode 100644 renderers/ios-xe/src/main/java/org/opendaylight/yang/gen/v1/urn/ietf/params/xml/ns/yang/ietf/inet/types/rev130715/IpAddressNoZoneBuilder.java create mode 100644 renderers/ios-xe/src/main/java/org/opendaylight/yang/gen/v1/urn/ietf/params/xml/ns/yang/ietf/inet/types/rev130715/IpPrefixBuilder.java create mode 100644 renderers/ios-xe/src/main/java/org/opendaylight/yang/gen/v1/urn/ios/rev160516/ClassNameTypeBuilder.java create mode 100644 renderers/ios-xe/src/main/java/org/opendaylight/yang/gen/v1/urn/ios/rev160516/CosValueTypeBuilder.java create mode 100644 renderers/ios-xe/src/main/java/org/opendaylight/yang/gen/v1/urn/ios/rev160516/DscpTypeBuilder.java create mode 100644 renderers/ios-xe/src/main/java/org/opendaylight/yang/gen/v1/urn/ios/rev160516/ExpValueTypeBuilder.java create mode 100644 renderers/ios-xe/src/main/java/org/opendaylight/yang/gen/v1/urn/ios/rev160516/PrecValueTypeBuilder.java create mode 100644 renderers/ios-xe/src/main/java/org/opendaylight/yang/gen/v1/urn/ios/rev160516/PrecedenceType2Builder.java create mode 100644 renderers/ios-xe/src/main/java/org/opendaylight/yang/gen/v1/urn/ios/rev160516/PrecedenceTypeBuilder.java create mode 100644 renderers/ios-xe/src/main/java/org/opendaylight/yang/gen/v1/urn/ios/rev160516/QosValueTypeBuilder.java create mode 100644 renderers/ios-xe/src/main/java/org/opendaylight/yang/gen/v1/urn/ios/rev160516/_native/mls/qos/MapPolicedDscpBuilder.java create mode 100644 renderers/ios-xe/src/main/java/org/opendaylight/yang/gen/v1/urn/ios/rev160516/_native/policy/map/_class/pm/policy/monitor/metric/rtp/ClockRateNumberBuilder.java create mode 100755 renderers/ios-xe/src/main/yang/ios-xe-provider-impl.yang create mode 100644 renderers/ios-xe/src/main/yang/ios-xe-provider.yang create mode 100644 renderers/ios-xe/src/main/yang/netconf/ietf-inet-types.yang create mode 100644 renderers/ios-xe/src/main/yang/netconf/ned.yang create mode 100644 renderers/ios-xe/src/main/yang/netconf/tailf-cli-extensions.yang create mode 100644 renderers/ios-xe/src/main/yang/netconf/tailf-common.yang create mode 100644 renderers/ios-xe/src/main/yang/netconf/tailf-meta-extensions.yang diff --git a/artifacts/pom.xml b/artifacts/pom.xml index f9fd8aa7f..b8c57bd28 100755 --- a/artifacts/pom.xml +++ b/artifacts/pom.xml @@ -46,6 +46,11 @@ ovssfc-renderer ${project.version} + + ${project.groupId} + ios-xe-renderer + ${project.version} + ${project.groupId} ne-location-provider diff --git a/renderers/ios-xe/pom.xml b/renderers/ios-xe/pom.xml new file mode 100755 index 000000000..244118e0a --- /dev/null +++ b/renderers/ios-xe/pom.xml @@ -0,0 +1,77 @@ + + + + 4.0.0 + + + org.opendaylight.groupbasedpolicy + groupbasedpolicy-renderers + 0.4.0-SNAPSHOT + ../ + + + ios-xe-renderer + bundle + + + + + junit + junit + test + + + org.mockito + mockito-all + test + + + org.opendaylight.controller + sal-binding-broker-impl + test-jar + test + + + org.opendaylight.groupbasedpolicy + groupbasedpolicy + ${project.version} + test-jar + test + + + + + + + org.opendaylight.yangtools + yang-maven-plugin + + + config + + generate-sources + + + + + org.opendaylight.controller.config.yangjmxgenerator.plugin.JMXGenerator + ${jmxGeneratorPath} + + urn:opendaylight:params:xml:ns:yang:controller==org.opendaylight.controller.config.yang + urn:opendaylight:params:xml:ns:yang:groupbasedpolicy:renderer==org.opendaylight.groupbasedpolicy.renderer + + + + true + + + + + + + + diff --git a/renderers/ios-xe/src/main/java/org/opendaylight/groupbasedpolicy/renderer/ios_xe_provider/api/IosXeRendererProvider.java b/renderers/ios-xe/src/main/java/org/opendaylight/groupbasedpolicy/renderer/ios_xe_provider/api/IosXeRendererProvider.java new file mode 100644 index 000000000..4c8e2521a --- /dev/null +++ b/renderers/ios-xe/src/main/java/org/opendaylight/groupbasedpolicy/renderer/ios_xe_provider/api/IosXeRendererProvider.java @@ -0,0 +1,18 @@ +/* + * Copyright (c) 2016 Cisco Systems, Inc. and others. 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 + */ + +package org.opendaylight.groupbasedpolicy.renderer.ios_xe_provider.api; + +/** + * Main IOS-XE provider interface + */ +public interface IosXeRendererProvider extends AutoCloseable { + + @Override + void close(); +} diff --git a/renderers/ios-xe/src/main/java/org/opendaylight/groupbasedpolicy/renderer/ios_xe_provider/impl/IosXeRendererProviderImpl.java b/renderers/ios-xe/src/main/java/org/opendaylight/groupbasedpolicy/renderer/ios_xe_provider/impl/IosXeRendererProviderImpl.java new file mode 100644 index 000000000..687474446 --- /dev/null +++ b/renderers/ios-xe/src/main/java/org/opendaylight/groupbasedpolicy/renderer/ios_xe_provider/impl/IosXeRendererProviderImpl.java @@ -0,0 +1,48 @@ +/* + * Copyright (c) 2016 Cisco Systems, Inc. and others. 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 + */ + +package org.opendaylight.groupbasedpolicy.renderer.ios_xe_provider.impl; + +import com.google.common.base.Preconditions; +import org.opendaylight.controller.md.sal.binding.api.DataBroker; +import org.opendaylight.controller.sal.binding.api.BindingAwareBroker; +import org.opendaylight.controller.sal.binding.api.BindingAwareProvider; +import org.opendaylight.groupbasedpolicy.renderer.ios_xe_provider.api.IosXeRendererProvider; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +/** + * Purpose: bootstrap provider implementation of Ios-xe renderer + */ +public class IosXeRendererProviderImpl implements IosXeRendererProvider, BindingAwareProvider { + + private static final Logger LOG = LoggerFactory.getLogger(IosXeRendererProviderImpl.class); + + private final DataBroker dataBrokerDependency; + + public IosXeRendererProviderImpl(final DataBroker dataBrokerDependency, final BindingAwareBroker brokerDependency) { + LOG.debug("ios-xe renderer bootstrap"); + this.dataBrokerDependency = Preconditions.checkNotNull(dataBrokerDependency, "missing dataBroker dependency"); + brokerDependency.registerProvider(this); + } + + @Override + public void close() { + //TODO + LOG.info("closing ios-xe renderer"); + } + + @Override + public void onSessionInitiated(final BindingAwareBroker.ProviderContext providerContext) { + LOG.info("starting ios-xe renderer"); + //TODO register listeners: + // renderer-configuration endpoints + // ep-policy-template-by-sgt + // supported node list maintenance + } +} diff --git a/renderers/ios-xe/src/main/java/org/opendaylight/groupbasedpolicy/renderer/ios_xe_provider/impl/config/IosXeProviderModule.java b/renderers/ios-xe/src/main/java/org/opendaylight/groupbasedpolicy/renderer/ios_xe_provider/impl/config/IosXeProviderModule.java new file mode 100644 index 000000000..b49b0dc0f --- /dev/null +++ b/renderers/ios-xe/src/main/java/org/opendaylight/groupbasedpolicy/renderer/ios_xe_provider/impl/config/IosXeProviderModule.java @@ -0,0 +1,32 @@ +/* + * Copyright (c) 2014 Cisco Systems, Inc. and others. 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 + */ + +package org.opendaylight.groupbasedpolicy.renderer.ios_xe_provider.impl.config; + +import org.opendaylight.groupbasedpolicy.renderer.ios_xe_provider.impl.IosXeRendererProviderImpl; + +public class IosXeProviderModule extends org.opendaylight.groupbasedpolicy.renderer.ios_xe_provider.impl.config.AbstractIosXeProviderModule { + public IosXeProviderModule(org.opendaylight.controller.config.api.ModuleIdentifier identifier, org.opendaylight.controller.config.api.DependencyResolver dependencyResolver) { + super(identifier, dependencyResolver); + } + + public IosXeProviderModule(org.opendaylight.controller.config.api.ModuleIdentifier identifier, org.opendaylight.controller.config.api.DependencyResolver dependencyResolver, org.opendaylight.groupbasedpolicy.renderer.ios_xe_provider.impl.config.IosXeProviderModule oldModule, java.lang.AutoCloseable oldInstance) { + super(identifier, dependencyResolver, oldModule, oldInstance); + } + + @Override + public void customValidation() { + // add custom validation form module attributes here. + } + + @Override + public java.lang.AutoCloseable createInstance() { + return new IosXeRendererProviderImpl(getDataBrokerDependency(), getBrokerDependency()); + } + +} diff --git a/renderers/ios-xe/src/main/java/org/opendaylight/groupbasedpolicy/renderer/ios_xe_provider/impl/config/IosXeProviderModuleFactory.java b/renderers/ios-xe/src/main/java/org/opendaylight/groupbasedpolicy/renderer/ios_xe_provider/impl/config/IosXeProviderModuleFactory.java new file mode 100644 index 000000000..e2215f7a7 --- /dev/null +++ b/renderers/ios-xe/src/main/java/org/opendaylight/groupbasedpolicy/renderer/ios_xe_provider/impl/config/IosXeProviderModuleFactory.java @@ -0,0 +1,12 @@ +/* + * Copyright (c) 2014 Cisco Systems, Inc. and others. 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 + */ + +package org.opendaylight.groupbasedpolicy.renderer.ios_xe_provider.impl.config; +public class IosXeProviderModuleFactory extends org.opendaylight.groupbasedpolicy.renderer.ios_xe_provider.impl.config.AbstractIosXeProviderModuleFactory { + +} diff --git a/renderers/ios-xe/src/main/java/org/opendaylight/yang/gen/v1/http/tail/f/com/yang/common/rev150522/IpAddressAndPrefixLengthBuilder.java b/renderers/ios-xe/src/main/java/org/opendaylight/yang/gen/v1/http/tail/f/com/yang/common/rev150522/IpAddressAndPrefixLengthBuilder.java new file mode 100644 index 000000000..972544846 --- /dev/null +++ b/renderers/ios-xe/src/main/java/org/opendaylight/yang/gen/v1/http/tail/f/com/yang/common/rev150522/IpAddressAndPrefixLengthBuilder.java @@ -0,0 +1,19 @@ +package org.opendaylight.yang.gen.v1.http.tail.f.com.yang.common.rev150522; + + +/** + * The purpose of generated class in src/main/java for Union types is to create new instances of unions from a string representation. + * In some cases it is very difficult to automate it since there can be unions such as (uint32 - uint16), or (string - uint32). + * + * The reason behind putting it under src/main/java is: + * This class is generated in form of a stub and needs to be finished by the user. This class is generated only once to prevent + * loss of user code. + * + */ +public class IpAddressAndPrefixLengthBuilder { + + public static IpAddressAndPrefixLength getDefaultInstance(java.lang.String defaultValue) { + throw new java.lang.UnsupportedOperationException("Not yet implemented"); + } + +} diff --git a/renderers/ios-xe/src/main/java/org/opendaylight/yang/gen/v1/urn/ietf/params/xml/ns/yang/ietf/inet/types/rev130715/HostBuilder.java b/renderers/ios-xe/src/main/java/org/opendaylight/yang/gen/v1/urn/ietf/params/xml/ns/yang/ietf/inet/types/rev130715/HostBuilder.java new file mode 100644 index 000000000..62ca8a660 --- /dev/null +++ b/renderers/ios-xe/src/main/java/org/opendaylight/yang/gen/v1/urn/ietf/params/xml/ns/yang/ietf/inet/types/rev130715/HostBuilder.java @@ -0,0 +1,19 @@ +package org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715; + + +/** + * The purpose of generated class in src/main/java for Union types is to create new instances of unions from a string representation. + * In some cases it is very difficult to automate it since there can be unions such as (uint32 - uint16), or (string - uint32). + * + * The reason behind putting it under src/main/java is: + * This class is generated in form of a stub and needs to be finished by the user. This class is generated only once to prevent + * loss of user code. + * + */ +public class HostBuilder { + + public static Host getDefaultInstance(java.lang.String defaultValue) { + throw new java.lang.UnsupportedOperationException("Not yet implemented"); + } + +} diff --git a/renderers/ios-xe/src/main/java/org/opendaylight/yang/gen/v1/urn/ietf/params/xml/ns/yang/ietf/inet/types/rev130715/IpAddressBuilder.java b/renderers/ios-xe/src/main/java/org/opendaylight/yang/gen/v1/urn/ietf/params/xml/ns/yang/ietf/inet/types/rev130715/IpAddressBuilder.java new file mode 100644 index 000000000..85f807711 --- /dev/null +++ b/renderers/ios-xe/src/main/java/org/opendaylight/yang/gen/v1/urn/ietf/params/xml/ns/yang/ietf/inet/types/rev130715/IpAddressBuilder.java @@ -0,0 +1,19 @@ +package org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715; + + +/** + * The purpose of generated class in src/main/java for Union types is to create new instances of unions from a string representation. + * In some cases it is very difficult to automate it since there can be unions such as (uint32 - uint16), or (string - uint32). + * + * The reason behind putting it under src/main/java is: + * This class is generated in form of a stub and needs to be finished by the user. This class is generated only once to prevent + * loss of user code. + * + */ +public class IpAddressBuilder { + + public static IpAddress getDefaultInstance(java.lang.String defaultValue) { + throw new java.lang.UnsupportedOperationException("Not yet implemented"); + } + +} diff --git a/renderers/ios-xe/src/main/java/org/opendaylight/yang/gen/v1/urn/ietf/params/xml/ns/yang/ietf/inet/types/rev130715/IpAddressNoZoneBuilder.java b/renderers/ios-xe/src/main/java/org/opendaylight/yang/gen/v1/urn/ietf/params/xml/ns/yang/ietf/inet/types/rev130715/IpAddressNoZoneBuilder.java new file mode 100644 index 000000000..1adede9cf --- /dev/null +++ b/renderers/ios-xe/src/main/java/org/opendaylight/yang/gen/v1/urn/ietf/params/xml/ns/yang/ietf/inet/types/rev130715/IpAddressNoZoneBuilder.java @@ -0,0 +1,19 @@ +package org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715; + + +/** + * The purpose of generated class in src/main/java for Union types is to create new instances of unions from a string representation. + * In some cases it is very difficult to automate it since there can be unions such as (uint32 - uint16), or (string - uint32). + * + * The reason behind putting it under src/main/java is: + * This class is generated in form of a stub and needs to be finished by the user. This class is generated only once to prevent + * loss of user code. + * + */ +public class IpAddressNoZoneBuilder { + + public static IpAddressNoZone getDefaultInstance(java.lang.String defaultValue) { + throw new java.lang.UnsupportedOperationException("Not yet implemented"); + } + +} diff --git a/renderers/ios-xe/src/main/java/org/opendaylight/yang/gen/v1/urn/ietf/params/xml/ns/yang/ietf/inet/types/rev130715/IpPrefixBuilder.java b/renderers/ios-xe/src/main/java/org/opendaylight/yang/gen/v1/urn/ietf/params/xml/ns/yang/ietf/inet/types/rev130715/IpPrefixBuilder.java new file mode 100644 index 000000000..3b252f6b9 --- /dev/null +++ b/renderers/ios-xe/src/main/java/org/opendaylight/yang/gen/v1/urn/ietf/params/xml/ns/yang/ietf/inet/types/rev130715/IpPrefixBuilder.java @@ -0,0 +1,19 @@ +package org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715; + + +/** + * The purpose of generated class in src/main/java for Union types is to create new instances of unions from a string representation. + * In some cases it is very difficult to automate it since there can be unions such as (uint32 - uint16), or (string - uint32). + * + * The reason behind putting it under src/main/java is: + * This class is generated in form of a stub and needs to be finished by the user. This class is generated only once to prevent + * loss of user code. + * + */ +public class IpPrefixBuilder { + + public static IpPrefix getDefaultInstance(java.lang.String defaultValue) { + throw new java.lang.UnsupportedOperationException("Not yet implemented"); + } + +} diff --git a/renderers/ios-xe/src/main/java/org/opendaylight/yang/gen/v1/urn/ios/rev160516/ClassNameTypeBuilder.java b/renderers/ios-xe/src/main/java/org/opendaylight/yang/gen/v1/urn/ios/rev160516/ClassNameTypeBuilder.java new file mode 100644 index 000000000..2c1601c21 --- /dev/null +++ b/renderers/ios-xe/src/main/java/org/opendaylight/yang/gen/v1/urn/ios/rev160516/ClassNameTypeBuilder.java @@ -0,0 +1,19 @@ +package org.opendaylight.yang.gen.v1.urn.ios.rev160516; + + +/** + * The purpose of generated class in src/main/java for Union types is to create new instances of unions from a string representation. + * In some cases it is very difficult to automate it since there can be unions such as (uint32 - uint16), or (string - uint32). + * + * The reason behind putting it under src/main/java is: + * This class is generated in form of a stub and needs to be finished by the user. This class is generated only once to prevent + * loss of user code. + * + */ +public class ClassNameTypeBuilder { + + public static ClassNameType getDefaultInstance(java.lang.String defaultValue) { + throw new java.lang.UnsupportedOperationException("Not yet implemented"); + } + +} diff --git a/renderers/ios-xe/src/main/java/org/opendaylight/yang/gen/v1/urn/ios/rev160516/CosValueTypeBuilder.java b/renderers/ios-xe/src/main/java/org/opendaylight/yang/gen/v1/urn/ios/rev160516/CosValueTypeBuilder.java new file mode 100644 index 000000000..98574d12c --- /dev/null +++ b/renderers/ios-xe/src/main/java/org/opendaylight/yang/gen/v1/urn/ios/rev160516/CosValueTypeBuilder.java @@ -0,0 +1,19 @@ +package org.opendaylight.yang.gen.v1.urn.ios.rev160516; + + +/** + * The purpose of generated class in src/main/java for Union types is to create new instances of unions from a string representation. + * In some cases it is very difficult to automate it since there can be unions such as (uint32 - uint16), or (string - uint32). + * + * The reason behind putting it under src/main/java is: + * This class is generated in form of a stub and needs to be finished by the user. This class is generated only once to prevent + * loss of user code. + * + */ +public class CosValueTypeBuilder { + + public static CosValueType getDefaultInstance(java.lang.String defaultValue) { + throw new java.lang.UnsupportedOperationException("Not yet implemented"); + } + +} diff --git a/renderers/ios-xe/src/main/java/org/opendaylight/yang/gen/v1/urn/ios/rev160516/DscpTypeBuilder.java b/renderers/ios-xe/src/main/java/org/opendaylight/yang/gen/v1/urn/ios/rev160516/DscpTypeBuilder.java new file mode 100644 index 000000000..2e8b0ce61 --- /dev/null +++ b/renderers/ios-xe/src/main/java/org/opendaylight/yang/gen/v1/urn/ios/rev160516/DscpTypeBuilder.java @@ -0,0 +1,19 @@ +package org.opendaylight.yang.gen.v1.urn.ios.rev160516; + + +/** + * The purpose of generated class in src/main/java for Union types is to create new instances of unions from a string representation. + * In some cases it is very difficult to automate it since there can be unions such as (uint32 - uint16), or (string - uint32). + * + * The reason behind putting it under src/main/java is: + * This class is generated in form of a stub and needs to be finished by the user. This class is generated only once to prevent + * loss of user code. + * + */ +public class DscpTypeBuilder { + + public static DscpType getDefaultInstance(java.lang.String defaultValue) { + throw new java.lang.UnsupportedOperationException("Not yet implemented"); + } + +} diff --git a/renderers/ios-xe/src/main/java/org/opendaylight/yang/gen/v1/urn/ios/rev160516/ExpValueTypeBuilder.java b/renderers/ios-xe/src/main/java/org/opendaylight/yang/gen/v1/urn/ios/rev160516/ExpValueTypeBuilder.java new file mode 100644 index 000000000..aa546e8f3 --- /dev/null +++ b/renderers/ios-xe/src/main/java/org/opendaylight/yang/gen/v1/urn/ios/rev160516/ExpValueTypeBuilder.java @@ -0,0 +1,19 @@ +package org.opendaylight.yang.gen.v1.urn.ios.rev160516; + + +/** + * The purpose of generated class in src/main/java for Union types is to create new instances of unions from a string representation. + * In some cases it is very difficult to automate it since there can be unions such as (uint32 - uint16), or (string - uint32). + * + * The reason behind putting it under src/main/java is: + * This class is generated in form of a stub and needs to be finished by the user. This class is generated only once to prevent + * loss of user code. + * + */ +public class ExpValueTypeBuilder { + + public static ExpValueType getDefaultInstance(java.lang.String defaultValue) { + throw new java.lang.UnsupportedOperationException("Not yet implemented"); + } + +} diff --git a/renderers/ios-xe/src/main/java/org/opendaylight/yang/gen/v1/urn/ios/rev160516/PrecValueTypeBuilder.java b/renderers/ios-xe/src/main/java/org/opendaylight/yang/gen/v1/urn/ios/rev160516/PrecValueTypeBuilder.java new file mode 100644 index 000000000..d2abe68b8 --- /dev/null +++ b/renderers/ios-xe/src/main/java/org/opendaylight/yang/gen/v1/urn/ios/rev160516/PrecValueTypeBuilder.java @@ -0,0 +1,19 @@ +package org.opendaylight.yang.gen.v1.urn.ios.rev160516; + + +/** + * The purpose of generated class in src/main/java for Union types is to create new instances of unions from a string representation. + * In some cases it is very difficult to automate it since there can be unions such as (uint32 - uint16), or (string - uint32). + * + * The reason behind putting it under src/main/java is: + * This class is generated in form of a stub and needs to be finished by the user. This class is generated only once to prevent + * loss of user code. + * + */ +public class PrecValueTypeBuilder { + + public static PrecValueType getDefaultInstance(java.lang.String defaultValue) { + throw new java.lang.UnsupportedOperationException("Not yet implemented"); + } + +} diff --git a/renderers/ios-xe/src/main/java/org/opendaylight/yang/gen/v1/urn/ios/rev160516/PrecedenceType2Builder.java b/renderers/ios-xe/src/main/java/org/opendaylight/yang/gen/v1/urn/ios/rev160516/PrecedenceType2Builder.java new file mode 100644 index 000000000..abd065e90 --- /dev/null +++ b/renderers/ios-xe/src/main/java/org/opendaylight/yang/gen/v1/urn/ios/rev160516/PrecedenceType2Builder.java @@ -0,0 +1,19 @@ +package org.opendaylight.yang.gen.v1.urn.ios.rev160516; + + +/** + * The purpose of generated class in src/main/java for Union types is to create new instances of unions from a string representation. + * In some cases it is very difficult to automate it since there can be unions such as (uint32 - uint16), or (string - uint32). + * + * The reason behind putting it under src/main/java is: + * This class is generated in form of a stub and needs to be finished by the user. This class is generated only once to prevent + * loss of user code. + * + */ +public class PrecedenceType2Builder { + + public static PrecedenceType2 getDefaultInstance(java.lang.String defaultValue) { + throw new java.lang.UnsupportedOperationException("Not yet implemented"); + } + +} diff --git a/renderers/ios-xe/src/main/java/org/opendaylight/yang/gen/v1/urn/ios/rev160516/PrecedenceTypeBuilder.java b/renderers/ios-xe/src/main/java/org/opendaylight/yang/gen/v1/urn/ios/rev160516/PrecedenceTypeBuilder.java new file mode 100644 index 000000000..d05b82e45 --- /dev/null +++ b/renderers/ios-xe/src/main/java/org/opendaylight/yang/gen/v1/urn/ios/rev160516/PrecedenceTypeBuilder.java @@ -0,0 +1,19 @@ +package org.opendaylight.yang.gen.v1.urn.ios.rev160516; + + +/** + * The purpose of generated class in src/main/java for Union types is to create new instances of unions from a string representation. + * In some cases it is very difficult to automate it since there can be unions such as (uint32 - uint16), or (string - uint32). + * + * The reason behind putting it under src/main/java is: + * This class is generated in form of a stub and needs to be finished by the user. This class is generated only once to prevent + * loss of user code. + * + */ +public class PrecedenceTypeBuilder { + + public static PrecedenceType getDefaultInstance(java.lang.String defaultValue) { + throw new java.lang.UnsupportedOperationException("Not yet implemented"); + } + +} diff --git a/renderers/ios-xe/src/main/java/org/opendaylight/yang/gen/v1/urn/ios/rev160516/QosValueTypeBuilder.java b/renderers/ios-xe/src/main/java/org/opendaylight/yang/gen/v1/urn/ios/rev160516/QosValueTypeBuilder.java new file mode 100644 index 000000000..00742237a --- /dev/null +++ b/renderers/ios-xe/src/main/java/org/opendaylight/yang/gen/v1/urn/ios/rev160516/QosValueTypeBuilder.java @@ -0,0 +1,19 @@ +package org.opendaylight.yang.gen.v1.urn.ios.rev160516; + + +/** + * The purpose of generated class in src/main/java for Union types is to create new instances of unions from a string representation. + * In some cases it is very difficult to automate it since there can be unions such as (uint32 - uint16), or (string - uint32). + * + * The reason behind putting it under src/main/java is: + * This class is generated in form of a stub and needs to be finished by the user. This class is generated only once to prevent + * loss of user code. + * + */ +public class QosValueTypeBuilder { + + public static QosValueType getDefaultInstance(java.lang.String defaultValue) { + throw new java.lang.UnsupportedOperationException("Not yet implemented"); + } + +} diff --git a/renderers/ios-xe/src/main/java/org/opendaylight/yang/gen/v1/urn/ios/rev160516/_native/mls/qos/MapPolicedDscpBuilder.java b/renderers/ios-xe/src/main/java/org/opendaylight/yang/gen/v1/urn/ios/rev160516/_native/mls/qos/MapPolicedDscpBuilder.java new file mode 100644 index 000000000..14a15a39f --- /dev/null +++ b/renderers/ios-xe/src/main/java/org/opendaylight/yang/gen/v1/urn/ios/rev160516/_native/mls/qos/MapPolicedDscpBuilder.java @@ -0,0 +1,20 @@ +package org.opendaylight.yang.gen.v1.urn.ios.rev160516._native.mls.qos; +import org.opendaylight.yang.gen.v1.urn.ios.rev160516._native.mls.qos.Map.PolicedDscp; + + +/** + * The purpose of generated class in src/main/java for Union types is to create new instances of unions from a string representation. + * In some cases it is very difficult to automate it since there can be unions such as (uint32 - uint16), or (string - uint32). + * + * The reason behind putting it under src/main/java is: + * This class is generated in form of a stub and needs to be finished by the user. This class is generated only once to prevent + * loss of user code. + * + */ +public class MapPolicedDscpBuilder { + + public static PolicedDscp getDefaultInstance(java.lang.String defaultValue) { + throw new java.lang.UnsupportedOperationException("Not yet implemented"); + } + +} diff --git a/renderers/ios-xe/src/main/java/org/opendaylight/yang/gen/v1/urn/ios/rev160516/_native/policy/map/_class/pm/policy/monitor/metric/rtp/ClockRateNumberBuilder.java b/renderers/ios-xe/src/main/java/org/opendaylight/yang/gen/v1/urn/ios/rev160516/_native/policy/map/_class/pm/policy/monitor/metric/rtp/ClockRateNumberBuilder.java new file mode 100644 index 000000000..4d95f491d --- /dev/null +++ b/renderers/ios-xe/src/main/java/org/opendaylight/yang/gen/v1/urn/ios/rev160516/_native/policy/map/_class/pm/policy/monitor/metric/rtp/ClockRateNumberBuilder.java @@ -0,0 +1,20 @@ +package org.opendaylight.yang.gen.v1.urn.ios.rev160516._native.policy.map._class.pm.policy.monitor.metric.rtp; +import org.opendaylight.yang.gen.v1.urn.ios.rev160516._native.policy.map._class.pm.policy.monitor.metric.rtp.ClockRate.Number; + + +/** + * The purpose of generated class in src/main/java for Union types is to create new instances of unions from a string representation. + * In some cases it is very difficult to automate it since there can be unions such as (uint32 - uint16), or (string - uint32). + * + * The reason behind putting it under src/main/java is: + * This class is generated in form of a stub and needs to be finished by the user. This class is generated only once to prevent + * loss of user code. + * + */ +public class ClockRateNumberBuilder { + + public static Number getDefaultInstance(java.lang.String defaultValue) { + throw new java.lang.UnsupportedOperationException("Not yet implemented"); + } + +} diff --git a/renderers/ios-xe/src/main/yang/ios-xe-provider-impl.yang b/renderers/ios-xe/src/main/yang/ios-xe-provider-impl.yang new file mode 100755 index 000000000..a02fc456d --- /dev/null +++ b/renderers/ios-xe/src/main/yang/ios-xe-provider-impl.yang @@ -0,0 +1,68 @@ +/* + * Copyright (c) 2016 Cisco Systems, Inc. and others. 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 + */ + +module ios-xe-provider-impl { + yang-version 1; + namespace "urn:opendaylight:params:xml:ns:yang:groupbasedpolicy:renderer:ios-xe-provider:impl:config"; + prefix "ios-xe-provider-impl"; + + import config { prefix config; revision-date 2013-04-05; } + import opendaylight-md-sal-binding { prefix mdsal; revision-date 2013-10-28; } + import ietf-yang-types { prefix "yang"; revision-date 2010-09-24; } + import opendaylight-sal-binding-broker-impl { prefix sal-broker; revision-date 2013-10-28;} + import groupbasedpolicy-cfg { prefix gbpcfg; revision-date 2015-11-06; } + + description + "This module contains the base YANG definitions for + ios-xe-provider impl implementation."; + + revision "2016-05-17" { + description + "Initial revision."; + } + + identity ios-xe-provider-impl { + base "config:module-type"; + config:java-name-prefix IosXeProvider; + } + + // Augments the 'configuration' choice node under modules/module. + augment "/config:modules/config:module/config:configuration" { + case ios-xe-provider-impl { + when "/config:modules/config:module/config:type = 'ios-xe-provider-impl'"; + + // Wires in the data-broker service + container data-broker { + uses config:service-ref { + refine type { + mandatory true; + config:required-identity mdsal:binding-async-data-broker; + } + } + } + // binding aware broker + container broker { + uses config:service-ref { + refine type { + mandatory true; + config:required-identity mdsal:binding-broker-osgi-registry; + } + } + } + // PolicyProviderRegistry service + container policy-validator-registry { + uses config:service-ref { + refine type { + mandatory true; + config:required-identity gbpcfg:policy-validator-registry; + } + } + } + } + } +} diff --git a/renderers/ios-xe/src/main/yang/ios-xe-provider.yang b/renderers/ios-xe/src/main/yang/ios-xe-provider.yang new file mode 100644 index 000000000..5a8718d93 --- /dev/null +++ b/renderers/ios-xe/src/main/yang/ios-xe-provider.yang @@ -0,0 +1,29 @@ +/* + * Copyright (c) 2016 Cisco Systems, Inc. and others. 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 + */ + +module ios-xe-provider { + yang-version 1; + namespace "urn:opendaylight:params:xml:ns:yang:groupbasedpolicy:renderer:ios-xe-provider:config"; + prefix "ios-xe-provider"; + + import config { prefix config; revision-date 2013-04-05; } + + description + "This module contains the base YANG definitions for + ios-xe-provider services."; + + revision "2016-05-17" { + description + "Initial revision."; + } + + identity ios-xe-provider { + base "config:service-type"; + config:java-class "org.opendaylight.groupbasedpolicy.renderer.ios_xe_provider.api.IosXeRendererProvider"; + } +} diff --git a/renderers/ios-xe/src/main/yang/netconf/ietf-inet-types.yang b/renderers/ios-xe/src/main/yang/netconf/ietf-inet-types.yang new file mode 100644 index 000000000..5624a9548 --- /dev/null +++ b/renderers/ios-xe/src/main/yang/netconf/ietf-inet-types.yang @@ -0,0 +1,461 @@ +module ietf-inet-types { + + namespace "urn:ietf:params:xml:ns:yang:ietf-inet-types"; + prefix "inet"; + + organization + "IETF NETMOD (NETCONF Data Modeling Language) Working Group"; + + contact + "WG Web: + WG List: + + WG Chair: David Kessens + + + WG Chair: Juergen Schoenwaelder + + + Editor: Juergen Schoenwaelder + "; + + description + "This module contains a collection of generally useful derived + YANG data types for Internet addresses and related things. + + Copyright (c) 2013 IETF Trust and the persons identified as + authors of the code. All rights reserved. + + Redistribution and use in source and binary forms, with or + without modification, is permitted pursuant to, and subject + to the license terms contained in, the Simplified BSD License + set forth in Section 4.c of the IETF Trust's Legal Provisions + Relating to IETF Documents + (http://trustee.ietf.org/license-info). + + This version of this YANG module is part of RFC 6991; see + the RFC itself for full legal notices."; + + revision 2013-07-15 { + description + "This revision adds the following new data types: + - ip-address-no-zone + - ipv4-address-no-zone + - ipv6-address-no-zone"; + reference + "RFC 6991: Common YANG Data Types"; + } + + revision 2010-09-24 { + description + "Initial revision."; + reference + "RFC 6021: Common YANG Data Types"; + } + + /*** collection of types related to protocol fields ***/ + + typedef ip-version { + type enumeration { + enum unknown { + value "0"; + description + "An unknown or unspecified version of the Internet + protocol."; + } + enum ipv4 { + value "1"; + description + "The IPv4 protocol as defined in RFC 791."; + } + enum ipv6 { + value "2"; + description + "The IPv6 protocol as defined in RFC 2460."; + } + } + description + "This value represents the version of the IP protocol. + + In the value set and its semantics, this type is equivalent + to the InetVersion textual convention of the SMIv2."; + reference + "RFC 791: Internet Protocol + RFC 2460: Internet Protocol, Version 6 (IPv6) Specification + RFC 4001: Textual Conventions for Internet Network Addresses"; + } + + typedef dscp { + type uint8 { + range "0..63"; + } + description + "The dscp type represents a Differentiated Services Code Point + that may be used for marking packets in a traffic stream. + In the value set and its semantics, this type is equivalent + to the Dscp textual convention of the SMIv2."; + reference + "RFC 3289: Management Information Base for the Differentiated + Services Architecture + RFC 2474: Definition of the Differentiated Services Field + (DS Field) in the IPv4 and IPv6 Headers + RFC 2780: IANA Allocation Guidelines For Values In + the Internet Protocol and Related Headers"; + } + + typedef ipv6-flow-label { + type uint32 { + range "0..1048575"; + } + description + "The ipv6-flow-label type represents the flow identifier or Flow + Label in an IPv6 packet header that may be used to + discriminate traffic flows. + + In the value set and its semantics, this type is equivalent + to the IPv6FlowLabel textual convention of the SMIv2."; + reference + "RFC 3595: Textual Conventions for IPv6 Flow Label + RFC 2460: Internet Protocol, Version 6 (IPv6) Specification"; + } + + typedef port-number { + type uint16 { + range "0..65535"; + } + description + "The port-number type represents a 16-bit port number of an + Internet transport-layer protocol such as UDP, TCP, DCCP, or + SCTP. Port numbers are assigned by IANA. A current list of + all assignments is available from . + + Note that the port number value zero is reserved by IANA. In + situations where the value zero does not make sense, it can + be excluded by subtyping the port-number type. + In the value set and its semantics, this type is equivalent + to the InetPortNumber textual convention of the SMIv2."; + reference + "RFC 768: User Datagram Protocol + RFC 793: Transmission Control Protocol + RFC 4960: Stream Control Transmission Protocol + RFC 4340: Datagram Congestion Control Protocol (DCCP) + RFC 4001: Textual Conventions for Internet Network Addresses"; + } + + /*** collection of types related to autonomous systems ***/ + + typedef as-number { + type uint32; + description + "The as-number type represents autonomous system numbers + which identify an Autonomous System (AS). An AS is a set + of routers under a single technical administration, using + an interior gateway protocol and common metrics to route + packets within the AS, and using an exterior gateway + protocol to route packets to other ASes. IANA maintains + the AS number space and has delegated large parts to the + regional registries. + + Autonomous system numbers were originally limited to 16 + bits. BGP extensions have enlarged the autonomous system + number space to 32 bits. This type therefore uses an uint32 + base type without a range restriction in order to support + a larger autonomous system number space. + + In the value set and its semantics, this type is equivalent + to the InetAutonomousSystemNumber textual convention of + the SMIv2."; + reference + "RFC 1930: Guidelines for creation, selection, and registration + of an Autonomous System (AS) + RFC 4271: A Border Gateway Protocol 4 (BGP-4) + RFC 4001: Textual Conventions for Internet Network Addresses + RFC 6793: BGP Support for Four-Octet Autonomous System (AS) + Number Space"; + } + + /*** collection of types related to IP addresses and hostnames ***/ + + typedef ip-address { + type union { + type inet:ipv4-address; + type inet:ipv6-address; + } + description + "The ip-address type represents an IP address and is IP + version neutral. The format of the textual representation + implies the IP version. This type supports scoped addresses + by allowing zone identifiers in the address format."; + reference + "RFC 4007: IPv6 Scoped Address Architecture"; + } + + typedef ipv4-address { + 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])' + + '(%[\p{N}\p{L}]+)?'; + } + description + "The ipv4-address type represents an IPv4 address in + dotted-quad notation. The IPv4 address may include a zone + index, separated by a % sign. + + The zone index is used to disambiguate identical address + values. For link-local addresses, the zone index will + typically be the interface index number or the name of an + interface. If the zone index is not present, the default + zone of the device will be used. + + The canonical format for the zone index is the numerical + format"; + } + + typedef ipv6-address { + 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])))' + + '(%[\p{N}\p{L}]+)?'; + pattern '(([^:]+:){6}(([^:]+:[^:]+)|(.*\..*)))|' + + '((([^:]+:)*[^:]+)?::(([^:]+:)*[^:]+)?)' + + '(%.+)?'; + } + description + "The ipv6-address type represents an IPv6 address in full, + mixed, shortened, and shortened-mixed notation. The IPv6 + address may include a zone index, separated by a % sign. + + The zone index is used to disambiguate identical address + values. For link-local addresses, the zone index will + typically be the interface index number or the name of an + interface. If the zone index is not present, the default + zone of the device will be used. + + + + The canonical format of IPv6 addresses uses the textual + representation defined in Section 4 of RFC 5952. The + canonical format for the zone index is the numerical + format as described in Section 11.2 of RFC 4007."; + reference + "RFC 4291: IP Version 6 Addressing Architecture + RFC 4007: IPv6 Scoped Address Architecture + RFC 5952: A Recommendation for IPv6 Address Text + Representation"; + } + + typedef ip-address-no-zone { + type union { + type inet:ipv4-address-no-zone; + type inet:ipv6-address-no-zone; + } + description + "The ip-address-no-zone type represents an IP address and is + IP version neutral. The format of the textual representation + implies the IP version. This type does not support scoped + addresses since it does not allow zone identifiers in the + address format."; + reference + "RFC 4007: IPv6 Scoped Address Architecture"; + } + + typedef ipv4-address-no-zone { + type inet:ipv4-address { + pattern '[0-9\.]*'; + } + description + "An IPv4 address without a zone index. This type, derived from + ipv4-address, may be used in situations where the zone is + known from the context and hence no zone index is needed."; + } + + typedef ipv6-address-no-zone { + type inet:ipv6-address { + pattern '[0-9a-fA-F:\.]*'; + } + description + "An IPv6 address without a zone index. This type, derived from + ipv6-address, may be used in situations where the zone is + known from the context and hence no zone index is needed."; + reference + "RFC 4291: IP Version 6 Addressing Architecture + RFC 4007: IPv6 Scoped Address Architecture + RFC 5952: A Recommendation for IPv6 Address Text + Representation"; + } + + typedef ip-prefix { + type union { + type inet:ipv4-prefix; + type inet:ipv6-prefix; + } + description + "The ip-prefix type represents an IP prefix and is IP + version neutral. The format of the textual representations + implies the IP version."; + } + + typedef ipv4-prefix { + 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-prefix type represents an IPv4 address prefix. + The prefix length is given by the number following the + slash character and must be less than or equal to 32. + + A prefix length value of n corresponds to an IP address + mask that has n contiguous 1-bits from the most + significant bit (MSB) and all other bits set to 0. + + The canonical format of an IPv4 prefix has all bits of + the IPv4 address set to zero that are not part of the + IPv4 prefix."; + } + + typedef ipv6-prefix { + 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-prefix type represents an IPv6 address prefix. + The prefix length is given by the number following the + slash character and must be less than or equal to 128. + + A prefix length value of n corresponds to an IP address + mask that has n contiguous 1-bits from the most + significant bit (MSB) and all other bits set to 0. + + The IPv6 address should have all bits that do not belong + to the prefix set to zero. + + The canonical format of an IPv6 prefix has all bits of + the IPv6 address set to zero that are not part of the + IPv6 prefix. Furthermore, the IPv6 address is represented + as defined in Section 4 of RFC 5952."; + reference + "RFC 5952: A Recommendation for IPv6 Address Text + Representation"; + } + + /*** collection of domain name and URI types ***/ + + typedef domain-name { + type string { + pattern + '((([a-zA-Z0-9_]([a-zA-Z0-9\-_]){0,61})?[a-zA-Z0-9]\.)*' + + '([a-zA-Z0-9_]([a-zA-Z0-9\-_]){0,61})?[a-zA-Z0-9]\.?)' + + '|\.'; + length "1..253"; + } + description + "The domain-name type represents a DNS domain name. The + name SHOULD be fully qualified whenever possible. + + Internet domain names are only loosely specified. Section + 3.5 of RFC 1034 recommends a syntax (modified in Section + 2.1 of RFC 1123). The pattern above is intended to allow + for current practice in domain name use, and some possible + future expansion. It is designed to hold various types of + domain names, including names used for A or AAAA records + (host names) and other records, such as SRV records. Note + that Internet host names have a stricter syntax (described + in RFC 952) than the DNS recommendations in RFCs 1034 and + 1123, and that systems that want to store host names in + schema nodes using the domain-name type are recommended to + adhere to this stricter standard to ensure interoperability. + + The encoding of DNS names in the DNS protocol is limited + to 255 characters. Since the encoding consists of labels + prefixed by a length bytes and there is a trailing NULL + byte, only 253 characters can appear in the textual dotted + notation. + + The description clause of schema nodes using the domain-name + type MUST describe when and how these names are resolved to + IP addresses. Note that the resolution of a domain-name value + may require to query multiple DNS records (e.g., A for IPv4 + and AAAA for IPv6). The order of the resolution process and + which DNS record takes precedence can either be defined + explicitly or may depend on the configuration of the + resolver. + + Domain-name values use the US-ASCII encoding. Their canonical + format uses lowercase US-ASCII characters. Internationalized + domain names MUST be A-labels as per RFC 5890."; + reference + "RFC 952: DoD Internet Host Table Specification + RFC 1034: Domain Names - Concepts and Facilities + RFC 1123: Requirements for Internet Hosts -- Application + and Support + RFC 2782: A DNS RR for specifying the location of services + (DNS SRV) + RFC 5890: Internationalized Domain Names in Applications + (IDNA): Definitions and Document Framework"; + } + + typedef host { + type union { + type inet:ip-address; + type inet:domain-name; + } + description + "The host type represents either an IP address or a DNS + domain name."; + } + + typedef uri { + type string; + description + "The uri type represents a Uniform Resource Identifier + (URI) as defined by STD 66. + + Objects using the uri type MUST be in US-ASCII encoding, + and MUST be normalized as described by RFC 3986 Sections + 6.2.1, 6.2.2.1, and 6.2.2.2. All unnecessary + percent-encoding is removed, and all case-insensitive + characters are set to lowercase except for hexadecimal + digits, which are normalized to uppercase as described in + Section 6.2.2.1. + + The purpose of this normalization is to help provide + unique URIs. Note that this normalization is not + sufficient to provide uniqueness. Two URIs that are + textually distinct after this normalization may still be + equivalent. + + Objects using the uri type may restrict the schemes that + they permit. For example, 'data:' and 'urn:' schemes + might not be appropriate. + + A zero-length URI is not a valid URI. This can be used to + express 'URI absent' where required. + + In the value set and its semantics, this type is equivalent + to the Uri SMIv2 textual convention defined in RFC 5017."; + reference + "RFC 3986: Uniform Resource Identifier (URI): Generic Syntax + RFC 3305: Report from the Joint W3C/IETF URI Planning Interest + Group: Uniform Resource Identifiers (URIs), URLs, + and Uniform Resource Names (URNs): Clarifications + and Recommendations + RFC 5017: MIB Textual Conventions for Uniform Resource + Identifiers (URIs)"; + } + +} \ No newline at end of file diff --git a/renderers/ios-xe/src/main/yang/netconf/ned.yang b/renderers/ios-xe/src/main/yang/netconf/ned.yang new file mode 100644 index 000000000..5d73d609b --- /dev/null +++ b/renderers/ios-xe/src/main/yang/netconf/ned.yang @@ -0,0 +1,5844 @@ +module ned { + + prefix ios; + namespace + "urn:ios"; + + import tailf-common { + prefix tailf; + } + + import ietf-inet-types { + prefix inet; + revision-date 2013-07-15; + } + + import ietf-yang-types { + prefix yang; + } + + description + "This file was adapted to be parsed by yangtools for groupbasedpolicy project purpose"; + + revision + 2016-05-16; + +/// ======================================================================== +/// typedefs +/// ======================================================================== + + typedef class-name-type { + type union { + type string { + // Note: leafref can't be used here due to part of union. + //path "/ios:native/class-map/name"; + tailf:info "WORD;;class-map name"; + } + type enumeration { + enum class-default { + tailf:info "System default class matching otherwise "+ + "unclassified packet"; + } + } + } + } + + typedef cos_value-type { + type union { + type uint8 { + tailf:info "<0-7>;;new cos value"; + range "0..7"; + } + type enumeration { + enum cos { + tailf:info "Set packet cos from cos"; + } + enum dscp { + tailf:info "Set packet cos from dscp"; + } + enum exp { + tailf:info "Set packet cos from exp"; + } + enum precedence { + tailf:info "Set packet cos from precedence"; + } + } + } + } + + typedef dscp-type { + type union { + type uint8 { + tailf:info "<0-63>;;Differentiated services codepoint value"; + range "0..63"; + } + type enumeration { + enum af11 { + tailf:info "Match packets with AF11 dscp (001010)"; + value 10; + } + enum af12 { + tailf:info "Match packets with AF12 dscp (001100)"; + value 12; + } + enum af13 { + tailf:info "Match packets with AF13 dscp (001110)"; + value 14; + } + enum af21 { + tailf:info "Match packets with AF21 dscp (010010)"; + value 18; + } + enum af22 { + tailf:info "Match packets with AF22 dscp (010100)"; + value 20; + } + enum af23 { + tailf:info "Match packets with AF23 dscp (010110)"; + value 22; + } + enum af31 { + tailf:info "Match packets with AF31 dscp (011010)"; + value 26; + } + enum af32 { + tailf:info "Match packets with AF32 dscp (011100)"; + value 28; + } + enum af33 { + tailf:info "Match packets with AF33 dscp (011110)"; + value 30; + } + enum af41 { + tailf:info "Match packets with AF41 dscp (100010)"; + value 34; + } + enum af42 { + tailf:info "Match packets with AF42 dscp (100100)"; + value 36; + } + enum af43 { + tailf:info "Match packets with AF43 dscp (100110)"; + value 38; + } + enum cs1 { + tailf:info "Match packets with CS1(precedence 1) dscp" + + " (001000)"; + value 8; + } + enum cs2 { + tailf:info "Match packets with CS2(precedence 2) dscp" + + " (010000)"; + value 16; + } + enum cs3 { + tailf:info "Match packets with CS3(precedence 3) dscp" + + " (011000)"; + value 24; + } + enum cs4 { + tailf:info "Match packets with CS4(precedence 4) dscp" + + " (100000)"; + value 32; + } + enum cs5 { + tailf:info "Match packets with CS5(precedence 5) dscp" + + " (101000)"; + value 40; + } + enum cs6 { + tailf:info "Match packets with CS6(precedence 6) dscp" + + " (110000)"; + value 48; + } + enum cs7 { + tailf:info "Match packets with CS7(precedence 7) dscp" + + " (111000)"; + value 56; + } + enum "default" { + tailf:code-name "dscp_default"; + tailf:info "Match packets with default dscp (000000)"; + value 0; + } + enum dscp { + tailf:info "Set packet dscp from dscp"; + } + enum ef { + tailf:info "Match packets with EF dscp (101110)"; + value 46; + } + enum precedence { + tailf:info "Set packet dscp from precedence"; + } + } + } + } + + typedef exp_value-type { + type union { + type uint8 { + tailf:info "<0-7>;;new exp"; + range "0..7"; + } + type enumeration { + enum cos { + tailf:info "Set packet exp from cos"; + } + enum dscp { + tailf:info "Set packet exp from dscp"; + } + enum exp { + tailf:info "Set packet exp from exp"; + } + enum precedence { + tailf:info "Set packet exp from precedence"; + } + } + } + } + + typedef percentage-type { + type uint8 { + tailf:info "<1-100>;;Percentage"; + range "1..100"; + } + } + + typedef police-bps-type { + type uint64 { + tailf:info "<8000-64000000000>;;Bits per second"; + range "8000..64000000000"; + } + } + + typedef police-burst-type { + type uint32 { + tailf:info "<1000-512000000>;;Burst bytes"; + range "1000..512000000"; + } + } + + typedef police-packets-bytes-type { + type enumeration { + enum packets { + tailf:info "Treat 'burst' value as packets"; + } + enum bytes { + tailf:info "Treat 'burst' value as bytes"; + } + } + } + + typedef police-pps-bps-type { + type enumeration { + enum pps { + tailf:info "pps Treat 'rate' value in "+ + "packets-per-second"; + } + enum bps { + tailf:info "pps Treat 'rate' value in "+ + "bytes-per-second"; + } + } + } + + typedef policy-action-type { + type enumeration { + enum bandwidth { + tailf:code-name policy_bandwidth; + tailf:info "Bandwidth"; + } + enum compression { + tailf:info "Activate Compression"; + } + enum dbl { + tailf:info "Dynamic buffer limiting"; + } + enum drop { + tailf:info "Drop all packets"; + } + enum estimate { + tailf:info "Estimate resources required for this class"; + } + enum fair-queue { + tailf:info "Enable Flow-based Fair Queuing in this Class"; + } + enum forward { + tailf:info "Forward service-path action"; + } + enum netflow-sampler { + tailf:info "NetFlow action"; + } + enum police { + tailf:info "Police"; + } + enum priority { + tailf:code-name policy_priority; + tailf:info "Strict Scheduling Priority for this Class"; + } + enum queue-limit { + tailf:info "Queue Max Threshold for Tail Drop"; + } + enum random-detect { + tailf:info "Enable Random Early Detection as drop policy"; + } + enum service-policy { + tailf:info "Configure Flow Next"; + } + enum set { + tailf:info "Set QoS values"; + } + enum shape { + tailf:code-name policy_shape; + tailf:info "Traffic Shaping"; + } + enum trust { + tailf:info "Set trust value for the class"; + } + enum queue-buffers { + tailf:info "queue buffer"; + } + } + } + + typedef prec_value-type { + type union { + type uint8 { + tailf:info "<0-7>;;new precedence"; + range "0..7"; + } + type enumeration { + enum cos { + tailf:info "Set packet precedence from cos"; + } + enum dscp { + tailf:info "Set packet precedence from dscp"; + } + enum exp { + tailf:info "Set packet precedence from exp"; + } + enum precedence { + tailf:info "Set packet precedence from precedence"; + } + } + } + } + + typedef precedence-type { + type union { + type uint8 { + tailf:info "<0-7>;;Precedence value"; + range "0..7"; + } + type enumeration { + enum critical { + tailf:info "Set packets with critical precedence (5)"; + } + enum flash { + tailf:info "Set packets with flash precedence (3)"; + } + enum flash-override { + tailf:info "Set packets with flash override precedence (4)"; + } + enum immediate { + tailf:info "Set packets with immediate precedence (2)"; + } + enum internet { + tailf:code-name "prec_internet"; + tailf:info "Set packets with internetwork control"+ + " precedence (6)"; + } + enum network { + tailf:info "Set packets with network control precedence"+ + " (7)"; + } + enum priority { + tailf:code-name "prec_priority"; + tailf:info "Set packets with priority precedence (1)"; + } + enum routine { + tailf:info "Set packets with routine precedence (0)"; + } + } + } + } + + typedef precedence-type2 { + type union { + type uint8 { + tailf:info "<0-7>;;IP precedence"; + range "0..7"; + } + type enumeration { + enum rsvp { + tailf:code-name "prec_rsvp"; + tailf:info "rsvp traffic"; + } + } + } + } + + typedef qos_value-type { + type union { + type uint8 { + tailf:info "<0-99>;;new qos-group"; + range "0..99"; + } + type enumeration { + enum cos { + tailf:info "Set packet qos from cos"; + } + enum dscp { + tailf:info "Set packet qos from dscp"; + } + enum exp { + tailf:info "Set packet qos from exp"; + } + enum precedence { + tailf:info "Set packet qos from precedence"; + } + } + } + } + +/// ======================================================================== +/// groupings +/// ======================================================================== + + grouping class-map-appnav-not-match-grouping { + // class-map * / peer + leaf peer { + when "../../../type = 'appnav'"; + tailf:info "APPNAV Peer Filter"; + description "APPNAV Peer Filter"; + type string { + tailf:info "H.H.H;;Device ID"; + } + } + } + + grouping class-map-appnav-match-grouping { + // class-map * / peer + leaf peer { + when "../../type = 'appnav'"; + tailf:info "APPNAV Peer Filter"; + description "APPNAV Peer Filter"; + type string { + tailf:info "H.H.H;;Device ID"; + } + } + } + + grouping class-map-match-grouping { + // class-map * / match application + container application { + tailf:info "Application to match"; + description "Application to match"; + container application-group { + tailf:info "Application Group to match"; + description "Application Group to match"; + leaf telepresence-group { + tailf:info "Telepresence Group"; + description "Telepresence Group"; + tailf:cli-full-command; + type empty; + } + leaf vmware-group { + tailf:info "VMWARE Group"; + description "VMWARE Group"; + tailf:cli-full-command; + type empty; + } + leaf webex-group { + tailf:info "WebEx Group"; + description "WebEx Group"; + tailf:cli-full-command; + type empty; + } + } + container attribute { + tailf:info "Application attribute to match"; + description "Application attribute to match"; + leaf media-type { + tailf:info "Media type attribute to match"; + description "Media type attribute to match"; + type enumeration { + enum audio { + tailf:info "Audio"; + } + enum audio-video { + tailf:info "Audio Video"; + } + enum control { + tailf:info "Control"; + } + enum data { + tailf:info "Data"; + } + enum video { + tailf:info "Video"; + } + } + } + } + } + // class-map * / match access-group + container access-group { + tailf:info "Access group"; + description "Access group"; + leaf index { + tailf:cli-drop-node-name; + type uint32 { + range "1..2699" { + tailf:info "<1-2699>;;Access list index"; + } + } + } + leaf-list name { + tailf:info "Named Access List"; + description "Named Access List"; + tailf:cli-list-syntax; + type string { + tailf:info "WORD;;Access List name"; + } + } + } + // class-map * / match any + leaf any { + tailf:info "Any packets"; + description "Any packets"; + type empty; + } + // class-map * / match class-map + leaf-list class-map { + tailf:info "Class map"; + description "Class map"; + tailf:cli-list-syntax; + type leafref { + path "/ios:native/class-map/name"; + // tailf:info "WORD;;Match class-map name"; + } + } + // class-map * / match cos + leaf-list cos { + tailf:info "IEEE 802.1Q/ISL class of service/user priority values"; + description "IEEE 802.1Q/ISL class of service/user priority values"; + tailf:cli-flat-list-syntax; + type uint8 { + range "0..7"; + tailf:info "<0-7>;;Enter up to 4 class-of-service values"+ + " separated by white-spaces"; + } + } + // class-map * / match destination-address + container destination-address { + tailf:info "Destination address"; + description "Destination address"; + leaf-list mac { + tailf:info "MAC address"; + description "MAC address"; + tailf:cli-list-syntax; + type yang:mac-address { + tailf:info "H.H.H;;MAC address"; + } + } + } + // class-map * / discard-class + leaf-list discard-class { + tailf:info "Discard behavior identifier"; + description "Discard behavior identifier"; + tailf:cli-list-syntax; + type uint8 { + range "0..7"; + tailf:info "<0-7>;;Discard Class value"; + } + } + // class-map * / dscp + leaf-list dscp { + tailf:info "Match DSCP in IP(v4) and IPv6 packets"; + description "Match DSCP in IP(v4) and IPv6 packets"; + tailf:cli-flat-list-syntax; + tailf:cli-list-syntax; + type dscp-type; + } + // class-map * / fr-de + leaf fr-de { + tailf:info "Match on Frame-relay DE bit"; + description "Match on Frame-relay DE bit"; + type empty; + } + // class-map * / fr-dlci + leaf-list fr-dlci { + tailf:info "Match on fr-dlci"; + description "Match on fr-dlci"; + tailf:cli-list-syntax; + type uint16 { + range "16..1007"; + tailf:info "<16-1007>;;frame-relay dlci number"; + } + } + // class-map * / input-interface + leaf-list input-interface { + tailf:info "Select an input interface to match"; + description "Select an input interface to match"; + tailf:cli-list-syntax; + //FIXME: interface dependency + type string; + } + // class-map * / ip + container ip { + tailf:info "IP specific values"; + description "IP specific values"; + // class-map * / ip dscp + leaf-list dscp { + tailf:info "Match IP DSCP (DiffServ CodePoints)"; + description "Match IP DSCP (DiffServ CodePoints)"; + tailf:cli-flat-list-syntax; + tailf:cli-list-syntax; + type dscp-type; + } + // class-map * / ip precedence + leaf-list precedence { + tailf:info "Match IP precedence"; + description "Match IP precedence"; + tailf:cli-flat-list-syntax; + type precedence-type; + } + // class-map * / ip rtp + list rtp { + tailf:info "Match RTP port nos"; + description "Match RTP port nos"; + key "port1 port2"; + leaf port1 { + type uint16 { + range "2000..65535"; + tailf:info "<2000-65535>;;Lower bound of UDP"+ + " destination port"; + } + } + leaf port2 { + type uint16 { + range "0..16383"; + tailf:info "<0-16383>;;Range of UDP ports"; + } + } + } + } + // class-map * / non-client-nrt + leaf non-client-nrt { + tailf:cli-full-command; + type empty; + } + // class-map * / mpls + container mpls { + tailf:info "Multi Protocol Label Switching specific values"; + description "Multi Protocol Label Switching specific values"; + container experimental { + tailf:info "Match MPLS experimental"; + description "Match MPLS experimental"; + leaf-list topmost { + tailf:info "Match MPLS experimental value on topmost label"; + description "Match MPLS experimental value on topmost label"; + tailf:cli-flat-list-syntax; + type uint8 { + range "0..7"; + tailf:info "<0-7>;;Enter up to 8 experimental values "+ + "separated by white-spaces"; + } + } + } + } + // class-map * / packet + container packet { + tailf:info "Layer 3 Packet length"; + description "Layer 3 Packet length"; + container "length" { + tailf:info "Layer 3 Packet length"; + description "Layer 3 Packet length"; + leaf max { + tailf:info "Maximum length of packet"; + description "Maximum length of packet"; + type uint16 { + range "1..2000"; + tailf:info "<1-2000>;;Packet length in bytes"; + } + } + leaf min { + tailf:info "Minimum length of packet"; + description "Minimum length of packet"; + type uint16 { + range "1..2000"; + tailf:info "<1-2000>;;Packet length in bytes"; + } + } + } + } + // class-map * / precedence + leaf-list precedence { + tailf:info "Match Precedence in IP(v4) and IPv6 packets"; + description "Match Precedence in IP(v4) and IPv6 packets"; + tailf:cli-flat-list-syntax; + type precedence-type; + } + // class-map * / protocol + container protocol { + tailf:info "Protocol"; + description "Protocol"; + leaf protocols { + tailf:cli-drop-node-name; + type enumeration { + enum x802-11-iapp { + tailf:info "IEEE 802.11 WLANs WG IAPP"; + } + enum ace-svr { + tailf:info "ACE Server/Propagation"; + } + enum aol { + tailf:info "America-Online Instant Messenger"; + } + enum appleqtc { + tailf:info "Apple QuickTime"; + } + enum biff { + tailf:info "Bliff mail notification"; + } + enum bittorrent { + tailf:info "bittorrent"; + } + enum bootpc { + tailf:info "Bootstrap Protocol Client"; + } + enum bootps { + tailf:info "Bootstrap Protocol Server"; + } + enum cddbp { + tailf:info "CD Database Protocol"; + } + enum cifs { + tailf:info "CIFS"; + } + enum cisco-fna { + tailf:info "Cisco FNATIVE"; + } + enum cisco-net-mgmt { + tailf:info "cisco-net-mgmt"; + } + enum cisco-svcs { + tailf:info "cisco license/perf/GDP/X.25/ident svcs"; + } + enum cisco-sys { + tailf:info "Cisco SYSMAINT"; + } + enum cisco-tdp { + tailf:info "Cisco TDP"; + } + enum cisco-tna { + tailf:info "Cisco TNATIVE"; + } + enum citriximaclient { + tailf:info "Citrix IMA Client"; + } + enum clp { + tailf:info "Cisco Line Protocol"; + } + enum creativepartnr { + tailf:info "Creative Partnr"; + } + enum creativeserver { + tailf:info "Creative Server"; + } + enum daytime { + tailf:info "Daytime (RFC 867)"; + } + enum dbase { + tailf:info "dBASE Unix"; + } + enum dbcontrol_agent { + tailf:info "Oracle dbControl Agent po"; + } + enum ddns-v3 { + tailf:info "Dynamic DNS Version 3"; + } + enum dhcp-failover { + tailf:info "DHCP Failover"; + } + enum directconnect { + tailf:info "Direct Connect Version 2.0"; + } + enum discard { + tailf:info "Discard port"; + } + enum dnsix { + tailf:info "DNSIX Securit Attribute Token Map"; + } + enum echo { + tailf:info "Echo port"; + } + enum entrust-svc-hdlr { + tailf:info "Entrust KM/Admin Service Handler"; + } + enum entrust-svcs { + tailf:info "Entrust sps/aaas/aams"; + } + enum exec { + tailf:info "Remote Process Execution"; + } + enum fcip-port { + tailf:info "FCIP"; + } + enum ftps { + tailf:info "FTP over TLS/SSL"; + } + enum gdoi { + tailf:info "GDOI"; + } + enum giop { + tailf:info "Oracle GIOP/SSL"; + } + enum gtpv0 { + tailf:info "GPRS Tunneling Protocol Version 0"; + } + enum gtpv1 { + tailf:info "GPRS Tunneling Protocol Version 1"; + } + enum h225ras { + tailf:info "H225 RAS over Unicast"; + } + enum h323callsigalt { + tailf:info "h323 Call Signal Alternate"; + } + enum hp-alarm-mgr { + tailf:info "HP Performance data alarm manager"; + } + enum hp-collector { + tailf:info "HP Performance data collector"; + } + enum hp-managed-node { + tailf:info "HP Performance data managed node"; + } + enum hsrp { + tailf:info "Hot Standby Router Protocol"; + } + enum https { + tailf:info "Secure Hypertext Transfer Protocol"; + } + enum ica { + tailf:info "ica (Citrix)"; + } + enum icabrowser { + tailf:info "icabrowser (Citrix)"; + } + enum ident { + tailf:info "Authentication Service"; + } + enum igmpv3lite { + tailf:info "IGMP over UDP for SSM"; + } + enum imap3 { + tailf:info "Interactive Mail Access Protocol 3"; + } + enum imaps { + tailf:info "IMAP over TLS/SSL"; + } + enum ipass { + tailf:info "IPASS"; + } + enum ipsec-msft { + tailf:info "Microsoft IPsec NAT-T"; + } + enum irc-serv { + tailf:info "IRC-SERV"; + } + enum ircs { + tailf:info "IRC over TLS/SSL"; + } + enum ircu { + tailf:info "IRCU"; + } + enum isakmp { + tailf:info "ISAKMP"; + } + enum iscsi { + tailf:info "iSCSI"; + } + enum iscsi-target { + tailf:info "iSCSI port"; + } + enum kermit { + tailf:info "kermit"; + } + enum ldap-admin { + tailf:info "LDAP admin server port"; + } + enum ldaps { + tailf:info "LDAP over TLS/SSL"; + } + enum login { + tailf:info "Remote login"; + } + enum lotusmtap { + tailf:info "Lotus Mail Tracking Agent Protocol"; + } + enum lotusnote { + tailf:info "Lotus Note"; + } + // AppNav match protocol + enum mapi { + tailf:info "MAPI"; + } + enum ms-ad-rep { + tailf:info "MS-AD-REP"; + } + enum ms-exch-nspi { + tailf:info "MS-EXCH-NSPI"; + } + enum ms-frs { + tailf:info "MS-FRS"; + } + enum ms-frsapi { + tailf:info "MS-FRSAPI"; + } + enum ms-rfr { + tailf:info "MS-RFR"; + } + //ms-sql MS-SQL + enum msn-messenger { + tailf:info "MSN-MESSENGER"; + } + enum netlogon { + tailf:info "NETLOGON"; + } + enum microsoft-ds { + tailf:info "Microsoft-DS"; + } + enum ms-cluster-net { + tailf:info "MS Cluster Net"; + } + enum ms-dotnetster { + tailf:info "Microsoft .NETster Port"; + } + enum ms-sna { + tailf:info "Microsoft SNA Server/Base"; + } + enum ms-sql { + tailf:info "Microsoft SQL"; + } + enum ms-sql-m { + tailf:info "Microsoft SQL Monitor"; + } + enum msexch-routing { + tailf:info "Microsoft Exchange Routing"; + } + enum msnmsgr { + tailf:info "MSN Instant Messenger"; + } + enum msrpc { + tailf:info "Microsoft Remote Procedure Call"; + } + enum mysql { + tailf:info "MySQL"; + } + enum n2h2server { + tailf:info "N2H2 Filter Service Port"; + } + enum ncp { + tailf:info "NCP (Novell)"; + } + enum net8-cman { + tailf:info "Oracle Net8 Cman/Admin"; + } + enum netbios-dgm { + tailf:info "NETBIOS Datagram Service"; + } + enum netbios-ns { + tailf:info "NETBIOS Name Service"; + } + enum netbios-ssn { + tailf:info "NETBIOS Session Service"; + } + enum netstat { + tailf:info "Variant of systat"; + } + enum oem-agent { + tailf:info "OEM Agent (Oracle)"; + } + enum oracle { + tailf:info "Oracle"; + } + enum oracle-em-vp { + tailf:info "Oracle EM/VP"; + } + enum oraclenames { + tailf:info "Oracle Names"; + } + enum orasrv { + tailf:info "Oracle SQL*Net v1/v2"; + } + enum pcanywheredata { + tailf:info "pcANYWHEREdata"; + } + enum pcanywherestat { + tailf:info "pcANYWHEREstat"; + } + enum pop3s { + tailf:info "POP3 over TLS/SSL"; + } + enum pwdgen { + tailf:info "Password Generator Protocol"; + } + enum qmtp { + tailf:info "Quick Mail Transfer Protocol"; + } + enum r-winsock { + tailf:info "remote-winsock"; + } + enum radius { + tailf:info "RADIUS & Accounting"; + } + enum rdb-dbs-disp { + tailf:info "Oracle RDB"; + } + enum realmedia { + tailf:info "RealNetwork's Realmedia Protocol"; + } + enum realsecure { + tailf:info "ISS Real Secure Console Service Port"; + } + enum router { + tailf:info "Local Routing Process"; + } + enum rsvp-encap { + tailf:info "RSVP ENCAPSULATION-1/2"; + } + enum rsvp_tunnel { + tailf:info "RSVP Tunnel"; + } + enum rtc-pm-port { + tailf:info "Oracle RTC-PM port"; + } + enum rtelnet { + tailf:info "Remote Telnet Service"; + } + enum send { + tailf:info "SEND"; + } + enum shell { + tailf:info "Remote command"; + } + enum sip-tls { + tailf:info "SIP-TLS"; + } + enum sms { + tailf:info "SMS RCINFO/XFER/CHAT"; + } + enum snmptrap { + tailf:info "SNMP Trap"; + } + enum sql-net { + tailf:info "SQL-NET"; + } + enum sqlserv { + tailf:info "SQL Services"; + } + enum sqlsrv { + tailf:info "SQL Service"; + } + enum sshell { + tailf:info "SSLshell"; + } + enum ssp { + tailf:info "State Sync Protocol"; + } + enum syslog-conn { + tailf:info "Reliable Syslog Service"; + } + enum tacacs { + tailf:info "Login Host Protocol (TACACS)"; + } + enum tacacs-ds { + tailf:info "TACACS-Database Service"; + } + enum tarantella { + tailf:info "Tarantella"; + } + enum tcp { + tailf:info "TCP"; + } + enum telnets { + tailf:info "Telnet over TLS/SSL"; + } + enum time { + tailf:info "Time"; + } + enum timed { + tailf:info "Time server"; + } + enum tr-rsrb { + tailf:info "cisco RSRB"; + } + enum ttc { + tailf:info "Oracle TTC/SSL"; + } + enum udp { + tailf:info "UDP"; + } + enum uucp { + tailf:info "UUCPD/UUCP-RLOGIN"; + } + enum vqp { + tailf:info "VQP"; + } + enum webster { + tailf:info "Network Disctionary"; + } + enum who { + tailf:info "Who's service"; + } + enum wins { + tailf:info "Microsoft WINS"; + } + enum x11 { + tailf:info "X Window System"; + } + enum xdmcp { + tailf:info "XDM Control Protocol"; + } + enum ymsgr { + tailf:info "Yahoo! Instant Messenger"; + } + enum aarp { + tailf:info "AppleTalk ARP"; + } + enum appletalk { + tailf:info "AppleTalk"; + } + enum arp { + tailf:info "IP ARP"; + } + enum bgp { + tailf:info "Border Gateway Protocol"; + } + enum bridge { + tailf:info "Bridging"; + } + enum bstun { + tailf:info "Block Serial Tunnel"; + } + enum cdp { + tailf:info "Cisco Discovery Protocol"; + } + } + } + container citrix { + tailf:info "Citrix Systems ICA protocol"; + description "Citrix Systems ICA protocol"; + presence "enable citrix system protocol matching"; + leaf ica-tag { + tailf:info "Citrix ICA tag 0-high 1-medium 2-low "+ + "3-background"; + description "Citrix ICA tag 0-high 1-medium 2-low "+ + "3-background"; + type string { + tailf:info "WORD;;Enter a string as the sub-protocol "+ + "parameter"; + } + } + } + leaf clns { + tailf:info "ISO CLNS"; + description "ISO CLNS"; + type empty; + } + leaf clns_es { + tailf:info "ISO CLNS End System"; + description "ISO CLNS End System"; + type empty; + } + leaf clns_is { + tailf:info "ISO CLNS Intermediate System"; + description "ISO CLNS Intermediate System"; + type empty; + } + leaf cmns { + tailf:info "ISO CMNS"; + description "ISO CMNS"; + type empty; + } + leaf compressedtcp { + tailf:info "Compressed TCP (VJ"; + description "Compressed TCP (VJ"; + type empty; + } + leaf cuseeme { + tailf:info "CU-SeeMe desktop video conference"; + description "CU-SeeMe desktop video conference"; + type empty; + } + leaf decnet { + tailf:info "DECnet"; + description "DECnet"; + type empty; + } + leaf decnet_node { + tailf:info "DECnet Node"; + description "DECnet Node"; + type empty; + } + leaf decnet_router-l1 { + tailf:info "DECnet Router L1"; + description "DECnet Router L1"; + type empty; + } + leaf decnet_router-l2 { + tailf:info "DECnet Router L2"; + description "DECnet Router L2"; + type empty; + } + leaf dhcp { + tailf:info "Dynamic Host Configuration"; + description "Dynamic Host Configuration"; + type empty; + } + leaf dlsw { + type empty; + tailf:info "Data Link Switching (Direct encapsulation only"; + } + leaf dns { + type empty; + tailf:info "Domain Name Server lookup"; + } + leaf edonkey { + type empty; + tailf:info "eDonkey"; + } + leaf egp { + type empty; + tailf:info "Exterior Gateway Protocol"; + } + leaf eigrp { + type empty; + tailf:info "Enhanced Interior Gateway Routing Protocol"; + } + leaf exchange { + type empty; + tailf:info "MS-RPC for Exchange"; + } + container fasttrack { + tailf:info "FastTrack Traffic - KaZaA, Morpheus, Grokster"; + description "FastTrack Traffic - KaZaA, Morpheus, Grokster"; + presence "enable fasttrack matching"; + leaf file-transfer { + tailf:info "File transfer stream"; + description "File transfer stream"; + type string { + tailf:info "WORD;;Enter a string as the sub-protocol "+ + "parameter"; + } + } + } + leaf finger { + type empty; + tailf:info "Finger"; + } + leaf ftp { + type empty; + tailf:info "File Transfer Protocol"; + } + container gnutella { + tailf:info "Gnutella Version2 Traffic - BearShare, Shareeza, "+ + "Morpheus"; + description "Gnutella Version2 Traffic - BearShare, Shareeza, "+ + "Morpheus"; + presence "enable gnutella matching"; + leaf file-transfer { + tailf:info "File transfer stream"; + description "File transfer stream"; + type string { + tailf:info "WORD;;Enter a string as the sub-protocol "+ + "parameter"; + } + } + } + leaf gopher { + type empty; + tailf:info "Gopher"; + } + leaf gre { + type empty; + tailf:info "Generic Routing Encapsulation"; + } + leaf h323 { + type empty; + tailf:info "H323 Protocol"; + } + container http { + tailf:info "World Wide Web traffic"; + description "World Wide Web traffic"; + presence "enable http traffic matching"; + leaf c-header-field { + tailf:info "Client general Header Field"; + description "Client general Header Field"; + type string { + tailf:info "WORD;;Enter a string as the sub-protocol "+ + "parameter"; + } + } + leaf host { + tailf:info "Server Host Name"; + description "Server Host Name"; + type string { + tailf:info "WORD;;Enter a string as the sub-protocol "+ + "parameter"; + } + } + leaf mime { + tailf:info "Match MIME Type"; + description "Match MIME Type"; + type string { + tailf:info "WORD;;Enter a string as the sub-protocol "+ + "parameter"; + } + } + leaf s-header-field { + tailf:info "Server general Header Field"; + description "Server general Header Field"; + type string { + tailf:info "WORD;;Enter a string as the sub-protocol "+ + "parameter"; + } + } + leaf url { + tailf:info "Match URL String"; + description "Match URL String"; + type string { + tailf:info "WORD;;Enter a string as the sub-protocol "+ + "parameter"; + } + } + } + leaf icmp { + tailf:info "Internet Control Message"; + description "Internet Control Message"; + type empty; + } + leaf imap { + tailf:info "Internet Message Access Protocol"; + description "Internet Message Access Protocol"; + type empty; + } + leaf ip { + tailf:info "IP"; + description "IP"; + type empty; + } + leaf ipinip { + tailf:info "IP in IP (encapsulation"; + description "IP in IP (encapsulation"; + type empty; + } + leaf ipsec { + tailf:info "IP Security Protocol (ESP/AH"; + description "IP Security Protocol (ESP/AH"; + type empty; + } + leaf ipv6 { + tailf:info "IPV6"; + description "IPV6"; + type empty; + } + leaf ipx { + tailf:info "Novell IPX"; + description "Novell IPX"; + type empty; + } + leaf irc { + type empty; + tailf:info "Internet Relay Chat"; + description "Internet Relay Chat"; + } + container kazaa2 { + tailf:info "Kazaa Version 2"; + description "Kazaa Version 2"; + presence "enable kazaa version 2 matching"; + leaf file-transfer { + tailf:info "File transfer stream"; + description "File transfer stream"; + type string { + tailf:info "WORD;;Enter a string as the sub-protocol "+ + "parameter"; + } + } + } + leaf kerberos { + tailf:info "Kerberos"; + description "Kerberos"; + type empty; + } + leaf l2tp { + tailf:info "L2F/L2TP tunnel"; + description "L2F/L2TP tunnel"; + type empty; + } + leaf ldap { + tailf:info "Lightweight Directory Access Protocol"; + description "Lightweight Directory Access Protocol"; + type empty; + } + leaf llc2 { + tailf:info "llc2"; + description "llc2"; + type empty; + } + leaf mgcp { + tailf:info "Media Gateway Control Protocol"; + description "Media Gateway Control Protocol"; + type empty; + } + container napster { + tailf:info "Napster Traffic"; + description "Napster Traffic"; + presence "enable napster matching"; + leaf non-std { + tailf:info "Non-standard port advertizements"; + description "Non-standard port advertizements"; + type empty; + } + } + leaf netbios { + tailf:info "NetBIOS"; + description "NetBIOS"; + type empty; + } + leaf netshow { + tailf:info "Microsoft Netshow"; + description "Microsoft Netshow"; + type empty; + } + leaf nfs { + tailf:info "Network File System"; + description "Network File System"; + type empty; + } + leaf nntp { + tailf:info "Network News Transfer Protocol"; + description "Network News Transfer Protocol"; + type empty; + } + leaf notes { + tailf:info "Lotus Notes(R"; + description "Lotus Notes(R"; + type empty; + } + leaf novadigm { + tailf:info "Novadigm EDM"; + description "Novadigm EDM"; + type empty; + } + leaf ntp { + tailf:info "Network Time Protocol"; + description "Network Time Protocol"; + type empty; + } + leaf ospf { + tailf:info "Open Shortest Path First"; + description "Open Shortest Path First"; + type empty; + } + leaf pad { + tailf:info "PAD links"; + description "PAD links"; + type empty; + } + leaf pcanywhere { + tailf:info "Symantec pcANYWHERE"; + description "Symantec pcANYWHERE"; + type empty; + } + leaf pop3 { + tailf:info "Post Office Protocol"; + description "Post Office Protocol"; + type empty; + } + leaf pppoe { + tailf:info "PPP over Ethernet"; + description "PPP over Ethernet"; + type empty; + } + leaf pptp { + tailf:info "Point-to-Point Tunneling Protocol"; + description "Point-to-Point Tunneling Protocol"; + type empty; + } + leaf printer { + tailf:info "print spooler/lpd"; + description "print spooler/lpd"; + type empty; + } + leaf qllc { + tailf:info "qllc protocol"; + description "qllc protocol"; + type empty; + } + leaf rcmd { + tailf:info "BSD r-commands (rsh, rlogin, rexec"; + description "BSD r-commands (rsh, rlogin, rexec"; + type empty; + } + leaf rip { + tailf:info "Routing Information Protocol"; + description "Routing Information Protocol"; + type empty; + } + leaf rsrb { + tailf:info "Remote Source-Route Bridging"; + description "Remote Source-Route Bridging"; + type empty; + } + leaf rsvp { + tailf:info "Resource Reservation Protocol"; + description "Resource Reservation Protocol"; + type empty; + } + leaf rtcp { + tailf:info "Real Time Control Protocol"; + description "Real Time Control Protocol"; + type empty; + } + container rtp { + tailf:info "Real Time Protocol"; + description "Real Time Protocol"; + presence "enable rtp matching"; + leaf audio { + tailf:info "Match voice packets"; + description "Match voice packets"; + type empty; + } + leaf payload-type { + tailf:info "Match an explicit PT"; + description "Match an explicit PT"; + type string { + tailf:info "WORD;;Enter a string as the sub-protocol "+ + "parameter"; + } + } + leaf video { + tailf:info "Match video packets"; + description "Match video packets"; + type empty; + } + } + leaf rtsp { + tailf:info "Real Time Streaming Protocol"; + description "Real Time Streaming Protocol"; + type empty; + } + leaf secure-ftp { + tailf:info "FTP over TLS/SSL"; + description "FTP over TLS/SSL"; + type empty; + } + leaf secure-http { + tailf:info "Secured HTTP"; + description "Secured HTTP"; + type empty; + } + leaf secure-imap { + tailf:info "Internet Message Access Protocol over TLS/SSL"; + description "Internet Message Access Protocol over TLS/SSL"; + type empty; + } + leaf secure-irc { + tailf:info "Internet Relay Chat over TLS/SSL"; + description "Internet Relay Chat over TLS/SSL"; + type empty; + } + leaf secure-ldap { + tailf:info "Lightweight Directory Access Protocol over TLS/SSL"; + description "Lightweight Directory Access Protocol over TLS/SSL"; + type empty; + } + leaf secure-nntp { + tailf:info "Network News Transfer Protocol over TLS/SSL"; + description "Network News Transfer Protocol over TLS/SSL"; + type empty; + } + leaf secure-pop3 { + tailf:info "Post Office Protocol over TLS/SSL"; + description "Post Office Protocol over TLS/SSL"; + type empty; + } + leaf secure-telnet { + tailf:info "Telnet over TLS/SSL"; + description "Telnet over TLS/SSL"; + type empty; + } + leaf sip { + tailf:info "Session Initiation Protocol"; + description "Session Initiation Protocol"; + type empty; + } + leaf skinny { + tailf:info "Skinny Protocol"; + description "Skinny Protocol"; + type empty; + } + container smtp { + tailf:info "Simple Mail Transfer Protocol"; + description "Simple Mail Transfer Protocol"; + leaf extended { + type empty; + } + } + leaf snapshot { + tailf:info "Snapshot routing support"; + description "Snapshot routing support"; + type empty; + } + leaf snmp { + tailf:info "Simple Network Management Protocol"; + description "Simple Network Management Protocol"; + type empty; + } + leaf socks { + tailf:info "SOCKS"; + description "SOCKS"; + type empty; + } + leaf sqlnet { + tailf:info "SQL*NET for Oracle"; + description "SQL*NET for Oracle"; + type empty; + } + leaf sqlserver { + tailf:info "MS SQL Server"; + description "MS SQL Server"; + type empty; + } + leaf ssh { + tailf:info "Secured Shell"; + description "Secured Shell"; + type empty; + } + leaf streamwork { + tailf:info "Xing Technology StreamWorks player"; + description "Xing Technology StreamWorks player"; + type empty; + } + leaf stun { + tailf:info "Serial Tunnel"; + description "Serial Tunnel"; + type empty; + } + leaf sunrpc { + tailf:info "Sun RPC"; + description "Sun RPC"; + type empty; + } + leaf syslog { + tailf:info "WORD;;Enter a string as the sub-protocol "+ + "parameter"; tailf:info "System Logging Utility"; + description "System Logging Utility"; + type empty; + } + leaf telnet { + tailf:info "Telnet"; + description "Telnet"; + type empty; + } + leaf tftp { + tailf:info "Trivial File Transfer Protocol"; + description "Trivial File Transfer Protocol"; + type empty; + } + leaf vdolive { + tailf:info "VDOLive streaming video"; + description "VDOLive streaming video"; + type empty; + } + leaf vofr { + tailf:info "voice over Frame Relay packets"; + description "voice over Frame Relay packets"; + type empty; + } + leaf winmx { + tailf:info "WinMx file-sharing application"; + description "WinMx file-sharing application"; + type empty; + } + leaf xwindows { + tailf:info "X-Windows remote access"; + description "X-Windows remote access"; + type empty; + } + } + // class-map * / qos-group + leaf-list qos-group { + tailf:info "Qos-group"; + description "Qos-group"; + tailf:cli-list-syntax; + type uint16 { + tailf:info "<0-99>;;Qos Group value"; + range "0..99"; + } + } + // class-map * / match security-group + container security-group { + tailf:info "Security group"; + description "Security group"; + container destination { + tailf:info "Destination security group"; + description "Destination security group"; + leaf tag { + tailf:info "Security group tag"; + description "Security group tag"; + type uint16 { + tailf:info "<1-65533>;;Security group tag id"; + } + } + } + container source { + tailf:info "Source security group"; + description "Source security group"; + leaf tag { + tailf:info "Security group tag"; + description "Security group tag"; + type uint16 { + tailf:info "<1-65533>;;Security group tag id"; + } + } + } + } + // class-map * / source-address + container source-address { + tailf:info "Source address"; + description "Source address"; + leaf-list mac { + tailf:info "MAC address"; + description "MAC address"; + tailf:cli-list-syntax; + type yang:mac-address { + tailf:info "H.H.H;;MAC address"; + } + } + } + // class-map * / match vlan + leaf-list vlan { + tailf:info "VLANs to match"; + description "VLANs to match"; + tailf:cli-range-list-syntax; + tailf:cli-list-syntax; + type uint16 { + tailf:info "<1-4094>;;VLAN id"; + range "1..4094"; + } + } + } + + grouping config-service-chain-grouping { + leaf description { + tailf:info "Service function forwarder description"; + description "Service function forwarder description"; + tailf:cli-multi-value; + type string { + tailf:info "LINE;;Up to 256 characters describing this " + "service function forwarder"; + length "1..256"; + } + } + container ip { + tailf:info "IP address for Service Function Forwarder"; + description "IP address for Service Function Forwarder"; + leaf address { + tailf:info "Set IPv4 address"; + description "Set IPv4 address"; + type inet:ipv4-address { + tailf:info "A.B.C.D;;IP address of Service Function Forwarder"; + } + } + } + } + + grouping police-action-drop-grouping { + leaf drop { + tailf:info "drop packet"; + description "drop packet"; + type empty; + } + } + + grouping police-action-grouping { + container actions { + tailf:cli-break-sequence-commands; + tailf:cli-no-keyword; + tailf:cli-drop-node-name; + tailf:cli-flatten-container; + // policy-map * / class * / police ? / conform-action + uses police-conform-action-grouping; + // policy-map * / class * / police ? / exceed-action + uses police-exceed-action-grouping; + // policy-map * / class * / police ? / violate-action + uses police-violate-action-grouping; + } + } + + grouping police-conform-action-grouping { + container conform-set-clp-transmit { + tailf:cli-no-keyword; + tailf:cli-drop-node-name; + tailf:cli-flatten-container; + container conform-action { + tailf:info "action when rate is less than conform burst"; + description "action when rate is less than conform burst"; + tailf:cli-flatten-container; + leaf set-clp-transmit { + tailf:info "set atm clp and send it"; + description "set atm clp and send it"; + type empty; + } + } + } + container conform-set-cos-transmit { + tailf:cli-no-keyword; + tailf:cli-drop-node-name; + tailf:cli-flatten-container; + container conform-action { + tailf:info "action when rate is less than conform burst"; + description "action when rate is less than conform burst"; + tailf:cli-flatten-container; + leaf set-cos-transmit { + tailf:info "rewrite packet cos and send it"; + description "rewrite packet cos and send it"; + type cos_value-type; + } + } + } + container conform-set-cos-transmit-table { + tailf:cli-no-keyword; + tailf:cli-drop-node-name; + tailf:cli-flatten-container; + container conform-action { + tailf:info "action when rate is less than conform burst"; + description "action when rate is less than conform burst"; + tailf:cli-compact-syntax; + tailf:cli-flatten-container; + tailf:cli-sequence-commands; + leaf set-cos-transmit { + tailf:info "rewrite packet cos and send it"; + description "rewrite packet cos and send it"; + type cos_value-type; + } + leaf table { + tailf:info "Specify table-map"; + description "Specify table-map"; + type leafref { + path "/ios:native/table-map/name"; + } + } + } + } + container conform-set-discard-class-transmit { + tailf:cli-no-keyword; + tailf:cli-drop-node-name; + tailf:cli-flatten-container; + container conform-action { + tailf:info "action when rate is less than conform burst"; + description "action when rate is less than conform burst"; + tailf:cli-flatten-container; + leaf set-discard-class-transmit { + tailf:info "set discard-class and send it"; + description "set discard-class and send it"; + type uint8 { + tailf:info "<0-7>;;new discard-class"; + range "0..7"; + } + } + } + } + container conform-set-dscp-transmit { + tailf:cli-no-keyword; + tailf:cli-drop-node-name; + tailf:cli-flatten-container; + container conform-action { + tailf:info "action when rate is less than conform burst"; + description "action when rate is less than conform burst"; + tailf:cli-flatten-container; + leaf set-dscp-transmit { + tailf:info "set dscp and send it"; + description "set dscp and send it"; + type dscp-type; + } + } + } + container conform-set-dscp-transmit-table { + tailf:cli-no-keyword; + tailf:cli-drop-node-name; + tailf:cli-flatten-container; + container conform-action { + tailf:info "action when rate is less than conform burst"; + description "action when rate is less than conform burst"; + tailf:cli-compact-syntax; + tailf:cli-flatten-container; + tailf:cli-sequence-commands; + leaf set-dscp-transmit { + tailf:info "set dscp and send it"; + description "set dscp and send it"; + type dscp-type; + } + leaf table { + tailf:info "Specify table-map"; + description "Specify table-map"; + type leafref { + path "/ios:native/table-map/name"; + } + } + } + } + container conform-set-frde-transmit { + tailf:cli-no-keyword; + tailf:cli-drop-node-name; + tailf:cli-flatten-container; + container conform-action { + tailf:info "action when rate is less than conform burst"; + description "action when rate is less than conform burst"; + tailf:cli-flatten-container; + leaf set-frde-transmit { + tailf:info "set FR DE and send it"; + description "set FR DE and send it"; + type empty; + } + } + } + container conform-set-mpls-exp-imposition-transmit { + tailf:cli-no-keyword; + tailf:cli-drop-node-name; + tailf:cli-flatten-container; + container conform-action { + tailf:info "action when rate is less than conform burst"; + description "action when rate is less than conform burst"; + tailf:cli-flatten-container; + leaf set-mpls-exp-imposition-transmit { + tailf:info "set exp at tag imposition and send it"; + description "set exp at tag imposition and send it"; + type exp_value-type; + } + } + } + container conform-set-mpls-exp-imposition-transmit-table { + tailf:cli-no-keyword; + tailf:cli-drop-node-name; + tailf:cli-flatten-container; + container conform-action { + tailf:info "action when rate is less than conform burst"; + description "action when rate is less than conform burst"; + tailf:cli-compact-syntax; + tailf:cli-flatten-container; + tailf:cli-sequence-commands; + leaf set-mpls-exp-imposition-transmit { + tailf:info "set exp at tag imposition and send it"; + description "set exp at tag imposition and send it"; + type exp_value-type; + } + leaf table { + tailf:info "Specify table-map"; + description "Specify table-map"; + type leafref { + path "/ios:native/table-map/name"; + } + } + } + } + container conform-set-mpls-exp-topmost-transmit { + tailf:cli-no-keyword; + tailf:cli-drop-node-name; + tailf:cli-flatten-container; + container conform-action { + tailf:info "action when rate is less than conform burst"; + description "action when rate is less than conform burst"; + tailf:cli-flatten-container; + leaf set-mpls-exp-topmost-transmit { + tailf:info "set exp on topmost label and send it"; + description "set exp on topmost label and send it"; + type exp_value-type; + } + } + } + container conform-set-mpls-exp-topmost-transmit-table { + tailf:cli-no-keyword; + tailf:cli-drop-node-name; + tailf:cli-flatten-container; + container conform-action { + tailf:info "action when rate is less than conform burst"; + description "action when rate is less than conform burst"; + tailf:cli-compact-syntax; + tailf:cli-flatten-container; + tailf:cli-sequence-commands; + leaf set-mpls-exp-topmost-transmit { + tailf:info "set exp on topmost label and send it"; + description "set exp on topmost label and send it"; + type exp_value-type; + } + leaf table { + tailf:info "Specify table-map"; + description "Specify table-map"; + type leafref { + path "/ios:native/table-map/name"; + } + } + } + } + container conform-set-prec-transmit { + tailf:cli-no-keyword; + tailf:cli-drop-node-name; + tailf:cli-flatten-container; + container conform-action { + tailf:info "action when rate is less than conform burst"; + description "action when rate is less than conform burst"; + tailf:cli-flatten-container; + leaf set-prec-transmit { + tailf:info "rewrite packet precedence and send it"; + description "rewrite packet precedence and send it"; + type prec_value-type; + } + } + } + container conform-set-prec-transmit-table { + tailf:cli-no-keyword; + tailf:cli-drop-node-name; + tailf:cli-flatten-container; + container conform-action { + tailf:info "action when rate is less than conform burst"; + description "action when rate is less than conform burst"; + tailf:cli-compact-syntax; + tailf:cli-flatten-container; + tailf:cli-sequence-commands; + leaf set-prec-transmit { + tailf:info "rewrite packet precedence and send it"; + description "rewrite packet precedence and send it"; + type prec_value-type; + } + leaf table { + tailf:info "Specify table-map"; + description "Specify table-map"; + type leafref { + path "/ios:native/table-map/name"; + } + } + } + } + container conform-set-qos-transmit { + tailf:cli-no-keyword; + tailf:cli-drop-node-name; + tailf:cli-flatten-container; + container conform-action { + tailf:info "action when rate is less than conform burst"; + description "action when rate is less than conform burst"; + tailf:cli-flatten-container; + leaf set-qos-transmit { + tailf:info "set qos-group and send it"; + description "set qos-group and send it"; + type qos_value-type; + } + } + } + container conform-set-qos-transmit-table { + tailf:cli-no-keyword; + tailf:cli-drop-node-name; + tailf:cli-flatten-container; + container conform-action { + tailf:info "action when rate is less than conform burst"; + description "action when rate is less than conform burst"; + tailf:cli-compact-syntax; + tailf:cli-flatten-container; + tailf:cli-sequence-commands; + leaf set-qos-transmit { + tailf:info "set qos-group and send it"; + description "set qos-group and send it"; + type qos_value-type; + } + leaf table { + tailf:info "Specify table-map"; + description "Specify table-map"; + type leafref { + path "/ios:native/table-map/name"; + } + } + } + } + container conform-transmit { + tailf:cli-no-keyword; + tailf:cli-drop-node-name; + tailf:cli-flatten-container; + container conform-action { + tailf:info "action when rate is less than conform burst"; + description "action when rate is less than conform burst"; + tailf:cli-flatten-container; + uses police-action-transmit-grouping; + } + } + container conform-drop { + tailf:cli-no-keyword; + tailf:cli-drop-node-name; + tailf:cli-flatten-container; + container conform-action { + tailf:info "action when rate is less than conform burst"; + description "action when rate is less than conform burst"; + tailf:cli-flatten-container; + uses police-action-drop-grouping; + } + } + } + + grouping police-action-transmit-grouping { + leaf transmit { + tailf:info "transmit packet"; + description "transmit packet"; + type empty; + } + } + + grouping police-exceed-action-grouping { + container exceed-dscp { + tailf:cli-no-keyword; + tailf:cli-drop-node-name; + tailf:cli-flatten-container; + container exceed-action { + tailf:info "action when rate is within conform and "+ + "conform + exceed burst"; + description "action when rate is within conform and "+ + "conform + exceed burst"; + tailf:cli-flatten-container; + leaf dscp { + //tailf:info + type dscp-type; + } + } + } + container exceed-set-clp-transmit { + tailf:cli-no-keyword; + tailf:cli-drop-node-name; + tailf:cli-flatten-container; + container exceed-action { + tailf:info "action when rate is within conform and "+ + "conform + exceed burst"; + description "action when rate is within conform and "+ + "conform + exceed burst"; + tailf:cli-flatten-container; + leaf set-clp-transmit { + tailf:info "set atm clp and send it"; + description "set atm clp and send it"; + type empty; + } + } + } + container exceed-set-cos-transmit { + tailf:cli-no-keyword; + tailf:cli-drop-node-name; + tailf:cli-flatten-container; + container exceed-action { + tailf:info "action when rate is within conform and "+ + "conform + exceed burst"; + description "action when rate is within conform and "+ + "conform + exceed burst"; + tailf:cli-flatten-container; + leaf set-cos-transmit { + tailf:info "rewrite packet cos and send it"; + description "rewrite packet cos and send it"; + type cos_value-type; + } + } + } + container exceed-set-discard-class-transmit { + tailf:cli-no-keyword; + tailf:cli-drop-node-name; + tailf:cli-flatten-container; + container exceed-action { + tailf:info "action when rate is within conform and "+ + "conform + exceed burst"; + description "action when rate is within conform and "+ + "conform + exceed burst"; + tailf:cli-flatten-container; + leaf set-discard-class-transmit { + tailf:info "set discard-class and send it"; + description "set discard-class and send it"; + type uint8 { + tailf:info "<0-7>;;new discard-class"; + range "0..7"; + } + } + } + } + container exceed-set-dscp-transmit { + tailf:cli-no-keyword; + tailf:cli-drop-node-name; + tailf:cli-flatten-container; + container exceed-action { + tailf:info "action when rate is within conform and "+ + "conform + exceed burst"; + description "action when rate is within conform and "+ + "conform + exceed burst"; + tailf:cli-flatten-container; + leaf set-dscp-transmit { + tailf:info "set dscp and send it"; + description "set dscp and send it"; + type dscp-type; + } + container set-dscp-transmit-c { + tailf:alt-name "set-dscp-transmit"; + container dscp { + leaf table { + type enumeration { + enum policed-dscp; + } + } + } + } + } + } + container exceed-set-frde-transmit { + tailf:cli-no-keyword; + tailf:cli-drop-node-name; + tailf:cli-flatten-container; + container exceed-action { + tailf:info "action when rate is within conform and "+ + "conform + exceed burst"; + description "action when rate is within conform and "+ + "conform + exceed burst"; + tailf:cli-flatten-container; + leaf set-frde-transmit { + tailf:info "set FR DE and send it"; + description "set FR DE and send it"; + type empty; + } + } + } + container exceed-set-mpls-exp-imposition-transmit { + tailf:cli-no-keyword; + tailf:cli-drop-node-name; + tailf:cli-flatten-container; + container exceed-action { + tailf:info "action when rate is within conform and "+ + "conform + exceed burst"; + description "action when rate is within conform and "+ + "conform + exceed burst"; + tailf:cli-flatten-container; + leaf set-mpls-exp-imposition-transmit { + tailf:info "set exp at tag imposition and send it"; + description "set exp at tag imposition and send it"; + type exp_value-type; + } + } + } + container exceed-set-mpls-exp-topmost-transmit { + tailf:cli-no-keyword; + tailf:cli-drop-node-name; + tailf:cli-flatten-container; + container exceed-action { + tailf:info "action when rate is within conform and "+ + "conform + exceed burst"; + description "action when rate is within conform and "+ + "conform + exceed burst"; + tailf:cli-flatten-container; + leaf set-mpls-exp-topmost-transmit { + tailf:info "set exp on topmost label and send it"; + description "set exp on topmost label and send it"; + type exp_value-type; + } + } + } + container exceed-set-prec-transmit { + tailf:cli-no-keyword; + tailf:cli-drop-node-name; + tailf:cli-flatten-container; + container exceed-action { + tailf:info "action when rate is within conform and "+ + "conform + exceed burst"; + description "action when rate is within conform and "+ + "conform + exceed burst"; + tailf:cli-flatten-container; + leaf set-prec-transmit { + tailf:info "rewrite packet precedence and send it"; + description "rewrite packet precedence and send it"; + type prec_value-type; + } + } + } + container exceed-set-qos-transmit { + tailf:cli-no-keyword; + tailf:cli-drop-node-name; + tailf:cli-flatten-container; + container exceed-action { + tailf:info "action when rate is within conform and "+ + "conform + exceed burst"; + description "action when rate is within conform and "+ + "conform + exceed burst"; + tailf:cli-flatten-container; + leaf set-qos-transmit { + tailf:info "set qos-group and send it"; + description "set qos-group and send it"; + type qos_value-type; + } + } + } + container exceed-transmit { + tailf:cli-no-keyword; + tailf:cli-drop-node-name; + tailf:cli-flatten-container; + container exceed-action { + tailf:info "action when rate is within conform and "+ + "conform + exceed burst"; + description "action when rate is within conform and "+ + "conform + exceed burst"; + tailf:cli-flatten-container; + uses police-action-transmit-grouping; + } + } + container exceed-drop { + tailf:cli-no-keyword; + tailf:cli-drop-node-name; + tailf:cli-flatten-container; + container exceed-action { + tailf:info "action when rate is within conform and "+ + "conform + exceed burst"; + description "action when rate is within conform and "+ + "conform + exceed burst"; + tailf:cli-flatten-container; + uses police-action-drop-grouping; + } + } + } + + grouping police-violate-action-grouping { + container violate-set-clp-transmit { + tailf:cli-no-keyword; + tailf:cli-drop-node-name; + tailf:cli-flatten-container; + container violate-action { + tailf:info "action when rate is greater than conform + "+ + "exceed burst"; + description "action when rate is greater than conform + "+ + "exceed burst"; + tailf:cli-flatten-container; + leaf set-clp-transmit { + tailf:info "set atm clp and send it"; + description "set atm clp and send it"; + type empty; + } + } + } + container violate-set-cos-transmit { + tailf:cli-no-keyword; + tailf:cli-drop-node-name; + tailf:cli-flatten-container; + container violate-action { + tailf:info "action when rate is greater than conform + "+ + "exceed burst"; + description "action when rate is greater than conform + "+ + "exceed burst"; + tailf:cli-flatten-container; + leaf set-cos-transmit { + tailf:info "rewrite packet cos and send it"; + description "rewrite packet cos and send it"; + type cos_value-type; + } + } + } + container violate-set-discard-class-transmit { + tailf:cli-no-keyword; + tailf:cli-drop-node-name; + tailf:cli-flatten-container; + container violate-action { + tailf:info "action when rate is greater than conform + "+ + "exceed burst"; + description "action when rate is greater than conform + "+ + "exceed burst"; + tailf:cli-flatten-container; + leaf set-discard-class-transmit { + tailf:info "set discard-class and send it"; + description "set discard-class and send it"; + type uint8 { + tailf:info "<0-7>;;new discard-class"; + range "0..7"; + } + } + } + } + container violate-set-dscp-transmit { + tailf:cli-no-keyword; + tailf:cli-drop-node-name; + tailf:cli-flatten-container; + container violate-action { + tailf:info "action when rate is greater than conform + "+ + "exceed burst"; + description "action when rate is greater than conform + "+ + "exceed burst"; + tailf:cli-flatten-container; + leaf set-dscp-transmit { + tailf:info "set dscp and send it"; + description "set dscp and send it"; + type dscp-type; + } + } + } + container violate-set-frde-transmit { + tailf:cli-no-keyword; + tailf:cli-drop-node-name; + tailf:cli-flatten-container; + container violate-action { + tailf:info "action when rate is greater than conform + "+ + "exceed burst"; + description "action when rate is greater than conform + "+ + "exceed burst"; + tailf:cli-flatten-container; + leaf set-frde-transmit { + tailf:info "set FR DE and send it"; + description "set FR DE and send it"; + type empty; + } + } + } + container violate-set-mpls-exp-imposition-transmit { + tailf:cli-no-keyword; + tailf:cli-drop-node-name; + tailf:cli-flatten-container; + container violate-action { + tailf:info "action when rate is greater than conform + "+ + "exceed burst"; + description "action when rate is greater than conform + "+ + "exceed burst"; + tailf:cli-flatten-container; + leaf set-mpls-exp-imposition-transmit { + tailf:info "set exp at tag imposition and send it"; + description "set exp at tag imposition and send it"; + type exp_value-type; + } + } + } + container violate-set-mpls-exp-topmost-transmit { + tailf:cli-no-keyword; + tailf:cli-drop-node-name; + tailf:cli-flatten-container; + container violate-action { + tailf:info "action when rate is greater than conform + "+ + "exceed burst"; + description "action when rate is greater than conform + "+ + "exceed burst"; + tailf:cli-flatten-container; + leaf set-mpls-exp-topmost-transmit { + tailf:info "set exp on topmost label and send it"; + description "set exp on topmost label and send it"; + type exp_value-type; + } + } + } + container violate-set-prec-transmit { + tailf:cli-no-keyword; + tailf:cli-drop-node-name; + tailf:cli-flatten-container; + container violate-action { + tailf:info "action when rate is greater than conform + "+ + "exceed burst"; + description "action when rate is greater than conform + "+ + "exceed burst"; + tailf:cli-flatten-container; + leaf set-prec-transmit { + tailf:info "rewrite packet precedence and send it"; + description "rewrite packet precedence and send it"; + type prec_value-type; + } + } + } + container violate-set-qos-transmit { + tailf:cli-no-keyword; + tailf:cli-drop-node-name; + tailf:cli-flatten-container; + container violate-action { + tailf:info "action when rate is greater than conform + "+ + "exceed burst"; + description "action when rate is greater than conform + "+ + "exceed burst"; + tailf:cli-flatten-container; + leaf set-qos-transmit { + tailf:info "set qos-group and send it"; + description "set qos-group and send it"; + type qos_value-type; + } + } + } + container violate-transmit { + tailf:cli-no-keyword; + tailf:cli-drop-node-name; + tailf:cli-flatten-container; + container violate-action { + tailf:info "action when rate is greater than conform + "+ + "exceed burst"; + description "action when rate is greater than conform + "+ + "exceed burst"; + tailf:cli-flatten-container; + uses police-action-transmit-grouping; + } + } + container violate-drop { + tailf:cli-no-keyword; + tailf:cli-drop-node-name; + tailf:cli-flatten-container; + container violate-action { + tailf:info "action when rate is greater than conform + "+ + "exceed burst"; + description "action when rate is greater than conform + "+ + "exceed burst"; + tailf:cli-flatten-container; + uses police-action-drop-grouping; + } + } + } + + grouping random-detect-grouping { + leaf min-threshold { + tailf:cli-drop-node-name; + tailf:cli-incomplete-command; + type uint16 { + range "1..4096"; + tailf:info "<1-4096>;;minimum threshold (number of packets)"; + } + } + leaf max-threshold { + tailf:cli-drop-node-name; + tailf:cli-incomplete-command; + type uint16 { + range "1..4096"; + tailf:info "<1-4096>;;maximum threshold (number of packets)"; + } + } + leaf denominator { + tailf:cli-drop-node-name; + type uint32 { + range "1..65535"; + tailf:info "<1-65535>;;mark probability denominator"; + } + } + } + +/// ======================================================================== +/// native +/// ======================================================================== + + container native { + tailf:cli-drop-node-name; + container table-map { + tailf:info "Map external entry attributes into routing table"; + tailf:cli-full-command; + description "Map external entry attributes into routing table"; + tailf:display-when "ipv4 or ../../ipv4 or ../ipv4 " + + " or ipv6 or ../../ipv6 or ../ipv6 "; + leaf name { + description "route-map name"; + tailf:cli-drop-node-name; + type string { + tailf:info "WORD;;route-map name"; + } + } + leaf filter { + tailf:info "Selective route download"; + type empty; + } + } + +/// ======================================================================== +/// mls +/// ======================================================================== +/// Note: must come before class-map and policy-map. + + container mls { + tailf:info "mls global commands"; + description "mls global commands"; + tailf:cli-incomplete-no; + + // mls acl + container acl { + tailf:info "MLS ACL operation"; + description "MLS ACL operation"; + // mls acl tcam + container tcam { + tailf:info "ACL TCAM"; + description "ACL TCAM"; + leaf default-result { + tailf:info "Default result to be used during tcam programming"; + description "Default result to be used during tcam programming"; + type enumeration { + enum bridge { + tailf:info "Bridge result"; + } + enum deny { + tailf:info "Deny result"; + } + enum permit { + tailf:info "Permit result"; + } + } + } + container log-update { + tailf:info "Log TCAM updates"; + description "Log TCAM updates"; + presence true; + leaf rate-limit-msg { + tailf:info "Enable/Disable syslog ratelimiting"; + description "Enable/Disable syslog ratelimiting"; + type enumeration { + enum disable { + tailf:info "Disable ratelimiting syslog"; + } + enum enable { + tailf:info "Enable syslog ratelimiting at 1 per second"; + } + } + } + } + leaf share-global { + tailf:info "share global deny or permit any entries"; + description "share global deny or permit any entries"; + tailf:cli-boolean-no; + tailf:cli-trim-default; + type boolean; + default true; + } + } + } + + // aging L3 aging + // mls cef + container cef { + tailf:info "cef keyword"; + description "cef keyword"; + container error { + leaf action { + type enumeration { + enum reset; + } + } + } + // maximum-routes Configure route allocation for protocols + // tunnel Allow tunnel fragmentation + } + // erm FIB Exception Recovery Manager + // exclude exclude keyword + // mls flow + container flow { + tailf:info "flowmask keyword"; + description "flowmask keyword"; + leaf ip { + tailf:info "flowmask ip keyword"; + description "flowmask ip keyword"; + type enumeration { + enum interface-destination { + tailf:info "interface-destination flow keyword"; + } + enum interface-destination-source { + tailf:info "interface-destination-source flow keyword"; + } + enum interface-full { + tailf:info "interface-full flow keyword"; + } + enum interface-source { + tailf:info "interface-source only flow keyword"; + } + } + } + } + // mls ip + container ip { + tailf:info "ip keyword"; + description "ip keyword"; + // cef cef keyword + // inspect inspect + // mls ip multicast + container multicast { + tailf:info "multicast keyword"; + description "multicast keyword"; + tailf:cli-display-separated; + presence true; + // bidir Bidir commands + // connected Enable download of interface/mask entry + container consistency-check { + tailf:info "Set consistency checking characteristics"; + description "Set consistency checking characteristics"; + presence true; + leaf settle-time { + tailf:info "Settle time for entry/oif for consistancy-checker"; + description "Settle time for entry/oif for consistancy-checker"; + type uint16 { + tailf:info "<2-3600>;;Settle time for entry/oif in seconds"; + range "2..3600"; + } + } + // type Set consistency checker type + } + // egress Set egress replication options + leaf flow-stat-timer { + tailf:info "timer for flow statistic used by mls-msc and mlsm"; + description "timer for flow statistic used by mls-msc and mlsm"; + type uint8 { + tailf:info "<1-100>;;#seconds between one batch and another"; + range "1..100"; + } + } + // met-optimization Enable or disable met optimisation + // non-rpf Enable rate-limiting of non-RPF traffic + // replication-mode Disable auto-detection mode for egress + // sso Stateful switchover parameters + // threshold Threshold rate for installing h/w shortcuts + } + // nat nat keyword + // slb Server Load Balancing + } + // nde netflow data export (nde) keyword + // netflow netflow keyword + // mls qos + container mls-qos-conf { + tailf:cli-no-keyword; + tailf:cli-drop-node-name; + leaf qos { + type empty; + } + } + // mls qos + container qos { + tailf:info "QoS parameters"; + description "QoS parameters"; + tailf:cli-incomplete-command; + tailf:cli-incomplete-no; + // mls qos aggregate-policer * + list aggregate-policer { + tailf:info "Assign aggregate policer"; + description "Assign aggregate policer"; + tailf:cli-suppress-mode; + tailf:cli-delete-when-empty; + tailf:cli-compact-syntax; + tailf:cli-sequence-commands { + tailf:cli-reset-all-siblings; + } + key name; + leaf name { + type string { + tailf:info "WORD;;aggregate policer name"; + } + } + leaf target-bit-rate { + tailf:cli-drop-node-name; + type uint64 { + tailf:info "<32000-60000000000>;;Target Bit Rate (bits per " + +"second) (postfix k, m, g optional; decimal point allowed)"; + range "32000..60000000000"; + } + } + leaf burst-normal { + tailf:cli-drop-node-name; + tailf:cli-optional-in-sequence; + type uint32 { + tailf:info "<1000-31250000>;;Normal burst bytes"; + range "1000..31250000"; + } + } + leaf burst-max { + tailf:cli-drop-node-name; + tailf:cli-optional-in-sequence; + when "../burst-normal" { + tailf:dependency "../burst-normal"; + } + type uint32 { + tailf:info "<1000-31250000>;;Maximum burst bytes"; + range "1000..31250000"; + } + } + leaf pir { + tailf:info "PIR"; + description "PIR"; + tailf:cli-optional-in-sequence; + type uint64 { + tailf:info "<32000-60000000000>;;Target Bit Rate (bits per " + +"second) (postfix k, m, g optional; decimal point allowed)"; + range "32000..60000000000"; + } + } + container conform-action { + tailf:info "action when rate is not exceeded"; + description "action when rate is not exceeded"; + tailf:cli-optional-in-sequence; + tailf:cli-compact-syntax; + tailf:cli-flatten-container; + choice action-choice { + leaf drop { + tailf:info "drop packet"; + description "drop packet"; + type empty; + } + leaf set-dscp-transmit { + tailf:info "set dscp and send it"; + description "set dscp and send it"; + type dscp-type; + } + leaf set-mpls-exp-imposition-transmit { + tailf:info "set exp at tag imposition and send it"; + description "set exp at tag imposition and send it"; + type uint8 { + tailf:info "<0-7>;;new exp"; + range "0..7"; + } + } + leaf set-prec-transmit { + tailf:info "rewrite packet precedence and send it"; + description "rewrite packet precedence and send it"; + type uint8 { + tailf:info "<0-7>;;new precedence"; + range "0..7"; + } + } + leaf transmit { + tailf:info "transmit packet"; + description "transmit packet"; + type empty; + } + } + } + leaf exceed-action { + tailf:info "action when rate is exceeded"; + description "action when rate is exceeded"; + tailf:cli-optional-in-sequence; + type enumeration { + enum drop { + tailf:info "drop packet"; + } + enum policed-dscp-transmit { + tailf:info "change dscp per policed-dscp map and send it"; + } + enum transmit { + tailf:info "transmit packet"; + } + } + } + leaf violate-action { + tailf:info "action when rate violated"; + description "action when rate violated"; + type enumeration { + enum drop { + tailf:info "drop packet"; + } + enum policed-dscp-transmit { + tailf:info "change dscp per policed-dscp map and send it"; + } + enum transmit { + tailf:info "transmit packet"; + } + } + } + } + // map Define QoS mapping + // mls qos map + container map { + tailf:info "qos map keyword"; + description "qos map keyword"; + leaf-list cos-dscp { + tailf:info "cos-dscp map: eight dscp values for cos 0-7"; + description "cos-dscp map: eight dscp values for cos 0-7"; + tailf:cli-flat-list-syntax; + //max-elements 8; + type uint8 { + tailf:info "<0-63>;;CoS values separated by spaces (up to 8 values total)"; + range "0..63"; + } + } + leaf-list policed-dscp { + tailf:info "policed-dscp map keyword"; + description "policed-dscp map keyword"; + ordered-by user; + tailf:cli-flat-list-syntax; + type union { + type uint8 { + tailf:info "<0-63>;;DSCP values separated by spaces (up to 8 values total)"; + range "0..63"; + } + type enumeration { + enum to { + tailf:info "to keyword"; + } + } + } + } + } + // marking marking keyword + // police police keyword + // protocol protocol keyword + // queueing-only queueing-only (no QoS rewrite, no policing) + // recirc recirculate path + // mls qos rewrite + container rewrite { + tailf:info "packet qos rewrite enable/disable"; + description "packet qos rewrite enable/disable"; + container ip { + tailf:info "ip packet qos rewrite enable/disable"; + description "ip packet qos rewrite enable/disable"; + container dscp { + tailf:info "packet ip dscp rewrite enable/disable"; + description "packet ip dscp rewrite enable/disable"; + presence true; + leaf slot { + tailf:info "slot number"; + description "slot number"; + type string { + tailf:info "WORD;;Slots seperated by commas. Valid slots: 1,2," + +"3,4,5,6,7,8,9"; + } + } + } + } + } + // mls qos queue-set + container queue-set { + tailf:info "Choose a queue set for this queue"; + description "Choose a queue set for this queue"; + container output { + tailf:info "Direction the command applies for this command"; + description "Direction the command applies for this command"; + tailf:cli-sequence-commands; + tailf:cli-compact-syntax; + leaf queue-set-id { + tailf:cli-drop-node-name; + type uint8 { + tailf:info "<1-2>;;queue-set id"; + range "1..2"; + } + } + list threshold { + tailf:info "Assign threshold values to a queue"; + description "Assign threshold values to a queue"; + tailf:cli-suppress-mode; + tailf:cli-break-sequence-commands; + tailf:cli-compact-syntax; + tailf:cli-sequence-commands; + key queue-id; + leaf queue-id { + type uint8 { + tailf:info "<1-4>;;enter queue id in this queue set"; + range "1..4"; + } + } + leaf drop1 { + tailf:cli-drop-node-name; + description "drop threshold1 1-3200"; + type uint32 { + tailf:info "<1-3200>;;enter drop threshold1 1-3200"; + range "1..3200"; + } + } + leaf drop2 { + tailf:cli-drop-node-name; + description "drop threshold2 1-3200"; + type uint32 { + tailf:info "<1-3200>;;enter drop threshold2 1-3200"; + range "1..3200"; + } + } + leaf reserved { + tailf:cli-drop-node-name; + description "reserved threshold 1-100"; + type uint32 { + tailf:info "<1-3200>;;enter drop threshold2 1-3200"; + range "1..3200"; + } + } + leaf maximum { + tailf:cli-drop-node-name; + description "maximum threshold1 1-3200"; + type uint32 { + tailf:info "<1-3200>;;enter maximum threshold1 1-3200"; + range "1..3200"; + } + } + } + leaf-list buffers { + tailf:info "assign buffers to each egress queue"; + description "assign buffers to each egress queue"; + tailf:cli-flat-list-syntax; + type uint16 { + tailf:info "<0-99>/<1-100>;;enter buffer percentage for queue x 0-99/2 1-100"; + range "0..100"; + } + } + } + } + // mls qos srr-queue + container srr-queue { + tailf:info "Configure SRR receive queues"; + description "Configure SRR receive queues"; + container input { + tailf:info "input keyword"; + description "input keyword"; + leaf-list bandwidth { + tailf:info "Configure SRR bandwidth"; + description "Configure SRR bandwidth"; + tailf:cli-flat-list-syntax; + type uint8 { + tailf:info "<1-100>;;enter bandwidth weight for queue id x"; + range "1..100"; + } + } + list threshold { + tailf:info "Configure queue tail-drop thresholds"; + description "Configure queue tail-drop thresholds"; + tailf:cli-suppress-mode; + key queue-id; + leaf queue-id { + type uint8 { + tailf:info "<1-2>;;enter threshold queue id (1-2)"; + range "1..2"; + } + } + leaf-list queue-size-percent { + tailf:cli-drop-node-name; + tailf:cli-flat-list-syntax; + type uint8 { + tailf:info "<1-100>;;enter percent of queue size for threshold x"; + range "1..100"; + } + } + } + list priority-queue { + tailf:info "Configure priority scheduling"; + description "Configure priority scheduling"; + tailf:cli-suppress-mode; + key queue-number; + leaf queue-number { + type uint8 { + tailf:info "<1-2>;;enter priority queue number [1-2]"; + } + } + leaf bandwidth { + tailf:info "ingress priority queue bandwidth % of stack ring"; + description "ingress priority queue bandwidth % of stack ring"; + type uint8 { + tailf:info "<0-40>;;enter bandwidth number [0-40]"; + range "0..40"; + } + } + } + list cos-map { + tailf:info "Configure cos-map for a queue id"; + description "Configure cos-map for a queue id"; + tailf:cli-suppress-mode; + key "queue threshold"; + leaf queue { + tailf:info "Assign COS values to a queue"; + description "Assign COS values to a queue"; + tailf:cli-expose-key-name; + type uint8 { + tailf:info "<1-4>;;enter cos-map output queue id"; + range "1..4"; + } + } + leaf threshold { + tailf:info "Assign COS values to a queue threshold"; + description "Assign COS values to a queue threshold"; + tailf:cli-expose-key-name; + type uint8 { + tailf:info "<1-3>;;enter cos-map threshold id"; + range "1..3"; + } + } + leaf-list cos { + tailf:cli-drop-node-name; + tailf:cli-flat-list-syntax; + max-elements 8; + type uint8 { + tailf:info "<0-7>;;8 cos values separated by spaces"; + range "0..7"; + } + } + } + list dscp-map { + tailf:info "Configure dscp-map for a queue id"; + description "Configure dscp-map for a queue id"; + tailf:cli-suppress-mode; + key "queue threshold"; + leaf queue { + tailf:info "Assign DSCP values to a queue"; + description "Assign DSCP values to a queue"; + tailf:cli-expose-key-name; + type uint8 { + tailf:info "<1-4>;;enter dscp-map output queue id"; + range "1..4"; + } + } + leaf threshold { + tailf:info "Assign DSCP values to a queue threshold"; + description "Assign DSCP values to a queue threshold"; + tailf:cli-expose-key-name; + type uint8 { + tailf:info "<1-3>;;enter dscp-map threshold id"; + range "1..3"; + } + } + leaf-list dscp { + tailf:cli-drop-node-name; + tailf:cli-flat-list-syntax; + max-elements 8; + type uint8 { + tailf:info "<0-63>;;dscp values separated by spaces (up to 8 values total)"; + range "0..63"; + } + } + } + } + container output { + tailf:info "output keyword"; + description "output keyword"; + list cos-map { + tailf:info "Configure cos-map for a queue id"; + description "Configure cos-map for a queue id"; + tailf:cli-suppress-mode; + key "queue threshold"; + leaf queue { + tailf:info "Assign COS values to a queue"; + description "Assign COS values to a queue"; + tailf:cli-expose-key-name; + type uint8 { + tailf:info "<1-4>;;enter cos-map output queue id"; + range "1..4"; + } + } + leaf threshold { + tailf:info "Assign COS values to a queue threshold"; + description "Assign COS values to a queue threshold"; + tailf:cli-expose-key-name; + type uint8 { + tailf:info "<1-3>;;enter cos-map threshold id"; + range "1..3"; + } + } + leaf-list cos { + tailf:cli-drop-node-name; + tailf:cli-flat-list-syntax; + max-elements 8; + type uint8 { + tailf:info "<0-7>;;8 cos values separated by spaces"; + range "0..7"; + } + } + } + list dscp-map { + tailf:info "Configure dscp-map for a queue id"; + description "Configure dscp-map for a queue id"; + tailf:cli-suppress-mode; + key "queue threshold"; + leaf queue { + tailf:info "Assign DSCP values to a queue"; + description "Assign DSCP values to a queue"; + tailf:cli-expose-key-name; + type uint8 { + tailf:info "<1-4>;;enter dscp-map output queue id"; + range "1..4"; + } + } + leaf threshold { + tailf:info "Assign DSCP values to a queue threshold"; + description "Assign DSCP values to a queue threshold"; + tailf:cli-expose-key-name; + type uint8 { + tailf:info "<1-3>;;enter dscp-map threshold id"; + range "1..3"; + } + } + leaf-list dscp { + tailf:cli-drop-node-name; + tailf:cli-flat-list-syntax; + max-elements 8; + type uint8 { + tailf:info "<0-63>;;dscp values separated by spaces (up to 8 values total)"; + range "0..63"; + } + } + } + } + } + } + // statistics-export qos statistics data export + // mls rate-limit + container rate-limit { + tailf:info "Rate limit different behaviors"; + description "Rate limit different behaviors"; + // all Rate Limiting for both Unicast and Multicast packets + container layer2 { + tailf:info "layer2 protocol cases"; + description "layer2 protocol cases"; + // ip-admission IP admission on Layer2 ports + container l2pt { + tailf:cli-compact-syntax; + tailf:cli-sequence-commands { + tailf:cli-reset-siblings; + } + tailf:info "layer2 protocol tunnelling packets"; + leaf packets-per-second { + description "layer2 protocol tunnelling packets"; + tailf:cli-drop-node-name; + type uint32 { + tailf:info "<10-1000000>;;packets per second"; + range "10..1000000"; + } + } + leaf packets-in-burst { + tailf:cli-drop-node-name; + type uint32 { + tailf:info "<1-255>;;packets in burst"; + range "1..255"; + } + } + } + // mac-security Mac security traffics + container pdu { + tailf:info "layer2 protocol data unit packets"; + description "layer2 protocol data unit packets"; + tailf:cli-compact-syntax; + tailf:cli-sequence-commands { + tailf:cli-reset-siblings; + } + leaf packets-per-second { + tailf:cli-drop-node-name; + type uint32 { + tailf:info "<10-1000000>;;packets per second"; + range "10..1000000"; + } + } + leaf packets-in-burst { + tailf:cli-drop-node-name; + type uint32 { + tailf:info "<1-255>;;packets in burst"; + range "1..255"; + } + } + } + // port-security Port security traffics + } + // multicast Rate limiting for Multicast packets + // unicast Rate limiting for Unicast packets + } + // rp rp + // sampling sampling keyword + // mls verify + container verify { + tailf:info "enable hardware packet parsing error checks"; + description "enable hardware packet parsing error checks"; + container ip { + tailf:info "check on IP packets"; + description "check on IP packets"; + leaf checksum { + tailf:info "check for packet checksum errors"; + description "check for packet checksum errors"; + tailf:cli-boolean-no; + tailf:cli-trim-default; + type boolean; + default true; + } + container "length" { + tailf:info "check for packet length errors"; + description "check for packet length errors"; + leaf consistent { + tailf:info "check length in header against physical frame length"; + description "check length in header against physical frame length"; + tailf:cli-boolean-no; + tailf:cli-trim-default; + type boolean; + default true; + } + leaf minimum { + tailf:info "check for minimum packet length"; + description "check for minimum packet length"; + tailf:cli-boolean-no; + tailf:cli-trim-default; + type boolean; + default true; + } + } + leaf same-address { + tailf:info "check for packet having equal source and destination IP " + +"addresses"; + description "check for packet having equal source and destination IP " + +"addresses"; + type empty; + } + leaf syslog { + tailf:info "syslog packet parse errors"; + description "syslog packet parse errors"; + type empty; + } + } + } + } + +/// ======================================================================== +/// policer +/// ======================================================================== +// Note: must come before class-map and policy-map. + + container policer { + tailf:info "Switch policer"; + description "Switch policer"; + // policer aggregate * + list aggregate { + tailf:info "Named aggregate policer"; + description "Named aggregate policer"; + tailf:cli-suppress-mode; + tailf:cli-delete-when-empty; + tailf:cli-compact-syntax; + tailf:cli-reset-container; + tailf:cli-sequence-commands { + tailf:cli-reset-siblings; + } + key name; + leaf name { + type string { + tailf:info "WORD;;aggregate policer Name"; + } + } + // cir + leaf cir { + tailf:info "Committed information rate"; + description "Committed information rate"; + type uint32 { + tailf:info "<8000-1000000000>;;Bits per second"; + range "8000..1000000000"; + } + } + // bc + leaf bc { + tailf:info "Conform burst"; + description "Conform burst"; + tailf:cli-optional-in-sequence; + type uint32 { + tailf:info "<8000-1000000000>;;Burst bytes"; + range "8000..1000000000"; + } + } + // conform-action + leaf conform-action { + tailf:info "action when rate is within conform and conform + "+ + "exceed burst"; + description "action when rate is within conform and conform + "+ + "exceed burst"; + tailf:cli-optional-in-sequence; + type empty; + } + leaf set-qos-transmit { + tailf:info "set qos-group and send it"; + description "set qos-group and send it"; + when "../conform-action"; + tailf:cli-optional-in-sequence; + type uint8 { + tailf:info "<0-99>;;new qos-group"; + range "0..99"; + } + } + leaf set-dot1ad-dei-transmit { + tailf:info "set dei and send it"; + description "set dei and send it"; + when "../conform-action"; + tailf:cli-optional-in-sequence; + type uint8 { + tailf:info "<0-1>;;new dei value"; + range "0..1"; + } + } + leaf set-prec-transmit { + tailf:info "rewrite packet precedence and send it"; + description "rewrite packet precedence and send it"; + when "../conform-action"; + tailf:cli-optional-in-sequence; + type prec_value-type; + } + container set-prec-transmit-table { + when "../set-prec-transmit"; + tailf:cli-no-keyword; + tailf:cli-drop-node-name; + tailf:cli-optional-in-sequence; + tailf:cli-flatten-container; + leaf table { + tailf:info "Set packet cos from cos based on table map"; + description "Set packet cos from cos based on table map"; + tailf:cli-optional-in-sequence; + type string; + tailf:non-strict-leafref { + path "/ios:native/table-map/name"; + } + } + } + leaf set-dscp-transmit { + tailf:info "set dscp and send it"; + description "set dscp and send it"; + when "../conform-action"; + tailf:cli-optional-in-sequence; + type dscp-type; + } + container set-dscp-transmit-table { + when "../set-dscp-transmit"; + tailf:cli-no-keyword; + tailf:cli-drop-node-name; + tailf:cli-optional-in-sequence; + tailf:cli-flatten-container; + leaf table { + tailf:info "Set packet cos from cos based on table map"; + description "Set packet cos from cos based on table map"; + tailf:cli-optional-in-sequence; + type string; + tailf:non-strict-leafref { + path "/ios:native/table-map/name"; + } + } + } + leaf set-cos-transmit { + tailf:info "set cos and send it"; + description "set cos and send it"; + when "../conform-action"; + tailf:cli-optional-in-sequence; + type cos_value-type; + } + container set-cos-transmit-table { + when "../set-cos-transmit"; + tailf:cli-no-keyword; + tailf:cli-drop-node-name; + tailf:cli-optional-in-sequence; + tailf:cli-flatten-container; + leaf table { + tailf:info "Set packet cos from cos based on table map"; + description "Set packet cos from cos based on table map"; + tailf:cli-optional-in-sequence; + type string; + tailf:non-strict-leafref { + path "/ios:native/table-map/name"; + } + } + } + leaf transmit { + tailf:info "transmit packet"; + description "transmit packet"; + when "../conform-action"; + tailf:cli-optional-in-sequence; + type empty; + } + // exceed-action + leaf exceed-action { + tailf:info "action when rate is within conform and conform + "+ + "exceed burst"; + description "action when rate is within conform and conform + "+ + "exceed burst"; + type empty; + } + leaf drop { + tailf:info "drop packet"; + description "drop packet"; + when "../exceed-action"; + tailf:cli-optional-in-sequence; + tailf:cli-full-command; + type empty; + } + container exceed-transmit { + tailf:cli-no-keyword; + tailf:cli-drop-node-name; + tailf:cli-optional-in-sequence; + tailf:cli-flatten-container; + leaf transmit { + tailf:info "transmit packet"; + description "transmit packet"; + when "../../exceed-action"; + tailf:cli-optional-in-sequence; + type empty; + } + } + } + } + +/// ======================================================================== +/// class-map +/// ======================================================================== + + list class-map { + tailf:info "Configure QoS Class Map"; + description "Configure QoS Class Map"; + tailf:cli-mode-name "config-cmap"; + tailf:cli-suppress-list-no; + tailf:cli-delete-when-empty; + tailf:cli-no-key-completion; + // class-map * + key name; + leaf name { + type string { + tailf:info "WORD;;class-map name"; + } + tailf:cli-disallow-value "type"; + } + // class-map * type inspect + leaf "type" { + tailf:info "type of the class-map"; + description "type of the class-map"; + tailf:cli-prefix-key; + type enumeration { + enum access-control { + tailf:info "access-control specific class-map"; + } + enum appnav { + tailf:info "Configure a APPNAV Class Map"; + } + enum control { + tailf:info "Configure a control policy class-map"; + } + enum inspect { + tailf:info "Configure Firewall Class Map"; + } + enum multicast-flows { + tailf:info "multicast class-maps"; + } + enum stack { + tailf:info "class-map for protocol header stack specification"; + } + enum traffic { + tailf:info "Configure a subscriber policy traffic classmap"; + } + } + } + // class-map * + leaf protocol { + when "../type = 'inspect'"; + tailf:cli-drop-node-name; + tailf:cli-prefix-key; + type enumeration { + enum aol { + tailf:info "Configure CBAC class-map for IM-AOL protocol"; + } + enum edonkey { + tailf:info "eDonkey"; + } + enum fasttrack { + tailf:info "FastTrack Traffic - KaZaA, Morpheus, Grokster..."; + } + enum gnutella { + tailf:info "Gnutella Version2 Traffic - BearShare, Shareeza, " + +"Morpheus ..."; + } + enum http { + tailf:info "Configure CBAC class-map for HTTP protocol"; + } + enum imap { + tailf:info "Configure CBAC class-map for IMAP protocol"; + } + enum kazaa2 { + tailf:info "Kazaa Version 2"; + } + enum msnmsgr { + tailf:info "Configure CBAC class-map for IM-MSN protocol"; + } + enum pop3 { + tailf:info "Configure CBAC class-map for POP3 protocol"; + } + enum smtp { + tailf:info "Configure CBAC class-map for SMTP protocol"; + } + enum sunrpc { + tailf:info "Configure CBAC class-map for RPC protocol"; + } + enum ymsgr { + tailf:info "Configure CBAC class-map for IM-YAHOO protocol"; + } + } + } + // class-map * + leaf prematch { + tailf:cli-no-keyword; + tailf:cli-prefix-key; + tailf:cli-drop-node-name; + type enumeration { + enum match-all { + tailf:info "Logical-AND all matching statements under "+ + "this classmap"; + } + enum match-any { + tailf:info "Logical-OR all matching statements under this "+ + "classmap"; + } + } + mandatory true; + } + // class-map * / description + leaf "description" { + tailf:info "Class-Map description"; + description "Class-Map description"; + tailf:cli-multi-value; + type string { + tailf:info "LINE;;Description of this class-map (up to 200 "+ + "characters)"; + } + } + // class-map * / match + container match { + tailf:info "classification criteria"; + description "classification criteria"; + uses class-map-match-grouping; + uses class-map-appnav-match-grouping; + container not { + tailf:info "Negate this match result"; + description "Negate this match result"; + uses class-map-match-grouping; + uses class-map-appnav-not-match-grouping; + } + } + } + +/// ======================================================================== +/// policy-map +/// ======================================================================== + + list policy-map { + tailf:info "Configure QoS Policy Map"; + description "Configure QoS Policy Map"; + tailf:cli-mode-name "config-pmap"; + tailf:cli-diff-dependency "/ios:native/class-map"; + tailf:cli-diff-dependency "/ios:native/table-map"; + tailf:cli-diff-dependency "/ios:native/mls/qos/aggregate-policer"; + tailf:cli-diff-dependency "/ios:native/policer/aggregate"; + key name; + leaf name { + type string { + tailf:info "WORD;;policy-map name"; + } + tailf:cli-disallow-value + "(type)|(http)|(im)|(imap)|(p2p)|(pop3)|(smtp)|(sunrpc)"; + } + leaf "type" { + tailf:info "type of the policy-map"; + description "type of the policy-map"; + tailf:cli-prefix-key; + type enumeration { + enum access-control { + tailf:info "access-control specific policy-map"; + } + enum appnav { + tailf:info "Configure a APPNAV Policy Map"; + } + enum inspect { + tailf:info "Configure Firewall Policy Map"; + } + enum packet-service { + tailf:info "Configure Packet Service Policy Map"; + } + enum performance-monitor { + tailf:info "Performance monitoring policy-map type"; + } + enum service { + tailf:info "policymap service configuration"; + } + enum service-chain { + tailf:info "Configure Service Chain Policy Map"; + } + } + } + leaf protocol { + when "../type = 'inspect'"; + tailf:cli-drop-node-name; + tailf:cli-prefix-key; + type enumeration { + enum http { + tailf:info "Configure CBAC policy-map for HTTP protocol"; + } + enum im { + tailf:info "Configure CBAC policy-map for IM protocol"; + } + enum imap { + tailf:info "Configure CBAC policy-map for IMAP protocol"; + } + enum p2p { + tailf:info "Configure CBAC policy-map for P2P protocols"; + } + enum pop3 { + tailf:info "Configure CBAC policy-map for POP3 protocol"; + } + enum smtp { + tailf:info "Configure CBAC policy-map for SMTP protocol"; + } + enum sunrpc { + tailf:info "Configure CBAC policy-map for RPC protocol"; + } + } + } + // policy-map * / class * + list class { + tailf:info "policy criteria"; + description "policy criteria"; + tailf:cli-mode-name "config-pmap-c"; + key name; + leaf name { + tailf:cli-disallow-value "type"; + type class-name-type; + } + // policy-map * / class * / type + leaf "type" { + tailf:info "type of the class-map"; + description "type of the class-map"; + tailf:cli-prefix-key; + type enumeration { + enum inspect { + tailf:info "Configure CBAC Class Map"; + } + } + } + leaf insert-before { + tailf:info "Insert the class before a specified class"; + description "Insert the class before a specified class"; + tailf:cli-hide-in-submode; + when "../../type = 'appnav'"; + type string { + tailf:info "WORD;;Insert the class before a specified class"; + } + } + // policy-map * / class * / appnav policy + container appnav-policy { + when "../../type = 'appnav'"; + tailf:cli-drop-node-name; + list distribute { + tailf:info "Distribute action"; + description "Distribute action"; + tailf:cli-suppress-mode; + key service-node-group; + leaf service-node-group { + tailf:info "Distribute to service-node-group"; + description "Distribute to service-node-group"; + tailf:cli-expose-key-name; + type string { + tailf:info "WORD;;service-node-group name"; + } + } + leaf insert-before { + tailf:info "Insert before specific node"; + description "Insert before specific node"; + tailf:cli-optional-in-sequence; + type string { + tailf:info "WORD;;service-node-group name"; + } + } + } + leaf monitor-load { + tailf:info "Monitor AO"; + description "Monitor AO"; + when "../distribute"; + type enumeration { + enum MS-port-mapper { + tailf:info "Monitor Microsoft Endpoint Port Mapper load"; + } + enum cifs { + tailf:info "Monitor CIFS Accelerator load"; + } + enum http { + tailf:info "Monitor HTTP Accelerator load"; + } + enum ica { + tailf:info "Monitor ICA Accelerator load"; + } + enum mapi { + tailf:info "Monitor MAPI Accelerator load"; + } + enum nfs { + tailf:info "Monitor NFS Accelerator load"; + } + enum ssl { + tailf:info "Monitor SSL accelerator load"; + } + enum video { + tailf:info "Monitor Video Accelerator load"; + } + } + } + leaf pass-through { + tailf:info "pass-through action"; + description "pass-through action"; + type empty; + } + } + // policy-map * / class * / inspect policy + container policy { + when "../../type = 'inspect'"; + tailf:cli-drop-node-name; + tailf:cli-sequence-commands { + tailf:cli-reset-siblings; + } + leaf action { + tailf:cli-drop-node-name; + tailf:cli-remove-before-change; + type enumeration { + enum cxsc { + tailf:info "CXSC Inspection"; + } + enum drop { + tailf:info "Drop the packet"; + } + enum inspect { + tailf:info "Context-based Access Control Engine"; + } + enum pass { + tailf:info "Pass the packet"; + } + enum service-policy { + tailf:info "Deep Packet Inspection Engine"; + } + } + } + leaf log { + tailf:info "Send logging message for drop or pass"; + description "Send logging message for drop or pass"; + when "../action = 'drop'or ../action = 'pass'"; + type empty; + } + leaf parameter-map { + tailf:cli-drop-node-name; + when "../action = 'inspect' or ../action = 'cxsc'"; + type string; + tailf:non-strict-leafref { + path "/ios:native/parameter-map/name"; + } + } + container dpi { + tailf:cli-drop-node-name; + when "../action = 'service-policy'"; + tailf:cli-sequence-commands; + tailf:cli-compact-syntax; + leaf type { + tailf:cli-drop-node-name; + type enumeration { + enum gtpv0 { + tailf:info "GTPv0 DPI"; + } + enum gtpv1 { + tailf:info "GTPv1 DPI"; + } + enum imap { + tailf:info "IMAP DPI"; + } + enum pop3 { + tailf:info "POP3 DPI"; + } + enum smtp { + tailf:info "SMTP DPI"; + } + enum sunrpc { + tailf:info "RPC DPI"; + } + } + } + leaf policy-map { + tailf:cli-drop-node-name; + type string { + tailf:info "WORD;;DPI policy-map name"; + } + } + } + } + // policy-map * / class * / performance-monitor policy + container pm-policy { + when "../../type = 'performance-monitor'"; + tailf:cli-drop-node-name; + container flow { + tailf:info "Flow subcommands"; + description "Flow subcommands"; + leaf monitor { + tailf:info "Apply a Flow Monitor"; + description "Apply a Flow Monitor"; + type string { + tailf:info "WORD;;Flow monitor name"; + } + } + } + container monitor { + tailf:info "Monitor related parameters"; + description "Monitor related parameters"; + container metric { + tailf:info "Monitor metric"; + description "Monitor metric"; + container rtp { + tailf:info "RTP metrics parameters"; + description "RTP metrics parameters"; + tailf:cli-add-mode; + tailf:cli-mode-name "config-pmap-c-mrtp"; + list clock-rate { + tailf:info "RTP timestamp field's sampling frequency"; + description "RTP timestamp field's sampling frequency"; + tailf:cli-suppress-mode; + tailf:cli-sequence-commands; + tailf:cli-compact-syntax; + key number; + leaf number { + type union { + type uint8 { + tailf:info "<0-127>;;payload type number"; + range "0..127"; + } + type enumeration { + enum celb { + tailf:info "CELB(25)"; + } + enum cn { + tailf:info "CN(13)"; + } + enum default { + tailf:info "Change the default clock rate for all the dynamic payload type"; + } + enum dvi4 { + tailf:info "DVI4 RFC-3551 8000Hz(5)"; + } + enum dvi4-2 { + tailf:info "DVI4 RFC-3551 16000Hz(6)"; + } + enum dvi4-3 { + tailf:info "DVI4 Dipol 11025Hz(16)"; + } + enum dvi4-4 { + tailf:info "DVI4 Dipol 22050Hz(17)"; + } + enum g722 { + tailf:info "G722(9)"; + } + enum g723 { + tailf:info "G723(4)"; + } + enum g728 { + tailf:info "G728(15)"; + } + enum g729 { + tailf:info "G729(18)"; + } + enum gsm { + tailf:info "GSM(3)"; + } + enum h261 { + tailf:info "H261(31)"; + } + enum h263 { + tailf:info "H263(34)"; + } + enum jpeg { + tailf:info "JPEG(26)"; + } + enum l16 { + tailf:info "L16 channel 1(11)"; + } + enum l16-2 { + tailf:info "L16 channel 2(10)"; + } + enum lpc { + tailf:info "LPC(7)"; + } + enum mp2t { + tailf:info "MP2T(33)"; + } + enum mpa { + tailf:info "MPA(14)"; + } + enum mpv { + tailf:info "MPV(32)"; + } + enum nv { + tailf:info "NV(28)"; + } + enum pcma { + tailf:info "PCMA(8)"; + } + enum pcmu { + tailf:info "PCMU(0)"; + } + enum qcelp { + tailf:info "QCELP(12)"; + } + } + } + } + leaf frequency { + tailf:cli-drop-node-name; + type uint32 { + tailf:info "<1000-192000>;;frequency in Hz"; + range "1000..192000"; + } + } + } + } + } + } + list react { + tailf:info "Configure threshold crossing actions"; + description "Configure threshold crossing actions"; + tailf:cli-mode-name "config-pmap-c-react"; + key id; + leaf id { + type uint16 { + tailf:info "<1-65535> React instance id"; + } + } + leaf mode { + tailf:cli-drop-node-name; + tailf:cli-hide-in-submode; + type enumeration { + enum media-stop { + tailf:info "Media stream stopped"; + } + enum mrv { + tailf:info "Variation in packet rate from configured expected rate"; + } + enum rtp-jitter-average { + tailf:info "Mean jitter for the RTP stream"; + } + enum transport-packets-lost-rate { + tailf:info "Ratio of lost packets to total reaceived packets"; + } + } + } + leaf description { + tailf:info "Description for threshold crossing action instance"; + description "Description for the instance"; + tailf:cli-multi-value; + type string; + } + container action { + tailf:info "Config react action"; + description "Config react action"; + leaf snmp { + tailf:info "SNMP is notified of the event"; + description "SNMP is notified of the event"; + tailf:cli-full-command; + type empty; + } + leaf syslog { + tailf:info "The threshold-crossing event is logged to syslog"; + description "The threshold-crossing event is logged to syslog"; + tailf:cli-full-command; + type empty; + } + } + container alarm { + tailf:info "Config react alarm"; + description "Config react alarm"; + leaf severity { + tailf:info "Alarm severity - default level none"; + description "Alarm severity - default level none"; + type enumeration { + enum alert { + tailf:info "TCA severity level critical (severity = 2)"; + } + enum critical { + tailf:info "TCA severity level major (severity = 3)"; + } + enum emergency { + tailf:info "TCA severity level critical (severity = 1)"; + } + enum error { + tailf:info "TCA severity level minor (severity = 4)"; + } + enum info { + tailf:info "TCA severity level default (severity = 5)"; + } + } + } + container type { + tailf:info "Alarm raised type - for each flow or a group"; + description "Alarm raised type - for each flow or a group"; + leaf discrete { + tailf:info "Alert for each flow within the class"; + description "Alert for each flow within the class"; + tailf:cli-full-command; + type empty; + } + container grouped { + tailf:info "Alert if more than one flow cross the threshold"; + description "Alert if more than one flow cross the threshold"; + leaf count { + tailf:info "Number of flows in the group cross the threshold"; + description "Number of flows in the group cross the threshold"; + tailf:cli-full-command; + type uint16 { + tailf:info "<1-65535>;;Number of flows"; + } + } + leaf percent { + tailf:info "Percent of flows in the group cross the threshold"; + description "Percent of flows in the group cross the threshold"; + tailf:cli-full-command; + type uint8 { + tailf:info "<1-100>;;Percent of flows"; + range "1..100"; + } + } + } + } + } + container threshold { + tailf:info "Config react threshold"; + description "Config react threshold"; + container value { + tailf:info "Range of percentage loss that would trigger the alarm"; + description "Range of percentage loss that would trigger the alarm"; + leaf ge { + tailf:info "greater and equal to"; + description "greater and equal to"; + tailf:cli-full-command; + type string { + tailf:info "WORD;;rtp lost fraction threshold 0.05 - 100 (% in precision of 0.01)"; + } + } + leaf gt { + tailf:info "greater than"; + description "greater than"; + tailf:cli-full-command; + type string { + tailf:info "WORD;;rtp lost fraction threshold 0.05 - 100 (% in precision of 0.01)"; + } + } + leaf le { + tailf:info "less and equal to"; + description "less and equal to"; + tailf:cli-full-command; + type string { + tailf:info "WORD;;rtp lost fraction threshold 0.05 - 100 (% in precision of 0.01)"; + } + } + leaf lt { + tailf:info "less than"; + description "less than"; + tailf:cli-full-command; + type string { + tailf:info "WORD;;rtp lost fraction threshold 0.05 - 100 (% in precision of 0.01)"; + } + } + container range { + tailf:info "threshold within the range of"; + description "threshold within the range of"; + tailf:cli-sequence-commands; + tailf:cli-compact-syntax; + leaf low { + tailf:cli-drop-node-name; + type string { + tailf:info "WORD;;rtp lost fraction threshold 0.05 - 100 (% in precision of 0.01)"; + } + } + leaf high { + tailf:cli-drop-node-name; + type string { + tailf:info "WORD;;rtp lost fraction threshold 0.05 - 100 (% in precision of 0.01)"; + } + } + } + } + } + } + } + // policy-map * / class * / inspect-police + container inspect-police { + when "../policy/action = 'inspect'"; + tailf:cli-drop-node-name; + container police { + tailf:info "Police"; + description "Police"; + tailf:cli-sequence-commands { + tailf:cli-reset-siblings; + } + tailf:cli-compact-syntax; + leaf rate { + tailf:info "Specify police rate"; + description "Specify police rate"; + type uint32 { + tailf:info "<8000-2000000000>;;Rate value in bps"; + range "8000..2000000000"; + } + } + leaf burst { + tailf:info "Specify 'burst' parameter"; + description "Specify 'burst' parameter"; + type uint32 { + tailf:info "<1000-512000000>;;Burst value in bytes"; + range "1000..512000000"; + } + } + } + } + list action-list { + tailf:cli-drop-node-name; + tailf:cli-suppress-mode; + key action-type; + ordered-by user; + leaf action-type { + type policy-action-type; + } + choice action-param { + case bandwidth-case { + // policy-map * / class * / bandwidth + container bandwidth { + //tailf:info "Bandwidth"; + tailf:cli-drop-node-name; + when "../action-type = 'bandwidth'"; + leaf bits { + tailf:cli-drop-node-name; + type uint32 { + range "8..2000000"; + tailf:info "<8-2000000>;;Kilo Bits per second"; + } + } + leaf percent { + tailf:info "% of total Bandwidth"; + description "% of total Bandwidth"; + type percentage-type; + } + container remaining { + tailf:info "% of the remaining bandwidth"; + description "% of the remaining bandwidth"; + leaf percent { + tailf:info "% of the remaining bandwidth"; + description "% of the remaining bandwidth"; + type percentage-type; + } + leaf ratio { + tailf:info "ratio for sharing excess bandwidth"; + description "ratio for sharing excess bandwidth"; + type uint16 { + tailf:info "<1-65536>;;Ratio"; + } + } + } + } + } + case compression-case { + // policy-map * / class * / compression + container compression { + //tailf:info "Activate Compression"; + tailf:cli-drop-node-name; + //presence "Activate Compression"; + when "../action-type = 'compression'"; + container header { + tailf:info "configure header compression"; + description "configure header compression"; + presence "configure header compression"; + leaf ip { + tailf:info "configure ip header compression"; + description "configure ip header compression"; + type enumeration { + enum rtp { + tailf:code-name "header_rtp"; + tailf:info "configure rtp header compression"; + } + enum tcp { + tailf:info "configure tcp header compression"; + } + } + } + } + } + } + //case drop-case { + // policy-map * / class * / drop + //leaf drop { + //tailf:info "Drop all packets"; + // tailf:cli-full-command; + //type empty; + //} + //} + case estimate-case { + // policy-map * / class * / estimate + container estimate { + //tailf:info "estimate resources required for this class"; + tailf:cli-drop-node-name; + when "../action-type = 'estimate'"; + container bandwidth { + presence "bandwidth required to service this class"; + tailf:info "bandwidth required to service this class"; + description "bandwidth required to service this class"; + tailf:cli-sequence-commands; + tailf:cli-compact-syntax; + container delay-one-in { + tailf:info "specify QoS target delay"; + description "specify QoS target delay"; + tailf:cli-compact-syntax; + tailf:cli-sequence-commands; + leaf doi { + tailf:cli-drop-node-name; + tailf:cli-incomplete-command; + type uint32 { + range "50..1000000"; + tailf:info "<50-1000000>;;delay one packet "+ + "of N"; + } + } + leaf milliseconds { + type uint32 { + range "8..1000" { + tailf:info "<8-1000>;;worst-case "+ + "milliseconds of delay"; + } + } + } + } + leaf drop-one-in { + tailf:info "specify QoS target loss rate"; + description "specify QoS target loss rate"; + type uint32 { + tailf:info "<50-1000000>;;drop one packet of N"; + } + } + } + } + } + case forward-case { + //policy-map * / class * / forward service-path + container forward { + //tailf:info "forward service-path action"; + tailf:cli-reset-container; + tailf:cli-drop-node-name; + when "../action-type = 'forward'"; + list service-path { + tailf:info "Service Path Entries"; + description "Service Path Entries"; + tailf:cli-suppress-mode; + key "service-path-id"; + leaf service-path-id { + type uint32 { + range "0..16777215"; + tailf:info "<0-16777215>;;Service Path ID"; + } + } + leaf service-index { + tailf:info "Service Index"; + description "Service Index"; + type uint8 { + range "2..255"; + tailf:info "<2-255>;;Service Index ID"; + } + } + } + } + } + case fair-queue-case { + // policy-map * / class * / fair-queue + // class-default: fair-queue [number-of-dynamic-queues] + // DWFQ: fair-queue + // policy-map: fair-queue [queue-limit queue-value] + // NOT SUPPORTED: + // air-queue [congestive-discard-threshold [dynamic-q [reservable-q]]] + container fair-queue { + //tailf:info "Enable Flow-based Fair Queuing in this Class"; + tailf:cli-reset-container; + tailf:cli-drop-node-name; + when "../action-type = 'fair-queue'"; + leaf dynamic-queues { + tailf:cli-drop-node-name; + tailf:cli-full-command; + type uint32 { + range "16|32|64|128|256|512|1024|2048|4096" { + tailf:info "<16-4096>;;Number Dynamic Conversation "+ + "Queues"; + } + } + } + leaf queue-limit { + tailf:info "per flow queue limit"; + description "per flow queue limit"; + tailf:cli-full-command; + type uint16 { + tailf:info "<1-32768>;;packets"; + range "1..32768"; + } + } + } + } + case netflow-sampler-case { + // policy-map * / class * / netflow-sampler + leaf netflow-sampler { + //tailf:info "NetFlow action"; + tailf:cli-drop-node-name; + tailf:cli-full-command; + when "../action-type = 'netflow-sampler'"; + // should be leafref to sampler + type string { + tailf:info "WORD;;Name of the flow sampler"; + } + } + } + case police-case { + // policy-map * / class * / police ? + choice police-choice { + // policy-map * / class * / police aggregate + case police-aggregate-case { + container police-aggregate { + tailf:cli-no-keyword; + tailf:cli-drop-node-name; + container police { + //tailf:info "Police"; + tailf:cli-drop-node-name; + when "../../action-type = 'police'" { + tailf:dependency "../../action-type"; + } + leaf aggregate { + tailf:info "Choose aggregate policer for current class"; + description "Choose aggregate policer for current class"; + type string { + tailf:info "WORD;;enter aggregate-policer name"; + } + } + } + } + } + // police (policy-map) + // police cir [[bc ] [be ]] + // [pir [be ]] ACTIONS + // NOTE: cir, bc & be keywords are mandatory in this model. + // Java code will add missing cir,bc and be in show(). + case police-policy-map-case { + container police-policy-map { + tailf:cli-no-keyword; + tailf:cli-drop-node-name; + container police { + tailf:cli-add-mode; + tailf:cli-mode-name "config-pmap-c-police"; + tailf:cli-flatten-container; + tailf:cli-sequence-commands { + tailf:cli-reset-siblings; + } + tailf:cli-drop-node-name; + when "../../action-type = 'police'" { + tailf:dependency "../../action-type"; + } + // cir + leaf cir { + tailf:info "Committed information rate"; + description "Committed information rate"; + tailf:cli-hide-in-submode; + type police-bps-type; + } + // [bc ] + leaf bc { + tailf:info "Conform burst"; + description "Conform burst"; + tailf:cli-optional-in-sequence; + tailf:cli-hide-in-submode; + type police-burst-type; + } + // [be ] + leaf be { + when "../bc"; + tailf:info "Excess burst"; + description "Excess burst"; + tailf:cli-optional-in-sequence; + tailf:cli-hide-in-submode; + type police-burst-type; + } + // [pir [be ]] + leaf pir { + tailf:info "Peak Information Rate"; + description "Peak Information Rate"; + tailf:cli-optional-in-sequence; + tailf:cli-hide-in-submode; + type police-bps-type; + } + container pir-be { + when "../pir"; + tailf:cli-no-keyword; + tailf:cli-drop-node-name; + tailf:cli-optional-in-sequence; + tailf:cli-flatten-container; + tailf:cli-hide-in-submode; + leaf be { + tailf:info "Excess burst"; + description "Excess burst"; + type police-burst-type; + } + } + // conform-action | exceed-action | violate-action + uses police-action-grouping; + } + } + } + // police cir percent (combo of percent & policy-map versions) + // police cir percent + // [bc] ms] [be [ ms] + // [pir percent [be ms]] ACTIONS + case police-cir-percent-case { + container police-cir-percent { + tailf:cli-no-keyword; + tailf:cli-drop-node-name; + container police { + tailf:cli-drop-node-name; + when "../../action-type = 'police'" { + tailf:dependency "../../action-type"; + } + container cir { + tailf:info "Committed information rate"; + description "Committed information rate"; + container percent { + tailf:info "% of interface bandwidth for Committed "+ + "information rate"; + description "% of interface bandwidth for Committed "+ + "information rate"; + tailf:cli-add-mode; + tailf:cli-mode-name "config-pmap-c-police"; + tailf:cli-incomplete-command; + tailf:cli-flatten-container; + tailf:cli-sequence-commands { + tailf:cli-reset-siblings; + } + // percent + leaf percentage { + tailf:cli-drop-node-name; + tailf:cli-hide-in-submode; + type percentage-type; + } + // [bc ms] + leaf bc { + tailf:info "Conform burst"; + description "Conform burst"; + tailf:cli-optional-in-sequence; + tailf:cli-hide-in-submode; + type uint16 { + tailf:info "<1-2000>;;Burst ms"; + } + } + container bc-ms { + when "../bc"; + tailf:cli-no-keyword; + tailf:cli-drop-node-name; + tailf:cli-optional-in-sequence; + tailf:cli-hide-in-submode; + tailf:cli-compact-syntax; + tailf:cli-flatten-container; + leaf ms { + tailf:info "Milli seconds"; + description "Milli seconds"; + tailf:cli-no-keyword; + type empty; + } + } + // [be [ ms] + leaf be { + when "../bc-ms/ms" { + tailf:dependency "../bc-ms/ms"; + } + tailf:info "Excess burst"; + tailf:cli-optional-in-sequence; + tailf:cli-hide-in-submode; + type uint16 { + tailf:info "<1-2000>;;Burst ms"; + } + } + container be-ms { + when "../be"; + tailf:cli-no-keyword; + tailf:cli-drop-node-name; + tailf:cli-hide-in-submode; + tailf:cli-compact-syntax; + tailf:cli-flatten-container; + leaf ms { + tailf:info "Milli seconds"; + description "Milli seconds"; + tailf:cli-no-keyword; + type empty; + } + } + // [pir percent [be ms]] + container pir { + tailf:info "Peak Information Rate"; + description "Peak Information Rate"; + tailf:cli-compact-syntax; + tailf:cli-flatten-container; + tailf:cli-hide-in-submode; + tailf:cli-optional-in-sequence; + leaf percent { + tailf:info "% of interface bandwidth for Peak "+ + "Information Rate"; + description "% of interface bandwidth for Peak "+ + "Information Rate"; + type percentage-type; + } + } + container pir-be { + when "../pir"; + tailf:cli-no-keyword; + tailf:cli-drop-node-name; + tailf:cli-optional-in-sequence; + tailf:cli-flatten-container; + tailf:cli-hide-in-submode; + leaf be { + tailf:info "Excess burst"; + description "Excess burst"; + type uint16 { + tailf:info "<1-2000>;;Burst ms"; + } + } + } + container pir-be-ms { + when "../pir-be/be" { + tailf:dependency "../pir-be/be"; + } + tailf:cli-no-keyword; + tailf:cli-drop-node-name; + tailf:cli-optional-in-sequence; + tailf:cli-hide-in-submode; + tailf:cli-flatten-container; + leaf ms { + tailf:info "Milli seconds"; + description "Milli seconds"; + tailf:cli-no-keyword; + type empty; + } + } + // conform-action | exceed-action | violate-action + uses police-action-grouping; + } + } + } + } + } + // police rate (control-plane) + // police rate [burst ] + // [peak-rate ] + // [peak-burst ] + // [conform-action ] + case police-rate-unit-case { + container police-rate-unit { + tailf:cli-no-keyword; + tailf:cli-drop-node-name; + container police { + tailf:cli-drop-node-name; + when "../../action-type = 'police'" { + tailf:dependency "../../action-type"; + } + container rate { + tailf:info "Specify police rate"; + description "Specify police rate"; + tailf:cli-add-mode; + tailf:cli-mode-name "config-pmap-c-police"; + tailf:cli-flatten-container; + tailf:cli-sequence-commands { + tailf:cli-reset-siblings; + } + // + leaf "units" { + tailf:cli-drop-node-name; + tailf:cli-hide-in-submode; + type uint64 { + tailf:info "<1-2000000000>;;Rate value in the range "+ + "8000-2,000,000,000 bps or 1-2,000,000 pps"; + } + } + // + leaf xps { + tailf:cli-no-keyword; + tailf:cli-drop-node-name; + tailf:cli-hide-in-submode; + type police-pps-bps-type; + } + // [burst ] + container burst { + tailf:info "Specify 'burst' parameter"; + description "Specify 'burst' parameter"; + tailf:cli-optional-in-sequence; + tailf:cli-compact-syntax; + tailf:cli-hide-in-submode; + tailf:cli-flatten-container; + tailf:cli-sequence-commands; + leaf burst-value { + tailf:cli-no-keyword; + tailf:cli-drop-node-name; + tailf:cli-incomplete-command; + type uint32 { + tailf:info "<1-512000000>;;Burst value in "+ + "packets/bytes"; + } + } + leaf burst-type { + tailf:cli-no-keyword; + tailf:cli-drop-node-name; + tailf:cli-hide-in-submode; + type police-packets-bytes-type; + } + } + // [peak-rate ] + container peak-rate { + tailf:info "Specify peak rate"; + description "Specify peak rate"; + tailf:cli-optional-in-sequence; + tailf:cli-compact-syntax; + tailf:cli-flatten-container; + tailf:cli-hide-in-submode; + tailf:cli-sequence-commands; + leaf peak-rate-value { + tailf:cli-no-keyword; + tailf:cli-drop-node-name; + tailf:cli-incomplete-command; + type uint32 { + tailf:info "<1-512000000>;;Peak-rate value in "+ + "packets or bytes per second"; + range "1..512000000"; + } + } + leaf xps { + tailf:cli-no-keyword; + tailf:cli-drop-node-name; + type police-pps-bps-type; + } + } + // [peak-burst ] + container peak-burst { + tailf:info "Specify 'peak-burst' parameter for peak-rate"; + description "Specify 'peak-burst' parameter for peak-rate"; + tailf:cli-optional-in-sequence; + tailf:cli-compact-syntax; + tailf:cli-flatten-container; + tailf:cli-hide-in-submode; + tailf:cli-sequence-commands; + leaf burst-value { + tailf:cli-no-keyword; + tailf:cli-drop-node-name; + tailf:cli-incomplete-command; + type uint32 { + tailf:info "<1-512000000>;;Burst value in "+ + "packets/bytes"; + } + } + leaf burst-type { + tailf:cli-no-keyword; + tailf:cli-drop-node-name; + type police-packets-bytes-type; + } + } + // conform-action | exceed-action | violate-action + uses police-action-grouping; + } + } + } + } + // police rate percent (control-plane) + // police rate percent [burst ms] + // [peak-rate percent ] [peak-burst ms] + case police-rate-percent-case { + container police-rate-percent { + tailf:cli-no-keyword; + tailf:cli-drop-node-name; + container police { + tailf:cli-drop-node-name; + when "../../action-type = 'police'" { + tailf:dependency "../../action-type"; + } + container rate { + tailf:info "Specify police rate"; + description "Specify police rate"; + container percent { + tailf:info "% of interface bandwidth for rate"; + description "% of interface bandwidth for rate"; + tailf:cli-add-mode; + tailf:cli-mode-name "config-pmap-c-police"; + tailf:cli-flatten-container; + tailf:cli-sequence-commands { + tailf:cli-reset-siblings; + } + // + leaf percentage { + tailf:cli-drop-node-name; + tailf:cli-hide-in-submode; + type percentage-type; + } + // [burst ms] + leaf burst { + tailf:info "Specify 'burst' parameter"; + description "Specify 'burst' parameter"; + tailf:cli-optional-in-sequence; + tailf:cli-hide-in-submode; + type uint16 { + tailf:info "<1-2000>;;Burst value in milliseconds"; + } + } + leaf ms { + when "../burst"; + tailf:info "Treat 'burst' value in milliseconds"; + description "Treat 'burst' value in milliseconds"; + tailf:cli-hide-in-submode; + type empty; + } + // [peak-rate percent ] + container peak-rate { + tailf:info "Specify peak rate"; + description "Specify peak rate"; + tailf:cli-hide-in-submode; + tailf:cli-optional-in-sequence; + tailf:cli-flatten-container; + leaf percent { + tailf:info "% of interface bandwidth for peak-rate"; + description "% of interface bandwidth for peak-rate"; + type percentage-type; + } + } + // [peak-burst ms] + leaf peak-burst { + tailf:info "Specify 'peak-burst' parameter for "+ + "'peak-rate'"; + description "Specify 'peak-burst' parameter for "+ + "'peak-rate'"; + tailf:cli-hide-in-submode; + tailf:cli-optional-in-sequence; + type uint16 { + tailf:info "<1-2000>;;Peak burst value in "+ + "milliseconds"; + } + } + container peak-burst-ms { + when "../peak-burst"; + tailf:cli-no-keyword; + tailf:cli-drop-node-name; + tailf:cli-optional-in-sequence; + tailf:cli-hide-in-submode; + tailf:cli-flatten-container; + leaf ms { + tailf:info "Milli seconds"; + description "Milli seconds"; + tailf:cli-no-keyword; + type empty; + } + } + // conform-action | exceed-action | violate-action + uses police-action-grouping; + } + } + } + } + } + // police rate pdp + // police rate pdp [burst ] + // [peak-rate pdp [peak-burst ]] ACTIONS + case police-rate-pdp-case { + container police-rate-pdp { + tailf:cli-no-keyword; + tailf:cli-drop-node-name; + container police { + tailf:cli-drop-node-name; + when "../../action-type = 'police'" { + tailf:dependency "../../action-type"; + } + container rate { + tailf:info "Specify police rate"; + description "Specify police rate"; + container pdp { + tailf:info "% of interface bandwidth for rate"; + description "% of interface bandwidth for rate"; + tailf:cli-add-mode; + tailf:cli-mode-name "config-pmap-c-police"; + tailf:cli-flatten-container; + tailf:cli-sequence-commands { + tailf:cli-reset-siblings; + } + // [burst ] + leaf burst { + tailf:info "Conform burst"; + description "Conform burst"; + tailf:cli-hide-in-submode; + tailf:cli-optional-in-sequence; + type police-burst-type; + } + // [peak-rate pdp [peak-burst ]] + leaf peak-rate { + tailf:info "Specify peak rate"; + description "Specify peak rate"; + tailf:cli-hide-in-submode; + tailf:cli-optional-in-sequence; + type enumeration { + enum "pdp" { + } + } + } + leaf peak-burst { + when "../peak-rate"; + tailf:info "Specify 'peak-burst' parameter for "+ + "'peak-rate'"; + description "Specify 'peak-burst' parameter for "+ + "'peak-rate'"; + tailf:cli-hide-in-submode; + tailf:cli-optional-in-sequence; + type police-burst-type; + } + // conform-action | exceed-action | violate-action + uses police-action-grouping; + } + } + } + } + } + // police target-bit-rate + case police-target-bitrate-case { + container police-target-bitrate { + tailf:cli-no-keyword; + tailf:cli-drop-node-name; + container police { + tailf:cli-drop-node-name; + when "../../action-type = 'police'" { + tailf:dependency "../../action-type"; + } + tailf:cli-add-mode; + tailf:cli-mode-name "config-pmap-c-police"; + leaf bit-rate { + tailf:info "Target bit rate (bits per second) (postfix k, m, g optional), + decimal point allowed"; + description "Target bit rate (bits per second) (postfix k, m, g optional), + decimal point allowed"; + tailf:cli-no-keyword; + tailf:cli-drop-node-name; + tailf:cli-hide-in-submode; + type uint64 { + tailf:info "<8000-10000000000>;;Target bit rate (bits per second)"; + range "8000..10000000000"; + } + } + // conform-action | exceed-action | violate-action + uses police-action-grouping; + } + } + } + // police flow (policy-map) + // police flow [mask {dest-only | full-flow | src-only}] + // [] ACTIONS + case police-flow-case { + container police-flow { + tailf:cli-no-keyword; + tailf:cli-drop-node-name; + container police { + tailf:cli-drop-node-name; + when "../../action-type = 'police'" { + tailf:dependency "../../action-type"; + } + container flow { + tailf:info "police each flow"; + description "police each flow"; + tailf:cli-add-mode; + tailf:cli-mode-name "config-pmap-c-police"; + tailf:cli-flatten-container; + tailf:cli-sequence-commands { + tailf:cli-reset-siblings; + } + // [mask {dest-only | full-flow | src-only}] + leaf mask { + tailf:info "flow mask to be used for policing"; + description "flow mask to be used for policing"; + tailf:cli-hide-in-submode; + tailf:cli-optional-in-sequence; + type enumeration { + enum dest-only { + tailf:info "destination-address only flow mask"; + } + enum full-flow { + tailf:info "full flow mask"; + } + enum src-only { + tailf:info "source-address only flow mask"; + } + } + } + // + leaf bps { + tailf:cli-drop-node-name; + tailf:cli-hide-in-submode; + type police-bps-type; + } + // [] + leaf burst-normal { + when "../bps"; + tailf:cli-drop-node-name; + tailf:cli-hide-in-submode; + tailf:cli-optional-in-sequence; + type police-burst-type; + } + // conform-action | exceed-action | violate-action + uses police-action-grouping; + } + } + } + } + // police (Catalyst 4500) + // police bps byte ACTIONS + case police-catalyst-case { + container police-catalyst { + tailf:cli-no-keyword; + tailf:cli-drop-node-name; + container police { + tailf:cli-add-mode; + tailf:cli-mode-name "config-pmap-c-police"; + tailf:cli-flatten-container; + tailf:cli-drop-node-name; + when "../../action-type = 'police'" { + tailf:dependency "../../action-type"; + } + tailf:cli-sequence-commands { + tailf:cli-reset-siblings; + } + // bps + leaf bps-value { + tailf:cli-no-keyword; + tailf:cli-drop-node-name; + tailf:cli-hide-in-submode; + tailf:cli-incomplete-command; + type string { + tailf:info "<32000-32000000000>;;Rate in bits per second "+ + "(postfix k, m, g optional; decimal point allowed)"; + } + } + leaf bps { + tailf:cli-hide-in-submode; + tailf:cli-incomplete-command; + type empty; + } + // byte + leaf byte-value { + tailf:cli-no-keyword; + tailf:cli-drop-node-name; + tailf:cli-hide-in-submode; + tailf:cli-incomplete-command; + type string { + tailf:info "<32000-32000000000>;;(postfix k, m, g "+ + "optional; decimal point allowed)"; + } + } + leaf byte { + tailf:cli-hide-in-submode; + type empty; + } + // conform-action | exceed-action | violate-action + container actions { + tailf:cli-no-keyword; + tailf:cli-break-sequence-commands; + tailf:cli-drop-node-name; + tailf:cli-flatten-container; + tailf:cli-hide-in-submode; + // policy-map * / class * / police ? / conform-action + uses police-conform-action-grouping; + // policy-map * / class * / police ? / exceed-action + uses police-exceed-action-grouping; + // policy-map * / class * / police ? / violate-action + uses police-violate-action-grouping; + } + } + } + } + // police (Catalyst C3550) + // police exceed-action {drop | policed-dscp-transmit}] + case police-switch-case { + container police-switch { + tailf:cli-no-keyword; + tailf:cli-drop-node-name; + container police { + tailf:cli-compact-syntax; + tailf:cli-drop-node-name; + when "../../action-type = 'police'" { + tailf:dependency "../../action-type"; + } + tailf:cli-sequence-commands { + tailf:cli-reset-siblings; + } + // + leaf cir { + tailf:cli-incomplete-command; + tailf:cli-drop-node-name; + type uint32 { + tailf:info "<8000-1000000000>;;Bits per second"; + range "8000..1000000000"; + } + } + // + leaf bc { + tailf:cli-drop-node-name; + type uint32 { + tailf:info "<8000-2000000>;;Normal burst bytes"; + range "8000..2000000"; + } + } + // exceed-action + leaf exceed-action { + tailf:info "action when rate is exceeded"; + description "action when rate is exceeded"; + type enumeration { + enum drop { + tailf:info "drop packet"; + } + enum policed-dscp-transmit { + tailf:info "change dscp per policed-dscp map and send it"; + } + } + } + } + } + } + } + } + case priority-case { + // policy-map * / class * / priority + container priority { + //tailf:info "Strict Scheduling Priority for this Class"; + tailf:cli-compact-syntax; + tailf:cli-sequence-commands; + tailf:cli-drop-node-name; + when "../action-type = 'priority'"; + leaf level { + tailf:info "Multi-Level Priority Queue"; + description "Multi-Level Priority Queue"; + tailf:cli-optional-in-sequence; + type uint8 { + tailf:info "<1-2>;;Multi-Level Priority Queue"; + range "1..2"; + } + } + choice priority-type { + leaf kilo-bits { + tailf:cli-drop-node-name; + type uint32 { + range "8..2000000"; + tailf:info "<8-2000000>;;Kilo Bits per second"; + } + } + leaf percent { + tailf:info "% of total bandwidth"; + description "% of total bandwidth"; + type uint16 { + range "1..100"; + tailf:info "<1-100>;;percentage"; + } + } + } + leaf burst { + tailf:cli-drop-node-name; + type uint32 { + tailf:info "<32-64000000>;;Burst in bytes"; + range "32..64000000"; + } + } + } + } + case queue-buffers-case { + // policy-map * / class * / queue-buffers + container queue-buffers { + tailf:cli-drop-node-name; + when "../action-type = 'queue-buffers'"; + leaf ratio { + tailf:info "Relative buffer size for queue"; + description "Relative buffer size for queue"; + type uint8 { + tailf:info "<0-100>;;Queue-buffers ratio limit"; + range "0..100"; + } + } + } + } + case queue-limit-case { + // policy-map * / class * / queue-limit + container queue-limit { + //tailf:info "Queue Max Threshold for Tail Drop"; + tailf:cli-compact-syntax; + tailf:cli-sequence-commands { + tailf:cli-reset-siblings; + } + tailf:cli-drop-node-name; + when "../action-type = 'queue-limit'"; + leaf queue-limit-value { + tailf:cli-drop-node-name; + type uint32 { + tailf:info "<1-8192000> in bytes, <1-3400> in ms, "+ + "<1-32768> in packets by default"; + range "1..8192000"; + } + } + leaf queue-limit-type { + tailf:cli-drop-node-name; + type enumeration { + enum bytes { + tailf:info "in bytes"; + } + enum ms { + tailf:info "in milliseconds"; + } + enum packets { + tailf:info "in packets"; + } + enum us { + tailf:info "in microseconds"; + } + } + } + } + container queue-limit-dscp { + //tailf:info "Queue Max Threshold for Tail Drop"; + tailf:cli-compact-syntax; + tailf:cli-drop-node-name; + when "../action-type = 'queue-limit'"; + leaf dscp { + tailf:info "parameters for each dscp value"; + description "parameters for each dscp value"; + type empty; + } + leaf values { + tailf:info "dscp values"; + description "dscp values"; + type empty; + } + leaf-list sdcp-val { + tailf:cli-drop-node-name; + type dscp-type; + } + leaf percent { + tailf:info "% of threshold"; + description "% of threshold"; + type uint8 { + tailf:info "<0-100>;;% of threshold"; + range "0..100"; + } + } + } + } + case random-detect { + // policy-map * / class * / random-detect + container random-detect { + //tailf:info "Enable Random Early Detection as drop policy"; + //presence true; + tailf:cli-drop-node-name; + when "../action-type = 'random-detect'"; + container aggregate { + tailf:info "aggregate subclasses"; + description "aggregate subclasses"; + tailf:cli-compact-syntax; + tailf:cli-sequence-commands { + tailf:cli-reset-siblings; + } + presence true; + leaf minimum-thresh { + tailf:info "minimum threshold for red aggregate"; + description "minimum threshold for red aggregate"; + type uint32 { + tailf:info "<0-1000000>;;minimum threshold (number of packets)"; + range "0..1000000"; + } + } + leaf maximum-thresh { + tailf:info "maximum threshold for red aggregate"; + description "maximum threshold for red aggregate"; + type uint32 { + tailf:info "<0-1000000>;;maximum threshold (number of packets)"; + range "0..1000000"; + } + } + leaf mark-probability { + tailf:info "mark-probability for red aggregate"; + description "mark-probability for red aggregate"; + type empty; + } + leaf denominator { + tailf:cli-drop-node-name; + type uint32 { + tailf:info "<0-65535>;;mark probability denominator"; + range "0..65535"; + } + } + } + container discard-class { + tailf:info "parameters for each discard-class value"; + description "parameters for each discard-class value"; + tailf:cli-compact-syntax; + tailf:cli-sequence-commands; + leaf dclass { + tailf:cli-drop-node-name; + tailf:cli-incomplete-command; + type uint16 { + range "0..7"; + tailf:info "<0-7>;;discard-class value"; + } + } + uses random-detect-grouping; + } + leaf discard-class-based { + tailf:info "Enable discard-class-based WRED as drop policy"; + description "Enable discard-class-based WRED as drop policy"; + tailf:cli-full-command; + type empty; + } + leaf dscp-based { + tailf:info "Enable dscp-based WRED as drop policy"; + description "Enable dscp-based WRED as drop policy"; + tailf:cli-full-command; + type empty; + } + list dscp { + tailf:info "parameters for each dscp value"; + description "parameters for each dscp value"; + tailf:cli-suppress-mode; + tailf:cli-compact-syntax; + tailf:cli-sequence-commands; + key dscp-val; + leaf dscp-val { + type dscp-type; + } + uses random-detect-grouping; + } + leaf ecn { + tailf:info "explicit congestion notification"; + description "explicit congestion notification"; + tailf:cli-full-command; + type empty; + } + leaf exponential-weighting-constant { + tailf:info "weight for mean queue depth calculation"; + description "weight for mean queue depth calculation"; + tailf:cli-full-command; + type uint16 { + range "1..16"; + tailf:info "<1-16>;;integer in 1..16 used in weighted "+ + "average to mean 2^number"; + } + } + leaf prec-based { + tailf:info "Enable precedence-based WRED as drop policy"; + description "Enable precedence-based WRED as drop policy"; + tailf:cli-full-command; + type empty; + } + container precedence { + tailf:info "parameters for each precedence value"; + description "parameters for each precedence value"; + tailf:cli-sequence-commands; + tailf:cli-compact-syntax; + leaf prec { + tailf:cli-drop-node-name; + tailf:cli-incomplete-command; + type precedence-type2; + } + uses random-detect-grouping; + } + } + } + case service-policy-case { + // policy-map * / class * / service-policy + leaf service-policy { + //tailf:info "Configure Flow Next"; + tailf:cli-full-command; + tailf:cli-drop-node-name; + when "../action-type = 'service-policy'"; + type string; + tailf:non-strict-leafref { + path "/ios:native/policy-map/name"; + } + } + } + case set-case { + // policy-map * / class * / set + container set { + //tailf:info "Set QoS values"; + tailf:cli-drop-node-name; + when "../action-type = 'set'"; + // policy-map * / class * / set atm-clp + leaf atm-clp { + tailf:info "Set ATM CLP bit to 1"; + description "Set ATM CLP bit to 1"; + tailf:cli-full-command; + type empty; + } + // policy-map * / class * / set cos + container cos { + tailf:info "Set IEEE 802.1Q/ISL class of service/user "+ + "priority"; + description "Set IEEE 802.1Q/ISL class of service/user "+ + "priority"; + tailf:cli-compact-syntax; + tailf:cli-sequence-commands; + choice cos-type { + case a { + leaf val { + tailf:cli-drop-node-name; + type uint16 { + range "0..7"; + tailf:info "<0-7>;;cos value"; + } + } + } + case b { + leaf pack { + tailf:cli-drop-node-name; + type enumeration { + enum dscp { + tailf:code-name "pack_dscp"; + tailf:info "Set value from packet dscp"; + } + enum precedence { + tailf:code-name "pack_precedence"; + tailf:info "Set value from packet "+ + "precedence."; + } + } + } + leaf table { + tailf:info "Set codepoint value based on tablemap."; + description "Set codepoint value based on tablemap."; + type string { + tailf:info "WORD;;table-map name"; + } + tailf:non-strict-leafref { + path "/ios:native/table-map/name"; + } + } + } + } + } + // policy-map * / class * / set discard-class + leaf discard-class { + tailf:info "Discard behavior identifier"; + description "Discard behavior identifier"; + tailf:cli-full-command; + type uint16 { + range "0..7"; + tailf:info "<0-7>;;Discard Class value"; + } + } + // policy-map * / class * / set dscp + container dscp { + tailf:info "Set DSCP in IP(v4) and IPv6 packets"; + description "Set DSCP in IP(v4) and IPv6 packets"; + tailf:cli-compact-syntax; + leaf tunnel { + tailf:info "set tunnel packet dscp"; + description "set tunnel packet dscp"; + type empty; + } + leaf dscp-val { + tailf:cli-drop-node-name; + type dscp-type; + } + } + // policy-map * / class * / set fr-de + leaf fr-de { + tailf:info "Set FR DE bit to 1"; + description "Set FR DE bit to 1"; + tailf:cli-full-command; + type empty; + } + // policy-map * / class * / set ip + container ip { + tailf:info "Set IP specific values"; + description "Set IP specific values"; + choice ip-choice { + container dscp { + tailf:info "Set IP DSCP (DiffServ CodePointint)"; + description "Set IP DSCP (DiffServ CodePointint)"; + tailf:cli-compact-syntax; + leaf tunnel { + tailf:info "set tunnel packet dscp"; + description "set tunnel packet dscp"; + type empty; + } + leaf dscp-val { + tailf:cli-drop-node-name; + type dscp-type; + } + } + container precedence { + tailf:info "Set IP precedence"; + description "Set IP precedence"; + presence "Set IP precedence"; + leaf precedence-val { + tailf:cli-drop-node-name; + type precedence-type; + } + } + } + } + // policy-map * / class * / set mpls + container mpls { + tailf:info "Set MPLS specific values"; + description "Set MPLS specific values"; + container experimental { + tailf:info "Set Experimental value"; + description "Set Experimental value"; + // 0-7 + container imposition { + tailf:info "Set Experimental value at tag imposition"; + description "Set Experimental value at tag imposition"; + leaf exp-value { + tailf:cli-drop-node-name; + tailf:cli-full-command; + type uint8 { + tailf:info "<0-7>;;Experimental value"; + range "0..7"; + } + } + // dscp + // precedence + } + // topmost + container topmost { + tailf:info "Set Experimental value on topmost label"; + description "Set Experimental value on topmost label"; + leaf exp-value { + tailf:cli-drop-node-name; + tailf:cli-full-command; + type uint8 { + tailf:info "<0-7>;;Experimental value"; + range "0..7"; + } + } + } + } + } + // policy-map * / class * / set qos-group + container qos-group { + tailf:info "Set QoS Group"; + description "Set QoS Group"; + leaf qos-group-value { + tailf:cli-drop-node-name; + tailf:cli-full-command; + type uint8 { + range "0..99"; + } + } + // dscp + // mpls + // precedence + } + } + } + case shape-case { + // policy-map * / class * / shape + container shape { + //tailf:info "Traffic Shaping"; + tailf:cli-drop-node-name; + when "../action-type = 'shape'"; + // policy-map * / class * / shape adaptive + leaf adaptive { + tailf:info "Enable Traffic Shaping adaptation to BECN"; + description "Enable Traffic Shaping adaptation to BECN"; + tailf:cli-full-command; + type uint32 { + range "8000..154400000"; + tailf:info "<8000-154400000>;;Lower Bound Target Bit "+ + "Rate (bits per second)"; + } + } + // policy-map * / class * / shape average + container average { + tailf:info "configure token bucket: CIR (bps) [Bc (bits) "+ + "[Be (bits)]], send out Bc only per interval"; + description "configure token bucket: CIR (bps) [Bc (bits) "+ + "[Be (bits)]], send out Bc only per interval"; + tailf:cli-sequence-commands; + tailf:cli-compact-syntax; + choice average-choice { + case a { + leaf bit-rate { + tailf:cli-drop-node-name; + type uint64 { + //range "8000..154400000"; + //FIXME: what is range max? + tailf:info "<8000-max>;;Target Bit "+ + "Rate (bits per second), the value "+ + "needs to be a multiple of 8000"; + } + } + leaf bits-per-interval-sustained { + tailf:cli-drop-node-name; + type uint32 { + range "256..154400000"; + tailf:info "<256-154400000>;;bits per "+ + "interval, sustained. Needs to be "+ + "multiple of 128. Recommend not to "+ + "configure it, the algorithm will "+ + "find out the best value"; + } + } + leaf bits-per-interval-excess { + tailf:cli-drop-node-name; + type uint32 { + range "0..154400000"; + tailf:info "<0-154400000>;;bits per "+ + "interval, excess. Needs to be "+ + "multiple of 128. Bc will be used if "+ + "you don't configure it."; + } + } + } + case b { + leaf percent { + tailf:info "% of interface bandwidth for "+ + "Committed information rate"; + description "% of interface bandwidth for "+ + "Committed information rate"; + type percentage-type; + } + leaf burst-size-sustained { + tailf:cli-incomplete-command; + tailf:cli-drop-node-name; + type uint16 { + range "10..2000"; + tailf:info "<10-2000>;;Sustained burst "+ + "size in msec"; + } + } + leaf ms { + tailf:info "milliseconds"; + description "milliseconds"; + type empty; + } + container bse { + tailf:cli-drop-node-name; + tailf:cli-flatten-container; + tailf:cli-sequence-commands; + tailf:cli-compact-syntax; + leaf burst-size-excess { + tailf:cli-incomplete-command; + type uint16 { + range "10..2000"; + tailf:info "<10-2000>;;Excess burst "+ + "size in msec"; + } + } + leaf ms { + tailf:info "milliseconds"; + description "milliseconds"; + type empty; + } + } + } + } + } + // policy-map * / class * / shape fecn-adapt + leaf fecn-adapt { + tailf:info "Enable Traffic Shaping reflection of FECN as "+ + "BECN"; + description "Enable Traffic Shaping reflection of FECN as "+ + "BECN"; + tailf:cli-full-command; + type empty; + } + // policy-map * / class * / shape fr-voice-adapt + container fr-voice-adapt { + tailf:info "Enable rate adjustment depending on voice "+ + "presence"; + description "Enable rate adjustment depending on voice "+ + "presence"; + presence "Enable rate adjustment depending on voice "+ + "presence" ; + leaf deactivation { + type uint16 { + range "1..10000"; + tailf:info "<1-10000>;;de-activation delay in "+ + "seconds"; + } + } + } + // policy-map * / class * / shape max-buffers + leaf max-buffers { + tailf:cli-full-command; + tailf:info "Set Maximum Buffer Limit"; + description "Set Maximum Buffer Limit"; + type uint16 { + range "1..4096"; + tailf:info "<1-4096>;;Maximum Buffer Limit"; + } + } + } + } + case trust-case { + // policy-map * / class * / trust + leaf trust { + //tailf:info "Set trust value for the class"; + tailf:cli-drop-node-name; + when "../action-type = 'trust'"; + type enumeration { + enum cos { + tailf:info "trust value for the class"; + } + enum dscp { + tailf:info "trust value for the class"; + } + enum ip-precedence { + tailf:info "trust value for the class"; + } + } + } + } + } + } + } + // policy-map * / description + leaf "description" { + tailf:info "Policy-Map description"; + description "Policy-Map description"; + tailf:cli-multi-value; + type string { + length "1..200"; + tailf:info "LINE;;Description of this policy-map (up to " + +"200 characters)"; + } + } + // policy-map * /sequence-interval + leaf sequence-interval { + tailf:info "Enable sequence number capability"; + description "Enable sequence number capability"; + when "../type = 'appnav'"; + type uint16 { + tailf:info "<0-65535>;;Sequence Number Interval"; + } + } + } + +/// ======================================================================== +/// service-chain +/// ======================================================================== + + container service-chain { + tailf:info "Service Chain mode"; + description "Service Chain mode"; + list service-function { + tailf:info "Service function details"; + description "Service function details"; + tailf:cli-mode-name "config-service-chain-sf"; + key "name"; + leaf name { + tailf:info "WORD;;Service function name"; + description "WORD;;Service function name"; + type string; + } + container config-service-chain-sf-mode { + tailf:cli-drop-node-name; + leaf description { + tailf:info "Service function description"; + description "Service function description"; + tailf:cli-multi-value; + tailf:cli-full-command; + type string { + tailf:info "LINE;;Up to 256 characters describing this " + +"service function"; + length "1..256"; + } + } + container encapsulation { + tailf:info "Service node encapsulation"; + description "Service node encapsulation"; + container gre { + tailf:info "Service node encapsulation type"; + description "Service node encapsulation type"; + leaf enhanced { + tailf:info "Add enhanced NSH TLV information"; + description "Add enhanced NSH TLV information"; + type enumeration { + enum copy { + tailf:info "Send a copy of the packet"; + } + enum divert { + tailf:info "Divert the packet (default)"; + } + } + } + } + leaf none { + tailf:info "Service node encapsulation type"; + description "Service node encapsulation type"; + type empty; + } + } + container ip { + tailf:info "Service node"; + description "Service node"; + leaf address { + type inet:ipv4-address { + tailf:info "A.B.C.D;;Service node"; + } + } + } + } + } + container service-function-forwarder { + tailf:info "Service function forwarder details"; + description "Service function forwarder details"; + list service-ff-name { + tailf:cli-drop-node-name; + tailf:cli-mode-name "config-service-chain-sff"; + key "name"; + leaf name { + tailf:info "WORD;;Service function forwarder name"; + description "WORD;;Service function forwarder name"; + type string; + } + uses config-service-chain-grouping; + } + container local { + tailf:info "Local service function forwarder"; + description "Local service function forwarder"; + tailf:cli-add-mode; + tailf:cli-mode-name "config-service-chain-sff"; + presence true; + uses config-service-chain-grouping; + } + } + list service-path { + tailf:info "Service Path Entries"; + description "Service Path Entries"; + tailf:cli-mode-name "config-service-chain-path"; + key "service-path-id"; + leaf service-path-id { + type uint32 { + range "0..16777215"; + tailf:info "<0-16777215>;;Service Path ID"; + } + } + container config-service-chain-path-mode { + tailf:cli-drop-node-name; + leaf description { + tailf:info "Path Description"; + description "Path Description"; + tailf:cli-multi-value; + tailf:cli-full-command; + type string { + tailf:info "LINE;;Up to 256 characters describing this " + +"service path"; + length "1..256"; + } + } + container service-index { + tailf:info "Service Index"; + description "Service Index"; + list services { + tailf:cli-drop-node-name; + tailf:cli-suppress-mode; + key "service-index-id"; + leaf service-index-id { + type uint8 { + range "2..255"; + tailf:info "<2-255>;;Service Index ID"; + } + } + choice service-type-choice { + leaf service-function { + tailf:info "Service Function name"; + description "Service Function name"; + type string { + tailf:info "WORD;;Service Function name"; + } + } + leaf service-function-forwarder { + tailf:info "Service Function Forwarder name"; + description "Service Function Forwarder name"; + type string { + tailf:info "WORD;;Service Function Forwarder name"; + } + } + leaf terminate { + tailf:info "Terminate(Proxy)"; + description "Terminate(Proxy)"; + type empty; + } + } + } + } + } + } + } + } + +/// ======================================================================== +/// eof +/// ======================================================================== + +} \ No newline at end of file diff --git a/renderers/ios-xe/src/main/yang/netconf/tailf-cli-extensions.yang b/renderers/ios-xe/src/main/yang/netconf/tailf-cli-extensions.yang new file mode 100644 index 000000000..764f8c0d3 --- /dev/null +++ b/renderers/ios-xe/src/main/yang/netconf/tailf-cli-extensions.yang @@ -0,0 +1,2611 @@ +submodule tailf-cli-extensions { + + belongs-to tailf-common { + prefix tailf; + } + + include tailf-meta-extensions { + revision-date 2013-11-07; + } + + organization "Tail-f Systems"; + + description + "This module defines all Tail-f YANG extensions statements + related to CLI customization. + + See also the 'display-' statements and the 'alt-name' statement + in tailf-common.yang."; + + revision 2015-03-19; + + extension cli-show-no { + tailf:use-in "leaf"; + tailf:use-in "list"; + tailf:use-in "leaf-list"; + tailf:use-in "refine"; + tailf:use-in "tailf:symlink"; + tailf:use-in "container"; + description + "Specifies that an optional leaf node or presence container + should be displayed as 'no ' when it does not exist. + For example, if a leaf 'shutdown' has this property and + does not exist, 'no shutdown' is displayed. + + Used in I- and C-style CLIs."; + } + + extension cli-disallow-value { + argument value { + tailf:arg-type { + type string; + } + } + tailf:use-in "leaf"; + tailf:use-in "leaf-list"; + tailf:use-in "refine"; + tailf:use-in "tailf:symlink"; + description + "Specifies that a pattern for invalid values. + + Used in I- and C-style CLIs."; + } + + extension cli-boolean-no { + tailf:use-in "typedef"; + tailf:use-in "leaf"; + tailf:use-in "refine"; + tailf:use-in "tailf:symlink"; + tailf:substatement "tailf:cli-reversed"; + description + "Specifies that a leaf of type boolean should be displayed as + '' if set to true, and 'no ' if set to + false. + + Cannot be used in conjunction with tailf:cli-hide-in-submode + or tailf:cli-compact-syntax. + + Used in I- and C-style CLIs."; + } + + extension cli-reversed { + tailf:use-in "tailf:cli-boolean-no"; + description + "Specified that true should be displayed as 'no ' and + false as 'name'. + + Used in I- and C-style CLIs."; + } + + extension cli-autowizard { + tailf:use-in "leaf"; + tailf:use-in "tailf:symlink"; + tailf:use-in "refine"; + description + "Specifies that the autowizard should include this leaf even + if the leaf is optional. + + One use case is when implementing pre-configuration of devices. + A config false node can be defined for showing if the + configuration is active or not (preconfigured). + + Used in J-, I- and C-style CLIs."; + } + + extension cli-show-config { + tailf:use-in "leaf"; + tailf:use-in "leaf-list"; + tailf:use-in "list"; + tailf:use-in "container"; + tailf:use-in "refine"; + tailf:use-in "tailf:symlink"; + description + "Specifies that the node will be included when doing a 'show + running-configuration', even if it is a non-config node. + + Used in I- and C-style CLIs."; + } + + + extension cli-display-empty-config { + tailf:use-in "list"; + tailf:use-in "tailf:symlink"; + tailf:use-in "refine"; + description + "Specifies that the node will be included when doing a 'show + stats', even if it is a non-config node, provided + that the list contains at least one non-config node. + + Used in J-style CLI."; + } + + extension cli-mode-name { + argument value { + tailf:arg-type { + type string; + } + } + tailf:use-in "container"; + tailf:use-in "list"; + tailf:use-in "tailf:symlink"; + tailf:use-in "refine"; + description + "Specifies a custom mode name, instead of the default which is the + name of the list or container node. + + Can be used in config nodes only. If used in a container, the + container must also have a tailf:cli-add-mode statement, and if + used in a list, the list must not also have a + tailf:cli-suppress-mode statement. + + Variables for the list keys in the current mode are available. + For examples, 'config-foo-xx$(name)' (privided the key leaf + is called 'name'). + + Used in I- and C-style CLIs."; + } + + extension cli-show-order-taglist { + argument value { + tailf:arg-type { + type string; + } + } + tailf:use-in "container"; + tailf:use-in "list"; + tailf:use-in "tailf:symlink"; + tailf:use-in "refine"; + description + "Specifies a custom display order for nodes with the + tailf:cli-show-order-tag attribute. Nodes will be displayed + in the order indicated in the list. Nodes without a tag will + be displayed after all nodes with a tag have been displayed. + + The scope of a taglist is until a new taglist is encountered. + + Used in I- and C-style CLIs."; + } + + extension cli-show-order-tag { + argument value { + 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 "tailf:symlink"; + tailf:use-in "refine"; + description + "Specifies a custom display order for nodes with the + tailf:cli-show-order-tag attribute. Nodes will be displayed + in the order indicated by a cli-show-order-taglist attribute in + a parent node. + + The scope of a tag reaches until a new taglist is encountered. + + Used in I- and C-style CLIs."; + } + + extension cli-mode-name-actionpoint { + argument value { + tailf:arg-type { + type string; + } + } + tailf:use-in "container"; + tailf:use-in "list"; + tailf:use-in "refine"; + description + "Specifies that a custom function will be invoked to find out the mode + name, instead of using the default with is the name of the list + or container node. + + The argument is the name of an actionpoint, which must be + implemented by custom code. In the actionpoint, the command() + callback function will be invoked, and it must return a string + with the mode name. See confd_lib_dp(3) for details. + + Can be used in config nodes only. If used in a container, the + container must also have a tailf:cli-add-mode statement, and if + used in a list, the list must not also have a + tailf:cli-suppress-mode statement. + + Used in I- and C-style CLIs."; + } + + extension cli-add-mode { + tailf:use-in "container"; + tailf:use-in "tailf:symlink"; + tailf:use-in "refine"; + description + "Creates a mode of the container. + + Can be used in config nodes only. + + Used in I- and C-style CLIs."; + } + + extension cli-flatten-container { + tailf:use-in "container"; + tailf:use-in "list"; + tailf:use-in "tailf:symlink"; + tailf:use-in "refine"; + description + "Allows the CLI to exit the container and continue to input + from the parent container when all leaves in the current + container has been set. + + Can be used in config nodes only. + + Used in I- and C-style CLIs."; + } + + extension cli-suppress-mode { + tailf:use-in "list"; + tailf:use-in "tailf:symlink"; + tailf:use-in "refine"; + description + "Instructs the CLI engine to not make a mode of the list node. + + Can be used in config nodes only. + + Used in I- and C-style CLIs."; + } + + extension cli-delete-when-empty { + tailf:use-in "list"; + tailf:use-in "container"; + description + "Instructs the CLI engine to delete the list when the last list + instance is deleted'. Requires that cli-suppress-mode is set. + + The behavior is recursive. If all optional leafs in a list + instance are deleted the list instance itself is deleted. If + that list instance happens to be the last list instance in a + list it is also deleted. And so on. Used in I- and C-style + CLIs."; + } + + extension cli-remove-before-change { + tailf:use-in "leaf-list"; + tailf:use-in "list"; + tailf:use-in "leaf"; + tailf:use-in "tailf:symlink"; + tailf:use-in "refine"; + description + "Instructs the CLI engine to generate a no-commnd before + modifying an existing instance. It only applies when + generating diffs, eg 'show configuration' in C-style."; + } + + extension cli-no-value-on-delete { + tailf:use-in "leaf"; + tailf:use-in "leaf-list"; + tailf:use-in "tailf:symlink"; + tailf:use-in "refine"; + description + "When displaying the deleted version of this leaf do not + include the old value. + + Applies to C-style"; + } + + extension cli-no-name-on-delete { + tailf:use-in "leaf"; + tailf:use-in "container"; + tailf:use-in "list"; + tailf:use-in "leaf-list"; + tailf:use-in "tailf:symlink"; + tailf:use-in "refine"; + description + "When displaying the deleted version of this element do not + include the name. + + Applies to C-style"; + } + + extension cli-embed-no-on-delete { + tailf:use-in "leaf"; + tailf:use-in "container"; + tailf:use-in "list"; + tailf:use-in "leaf-list"; + tailf:use-in "tailf:symlink"; + tailf:use-in "refine"; + description + "Embed no in front of the element name insead of at the + beginning of the line. + + Applies to C-style"; + } + + extension cli-recursive-delete { + tailf:use-in "container"; + tailf:use-in "list"; + tailf:use-in "tailf:symlink"; + tailf:use-in "refine"; + description + "When generating configuration diffs delete all contents + of a container or list before deleting the node. + + Applies to C-style"; + } + + + extension cli-diff-dependency { + argument path { + 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 "tailf:symlink"; + tailf:use-in "refine"; + tailf:substatement "tailf:xpath-root"; + tailf:substatement "tailf:cli-trigger-on-set"; + tailf:substatement "tailf:cli-trigger-on-delete"; + tailf:substatement "tailf:cli-trigger-on-all"; + tailf:occurence "*"; + description + "Tells the 'show configuration' command, and the diff generator + that this node depends on another node. When removing the node + with this declaration, it should be removed before the node + it depends on is removed, ie the declaration controlls the ordering + of the commands in the 'show configuration' output. + + Applies to C-style"; + } + + extension cli-trigger-on-set { + tailf:use-in "tailf:cli-diff-dependency"; + description + 'Specify that the dependency should trigger on set/modify of + the target path, but deletion of the target will trigger the + current node to be placed in front of the target. + + The annotation can be used to get the diff behavior where + one leaf is first deleted before the other leaf is set. + For example, having the data model below: + + container X { + leaf A { + tailf:cli-diff-dependency "../B" { + tailf:cli-trigger-on-set; + } + type empty; + } + leaf B { + tailf:cli-diff-dependency "../A" { + tailf:cli-trigger-on-set; + } + type empty; + } + } + + produces the following diffs when setting one leaf + and deleting the other + + no X A + X B + + and + + no X B + X A + + this can also be done with list instances, for example + + list a { + key id; + + leaf id { + tailf:cli-diff-dependency "/c[id=current()/../id]" { + tailf:cli-trigger-on-set; + } + type string; + } + } + + list c { + key id; + leaf id { + tailf:cli-diff-dependency "/a[id=current()/../id]" { + tailf:cli-trigger-on-set; + } + type string; + } + } + + we get + + no a foo + c foo + ! + + and + + no c foo + a foo + ! + + In the above case if we have the same id in list "a" and "c" + and we delete the instance in one list, and add it in the other, + then the deletion will always preceed the create. + '; + } + + extension cli-trigger-on-delete { + tailf:use-in "tailf:cli-diff-dependency"; + description + "This annotation can be used togeter with tailf:cli-trigger-on-set + to also get the behavior that when deleting the target display + changes to this node first. For exmaple: + + container settings { + tailf:cli-add-mode; + + leaf opmode { + tailf:cli-no-value-on-delete; + + type enumeration { + enum nat; + enum transparent; + } + } + + leaf manageip { + when \"../opmode = 'transparent'\"; + mandatory true; + tailf:cli-no-value-on-delete; + tailf:cli-diff-dependency '../opmode' { + tailf:cli-trigger-on-set; + tailf:cli-trigger-on-delete; + } + + type string; + } + } + + What we are trying to achieve here is that if manageip is + deleted, it should be displayed before opmode, but if we + configure both opmode and manageip, we should display opmode + first, ie get the diffs: + + settings + opmode transparent + manageip 1.1.1.1 + ! + + and + + settings + no manageip + opmode nat + ! + + and + + settings + no manageip + no opmode + ! + + The cli-trigger-on-set annotation will cause the 'no manageip' + command to be displayed before setting opmode. The + tailf:cli-trigger-on-delete will cause 'no manageip' to be + placed before 'no opmode' when both are deleted. + + In the first diff where both are created, opmode will come first + due to the diff-dependency setting, regardless of the + cli-trigger-on-delete and cli-trigger-on-set. + "; + + } + + + extension cli-trigger-on-all { + tailf:use-in "tailf:cli-diff-dependency"; + description + "Specify that the dependency should always trigger. It is the + same as placing one element before another in the data model. + For example, given the data model: + + container X { + leaf A { + tailf:cli-diff-dependency '../B' { + tailf:cli-trigger-on-all; + } + type empty; + } + leaf B { + type empty; + } + } + + We get the diffs + + X B + X A + + and + + no X B + no X A + "; + } + + + extension cli-ignore-modified { + tailf:use-in "container"; + tailf:use-in "list"; + tailf:use-in "leaf"; + tailf:use-in "leaf-list"; + tailf:use-in "tailf:symlink"; + tailf:use-in "refine"; + description + "Tells the cdb_cli_diff_iterate system call to not generate + a CLI string when this container is modified. The string will + instead be generated for the modified sub-element. + + Applies to C-style and I-style"; + } + + extension cli-show-long-obu-diffs { + tailf:use-in "list"; + tailf:use-in "tailf:symlink"; + tailf:use-in "refine"; + description + "Instructs the CLI engine to not generate 'insert' comments + when displaying configuration changes of ordered-by user + lists, but instead explicitly remove old instances with 'no' + and then add the instances following a newly inserted instance. + Should not be used together with tailf:cli-show-obu-comments"; + } + + extension cli-show-obu-comments { + tailf:use-in "list"; + tailf:use-in "tailf:symlink"; + tailf:use-in "refine"; + description + "Enforces the CLI engine to generate 'insert' comments + when displaying configuration changes of ordered-by user + lists. Should not be used together with tailf:cli-show-long-obu-diffs"; + } + + extension cli-allow-join-with-key { + tailf:use-in "list"; + tailf:use-in "tailf:symlink"; + tailf:use-in "refine"; + tailf:substatement "tailf:cli-display-joined"; + description + "Indicates that the list name may be written together + with the first key, without requiring a whitespace + in between, ie allowing both + interface ethernet1/1 + and + interface ethernet 1/1 + + Used in I- and C-style CLIs."; + } + + extension cli-allow-join-with-value { + tailf:use-in "leaf"; + tailf:use-in "tailf:symlink"; + tailf:use-in "refine"; + tailf:substatement "tailf:cli-display-joined"; + description + "Indicates that the leaf name may be written together + with the value, without requiring a whitespace + in between, ie allowing both + interface ethernet1/1 + and + interface ethernet 1/1 + + Used in I- and C-style CLIs."; + } + + + extension cli-display-joined { + tailf:use-in "tailf:cli-allow-join-with-key"; + tailf:use-in "tailf:cli-allow-join-with-value"; + description + "Specifies that the joined version should be used when displaying + the configuration in C- and I- mode."; + } + + extension cli-exit-command { + argument value { + yin-element true; + tailf:arg-type { + type string; + } + } + tailf:use-in "list"; + tailf:use-in "container"; + tailf:use-in "refine"; + tailf:use-in "tailf:symlink"; + tailf:substatement "tailf:info"; + description + "Tells the CLI to add an explicit exit-from-submode command. + The tailf:info substatement can be used for adding a custom + info text for the command. + + Used in I- and C-style CLIs."; + } + + extension cli-explicit-exit { + tailf:use-in "list"; + tailf:use-in "container"; + tailf:use-in "refine"; + tailf:use-in "tailf:symlink"; + description + "Tells the CLI to add an explicit exit command when displaying + the configuration. It will not be added if cli-exit-command + is defined as well. The annotation is inherited by all + sub-modes. + + Used in I- and C-style CLIs."; + } + + + extension cli-key-format { + argument value { + yin-element true; + tailf:arg-type { + type string; + } + } + tailf:use-in "list"; + tailf:use-in "tailf:symlink"; + tailf:use-in "refine"; + description + "The format string is used when parsing a key value and when + generating a key value for an existing configuration. The key + items are numbered from 1-N and the format string should + indicate how they are related by using $(X) (where X is the + key number). For example: + + tailf:cli-key-format '$(1)-$(2)' means that the first key + item is concatenated with the second key item by a '-'. + + Used in J-, I- and C-style CLIs."; + } + + extension cli-suppress-key-sort { + tailf:use-in "list"; + tailf:use-in "tailf:symlink"; + tailf:use-in "refine"; + description + "Instructs the CLI engine to not sort the keys in alphabetical order + when presenting them to the user during TAB completion. + + Used in J-, I- and C-style CLIs."; + } + + extension cli-suppress-table { + tailf:use-in "list"; + tailf:use-in "tailf:symlink"; + tailf:use-in "refine"; + description + "Instructs the CLI engine to not print the list as a table in + the 'show' command. + + Can be used in non-config nodes only. + + Used in I- and C-style CLIs."; + } + + extension cli-suppress-validation-warning-prompt { + tailf:use-in "list"; + tailf:use-in "leaf"; + tailf:use-in "container"; + tailf:use-in "leaf-list"; + tailf:use-in "tailf:symlink"; + tailf:use-in "refine"; + description + "Instructs the CLI engine to not prompt the user whether to proceed + or not if a warning is generated for this node. + + Used in I- and C-style CLIs."; + } + + + extension cli-suppress-key-abbreviation { + tailf:use-in "list"; + tailf:use-in "tailf:symlink"; + tailf:use-in "refine"; + description + "Key values cannot be abbreviated. The user must always give + complete values for keys. + + In the J-style CLI this is relevant when using the commands + 'delete' and 'edit'. + + In the I- and C-style CLIs this is relevant when using the + commands 'no', 'show configuration' and for commands to enter + submodes. + + See also /confdConfig/cli/allowAbbrevKeys in confd.conf(5)."; + } + + extension cli-allow-key-abbreviation { + tailf:use-in "list"; + tailf:use-in "tailf:symlink"; + tailf:use-in "refine"; + description + "Key values can be abbreviated. + + In the J-style CLI this is relevant when using the commands + 'delete' and 'edit'. + + In the I- and C-style CLIs this is relevant when using the + commands 'no', 'show configuration' and for commands to enter + submodes. + + See also /confdConfig/cli/allowAbbrevKeys in confd.conf(5)."; + } + + extension cli-table-legend { + argument value { + yin-element true; + tailf:arg-type { + type string; + } + } + tailf:use-in "list"; + tailf:use-in "tailf:symlink"; + tailf:use-in "refine"; + description + "Specifies a template string to be printed before all list entries are + printed. + + Used in J-, I- and C-style CLIs."; + } + + extension cli-table-footer { + argument value { + yin-element true; + tailf:arg-type { + type string; + } + } + tailf:use-in "list"; + tailf:use-in "tailf:symlink"; + tailf:use-in "refine"; + description + "Specifies a template string to be printed after all list entries are + printed. + + Used in J-, I- and C-style CLIs."; + } + + extension cli-completion-actionpoint { + argument value { + tailf:arg-type { + type tailf:identifier; + } + } + tailf:use-in "leaf-list"; + tailf:use-in "leaf"; + tailf:use-in "tailf:symlink"; + tailf:use-in "refine"; + tailf:substatement "tailf:cli-completion-id"; + description + "Specifies that completion for the leaf values is done through a + callback function. + + The argument is the name of an actionpoint, which must be + implemented by custom code. In the actionpoint, the completion() + callback function will be invoked. See confd_lib_dp(3) for details. + + Used in J-, I- and C-style CLIs."; + } + + extension cli-completion-id { + argument value { + tailf:arg-type { + type tailf:identifier; + } + } + tailf:use-in "tailf:cli-completion-actionpoint"; + tailf:use-in "tailf:cli-custom-range-actionpoint"; + description + "Specifies a string which is passed to the callback when invoked. + This makes it possible to use the same callback at several + locations and still keep track of which point it is invoked + from."; + } + + extension cli-allow-caching { + tailf:use-in "tailf:cli-custom-range-actionpoint"; + tailf:use-in "tailf:cli-custom-range-enumerator"; + description + "Allow caching of the evaluation results between different parent paths."; + } + + extension cli-multi-line-prompt { + tailf:use-in "leaf"; + tailf:use-in "tailf:symlink"; + tailf:use-in "refine"; + description + "Tells the CLI to automatically enter multi-line mode when prompting + the user for a value to this leaf. + + Used in J-, I- and C-style CLIs."; + } + + extension cli-multi-word-key { + tailf:use-in "leaf"; + tailf:use-in "tailf:symlink"; + tailf:use-in "refine"; + tailf:substatement "tailf:cli-max-words"; + description + "Specifies that the key should allow multiple tokens for the + value. Proper type restrictions needs to be used to limit + the range of the leaf value. + + Can be used in key leafs only. + + Used in J-, I- and C-style CLIs."; + } + + extension cli-max-words { + argument value { + tailf:arg-type { + type uint32; + } + } + tailf:use-in "tailf:cli-multi-word-key"; + tailf:use-in "tailf:cli-multi-word"; + tailf:use-in "tailf:cli-multi-value"; + description + "Specifies the maximum number of allowed words for the key or value."; + } + + extension cli-allow-range { + tailf:use-in "leaf"; + tailf:use-in "tailf:symlink"; + tailf:use-in "refine"; + description + "Means that the non-integer key should allow range expressions. + + Can be used in key leafs only. + + Used in J-, I- and C-style CLIs."; + } + + extension cli-range-delimiters { + argument value { + tailf:arg-type { + type string; + } + } + tailf:use-in "list"; + tailf:use-in "tailf:symlink"; + tailf:use-in "refine"; + description + "Allows for custom delimiters to be defined for range expressions. + By default only / is considered a delimiter, ie when processing + a key like 1/2/3 then each of 1, 2 and 3 will be matched separately + agains range expressions, ie given the expression 1-3/5-6/7,8 + 1 will be matched with 1-3, 2 with 5-6, and 3 with 7,8. If, for + example, the delimiters value is set to '/.' then both '/' and + '.' will be considered delimiters and an key such as 1/2/3.4 will + consist of the enteties 1,2,3,4, all matched separately. + + Used in J-, I- and C-style CLIs."; + } + + + extension cli-suppress-range { + tailf:use-in "leaf"; + tailf:use-in "tailf:symlink"; + tailf:use-in "refine"; + description + "Means that the integer key should not allow range expressions. + + Can be used in key leafs only. + + Used in J-, I- and C-style CLIs."; + } + + extension cli-custom-range { + tailf:use-in "leaf"; + tailf:use-in "tailf:symlink"; + tailf:use-in "refine"; + tailf:substatement "tailf:cli-range-type" { + tailf:occurence "1"; + } + description + "Specifies that the key should support ranges. A type matching the + range expression must be supplied. + + Can be used in key leafs only. + + Used in J-, I- and C-style CLIs."; + } + + extension cli-custom-range-actionpoint { + argument value { + tailf:arg-type { + type tailf:identifier; + } + } + tailf:use-in "list"; + tailf:use-in "tailf:symlink"; + tailf:use-in "refine"; + tailf:substatement "tailf:cli-completion-id"; + tailf:substatement "tailf:cli-allow-caching"; + description + "Specifies that the list supports range expressions and that a custom + function will be invoked to determine if an instance belong in + the range or not. At least one key element needs a + cli-custom-range statement. + + The argument is the name of an actionpoint, which must be + implemented by custom code. In the actionpoint, the + completion() callback function will be invoked. See + confd_lib_dp(3) for details. + + When a range expression value which matches the type is given in + the CLI, the CLI engine will invoke the callback with each + existing list entry instance. If the callback returns CONFD_OK, + it matches the range expression, and if it returns CONFD_ERR, it + doesn't match. + + Used in J-, I- and C-style CLIs."; + } + + extension cli-custom-range-enumerator { + argument value { + tailf:arg-type { + type tailf:identifier; + } + } + tailf:use-in "list"; + tailf:use-in "tailf:symlink"; + tailf:use-in "refine"; + tailf:substatement "tailf:cli-completion-id"; + tailf:substatement "tailf:cli-allow-caching"; + description + "Specifies a callback to invoke to get an array of + instances matching a regular expression. This is used + when instances should be allowed to be created using + a range expression in set. + + The callback is not used for delete or show operations. + + The callback is allowed to return a superset of all matching + instances since the instances will be filtered using the + range expression afterwards. + + Used in J-, I- and C-style CLIs."; + } + + extension cli-range-type { + argument value { + tailf:arg-type { + type string; + } + } + tailf:use-in "tailf:cli-custom-range"; + description + "This statement contains the name of a derived type, possibly + with a prefix. If no prefix is given, the type must be defined in + the local module. For example: + + cli-range-type p:my-range-type; + + All range expressions must match this type, and a valid key + value must not match this type."; + } + + extension cli-allow-wildcard { + tailf:use-in "list"; + tailf:use-in "tailf:symlink"; + tailf:use-in "refine"; + description + "Means that the list allows wildcard expressions in the 'show' pattern. + + See also /confdConfig/cli/allowWildcard in confd.conf(5). + + Used in J-, I- and C-style CLIs."; + } + + extension cli-suppress-wildcard { + tailf:use-in "list"; + tailf:use-in "tailf:symlink"; + tailf:use-in "refine"; + description + "Means that the list does not allow wildcard expressions in the 'show' + pattern. + + See also /confdConfig/cli/allowWildcard in confd.conf(5). + + Used in J-, I- and C-style CLIs."; + } + + extension cli-configure-mode { + tailf:use-in "tailf:action"; + tailf:use-in "rpc"; + description + "An action or rpc with this attribute will be available in + configure mode, but not in operational mode. + + The default is that the action or rpc is available in both + configure and operational mode. + + Used in J-, I- and C-style CLIs."; + } + + extension cli-operational-mode { + tailf:use-in "tailf:action"; + tailf:use-in "rpc"; + description + "An action or rpc with this attribute will be available in + operational mode, but not in configure mode. + + The default is that the action or rpc is available in both + configure and operational mode. + + Used in J-, I- and C-style CLIs."; + } + + extension cli-mount-point { + argument value { + tailf:arg-type { + type string; + } + } + tailf:use-in "tailf:action"; + tailf:use-in "rpc"; + description + "By default actions are mounted under the 'request' + command in the J-style CLI and at the top-level in + the I- and C-style CLIs. This annotation allowes + the action to be mounted under other top level commands"; + } + + extension cli-batch-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 during batch + processing in the CLI (e.g. non-interactive mode) when a confirm-text is + set. If this value is not specified, the default value may instead be + provdied by tailf:confirm-default or by the ConfD global default if + specified in a clispec(5)."; + } + + extension cli-delayed-auto-commit { + tailf:use-in "container"; + tailf:use-in "list"; + tailf:use-in "tailf:symlink"; + tailf:use-in "refine"; + description + "Enables transactions while in a specific submode (or submode of that + mode). The modifications performed in that mode will not take effect + until the user exits that submode. + + Can be used in config nodes only. If used in a container, the + container must also have a tailf:cli-add-mode statement, and if + used in a list, the list must not also have a + tailf:cli-suppress-mode statement. + + Used in I- and C-style CLIs."; + } + + extension cli-preformatted { + tailf:use-in "leaf"; + tailf:use-in "tailf:symlink"; + tailf:use-in "refine"; + description + "Suppresses quoting of non-config elements when displaying them. + Newlines will be preserved in strings etc. + + Used in J-, I- and C-style CLIs."; + } + + extension cli-disabled-info { + argument value { + tailf:arg-type { + type string; + } + } + tailf:use-in "leaf"; + tailf:use-in "tailf:symlink"; + tailf:use-in "refine"; + description + "Specifies an info string that will be used as a descriptive text for the + value 'disable' (false) of boolean-typed leafs when the confd.conf(5) + setting /confdConfig/cli/useShortEnabled is set to 'true'. + + Used in J-, I- and C-style CLIs."; + } + + extension cli-suppress-shortenabled { + tailf:use-in "leaf"; + tailf:use-in "tailf:symlink"; + tailf:use-in "refine"; + description + "Suppresses the confd.conf(5) setting /confdConfig/cli/useShortEnabled. + + Used in J-, I- and C-style CLIs."; + } + + extension cli-trim-default { + tailf:use-in "leaf"; + tailf:use-in "tailf:symlink"; + tailf:use-in "refine"; + description + "Do not display value if it is same as default. + + Used in I- and C-style CLIs."; + } + + extension cli-expose-key-name { + tailf:use-in "leaf"; + tailf:use-in "tailf:symlink"; + tailf:use-in "refine"; + description + "Force the user to enter the name of the key and display the + key name when displaying the running-configuration. + + Used in J-, I- and C-style CLIs."; + } + + + extension cli-enforce-table { + tailf:use-in "list"; + tailf:use-in "tailf:symlink"; + tailf:use-in "refine"; + description + "Forces the generation of a table for a list element node regardless of + whether the table will be too wide or not. This applies to the + tables generated by the auto-rendred show commands for non-config data. + + Used in I- and C-style CLIs."; + } + + extension cli-drop-node-name { + tailf:use-in "leaf"; + tailf:use-in "container"; + tailf:use-in "list"; + tailf:use-in "leaf-list"; + tailf:use-in "tailf:symlink"; + tailf:use-in "refine"; + description + "Specifies that the name of a node is not present in the CLI. + + If tailf:cli-drop-node-name is given on a child to a list node, + we recommend that you also use tailf:cli-suppress-mode on that + list node, otherwise the CLI will be very confusing. + + For example, consider this data model, from the tailf-aaa module: + + list alias { + key name; + leaf name { + type string; + } + leaf expansion { + type string; + mandatory true; + tailf:cli-drop-node-name; + } + } + + If you type 'alias foo' in the CLI, you would end up in the + 'alias' submode. But since the expansion is dropped, you would + end up specifying the expansion value without typing any command. + + If, on the other hand, the 'alias' list had a + tailf:cli-suppress-mode statement, you would set an expansion + 'bar' by typing 'alias foo bar'. + + tailf:cli-drop-node-name cannot be used inside tailf:action. + + Used in I- and C-style CLIs."; + } + + extension cli-no-keyword { + tailf:use-in "leaf"; + tailf:use-in "container"; + tailf:use-in "list"; + tailf:use-in "leaf-list"; + tailf:use-in "tailf:symlink"; + tailf:use-in "refine"; + description + "Specifies that the name of a node is not present in the CLI. + + + Note that is must be used with some care, just + like tailf:cli-drop-node-name. The resulting data model must still + be possible to parse deterministically. + For example, consider the data model + + container interfaces { + list traffic { + tailf:cli-no-keyword; + key id; + leaf id { type string; } + leaf mtu { type uint16; } + } + list management { + tailf:cli-no-keyword; + key id; + leaf id { type string; } + leaf mtu { type uint16; } + } + } + + In this case it is impossible to determine if the config + + interfaces { + eth0 { + mtu 1400; + } + } + + Means that there should be an traffic interface instance named + 'eth0' or a management interface instance maned 'eth0'. If, on + the other hand, a restriction on the type was used, for example + + container interfaces { + list traffic { + tailf:cli-no-keyword; + key id; + leaf id { type string; pattern 'eth.*'; } + leaf mtu { type uint16; } + } + list management { + tailf:cli-no-keyword; + key id; + leaf id { type string; pattern 'lo.*';} + leaf mtu { type uint16; } + } + } + + then the problem would disappear. + + Used in the J-style CLIs."; + } + + extension cli-compact-syntax { + tailf:use-in "list"; + tailf:use-in "container"; + tailf:use-in "tailf:symlink"; + tailf:use-in "refine"; + description + "Instructs the CLI engine to use the compact representation for this + node in the 'show running-configuration' command. The compact + representation means that all leaf elements are shown on a + single line. + + Cannot be used in conjunction with tailf:cli-boolean-no. + + Used in I- and C-style CLIs."; + } + + extension cli-compact-stats { + tailf:use-in "list"; + tailf:use-in "container"; + tailf:use-in "tailf:symlink"; + tailf:use-in "refine"; + tailf:substatement "tailf:cli-wrap"; + tailf:substatement "tailf:cli-width"; + tailf:substatement "tailf:cli-delimiter"; + tailf:substatement "tailf:cli-prettify"; + tailf:substatement "tailf:cli-spacer"; + description + "Instructs the CLI engine to use the compact representation for this + node. The compact representation means that all leaf elements + are shown on a single line. + + Used in J-, I- and C-style CLIs."; + } + + extension cli-wrap { + tailf:use-in "tailf:cli-compact-stats"; + description + "If present, the line will be wrapped at screen width."; + } + + extension cli-width { + argument value { + tailf:arg-type { + type uint32; + } + } + tailf:use-in "tailf:cli-compact-stats"; + description + "Specifies a fixed terminal width to use before wrapping line. It is + only used when tailf:cli-wrap is present. If a width is not + specified the line is wrapped when the terminal width is + reached."; + } + + extension cli-delimiter { + argument value { + tailf:arg-type { + type string; + } + } + tailf:use-in "tailf:cli-compact-stats"; + description + "Specifies a string to print between the leaf name and its value + when displaying leaf values."; + } + + extension cli-prettify { + tailf:use-in "tailf:cli-compact-stats"; + description + "If present, dashes (-) and underscores (_) in leaf names are replaced + with spaces."; + } + + extension cli-spacer { + argument value { + tailf:arg-type { + type string; + } + } + tailf:use-in "tailf:cli-compact-stats"; + description + "Specifies a string to print between the nodes."; + } + + + extension cli-column-stats { + tailf:use-in "container"; + tailf:use-in "refine"; + tailf:use-in "tailf:symlink"; + description + "Display leafs in the container as columns, i.e., do not repeat + the name of the container on each line, but instead indent each + leaf under the container. + + Used in I- and C-style CLIs."; + } + + extension cli-column-width { + argument value { + tailf:arg-type { + type uint32; + } + } + tailf:use-in "leaf"; + tailf:use-in "leaf-list"; + tailf:use-in "tailf:symlink"; + tailf:use-in "refine"; + description + "Set a fixed width for the column in the auto-rendered tables. + + Used in J-, I- and C-style CLIs."; + } + + extension cli-min-column-width { + argument value { + tailf:arg-type { + type uint32; + } + } + tailf:use-in "leaf"; + tailf:use-in "leaf-list"; + tailf:use-in "tailf:symlink"; + tailf:use-in "refine"; + description + "Set a minimum width for the column in the auto-rendered tables. + + Used in J-, I- and C-style CLIs."; + } + + extension cli-column-align { + argument value { + tailf:arg-type { + type enumeration { + enum left; + enum center; + enum right; + } + } + } + tailf:use-in "leaf"; + tailf:use-in "leaf-list"; + tailf:use-in "tailf:symlink"; + tailf:use-in "refine"; + description + "Specifies the alignment of the data in the column in the + auto-rendered tables. + + Used in J-, I- and C-style CLIs."; + } + + extension cli-list-syntax { + tailf:use-in "leaf-list"; + tailf:use-in "tailf:symlink"; + tailf:use-in "refine"; + tailf:substatement "tailf:cli-multi-word"; + description + "Specifies that each entry in a leaf-list should be displayed as + a separate element. + + Used in J-, I- and C-style CLIs."; + } + + extension cli-multi-word { + tailf:use-in "tailf:cli-list-syntax"; + tailf:substatement "tailf:cli-max-words"; + description + "Specifies that a multi-word value may be entered without quotes."; + } + + extension cli-flat-list-syntax { + tailf:use-in "leaf-list"; + tailf:substatement "tailf:cli-replace-all"; + tailf:use-in "refine"; + description + "Specifies that elements in a leaf-list should be entered without + surrounding brackets. Also, multiple elements can be added to a list + or deleted from a list. + + Used in J-, I- and C-style CLIs."; + } + + extension cli-replace-all { + tailf:use-in "leaf-list"; + tailf:use-in "tailf:cli-flat-list-syntax"; + tailf:use-in "refine"; + description + "Specifies that the new leaf-list value(s) should replace the old, + as opposed to be added to the old leaf-list."; + } + + extension cli-range-list-syntax { + tailf:use-in "leaf-list"; + tailf:use-in "list"; + tailf:use-in "refine"; + description + "Specifies that elements in a leaf-list or a list should be entered + without surrounding brackets and presented as ranges. The + element in the list should be separated by a comma. For + example: + + vlan 1,3,10-20,30,32,300-310 + + When this statement is used for lists, the list must have a + single key. The elements are be presented as ranges as above. + + The type of the list key, or the leaf-list, must be integer based. + + Used in J-, I- and C-style CLIs."; + } + + extension cli-incomplete-command { + tailf:use-in "leaf"; + tailf:use-in "leaf-list"; + tailf:use-in "list"; + tailf:use-in "container"; + tailf:use-in "refine"; + description + "Specifies that an auto-rendered command should be considered + incomplete. Can be used to prevent from appearing in + the completion list for optional internal nodes, for example, or + to ensure that the user enters all leaf values in a container + (if used in combination with cli-sequence-commands). + + Used in I- and C-style CLIs."; + } + + extension cli-full-command { + tailf:use-in "leaf"; + tailf:use-in "leaf-list"; + tailf:use-in "list"; + tailf:use-in "tailf:symlink"; + tailf:use-in "container"; + tailf:use-in "refine"; + description + "Specifies that an auto-rendered command should be considered complete, + ie, no additional leaves or containers can be entered on the same + command line. + + Used in I- and C-style CLIs."; + } + + extension cli-sequence-commands { + tailf:use-in "list"; + tailf:use-in "container"; + tailf:use-in "tailf:symlink"; + tailf:use-in "refine"; + tailf:substatement "tailf:cli-reset-siblings"; + tailf:substatement "tailf:cli-reset-all-siblings"; + description + "Specifies that an auto-rendered command should only accept arguments + in the same order as they are specified in the YANG model. + This, in combination with tailf:cli-drop-node-name, can be used + to create CLI commands for setting multiple leafs in a container + without having to specify the leaf names. + + In almost all cases this annotation should be accompanied by the + tailf:cli-compact-syntax annotation. Otherwise the output from + 'show running-config' will not be correct, and the sequence + 'save xx' 'load override xx' will not work. + + Used in I- and C-style CLIs."; + } + + extension cli-reset-siblings { + tailf:use-in "tailf:cli-sequence-commands"; + description + "Specifies that all sibling leaves in the sequence should be reset + whenever the first leaf in the sequence is set."; + } + + extension cli-reset-all-siblings { + tailf:use-in "tailf:cli-sequence-commands"; + description + "Specifies that all sibling leaves in the container should be reset + whenever the first leaf in the sequence is set."; + } + + extension cli-reset-container { + tailf:use-in "leaf"; + tailf:use-in "list"; + tailf:use-in "container"; + tailf:use-in "tailf:symlink"; + tailf:use-in "refine"; + description + "Specifies that all sibling leaves in the container should be + reset when this element is set. + + When used on a container its content is cleared when set."; + } + + extension cli-display-separated { + tailf:use-in "container"; + tailf:use-in "tailf:symlink"; + tailf:use-in "refine"; + description + "Tells CLI engine to display this container as a separate + line item even when it has children. Only applies to + presence containers. + + Applicable for optional containers in the C- and I- style CLIs."; + } + + extension cli-delete-container-on-delete { + tailf:use-in "leaf"; + tailf:use-in "tailf:symlink"; + tailf:use-in "refine"; + description + "Specifies that the parent container should be deleted when +. this leaf is deleted."; + } + + extension cli-break-sequence-commands { + tailf:use-in "leaf"; + tailf:use-in "tailf:symlink"; + tailf:use-in "leaf-list"; + tailf:use-in "list"; + tailf:use-in "container"; + tailf:use-in "refine"; + description + "Specifies that previous cli-sequence-command declaration should + stop at this point. Only applicable when a cli-sequence-command + declaration has been used in the parent container. + + Used in I- and C-style CLIs."; + } + + extension cli-strict-leafref { + tailf:use-in "leaf"; + tailf:use-in "leaf-list"; + tailf:use-in "tailf:symlink"; + tailf:use-in "refine"; + description + "Specifies that the leaf should only be allowed to be assigned + references to existing instances when the command is executed. + Without this annotation the requirement is that the instance + exists on commit time. + + Used in I- and C-style CLIs."; + } + + extension cli-optional-in-sequence { + tailf:use-in "leaf"; + tailf:use-in "tailf:symlink"; + tailf:use-in "leaf-list"; + tailf:use-in "list"; + tailf:use-in "container"; + tailf:use-in "refine"; + description + "Specifies that this element is optional in the sequence. If it + is set it must be set in the right sequence but may be skipped. + + Used in I- and C-style CLIs."; + } + + extension cli-incomplete-show-path { + tailf:use-in "leaf"; + tailf:use-in "tailf:symlink"; + tailf:use-in "leaf-list"; + tailf:use-in "list"; + tailf:use-in "container"; + tailf:use-in "refine"; + tailf:substatement "tailf:cli-min-keys"; + description + "Specifies that a path to the show command is considered incomplete, + i.e., it needs more elements added to the path. It can also be used + to specify a minimum number of keys to be given for lists. + + Used in J-, I- and C-style CLIs."; + } + + extension cli-min-keys { + argument value { + tailf:arg-type { + type uint32; + } + } + tailf:use-in "tailf:cli-incomplete-show-path"; + description + "Specifies the minimum number of required keys for the show command."; + } + + extension cli-hide-in-submode { + tailf:use-in "leaf"; + tailf:use-in "container"; + tailf:use-in "tailf:symlink"; + tailf:use-in "refine"; + description + "Hide leaf when submode has been entered. Mostly useful when + leaf has to be entered in order to enter a submode. Also works + for flattened containers. + + Cannot be used in conjunction with tailf:cli-boolean-no. + + Used in I- and C-style CLIs."; + } + + extension cli-expose-ns-prefix { + tailf:use-in "container"; + tailf:use-in "list"; + tailf:use-in "tailf:symlink"; + tailf:use-in "refine"; + description + "When used force the CLI to display namespace prefix of all children."; + } + + extension cli-prefix-key { + tailf:use-in "leaf"; + tailf:use-in "tailf:symlink"; + tailf:use-in "refine"; + tailf:use-in "leaf-list"; + tailf:substatement "tailf:cli-before-key"; + description + "This leaf has to be given as a prefix before entering the actual + list keys. Very backwards but a construct that exists in some + Cisco CLIs. + + The construct can be used also for leaf-lists but only when + then tailf:cli-range-list-syntax is also used. + + Used in I- and C-style CLIs."; + } + + extension cli-before-key { + argument value { + tailf:arg-type { + type uint32; + } + } + tailf:use-in "tailf:cli-prefix-key"; + description + "Specifies before which key the prefix element should be inserted. + The first key has number 1."; + } + + extension cli-show-with-default { + tailf:use-in "leaf"; + tailf:use-in "refine"; + tailf:use-in "tailf:symlink"; + description + "This leaf will be displayed even when it has its default value. + Note that this will somewhat result in a slightly different behaviour + when you save a config and then load it again. With this setting + in place a leaf that has not been configured will be configured + after the load. + + Used in I- and C-style CLIs."; + } + + extension cli-oper-info { + 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 is used when displaying the element info in the context + of stats. + + Both tailf:info and tailf:cli-oper-info can be present at the same + time."; + } + + extension cli-case-sensitive { + tailf:use-in "container"; + tailf:use-in "list"; + tailf:use-in "leaf"; + description + "Specifies that this node is case-sensitive. + If applied to a container or a list, any nodes below will + also be case-sensitive. + + Note that this will override any case-sensitivity settings + configured in confd.conf"; + } + + extension cli-case-insensitive { + tailf:use-in "container"; + tailf:use-in "list"; + tailf:use-in "leaf"; + description + "Specifies that node is case-insensitive. + If applied to a container or a list, any nodes below will + also be case-insensitive. + + Note that this will override any case-insensitivity settings + configured in confd.conf"; + } + + extension cli-custom-error { + argument text { + yin-element true; + tailf:arg-type { + type string; + } + } + tailf:use-in "leaf"; + tailf:use-in "tailf:symlink"; + tailf:use-in "refine"; + description + "This statement specifies a custom error message to be displayed + when the user enters an invalid value."; + } + + extension cli-full-show-path { + 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"; + tailf:substatement "tailf:cli-max-keys"; + description + "Specifies that a path to the show command is considered complete, i.e., + no more elements can be added to the path. It can also be used to + specify a maximum number of keys to be given for lists. + + Used in J-, I- and C-style CLIs."; + } + + extension cli-max-keys { + argument value { + tailf:arg-type { + type uint32; + } + } + tailf:use-in "tailf:cli-full-show-path"; + description + "Specifies the maximum number of allowed keys for the show command."; + } + + extension cli-suppress-show-path { + tailf:use-in "leaf"; + tailf:use-in "leaf-list"; + tailf:use-in "list"; + tailf:use-in "tailf:symlink"; + tailf:use-in "container"; + tailf:use-in "refine"; + description + "Specifies that the show command cannot be invoked with the path, + ie the path is suppressed when auto-rendering show commands for + config='false' data. + + Used in J-, I- and C-style CLIs."; + } + + + extension cli-suppress-show-match { + tailf:use-in "leaf"; + tailf:use-in "leaf-list"; + tailf:use-in "list"; + tailf:use-in "tailf:symlink"; + tailf:use-in "container"; + tailf:use-in "refine"; + description + "Specifies that a specific completion match (i.e., a filter match that + appear at list nodes as an alternative to specifying a single + instance) to the show command should not be available. + + Used in J-, I- and C-style CLIs."; + } + + extension cli-suppress-list-no { + tailf:use-in "leaf-list"; + tailf:use-in "list"; + tailf:use-in "tailf:symlink"; + tailf:use-in "refine"; + description + "Specifies that the CLI should not accept deletion of the entire list + or leaf-list. Only specific instances should be deletable not the + entire list in one command. ie, 'no foo ' should be allowed + but not 'no foo'. + + Used in I- and C-style CLIs."; + } + + extension cli-suppress-no { + tailf:use-in "leaf"; + tailf:use-in "leaf-list"; + tailf:use-in "list"; + tailf:use-in "tailf:symlink"; + tailf:use-in "container"; + tailf:use-in "refine"; + description + "Specifies that the CLI should not auto-render 'no' commands for + this element. An element with this annotation will not appear in the + completion list to the 'no' command. + + Used in I- and C-style CLIs."; + } + + extension cli-suppress-silent-no { + argument value { + tailf:arg-type { + type string; + } + } + tailf:use-in "leaf"; + tailf:use-in "leaf-list"; + tailf:use-in "list"; + tailf:use-in "tailf:symlink"; + tailf:use-in "container"; + tailf:use-in "refine"; + description + "Specifies that the confd.cnof directive cSilentNo should be + suppressed for a leaf and that a custom error message should + be displayed when the user attempts to delete a non-existing + element. + + Used in I- and C-style CLIs."; + } + + + extension cli-full-no { + tailf:use-in "leaf"; + tailf:use-in "leaf-list"; + tailf:use-in "list"; + tailf:use-in "tailf:symlink"; + tailf:use-in "container"; + tailf:use-in "refine"; + description + "Specifies that an auto-rendered 'no'-command should be considered complete, + ie, no additional leaves or containers can be entered on the same + command line. + + Used in I- and C-style CLIs."; + } + + extension cli-incomplete-no { + 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 + "Specifies that an auto-rendered 'no'-command should not be considered + complete, ie, additional leaves or containers must be entered on the same + command line. + + Used in I- and C-style CLIs."; + } + + extension cli-no-match-completion { + tailf:use-in "list"; + tailf:use-in "tailf:symlink"; + tailf:use-in "refine"; + description + "Specifies that the CLI engine should not provide match completion + for the key leafs in the list. + + Used in J-, I- and C-style CLIs."; + } + + extension cli-suppress-show-conf-path { + 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 + "Specifies that the show running-config command cannot be invoked with + the path, ie the path is suppressed when auto-rendering show running- + config commands for config='true' data. + + Used in J-, I- and C-style CLIs."; + } + + + extension cli-no-key-completion { + tailf:use-in "list"; + tailf:use-in "tailf:symlink"; + tailf:use-in "refine"; + description + "Specifies that the CLI engine should not perform completion for key + leafs in the list. This is to avoid querying the data provider + for all existing keys. + + Used in J-, I- and C-style CLIs."; + } + + extension cli-instance-info-leafs { + argument value { + tailf:arg-type { + type string; + } + } + tailf:use-in "list"; + tailf:use-in "tailf:symlink"; + tailf:use-in "refine"; + description + "This statement is used to specifiy how list entries are displayed + when doing completion in the CLI. By default, a list entry is + displayed by listing its key values, and the value of a leaf + called 'description', if such a leaf exists in the list entry. + + The 'cli-instance-info-leafs' statement takes as its argument a + space separated string of leaf names. When a list entry is + displayed, the values of these leafs are concatenated with a + space character as separator and shown to the user. + + For example, when asked to specify an interface the CLI will + display a list of possible interface instances, say 1 2 3 4. If + the cli-instance-info-leafs property is set to 'description' then + the CLI might show: + + Possible completions: + 1 - internet + 2 - lab + 3 - dmz + 4 - wlan + + Used in J-, I- and C-style CLIs."; + } + + extension cli-multi-value { + tailf:use-in "leaf"; + tailf:use-in "tailf:symlink"; + tailf:use-in "refine"; + tailf:substatement "tailf:cli-max-words"; + description + "Specifies that all remaining tokens on the command line + should be considered a value for this leaf. This prevents + the need for quoting values containing spaces, but also + prevents multiple leaves from being set on the same command + line once a multi-value leaf has been given on a line. + + If the tailf:cli-max-words substatements is used then + additional leaves may be entered. + + Used in I- and C-style CLIs."; + } + + extension cli-value-display-template { + argument value { + yin-element true; + tailf:arg-type { + type tailf:cli-template-string; + } + } + tailf:use-in "leaf"; + tailf:use-in "tailf:symlink"; + tailf:use-in "refine"; + description + "Specifies a template string to be used when formating the + value of a leaf for display. Note that other leaves cannot + be referenced from a display template of one leaf. The only + value accessible is the leaf's own value, accessed through + $(.). + + See the defintion of cli-template-string for more info. + + Used in J-, I- and C-style CLIs."; + } + + + extension cli-show-template { + argument value { + yin-element true; + tailf:arg-type { + type tailf:cli-template-string; + } + } + tailf:use-in "leaf"; + tailf:use-in "leaf-list"; + tailf:use-in "list"; + tailf:use-in "tailf:symlink"; + tailf:use-in "container"; + tailf:use-in "refine"; + tailf:substatement "tailf:cli-auto-legend"; + description + "Specifies a template string to be used by the 'show' command in + operational mode. It is primarily intended for displaying + non-config data but config data may be included in the template + as well. + + See the defintion of cli-template-string for more info. + + Some restrictions includes not applying templates on a leaf that + is the key in a list. It is recommended to use the template + directly on the list to format the whole list instead. + + Used in J-, I- and C-style CLIs."; + } + + extension cli-auto-legend { + tailf:use-in "tailf:cli-show-template"; + description + "Specifies that the legend should be automatically rendered if not " + +"already displayed. Useful when using templates for rendering " + +"tables."; + } + + extension cli-show-template-legend { + argument value { + yin-element true; + tailf:arg-type { + type tailf:cli-template-string; + } + } + tailf:use-in "list"; + tailf:use-in "refine"; + description + + "Specifies a template string to be printed before all list entries are + printed. + + See the defintion of cli-template-string for more info. + + Used in J-, I- and C-style CLIs."; + } + + extension cli-show-template-enter { + argument value { + yin-element true; + tailf:arg-type { + type tailf:cli-template-string; + } + } + tailf:use-in "list"; + tailf:use-in "tailf:symlink"; + tailf:use-in "refine"; + description + "Specifies a template string to be printed before each list entry is + printed. + + See the defintion of cli-template-string for more info. + + Used in J-, I- and C-style CLIs."; + } + + extension cli-show-template-footer { + argument value { + yin-element true; + tailf:arg-type { + type tailf:cli-template-string; + } + } + tailf:use-in "list"; + tailf:use-in "tailf:symlink"; + tailf:use-in "refine"; + description + + "Specifies a template string to be printed after all list entries are + printed. + + See the defintion of cli-template-string for more info. + + Used in J-, I- and C-style CLIs."; + } + + extension cli-run-template { + argument value { + yin-element true; + tailf:arg-type { + type tailf:cli-template-string; + } + } + tailf:use-in "leaf"; + tailf:use-in "leaf-list"; + tailf:use-in "tailf:symlink"; + tailf:use-in "refine"; + description + "Specifies a template string to be used by the 'show running-config' + command in operational mode. It is primarily intended for displaying + config data but non-config data may be included in the template + as well. + + See the defintion of cli-template-string for more info. + + Used in I- and C-style CLIs."; + } + + extension cli-run-template-legend { + argument value { + yin-element true; + tailf:arg-type { + type tailf:cli-template-string; + } + } + tailf:use-in "list"; + tailf:use-in "tailf:symlink"; + tailf:use-in "refine"; + description + + "Specifies a template string to be printed before all list entries are + printed. + + See the defintion of cli-template-string for more info. + + Used in I- and C-style CLIs."; + } + + extension cli-run-template-enter { + argument value { + yin-element true; + tailf:arg-type { + type tailf:cli-template-string; + } + } + tailf:use-in "list"; + tailf:use-in "container"; + tailf:use-in "tailf:symlink"; + tailf:use-in "refine"; + description + "Specifies a template string to be printed before each list entry is + printed. + + When used on a container it only has effect when the container + also has a tailf:cli-add-mode, and when tailf:cli-show-no isn't + used on the container. + + See the defintion of cli-template-string for more info. + + The variable .reenter is set to 'true' when the 'show configuration' + command is executed and the list or container isn't created. This + allow, for example, to display + + create foo + + when an instance is created + + edit foo + + when something inside the instance is modified. + + Used in I- and C-style CLIs."; + } + + extension cli-run-template-footer { + argument value { + yin-element true; + tailf:arg-type { + type tailf:cli-template-string; + } + } + tailf:use-in "list"; + tailf:use-in "tailf:symlink"; + tailf:use-in "refine"; + description + + "Specifies a template string to be printed after all list entries are + printed. + + See the defintion of cli-template-string for more info. + + Used in I- and C-style CLIs."; + } + + typedef cli-template-string { + type string; + description + "A template is a text string which is expanded by the CLI engine, + and then displayed to the user. + + The template may contain a mix of text and expandable entries. + Expandable entries all start with $( and end with a matching ). + Parentheses and dollar signs need to be quoted in plain text. + + The template is expanded as follows: + + A parameter is either a relative or absolute path to a leaf + element (eg /foo/bar, foo/bar), or one of the builtin variables: + .selected, .entered, .legend_shown, .user, .groups, .ip, + .display_groups, .path, .ipath or .licounter. In addition the + variables .spath and .ispath are available when a command + is executed from a show path. + + .selected + + The .selected variable contains the list of selected paths + to be shown. The show template can inspect this element to + determine if a given element should be displayed or + not. For example: + + $(.selected~=hwaddr?HW Address) + + .entered + + The .entered variable is true if the \"entered\" text has + been displayed (either the auto generated text or a + showTemplateEnter). This is useful when having a non-table + template where each instance should have a text. + + $(.entered?:host $(name)) + + .legend_shown + + The .legend_shown variable is true if the \"legend\" text has + been displayed (either the auto generated table header or + a showTemplateLegend). This is useful to inspect when + displaying a table row. If the user enteres the path to a + specific instance the builtin table header will not be + displayed and the showTemplateLegend will not be invoked + and it may be useful to render the legend specifically + for this instance. + + $(.legend_shown!=true?Address Interface) + + .user + + The .user variable contains the name of the current + user. This can be used for differentiating the content + displayed for a specific user, or in paths. For exapmle: + + $(user{$(.user)}/settings) + + .groups + + The .groups variable contains the a list of groups that the + user belongs to. + + .display_groups + + The .display_groups variable contains a list of selected + display groups. This can be used to display different + content depending on the selected display group. For + example: + + $(.display_groups~=details?details...) + + .ip + + The .ip variable contains the ip address that the user + connected from. + + .path + + The .path variable contains the path to the entry, + formated in CLI style. + + .ipath + + The .ipath variable contains the path to the entry, + formated in template style. + + .spath + + The .spath variable contains the show path, + formated in CLI style. + + .ispath + + The .ispath variable contains the show path, + formated in template style. + + .licounter + + The .licounter variable contains a counter that is + incremented for each instance in a list. This means that + it will be 0 in the legend, contain the total number of + list instances in the footer and something in between in + the basic show template. + + $(parameter) + + The value of 'parameter' is substituted. + + $(cond?word1:word2) + + The expansion of 'word1' is substituted if 'cond' + evaluates to true, otherwise the expansion of 'word2' is + substituted. + + 'cond' may be one of + + parameter + + Evaluates to true if the node exists. + + parameter == + + Evaluates to true if the value of the parameter equals + . + + parameter != + + Evalutes to true if the value of the parameter does not + equal + + parameter ~= + + Provided that the value of the parameter is a list + (i.e., the node that the parameter refers to is a + leaf-list), this expression evaluates to true if + is a member of the list. + + $(parameter|filter) + + The value of 'parameter' processed by 'filter' is + substituted. Filters may be either one of the + built-ins or a customized filter defined in a + callback. See /confdConfig/cli/templateFilter. + + A built-in 'filter' may be one of: + + capfirst + + Capitalizes the first character of the value. + + lower + + Converts the value into lowercase. + + upper + + Converts the value into uppercase. + + filesizeformat + + Formats the value in a human-readable format (e.g., + '13 KB', '4.10 MB', '102 bytes' etc), where K + means 1024, M means 1024*1024 etc. + + When used without argument the default number of + decimals displayed is 2. When used with a numeric + integer argument, filesizeformat will display the + given number of decimal places. + + humanreadable + + Similar to filesizeformat except no bytes suffix + is added (e.g., '13.00 k', '4.10 M' '102' etc), + where k means 1000, M means 1000*1000 etc. + + When used without argument the default number of + decimals displayed is 2. When used with a numeric + integer argument, humanreadable will display the + given number of decimal places. + + commasep + + Separate the numerical values into groups of three + digits using a comma (e.g., 1234567 -> 1,234,567) + + hex + + Display integer as hex number. An argument can be + used to indicate how many digits should be used in + the output. If the hex number is too long it will + be truncated at the front, if it is too short it will + be padded with zeros at the front. If the width is + a negative number then at most that number of digits + will be used, but short numbers will not be padded + with zeroes. Another argument can be given to indicate + if the hex numbers should be written with lower + or upper case. + + For example: + + value Template Output + 12345 {{ value|hex }} 3039 + 12345 {{ value|hex:2 }} 39 + 12345 {{ value|hex:8 }} 00003039 + 12345 {{ value|hex:-8 }} 3039 + 14911 {{ value|hex:-8:upper }} 3A3F + 14911 {{ value|hex:-8:lower }} 3a3f + + hexlist + + Display integer as hex number with : between pairs. An + argument can be used to indicate how many digits should + be used in the output. If the hex number is too long it + will be truncated at the front, if it is too short it will + be padded with zeros at the front. If the width is + a negative number then at most that number of digits + will be used, but short numbers will not be padded + with zeroes. Another argument can be given to indicate + if the hex numbers should be written with lower + or upper case. + + For example: + + value Template Output + 12345 {{ value|hexlist }} 30:39 + 12345 {{ value|hexlist:2 }} 39 + 12345 {{ value|hexlist:8 }} 00:00:30:39 + 12345 {{ value|hexlist:-8 }} 30:39 + 14911 {{ value|hexlist:-8:upper }} 3A:3F + 14911 {{ value|hexlist:-8:lower }} 3a:3f + + floatformat + + Used for type 'float' in tailf-xsd-types. We recommend + that the YANG built-in type 'decimal64' is used instead of + 'float'. + + When used without an argument, rounds a floating-point + number to one decimal place -- but only if there is a + decimal part to be displayed. + + For example: + + value Template Output + 34.23234 {{ value|floatformat }} 34.2 + 34.00000 {{ value|floatformat }} 34 + 34.26000 {{ value|floatformat }} 34.3 + + If used with a numeric integer argument, floatformat + rounds a number to that many decimal places. For example: + + value Template Output + 34.23234 {{ value|floatformat:3 }} 34.232 + 34.00000 {{ value|floatformat:3 }} 34.000 + 34.26000 {{ value|floatformat:3 }} 34.260 + + If the argument passed to floatformat is negative, it will + round a number to that many decimal places -- but only if + there's a decimal part to be displayed. For example: + + value Template Output + 34.23234 {{ value|floatformat:-3 }} 34.232 + 34.00000 {{ value|floatformat:-3 }} 34 + 34.26000 {{ value|floatformat:-3 }} 34.260 + + Using floatformat with no argument is equivalent to using + floatformat with an argument of -1. + + ljust:width + + Left-align the value given a width. + + rjust:width + + Right-align the value given a width. + + trunc:width + + Truncate value to a given width. + + lower + + Convert the value into lowercase. + + upper + + Convert the value into uppercase. + + show: + + Substitutes the result of invoking the default display + function for the parameter. The dictionary can be used + for introducing own variables that can be accessed in + the same manner as builtin variables. The user defined + variables overrides builtin variables. The dictionary + is specified as a string on the following form: + + (key=value)(:key=value)* + + For example, with the following expression: + + $(foo|show:myvar1=true:myvar2=Interface) + + the user defined variables can be accessed like this: + + $(.myvar1!=true?Address) $(.myvar2) + + A special case is the dict variable 'indent'. It + controls the indentation level of the displayed path. + The current indent level can be incremented and + decremented using =+ and =-. + + For example: + + $(foobar|show:indent=+2) + $(foobar|show:indent=-1) + $(foobar|show:indent=10) + + Another special case is he dict variable 'noalign'. + It may be used to suppress the default aligning that + may occur when displaying an element. + + For example: + + $(foobar|show:noalign) + + dict: + + Translates the value using the dictionary. Can for + example be used for displaying on/off instead of + true/false. The dictionary is specified as a string on + the following form: + + (key=value)(:key=value)* + + For example, with the following expression: + + $(foo|dict:true=on:false=off) + + if the leaf 'foo' has value 'true', it is displayed as 'on', and + if its value is 'false' it is displayed as 'off'. + + Nested invocations are allowed, ie it is possible to have expressions + like $((state|dict:yes=Yes:no=No)|rjust:14), or $(/foo{$(../bar)}) + + + For example: + + list interface { + key name; + leaf name { ... } + leaf status { ... } + container line { + leaf status { ... } + } + leaf mtu { ... } + leaf bw { ... } + leaf encapsulation { ... } + leaf loopback { ... } + tailf:cli-show-template + '$(name) is administratively $(status),' + + ' line protocol is $(line/status)\\n' + + 'MTU $(mtu) bytes, BW $(bw|humanreadable)bit, \\n' + + 'Encap $(encapsulation|upper), $(loopback?:loopback not set)\\n'; + }"; + } + +} \ No newline at end of file diff --git a/renderers/ios-xe/src/main/yang/netconf/tailf-common.yang b/renderers/ios-xe/src/main/yang/netconf/tailf-common.yang new file mode 100644 index 000000000..eb71e7e92 --- /dev/null +++ b/renderers/ios-xe/src/main/yang/netconf/tailf-common.yang @@ -0,0 +1,3219 @@ +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."; + } + + /* + * Common types, natively supported by ConfD. + */ + + 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."; + } + + + /* + * Meta extensions + */ + + 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; + } + } + "; + } + + /* + * Type restriction statements + */ + + 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 }"; + } + + /* + * Data implementation statements + */ + + 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."; + } + + /* + * Validation related statements + */ + + 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."; + } + + + /* + * User interface related statements + */ + + 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 '[^\*].*|..+'; // must not be single '*' +// YANG 1.1: +// pattern '\*' { +// modifier invert-match; +// } + } + } + } + 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."; + } + + /* + * SNMP mapping statements + */ + + 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."; + } + + /* + * SNMP NED statements + */ + + 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."; + } + + /* + * Java code generation statements + */ + + 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."; + } + + /* + * Common code generation statemements + */ + + 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."; + } + + /* + * Data modeling extensions + */ + + 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."; + } + + /* + * RPC and action implementation statements + */ + + 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."; + } + + /* + * Deprecated types + */ + + 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."; + } + + /* + * Deprecated statements + */ + + 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 + "; + } + + /* + * Tail-f internal statements + */ + + 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."; + } + +} \ No newline at end of file diff --git a/renderers/ios-xe/src/main/yang/netconf/tailf-meta-extensions.yang b/renderers/ios-xe/src/main/yang/netconf/tailf-meta-extensions.yang new file mode 100644 index 000000000..1581d52bc --- /dev/null +++ b/renderers/ios-xe/src/main/yang/netconf/tailf-meta-extensions.yang @@ -0,0 +1,133 @@ +submodule tailf-meta-extensions { + + belongs-to tailf-common { + prefix tailf; + } + + organization "Tail-f Systems"; + + description + "This submodule defines Tail-f YANG meta extensions statements."; + + revision 2013-11-07 { + description + "Released as part of ConfD-5.0. + + Added tailf:occurrence."; + } + + revision 2010-08-19 { + description + "Released as part of ConfD-3.3.1. + + Added tailf:snmp-identifier."; + } + + revision 2010-03-18 { + description + "Released as part of ConfD-3.2."; + } + + /* + * Types used to describe the extension statements' arguments. + */ + + typedef identifier { + type string { + pattern "[A-Za-z_][A-Za-z0-9_-]*"; + } + } + + typedef snmp-identifier { + type string { + pattern "[A-Za-z_][A-Za-z0-9_-]*(:[A-Za-z_][A-Za-z0-9_-]*)*"; + } + } + + typedef tailf-oid { + type string { + pattern "(([0-1](\.[1-3]?[0-9]))" + + "|(2.(0|([1-9]\d*)))" + + "|([A-Za-z_][A-Za-z0-9_-]*))?" + + "(\.(0|([1-9]\d*)))+"; + } + } + + /* + * Descriptive meta extensions + */ + + extension use-in { + argument name { + tailf:arg-type { + type string; + } + } + tailf:use-in "extension"; + tailf:occurence "*"; + description + "Specifies in which statements a particular extension statement can be + used."; + } + + extension substatement { + argument name { + tailf:arg-type { + type string; + } + } + tailf:use-in "extension"; + tailf:occurence "*"; + + tailf:substatement "tailf:occurence"; + description + "Specifies which statements can occur as substatement to the + given statement."; + } + + extension arg-type { + tailf:use-in "argument"; + tailf:substatement "type" { + tailf:occurence "1"; + } + tailf:substatement "default"; + description + "Specifies the type of the argument."; + } + + extension occurence { + argument value { + tailf:arg-type { + type enumeration { + enum "QuestionMark" { + description + "The extenstion may be given zero or one time. + This is the default."; + } + enum "*" { + description + "The extenstion may be given zero or multiple times."; + } + enum "+" { + description + "The extenstion must be given at least once."; + } + enum "1" { + description + "The extenstion must be given exactly once."; + } + } + } + } + tailf:use-in "extension"; + description + "Specifices how an extension statement may be used. + + If this statement is given as a substatement to 'extension', + it applies to all 'use-in' statements. + + If this statement is given as a substatement to 'tailf:substatement', + it applies to this substatement."; + } + +} \ No newline at end of file diff --git a/renderers/pom.xml b/renderers/pom.xml index 1a39df73b..445a682d0 100644 --- a/renderers/pom.xml +++ b/renderers/pom.xml @@ -1,7 +1,7 @@ - @@ -26,13 +26,25 @@ ovssfc netconf vpp + ios-xe + + + + org.opendaylight.groupbasedpolicy + groupbasedpolicy-artifacts + ${project.version} + import + pom + + + + org.opendaylight.groupbasedpolicy groupbasedpolicy - ${project.version} -- 2.36.6