set -e
-(cd honeynode && mvn clean install -DskipTests -s fd_io_honeycomb_settings.xml)
+rm -rf honeynode/honeynode-plugin-impl/src/main/resources/honeycomb-minimal-resources/config/yang
+mkdir -p honeynode/honeynode-plugin-impl/src/main/resources/honeycomb-minimal-resources/config/yang
+cp ordmodels_2_1/* honeynode/honeynode-plugin-impl/src/main/resources/honeycomb-minimal-resources/config/yang
+(cd honeynode && mvn clean install -DskipTests -Dcheckstyle.skip -s fd_io_honeycomb_settings.xml)
chmod +x ./honeynode/honeynode-distribution/target/honeynode-distribution-1.18.01-hc/honeynode-distribution-1.18.01/honeycomb-tpce
exit $?
</pluginRepository>
</pluginRepositories>
</profile>
+ <profile>
+ <id>opendaylight-release</id>
+ <repositories>
+ <repository>
+ <id>opendaylight-mirror</id>
+ <name>opendaylight-mirror</name>
+ <url>https://nexus.opendaylight.org/content/repositories/public/</url>
+ <releases>
+ <enabled>true</enabled>
+ <updatePolicy>never</updatePolicy>
+ </releases>
+ <snapshots>
+ <enabled>false</enabled>
+ </snapshots>
+ </repository>
+ </repositories>
+ <pluginRepositories>
+ <pluginRepository>
+ <id>opendaylight-mirror</id>
+ <name>opendaylight-mirror</name>
+ <url>https://nexus.opendaylight.org/content/repositories/public/</url>
+ <releases>
+ <enabled>true</enabled>
+ <updatePolicy>never</updatePolicy>
+ </releases>
+ <snapshots>
+ <enabled>false</enabled>
+ </snapshots>
+ </pluginRepository>
+ </pluginRepositories>
+ </profile>
</profiles>
<activeProfiles>
<activeProfile>fd.io-release</activeProfile>
<activeProfile>fd.io-snapshots</activeProfile>
<activeProfile>opendaylight-snapshots</activeProfile>
+ <activeProfile>opendaylight-release</activeProfile>
</activeProfiles>
</settings>
--- /dev/null
+module ietf-netconf-monitoring-extension {
+
+ yang-version 1;
+
+ namespace
+ "urn:ietf:params:xml:ns:yang:ietf-netconf-monitoring-extension";
+
+ prefix ncme;
+
+ import ietf-netconf-monitoring {
+ prefix ncm;
+ }
+
+ revision "2013-12-10" {
+ description "Initial revision.";
+
+ }
+
+ identity netconf-tcp {
+ base ncm:transport;
+ description
+ "NETCONF over TCP.";
+ }
+
+ augment "/ncm:netconf-state/ncm:sessions/ncm:session" {
+ leaf session-identifier {
+ type string;
+ }
+ }
+
+}
\ No newline at end of file
--- /dev/null
+module ietf-netconf-monitoring {
+
+ yang-version 1;
+
+ namespace
+ "urn:ietf:params:xml:ns:yang:ietf-netconf-monitoring";
+
+ prefix ncm;
+
+ import ietf-yang-types {
+ prefix yang;
+ revision-date "2013-07-15";
+ }
+
+ import ietf-inet-types {
+ prefix inet;
+ revision-date "2013-07-15";
+ }
+
+ organization
+ "IETF NETCONF (Network Configuration) Working Group";
+
+ contact
+ "WG Web: <http://tools.ietf.org/wg/netconf/>
+ WG List: <mailto:netconf@ietf.org>
+
+ WG Chair: Mehmet Ersue
+ <mailto:mehmet.ersue@nsn.com>
+
+ WG Chair: Bert Wijnen
+ <mailto:bertietf@bwijnen.net>
+
+ Editor: Mark Scott
+ <mailto:mark.scott@ericsson.com>
+
+ Editor: Martin Bjorklund
+ <mailto:mbj@tail-f.com>";
+
+ description
+ "NETCONF Monitoring Module.
+ All elements in this module are read-only.
+
+ Copyright (c) 2010 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 6022; see
+ the RFC itself for full legal notices.";
+
+ revision "2010-10-04" {
+ description "Initial revision.";
+ reference
+ "RFC 6022: YANG Module for NETCONF Monitoring";
+
+ }
+
+
+ typedef netconf-datastore-type {
+ type enumeration {
+ enum "running" {
+ value 0;
+ }
+ enum "candidate" {
+ value 1;
+ }
+ enum "startup" {
+ value 2;
+ }
+ }
+ description
+ "Enumeration of possible NETCONF datastore types.";
+ reference
+ "RFC 4741: NETCONF Configuration Protocol";
+
+ }
+
+ identity transport {
+ description
+ "Base identity for NETCONF transport types.";
+ }
+
+ identity netconf-ssh {
+ base transport;
+ description
+ "NETCONF over Secure Shell (SSH).";
+ reference
+ "RFC 4742: Using the NETCONF Configuration Protocol
+ over Secure SHell (SSH)";
+
+ }
+
+ identity netconf-soap-over-beep {
+ base transport;
+ description
+ "NETCONF over Simple Object Access Protocol (SOAP) over
+ Blocks Extensible Exchange Protocol (BEEP).";
+ reference
+ "RFC 4743: Using NETCONF over the Simple Object
+ Access Protocol (SOAP)";
+
+ }
+
+ identity netconf-soap-over-https {
+ base transport;
+ description
+ "NETCONF over Simple Object Access Protocol (SOAP)
+ over Hypertext Transfer Protocol Secure (HTTPS).";
+ reference
+ "RFC 4743: Using NETCONF over the Simple Object
+ Access Protocol (SOAP)";
+
+ }
+
+ identity netconf-beep {
+ base transport;
+ description
+ "NETCONF over Blocks Extensible Exchange Protocol (BEEP).";
+ reference
+ "RFC 4744: Using the NETCONF Protocol over the
+ Blocks Extensible Exchange Protocol (BEEP)";
+
+ }
+
+ identity netconf-tls {
+ base transport;
+ description
+ "NETCONF over Transport Layer Security (TLS).";
+ reference
+ "RFC 5539: NETCONF over Transport Layer Security (TLS)";
+
+ }
+
+ identity schema-format {
+ description
+ "Base identity for data model schema languages.";
+ }
+
+ identity xsd {
+ base schema-format;
+ description
+ "W3C XML Schema Definition.";
+ reference
+ "W3C REC REC-xmlschema-1-20041028:
+ XML Schema Part 1: Structures";
+
+ }
+
+ identity yang {
+ base schema-format;
+ description
+ "The YANG data modeling language for NETCONF.";
+ reference
+ "RFC 6020: YANG - A Data Modeling Language for the
+ Network Configuration Protocol (NETCONF)";
+
+ }
+
+ identity yin {
+ base schema-format;
+ description "The YIN syntax for YANG.";
+ reference
+ "RFC 6020: YANG - A Data Modeling Language for the
+ Network Configuration Protocol (NETCONF)";
+
+ }
+
+ identity rng {
+ base schema-format;
+ description
+ "Regular Language for XML Next Generation (RELAX NG).";
+ reference
+ "ISO/IEC 19757-2:2008: RELAX NG";
+
+ }
+
+ identity rnc {
+ base schema-format;
+ description "Relax NG Compact Syntax";
+ reference
+ "ISO/IEC 19757-2:2008: RELAX NG";
+
+ }
+
+ grouping common-counters {
+ description
+ "Counters that exist both per session, and also globally,
+ accumulated from all sessions.";
+ leaf in-rpcs {
+ type yang:zero-based-counter32;
+ description
+ "Number of correct <rpc> messages received.";
+ }
+
+ leaf in-bad-rpcs {
+ type yang:zero-based-counter32;
+ description
+ "Number of messages received when an <rpc> message was expected,
+ that were not correct <rpc> messages. This includes XML parse
+ errors and errors on the rpc layer.";
+ }
+
+ leaf out-rpc-errors {
+ type yang:zero-based-counter32;
+ description
+ "Number of <rpc-reply> messages sent that contained an
+ <rpc-error> element.";
+ }
+
+ leaf out-notifications {
+ type yang:zero-based-counter32;
+ description
+ "Number of <notification> messages sent.";
+ }
+ } // grouping common-counters
+
+ container netconf-state {
+ config false;
+ description
+ "The netconf-state container is the root of the monitoring
+ data model.";
+ container capabilities {
+ description
+ "Contains the list of NETCONF capabilities supported by the
+ server.";
+ leaf-list capability {
+ type inet:uri;
+ description
+ "List of NETCONF capabilities supported by the server.";
+ }
+ } // container capabilities
+
+ container datastores {
+ description
+ "Contains the list of NETCONF configuration datastores.";
+ list datastore {
+ key "name";
+ description
+ "List of NETCONF configuration datastores supported by
+ the NETCONF server and related information.";
+ leaf name {
+ type netconf-datastore-type;
+ description
+ "Name of the datastore associated with this list entry.";
+ }
+
+ container locks {
+ presence
+ "This container is present only if the datastore
+ is locked.";
+ description
+ "The NETCONF <lock> and <partial-lock> operations allow
+ a client to lock specific resources in a datastore. The
+ NETCONF server will prevent changes to the locked
+ resources by all sessions except the one that acquired
+ the lock(s).
+
+ Monitoring information is provided for each datastore
+ entry including details such as the session that acquired
+ the lock, the type of lock (global or partial) and the
+ list of locked resources. Multiple locks per datastore
+ are supported.";
+ grouping lock-info {
+ description
+ "Lock related parameters, common to both global and
+ partial locks.";
+ leaf locked-by-session {
+ type uint32;
+ mandatory true;
+ description
+ "The session ID of the session that has locked
+ this resource. Both a global lock and a partial
+ lock MUST contain the NETCONF session-id.
+
+ If the lock is held by a session that is not managed
+ by the NETCONF server (e.g., a CLI session), a session
+ id of 0 (zero) is reported.";
+ reference
+ "RFC 4741: NETCONF Configuration Protocol";
+
+ }
+
+ leaf locked-time {
+ type yang:date-and-time;
+ mandatory true;
+ description
+ "The date and time of when the resource was
+ locked.";
+ }
+ } // grouping lock-info
+ choice lock-type {
+ description
+ "Indicates if a global lock or a set of partial locks
+ are set.";
+ container global-lock {
+ description
+ "Present if the global lock is set.";
+ uses lock-info;
+ } // container global-lock
+ list partial-lock {
+ key "lock-id";
+ description
+ "List of partial locks.";
+ reference
+ "RFC 5717: Partial Lock Remote Procedure Call (RPC) for
+ NETCONF";
+
+ leaf lock-id {
+ type uint32;
+ description
+ "This is the lock id returned in the <partial-lock>
+ response.";
+ }
+
+ uses lock-info;
+
+ leaf-list select {
+ type yang:xpath1.0;
+ min-elements 1;
+ description
+ "The xpath expression that was used to request
+ the lock. The select expression indicates the
+ original intended scope of the lock.";
+ }
+
+ leaf-list locked-node {
+ type instance-identifier;
+ description
+ "The list of instance-identifiers (i.e., the
+ locked nodes).
+
+ The scope of the partial lock is defined by the list
+ of locked nodes.";
+ }
+ } // list partial-lock
+ } // choice lock-type
+ } // container locks
+ } // list datastore
+ } // container datastores
+
+ container schemas {
+ description
+ "Contains the list of data model schemas supported by the
+ server.";
+ list schema {
+ key "identifier version format";
+ description
+ "List of data model schemas supported by the server.";
+ leaf identifier {
+ type string;
+ description
+ "Identifier to uniquely reference the schema. The
+ identifier is used in the <get-schema> operation and may
+ be used for other purposes such as file retrieval.
+
+ For modeling languages that support or require a data
+ model name (e.g., YANG module name) the identifier MUST
+ match that name. For YANG data models, the identifier is
+ the name of the module or submodule. In other cases, an
+ identifier such as a filename MAY be used instead.";
+ }
+
+ leaf version {
+ type string;
+ description
+ "Version of the schema supported. Multiple versions MAY be
+ supported simultaneously by a NETCONF server. Each
+ version MUST be reported individually in the schema list,
+ i.e., with same identifier, possibly different location,
+ but different version.
+
+ For YANG data models, version is the value of the most
+ recent YANG 'revision' statement in the module or
+ submodule, or the empty string if no 'revision' statement
+ is present.";
+ }
+
+ leaf format {
+ type identityref {
+ base schema-format;
+ }
+ description
+ "The data modeling language the schema is written
+ in (currently xsd, yang, yin, rng, or rnc).
+ For YANG data models, 'yang' format MUST be supported and
+ 'yin' format MAY also be provided.";
+ }
+
+ leaf namespace {
+ type inet:uri;
+ mandatory true;
+ description
+ "The XML namespace defined by the data model.
+
+ For YANG data models, this is the module's namespace.
+ If the list entry describes a submodule, this field
+ contains the namespace of the module to which the
+ submodule belongs.";
+ }
+
+ leaf-list location {
+ type union {
+ type enumeration {
+ enum "NETCONF" {
+ value 0;
+ }
+ }
+ type inet:uri;
+ }
+ description
+ "One or more locations from which the schema can be
+ retrieved. This list SHOULD contain at least one
+ entry per schema.
+
+ A schema entry may be located on a remote file system
+ (e.g., reference to file system for ftp retrieval) or
+ retrieved directly from a server supporting the
+ <get-schema> operation (denoted by the value 'NETCONF').";
+ }
+ } // list schema
+ } // container schemas
+
+ container sessions {
+ description
+ "The sessions container includes session-specific data for
+ NETCONF management sessions. The session list MUST include
+ all currently active NETCONF sessions.";
+ list session {
+ key "session-id";
+ description
+ "All NETCONF sessions managed by the NETCONF server
+ MUST be reported in this list.";
+ leaf session-id {
+ type uint32 {
+ range "1..max";
+ }
+ description
+ "Unique identifier for the session. This value is the
+ NETCONF session identifier, as defined in RFC 4741.";
+ reference
+ "RFC 4741: NETCONF Configuration Protocol";
+
+ }
+
+ leaf transport {
+ type identityref {
+ base transport;
+ }
+ mandatory true;
+ description
+ "Identifies the transport for each session, e.g.,
+ 'netconf-ssh', 'netconf-soap', etc.";
+ }
+
+ leaf username {
+ type string;
+ mandatory true;
+ description
+ "The username is the client identity that was authenticated
+ by the NETCONF transport protocol. The algorithm used to
+ derive the username is NETCONF transport protocol specific
+ and in addition specific to the authentication mechanism
+ used by the NETCONF transport protocol.";
+ }
+
+ leaf source-host {
+ type inet:host;
+ description
+ "Host identifier of the NETCONF client. The value
+ returned is implementation specific (e.g., hostname,
+ IPv4 address, IPv6 address)";
+ }
+
+ leaf login-time {
+ type yang:date-and-time;
+ mandatory true;
+ description
+ "Time at the server at which the session was established.";
+ }
+
+ uses common-counters {
+ description
+ "Per-session counters. Zero based with following reset
+ behaviour:
+ - at start of a session
+ - when max value is reached";
+ }
+ } // list session
+ } // container sessions
+
+ container statistics {
+ description
+ "Statistical data pertaining to the NETCONF server.";
+ leaf netconf-start-time {
+ type yang:date-and-time;
+ description
+ "Date and time at which the management subsystem was
+ started.";
+ }
+
+ leaf in-bad-hellos {
+ type yang:zero-based-counter32;
+ description
+ "Number of sessions silently dropped because an
+ invalid <hello> message was received. This includes <hello>
+ messages with a 'session-id' attribute, bad namespace, and
+ bad capability declarations.";
+ }
+
+ leaf in-sessions {
+ type yang:zero-based-counter32;
+ description
+ "Number of sessions started. This counter is incremented
+ when a <hello> message with a <session-id> is sent.
+
+ 'in-sessions' - 'in-bad-hellos' =
+ 'number of correctly started netconf sessions'";
+ }
+
+ leaf dropped-sessions {
+ type yang:zero-based-counter32;
+ description
+ "Number of sessions that were abnormally terminated, e.g.,
+ due to idle timeout or transport close. This counter is not
+ incremented when a session is properly closed by a
+ <close-session> operation, or killed by a <kill-session>
+ operation.";
+ }
+
+ uses common-counters {
+ description
+ "Global counters, accumulated from all sessions.
+ Zero based with following reset behaviour:
+ - re-initialization of NETCONF server
+ - when max value is reached";
+ }
+ } // container statistics
+ } // container netconf-state
+
+ rpc get-schema {
+ description
+ "This operation is used to retrieve a schema from the
+ NETCONF server.
+
+ Positive Response:
+ The NETCONF server returns the requested schema.
+
+ Negative Response:
+ If requested schema does not exist, the <error-tag> is
+ 'invalid-value'.
+
+ If more than one schema matches the requested parameters, the
+ <error-tag> is 'operation-failed', and <error-app-tag> is
+ 'data-not-unique'.";
+ input {
+ leaf identifier {
+ type string;
+ mandatory true;
+ description
+ "Identifier for the schema list entry.";
+ }
+
+ leaf version {
+ type string;
+ description
+ "Version of the schema requested. If this parameter is not
+ present, and more than one version of the schema exists on
+ the server, a 'data-not-unique' error is returned, as
+ described above.";
+ }
+
+ leaf format {
+ type identityref {
+ base schema-format;
+ }
+ description
+ "The data modeling language of the schema. If this
+ parameter is not present, and more than one formats of
+ the schema exists on the server, a 'data-not-unique' error
+ is returned, as described above.";
+ }
+ }
+
+ output {
+ anyxml data {
+ description
+ "Contains the schema content.";
+ }
+ }
+ } // rpc get-schema
+} // module
*/
package io.fd.honeycomb.transportpce.device.read;
+import com.google.common.collect.Sets;
import com.google.common.util.concurrent.Futures;
import com.google.inject.Inject;
import com.google.inject.name.Named;
-
import io.fd.honeycomb.translate.read.ReaderFactory;
import io.fd.honeycomb.translate.read.registry.ModifiableReaderRegistryBuilder;
import io.fd.honeycomb.translate.util.read.BindingBrokerReader;
import io.fd.honeycomb.transportpce.device.DeviceConfiguration;
-
+import java.io.File;
+import java.io.IOException;
+import java.text.DateFormat;
+import java.text.SimpleDateFormat;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Set;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;
-
+import org.opendaylight.controller.config.util.capability.Capability;
+import org.opendaylight.controller.config.util.capability.YangModuleCapability;
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.org.openroadm.device.container.OrgOpenroadmDevice;
import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.org.openroadm.device.container.OrgOpenroadmDeviceBuilder;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.netconf.monitoring.rev101004.NetconfState;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.netconf.monitoring.rev101004.NetconfStateBuilder;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.netconf.monitoring.rev101004.Yang;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.netconf.monitoring.rev101004.netconf.state.Schemas;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.netconf.monitoring.rev101004.netconf.state.SchemasBuilder;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.netconf.monitoring.rev101004.netconf.state.schemas.Schema;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.netconf.monitoring.rev101004.netconf.state.schemas.Schema.Location;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.netconf.monitoring.rev101004.netconf.state.schemas.Schema.Location.Enumeration;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.netconf.monitoring.rev101004.netconf.state.schemas.SchemaBuilder;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.model.api.Module;
+import org.opendaylight.yangtools.yang.model.api.SchemaContext;
+import org.opendaylight.yangtools.yang.model.repo.api.RevisionSourceIdentifier;
+import org.opendaylight.yangtools.yang.model.repo.api.SchemaSourceFilter;
+import org.opendaylight.yangtools.yang.model.repo.api.SchemaSourceRepresentation;
+import org.opendaylight.yangtools.yang.model.repo.api.SourceIdentifier;
+import org.opendaylight.yangtools.yang.model.repo.api.YangTextSchemaSource;
+import org.opendaylight.yangtools.yang.model.repo.spi.PotentialSchemaSource;
+import org.opendaylight.yangtools.yang.model.repo.spi.SchemaSourceListener;
+import org.opendaylight.yangtools.yang.model.repo.util.FilesystemSchemaSourceCache;
+import org.opendaylight.yangtools.yang.parser.repo.SharedSchemaRepository;
+import org.opendaylight.yangtools.yang.parser.util.TextToASTTransformer;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
private static final Logger LOG = LoggerFactory.getLogger(DeviceReaderFactory.class);
public static final InstanceIdentifier<OrgOpenroadmDevice> DEVICE_CONTAINER_ID =
InstanceIdentifier.create(OrgOpenroadmDevice.class);
+ private static final String YANG_MODELS = "yang";
@Inject
@Named("device-databroker")
registry.add(new BindingBrokerReader<>(DEVICE_CONTAINER_ID, dataBroker,LogicalDatastoreType.OPERATIONAL,
OrgOpenroadmDeviceBuilder.class));
if(writeXMLDataToOper()) {
+ writeNetconfState();
loadConfigData();
}
}
}
return res;
}
+
+ /**
+ * Write xml data from {@link DeviceConfiguration}
+ * to operational data.
+ *
+ */
+ public boolean writeNetconfState() {
+ Boolean res = false;
+ LOG.info("writting netconf state to oper datastore");
+ final SharedSchemaRepository schemaRepo = new SharedSchemaRepository("honeynode-simulator");
+ final Set<Capability> capabilities = parseSchemasToModuleCapabilities(schemaRepo);
+ final Set<Capability> transformedCapabilities = Sets.newHashSet(capabilities);
+ DummyMonitoringService monitor = new DummyMonitoringService(transformedCapabilities);
+ List<Schema> schemaList = new ArrayList<Schema>();
+ List<Location> locationList = new ArrayList<Location>();
+ Location location = new Location(Enumeration.NETCONF);
+ locationList.add(location );
+ Schema schematobuild = null;
+ for (final Schema schema : monitor.getSchemas().getSchema()) {
+ schematobuild = new SchemaBuilder()
+ .setIdentifier(schema.getIdentifier())
+ .setNamespace(schema.getNamespace())
+ .setVersion(schema.getVersion())
+ .setFormat(Yang.class)
+ .setLocation(locationList)
+ .build();
+ schemaList.add(schematobuild);
+ }
+ Schemas schemas = new SchemasBuilder()
+ .setSchema(schemaList)
+ .build();
+ NetconfState netconfState = new NetconfStateBuilder()
+ .setSchemas(schemas)
+ .build();
+ if (netconfState !=null) {
+ InstanceIdentifier<NetconfState> iid = InstanceIdentifier.create(NetconfState.class);
+ WriteTransaction writeTx = this.dataBroker.newWriteOnlyTransaction();
+ if (writeTx != null ) {
+ LOG.info("WriteTransaction is ok, copy device info to oper datastore");
+ writeTx.put(LogicalDatastoreType.OPERATIONAL, iid, netconfState);
+ Future<Void> future = writeTx.submit();
+ try {
+ Futures.getChecked(future, ExecutionException.class);
+ LOG.info("netconf state writed to oper datastore");
+ res = true;
+ } catch (ExecutionException e) {
+ LOG.error("Failed to write netconf state to oper datastore");
+ }
+ } else {
+ LOG.error("WriteTransaction object is null");
+ }
+ } else {
+ LOG.error("device data operation gets from xml file is null !");
+ }
+ return res;
+ }
+
+ private Set<Capability> parseSchemasToModuleCapabilities(final SharedSchemaRepository consumer) {
+ final Set<SourceIdentifier> loadedSources = Sets.newHashSet();
+ consumer.registerSchemaSourceListener(TextToASTTransformer.create(consumer, consumer));
+ consumer.registerSchemaSourceListener(new SchemaSourceListener() {
+ @Override
+ public void schemaSourceEncountered(final SchemaSourceRepresentation schemaSourceRepresentation) {}
+
+ @Override
+ public void schemaSourceRegistered(final Iterable<PotentialSchemaSource<?>> potentialSchemaSources) {
+ for (final PotentialSchemaSource<?> potentialSchemaSource : potentialSchemaSources) {
+ loadedSources.add(potentialSchemaSource.getSourceIdentifier());
+ }
+ }
+
+ @Override
+ public void schemaSourceUnregistered(final PotentialSchemaSource<?> potentialSchemaSource) {}
+ });
+ LOG.info("Loading models from directory.");
+ ClassLoader classLoader = Thread.currentThread().getContextClassLoader();
+ File models = new File(classLoader.getResource(YANG_MODELS).getFile());
+ if (models.exists() && models.isDirectory()) {
+ LOG.info("folder '{}' exists !", models.getAbsolutePath());
+ final FilesystemSchemaSourceCache<YangTextSchemaSource> cache = new FilesystemSchemaSourceCache<>(
+ consumer, YangTextSchemaSource.class, models);
+ consumer.registerSchemaSourceListener(cache);
+ } else {
+ LOG.warn("folder '{}' not exists !", models.getAbsolutePath());
+ LOG.info("Custom module loading skipped.");
+ }
+ SchemaContext schemaContext;
+ try {
+ //necessary for creating mdsal data stores and operations
+ schemaContext = consumer.createSchemaContextFactory(SchemaSourceFilter.ALWAYS_ACCEPT)
+ .createSchemaContext(loadedSources).get();
+ } catch (final InterruptedException | ExecutionException e) {
+ throw new RuntimeException("Cannot parse schema context", e);
+ }
+
+ final Set<Capability> capabilities = Sets.newHashSet();
+
+ for (final Module module : schemaContext.getModules()) {
+ for (final Module subModule : module.getSubmodules()) {
+ addModuleCapability(consumer, capabilities, subModule);
+ }
+ addModuleCapability(consumer, capabilities, module);
+ }
+ return capabilities;
+ }
+
+ private static void addModuleCapability(final SharedSchemaRepository consumer, final Set<Capability> capabilities,
+ final Module module) {
+ DateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd");
+
+ //to convert Date to String, use format method of SimpleDateFormat class.
+ String revision = dateFormat.format(module.getRevision());
+ final SourceIdentifier moduleSourceIdentifier = RevisionSourceIdentifier.create(module.getName(),
+ revision);
+ try {
+ final String moduleContent = new String(
+ consumer.getSchemaSource(moduleSourceIdentifier, YangTextSchemaSource.class).get().read());
+ capabilities.add(new YangModuleCapability(module, moduleContent));
+ //IOException would be thrown in creating SchemaContext already
+ } catch (ExecutionException | InterruptedException | IOException e) {
+ LOG.warn("Cannot retrieve schema source for module {} from schema repository",
+ moduleSourceIdentifier.toString(), e);
+ }
+}
}
--- /dev/null
+/*
+ * Copyright (c) 2018 Orange and/or its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at:
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package io.fd.honeycomb.transportpce.device.read;
+
+import com.google.common.base.Function;
+import com.google.common.base.Optional;
+import com.google.common.collect.ArrayListMultimap;
+import com.google.common.collect.Collections2;
+import com.google.common.collect.Lists;
+import com.google.common.collect.Sets;
+import java.util.Collections;
+import java.util.Set;
+import javax.annotation.Nonnull;
+import javax.annotation.Nullable;
+import org.opendaylight.controller.config.util.capability.Capability;
+import org.opendaylight.netconf.api.monitoring.NetconfManagementSession;
+import org.opendaylight.netconf.api.monitoring.NetconfMonitoringService;
+import org.opendaylight.netconf.api.monitoring.SessionEvent;
+import org.opendaylight.netconf.api.monitoring.SessionListener;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Uri;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.netconf.monitoring.rev101004.Yang;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.netconf.monitoring.rev101004.netconf.state.Capabilities;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.netconf.monitoring.rev101004.netconf.state.CapabilitiesBuilder;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.netconf.monitoring.rev101004.netconf.state.Schemas;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.netconf.monitoring.rev101004.netconf.state.SchemasBuilder;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.netconf.monitoring.rev101004.netconf.state.Sessions;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.netconf.monitoring.rev101004.netconf.state.SessionsBuilder;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.netconf.monitoring.rev101004.netconf.state.schemas.Schema;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.netconf.monitoring.rev101004.netconf.state.schemas.Schema.Location;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.netconf.monitoring.rev101004.netconf.state.schemas.Schema.Location.Enumeration;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.netconf.monitoring.rev101004.netconf.state.schemas.SchemaBuilder;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.netconf.monitoring.rev101004.netconf.state.schemas.SchemaKey;
+
+public class DummyMonitoringService implements NetconfMonitoringService {
+
+ private static final Sessions EMPTY_SESSIONS = new SessionsBuilder().setSession(Collections.emptyList()).build();
+ private static final Function<Capability, Uri> CAPABILITY_URI_FUNCTION =
+ capability -> new Uri(capability.getCapabilityUri());
+
+ private static final Function<Capability, Schema> CAPABILITY_SCHEMA_FUNCTION = new Function<Capability, Schema>() {
+ @Nullable
+ @Override
+ public Schema apply(@Nonnull final Capability capability) {
+ return new SchemaBuilder()
+ .setIdentifier(capability.getModuleName().get())
+ .setNamespace(new Uri(capability.getModuleNamespace().get()))
+ .setFormat(Yang.class)
+ .setVersion(capability.getRevision().get())
+ .setLocation(Collections.singletonList(new Location(Enumeration.NETCONF)))
+ .setKey(new SchemaKey(Yang.class, capability.getModuleName().get(),
+ capability.getRevision().get()))
+ .build();
+ }
+ };
+
+ private final Capabilities capabilities;
+ private final ArrayListMultimap<String, Capability> capabilityMultiMap;
+ private final Schemas schemas;
+
+ public DummyMonitoringService(final Set<Capability> capabilities) {
+
+ this.capabilities = new CapabilitiesBuilder().setCapability(
+ Lists.newArrayList(Collections2.transform(capabilities, CAPABILITY_URI_FUNCTION))).build();
+
+ Set<Capability> moduleCapabilities = Sets.newHashSet();
+ this.capabilityMultiMap = ArrayListMultimap.create();
+ for (Capability cap : capabilities) {
+ if (cap.getModuleName().isPresent()) {
+ capabilityMultiMap.put(cap.getModuleName().get(), cap);
+ moduleCapabilities.add(cap);
+ }
+ }
+
+ this.schemas = new SchemasBuilder().setSchema(
+ Lists.newArrayList(Collections2.transform(moduleCapabilities, CAPABILITY_SCHEMA_FUNCTION))).build();
+ }
+
+ @Override
+ public Sessions getSessions() {
+ return EMPTY_SESSIONS;
+ }
+
+ @Override
+ public SessionListener getSessionListener() {
+ return new SessionListener() {
+ @Override
+ public void onSessionUp(final NetconfManagementSession session) {
+ //no op
+ }
+
+ @Override
+ public void onSessionDown(final NetconfManagementSession session) {
+ //no op
+ }
+
+ @Override
+ public void onSessionEvent(final SessionEvent event) {
+ //no op
+ }
+ };
+ }
+
+ @Override
+ public Schemas getSchemas() {
+ return schemas;
+ }
+
+ @Override
+ public String getSchemaForCapability(final String moduleName, final Optional<String> revision) {
+
+ for (Capability capability : capabilityMultiMap.get(moduleName)) {
+ if (capability.getRevision().get().equals(revision.get())) {
+ return capability.getCapabilitySchema().get();
+ }
+ }
+ throw new IllegalArgumentException(
+ "Module with name: " + moduleName + " and revision: " + revision + " does not exist");
+ }
+
+ @Override
+ public Capabilities getCapabilities() {
+ return capabilities;
+ }
+
+ @Override
+ public AutoCloseable registerCapabilitiesListener(final CapabilitiesListener listener) {
+ return null;
+ }
+
+ @Override
+ public AutoCloseable registerSessionsListener(final SessionsListener listener) {
+ return null;
+ }
+
+}
\ No newline at end of file
--- /dev/null
+/*
+ * Copyright (c) 2018 Orange and/or its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at:
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package io.fd.honeycomb.transportpce.device.write;
+
+import com.google.common.base.Optional;
+import com.google.common.base.Preconditions;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Iterator;
+import java.util.List;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.Future;
+
+import org.opendaylight.controller.md.sal.binding.api.DataBroker;
+import org.opendaylight.controller.md.sal.binding.api.DataObjectModification;
+import org.opendaylight.controller.md.sal.binding.api.DataTreeChangeListener;
+import org.opendaylight.controller.md.sal.binding.api.DataTreeIdentifier;
+import org.opendaylight.controller.md.sal.binding.api.DataTreeModification;
+import org.opendaylight.controller.md.sal.binding.api.ReadTransaction;
+import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
+import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.circuit.pack.Ports;
+import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.circuit.pack.PortsBuilder;
+import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.circuit.packs.CircuitPacks;
+import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.circuit.packs.CircuitPacksKey;
+import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.interfaces.grp.Interface;
+import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.interfaces.grp.InterfaceKey;
+import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.org.openroadm.device.container.OrgOpenroadmDevice;
+import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.org.openroadm.device.container.OrgOpenroadmDeviceBuilder;
+import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.org.openroadm.device.container.org.openroadm.device.RoadmConnections;
+import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.org.openroadm.device.container.org.openroadm.device.RoadmConnectionsKey;
+import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.port.Interfaces;
+import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.port.InterfacesBuilder;
+import org.opendaylight.yangtools.yang.binding.DataObject;
+import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.binding.InstanceIdentifier.PathArgument;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+/**
+ * @author Martial COULIBALY ( mcoulibaly.ext@orange.com ) on behalf of Orange
+ */
+final class DeviceChangeListener implements DataTreeChangeListener<OrgOpenroadmDevice> {
+
+ private static final Logger LOG = LoggerFactory.getLogger(DeviceChangeListener.class);
+ private final DataBroker dataBroker;
+
+ public DeviceChangeListener(DataBroker deviceDataBroker) {
+ this.dataBroker = deviceDataBroker;
+ Preconditions.checkArgument(this.dataBroker != null, "Device datastore is null");
+ }
+
+ @Override
+ public void onDataTreeChanged(Collection<DataTreeModification<OrgOpenroadmDevice>> changes) {
+ LOG.info("onDataTreeChanged");
+ for (DataTreeModification<OrgOpenroadmDevice> change : changes) {
+ final DataObjectModification<OrgOpenroadmDevice> rootNode = change.getRootNode();
+ final DataTreeIdentifier<OrgOpenroadmDevice> rootPath = change.getRootPath();
+ if (rootNode != null ) {
+ final OrgOpenroadmDevice dataBefore = rootNode.getDataBefore();
+ final OrgOpenroadmDevice dataAfter = rootNode.getDataAfter();
+ LOG.info("Received Device change({}):\n before={} \n after={}", rootNode.getModificationType(), dataBefore,
+ dataAfter);
+ Collection<DataObjectModification<? extends DataObject>> modifiedChildren = rootNode.getModifiedChildren();
+ switch (rootNode.getModificationType()) {
+ case SUBTREE_MODIFIED:
+ if (!modifiedChildren.isEmpty()) {
+ Iterator<DataObjectModification<? extends DataObject>> iterator = modifiedChildren.iterator();
+ while (iterator.hasNext()) {
+ DataObjectModification<? extends DataObject> modified = iterator.next();
+ LOG.info("modified = \ndataType : {}\nid : {}\nmodifiedType : {}\noldData : {}\nnewData : {} \n",
+ modified.getDataType(), modified.getIdentifier(),modified.getModificationType(),
+ modified.getDataBefore(), modified.getDataAfter());
+ switch (modified.getModificationType()) {
+ case SUBTREE_MODIFIED:
+ case WRITE :
+ processChange(rootPath.getRootIdentifier(), modified, dataAfter);
+ updateCircuitPackInterface(rootPath.getRootIdentifier(), modified, false);
+ break;
+ case DELETE:
+ updateCircuitPackInterface(rootPath.getRootIdentifier(), modified, true);
+ deleteContainer(rootPath, modified);
+ break;
+ default:
+ break;
+ }
+ }
+ }
+ //processChange(rootPath.getRootIdentifier(), dataAfter);
+ break;
+ case WRITE :
+ processChange(rootPath.getRootIdentifier(), null, dataAfter);
+ break;
+ case DELETE:
+ LOG.info("device config datastore is deleted !");
+ break;
+ default:
+ break;
+ }
+ } else {
+ LOG.error("rootNode is null !");
+ }
+ }
+ }
+
+ /**
+ * Delete change from device
+ * oper datastore.
+ *
+ * @param id container identifier
+ */
+ private void deleteContainer(DataTreeIdentifier<OrgOpenroadmDevice> rootPath,
+ DataObjectModification<? extends DataObject> modified) {
+ final String ROADM_CONNECTIONS = "interface org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206"
+ + ".org.openroadm.device.container.org.openroadm.device.RoadmConnections";
+ final String INTERFACE_GRP = "interface org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206"
+ + ".interfaces.grp.Interface";
+ Class<? extends DataObject> type = modified.getDataType();
+ PathArgument path = modified.getIdentifier();
+ LOG.info("deleting container type '{}' with id '{}' ...", type.toString(), path);
+ String key = extractKey(path.toString());
+ if ( key != null) {
+ InstanceIdentifier<?> iid = null;
+ switch (type.toString()) {
+ case ROADM_CONNECTIONS:
+ LOG.info("roadm-connections ...");
+ iid = rootPath.getRootIdentifier().child(RoadmConnections.class,
+ new RoadmConnectionsKey(key));
+ break;
+ case INTERFACE_GRP:
+ LOG.info("interface ....");
+ iid = rootPath.getRootIdentifier().child(Interface.class,
+ new InterfaceKey(key));
+ default:
+ break;
+ }
+ LOG.info("iid : {}", iid);
+ WriteTransaction writeTx = this.dataBroker.newWriteOnlyTransaction();
+ if (writeTx != null) {
+ LOG.info("WriteTransaction is ok, delete container device from device oper datastore");
+ try {
+ LOG.info("deleting container element from device oper DS ...");
+ writeTx.delete(LogicalDatastoreType.OPERATIONAL, iid);
+ Future<Void> future = writeTx.submit();
+ future.get();
+ LOG.info("container element '{}' deleted from device oper datastore", iid);
+ } catch (InterruptedException | ExecutionException e) {
+ LOG.error("Failed to process WriteTransactions",e);
+ }
+ } else {
+ LOG.error("WriteTransaction object is null");
+ }
+ } else {
+ LOG.error("extract key is null");
+ }
+ }
+
+
+
+ private String extractKey(String path) {
+ LOG.info("getting key from pathArgument ...");
+ String result = null;
+ if (path != null && path.length() > 2) {
+ result = path.substring(path.lastIndexOf("=") + 1, path.length()-2);
+ LOG.info("result : {}", result);
+ } else {
+ LOG.error("String pathArgument is not compliant !!");
+ }
+ return result;
+ }
+
+
+ /**
+ * Merge change to Honeycomb
+ * config datastore and device
+ * config datastore.
+ *
+ * @param id OrgOpenroadmDevice identifier
+ * @param dataAfter OrgOpenroadmDevice to be merged
+ */
+ private void processChange(final InstanceIdentifier<OrgOpenroadmDevice> id,
+ DataObjectModification<? extends DataObject> modified, final OrgOpenroadmDevice dataAfter) {
+ LOG.info("processing change ...");
+ WriteTransaction writeTx = this.dataBroker.newWriteOnlyTransaction();
+ if (writeTx != null) {
+ LOG.info("WriteTransactions are ok, merge device info to datastores");
+ if(dataAfter != null) {
+ String deviceId = dataAfter.getInfo().getNodeId();
+ writeTx.merge(LogicalDatastoreType.OPERATIONAL, id, dataAfter);
+ Future<Void> future = writeTx.submit();
+ try {
+ future.get();
+ LOG.info("device '{}' merged to device oper datastore", deviceId);
+ } catch (InterruptedException | ExecutionException e) {
+ LOG.error("Failed to merge Element '{}' to datastores", deviceId);
+ }
+ } else {
+ LOG.error("device is null");
+ }
+ } else {
+ LOG.error("WriteTransaction object is null");
+ }
+ }
+
+ /**
+ *Update Interface info on
+ *Ports list in CircuitPacks.
+ *
+ * @param id device InstanceIdentifier
+ * @param modified DataObjectModification
+ * @param deviceData OrgOpenroadmDevice
+ * @param delete if yes delete interface from circuitpacks else adding interface
+ */
+ private void updateCircuitPackInterface(final InstanceIdentifier<OrgOpenroadmDevice> id,
+ DataObjectModification<? extends DataObject> modified, boolean delete) {
+ LOG.info("Updating circuit packs interface ...");
+ final String INTERFACE_GRP = "interface org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206"
+ + ".interfaces.grp.Interface";
+ InstanceIdentifier<CircuitPacks> iid = null;
+ if (modified != null) {
+ Class<? extends DataObject> type = modified.getDataType();
+ LOG.info("getting container type '{}' ...", type.toString());
+ if (type != null) {
+ if (type.toString().compareTo(INTERFACE_GRP) == 0) {
+ LOG.warn("interface update ! ");
+ Interface data = null;
+ if (delete) {
+ data = (Interface) modified.getDataBefore();
+ } else {
+ data = (Interface) modified.getDataAfter();
+ }
+ LOG.info("Interface data gets : {}", data.toString());
+ if (data!= null) {
+ String circuitPackName = data.getSupportingCircuitPackName();
+ String port = data.getSupportingPort().toString();
+ String interfaceName = data.getName();
+ if (circuitPackName != null && port != null && interfaceName != null) {
+ iid = id.child(CircuitPacks.class,
+ new CircuitPacksKey(circuitPackName));
+ OrgOpenroadmDevice operDevice = readDeviceOperData(id);
+ if (operDevice != null) {
+ OrgOpenroadmDeviceBuilder builder = new OrgOpenroadmDeviceBuilder(operDevice);
+ List<CircuitPacks> list = builder.getCircuitPacks();
+ LOG.info("Getting circuit packs ...");
+ for (CircuitPacks circuitPacks : list) {
+ if (circuitPacks.getCircuitPackName().compareTo(circuitPackName) == 0) {
+ LOG.info("circuitpack found");
+ List<Ports> portList = circuitPacks.getPorts();
+ LOG.info("Getting ports for circuit pack '{}' ...", circuitPackName);
+ for (Ports ports : portList) {
+ if (ports.getPortName().compareTo(port) == 0) {
+ LOG.info("port found");
+ PortsBuilder newPorts = new PortsBuilder(ports);
+ List<org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206
+ .port.Interfaces> value = newPorts.getInterfaces();
+ if (!delete) {
+ LOG.info("adding interface info to port '{}'", port);
+ if (value == null || value.isEmpty()) {
+ LOG.info("Interfaces List is empty !");
+ value = new ArrayList<org.opendaylight.yang.gen.v1.http.org
+ .openroadm.device.rev170206.port.Interfaces>();
+ value.add(new InterfacesBuilder().setInterfaceName(interfaceName)
+ .build());
+ } else { // value is not empty
+ org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206
+ .port.Interfaces tmp = getInterfaces(value, interfaceName);
+ if( tmp != null) {
+ LOG.warn("Interfaces with name '{}' already exists !",interfaceName);
+ break;
+ } else { // no interface found
+ value.add(new InterfacesBuilder().setInterfaceName(interfaceName)
+ .build());
+ }
+ }
+ } else {
+ LOG.info("removing interface info from port '{}'", port);
+ org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206
+ .port.Interfaces tmp = getInterfaces(value, interfaceName);
+ if( tmp != null) {
+ LOG.info("Interfaces with name '{}' gets",interfaceName);
+ value.remove(tmp);
+ }else {
+ LOG.error("Interfaces list is null");
+ value = new ArrayList<org.opendaylight.yang.gen.v1.http.org.openroadm
+ .device.rev170206.port.Interfaces>();
+ }
+ }
+ newPorts.setInterfaces(value);
+ portList.remove(ports);
+ portList.add(newPorts.build());
+ LOG.info("port list updated !");
+ update(circuitPacks, iid);
+ break;
+ }
+ }
+ break;
+ }
+ }
+ } else {
+ LOG.error("reading operational device data failed !");
+ }
+
+ } else {
+ LOG.error("SupportingCircuitPackName / SupportingPort / Interface Name are/is null !");
+ }
+ }
+ } else {
+ LOG.warn("not an interface update ! ");
+ }
+ }
+ } else {
+ LOG.error("DataObjectModification is null");
+ }
+ }
+
+ /**
+ * Search in {@link Interfaces} list
+ * if an interfaces already exists.
+ *
+ * @param value Interfaces List
+ * @param interfaceName Interface Name
+ * @return Interfaces
+ */
+ private org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.port.Interfaces getInterfaces(
+ List<org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.port.Interfaces> value,
+ String interfaceName) {
+ org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.port.Interfaces result = null;
+ if (value != null && !value.isEmpty()) {
+ LOG.info("Getting interfaces list ...");
+ for (org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206
+ .port.Interfaces tmp : value) {
+ if( tmp != null
+ && tmp.getInterfaceName().compareTo(interfaceName) == 0) {
+ LOG.info("Interfaces with name '{}' gets",interfaceName);
+ result = tmp;
+ break;
+ }
+ }
+ } else {
+ LOG.error("Interfaces list is empty");
+ }
+ return result;
+ }
+
+ /**
+ * Update circuitPacks information
+ * in device oper datastore.
+ *
+ * @param circuitPacks CircuitPacks data
+ * @param iid CircuitPacks InstanceIdentifier
+ * @param id OrgOpenroadmDevice InstanceIdentifier
+ * @param deviceData OrgOpenroadmDevice data
+ */
+ private void update(CircuitPacks circuitPacks, final InstanceIdentifier<CircuitPacks> iid) {
+ LOG.info("updating oper Datastore with iid : {}", iid);
+ WriteTransaction writeTx = this.dataBroker.newWriteOnlyTransaction();
+ if (writeTx != null) {
+ LOG.info("WriteTransaction is ok, update container circuitpacks from device oper datastore");
+ try {
+ LOG.info("updating container circuitpacks from device oper DS ...");
+ writeTx.merge(LogicalDatastoreType.OPERATIONAL, iid,circuitPacks);
+ Future<Void> future = writeTx.submit();
+ future.get();
+ LOG.info("container circuitpacks '{}' merged to device oper datastore", iid);
+ } catch (InterruptedException | ExecutionException e) {
+ LOG.error("Failed to process WriteTransactions",e);
+ }
+ } else {
+ LOG.error("WriteTransaction object is null");
+ }
+ }
+
+ /**
+ * Get {@link OrgOpenroadmDevice} data
+ * from operational datastore
+ *
+ * @param id OrgOpenroadmDevice InstanceIdentifier
+ * @return OrgOpenroadmDevice result
+ */
+ private OrgOpenroadmDevice readDeviceOperData(final InstanceIdentifier<OrgOpenroadmDevice> id) {
+ OrgOpenroadmDevice result = null;
+ LOG.info("reading device operational datastore ...");
+ ReadTransaction readTx = this.dataBroker.newReadOnlyTransaction();
+ if (readTx != null) {
+ LOG.info("ReadTransaction is ok");
+ try {
+ LOG.info("reading device from device oper DS ...");
+ Optional<OrgOpenroadmDevice> device = readTx.read(LogicalDatastoreType.OPERATIONAL, id).get();
+ if (device.isPresent()) {
+ result = device.get();
+ LOG.info("device gets from device oper datastore");
+ }
+ } catch (InterruptedException | ExecutionException e) {
+ LOG.error("Failed to process ReadTransaction",e);
+ }
+ } else {
+ LOG.error("ReadTransaction object is null");
+ }
+ return result;
+
+ }
+
+}
import com.google.inject.Inject;
import com.google.inject.name.Named;
-
import io.fd.honeycomb.translate.util.write.BindingBrokerWriter;
import io.fd.honeycomb.translate.write.WriterFactory;
import io.fd.honeycomb.translate.write.registry.ModifiableWriterRegistryBuilder;
-
import javax.annotation.Nonnull;
-
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
+import org.opendaylight.controller.md.sal.binding.api.DataTreeIdentifier;
+import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.org.openroadm.device.container.OrgOpenroadmDevice;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
@Override
public void init(@Nonnull final ModifiableWriterRegistryBuilder registry) {
registry.wildcardedSubtreeAdd(new BindingBrokerWriter<>(DEVICE_CONTAINER_ID, deviceDataBroker));
+ deviceDataBroker.registerDataTreeChangeListener(new DataTreeIdentifier<>(LogicalDatastoreType.CONFIGURATION,
+ DEVICE_CONTAINER_ID), new DeviceChangeListener(deviceDataBroker));
}
}
+++ /dev/null
-/*
- * Copyright (c) 2018 Orange and/or its affiliates.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at:
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package io.fd.honeycomb.infra.distro.initializer;
-
-import com.google.common.base.Preconditions;
-
-import java.util.Collection;
-import java.util.Iterator;
-import java.util.concurrent.ExecutionException;
-import java.util.concurrent.Future;
-
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.DataObjectModification;
-import org.opendaylight.controller.md.sal.binding.api.DataTreeChangeListener;
-import org.opendaylight.controller.md.sal.binding.api.DataTreeIdentifier;
-import org.opendaylight.controller.md.sal.binding.api.DataTreeModification;
-import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.interfaces.grp.Interface;
-import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.interfaces.grp.InterfaceKey;
-import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.org.openroadm.device.container.OrgOpenroadmDevice;
-import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.org.openroadm.device.container.org.openroadm.device.RoadmConnections;
-import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.org.openroadm.device.container.org.openroadm.device.RoadmConnectionsKey;
-import org.opendaylight.yangtools.yang.binding.DataObject;
-import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
-import org.opendaylight.yangtools.yang.binding.InstanceIdentifier.PathArgument;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-/**
- * @author Martial COULIBALY ( mcoulibaly.ext@orange.com ) on behalf of Orange
- */
-final class DeviceChangeListener implements DataTreeChangeListener<OrgOpenroadmDevice> {
-
- private static final Logger LOG = LoggerFactory.getLogger(DeviceChangeListener.class);
- private final DataBroker honeyCombDB;
- private final DataBroker dataBroker;
-
- public DeviceChangeListener(DataBroker deviceDataBroker, DataBroker honeycombDB) {
- this.dataBroker = deviceDataBroker;
- this.honeyCombDB = honeycombDB;
- Preconditions.checkArgument(this.dataBroker != null, "Device datastore is null");
- Preconditions.checkArgument(this.honeyCombDB != null, "HC datastore is null");
- }
-
- @Override
- public void onDataTreeChanged(Collection<DataTreeModification<OrgOpenroadmDevice>> changes) {
- LOG.info("onDataTreeChanged");
- for (DataTreeModification<OrgOpenroadmDevice> change : changes) {
- final DataObjectModification<OrgOpenroadmDevice> rootNode = change.getRootNode();
- final DataTreeIdentifier<OrgOpenroadmDevice> rootPath = change.getRootPath();
- if (rootNode != null ) {
- final OrgOpenroadmDevice dataBefore = rootNode.getDataBefore();
- final OrgOpenroadmDevice dataAfter = rootNode.getDataAfter();
- LOG.info("Received Device change({}):\n before={} \n after={}", rootNode.getModificationType(), dataBefore,
- dataAfter);
- Collection<DataObjectModification<? extends DataObject>> modifiedChildren = rootNode.getModifiedChildren();
- switch (rootNode.getModificationType()) {
- case SUBTREE_MODIFIED:
- if (!modifiedChildren.isEmpty()) {
- Iterator<DataObjectModification<? extends DataObject>> iterator = modifiedChildren.iterator();
- while (iterator.hasNext()) {
- DataObjectModification<? extends DataObject> modified = iterator.next();
- LOG.info("modified = \ndataType : {}\nid : {}\nmodifiedType : {}\noldData : {}\nnewData : {} \n",
- modified.getDataType(), modified.getIdentifier(),modified.getModificationType(),
- modified.getDataBefore(), modified.getDataAfter());
- switch (modified.getModificationType()) {
- case SUBTREE_MODIFIED:
- case WRITE :
- processChange(rootPath.getRootIdentifier(), dataAfter);
- break;
- case DELETE:
- deleteContainer(rootPath, modified, dataAfter);
- break;
- default:
- break;
- }
- }
- }
- processChange(rootPath.getRootIdentifier(), dataAfter);
- break;
- case WRITE :
- processChange(rootPath.getRootIdentifier(), dataAfter);
- break;
- case DELETE:
- deleteChange(rootPath.getRootIdentifier(),dataBefore);
- break;
- default:
- break;
- }
- } else {
- LOG.error("rootNode is null !");
- }
- }
- }
-
- /**
- * Delete change from device
- * oper datastore.
- *
- * @param id container identifier
- */
- private void deleteContainer(DataTreeIdentifier<OrgOpenroadmDevice> rootPath,
- DataObjectModification<? extends DataObject> modified, final OrgOpenroadmDevice dataAfter) {
- final String ROADM_CONNECTIONS = "interface org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206"
- + ".org.openroadm.device.container.org.openroadm.device.RoadmConnections";
- final String INTERFACE_GRP = "interface org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206"
- + ".interfaces.grp.Interface";
- Class<? extends DataObject> type = modified.getDataType();
- PathArgument path = modified.getIdentifier();
- LOG.info("deleting container type '{}' with id '{}' ...", type.toString(), path);
- String key = extractKey(path.toString());
- if ( key != null) {
- InstanceIdentifier<?> iid = null;
- switch (type.toString()) {
- case ROADM_CONNECTIONS:
- LOG.info("roadm-connections ...");
- iid = rootPath.getRootIdentifier().child(RoadmConnections.class,
- new RoadmConnectionsKey(key));
- break;
- case INTERFACE_GRP:
- LOG.info("interface ....");
- iid = rootPath.getRootIdentifier().child(Interface.class,
- new InterfaceKey(key));
- default:
- break;
- }
- LOG.info("iid : {}", iid);
- WriteTransaction writeTx = this.dataBroker.newWriteOnlyTransaction();
- WriteTransaction writeHCTx = this.honeyCombDB.newWriteOnlyTransaction();
- if (writeTx != null && writeHCTx != null) {
- LOG.info("WriteTransaction is ok, delete container device from device oper datastore");
- try {
- LOG.info("deleting container element from device oper DS ...");
- writeTx.delete(LogicalDatastoreType.OPERATIONAL, iid);
- Future<Void> future = writeTx.submit();
- future.get();
- LOG.info("container element '{}' deleted from device oper datastore", iid);
- LOG.info("deleting from HC config DS ...");
- writeHCTx.put(LogicalDatastoreType.CONFIGURATION, rootPath.getRootIdentifier(),dataAfter);
- future = writeHCTx.submit();
- future.get();
- LOG.info("device config DS '{}' updated to HC config DS", rootPath.getRootIdentifier());
- } catch (InterruptedException | ExecutionException e) {
- LOG.error("Failed to process WriteTransactions",e);
- }
- } else {
- LOG.error("WriteTransaction object is null");
- }
- } else {
- LOG.error("extract key is null");
- }
- }
-
- private String extractKey(String path) {
- LOG.info("getting key from pathArgument ...");
- String result = null;
- if (path != null && path.length() > 2) {
- result = path.substring(path.lastIndexOf("=") + 1, path.length()-2);
- LOG.info("result : {}", result);
- } else {
- LOG.error("String pathArgument is not compliant !!");
- }
- return result;
- }
-
- /**
- * Delete change from Honeycomb
- * config datastore.
- *
- * @param id OrgOpenroadmDevice identifier
- * @param dataBefore OrgOpenroadmDevice before delete action
- */
- private void deleteChange(final InstanceIdentifier<OrgOpenroadmDevice> id, final OrgOpenroadmDevice dataBefore) {
- LOG.info("deleting change ...");
- WriteTransaction writeHCTx = this.honeyCombDB.newWriteOnlyTransaction();
- if (writeHCTx != null) {
- LOG.info("WriteTransaction is ok, delete device info from HC config datastore");
- if(dataBefore != null) {
- String deviceId = dataBefore.getInfo().getNodeId();
- try {
- writeHCTx.delete(LogicalDatastoreType.CONFIGURATION, id);
- Future<Void> future = writeHCTx.submit();
- future.get();
- LOG.info("device '{}' deleted from HC config datastore", deviceId);
- } catch (InterruptedException | ExecutionException e) {
- LOG.error("Failed to delete Element '{}' from datastore", deviceId);
- }
- } else {
- LOG.error("OrgOpenroadmDevice is null");
- }
- } else {
- LOG.error("WriteTransaction object is null");
- }
-
- }
-
- /**
- * Merge change to Honeycomb
- * config datastore and device
- * config datastore.
- *
- * @param id OrgOpenroadmDevice identifier
- * @param dataAfter OrgOpenroadmDevice to be merged
- */
- private void processChange(final InstanceIdentifier<OrgOpenroadmDevice> id, final OrgOpenroadmDevice dataAfter) {
- LOG.info("processing change ...");
- WriteTransaction writeTx = this.dataBroker.newWriteOnlyTransaction();
- WriteTransaction writeHCTx = this.honeyCombDB.newWriteOnlyTransaction();
- if (writeTx != null && writeHCTx != null) {
- LOG.info("WriteTransactions are ok, merge device info to datastores");
- if(dataAfter != null) {
- String deviceId = dataAfter.getInfo().getNodeId();
- writeTx.merge(LogicalDatastoreType.OPERATIONAL, id, dataAfter);
- Future<Void> future = writeTx.submit();
- try {
- future.get();
- LOG.info("device '{}' merged to device oper datastore", deviceId);
- writeHCTx.merge(LogicalDatastoreType.CONFIGURATION, id, dataAfter);
- future = writeHCTx.submit();
- future.get();
- LOG.info("device '{}' merged to HC config datastore", deviceId);
- } catch (InterruptedException | ExecutionException e) {
- LOG.error("Failed to merge Element '{}' to datastores", deviceId);
- }
- } else {
- LOG.error("device is null");
- }
- } else {
- LOG.error("WriteTransaction object is null");
- }
- }
-
-}
import io.fd.honeycomb.translate.ModificationCache;
import io.fd.honeycomb.translate.read.ReadContext;
import io.fd.honeycomb.translate.read.registry.InitRegistry;
-
import javax.annotation.Nonnull;
-
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.DataTreeIdentifier;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.org.openroadm.device.container.OrgOpenroadmDevice;
-import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
private final InitRegistry initRegistry;
private final DataBroker dataBroker;
private final MappingContext realtimeMappingContext;
- /** Add by Martial. */
- private final DataBroker deviceDataBroker;
- private final DataBroker hcConfigDataBroker;
- private final InstanceIdentifier<OrgOpenroadmDevice> DEVICE_CONTAINER_ID = InstanceIdentifier
- .create(OrgOpenroadmDevice.class);
InitializerRegistryAdapter(final DataTreeInitializer configInitializer,
final DataTreeInitializer contextInitializer,
final InitRegistry initRegistry,
final DataBroker noopConfigDataBroker,
- final MappingContext realtimeMappingContext,
- final DataBroker deviceDataBroker,
- final DataBroker hcConfigDataBroker) {
+ final MappingContext realtimeMappingContext) {
this.configInitializer = configInitializer;
this.contextInitializer = contextInitializer;
this.initRegistry = initRegistry;
this.dataBroker = noopConfigDataBroker;
this.realtimeMappingContext = realtimeMappingContext;
- this.deviceDataBroker = deviceDataBroker;
- this.hcConfigDataBroker = hcConfigDataBroker;
}
@Override
public void initialize() throws DataTreeInitializer.InitializeException {
LOG.info("Config initialization started");
try {
- LOG.info("Register device databroker listener ...");
- deviceDataBroker
- .registerDataTreeChangeListener(new DataTreeIdentifier<>(LogicalDatastoreType.CONFIGURATION,
- DEVICE_CONTAINER_ID), new DeviceChangeListener(deviceDataBroker, hcConfigDataBroker));
- LOG.info("Device databroker listener registered");
// Initialize contexts first so that other initializers can find any relevant mapping before initializing
// configuration to what is already in VPP
contextInitializer.initialize();
import com.google.inject.Inject;
import com.google.inject.name.Named;
-
import io.fd.honeycomb.binding.init.ProviderTrait;
import io.fd.honeycomb.data.init.DataTreeInitializer;
import io.fd.honeycomb.data.init.InitializerRegistry;
import io.fd.honeycomb.translate.MappingContext;
import io.fd.honeycomb.translate.read.registry.ReaderRegistry;
-
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
public final class InitializerRegistryAdapterProvider extends ProviderTrait<InitializerRegistry> {
@Inject
@Named(HONEYCOMB_CONTEXT)
private MappingContext realtimeMappingContext;
- @Inject
- @Named("device-databroker")
- private DataBroker deviceDataBroker;
- @Inject
- @Named(HONEYCOMB_CONFIG)
- private DataBroker configDataBroker;
@Override
protected InitializerRegistryAdapter create() {
return new InitializerRegistryAdapter(configInitializer, contextInitializer, initRegistry,
- noopConfigDataBroker, realtimeMappingContext, deviceDataBroker, configDataBroker);
+ noopConfigDataBroker, realtimeMappingContext);
}
}
filename=$(basename -- "$CONFIG")
echo "changing netconf port with $PORT in netconf.json file ..."
sed -i "/netconf-ssh-binding-port/c\ \"netconf-ssh-binding-port\" : "$PORT"," $(dirname $0)/config/netconf.json
- echo "changing context and config path in honeycomb.json file ..."
- sed -i "/persisted-context-path/c\ \"persisted-context-path\" : \"./persist/"$PORT"/context/data.json\"," $(dirname $0)/config/honeycomb.json
- sed -i "/persisted-config-path/c\ \"persisted-config-path\" : \"./persist/"$PORT"/config/data.json\"," $(dirname $0)/config/honeycomb.json
+ echo "changing persist-context and persist-config to false in honeycomb.json file ..."
+ sed -i "/persist-context/c\ \"persist-context\" : \"false\"," $(dirname $0)/config/honeycomb.json
+ sed -i "/persist-config/c\ \"persist-config\" : \"false\"," $(dirname $0)/config/honeycomb.json
echo "changing netconf-initial-config-xml location with $CONFIG in honeycomb.json file ..."
sed -i "/netconf-initial-config-xml/c\ \"netconf-initial-config-xml\" : \"device/$filename\"" $(dirname $0)/config/honeycomb.json
while [ $STATUS -eq 100 ]
do
- java -Xms32m -Xmn90m -Xmx128m -XX:MetaspaceSize=32m -XX:MaxMetaspaceSize=128m -jar $(dirname $0)/honeynode-distribution-1.18.01.jar
+ java -Xms512m -Xmn512m -Xmx1024m -XX:MetaspaceSize=128m -XX:MaxMetaspaceSize=512m -jar $(dirname $0)/honeynode-distribution-1.18.01.jar
STATUS=$?
echo "Honeycomb exited with status: $STATUS"
if [ $STATUS -eq 100 ]
--- /dev/null
+<?xml version="1.0" encoding="UTF-8"?>
+<!--
+ ~ 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
+ -->
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+ <modelVersion>4.0.0</modelVersion>
+
+ <parent>
+ <groupId>org.opendaylight.odlparent</groupId>
+ <artifactId>bundle-parent</artifactId>
+ <version>2.0.5</version>
+ <relativePath/>
+ </parent>
+
+ <groupId>org.opendaylight.netconf</groupId>
+ <artifactId>netconf-netty-util</artifactId>
+ <packaging>bundle</packaging>
+ <version>1.3.1</version>
+ <name>${project.artifactId}</name>
+
+ <dependencyManagement>
+ <dependencies>
+ <dependency>
+ <groupId>org.opendaylight.netconf</groupId>
+ <artifactId>netconf-artifacts</artifactId>
+ <version>${project.version}</version>
+ <type>pom</type>
+ <scope>import</scope>
+ </dependency>
+ <dependency>
+ <groupId>org.opendaylight.yangtools</groupId>
+ <artifactId>yangtools-artifacts</artifactId>
+ <version>1.2.1</version>
+ <type>pom</type>
+ <scope>import</scope>
+ </dependency>
+ <!--<dependency>
+ <groupId>openexi</groupId>
+ <artifactId>nagasena</artifactId>
+ <version>0000.0002.0062.0</version>
+ </dependency>
+ <dependency>
+ <groupId>openexi</groupId>
+ <artifactId>nagasena-rta</artifactId>
+ <version>0000.0002.0062.0</version>
+ </dependency>-->
+ <dependency>
+ <groupId>com.siemens.ct.exi</groupId>
+ <artifactId>exificient</artifactId>
+ <version>1.0.1</version>
+ </dependency>
+ </dependencies>
+ </dependencyManagement>
+
+ <dependencies>
+ <!-- compile dependencies -->
+ <dependency>
+ <groupId>${project.groupId}</groupId>
+ <artifactId>netconf-api</artifactId>
+ </dependency>
+ <dependency>
+ <groupId>${project.groupId}</groupId>
+ <artifactId>netconf-mapping-api</artifactId>
+ </dependency>
+ <dependency>
+ <groupId>${project.groupId}</groupId>
+ <artifactId>netconf-util</artifactId>
+ </dependency>
+ <dependency>
+ <groupId>com.google.guava</groupId>
+ <artifactId>guava</artifactId>
+ </dependency>
+ <dependency>
+ <groupId>io.netty</groupId>
+ <artifactId>netty-handler</artifactId>
+ </dependency>
+ <dependency>
+ <groupId>org.apache.sshd</groupId>
+ <artifactId>sshd-core</artifactId>
+ <version>0.14.0</version>
+ </dependency>
+ <!--<dependency>
+ <groupId>openexi</groupId>
+ <artifactId>nagasena</artifactId>
+ </dependency>
+ <dependency>
+ <groupId>openexi</groupId>
+ <artifactId>nagasena-rta</artifactId>
+ </dependency>-->
+ <dependency>
+ <groupId>com.siemens.ct.exi</groupId>
+ <artifactId>exificient</artifactId>
+ </dependency>
+ <dependency>
+ <groupId>org.slf4j</groupId>
+ <artifactId>slf4j-api</artifactId>
+ </dependency>
+ <dependency>
+ <groupId>xmlunit</groupId>
+ <artifactId>xmlunit</artifactId>
+ </dependency>
+ <dependency>
+ <groupId>org.opendaylight.yangtools</groupId>
+ <artifactId>mockito-configuration</artifactId>
+ </dependency>
+ <dependency>
+ <groupId>org.opendaylight.aaa</groupId>
+ <artifactId>aaa-encrypt-service</artifactId>
+ <version>0.6.1</version>
+ </dependency>
+ </dependencies>
+
+ <build>
+ <plugins>
+ <plugin>
+ <groupId>org.apache.maven.plugins</groupId>
+ <artifactId>maven-jar-plugin</artifactId>
+ <executions>
+ <execution>
+ <goals>
+ <goal>test-jar</goal>
+ </goals>
+ <phase>package</phase>
+ </execution>
+ </executions>
+ </plugin>
+ <plugin>
+ <groupId>org.apache.maven.plugins</groupId>
+ <artifactId>maven-checkstyle-plugin</artifactId>
+ <configuration>
+ <propertyExpansion>checkstyle.violationSeverity=error</propertyExpansion>
+ </configuration>
+ </plugin>
+ </plugins>
+ </build>
+
+</project>
--- /dev/null
+/*
+ * Copyright (c) 2013 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.netconf.nettyutil;
+
+import io.netty.channel.Channel;
+import io.netty.util.concurrent.Promise;
+import org.opendaylight.netconf.api.NetconfSession;
+import org.opendaylight.netconf.nettyutil.handler.FramingMechanismHandlerFactory;
+import org.opendaylight.netconf.nettyutil.handler.NetconfEOMAggregator;
+import org.opendaylight.netconf.nettyutil.handler.NetconfHelloMessageToXMLEncoder;
+import org.opendaylight.netconf.nettyutil.handler.NetconfXMLToHelloMessageDecoder;
+import org.opendaylight.netconf.util.messages.FramingMechanism;
+
+public abstract class AbstractChannelInitializer<S extends NetconfSession> {
+
+ public static final String NETCONF_MESSAGE_DECODER = "netconfMessageDecoder";
+ public static final String NETCONF_MESSAGE_AGGREGATOR = "aggregator";
+ public static final String NETCONF_MESSAGE_ENCODER = "netconfMessageEncoder";
+ public static final String NETCONF_MESSAGE_FRAME_ENCODER = "frameEncoder";
+ public static final String NETCONF_SESSION_NEGOTIATOR = "negotiator";
+
+ public void initialize(Channel ch, Promise<S> promise) {
+ ch.pipeline().addLast(NETCONF_MESSAGE_AGGREGATOR, new NetconfEOMAggregator());
+ initializeMessageDecoder(ch);
+ ch.pipeline().addLast(NETCONF_MESSAGE_FRAME_ENCODER,
+ FramingMechanismHandlerFactory.createHandler(FramingMechanism.EOM));
+ initializeMessageEncoder(ch);
+
+ initializeSessionNegotiator(ch, promise);
+ }
+
+ protected void initializeMessageEncoder(Channel ch) {
+ // Special encoding handler for hello message to include additional header if available,
+ // it is thrown away after successful negotiation
+ ch.pipeline().addLast(NETCONF_MESSAGE_ENCODER, new NetconfHelloMessageToXMLEncoder());
+ }
+
+ protected void initializeMessageDecoder(Channel ch) {
+ // Special decoding handler for hello message to parse additional header if available,
+ // it is thrown away after successful negotiation
+ ch.pipeline().addLast(NETCONF_MESSAGE_DECODER, new NetconfXMLToHelloMessageDecoder());
+ }
+
+ /**
+ * Insert session negotiator into the pipeline. It must be inserted after message decoder
+ * identified by {@link AbstractChannelInitializer#NETCONF_MESSAGE_DECODER}, (or any other custom decoder processor)
+ */
+ protected abstract void initializeSessionNegotiator(Channel ch, Promise<S> promise);
+
+}
--- /dev/null
+/*
+ * Copyright (c) 2013 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.netconf.nettyutil;
+
+import com.siemens.ct.exi.core.exceptions.EXIException;
+import com.siemens.ct.exi.core.exceptions.UnsupportedOption;
+import io.netty.channel.Channel;
+import io.netty.channel.ChannelFuture;
+import io.netty.channel.ChannelHandler;
+import io.netty.channel.DefaultChannelPromise;
+import io.netty.handler.codec.ByteToMessageDecoder;
+import io.netty.handler.codec.MessageToByteEncoder;
+import io.netty.util.concurrent.Future;
+import io.netty.util.concurrent.FutureListener;
+import java.io.IOException;
+import org.opendaylight.controller.config.util.xml.XmlElement;
+import org.opendaylight.netconf.api.NetconfExiSession;
+import org.opendaylight.netconf.api.NetconfMessage;
+import org.opendaylight.netconf.api.NetconfSession;
+import org.opendaylight.netconf.api.NetconfSessionListener;
+import org.opendaylight.netconf.api.NetconfTerminationReason;
+import org.opendaylight.netconf.nettyutil.handler.NetconfEXICodec;
+import org.opendaylight.netconf.nettyutil.handler.NetconfEXIToMessageDecoder;
+import org.opendaylight.netconf.nettyutil.handler.NetconfMessageToEXIEncoder;
+import org.opendaylight.netconf.nettyutil.handler.exi.EXIParameters;
+import org.opendaylight.protocol.framework.AbstractProtocolSession;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public abstract class AbstractNetconfSession<S extends NetconfSession,L extends NetconfSessionListener<S>>
+ extends AbstractProtocolSession<NetconfMessage> implements NetconfSession, NetconfExiSession {
+ private static final Logger LOG = LoggerFactory.getLogger(AbstractNetconfSession.class);
+ private final L sessionListener;
+ private final long sessionId;
+ private boolean up = false;
+
+ private ChannelHandler delayedEncoder;
+
+ private final Channel channel;
+
+ protected AbstractNetconfSession(final L sessionListener, final Channel channel, final long sessionId) {
+ this.sessionListener = sessionListener;
+ this.channel = channel;
+ this.sessionId = sessionId;
+ LOG.debug("Session {} created", sessionId);
+ }
+
+ protected abstract S thisInstance();
+
+ @Override
+ public void close() {
+ channel.close();
+ up = false;
+ sessionListener.onSessionTerminated(thisInstance(), new NetconfTerminationReason("Session closed"));
+ }
+
+ @Override
+ protected void handleMessage(final NetconfMessage netconfMessage) {
+ LOG.debug("handling incoming message");
+ sessionListener.onMessage(thisInstance(), netconfMessage);
+ }
+
+ @Override
+ public ChannelFuture sendMessage(final NetconfMessage netconfMessage) {
+ // From: https://github.com/netty/netty/issues/3887
+ // Netty can provide "ordering" in the following situations:
+ // 1. You are doing all writes from the EventLoop thread; OR
+ // 2. You are doing no writes from the EventLoop thread (i.e. all writes are being done in other thread(s)).
+ //
+ // Restconf writes to a netconf mountpoint execute multiple messages
+ // and one of these was executed from a restconf thread thus breaking ordering so
+ // we need to execute all messages from an EventLoop thread.
+ final DefaultChannelPromise proxyFuture = new DefaultChannelPromise(channel);
+ channel.eventLoop().execute(new Runnable() {
+ @Override
+ public void run() {
+ final ChannelFuture future = channel.writeAndFlush(netconfMessage);
+ future.addListener(new FutureListener<Void>() {
+ @Override
+ public void operationComplete(Future<Void> future) throws Exception {
+ if (future.isSuccess()) {
+ proxyFuture.setSuccess();
+ } else {
+ proxyFuture.setFailure(future.cause());
+ }
+ }
+ });
+ if (delayedEncoder != null) {
+ replaceMessageEncoder(delayedEncoder);
+ delayedEncoder = null;
+ }
+ }
+ });
+
+ return proxyFuture;
+ }
+
+ @Override
+ protected void endOfInput() {
+ LOG.debug("Session {} end of input detected while session was in state {}", toString(), isUp() ? "up"
+ : "initialized");
+ if (isUp()) {
+ this.sessionListener.onSessionDown(thisInstance(),
+ new IOException("End of input detected. Close the session."));
+ }
+ }
+
+ @Override
+ protected void sessionUp() {
+ LOG.debug("Session {} up", toString());
+ sessionListener.onSessionUp(thisInstance());
+ this.up = true;
+ }
+
+ @Override
+ public String toString() {
+ final StringBuffer sb = new StringBuffer(getClass().getSimpleName() + "{");
+ sb.append("sessionId=").append(sessionId);
+ sb.append(", channel=").append(channel);
+ sb.append('}');
+ return sb.toString();
+ }
+
+ protected final void replaceMessageDecoder(final ChannelHandler handler) {
+ replaceChannelHandler(AbstractChannelInitializer.NETCONF_MESSAGE_DECODER, handler);
+ }
+
+ protected final void replaceMessageEncoder(final ChannelHandler handler) {
+ replaceChannelHandler(AbstractChannelInitializer.NETCONF_MESSAGE_ENCODER, handler);
+ }
+
+ protected final void replaceMessageEncoderAfterNextMessage(final ChannelHandler handler) {
+ this.delayedEncoder = handler;
+ }
+
+ protected final void replaceChannelHandler(final String handlerName, final ChannelHandler handler) {
+ channel.pipeline().replace(handlerName, handlerName, handler);
+ }
+
+ @Override
+ public final void startExiCommunication(final NetconfMessage startExiMessage) {
+ final EXIParameters exiParams;
+ try {
+ exiParams = EXIParameters.fromXmlElement(XmlElement.fromDomDocument(startExiMessage.getDocument()));
+ } catch (final UnsupportedOption e) {
+ LOG.warn("Unable to parse EXI parameters from {} on session {}", startExiMessage, this, e);
+ throw new IllegalArgumentException("Cannot parse options", e);
+ }
+
+ final NetconfEXICodec exiCodec = NetconfEXICodec.forParameters(exiParams);
+ final NetconfMessageToEXIEncoder exiEncoder = NetconfMessageToEXIEncoder.create(exiCodec);
+ final NetconfEXIToMessageDecoder exiDecoder;
+ try {
+ exiDecoder = NetconfEXIToMessageDecoder.create(exiCodec);
+ } catch (EXIException e) {
+ LOG.warn("Failed to instantiate EXI decodeer for {} on session {}", exiCodec, this, e);
+ throw new IllegalStateException("Cannot instantiate encoder for options", e);
+ }
+
+ addExiHandlers(exiDecoder, exiEncoder);
+ LOG.debug("Session {} EXI handlers added to pipeline", this);
+ }
+
+ /**
+ * Add a set encoder/decoder tuple into the channel pipeline as appropriate.
+ *
+ * @param decoder EXI decoder
+ * @param encoder EXI encoder
+ */
+ protected abstract void addExiHandlers(ByteToMessageDecoder decoder, MessageToByteEncoder<NetconfMessage> encoder);
+
+ public final boolean isUp() {
+ return up;
+ }
+
+ public final long getSessionId() {
+ return sessionId;
+ }
+}
--- /dev/null
+/*
+ * Copyright (c) 2013 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.netconf.nettyutil;
+
+import com.google.common.base.Optional;
+import com.google.common.base.Preconditions;
+import io.netty.channel.Channel;
+import io.netty.channel.ChannelFuture;
+import io.netty.channel.ChannelHandler;
+import io.netty.channel.ChannelHandlerContext;
+import io.netty.channel.ChannelInboundHandlerAdapter;
+import io.netty.handler.ssl.SslHandler;
+import io.netty.util.Timeout;
+import io.netty.util.Timer;
+import io.netty.util.TimerTask;
+import io.netty.util.concurrent.Future;
+import io.netty.util.concurrent.GenericFutureListener;
+import io.netty.util.concurrent.Promise;
+import java.util.concurrent.TimeUnit;
+import org.opendaylight.netconf.api.NetconfDocumentedException;
+import org.opendaylight.netconf.api.NetconfMessage;
+import org.opendaylight.netconf.api.NetconfSessionListener;
+import org.opendaylight.netconf.api.NetconfSessionPreferences;
+import org.opendaylight.netconf.api.messages.NetconfHelloMessage;
+import org.opendaylight.netconf.api.xml.XmlNetconfConstants;
+import org.opendaylight.netconf.nettyutil.handler.FramingMechanismHandlerFactory;
+import org.opendaylight.netconf.nettyutil.handler.NetconfChunkAggregator;
+import org.opendaylight.netconf.nettyutil.handler.NetconfMessageToXMLEncoder;
+import org.opendaylight.netconf.nettyutil.handler.NetconfXMLToHelloMessageDecoder;
+import org.opendaylight.netconf.nettyutil.handler.NetconfXMLToMessageDecoder;
+import org.opendaylight.netconf.util.messages.FramingMechanism;
+import org.opendaylight.protocol.framework.AbstractSessionNegotiator;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.w3c.dom.Document;
+import org.w3c.dom.NodeList;
+
+public abstract class AbstractNetconfSessionNegotiator<P extends NetconfSessionPreferences,
+ S extends AbstractNetconfSession<S, L>, L extends NetconfSessionListener<S>>
+ extends AbstractSessionNegotiator<NetconfHelloMessage, S> {
+
+ private static final Logger LOG = LoggerFactory.getLogger(AbstractNetconfSessionNegotiator.class);
+
+ public static final String NAME_OF_EXCEPTION_HANDLER = "lastExceptionHandler";
+
+ protected final P sessionPreferences;
+
+ private final L sessionListener;
+ private Timeout timeout;
+
+ /**
+ * Possible states for Finite State Machine.
+ */
+ protected enum State {
+ IDLE, OPEN_WAIT, FAILED, ESTABLISHED
+ }
+
+ private State state = State.IDLE;
+ private final Promise<S> promise;
+ private final Timer timer;
+ private final long connectionTimeoutMillis;
+
+ protected AbstractNetconfSessionNegotiator(final P sessionPreferences, final Promise<S> promise,
+ final Channel channel, final Timer timer,
+ final L sessionListener, final long connectionTimeoutMillis) {
+ super(promise, channel);
+ this.sessionPreferences = sessionPreferences;
+ this.promise = promise;
+ this.timer = timer;
+ this.sessionListener = sessionListener;
+ this.connectionTimeoutMillis = connectionTimeoutMillis;
+ }
+
+ @Override
+ protected final void startNegotiation() {
+ final Optional<SslHandler> sslHandler = getSslHandler(channel);
+ if (sslHandler.isPresent()) {
+ Future<Channel> future = sslHandler.get().handshakeFuture();
+ future.addListener(new GenericFutureListener<Future<? super Channel>>() {
+ @Override
+ public void operationComplete(final Future<? super Channel> future) {
+ Preconditions.checkState(future.isSuccess(), "Ssl handshake was not successful");
+ LOG.debug("Ssl handshake complete");
+ start();
+ }
+ });
+ } else {
+ start();
+ }
+ }
+
+ private static Optional<SslHandler> getSslHandler(final Channel channel) {
+ final SslHandler sslHandler = channel.pipeline().get(SslHandler.class);
+ return sslHandler == null ? Optional.<SslHandler>absent() : Optional.of(sslHandler);
+ }
+
+ public P getSessionPreferences() {
+ return sessionPreferences;
+ }
+
+ private void start() {
+ final NetconfHelloMessage helloMessage = this.sessionPreferences.getHelloMessage();
+ LOG.debug("Session negotiation started with hello message {} on channel {}", helloMessage, channel);
+
+ channel.pipeline().addLast(NAME_OF_EXCEPTION_HANDLER, new ExceptionHandlingInboundChannelHandler());
+
+ sendMessage(helloMessage);
+
+ replaceHelloMessageOutboundHandler();
+ changeState(State.OPEN_WAIT);
+
+ timeout = this.timer.newTimeout(new TimerTask() {
+ @Override
+ public void run(final Timeout timeout) {
+ synchronized (this) {
+ if (state != State.ESTABLISHED) {
+
+ LOG.debug("Connection timeout after {}, session is in state {}", timeout, state);
+
+ // Do not fail negotiation if promise is done or canceled
+ // It would result in setting result of the promise second time and that throws exception
+ if (isPromiseFinished() == false) {
+ LOG.warn("Netconf session was not established after {}", connectionTimeoutMillis);
+ changeState(State.FAILED);
+
+ channel.close().addListener(new GenericFutureListener<ChannelFuture>() {
+ @Override
+ public void operationComplete(final ChannelFuture future) throws Exception {
+ if (future.isSuccess()) {
+ LOG.debug("Channel {} closed: success", future.channel());
+ } else {
+ LOG.warn("Channel {} closed: fail", future.channel());
+ }
+ }
+ });
+ }
+ } else if (channel.isOpen()) {
+ channel.pipeline().remove(NAME_OF_EXCEPTION_HANDLER);
+ }
+ }
+ }
+
+ private boolean isPromiseFinished() {
+ return promise.isDone() || promise.isCancelled();
+ }
+
+ }, connectionTimeoutMillis, TimeUnit.MILLISECONDS);
+ }
+
+ private void cancelTimeout() {
+ if (timeout != null) {
+ timeout.cancel();
+ }
+ }
+
+ protected final S getSessionForHelloMessage(final NetconfHelloMessage netconfMessage)
+ throws NetconfDocumentedException {
+ Preconditions.checkNotNull(netconfMessage, "netconfMessage");
+
+ final Document doc = netconfMessage.getDocument();
+
+ if (shouldUseChunkFraming(doc)) {
+ insertChunkFramingToPipeline();
+ }
+
+ changeState(State.ESTABLISHED);
+ return getSession(sessionListener, channel, netconfMessage);
+ }
+
+ /**
+ * Insert chunk framing handlers into the pipeline.
+ */
+ private void insertChunkFramingToPipeline() {
+ replaceChannelHandler(channel, AbstractChannelInitializer.NETCONF_MESSAGE_FRAME_ENCODER,
+ FramingMechanismHandlerFactory.createHandler(FramingMechanism.CHUNK));
+ replaceChannelHandler(channel, AbstractChannelInitializer.NETCONF_MESSAGE_AGGREGATOR,
+ new NetconfChunkAggregator());
+ }
+
+ private boolean shouldUseChunkFraming(final Document doc) {
+ return containsBase11Capability(doc)
+ && containsBase11Capability(sessionPreferences.getHelloMessage().getDocument());
+ }
+
+ /**
+ * Remove special inbound handler for hello message. Insert regular netconf xml message (en|de)coders.
+ *
+ * <p>
+ * Inbound hello message handler should be kept until negotiation is successful
+ * It caches any non-hello messages while negotiation is still in progress
+ */
+ protected final void replaceHelloMessageInboundHandler(final S session) {
+ ChannelHandler helloMessageHandler = replaceChannelHandler(channel,
+ AbstractChannelInitializer.NETCONF_MESSAGE_DECODER, new NetconfXMLToMessageDecoder());
+
+ Preconditions.checkState(helloMessageHandler instanceof NetconfXMLToHelloMessageDecoder,
+ "Pipeline handlers misplaced on session: %s, pipeline: %s", session, channel.pipeline());
+ Iterable<NetconfMessage> netconfMessagesFromNegotiation =
+ ((NetconfXMLToHelloMessageDecoder) helloMessageHandler).getPostHelloNetconfMessages();
+
+ // Process messages received during negotiation
+ // The hello message handler does not have to be synchronized,
+ // since it is always call from the same thread by netty.
+ // It means, we are now using the thread now
+ for (NetconfMessage message : netconfMessagesFromNegotiation) {
+ session.handleMessage(message);
+ }
+ }
+
+ /**
+ * Remove special outbound handler for hello message. Insert regular netconf xml message (en|de)coders.
+ */
+ private void replaceHelloMessageOutboundHandler() {
+ replaceChannelHandler(channel, AbstractChannelInitializer.NETCONF_MESSAGE_ENCODER,
+ new NetconfMessageToXMLEncoder());
+ }
+
+ private static ChannelHandler replaceChannelHandler(final Channel channel, final String handlerKey,
+ final ChannelHandler decoder) {
+ return channel.pipeline().replace(handlerKey, handlerKey, decoder);
+ }
+
+ protected abstract S getSession(L sessionListener, Channel channel, NetconfHelloMessage message)
+ throws NetconfDocumentedException;
+
+ private synchronized void changeState(final State newState) {
+ LOG.debug("Changing state from : {} to : {} for channel: {}", state, newState, channel);
+ Preconditions.checkState(isStateChangePermitted(state, newState),
+ "Cannot change state from %s to %s for chanel %s", state, newState, channel);
+ this.state = newState;
+ }
+
+ private static boolean containsBase11Capability(final Document doc) {
+ final NodeList nList = doc.getElementsByTagName(XmlNetconfConstants.CAPABILITY);
+ for (int i = 0; i < nList.getLength(); i++) {
+ if (nList.item(i).getTextContent().contains(XmlNetconfConstants.URN_IETF_PARAMS_NETCONF_BASE_1_1)) {
+ return true;
+ }
+ }
+ return false;
+ }
+
+ private static boolean isStateChangePermitted(final State state, final State newState) {
+ if (state == State.IDLE && newState == State.OPEN_WAIT) {
+ return true;
+ }
+ if (state == State.OPEN_WAIT && newState == State.ESTABLISHED) {
+ return true;
+ }
+ if (state == State.OPEN_WAIT && newState == State.FAILED) {
+ return true;
+ }
+ LOG.debug("Transition from {} to {} is not allowed", state, newState);
+ return false;
+ }
+
+ /**
+ * Handler to catch exceptions in pipeline during negotiation.
+ */
+ private final class ExceptionHandlingInboundChannelHandler extends ChannelInboundHandlerAdapter {
+ @Override
+ public void exceptionCaught(final ChannelHandlerContext ctx, final Throwable cause) {
+ LOG.warn("An exception occurred during negotiation with {}", channel.remoteAddress(), cause);
+ cancelTimeout();
+ negotiationFailed(cause);
+ changeState(State.FAILED);
+ }
+ }
+}
--- /dev/null
+/*
+ * Copyright (c) 2015 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.netconf.nettyutil.handler;
+
+import com.google.common.base.Preconditions;
+import java.io.IOException;
+import java.io.Writer;
+import javax.annotation.concurrent.NotThreadSafe;
+
+/**
+ * Custom BufferedWriter optimized for netconf pipeline implemented instead of default BufferedWriter provided by jdk.
+ *
+ * <p>
+ * The line separator instance field in java.io.BufferedWriter is
+ * assigned using AccessController and takes considerable amount of time especially
+ * if lots of BufferedWriters are created in the system.
+ *
+ * <p>
+ * This implementation should only be used if newLine method is not required
+ * such as netconf message to XML encoders.
+ * Methods in this implementation are not synchronized.
+ */
+@NotThreadSafe
+public final class BufferedWriter extends Writer {
+
+ private static final int DEFAULT_CHAR_BUFFER_SIZE = 8192;
+
+ private final Writer writer;
+ private final char[] buffer;
+ private final int bufferSize;
+
+ private int nextChar = 0;
+
+ public BufferedWriter(final Writer writer) {
+ this(writer, DEFAULT_CHAR_BUFFER_SIZE);
+ }
+
+ public BufferedWriter(final Writer writer, final int bufferSize) {
+ super(writer);
+ Preconditions.checkArgument(bufferSize > 0, "Buffer size <= 0");
+ this.writer = writer;
+ this.buffer = new char[bufferSize];
+ this.bufferSize = bufferSize;
+ }
+
+ private void flushBuffer() throws IOException {
+ if (nextChar == 0) {
+ return;
+ }
+ writer.write(buffer, 0, nextChar);
+ nextChar = 0;
+ }
+
+ @Override
+ public void write(final int character) throws IOException {
+ if (nextChar >= bufferSize) {
+ flushBuffer();
+ }
+ buffer[nextChar++] = (char) character;
+ }
+
+ @Override
+ public void write(final char[] buffer, final int offset, final int length) throws IOException {
+ if ((offset < 0) || (offset > buffer.length)
+ || (length < 0) || ((offset + length) > buffer.length) || ((offset + length) < 0)) {
+ throw new IndexOutOfBoundsException(
+ String.format("Buffer size: %d, Offset: %d, Length: %d", buffer.length, offset, length));
+ } else if (length == 0) {
+ return;
+ }
+
+ if (length >= bufferSize) {
+ flushBuffer();
+ writer.write(buffer, offset, length);
+ return;
+ }
+
+ int bufferOffset = offset;
+ final int t = offset + length;
+ while (bufferOffset < t) {
+ final int d = Math.min(bufferSize - nextChar, t - bufferOffset);
+ System.arraycopy(buffer, bufferOffset, this.buffer, nextChar, d);
+ bufferOffset += d;
+ nextChar += d;
+ if (nextChar >= bufferSize) {
+ flushBuffer();
+ }
+ }
+ }
+
+ @Override
+ public void write(final String string, final int offset, final int length) throws IOException {
+ int bufferOffset = offset;
+ final int t = offset + length;
+ while (bufferOffset < t) {
+ final int d = Math.min(bufferSize - nextChar, t - bufferOffset);
+ string.getChars(bufferOffset, bufferOffset + d, buffer, nextChar);
+ bufferOffset += d;
+ nextChar += d;
+ if (nextChar >= bufferSize) {
+ flushBuffer();
+ }
+ }
+ }
+
+ @Override
+ public void flush() throws IOException {
+ flushBuffer();
+ writer.flush();
+ }
+
+ @Override
+ public void close() throws IOException {
+ try {
+ flushBuffer();
+ } finally {
+ writer.close();
+ }
+ }
+}
--- /dev/null
+/*
+ * Copyright (c) 2013 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.netconf.nettyutil.handler;
+
+import com.google.common.base.Preconditions;
+import io.netty.buffer.ByteBuf;
+import io.netty.channel.ChannelHandlerContext;
+import io.netty.handler.codec.MessageToByteEncoder;
+import java.nio.charset.StandardCharsets;
+import org.opendaylight.netconf.util.messages.NetconfMessageConstants;
+
+public class ChunkedFramingMechanismEncoder extends MessageToByteEncoder<ByteBuf> {
+ public static final int DEFAULT_CHUNK_SIZE = 8192;
+ public static final int MIN_CHUNK_SIZE = 128;
+ public static final int MAX_CHUNK_SIZE = 16 * 1024 * 1024;
+
+ private final int chunkSize;
+
+ public ChunkedFramingMechanismEncoder() {
+ this(DEFAULT_CHUNK_SIZE);
+ }
+
+ public ChunkedFramingMechanismEncoder(final int chunkSize) {
+ Preconditions.checkArgument(chunkSize >= MIN_CHUNK_SIZE && chunkSize <= MAX_CHUNK_SIZE,
+ "Unsupported chunk size %s", chunkSize);
+ this.chunkSize = chunkSize;
+ }
+
+ public final int getChunkSize() {
+ return chunkSize;
+ }
+
+ @Override
+ protected void encode(final ChannelHandlerContext ctx, final ByteBuf msg, final ByteBuf out) {
+ do {
+ final int xfer = Math.min(chunkSize, msg.readableBytes());
+
+ out.writeBytes(NetconfMessageConstants.START_OF_CHUNK);
+ out.writeBytes(String.valueOf(xfer).getBytes(StandardCharsets.US_ASCII));
+ out.writeByte('\n');
+
+ out.writeBytes(msg, xfer);
+ } while (msg.isReadable());
+
+ out.writeBytes(NetconfMessageConstants.END_OF_CHUNK);
+ }
+}
--- /dev/null
+/*
+ * Copyright (c) 2013 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.netconf.nettyutil.handler;
+
+import io.netty.buffer.ByteBuf;
+import io.netty.channel.ChannelHandlerContext;
+import io.netty.handler.codec.MessageToByteEncoder;
+import org.opendaylight.netconf.util.messages.NetconfMessageConstants;
+
+public class EOMFramingMechanismEncoder extends MessageToByteEncoder<ByteBuf> {
+ @Override
+ protected void encode(ChannelHandlerContext ctx, ByteBuf msg, ByteBuf out) {
+ out.writeBytes(msg);
+ out.writeBytes(NetconfMessageConstants.END_OF_MESSAGE);
+ }
+}
--- /dev/null
+/*
+ * Copyright (c) 2013 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.netconf.nettyutil.handler;
+
+import io.netty.buffer.ByteBuf;
+import io.netty.handler.codec.MessageToByteEncoder;
+import org.opendaylight.netconf.util.messages.FramingMechanism;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public final class FramingMechanismHandlerFactory {
+
+ private static final Logger LOG = LoggerFactory.getLogger(FramingMechanismHandlerFactory.class);
+
+ private FramingMechanismHandlerFactory() {
+ // not called - private constructor for utility class
+ }
+
+ public static MessageToByteEncoder<ByteBuf> createHandler(FramingMechanism framingMechanism) {
+ LOG.debug("{} framing mechanism was selected.", framingMechanism);
+ if (framingMechanism == FramingMechanism.EOM) {
+ return new EOMFramingMechanismEncoder();
+ } else {
+ return new ChunkedFramingMechanismEncoder();
+ }
+ }
+}
--- /dev/null
+/*
+ * Copyright (c) 2013 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.netconf.nettyutil.handler;
+
+import io.netty.buffer.ByteBuf;
+import io.netty.buffer.CompositeByteBuf;
+import io.netty.buffer.Unpooled;
+import io.netty.channel.ChannelHandlerContext;
+import io.netty.handler.codec.ByteToMessageDecoder;
+import java.util.List;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public class NetconfChunkAggregator extends ByteToMessageDecoder {
+ private static final Logger LOG = LoggerFactory.getLogger(NetconfChunkAggregator.class);
+ private static final String GOT_PARAM_WHILE_WAITING_FOR_PARAM = "Got byte {} while waiting for {}";
+ private static final String GOT_PARAM_WHILE_WAITING_FOR_PARAM_PARAM = "Got byte {} while waiting for {}-{}";
+ public static final int DEFAULT_MAXIMUM_CHUNK_SIZE = 16 * 1024 * 1024;
+
+ private enum State {
+ HEADER_ONE, // \n
+ HEADER_TWO, // #
+ HEADER_LENGTH_FIRST, // [1-9]
+ HEADER_LENGTH_OTHER, // [0-9]*\n
+ DATA,
+ FOOTER_ONE, // \n
+ FOOTER_TWO, // #
+ FOOTER_THREE, // #
+ FOOTER_FOUR, // \n
+ }
+
+ private final int maxChunkSize = DEFAULT_MAXIMUM_CHUNK_SIZE;
+ private State state = State.HEADER_ONE;
+ private long chunkSize;
+ private CompositeByteBuf chunk;
+
+ private static void checkNewLine(final byte byteToCheck, final String errorMessage) {
+ if (byteToCheck != '\n') {
+ LOG.debug(GOT_PARAM_WHILE_WAITING_FOR_PARAM, byteToCheck, (byte)'\n');
+ throw new IllegalStateException(errorMessage);
+ }
+ }
+
+ private static void checkHash(final byte byteToCheck, final String errorMessage) {
+ if (byteToCheck != '#') {
+ LOG.debug(GOT_PARAM_WHILE_WAITING_FOR_PARAM, byteToCheck, (byte)'#');
+ throw new IllegalStateException(errorMessage);
+ }
+ }
+
+ private void checkChunkSize() {
+ if (chunkSize > maxChunkSize) {
+ LOG.debug("Parsed chunk size {}, maximum allowed is {}", chunkSize, maxChunkSize);
+ throw new IllegalStateException("Maximum chunk size exceeded");
+ }
+ }
+
+ @Override
+ protected void decode(final ChannelHandlerContext ctx,
+ final ByteBuf in, final List<Object> out) throws IllegalStateException {
+ while (in.isReadable()) {
+ switch (state) {
+ case HEADER_ONE:
+ {
+ final byte b = in.readByte();
+ checkNewLine(b, "Malformed chunk header encountered (byte 0)");
+ state = State.HEADER_TWO;
+ initChunk();
+ break;
+ }
+ case HEADER_TWO:
+ {
+ final byte b = in.readByte();
+ checkHash(b, "Malformed chunk header encountered (byte 1)");
+ state = State.HEADER_LENGTH_FIRST;
+ break;
+ }
+ case HEADER_LENGTH_FIRST:
+ {
+ final byte b = in.readByte();
+ chunkSize = processHeaderLengthFirst(b);
+ state = State.HEADER_LENGTH_OTHER;
+ break;
+ }
+ case HEADER_LENGTH_OTHER:
+ {
+ final byte b = in.readByte();
+ if (b == '\n') {
+ state = State.DATA;
+ break;
+ }
+ if (b < '0' || b > '9') {
+ LOG.debug(GOT_PARAM_WHILE_WAITING_FOR_PARAM_PARAM, b, (byte)'0', (byte)'9');
+ throw new IllegalStateException("Invalid chunk size encountered");
+ }
+ chunkSize *= 10;
+ chunkSize += b - '0';
+ checkChunkSize();
+ break;
+ }
+ case DATA:
+ /*
+ * FIXME: this gathers all data into one big chunk before passing
+ * it on. Make sure the pipeline can work with partial data
+ * and then change this piece to pass the data on as it
+ * comes through.
+ */
+ if (in.readableBytes() < chunkSize) {
+ LOG.debug("Buffer has {} bytes, need {} to complete chunk", in.readableBytes(), chunkSize);
+ in.discardReadBytes();
+ return;
+ }
+ aggregateChunks(in.readBytes((int) chunkSize));
+ state = State.FOOTER_ONE;
+ break;
+ case FOOTER_ONE:
+ {
+ final byte b = in.readByte();
+ checkNewLine(b,"Malformed chunk footer encountered (byte 0)");
+ state = State.FOOTER_TWO;
+ chunkSize = 0;
+ break;
+ }
+ case FOOTER_TWO:
+ {
+ final byte b = in.readByte();
+ checkHash(b,"Malformed chunk footer encountered (byte 1)");
+ state = State.FOOTER_THREE;
+ break;
+ }
+ case FOOTER_THREE:
+ {
+ final byte b = in.readByte();
+ // In this state, either header-of-new-chunk or message-end is expected
+ // Depends on the next character
+ extractNewChunkOrMessageEnd(b);
+ break;
+ }
+ case FOOTER_FOUR:
+ {
+ final byte b = in.readByte();
+ checkNewLine(b,"Malformed chunk footer encountered (byte 3)");
+ state = State.HEADER_ONE;
+ out.add(chunk);
+ chunk = null;
+ break;
+ }
+ default :
+ {
+ LOG.info("Unknown state.");
+ }
+ }
+ }
+
+ in.discardReadBytes();
+ }
+
+ private void extractNewChunkOrMessageEnd(final byte byteToCheck) {
+ if (isHeaderLengthFirst(byteToCheck)) {
+ // Extract header length#1 from new chunk
+ chunkSize = processHeaderLengthFirst(byteToCheck);
+ // Proceed with next chunk processing
+ state = State.HEADER_LENGTH_OTHER;
+ } else if (byteToCheck == '#') {
+ state = State.FOOTER_FOUR;
+ } else {
+ LOG.debug(GOT_PARAM_WHILE_WAITING_FOR_PARAM_PARAM, byteToCheck, (byte) '#', (byte) '1', (byte) '9');
+ throw new IllegalStateException("Malformed chunk footer encountered (byte 2)");
+ }
+ }
+
+ private void initChunk() {
+ chunk = Unpooled.compositeBuffer();
+ }
+
+ private void aggregateChunks(final ByteBuf newChunk) {
+ chunk.addComponent(chunk.numComponents(), newChunk);
+
+ // Update writer index, addComponent does not update it
+ chunk.writerIndex(chunk.writerIndex() + newChunk.readableBytes());
+ }
+
+ private static int processHeaderLengthFirst(final byte byteToCheck) {
+ if (!isHeaderLengthFirst(byteToCheck)) {
+ LOG.debug(GOT_PARAM_WHILE_WAITING_FOR_PARAM_PARAM, byteToCheck, (byte)'1', (byte)'9');
+ throw new IllegalStateException("Invalid chunk size encountered (byte 0)");
+ }
+
+ return byteToCheck - '0';
+ }
+
+ private static boolean isHeaderLengthFirst(final byte byteToCheck) {
+ return byteToCheck >= '1' && byteToCheck <= '9';
+ }
+}
--- /dev/null
+/*
+ * Copyright (c) 2013 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.netconf.nettyutil.handler;
+
+import io.netty.buffer.ByteBuf;
+import io.netty.buffer.Unpooled;
+import io.netty.handler.codec.DelimiterBasedFrameDecoder;
+import org.opendaylight.netconf.util.messages.NetconfMessageConstants;
+
+public class NetconfEOMAggregator extends DelimiterBasedFrameDecoder {
+
+ public static final ByteBuf DELIMITER = Unpooled.wrappedBuffer(NetconfMessageConstants.END_OF_MESSAGE);
+
+ public NetconfEOMAggregator() {
+ super(Integer.MAX_VALUE, DELIMITER);
+ }
+}
--- /dev/null
+/*
+ * Copyright (c) 2014, 2015 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.netconf.nettyutil.handler;
+
+import static java.util.Objects.requireNonNull;
+
+import com.google.common.cache.CacheBuilder;
+import com.google.common.cache.CacheLoader;
+import com.google.common.cache.LoadingCache;
+import com.siemens.ct.exi.core.EXIFactory;
+import com.siemens.ct.exi.core.exceptions.EXIException;
+import com.siemens.ct.exi.main.api.sax.SAXEncoder;
+import com.siemens.ct.exi.main.api.sax.SAXFactory;
+import org.opendaylight.netconf.nettyutil.handler.exi.EXIParameters;
+import org.xml.sax.EntityResolver;
+import org.xml.sax.InputSource;
+import org.xml.sax.XMLReader;
+
+public final class NetconfEXICodec {
+ /**
+ * OpenEXI does not allow us to directly prevent resolution of external entities. In order
+ * to prevent XXE attacks, we reuse a single no-op entity resolver.
+ */
+ private static final EntityResolver ENTITY_RESOLVER = (publicId, systemId) -> new InputSource();
+
+ /**
+ * Since we have a limited number of options we can have, instantiating a weak cache
+ * will allow us to reuse instances where possible.
+ */
+ private static final LoadingCache<EXIParameters, NetconfEXICodec> CODECS =
+ CacheBuilder.newBuilder().weakValues().build(new CacheLoader<EXIParameters, NetconfEXICodec>() {
+ @Override
+ public NetconfEXICodec load(final EXIParameters key) {
+ return new NetconfEXICodec(key.getFactory());
+ }
+ });
+
+ private final SAXFactory exiFactory;
+
+ private NetconfEXICodec(final EXIFactory exiFactory) {
+ this.exiFactory = new SAXFactory(requireNonNull(exiFactory));
+ }
+
+ public static NetconfEXICodec forParameters(final EXIParameters parameters) {
+ return CODECS.getUnchecked(parameters);
+ }
+
+ XMLReader getReader() throws EXIException {
+ final XMLReader reader = exiFactory.createEXIReader();
+ reader.setEntityResolver(ENTITY_RESOLVER);
+ return reader;
+ }
+
+ SAXEncoder getWriter() throws EXIException {
+ final SAXEncoder writer = exiFactory.createEXIWriter();
+ return writer;
+ }
+}
--- /dev/null
+/*
+ * 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.netconf.nettyutil.handler;
+
+import static java.util.Objects.requireNonNull;
+
+import com.siemens.ct.exi.core.exceptions.EXIException;
+import io.netty.buffer.ByteBuf;
+import io.netty.buffer.ByteBufInputStream;
+import io.netty.buffer.ByteBufUtil;
+import io.netty.channel.ChannelHandlerContext;
+import io.netty.handler.codec.ByteToMessageDecoder;
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.List;
+import javax.xml.parsers.DocumentBuilder;
+import javax.xml.transform.TransformerConfigurationException;
+import javax.xml.transform.TransformerFactory;
+import javax.xml.transform.TransformerFactoryConfigurationError;
+import javax.xml.transform.dom.DOMResult;
+import javax.xml.transform.sax.SAXTransformerFactory;
+import javax.xml.transform.sax.TransformerHandler;
+import org.opendaylight.netconf.api.NetconfMessage;
+import org.opendaylight.yangtools.util.xml.UntrustedXML;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.w3c.dom.Document;
+import org.xml.sax.InputSource;
+import org.xml.sax.SAXException;
+import org.xml.sax.XMLReader;
+
+public final class NetconfEXIToMessageDecoder extends ByteToMessageDecoder {
+
+ private static final Logger LOG = LoggerFactory.getLogger(NetconfEXIToMessageDecoder.class);
+ private static final SAXTransformerFactory FACTORY;
+
+ static {
+ final TransformerFactory f = SAXTransformerFactory.newInstance();
+ if (!f.getFeature(SAXTransformerFactory.FEATURE)) {
+ throw new TransformerFactoryConfigurationError(
+ String.format("Factory %s is not a SAXTransformerFactory", f));
+ }
+
+ FACTORY = (SAXTransformerFactory)f;
+ }
+
+ /**
+ * This class is not marked as shared, so it can be attached to only a single channel,
+ * which means that {@link #decode(ChannelHandlerContext, ByteBuf, List)}
+ * cannot be invoked concurrently. Hence we can reuse the reader.
+ */
+ private final XMLReader reader;
+ private final DocumentBuilder documentBuilder;
+
+ private NetconfEXIToMessageDecoder(final XMLReader reader) {
+ this.reader = requireNonNull(reader);
+ this.documentBuilder = UntrustedXML.newDocumentBuilder();
+ }
+
+ public static NetconfEXIToMessageDecoder create(final NetconfEXICodec codec) throws EXIException {
+ return new NetconfEXIToMessageDecoder(codec.getReader());
+ }
+
+ @Override
+ protected void decode(final ChannelHandlerContext ctx, final ByteBuf in, final List<Object> out)
+ throws IOException, SAXException, TransformerConfigurationException {
+ /*
+ * Note that we could loop here and process all the messages, but we can't do that.
+ * The reason is <stop-exi> operation, which has the contract of immediately stopping
+ * the use of EXI, which means the next message needs to be decoded not by us, but rather
+ * by the XML decoder.
+ */
+
+ // If empty Byte buffer is passed to r.parse, EOFException is thrown
+ if (!in.isReadable()) {
+ LOG.debug("No more content in incoming buffer.");
+ return;
+ }
+
+ if (LOG.isTraceEnabled()) {
+ LOG.trace("Received to decode: {}", ByteBufUtil.hexDump(in));
+ }
+
+ final TransformerHandler handler = FACTORY.newTransformerHandler();
+ reader.setContentHandler(handler);
+
+ final DOMResult domResult = new DOMResult(documentBuilder.newDocument());
+ handler.setResult(domResult);
+
+ try (InputStream is = new ByteBufInputStream(in)) {
+ // Performs internal reset before doing anything
+ reader.parse(new InputSource(is));
+ }
+
+ out.add(new NetconfMessage((Document) domResult.getNode()));
+ }
+}
--- /dev/null
+/*
+ * 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.netconf.nettyutil.handler;
+
+import com.google.common.annotations.VisibleForTesting;
+import com.google.common.base.Optional;
+import com.google.common.base.Preconditions;
+import io.netty.buffer.ByteBuf;
+import io.netty.channel.ChannelHandlerContext;
+import java.io.IOException;
+import java.nio.charset.StandardCharsets;
+import javax.xml.transform.TransformerException;
+import org.opendaylight.netconf.api.NetconfMessage;
+import org.opendaylight.netconf.api.messages.NetconfHelloMessage;
+import org.opendaylight.netconf.api.messages.NetconfHelloMessageAdditionalHeader;
+
+/**
+ * Customized NetconfMessageToXMLEncoder that serializes additional header with
+ * session metadata along with
+ * {@link NetconfHelloMessage}
+ * . Used by netconf clients to send information about the user, ip address,
+ * protocol etc.
+ *
+ * <p>
+ * Hello message with header example:
+ *
+ * <p>
+ *
+ * <pre>
+ * {@code
+ * [tomas;10.0.0.0/10000;tcp;1000;1000;;/home/tomas;;]
+ * < hello xmlns="urn:ietf:params:xml:ns:netconf:base:1.0">
+ * < capabilities>
+ * < capability>urn:ietf:params:netconf:base:1.0< /capability>
+ * < /capabilities>
+ * < /hello>
+ * }
+ * </pre>
+ */
+public final class NetconfHelloMessageToXMLEncoder extends NetconfMessageToXMLEncoder {
+ @Override
+ @VisibleForTesting
+ public void encode(ChannelHandlerContext ctx, NetconfMessage msg, ByteBuf out)
+ throws IOException, TransformerException {
+ Preconditions.checkState(msg instanceof NetconfHelloMessage, "Netconf message of type %s expected, was %s",
+ NetconfHelloMessage.class, msg.getClass());
+ Optional<NetconfHelloMessageAdditionalHeader> headerOptional = ((NetconfHelloMessage) msg)
+ .getAdditionalHeader();
+
+ // If additional header present, serialize it along with netconf hello message
+ if (headerOptional.isPresent()) {
+ out.writeBytes(headerOptional.get().toFormattedString().getBytes(StandardCharsets.UTF_8));
+ }
+
+ super.encode(ctx, msg, out);
+ }
+}
--- /dev/null
+/*
+ * 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.netconf.nettyutil.handler;
+
+import static java.util.Objects.requireNonNull;
+
+import com.siemens.ct.exi.core.exceptions.EXIException;
+import com.siemens.ct.exi.main.api.sax.SAXEncoder;
+import io.netty.buffer.ByteBuf;
+import io.netty.buffer.ByteBufOutputStream;
+import io.netty.channel.ChannelHandlerContext;
+import io.netty.handler.codec.MessageToByteEncoder;
+import java.io.IOException;
+import java.io.OutputStream;
+import javax.xml.transform.Transformer;
+import javax.xml.transform.TransformerException;
+import javax.xml.transform.dom.DOMSource;
+import javax.xml.transform.sax.SAXResult;
+import org.opendaylight.netconf.api.NetconfMessage;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public final class NetconfMessageToEXIEncoder extends MessageToByteEncoder<NetconfMessage> {
+ private static final Logger LOG = LoggerFactory.getLogger(NetconfMessageToEXIEncoder.class);
+ private final NetconfEXICodec codec;
+
+ private NetconfMessageToEXIEncoder(final NetconfEXICodec codec) {
+ this.codec = requireNonNull(codec);
+ }
+
+ public static NetconfMessageToEXIEncoder create(final NetconfEXICodec codec) {
+ return new NetconfMessageToEXIEncoder(codec);
+ }
+
+ @Override
+ protected void encode(final ChannelHandlerContext ctx, final NetconfMessage msg, final ByteBuf out)
+ throws IOException, TransformerException, EXIException {
+ LOG.trace("Sent to encode : {}", msg);
+
+ try (OutputStream os = new ByteBufOutputStream(out)) {
+ final SAXEncoder encoder = codec.getWriter();
+ encoder.setOutputStream(os);
+ final Transformer transformer = ThreadLocalTransformers.getDefaultTransformer();
+ transformer.transform(new DOMSource(msg.getDocument()), new SAXResult(encoder));
+ }
+ }
+}
--- /dev/null
+/*
+ * 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.netconf.nettyutil.handler;
+
+import com.google.common.annotations.VisibleForTesting;
+import com.google.common.base.Optional;
+import io.netty.buffer.ByteBuf;
+import io.netty.buffer.ByteBufOutputStream;
+import io.netty.channel.ChannelHandlerContext;
+import io.netty.handler.codec.MessageToByteEncoder;
+import java.io.IOException;
+import java.io.OutputStream;
+import java.io.OutputStreamWriter;
+import java.nio.charset.StandardCharsets;
+import javax.xml.transform.TransformerException;
+import javax.xml.transform.dom.DOMSource;
+import javax.xml.transform.stream.StreamResult;
+import org.opendaylight.netconf.api.NetconfMessage;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.w3c.dom.Comment;
+
+public class NetconfMessageToXMLEncoder extends MessageToByteEncoder<NetconfMessage> {
+ private static final Logger LOG = LoggerFactory.getLogger(NetconfMessageToXMLEncoder.class);
+
+ private final Optional<String> clientId;
+
+ public NetconfMessageToXMLEncoder() {
+ this(Optional.<String>absent());
+ }
+
+ public NetconfMessageToXMLEncoder(final Optional<String> clientId) {
+ this.clientId = clientId;
+ }
+
+ @Override
+ @VisibleForTesting
+ public void encode(final ChannelHandlerContext ctx, final NetconfMessage msg, final ByteBuf out)
+ throws IOException, TransformerException {
+ LOG.trace("Sent to encode : {}", msg);
+
+ if (clientId.isPresent()) {
+ Comment comment = msg.getDocument().createComment("clientId:" + clientId.get());
+ msg.getDocument().appendChild(comment);
+ }
+
+ try (OutputStream os = new ByteBufOutputStream(out)) {
+ // Wrap OutputStreamWriter with BufferedWriter as suggested in javadoc for OutputStreamWriter
+
+ // Using custom BufferedWriter that does not provide newLine method as performance improvement
+ // see javadoc for BufferedWriter
+ StreamResult result =
+ new StreamResult(new BufferedWriter(new OutputStreamWriter(os, StandardCharsets.UTF_8)));
+ DOMSource source = new DOMSource(msg.getDocument());
+ ThreadLocalTransformers.getPrettyTransformer().transform(source, result);
+ }
+ }
+}
--- /dev/null
+/*
+ * 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.netconf.nettyutil.handler;
+
+import com.google.common.annotations.VisibleForTesting;
+import com.google.common.base.Preconditions;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.Lists;
+import io.netty.buffer.ByteBuf;
+import io.netty.buffer.ByteBufUtil;
+import io.netty.channel.ChannelHandlerContext;
+import io.netty.handler.codec.ByteToMessageDecoder;
+import java.io.ByteArrayInputStream;
+import java.io.IOException;
+import java.nio.ByteBuffer;
+import java.nio.charset.StandardCharsets;
+import java.util.Arrays;
+import java.util.List;
+import org.opendaylight.controller.config.util.xml.XmlUtil;
+import org.opendaylight.netconf.api.NetconfDocumentedException;
+import org.opendaylight.netconf.api.NetconfMessage;
+import org.opendaylight.netconf.api.messages.NetconfHelloMessage;
+import org.opendaylight.netconf.api.messages.NetconfHelloMessageAdditionalHeader;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.w3c.dom.Document;
+import org.xml.sax.SAXException;
+
+/**
+ * Customized NetconfXMLToMessageDecoder that reads additional header with
+ * session metadata from
+ * {@link NetconfHelloMessage}*
+ * This handler should be replaced in pipeline by regular message handler as last step of negotiation.
+ * It serves as a message barrier and halts all non-hello netconf messages.
+ * Netconf messages after hello should be processed once the negotiation succeeded.
+ *
+ */
+public final class NetconfXMLToHelloMessageDecoder extends ByteToMessageDecoder {
+ private static final Logger LOG = LoggerFactory.getLogger(NetconfXMLToHelloMessageDecoder.class);
+
+ private static final List<byte[]> POSSIBLE_ENDS = ImmutableList.of(
+ new byte[] { ']', '\n' },
+ new byte[] { ']', '\r', '\n' });
+ private static final List<byte[]> POSSIBLE_STARTS = ImmutableList.of(
+ new byte[] { '[' },
+ new byte[] { '\r', '\n', '[' },
+ new byte[] { '\n', '[' });
+
+ // State variables do not have to by synchronized
+ // Netty uses always the same (1) thread per pipeline
+ // We use instance of this per pipeline
+ private final List<NetconfMessage> nonHelloMessages = Lists.newArrayList();
+ private boolean helloReceived = false;
+
+ @Override
+ @VisibleForTesting
+ public void decode(final ChannelHandlerContext ctx, final ByteBuf in, final List<Object> out)
+ throws IOException, SAXException, NetconfDocumentedException {
+ if (in.readableBytes() == 0) {
+ LOG.debug("No more content in incoming buffer.");
+ return;
+ }
+
+ in.markReaderIndex();
+ try {
+ if (LOG.isTraceEnabled()) {
+ LOG.trace("Received to decode: {}", ByteBufUtil.hexDump(in));
+ }
+
+ byte[] bytes = new byte[in.readableBytes()];
+ in.readBytes(bytes);
+
+ logMessage(bytes);
+
+ // Extract bytes containing header with additional metadata
+ String additionalHeader = null;
+ if (startsWithAdditionalHeader(bytes)) {
+ // Auth information containing username, ip address... extracted for monitoring
+ int endOfAuthHeader = getAdditionalHeaderEndIndex(bytes);
+ if (endOfAuthHeader > -1) {
+ byte[] additionalHeaderBytes = Arrays.copyOfRange(bytes, 0, endOfAuthHeader);
+ additionalHeader = additionalHeaderToString(additionalHeaderBytes);
+ bytes = Arrays.copyOfRange(bytes, endOfAuthHeader, bytes.length);
+ }
+ }
+
+ Document doc = XmlUtil.readXmlToDocument(new ByteArrayInputStream(bytes));
+
+ final NetconfMessage message = getNetconfMessage(additionalHeader, doc);
+ if (message instanceof NetconfHelloMessage) {
+ Preconditions.checkState(helloReceived == false,
+ "Multiple hello messages received, unexpected hello: %s", message);
+ out.add(message);
+ helloReceived = true;
+ // Non hello message, suspend the message and insert into cache
+ } else {
+ Preconditions.checkState(helloReceived, "Hello message not received, instead received: %s", message);
+ LOG.debug("Netconf message received during negotiation, caching {}", message);
+ nonHelloMessages.add(message);
+ }
+ } finally {
+ in.discardReadBytes();
+ }
+ }
+
+ private static NetconfMessage getNetconfMessage(final String additionalHeader, final Document doc)
+ throws NetconfDocumentedException {
+ NetconfMessage msg = new NetconfMessage(doc);
+ if (NetconfHelloMessage.isHelloMessage(msg)) {
+ if (additionalHeader != null) {
+ return new NetconfHelloMessage(doc, NetconfHelloMessageAdditionalHeader.fromString(additionalHeader));
+ } else {
+ return new NetconfHelloMessage(doc);
+ }
+ }
+
+ return msg;
+ }
+
+ private static int getAdditionalHeaderEndIndex(final byte[] bytes) {
+ for (byte[] possibleEnd : POSSIBLE_ENDS) {
+ int idx = findByteSequence(bytes, possibleEnd);
+
+ if (idx != -1) {
+ return idx + possibleEnd.length;
+ }
+ }
+
+ return -1;
+ }
+
+ private static int findByteSequence(final byte[] bytes, final byte[] sequence) {
+ if (bytes.length < sequence.length) {
+ throw new IllegalArgumentException("Sequence to be found is longer than the given byte array.");
+ }
+ if (bytes.length == sequence.length) {
+ if (Arrays.equals(bytes, sequence)) {
+ return 0;
+ } else {
+ return -1;
+ }
+ }
+ int index = 0;
+ for (int i = 0; i < bytes.length; i++) {
+ if (bytes[i] == sequence[index]) {
+ index++;
+ if (index == sequence.length) {
+ return i - index + 1;
+ }
+ } else {
+ index = 0;
+ }
+ }
+ return -1;
+ }
+
+ private static void logMessage(final byte[] bytes) {
+ if (LOG.isDebugEnabled()) {
+ String string = StandardCharsets.UTF_8.decode(ByteBuffer.wrap(bytes)).toString();
+ LOG.debug("Parsing message \n{}", string);
+ }
+ }
+
+ private static boolean startsWithAdditionalHeader(final byte[] bytes) {
+ for (byte[] possibleStart : POSSIBLE_STARTS) {
+ int index = 0;
+ for (byte b : possibleStart) {
+ if (bytes[index++] != b) {
+ break;
+ }
+
+ if (index == possibleStart.length) {
+ return true;
+ }
+ }
+ }
+
+ return false;
+ }
+
+ private static String additionalHeaderToString(final byte[] bytes) {
+ return StandardCharsets.UTF_8.decode(ByteBuffer.wrap(bytes)).toString();
+ }
+
+ /**
+ * Get netconf messages received during negotiation.
+ *
+ * @return Collection of NetconfMessages that were not hello, but were received during negotiation.
+ */
+ public Iterable<NetconfMessage> getPostHelloNetconfMessages() {
+ return nonHelloMessages;
+ }
+}
--- /dev/null
+/*
+ * 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.netconf.nettyutil.handler;
+
+import io.netty.buffer.ByteBuf;
+import io.netty.buffer.ByteBufInputStream;
+import io.netty.buffer.ByteBufUtil;
+import io.netty.buffer.Unpooled;
+import io.netty.channel.ChannelHandlerContext;
+import io.netty.handler.codec.ByteToMessageDecoder;
+import java.io.IOException;
+import java.util.List;
+import org.opendaylight.controller.config.util.xml.XmlUtil;
+import org.opendaylight.netconf.api.FailedNetconfMessage;
+import org.opendaylight.netconf.api.NetconfMessage;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.xml.sax.SAXException;
+import org.xml.sax.SAXParseException;
+
+public final class NetconfXMLToMessageDecoder extends ByteToMessageDecoder {
+ private static final Logger LOG = LoggerFactory.getLogger(NetconfXMLToMessageDecoder.class);
+
+ @Override
+ public void decode(final ChannelHandlerContext ctx, final ByteBuf in,
+ final List<Object> out) throws IOException, SAXException {
+ if (in.isReadable()) {
+ if (LOG.isTraceEnabled()) {
+ LOG.trace("Received to decode: {}", ByteBufUtil.hexDump(in));
+ }
+
+ /* According to the XML 1.0 specifications, when there is an XML declaration
+ * at the beginning of an XML document, it is invalid to have
+ * white spaces before that declaration (reminder: a XML declaration looks like:
+ * <?xml version="1.0" encoding="UTF-8"?>). In contrast, when there is no XML declaration,
+ * it is valid to have white spaces at the beginning of the document.
+ *
+ * When they send a NETCONF message, several NETCONF servers start with a new line (either
+ * LF or CRLF), presumably to improve readability in interactive sessions with a human being.
+ * Some NETCONF servers send an XML declaration, some others do not.
+ *
+ * If a server starts a NETCONF message with white spaces and follows with an XML
+ * declaration, XmlUtil.readXmlToDocument() will fail because this is invalid XML.
+ * But in the spirit of the "NETCONF over SSH" RFC 4742 and to improve interoperability, we want
+ * to accept those messages.
+ *
+ * To do this, the following code strips the leading bytes before the start of the XML messages.
+ */
+
+ // Skip all leading whitespaces by moving the reader index to the first non whitespace character
+ while (in.isReadable()) {
+ if (!isWhitespace(in.readByte())) {
+ // return reader index to the first non whitespace character
+ in.readerIndex(in.readerIndex() - 1);
+ break;
+ }
+ }
+
+ // Warn about leading whitespaces
+ if (in.readerIndex() != 0 && LOG.isWarnEnabled()) {
+ final byte[] strippedBytes = new byte[in.readerIndex()];
+ in.getBytes(0, strippedBytes, 0, in.readerIndex());
+ LOG.warn("XML message with unwanted leading bytes detected. Discarded the {} leading byte(s): '{}'",
+ in.readerIndex(), ByteBufUtil.hexDump(Unpooled.wrappedBuffer(strippedBytes)));
+ }
+ }
+ if (in.isReadable()) {
+ NetconfMessage msg;
+
+ try {
+ msg = new NetconfMessage(XmlUtil.readXmlToDocument(new ByteBufInputStream(in)));
+ } catch (SAXParseException exception) {
+ LOG.error("Failed to parse received message", exception);
+ msg = new FailedNetconfMessage(exception);
+ }
+
+ out.add(msg);
+ } else {
+ LOG.debug("No more content in incoming buffer.");
+ }
+ }
+
+ /**
+ * Check whether a byte is whitespace/control character. Considered whitespace characters: <br/>
+ * SPACE, \t, \n, \v, \r, \f
+ *
+ * @param byteToCheck byte to check
+ * @return true if the byte is a whitespace/control character
+ */
+ private static boolean isWhitespace(final byte byteToCheck) {
+ return byteToCheck <= 0x0d && byteToCheck >= 0x09 || byteToCheck == 0x20;
+ }
+}
--- /dev/null
+/*
+ * 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.netconf.nettyutil.handler;
+
+import javax.xml.transform.OutputKeys;
+import javax.xml.transform.Transformer;
+import javax.xml.transform.TransformerConfigurationException;
+import javax.xml.transform.TransformerFactory;
+import javax.xml.transform.TransformerFactoryConfigurationError;
+
+/**
+ * Utility class for cached thread-local transformers. This class exists mostly for use by handlers.
+ */
+final class ThreadLocalTransformers {
+ private static final TransformerFactory FACTORY = TransformerFactory.newInstance();
+
+ private static final ThreadLocal<Transformer> DEFAULT_TRANSFORMER = new ThreadLocal<Transformer>() {
+ @Override
+ protected Transformer initialValue() {
+ return createTransformer();
+ }
+
+ @Override
+ public void set(final Transformer value) {
+ throw new UnsupportedOperationException();
+ }
+ };
+
+ private static final ThreadLocal<Transformer> PRETTY_TRANSFORMER = new ThreadLocal<Transformer>() {
+ @Override
+ protected Transformer initialValue() {
+ final Transformer ret = createTransformer();
+ ret.setOutputProperty(OutputKeys.INDENT, "yes");
+ ret.setOutputProperty(OutputKeys.OMIT_XML_DECLARATION, "no");
+ return ret;
+ }
+
+ @Override
+ public void set(final Transformer value) {
+ throw new UnsupportedOperationException();
+ }
+ };
+
+ private ThreadLocalTransformers() {
+ throw new UnsupportedOperationException("Utility class");
+ }
+
+ /**
+ * Get the transformer with default configuration.
+ *
+ * @return A transformer with default configuration based on the default implementation.
+ */
+ static Transformer getDefaultTransformer() {
+ return DEFAULT_TRANSFORMER.get();
+ }
+
+ /**
+ * Get the transformer with default configuration, but with automatic indentation
+ * and the XML declaration removed.
+ *
+ * @return A transformer with human-friendly configuration.
+ */
+ static Transformer getPrettyTransformer() {
+ return PRETTY_TRANSFORMER.get();
+ }
+
+ private static Transformer createTransformer() {
+ try {
+ return FACTORY.newTransformer();
+ } catch (TransformerConfigurationException | TransformerFactoryConfigurationError e) {
+ throw new IllegalStateException("Unexpected error while instantiating a Transformer", e);
+ }
+ }
+}
--- /dev/null
+/*
+ * Copyright (c) 2013 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.netconf.nettyutil.handler.exi;
+
+import static java.util.Objects.requireNonNull;
+
+import com.google.common.annotations.VisibleForTesting;
+import com.siemens.ct.exi.core.CodingMode;
+import com.siemens.ct.exi.core.EXIFactory;
+import com.siemens.ct.exi.core.EncodingOptions;
+import com.siemens.ct.exi.core.FidelityOptions;
+import com.siemens.ct.exi.core.exceptions.UnsupportedOption;
+import com.siemens.ct.exi.core.helpers.DefaultEXIFactory;
+import java.util.Objects;
+import org.opendaylight.controller.config.util.xml.XmlElement;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.w3c.dom.Element;
+import org.w3c.dom.NodeList;
+
+public final class EXIParameters {
+ private static final Logger LOG = LoggerFactory.getLogger(EXIParameters.class);
+
+ static final String EXI_PARAMETER_ALIGNMENT = "alignment";
+ private static final String EXI_PARAMETER_BYTE_ALIGNED = "byte-aligned";
+ private static final String EXI_PARAMETER_BIT_PACKED = "bit-packed";
+ private static final String EXI_PARAMETER_COMPRESSED = "compressed";
+ private static final String EXI_PARAMETER_PRE_COMPRESSION = "pre-compression";
+
+ static final String EXI_PARAMETER_FIDELITY = "fidelity";
+ private static final String EXI_FIDELITY_DTD = "dtd";
+ private static final String EXI_FIDELITY_LEXICAL_VALUES = "lexical-values";
+ private static final String EXI_FIDELITY_COMMENTS = "comments";
+ private static final String EXI_FIDELITY_PIS = "pis";
+ private static final String EXI_FIDELITY_PREFIXES = "prefixes";
+
+ private static final EncodingOptions ENCODING_OPTIONS;
+
+ static {
+ final EncodingOptions opts = EncodingOptions.createDefault();
+ try {
+ opts.setOption(EncodingOptions.RETAIN_ENTITY_REFERENCE);
+ opts.setOption(EncodingOptions.INCLUDE_OPTIONS);
+
+ /**
+ * NETCONF is XML environment, so the use of EXI cookie is not really needed. Adding it
+ * decreases efficiency of encoding by adding human-readable 4 bytes "EXI$" to the head
+ * of the stream. This is really useful, so let's output it now.
+ */
+ opts.setOption(EncodingOptions.INCLUDE_COOKIE);
+ } catch (final UnsupportedOption e) {
+ throw new ExceptionInInitializerError(e);
+ }
+
+ ENCODING_OPTIONS = opts;
+ }
+
+ private final FidelityOptions fidelityOptions;
+ private final CodingMode codingMode;
+
+ public EXIParameters(final CodingMode codingMode, final FidelityOptions fidelityOptions) {
+ this.fidelityOptions = requireNonNull(fidelityOptions);
+ this.codingMode = requireNonNull(codingMode);
+ }
+
+ @VisibleForTesting
+ public static EXIParameters empty() {
+ return new EXIParameters(CodingMode.BIT_PACKED, FidelityOptions.createDefault());
+ }
+
+ public static EXIParameters fromXmlElement(final XmlElement root) throws UnsupportedOption {
+ final CodingMode coding;
+ final NodeList alignmentElements = root.getElementsByTagName(EXI_PARAMETER_ALIGNMENT);
+ if (alignmentElements.getLength() > 0) {
+ final Element alignmentElement = (Element) alignmentElements.item(0);
+ final String alignmentTextContent = alignmentElement.getTextContent().trim();
+
+ switch (alignmentTextContent) {
+ case EXI_PARAMETER_BYTE_ALIGNED:
+ coding = CodingMode.BYTE_PACKED;
+ break;
+ case EXI_PARAMETER_COMPRESSED:
+ coding = CodingMode.COMPRESSION;
+ break;
+ case EXI_PARAMETER_PRE_COMPRESSION:
+ coding = CodingMode.PRE_COMPRESSION;
+ break;
+ case EXI_PARAMETER_BIT_PACKED:
+ coding = CodingMode.BIT_PACKED;
+ break;
+ default:
+ LOG.warn("Unexpected value in alignmentTextContent: {} , using default value",
+ alignmentTextContent);
+ coding = CodingMode.BIT_PACKED;
+ break;
+ }
+ } else {
+ coding = CodingMode.BIT_PACKED;
+ }
+
+ final FidelityOptions fidelity = FidelityOptions.createDefault();
+ final NodeList fidelityElements = root.getElementsByTagName(EXI_PARAMETER_FIDELITY);
+ if (fidelityElements.getLength() > 0) {
+ final Element fidelityElement = (Element) fidelityElements.item(0);
+
+ fidelity.setFidelity(FidelityOptions.FEATURE_DTD,
+ fidelityElement.getElementsByTagName(EXI_FIDELITY_DTD).getLength() > 0);
+ fidelity.setFidelity(FidelityOptions.FEATURE_LEXICAL_VALUE,
+ fidelityElement.getElementsByTagName(EXI_FIDELITY_LEXICAL_VALUES).getLength() > 0);
+ fidelity.setFidelity(FidelityOptions.FEATURE_COMMENT,
+ fidelityElement.getElementsByTagName(EXI_FIDELITY_COMMENTS).getLength() > 0);
+ fidelity.setFidelity(FidelityOptions.FEATURE_PI,
+ fidelityElement.getElementsByTagName(EXI_FIDELITY_PIS).getLength() > 0);
+ fidelity.setFidelity(FidelityOptions.FEATURE_PREFIX,
+ fidelityElement.getElementsByTagName(EXI_FIDELITY_PREFIXES).getLength() > 0);
+ }
+
+ return new EXIParameters(coding, fidelity);
+ }
+
+ public EXIFactory getFactory() {
+ final EXIFactory factory = DefaultEXIFactory.newInstance();
+ factory.setCodingMode(codingMode);
+ factory.setEncodingOptions(ENCODING_OPTIONS);
+ factory.setFidelityOptions(fidelityOptions);
+ return factory;
+ }
+
+ @Override
+ public int hashCode() {
+ return Objects.hash(fidelityOptions, codingMode);
+ }
+
+ @Override
+ public boolean equals(final Object obj) {
+ if (this == obj) {
+ return true;
+ }
+ if (!(obj instanceof EXIParameters)) {
+ return false;
+ }
+ final EXIParameters other = (EXIParameters) obj;
+ return (codingMode == other.codingMode) && fidelityOptions.equals(other.fidelityOptions);
+ }
+
+ String getAlignment() {
+ switch (codingMode) {
+ case BIT_PACKED:
+ return EXI_PARAMETER_BIT_PACKED;
+ case BYTE_PACKED:
+ return EXI_PARAMETER_BYTE_ALIGNED;
+ case COMPRESSION:
+ return EXI_PARAMETER_COMPRESSED;
+ case PRE_COMPRESSION:
+ return EXI_PARAMETER_PRE_COMPRESSION;
+ default:
+ throw new IllegalStateException("Unhandled coding mode " + codingMode);
+ }
+ }
+
+ private String fidelityString(final String feature, final String string) {
+ return fidelityOptions.isFidelityEnabled(feature) ? string : null;
+ }
+
+ String getPreserveComments() {
+ return fidelityString(FidelityOptions.FEATURE_COMMENT, EXI_FIDELITY_COMMENTS);
+ }
+
+ String getPreserveDTD() {
+ return fidelityString(FidelityOptions.FEATURE_DTD, EXI_FIDELITY_DTD);
+ }
+
+ String getPreserveLexicalValues() {
+ return fidelityString(FidelityOptions.FEATURE_LEXICAL_VALUE, EXI_FIDELITY_LEXICAL_VALUES);
+ }
+
+ String getPreservePIs() {
+ return fidelityString(FidelityOptions.FEATURE_PI, EXI_FIDELITY_PIS);
+ }
+
+ String getPreservePrefixes() {
+ return fidelityString(FidelityOptions.FEATURE_PREFIX, EXI_FIDELITY_PREFIXES);
+ }
+}
\ No newline at end of file
--- /dev/null
+/*
+ * Copyright (c) 2013 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.netconf.nettyutil.handler.exi;
+
+import com.google.common.annotations.VisibleForTesting;
+import java.util.ArrayList;
+import java.util.List;
+import org.opendaylight.controller.config.util.xml.XmlUtil;
+import org.opendaylight.netconf.api.NetconfMessage;
+import org.opendaylight.netconf.api.xml.XmlNetconfConstants;
+import org.w3c.dom.Document;
+import org.w3c.dom.Element;
+
+/**
+ * Start-exi netconf message.
+ */
+public final class NetconfStartExiMessage extends NetconfMessage {
+ @VisibleForTesting
+ public static final String START_EXI = "start-exi";
+
+
+ private NetconfStartExiMessage(final Document doc) {
+ super(doc);
+ }
+
+ public static NetconfStartExiMessage create(final EXIParameters exiOptions, final String messageId) {
+ final Document doc = XmlUtil.newDocument();
+ final Element rpcElement = doc.createElementNS(XmlNetconfConstants.URN_IETF_PARAMS_XML_NS_NETCONF_BASE_1_0,
+ XmlNetconfConstants.RPC_KEY);
+ rpcElement.setAttributeNS(XmlNetconfConstants.URN_IETF_PARAMS_XML_NS_NETCONF_BASE_1_0,
+ XmlNetconfConstants.MESSAGE_ID, messageId);
+
+ // TODO draft http://tools.ietf.org/html/draft-varga-netconf-exi-capability-02#section-3.5.1 has no namespace
+ // for start-exi element in xml
+ final Element startExiElement = doc.createElementNS(XmlNetconfConstants.URN_IETF_PARAMS_XML_NS_NETCONF_EXI_1_0,
+ START_EXI);
+
+ addAlignment(exiOptions, doc, startExiElement);
+ addFidelity(exiOptions, doc, startExiElement);
+
+ rpcElement.appendChild(startExiElement);
+
+ doc.appendChild(rpcElement);
+ return new NetconfStartExiMessage(doc);
+ }
+
+ private static void addFidelity(final EXIParameters exiOptions, final Document doc, final Element startExiElement) {
+ final List<Element> fidelityElements = new ArrayList<>(5);
+ createFidelityElement(doc, fidelityElements, exiOptions.getPreserveComments());
+ createFidelityElement(doc, fidelityElements, exiOptions.getPreserveDTD());
+ createFidelityElement(doc, fidelityElements, exiOptions.getPreserveLexicalValues());
+ createFidelityElement(doc, fidelityElements, exiOptions.getPreservePIs());
+ createFidelityElement(doc, fidelityElements, exiOptions.getPreservePrefixes());
+
+ if (!fidelityElements.isEmpty()) {
+ final Element fidelityElement = doc.createElementNS(
+ XmlNetconfConstants.URN_IETF_PARAMS_XML_NS_NETCONF_EXI_1_0, EXIParameters.EXI_PARAMETER_FIDELITY);
+ for (final Element element : fidelityElements) {
+ fidelityElement.appendChild(element);
+ }
+ startExiElement.appendChild(fidelityElement);
+ }
+ }
+
+ private static void addAlignment(final EXIParameters exiOptions, final Document doc,
+ final Element startExiElement) {
+ final Element alignmentElement = doc.createElementNS(XmlNetconfConstants.URN_IETF_PARAMS_XML_NS_NETCONF_EXI_1_0,
+ EXIParameters.EXI_PARAMETER_ALIGNMENT);
+
+ alignmentElement.setTextContent(exiOptions.getAlignment());
+ startExiElement.appendChild(alignmentElement);
+ }
+
+ private static void createFidelityElement(final Document doc, final List<Element> elements,
+ final String fidelity) {
+ if (fidelity != null) {
+ elements.add(doc.createElementNS(XmlNetconfConstants.URN_IETF_PARAMS_XML_NS_NETCONF_EXI_1_0, fidelity));
+ }
+ }
+}
\ No newline at end of file
--- /dev/null
+/*
+ * Copyright (c) 2013 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.netconf.nettyutil.handler.ssh.authentication;
+
+import java.io.IOException;
+import org.apache.sshd.ClientSession;
+
+/**
+ * Class providing authentication facility to SSH handler.
+ */
+public abstract class AuthenticationHandler {
+
+ public abstract String getUsername();
+
+ public abstract org.apache.sshd.client.future.AuthFuture authenticate(ClientSession session)
+ throws IOException;
+}
--- /dev/null
+/*
+ * Copyright (c) 2013 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.netconf.nettyutil.handler.ssh.authentication;
+
+import java.io.IOException;
+import org.apache.sshd.ClientSession;
+import org.apache.sshd.client.future.AuthFuture;
+import org.opendaylight.aaa.encrypt.AAAEncryptionService;
+
+/**
+ * Class Providing username/password authentication option to
+ * {@link org.opendaylight.netconf.nettyutil.handler.ssh.client.AsyncSshHandler}.
+ */
+public class LoginPassword extends AuthenticationHandler {
+ protected final String username;
+ protected final String password;
+ protected final AAAEncryptionService encryptionService;
+
+ public LoginPassword(String username, String password) {
+ this(username, password, null);
+ }
+
+ public LoginPassword(final String username, final String password, final AAAEncryptionService encryptionService) {
+ this.username = username;
+ this.password = password;
+ this.encryptionService = encryptionService;
+ }
+
+ @Override
+ public String getUsername() {
+ return username;
+ }
+
+ @Override
+ public AuthFuture authenticate(final ClientSession session) throws IOException {
+ if (encryptionService != null) {
+ String decryptedPassword = encryptionService.decrypt(password);
+ session.addPasswordIdentity(decryptedPassword);
+ } else {
+ session.addPasswordIdentity(password);
+ }
+ return session.auth();
+ }
+}
--- /dev/null
+/*
+ * Copyright (c) 2017 Brocade Communication Systems 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.netconf.nettyutil.handler.ssh.authentication;
+
+import com.google.common.base.Strings;
+import java.io.IOException;
+import java.security.KeyPair;
+import org.apache.sshd.ClientSession;
+import org.apache.sshd.client.future.AuthFuture;
+import org.opendaylight.aaa.encrypt.AAAEncryptionService;
+import org.opendaylight.aaa.encrypt.PKIUtil;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+/**
+ * Represents Auth information for the public key based authentication for netconf.
+ */
+public class PublicKeyAuth extends LoginPassword {
+ private KeyPair keyPair = null;
+ private static final Logger LOG = LoggerFactory.getLogger(PublicKeyAuth.class);
+
+ public PublicKeyAuth(String username, String password, String keyPath,
+ String passPhrase, AAAEncryptionService encryptionService) {
+ super(username, password, encryptionService);
+ try {
+ boolean isKeyPathAbsent = Strings.isNullOrEmpty(keyPath);
+ passPhrase = Strings.isNullOrEmpty(passPhrase) ? "" : passPhrase;
+ if (!isKeyPathAbsent) {
+ this.keyPair = new PKIUtil().decodePrivateKey(keyPath, passPhrase);
+ } else {
+ LOG.info("Private key path not specified in the config file.");
+ }
+ } catch (IOException ioEx) {
+ LOG.warn("Not able to read the private key and passphrase for netconf client", ioEx);
+ }
+ }
+
+ @Override
+ public AuthFuture authenticate(final ClientSession session) throws IOException {
+ if (keyPair != null) {
+ session.addPublicKeyIdentity(keyPair);
+ }
+
+ return super.authenticate(session);
+ }
+}
--- /dev/null
+/*
+ * 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.netconf.nettyutil.handler.ssh.client;
+
+import com.google.common.base.Preconditions;
+import io.netty.buffer.ByteBuf;
+import io.netty.channel.ChannelHandlerContext;
+import io.netty.channel.ChannelOutboundHandlerAdapter;
+import io.netty.channel.ChannelPromise;
+import io.netty.util.concurrent.Future;
+import io.netty.util.concurrent.GenericFutureListener;
+import java.io.IOException;
+import java.net.SocketAddress;
+import java.util.HashMap;
+import java.util.Map;
+import org.apache.sshd.ClientChannel;
+import org.apache.sshd.ClientSession;
+import org.apache.sshd.SshClient;
+import org.apache.sshd.client.future.AuthFuture;
+import org.apache.sshd.client.future.ConnectFuture;
+import org.apache.sshd.client.future.OpenFuture;
+import org.apache.sshd.common.future.CloseFuture;
+import org.apache.sshd.common.future.SshFutureListener;
+import org.opendaylight.netconf.nettyutil.handler.ssh.authentication.AuthenticationHandler;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+/**
+ * Netty SSH handler class. Acts as interface between Netty and SSH library.
+ */
+public class AsyncSshHandler extends ChannelOutboundHandlerAdapter {
+ private static final Logger LOG = LoggerFactory.getLogger(AsyncSshHandler.class);
+
+ public static final String SUBSYSTEM = "netconf";
+
+ public static final int SSH_DEFAULT_NIO_WORKERS = 8;
+ // Disable default timeouts from mina sshd
+ private static final long DEFAULT_TIMEOUT = -1L;
+
+ public static final SshClient DEFAULT_CLIENT;
+
+ static {
+ final Map<String, String> props = new HashMap<>();
+ props.put(SshClient.AUTH_TIMEOUT, Long.toString(DEFAULT_TIMEOUT));
+ props.put(SshClient.IDLE_TIMEOUT, Long.toString(DEFAULT_TIMEOUT));
+
+ final SshClient c = SshClient.setUpDefaultClient();
+
+ c.setProperties(props);
+ // TODO make configurable, or somehow reuse netty threadpool
+ c.setNioWorkers(SSH_DEFAULT_NIO_WORKERS);
+ c.start();
+ DEFAULT_CLIENT = c;
+ }
+
+ private final AuthenticationHandler authenticationHandler;
+ private final SshClient sshClient;
+ private Future<?> negotiationFuture;
+
+ private AsyncSshHandlerReader sshReadAsyncListener;
+ private AsyncSshHandlerWriter sshWriteAsyncHandler;
+
+ private ClientChannel channel;
+ private ClientSession session;
+ private ChannelPromise connectPromise;
+ private GenericFutureListener negotiationFutureListener;
+
+ public AsyncSshHandler(final AuthenticationHandler authenticationHandler, final SshClient sshClient,
+ final Future<?> negotiationFuture) throws IOException {
+ this(authenticationHandler, sshClient);
+ this.negotiationFuture = negotiationFuture;
+ }
+
+ /**
+ * Constructor of {@code AsyncSshHandler}.
+ *
+ * @param authenticationHandler authentication handler
+ * @param sshClient started SshClient
+ * @throws IOException if the I/O operation fails
+ */
+ public AsyncSshHandler(final AuthenticationHandler authenticationHandler,
+ final SshClient sshClient) throws IOException {
+ this.authenticationHandler = Preconditions.checkNotNull(authenticationHandler);
+ this.sshClient = Preconditions.checkNotNull(sshClient);
+ }
+
+ public static AsyncSshHandler createForNetconfSubsystem(final AuthenticationHandler authenticationHandler)
+ throws IOException {
+ return new AsyncSshHandler(authenticationHandler, DEFAULT_CLIENT);
+ }
+
+ /**
+ * Create AsyncSshHandler for netconf subsystem. Negotiation future has to be set to success after successful
+ * netconf negotiation.
+ *
+ * @param authenticationHandler authentication handler
+ * @param negotiationFuture negotiation future
+ * @return {@code AsyncSshHandler}
+ * @throws IOException if the I/O operation fails
+ */
+ public static AsyncSshHandler createForNetconfSubsystem(final AuthenticationHandler authenticationHandler,
+ final Future<?> negotiationFuture) throws IOException {
+ return new AsyncSshHandler(authenticationHandler, DEFAULT_CLIENT, negotiationFuture);
+ }
+
+ private void startSsh(final ChannelHandlerContext ctx, final SocketAddress address) {
+ LOG.debug("Starting SSH to {} on channel: {}", address, ctx.channel());
+
+ final ConnectFuture sshConnectionFuture = sshClient.connect(authenticationHandler.getUsername(), address);
+ sshConnectionFuture.addListener(new SshFutureListener<ConnectFuture>() {
+ @Override
+ public void operationComplete(final ConnectFuture future) {
+ if (future.isConnected()) {
+ handleSshSessionCreated(future, ctx);
+ } else {
+ handleSshSetupFailure(ctx, future.getException());
+ }
+ }
+ });
+ }
+
+ private synchronized void handleSshSessionCreated(final ConnectFuture future, final ChannelHandlerContext ctx) {
+ try {
+ LOG.trace("SSH session created on channel: {}", ctx.channel());
+
+ session = future.getSession();
+ final AuthFuture authenticateFuture = authenticationHandler.authenticate(session);
+ authenticateFuture.addListener(new SshFutureListener<AuthFuture>() {
+ @Override
+ public void operationComplete(final AuthFuture future) {
+ if (future.isSuccess()) {
+ handleSshAuthenticated(session, ctx);
+ } else {
+ // Exception does not have to be set in the future, add simple exception in such case
+ final Throwable exception = future.getException() == null
+ ? new IllegalStateException("Authentication failed") : future.getException();
+ handleSshSetupFailure(ctx, exception);
+ }
+ }
+ });
+ } catch (final IOException e) {
+ handleSshSetupFailure(ctx, e);
+ }
+ }
+
+ private synchronized void handleSshAuthenticated(final ClientSession session, final ChannelHandlerContext ctx) {
+ try {
+ LOG.debug("SSH session authenticated on channel: {}, server version: {}", ctx.channel(),
+ session.getServerVersion());
+
+ channel = session.createSubsystemChannel(SUBSYSTEM);
+ channel.setStreaming(ClientChannel.Streaming.Async);
+ channel.open().addListener(new SshFutureListener<OpenFuture>() {
+ @Override
+ public void operationComplete(final OpenFuture future) {
+ if (future.isOpened()) {
+ handleSshChanelOpened(ctx);
+ } else {
+ handleSshSetupFailure(ctx, future.getException());
+ }
+ }
+ });
+
+
+ } catch (final IOException e) {
+ handleSshSetupFailure(ctx, e);
+ }
+ }
+
+ private synchronized void handleSshChanelOpened(final ChannelHandlerContext ctx) {
+ LOG.trace("SSH subsystem channel opened successfully on channel: {}", ctx.channel());
+
+ if (negotiationFuture == null) {
+ connectPromise.setSuccess();
+ }
+
+ // TODO we should also read from error stream and at least log from that
+
+ sshReadAsyncListener = new AsyncSshHandlerReader(new AutoCloseable() {
+ @Override
+ public void close() throws Exception {
+ AsyncSshHandler.this.disconnect(ctx, ctx.newPromise());
+ }
+ }, new AsyncSshHandlerReader.ReadMsgHandler() {
+ @Override
+ public void onMessageRead(final ByteBuf msg) {
+ ctx.fireChannelRead(msg);
+ }
+ }, channel.toString(), channel.getAsyncOut());
+
+ // if readAsyncListener receives immediate close,
+ // it will close this handler and closing this handler sets channel variable to null
+ if (channel != null) {
+ sshWriteAsyncHandler = new AsyncSshHandlerWriter(channel.getAsyncIn());
+ ctx.fireChannelActive();
+ }
+ }
+
+ private synchronized void handleSshSetupFailure(final ChannelHandlerContext ctx, final Throwable error) {
+ LOG.warn("Unable to setup SSH connection on channel: {}", ctx.channel(), error);
+
+ // If the promise is not yet done, we have failed with initial connect and set connectPromise to failure
+ if (!connectPromise.isDone()) {
+ connectPromise.setFailure(error);
+ }
+
+ disconnect(ctx, ctx.newPromise());
+ }
+
+ @Override
+ public synchronized void write(final ChannelHandlerContext ctx, final Object msg, final ChannelPromise promise) {
+ sshWriteAsyncHandler.write(ctx, msg, promise);
+ }
+
+ @Override
+ public synchronized void connect(final ChannelHandlerContext ctx, final SocketAddress remoteAddress,
+ final SocketAddress localAddress, final ChannelPromise promise) throws Exception {
+ LOG.debug("SSH session connecting on channel {}. promise: {} ", ctx.channel(), connectPromise);
+ this.connectPromise = promise;
+
+ if (negotiationFuture != null) {
+
+ negotiationFutureListener = new GenericFutureListener<Future<?>>() {
+ @Override
+ public void operationComplete(final Future<?> future) {
+ if (future.isSuccess()) {
+ connectPromise.setSuccess();
+ }
+ }
+ };
+ //complete connection promise with netconf negotiation future
+ negotiationFuture.addListener(negotiationFutureListener);
+ }
+ startSsh(ctx, remoteAddress);
+ }
+
+ @Override
+ public void close(final ChannelHandlerContext ctx, final ChannelPromise promise) throws Exception {
+ disconnect(ctx, promise);
+ }
+
+ @SuppressWarnings("checkstyle:IllegalCatch")
+ @Override
+ public synchronized void disconnect(final ChannelHandlerContext ctx, final ChannelPromise promise) {
+ LOG.trace("Closing SSH session on channel: {} with connect promise in state: {}",
+ ctx.channel(),connectPromise);
+
+ // If we have already succeeded and the session was dropped after,
+ // we need to fire inactive to notify reconnect logic
+ if (connectPromise.isSuccess()) {
+ ctx.fireChannelInactive();
+ }
+
+ if (sshWriteAsyncHandler != null) {
+ sshWriteAsyncHandler.close();
+ }
+
+ if (sshReadAsyncListener != null) {
+ sshReadAsyncListener.close();
+ }
+
+ //If connection promise is not already set, it means negotiation failed
+ //we must set connection promise to failure
+ if (!connectPromise.isDone()) {
+ connectPromise.setFailure(new IllegalStateException("Negotiation failed"));
+ }
+
+ //Remove listener from negotiation future, we don't want notifications
+ //from negotiation anymore
+ if (negotiationFuture != null) {
+ negotiationFuture.removeListener(negotiationFutureListener);
+ }
+
+ if (session != null && !session.isClosed() && !session.isClosing()) {
+ session.close(false).addListener(new SshFutureListener<CloseFuture>() {
+ @Override
+ public void operationComplete(final CloseFuture future) {
+ if (future.isClosed() == false) {
+ session.close(true);
+ }
+ session = null;
+ }
+ });
+ }
+
+ // Super disconnect is necessary in this case since we are using NioSocketChannel and it needs
+ // to cleanup its resources e.g. Socket that it tries to open in its constructor
+ // (https://bugs.opendaylight.org/show_bug.cgi?id=2430)
+ // TODO better solution would be to implement custom ChannelFactory + Channel
+ // that will use mina SSH lib internally: port this to custom channel implementation
+ try {
+ // Disconnect has to be closed after inactive channel event was fired, because it interferes with it
+ super.disconnect(ctx, ctx.newPromise());
+ } catch (final Exception e) {
+ LOG.warn("Unable to cleanup all resources for channel: {}. Ignoring.", ctx.channel(), e);
+ }
+
+ channel = null;
+ promise.setSuccess();
+ LOG.debug("SSH session closed on channel: {}", ctx.channel());
+ }
+
+}
--- /dev/null
+/*
+ * 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.netconf.nettyutil.handler.ssh.client;
+
+import io.netty.buffer.ByteBuf;
+import io.netty.buffer.Unpooled;
+import org.apache.sshd.common.future.SshFutureListener;
+import org.apache.sshd.common.io.IoInputStream;
+import org.apache.sshd.common.io.IoReadFuture;
+import org.apache.sshd.common.util.Buffer;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+/**
+ * Listener on async input stream from SSH session.
+ * This listeners schedules reads in a loop until the session is closed or read fails.
+ */
+public final class AsyncSshHandlerReader implements SshFutureListener<IoReadFuture>, AutoCloseable {
+
+ private static final Logger LOG = LoggerFactory.getLogger(AsyncSshHandlerReader.class);
+
+ private static final int BUFFER_SIZE = 2048;
+
+ private final AutoCloseable connectionClosedCallback;
+ private final ReadMsgHandler readHandler;
+
+ private final String channelId;
+ private IoInputStream asyncOut;
+ private Buffer buf;
+ private IoReadFuture currentReadFuture;
+
+ public AsyncSshHandlerReader(final AutoCloseable connectionClosedCallback, final ReadMsgHandler readHandler,
+ final String channelId, final IoInputStream asyncOut) {
+ this.connectionClosedCallback = connectionClosedCallback;
+ this.readHandler = readHandler;
+ this.channelId = channelId;
+ this.asyncOut = asyncOut;
+ buf = new Buffer(BUFFER_SIZE);
+ asyncOut.read(buf).addListener(this);
+ }
+
+ @Override
+ public synchronized void operationComplete(final IoReadFuture future) {
+ if (future.getException() != null) {
+
+ //if asyncout is already set to null by close method, do nothing
+ if (asyncOut == null) {
+ return;
+ }
+
+ if (asyncOut.isClosed() || asyncOut.isClosing()) {
+ // Ssh dropped
+ LOG.debug("Ssh session dropped on channel: {}", channelId, future.getException());
+ } else {
+ LOG.warn("Exception while reading from SSH remote on channel {}", channelId, future.getException());
+ }
+ invokeDisconnect();
+ return;
+ }
+
+ if (future.getRead() > 0) {
+ final ByteBuf msg = Unpooled.wrappedBuffer(buf.array(), 0, future.getRead());
+ if (LOG.isTraceEnabled()) {
+ LOG.trace("Reading message on channel: {}, message: {}",
+ channelId, AsyncSshHandlerWriter.byteBufToString(msg));
+ }
+ readHandler.onMessageRead(msg);
+
+ // Schedule next read
+ buf = new Buffer(BUFFER_SIZE);
+ currentReadFuture = asyncOut.read(buf);
+ currentReadFuture.addListener(this);
+ }
+ }
+
+ @SuppressWarnings("checkstyle:IllegalCatch")
+ private void invokeDisconnect() {
+ try {
+ connectionClosedCallback.close();
+ } catch (final Exception e) {
+ // This should not happen
+ throw new IllegalStateException(e);
+ }
+ }
+
+ @Override
+ public synchronized void close() {
+ // Remove self as listener on close to prevent reading from closed input
+ if (currentReadFuture != null) {
+ currentReadFuture.removeListener(this);
+ currentReadFuture = null;
+ }
+
+ asyncOut = null;
+ }
+
+ public interface ReadMsgHandler {
+
+ void onMessageRead(ByteBuf msg);
+ }
+}
--- /dev/null
+/*
+ * 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.netconf.nettyutil.handler.ssh.client;
+
+import com.google.common.base.Preconditions;
+import io.netty.buffer.ByteBuf;
+import io.netty.channel.ChannelHandlerContext;
+import io.netty.channel.ChannelPromise;
+import java.nio.charset.StandardCharsets;
+import java.util.Deque;
+import java.util.LinkedList;
+import java.util.Queue;
+import org.apache.sshd.common.future.SshFutureListener;
+import org.apache.sshd.common.io.IoOutputStream;
+import org.apache.sshd.common.io.IoWriteFuture;
+import org.apache.sshd.common.io.WritePendingException;
+import org.apache.sshd.common.util.Buffer;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+/**
+ * Async Ssh writer. Takes messages(byte arrays) and sends them encrypted to remote server.
+ * Also handles pending writes by caching requests until pending state is over.
+ */
+public final class AsyncSshHandlerWriter implements AutoCloseable {
+
+ private static final Logger LOG = LoggerFactory
+ .getLogger(AsyncSshHandlerWriter.class);
+
+ // public static final int MAX_PENDING_WRITES = 1000;
+ // TODO implement Limiting mechanism for pending writes
+ // But there is a possible issue with limiting:
+ // 1. What to do when queue is full ? Immediate Fail for every request ?
+ // 2. At this level we might be dealing with Chunks of messages(not whole messages)
+ // and unexpected behavior might occur when we send/queue 1 chunk and fail the other chunks
+
+ private final Object asyncInLock = new Object();
+ private volatile IoOutputStream asyncIn;
+
+ // Order has to be preserved for queued writes
+ private final Deque<PendingWriteRequest> pending = new LinkedList<>();
+
+ public AsyncSshHandlerWriter(final IoOutputStream asyncIn) {
+ this.asyncIn = asyncIn;
+ }
+
+ public void write(final ChannelHandlerContext ctx,
+ final Object msg, final ChannelPromise promise) {
+ if (asyncIn == null) {
+ promise.setFailure(new IllegalStateException("Channel closed"));
+ return;
+ }
+ // synchronized block due to deadlock that happens on ssh window resize
+ // writes and pending writes would lock the underlyinch channel session
+ // window resize write would try to write the message on an already locked channelSession
+ // while the pending write was in progress from the write callback
+ synchronized (asyncInLock) {
+ // TODO check for isClosed, isClosing might be performed by mina SSH internally and is not required here
+ // If we are closed/closing, set immediate fail
+ if (asyncIn.isClosed() || asyncIn.isClosing()) {
+ promise.setFailure(new IllegalStateException("Channel closed"));
+ } else {
+ final ByteBuf byteBufMsg = (ByteBuf) msg;
+ if (pending.isEmpty() == false) {
+ queueRequest(ctx, byteBufMsg, promise);
+ return;
+ }
+
+ writeWithPendingDetection(ctx, promise, byteBufMsg, false);
+ }
+ }
+ }
+
+ //sending message with pending
+ //if resending message not succesfull, then attribute wasPending is true
+ private void writeWithPendingDetection(final ChannelHandlerContext ctx, final ChannelPromise promise,
+ final ByteBuf byteBufMsg, final boolean wasPending) {
+ try {
+
+ if (LOG.isTraceEnabled()) {
+ LOG.trace("Writing request on channel: {}, message: {}", ctx.channel(), byteBufToString(byteBufMsg));
+ }
+ asyncIn.write(toBuffer(byteBufMsg)).addListener(new SshFutureListener<IoWriteFuture>() {
+
+ @Override
+ public void operationComplete(final IoWriteFuture future) {
+ // synchronized block due to deadlock that happens on ssh window resize
+ // writes and pending writes would lock the underlyinch channel session
+ // window resize write would try to write the message on an already locked channelSession,
+ // while the pending write was in progress from the write callback
+ synchronized (asyncInLock) {
+ if (LOG.isTraceEnabled()) {
+ LOG.trace(
+ "Ssh write request finished on channel: {} with result: {}: and ex:{}, message: {}",
+ ctx.channel(), future.isWritten(), future.getException(), byteBufToString(byteBufMsg));
+ }
+
+ // Notify success or failure
+ if (future.isWritten()) {
+ promise.setSuccess();
+ } else {
+ LOG.warn("Ssh write request failed on channel: {} for message: {}", ctx.channel(),
+ byteBufToString(byteBufMsg), future.getException());
+ promise.setFailure(future.getException());
+ }
+
+ // Not needed anymore, release
+ byteBufMsg.release();
+
+ //rescheduling message from queue after successfully sent
+ if (wasPending) {
+ byteBufMsg.resetReaderIndex();
+ pending.remove();
+ }
+ }
+
+ // Check pending queue and schedule next
+ // At this time we are guaranteed that we are not in pending state anymore
+ // so the next request should succeed
+ writePendingIfAny();
+ }
+ });
+
+ } catch (final WritePendingException e) {
+
+ if (wasPending == false) {
+ queueRequest(ctx, byteBufMsg, promise);
+ }
+ }
+ }
+
+ private void writePendingIfAny() {
+ synchronized (asyncInLock) {
+ if (pending.peek() == null) {
+ return;
+ }
+
+ final PendingWriteRequest pendingWrite = pending.peek();
+ final ByteBuf msg = pendingWrite.msg;
+ if (LOG.isTraceEnabled()) {
+ LOG.trace("Writing pending request on channel: {}, message: {}",
+ pendingWrite.ctx.channel(), byteBufToString(msg));
+ }
+
+ writeWithPendingDetection(pendingWrite.ctx, pendingWrite.promise, msg, true);
+ }
+ }
+
+ public static String byteBufToString(final ByteBuf msg) {
+ final String s = msg.toString(StandardCharsets.UTF_8);
+ msg.resetReaderIndex();
+ return s;
+ }
+
+ private void queueRequest(final ChannelHandlerContext ctx, final ByteBuf msg, final ChannelPromise promise) {
+// try {
+ LOG.debug("Write pending on channel: {}, queueing, current queue size: {}", ctx.channel(), pending.size());
+ if (LOG.isTraceEnabled()) {
+ LOG.trace("Queueing request due to pending: {}", byteBufToString(msg));
+ }
+ new PendingWriteRequest(ctx, msg, promise).pend(pending);
+// } catch (final Exception ex) {
+// LOG.warn("Unable to queue write request on channel: {}. Setting fail for the request: {}",
+// ctx.channel(), ex, byteBufToString(msg));
+// msg.release();
+// promise.setFailure(ex);
+// }
+ }
+
+ @Override
+ public void close() {
+ asyncIn = null;
+ }
+
+ private static Buffer toBuffer(final ByteBuf msg) {
+ // TODO Buffer vs ByteBuf translate, Can we handle that better ?
+ msg.resetReaderIndex();
+ final byte[] temp = new byte[msg.readableBytes()];
+ msg.readBytes(temp, 0, msg.readableBytes());
+ return new Buffer(temp);
+ }
+
+ private static final class PendingWriteRequest {
+ private final ChannelHandlerContext ctx;
+ private final ByteBuf msg;
+ private final ChannelPromise promise;
+
+ PendingWriteRequest(final ChannelHandlerContext ctx, final ByteBuf msg, final ChannelPromise promise) {
+ this.ctx = ctx;
+ // Reset reader index, last write (failed) attempt moved index to the end
+ msg.resetReaderIndex();
+ this.msg = msg;
+ this.promise = promise;
+ }
+
+ public void pend(final Queue<PendingWriteRequest> pending) {
+ // Preconditions.checkState(pending.size() < MAX_PENDING_WRITES,
+ // "Too much pending writes(%s) on channel: %s, remote window is not getting read or is too small",
+ // pending.size(), ctx.channel());
+ Preconditions.checkState(pending.offer(this),
+ "Cannot pend another request write (pending count: %s) on channel: %s", pending.size(), ctx.channel());
+ }
+ }
+}
<module>honeynode-common</module>
<module>honeynode-plugin-api</module>
<module>honeynode-plugin-impl</module>
+ <module>netconf-netty-util</module>
<module>netconf</module>
<module>restconf</module>
<module>honeynode-distribution</module>
-
</modules>
<!-- DO NOT install or deploy the repo root pom as it's only needed to initiate a build -->
--- /dev/null
+module iana-afn-safi {
+ namespace "urn:ietf:params:xml:ns:yang:iana-afn-safi";
+ prefix "ianaaf";
+
+ organization
+ "IANA";
+ contact
+ " Internet Assigned Numbers Authority
+
+ Postal: ICANN
+ 4676 Admiralty Way, Suite 330
+ Marina del Rey, CA 90292
+
+ Tel: +1 310 823 9358
+ E-Mail: iana&iana.org";
+ description
+ "This YANG module provides two typedefs containing YANG
+ definitions for the following IANA-registered enumerations:
+
+ - Address Family Numbers (AFN)
+
+ - Subsequent Address Family Identifiers (SAFI)
+
+ The latest revision of this YANG module can be obtained from the
+ IANA web site.
+
+ Copyright (c) 2012 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 XXXX; see the
+ RFC itself for full legal notices.";
+ // RFC Ed.: replace XXXX with actual RFC number and remove this
+ // note.
+
+ // RFC Ed.: update the date below with the date of RFC publication
+ // and remove this note.
+ revision 2013-07-04 {
+ description
+ "Initial revision.";
+ reference
+ "RFC XXXX: IANA Address Family Numbers and
+ Subsequent Address Family Identifiers YANG Module";
+ }
+
+ typedef address-family {
+ type enumeration {
+ // value 0 is reserved by IANA
+ enum ipV4 {
+ value "1";
+ description
+ "IP version 4";
+ }
+ enum ipV6 {
+ value "2";
+ description
+ "IP version 6";
+ }
+ enum nsap {
+ value "3";
+ description
+ "NSAP";
+ }
+ enum hdlc {
+ value "4";
+ description
+ "HDLC (8-bit multidrop)";
+ }
+ enum bbn1822 {
+ value "5";
+ description
+ "BBN 1822";
+ }
+ enum all802 {
+ value "6";
+ description
+ "802 (includes all 802 media plus Ethernet 'canonical
+ format')";
+ }
+ enum e163 {
+ value "7";
+ description
+ "E.163";
+ }
+ enum e164 {
+ value "8";
+ description
+ "E.164 (SMDS, FrameRelay, ATM)";
+ }
+ enum f69 {
+ value "9";
+ description
+ "F.69 (Telex)";
+ }
+ enum x121 {
+ value "10";
+ description
+ "X.121 (X.25, Frame Relay)";
+ }
+ enum ipx {
+ value "11";
+ description
+ "IPX (Internetwork Packet Exchange)";
+ }
+ enum appletalk {
+ value "12";
+ description
+ "Appletalk";
+ }
+ enum decnetIV {
+ value "13";
+ description
+ "DECnet IV";
+ }
+ enum banyanVines {
+ value "14";
+ description
+ "Banyan Vines";
+ }
+ enum e164withNsap {
+ value "15";
+ description
+ "E.164 with NSAP format subaddress";
+ reference
+ "ATM Forum UNI 3.1";
+ }
+ enum dns {
+ value "16";
+ description
+ "DNS (Domain Name System)";
+ }
+ enum distinguishedName {
+ value "17";
+ description
+ "Distinguished Name (per X.500)";
+ }
+ enum asNumber {
+ value "18";
+ description
+ "Autonomous System Number";
+ }
+ enum xtpOverIpv4 {
+ value "19";
+ description
+ "XTP over IP version 4";
+ }
+ enum xtpOverIpv6 {
+ value "20";
+ description
+ "XTP over IP version 6";
+ }
+ enum xtpNativeModeXTP {
+ value "21";
+ description
+ "XTP native mode XTP";
+ }
+ enum fibreChannelWWPN {
+ value "22";
+ description
+ "Fibre Channel World-Wide Port Name";
+ }
+ enum fibreChannelWWNN {
+ value "23";
+ description
+ "Fibre Channel World-Wide Node Name";
+ }
+ enum gwid {
+ value "24";
+ description
+ "Gateway Identifier";
+ }
+ // FIXME: This one is actually called "afi" in the MIB, but
+ // that must be a mistake.
+ enum l2vpn {
+ value "25";
+ description
+ "AFI for L2VPN information";
+ reference
+ "RFC 4761: Virtual Private LAN Service (VPLS): Using BGP
+ for Auto-Discovery and Signaling
+
+ RFC 6074: Provisioning, Auto-Discovery, and Signaling in
+ Layer 2 Virtual Private Networks (L2VPNs)";
+ }
+ enum mplsTpSectionEndpointIdentifier {
+ value "26";
+ description
+ "MPLS-TP Section Endpoint Identifier";
+ reference
+ "draft-ietf-mpls-gach-adv";
+ }
+ enum mplsTpLspEndpointIdentifier {
+ value "27";
+ description
+ "MPLS-TP LSP Endpoint Identifier";
+ reference
+ "draft-ietf-mpls-gach-adv";
+ }
+ enum mplsTpPseudowireEndpointIdentifier {
+ value "28";
+ description
+ "MPLS-TP Pseudowire Endpoint Identifier";
+ reference
+ "draft-ietf-mpls-gach-adv";
+ }
+ enum eigrpCommonServiceFamily {
+ value "16384";
+ description
+ "EIGRP Common Service Family";
+ }
+ enum eigrpIpv4ServiceFamily {
+ value "16385";
+ description
+ "EIGRP IPv4 Service Family";
+ }
+ enum eigrpIpv6ServiceFamily {
+ value "16386";
+ description
+ "EIGRP IPv6 Service Family";
+ }
+ enum lispCanonicalAddressFormat {
+ value "16387";
+ description
+ "LISP Canonical Address Format (LCAF)";
+ }
+ enum bgpLs {
+ value "16388";
+ description
+ "BGP-LS";
+ reference
+ "draft-ietf-idr-ls-distribution";
+ }
+ enum 48BitMac {
+ value "16389";
+ description
+ "48-bit MAC";
+ reference
+ "draft-eastlake-rfc5342bis";
+ }
+ enum 64BitMac {
+ value "16390";
+ description
+ "64-bit MAC";
+ reference
+ "draft-eastlake-rfc5342bis";
+ }
+ // value 65535 is reserved by IANA
+ }
+ description
+ "This typedef is a YANG enumeration of IANA-registered address
+ family numbers (AFN).";
+ reference
+ "IANA Address Family Numbers registry.
+ <http://www.iana.org/assignments/address-family-numbers>";
+ }
+
+ typedef subsequent-address-family {
+ type enumeration {
+ // value 0 is reserved by IANA
+ enum nlriUnicast {
+ value "1";
+ description
+ "Network Layer Reachability Information used for unicast
+ forwarding";
+ reference
+ "RFC 4760: Multiprotocol Extensions for BGP-4";
+ }
+ enum nlriMulticast {
+ value "2";
+ description
+ "Network Layer Reachability Information used for multicast
+ forwarding";
+ reference
+ "RFC 4760: Multiprotocol Extensions for BGP-4";
+ }
+ // value 3 is reserved by IANA
+ enum nlriMpls {
+ value "4";
+ description
+ "Network Layer Reachability Information (NLRI) with MPLS
+ Labels";
+ reference
+ "RFC 3107: Carrying Label Information in BGP-4";
+ }
+ enum mcastVpn {
+ value "5";
+ description
+ "MCAST-VPN";
+ reference
+ "RFC 6514: BGP Encodings and Procedures for Multicast in
+ MPLS/BGP IP VPNs";
+ }
+ enum nlriDynamicMsPw {
+ value "6";
+ status "obsolete";
+ description
+ "Network Layer Reachability Information used for Dynamic
+ Placement of Multi-Segment Pseudowires (TEMPORARY -
+ Expires 2008-08-23)";
+ reference
+ "draft-ietf-pwe3-dynamic-ms-pw: Dynamic Placement of Multi
+ Segment Pseudowires";
+ }
+ enum encapsulation {
+ value "7";
+ description
+ "Encapsulation SAFI";
+ reference
+ "RFC 5512: The BGP Encapsulation Subsequent Address Family
+ Identifier (SAFI) and the BGP Tunnel Encapsulation
+ Attribute";
+ }
+ enum tunnel {
+ value "64";
+ status "obsolete";
+ description
+ "Tunnel SAFI";
+ reference
+ "draft-nalawade-kapoor-tunnel-safi: BGP Tunnel SAFI";
+ }
+ enum vpls {
+ value "65";
+ description
+ "Virtual Private LAN Service (VPLS)";
+ reference
+ "RFC 4761: Virtual Private LAN Service (VPLS): Using BGP
+ for Auto-Discovery and Signaling
+
+ RFC 6074: Provisioning, Auto-Discovery, and Signaling in
+ Layer 2 Virtual Private Networks (L2VPNs)";
+ }
+ enum bgpMdt {
+ value "66";
+ description
+ "BGP MDT SAFI";
+ reference
+ "RFC 6037: Cisco Systems' Solution for Multicast in
+ BGP/MPLS IP VPNs";
+ }
+ enum bgp4over6 {
+ value "67";
+ description
+ "BGP 4over6 SAFI";
+ reference
+ "RFC 5747: 4over6 Transit Solution Using IP Encapsulation
+ and MP-BGP Extensions";
+ }
+ enum bgp6over4 {
+ value "68";
+ description
+ "BGP 6over4 SAFI";
+ }
+ enum l1VpnAutoDiscovery {
+ value "69";
+ description
+ "Layer-1 VPN auto-discovery information";
+ reference
+ "RFC 5195: BGP-Based Auto-Discovery for Layer-1 VPNs";
+ }
+ enum mplsVpn {
+ value "128";
+ description
+ "MPLS-labeled VPN address";
+ reference
+ "RFC 4364: BGP/MPLS IP Virtual Private Networks (VPNs)";
+ }
+ enum multicastBgpMplsVpn {
+ value "129";
+ description
+ "Multicast for BGP/MPLS IP Virtual Private Networks
+ (VPNs)";
+ reference
+ "RFC 6513: Multicast in MPLS/BGP IP VPNs
+
+ RFC 6514: BGP Encodings and Procedures for Multicast in
+ MPLS/BGP IP VPNs";
+ }
+ // values 130-131 are reserved by IANA
+ enum routeTargetConstraints {
+ value "132";
+ description
+ "Route Target constraints";
+ reference
+ "RFC 4684: Constrained Route Distribution for Border
+ Gateway Protocol/MultiProtocol Label Switching (BGP/MPLS)
+ Internet Protocol (IP) Virtual Private Networks (VPNs)";
+ }
+ enum ipv4DissFlow {
+ value "133";
+ description
+ "IPv4 dissemination of flow specification rules";
+ reference
+ "RFC 5575: Dissemination of Flow Specification Rules";
+ }
+ enum vpnv4DissFlow {
+ value "134";
+ description
+ "VPNv4 dissemination of flow specification rules";
+ reference
+ "RFC 5575: Dissemination of Flow Specification Rules";
+ }
+ // values 135-139 are reserved by IANA
+ enum vpnAutoDiscovery {
+ value "140";
+ status "obsolete";
+ description
+ "VPN auto-discovery";
+ reference
+ "draft-ietf-l3vpn-bgpvpn-auto: Using BGP as an
+ Auto-Discovery Mechanism for VR-based Layer-3 VPNs";
+ }
+ // values 141-240 are reserved by IANA
+ enum private241 {
+ value "241";
+ description
+ "Reserved for Private Use";
+ reference
+ "RFC 4760: Multiprotocol Extensions for BGP-4";
+ }
+ enum private242 {
+ value "242";
+ description
+ "Reserved for Private Use";
+ reference
+ "RFC 4760: Multiprotocol Extensions for BGP-4";
+ }
+ enum private243 {
+ value "243";
+ description
+ "Reserved for Private Use";
+ reference
+ "RFC 4760: Multiprotocol Extensions for BGP-4";
+ }
+ enum private244 {
+ value "244";
+ description
+ "Reserved for Private Use";
+ reference
+ "RFC 4760: Multiprotocol Extensions for BGP-4";
+ }
+ enum private245 {
+ value "245";
+ description
+ "Reserved for Private Use";
+ reference
+ "RFC 4760: Multiprotocol Extensions for BGP-4";
+ }
+ enum private246 {
+ value "246";
+ description
+ "Reserved for Private Use";
+ reference
+ "RFC 4760: Multiprotocol Extensions for BGP-4";
+ }
+ enum private247 {
+ value "247";
+ description
+ "Reserved for Private Use";
+ reference
+ "RFC 4760: Multiprotocol Extensions for BGP-4";
+ }
+ enum private248 {
+ value "248";
+ description
+ "Reserved for Private Use";
+ reference
+ "RFC 4760: Multiprotocol Extensions for BGP-4";
+ }
+ enum private249 {
+ value "249";
+ description
+ "Reserved for Private Use";
+ reference
+ "RFC 4760: Multiprotocol Extensions for BGP-4";
+ }
+ enum private250 {
+ value "250";
+ description
+ "Reserved for Private Use";
+ reference
+ "RFC 4760: Multiprotocol Extensions for BGP-4";
+ }
+ enum private251 {
+ value "251";
+ description
+ "Reserved for Private Use";
+ reference
+ "RFC 4760: Multiprotocol Extensions for BGP-4";
+ }
+ enum private252 {
+ value "252";
+ description
+ "Reserved for Private Use";
+ reference
+ "RFC 4760: Multiprotocol Extensions for BGP-4";
+ }
+ enum private253 {
+ value "253";
+ description
+ "Reserved for Private Use";
+ reference
+ "RFC 4760: Multiprotocol Extensions for BGP-4";
+ }
+ enum private254 {
+ value "254";
+ description
+ "Reserved for Private Use";
+ reference
+ "RFC 4760: Multiprotocol Extensions for BGP-4";
+ }
+ // value 255 is reserved by IANA
+ }
+ description
+ "This typedef is a YANG enumeration of IANA-registered
+ subsequent address family identifiers (SAFI).";
+ reference
+ "IANA SAFI Values registry.
+ <http://www.iana.org/assignments/safi-namespace>";
+ }
+}
--- /dev/null
+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: <http://tools.ietf.org/wg/netmod/>
+ WG List: <mailto:netmod@ietf.org>
+
+ WG Chair: David Kessens
+ <mailto:david.kessens@nsn.com>
+
+ WG Chair: Juergen Schoenwaelder
+ <mailto:j.schoenwaelder@jacobs-university.de>
+
+ Editor: Juergen Schoenwaelder
+ <mailto:j.schoenwaelder@jacobs-university.de>";
+
+ 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 <http://www.iana.org/>.
+
+ 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)";
+ }
+
+}
--- /dev/null
+module ietf-netconf-monitoring-extension {
+
+ yang-version 1;
+
+ namespace
+ "urn:ietf:params:xml:ns:yang:ietf-netconf-monitoring-extension";
+
+ prefix ncme;
+
+ import ietf-netconf-monitoring {
+ prefix ncm;
+ }
+
+ revision "2013-12-10" {
+ description "Initial revision.";
+
+ }
+
+ identity netconf-tcp {
+ base ncm:transport;
+ description
+ "NETCONF over TCP.";
+ }
+
+ augment "/ncm:netconf-state/ncm:sessions/ncm:session" {
+ leaf session-identifier {
+ type string;
+ }
+ }
+
+}
\ No newline at end of file
--- /dev/null
+module ietf-netconf-monitoring {
+
+ yang-version 1;
+
+ namespace
+ "urn:ietf:params:xml:ns:yang:ietf-netconf-monitoring";
+
+ prefix ncm;
+
+ import ietf-yang-types {
+ prefix yang;
+ revision-date "2013-07-15";
+ }
+
+ import ietf-inet-types {
+ prefix inet;
+ revision-date "2013-07-15";
+ }
+
+ organization
+ "IETF NETCONF (Network Configuration) Working Group";
+
+ contact
+ "WG Web: <http://tools.ietf.org/wg/netconf/>
+ WG List: <mailto:netconf@ietf.org>
+
+ WG Chair: Mehmet Ersue
+ <mailto:mehmet.ersue@nsn.com>
+
+ WG Chair: Bert Wijnen
+ <mailto:bertietf@bwijnen.net>
+
+ Editor: Mark Scott
+ <mailto:mark.scott@ericsson.com>
+
+ Editor: Martin Bjorklund
+ <mailto:mbj@tail-f.com>";
+
+ description
+ "NETCONF Monitoring Module.
+ All elements in this module are read-only.
+
+ Copyright (c) 2010 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 6022; see
+ the RFC itself for full legal notices.";
+
+ revision "2010-10-04" {
+ description "Initial revision.";
+ reference
+ "RFC 6022: YANG Module for NETCONF Monitoring";
+
+ }
+
+
+ typedef netconf-datastore-type {
+ type enumeration {
+ enum "running" {
+ value 0;
+ }
+ enum "candidate" {
+ value 1;
+ }
+ enum "startup" {
+ value 2;
+ }
+ }
+ description
+ "Enumeration of possible NETCONF datastore types.";
+ reference
+ "RFC 4741: NETCONF Configuration Protocol";
+
+ }
+
+ identity transport {
+ description
+ "Base identity for NETCONF transport types.";
+ }
+
+ identity netconf-ssh {
+ base transport;
+ description
+ "NETCONF over Secure Shell (SSH).";
+ reference
+ "RFC 4742: Using the NETCONF Configuration Protocol
+ over Secure SHell (SSH)";
+
+ }
+
+ identity netconf-soap-over-beep {
+ base transport;
+ description
+ "NETCONF over Simple Object Access Protocol (SOAP) over
+ Blocks Extensible Exchange Protocol (BEEP).";
+ reference
+ "RFC 4743: Using NETCONF over the Simple Object
+ Access Protocol (SOAP)";
+
+ }
+
+ identity netconf-soap-over-https {
+ base transport;
+ description
+ "NETCONF over Simple Object Access Protocol (SOAP)
+ over Hypertext Transfer Protocol Secure (HTTPS).";
+ reference
+ "RFC 4743: Using NETCONF over the Simple Object
+ Access Protocol (SOAP)";
+
+ }
+
+ identity netconf-beep {
+ base transport;
+ description
+ "NETCONF over Blocks Extensible Exchange Protocol (BEEP).";
+ reference
+ "RFC 4744: Using the NETCONF Protocol over the
+ Blocks Extensible Exchange Protocol (BEEP)";
+
+ }
+
+ identity netconf-tls {
+ base transport;
+ description
+ "NETCONF over Transport Layer Security (TLS).";
+ reference
+ "RFC 5539: NETCONF over Transport Layer Security (TLS)";
+
+ }
+
+ identity schema-format {
+ description
+ "Base identity for data model schema languages.";
+ }
+
+ identity xsd {
+ base schema-format;
+ description
+ "W3C XML Schema Definition.";
+ reference
+ "W3C REC REC-xmlschema-1-20041028:
+ XML Schema Part 1: Structures";
+
+ }
+
+ identity yang {
+ base schema-format;
+ description
+ "The YANG data modeling language for NETCONF.";
+ reference
+ "RFC 6020: YANG - A Data Modeling Language for the
+ Network Configuration Protocol (NETCONF)";
+
+ }
+
+ identity yin {
+ base schema-format;
+ description "The YIN syntax for YANG.";
+ reference
+ "RFC 6020: YANG - A Data Modeling Language for the
+ Network Configuration Protocol (NETCONF)";
+
+ }
+
+ identity rng {
+ base schema-format;
+ description
+ "Regular Language for XML Next Generation (RELAX NG).";
+ reference
+ "ISO/IEC 19757-2:2008: RELAX NG";
+
+ }
+
+ identity rnc {
+ base schema-format;
+ description "Relax NG Compact Syntax";
+ reference
+ "ISO/IEC 19757-2:2008: RELAX NG";
+
+ }
+
+ grouping common-counters {
+ description
+ "Counters that exist both per session, and also globally,
+ accumulated from all sessions.";
+ leaf in-rpcs {
+ type yang:zero-based-counter32;
+ description
+ "Number of correct <rpc> messages received.";
+ }
+
+ leaf in-bad-rpcs {
+ type yang:zero-based-counter32;
+ description
+ "Number of messages received when an <rpc> message was expected,
+ that were not correct <rpc> messages. This includes XML parse
+ errors and errors on the rpc layer.";
+ }
+
+ leaf out-rpc-errors {
+ type yang:zero-based-counter32;
+ description
+ "Number of <rpc-reply> messages sent that contained an
+ <rpc-error> element.";
+ }
+
+ leaf out-notifications {
+ type yang:zero-based-counter32;
+ description
+ "Number of <notification> messages sent.";
+ }
+ } // grouping common-counters
+
+ container netconf-state {
+ config false;
+ description
+ "The netconf-state container is the root of the monitoring
+ data model.";
+ container capabilities {
+ description
+ "Contains the list of NETCONF capabilities supported by the
+ server.";
+ leaf-list capability {
+ type inet:uri;
+ description
+ "List of NETCONF capabilities supported by the server.";
+ }
+ } // container capabilities
+
+ container datastores {
+ description
+ "Contains the list of NETCONF configuration datastores.";
+ list datastore {
+ key "name";
+ description
+ "List of NETCONF configuration datastores supported by
+ the NETCONF server and related information.";
+ leaf name {
+ type netconf-datastore-type;
+ description
+ "Name of the datastore associated with this list entry.";
+ }
+
+ container locks {
+ presence
+ "This container is present only if the datastore
+ is locked.";
+ description
+ "The NETCONF <lock> and <partial-lock> operations allow
+ a client to lock specific resources in a datastore. The
+ NETCONF server will prevent changes to the locked
+ resources by all sessions except the one that acquired
+ the lock(s).
+
+ Monitoring information is provided for each datastore
+ entry including details such as the session that acquired
+ the lock, the type of lock (global or partial) and the
+ list of locked resources. Multiple locks per datastore
+ are supported.";
+ grouping lock-info {
+ description
+ "Lock related parameters, common to both global and
+ partial locks.";
+ leaf locked-by-session {
+ type uint32;
+ mandatory true;
+ description
+ "The session ID of the session that has locked
+ this resource. Both a global lock and a partial
+ lock MUST contain the NETCONF session-id.
+
+ If the lock is held by a session that is not managed
+ by the NETCONF server (e.g., a CLI session), a session
+ id of 0 (zero) is reported.";
+ reference
+ "RFC 4741: NETCONF Configuration Protocol";
+
+ }
+
+ leaf locked-time {
+ type yang:date-and-time;
+ mandatory true;
+ description
+ "The date and time of when the resource was
+ locked.";
+ }
+ } // grouping lock-info
+ choice lock-type {
+ description
+ "Indicates if a global lock or a set of partial locks
+ are set.";
+ container global-lock {
+ description
+ "Present if the global lock is set.";
+ uses lock-info;
+ } // container global-lock
+ list partial-lock {
+ key "lock-id";
+ description
+ "List of partial locks.";
+ reference
+ "RFC 5717: Partial Lock Remote Procedure Call (RPC) for
+ NETCONF";
+
+ leaf lock-id {
+ type uint32;
+ description
+ "This is the lock id returned in the <partial-lock>
+ response.";
+ }
+
+ uses lock-info;
+
+ leaf-list select {
+ type yang:xpath1.0;
+ min-elements 1;
+ description
+ "The xpath expression that was used to request
+ the lock. The select expression indicates the
+ original intended scope of the lock.";
+ }
+
+ leaf-list locked-node {
+ type instance-identifier;
+ description
+ "The list of instance-identifiers (i.e., the
+ locked nodes).
+
+ The scope of the partial lock is defined by the list
+ of locked nodes.";
+ }
+ } // list partial-lock
+ } // choice lock-type
+ } // container locks
+ } // list datastore
+ } // container datastores
+
+ container schemas {
+ description
+ "Contains the list of data model schemas supported by the
+ server.";
+ list schema {
+ key "identifier version format";
+ description
+ "List of data model schemas supported by the server.";
+ leaf identifier {
+ type string;
+ description
+ "Identifier to uniquely reference the schema. The
+ identifier is used in the <get-schema> operation and may
+ be used for other purposes such as file retrieval.
+
+ For modeling languages that support or require a data
+ model name (e.g., YANG module name) the identifier MUST
+ match that name. For YANG data models, the identifier is
+ the name of the module or submodule. In other cases, an
+ identifier such as a filename MAY be used instead.";
+ }
+
+ leaf version {
+ type string;
+ description
+ "Version of the schema supported. Multiple versions MAY be
+ supported simultaneously by a NETCONF server. Each
+ version MUST be reported individually in the schema list,
+ i.e., with same identifier, possibly different location,
+ but different version.
+
+ For YANG data models, version is the value of the most
+ recent YANG 'revision' statement in the module or
+ submodule, or the empty string if no 'revision' statement
+ is present.";
+ }
+
+ leaf format {
+ type identityref {
+ base schema-format;
+ }
+ description
+ "The data modeling language the schema is written
+ in (currently xsd, yang, yin, rng, or rnc).
+ For YANG data models, 'yang' format MUST be supported and
+ 'yin' format MAY also be provided.";
+ }
+
+ leaf namespace {
+ type inet:uri;
+ mandatory true;
+ description
+ "The XML namespace defined by the data model.
+
+ For YANG data models, this is the module's namespace.
+ If the list entry describes a submodule, this field
+ contains the namespace of the module to which the
+ submodule belongs.";
+ }
+
+ leaf-list location {
+ type union {
+ type enumeration {
+ enum "NETCONF" {
+ value 0;
+ }
+ }
+ type inet:uri;
+ }
+ description
+ "One or more locations from which the schema can be
+ retrieved. This list SHOULD contain at least one
+ entry per schema.
+
+ A schema entry may be located on a remote file system
+ (e.g., reference to file system for ftp retrieval) or
+ retrieved directly from a server supporting the
+ <get-schema> operation (denoted by the value 'NETCONF').";
+ }
+ } // list schema
+ } // container schemas
+
+ container sessions {
+ description
+ "The sessions container includes session-specific data for
+ NETCONF management sessions. The session list MUST include
+ all currently active NETCONF sessions.";
+ list session {
+ key "session-id";
+ description
+ "All NETCONF sessions managed by the NETCONF server
+ MUST be reported in this list.";
+ leaf session-id {
+ type uint32 {
+ range "1..max";
+ }
+ description
+ "Unique identifier for the session. This value is the
+ NETCONF session identifier, as defined in RFC 4741.";
+ reference
+ "RFC 4741: NETCONF Configuration Protocol";
+
+ }
+
+ leaf transport {
+ type identityref {
+ base transport;
+ }
+ mandatory true;
+ description
+ "Identifies the transport for each session, e.g.,
+ 'netconf-ssh', 'netconf-soap', etc.";
+ }
+
+ leaf username {
+ type string;
+ mandatory true;
+ description
+ "The username is the client identity that was authenticated
+ by the NETCONF transport protocol. The algorithm used to
+ derive the username is NETCONF transport protocol specific
+ and in addition specific to the authentication mechanism
+ used by the NETCONF transport protocol.";
+ }
+
+ leaf source-host {
+ type inet:host;
+ description
+ "Host identifier of the NETCONF client. The value
+ returned is implementation specific (e.g., hostname,
+ IPv4 address, IPv6 address)";
+ }
+
+ leaf login-time {
+ type yang:date-and-time;
+ mandatory true;
+ description
+ "Time at the server at which the session was established.";
+ }
+
+ uses common-counters {
+ description
+ "Per-session counters. Zero based with following reset
+ behaviour:
+ - at start of a session
+ - when max value is reached";
+ }
+ } // list session
+ } // container sessions
+
+ container statistics {
+ description
+ "Statistical data pertaining to the NETCONF server.";
+ leaf netconf-start-time {
+ type yang:date-and-time;
+ description
+ "Date and time at which the management subsystem was
+ started.";
+ }
+
+ leaf in-bad-hellos {
+ type yang:zero-based-counter32;
+ description
+ "Number of sessions silently dropped because an
+ invalid <hello> message was received. This includes <hello>
+ messages with a 'session-id' attribute, bad namespace, and
+ bad capability declarations.";
+ }
+
+ leaf in-sessions {
+ type yang:zero-based-counter32;
+ description
+ "Number of sessions started. This counter is incremented
+ when a <hello> message with a <session-id> is sent.
+
+ 'in-sessions' - 'in-bad-hellos' =
+ 'number of correctly started netconf sessions'";
+ }
+
+ leaf dropped-sessions {
+ type yang:zero-based-counter32;
+ description
+ "Number of sessions that were abnormally terminated, e.g.,
+ due to idle timeout or transport close. This counter is not
+ incremented when a session is properly closed by a
+ <close-session> operation, or killed by a <kill-session>
+ operation.";
+ }
+
+ uses common-counters {
+ description
+ "Global counters, accumulated from all sessions.
+ Zero based with following reset behaviour:
+ - re-initialization of NETCONF server
+ - when max value is reached";
+ }
+ } // container statistics
+ } // container netconf-state
+
+ rpc get-schema {
+ description
+ "This operation is used to retrieve a schema from the
+ NETCONF server.
+
+ Positive Response:
+ The NETCONF server returns the requested schema.
+
+ Negative Response:
+ If requested schema does not exist, the <error-tag> is
+ 'invalid-value'.
+
+ If more than one schema matches the requested parameters, the
+ <error-tag> is 'operation-failed', and <error-app-tag> is
+ 'data-not-unique'.";
+ input {
+ leaf identifier {
+ type string;
+ mandatory true;
+ description
+ "Identifier for the schema list entry.";
+ }
+
+ leaf version {
+ type string;
+ description
+ "Version of the schema requested. If this parameter is not
+ present, and more than one version of the schema exists on
+ the server, a 'data-not-unique' error is returned, as
+ described above.";
+ }
+
+ leaf format {
+ type identityref {
+ base schema-format;
+ }
+ description
+ "The data modeling language of the schema. If this
+ parameter is not present, and more than one formats of
+ the schema exists on the server, a 'data-not-unique' error
+ is returned, as described above.";
+ }
+ }
+
+ output {
+ anyxml data {
+ description
+ "Contains the schema content.";
+ }
+ }
+ } // rpc get-schema
+} // module
--- /dev/null
+module ietf-netconf-notifications {
+
+ namespace
+ "urn:ietf:params:xml:ns:yang:ietf-netconf-notifications";
+
+ prefix ncn;
+
+ import ietf-inet-types { prefix inet; revision-date "2013-07-15";}
+ import ietf-netconf { prefix nc; revision-date "2011-06-01";}
+
+ organization
+ "IETF NETCONF (Network Configuration Protocol) Working Group";
+
+ contact
+ "WG Web: <http://tools.ietf.org/wg/netconf/>
+ WG List: <mailto:netconf@ietf.org>
+
+ WG Chair: Bert Wijnen
+ <mailto:bertietf@bwijnen.net>
+
+ WG Chair: Mehmet Ersue
+ <mailto:mehmet.ersue@nsn.com>
+
+ Editor: Andy Bierman
+ <mailto:andy@netconfcentral.org>";
+
+ description
+ "This module defines a YANG data model for use with the
+ NETCONF protocol that allows the NETCONF client to
+ receive common NETCONF base event notifications.
+
+ Copyright (c) 2012 IETF Trust and the persons identified as
+ the document authors. 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 6470; see
+ the RFC itself for full legal notices.";
+
+ revision "2012-02-06" {
+ description
+ "Initial version. Errata 3957 added.";
+ reference
+ "RFC 6470: NETCONF Base Notifications";
+ }
+
+ grouping common-session-parms {
+ description
+ "Common session parameters to identify a
+ management session.";
+
+ leaf username {
+ type string;
+ mandatory true;
+ description
+ "Name of the user for the session.";
+ }
+
+ leaf session-id {
+ type nc:session-id-or-zero-type;
+ mandatory true;
+ description
+ "Identifier of the session.
+ A NETCONF session MUST be identified by a non-zero value.
+ A non-NETCONF session MAY be identified by the value zero.";
+ }
+
+ leaf source-host {
+ type inet:ip-address;
+ description
+ "Address of the remote host for the session.";
+ }
+ }
+
+
+
+
+
+
+
+
+ grouping changed-by-parms {
+ description
+ "Common parameters to identify the source
+ of a change event, such as a configuration
+ or capability change.";
+
+ container changed-by {
+ description
+ "Indicates the source of the change.
+ If caused by internal action, then the
+ empty leaf 'server' will be present.
+ If caused by a management session, then
+ the name, remote host address, and session ID
+ of the session that made the change will be reported.";
+ choice server-or-user {
+ mandatory true;
+ leaf server {
+ type empty;
+ description
+ "If present, the change was caused
+ by the server.";
+ }
+
+ case by-user {
+ uses common-session-parms;
+ }
+ } // choice server-or-user
+ } // container changed-by-parms
+ }
+
+
+ notification netconf-config-change {
+ description
+ "Generated when the NETCONF server detects that the
+ <running> or <startup> configuration datastore
+ has been changed by a management session.
+ The notification summarizes the edits that
+ have been detected.
+
+ The server MAY choose to also generate this
+ notification while loading a datastore during the
+ boot process for the device.";
+
+ uses changed-by-parms;
+
+
+
+
+
+ leaf datastore {
+ type enumeration {
+ enum running {
+ description "The <running> datastore has changed.";
+ }
+ enum startup {
+ description "The <startup> datastore has changed";
+ }
+ }
+ default "running";
+ description
+ "Indicates which configuration datastore has changed.";
+ }
+
+ list edit {
+ description
+ "An edit record SHOULD be present for each distinct
+ edit operation that the server has detected on
+ the target datastore. This list MAY be omitted
+ if the detailed edit operations are not known.
+ The server MAY report entries in this list for
+ changes not made by a NETCONF session (e.g., CLI).";
+
+ leaf target {
+ type instance-identifier;
+ description
+ "Topmost node associated with the configuration change.
+ A server SHOULD set this object to the node within
+ the datastore that is being altered. A server MAY
+ set this object to one of the ancestors of the actual
+ node that was changed, or omit this object, if the
+ exact node is not known.";
+ }
+
+ leaf operation {
+ type nc:edit-operation-type;
+ description
+ "Type of edit operation performed.
+ A server MUST set this object to the NETCONF edit
+ operation performed on the target datastore.";
+ }
+ } // list edit
+ } // notification netconf-config-change
+
+
+
+
+
+
+ notification netconf-capability-change {
+ description
+ "Generated when the NETCONF server detects that
+ the server capabilities have changed.
+ Indicates which capabilities have been added, deleted,
+ and/or modified. The manner in which a server
+ capability is changed is outside the scope of this
+ document.";
+
+ uses changed-by-parms;
+
+ leaf-list added-capability {
+ type inet:uri;
+ description
+ "List of capabilities that have just been added.";
+ }
+
+ leaf-list deleted-capability {
+ type inet:uri;
+ description
+ "List of capabilities that have just been deleted.";
+ }
+
+ leaf-list modified-capability {
+ type inet:uri;
+ description
+ "List of capabilities that have just been modified.
+ A capability is considered to be modified if the
+ base URI for the capability has not changed, but
+ one or more of the parameters encoded at the end of
+ the capability URI have changed.
+ The new modified value of the complete URI is returned.";
+ }
+ } // notification netconf-capability-change
+
+
+ notification netconf-session-start {
+ description
+ "Generated when a NETCONF server detects that a
+ NETCONF session has started. A server MAY generate
+ this event for non-NETCONF management sessions.
+ Indicates the identity of the user that started
+ the session.";
+ uses common-session-parms;
+ } // notification netconf-session-start
+
+
+
+
+ notification netconf-session-end {
+ description
+ "Generated when a NETCONF server detects that a
+ NETCONF session has terminated.
+ A server MAY optionally generate this event for
+ non-NETCONF management sessions. Indicates the
+ identity of the user that owned the session,
+ and why the session was terminated.";
+
+ uses common-session-parms;
+
+ leaf killed-by {
+ when "../termination-reason = 'killed'";
+ type nc:session-id-type;
+ description
+ "The ID of the session that directly caused this session
+ to be abnormally terminated. If this session was abnormally
+ terminated by a non-NETCONF session unknown to the server,
+ then this leaf will not be present.";
+ }
+
+ leaf termination-reason {
+ type enumeration {
+ enum "closed" {
+ description
+ "The session was terminated by the client in normal
+ fashion, e.g., by the NETCONF <close-session>
+ protocol operation.";
+ }
+ enum "killed" {
+ description
+ "The session was terminated in abnormal
+ fashion, e.g., by the NETCONF <kill-session>
+ protocol operation.";
+ }
+ enum "dropped" {
+ description
+ "The session was terminated because the transport layer
+ connection was unexpectedly closed.";
+ }
+ enum "timeout" {
+ description
+ "The session was terminated because of inactivity,
+ e.g., waiting for the <hello> message or <rpc>
+ messages.";
+ }
+
+
+
+ enum "bad-hello" {
+ description
+ "The client's <hello> message was invalid.";
+ }
+ enum "other" {
+ description
+ "The session was terminated for some other reason.";
+ }
+ }
+ mandatory true;
+ description
+ "Reason the session was terminated.";
+ }
+ } // notification netconf-session-end
+
+
+ notification netconf-confirmed-commit {
+ description
+ "Generated when a NETCONF server detects that a
+ confirmed-commit event has occurred. Indicates the event
+ and the current state of the confirmed-commit procedure
+ in progress.";
+ reference
+ "RFC 6241, Section 8.4";
+
+ uses common-session-parms {
+ when "confirm-event != 'timeout'";
+ }
+
+ leaf confirm-event {
+ type enumeration {
+ enum "start" {
+ description
+ "The confirmed-commit procedure has started.";
+ }
+ enum "cancel" {
+ description
+ "The confirmed-commit procedure has been canceled,
+ e.g., due to the session being terminated, or an
+ explicit <cancel-commit> operation.";
+ }
+ enum "timeout" {
+ description
+ "The confirmed-commit procedure has been canceled
+ due to the confirm-timeout interval expiring.
+ The common session parameters will not be present
+ in this sub-mode.";
+ }
+
+ enum "extend" {
+ description
+ "The confirmed-commit timeout has been extended,
+ e.g., by a new <confirmed-commit> operation.";
+ }
+ enum "complete" {
+ description
+ "The confirmed-commit procedure has been completed.";
+ }
+ }
+ mandatory true;
+ description
+ "Indicates the event that caused the notification.";
+ }
+
+ leaf timeout {
+ when
+ "../confirm-event = 'start' or ../confirm-event = 'extend'";
+ type uint32;
+ units "seconds";
+ description
+ "The configured timeout value if the event type
+ is 'start' or 'extend'. This value represents
+ the approximate number of seconds from the event
+ time when the 'timeout' event might occur.";
+ }
+ } // notification netconf-confirmed-commit
+
+}
--- /dev/null
+module ietf-netconf {
+
+ // the namespace for NETCONF XML definitions is unchanged
+ // from RFC 4741, which this document replaces
+ namespace "urn:ietf:params:xml:ns:netconf:base:1.0";
+
+ prefix nc;
+
+ import ietf-inet-types {
+ prefix inet;
+ }
+
+ organization
+ "IETF NETCONF (Network Configuration) Working Group";
+
+ contact
+ "WG Web: <http://tools.ietf.org/wg/netconf/>
+ WG List: <netconf@ietf.org>
+
+ WG Chair: Bert Wijnen
+ <bertietf@bwijnen.net>
+
+ WG Chair: Mehmet Ersue
+ <mehmet.ersue@nsn.com>
+
+ Editor: Martin Bjorklund
+ <mbj@tail-f.com>
+
+ Editor: Juergen Schoenwaelder
+ <j.schoenwaelder@jacobs-university.de>
+
+ Editor: Andy Bierman
+ <andy.bierman@brocade.com>";
+ description
+ "NETCONF Protocol Data Types and Protocol Operations.
+
+ Copyright (c) 2011 IETF Trust and the persons identified as
+ the document authors. 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 6241; see
+ the RFC itself for full legal notices.";
+
+ revision 2011-06-01 {
+ description
+ "Initial revision;";
+ reference
+ "RFC 6241: Network Configuration Protocol";
+ }
+
+ extension get-filter-element-attributes {
+ description
+ "If this extension is present within an 'anyxml'
+ statement named 'filter', which must be conceptually
+ defined within the RPC input section for the <get>
+ and <get-config> protocol operations, then the
+ following unqualified XML attribute is supported
+ within the <filter> element, within a <get> or
+ <get-config> protocol operation:
+
+ type : optional attribute with allowed
+ value strings 'subtree' and 'xpath'.
+ If missing, the default value is 'subtree'.
+
+ If the 'xpath' feature is supported, then the
+ following unqualified XML attribute is
+ also supported:
+
+ select: optional attribute containing a
+ string representing an XPath expression.
+ The 'type' attribute must be equal to 'xpath'
+ if this attribute is present.";
+ }
+
+ // NETCONF capabilities defined as features
+ feature writable-running {
+ description
+ "NETCONF :writable-running capability;
+ If the server advertises the :writable-running
+ capability for a session, then this feature must
+ also be enabled for that session. Otherwise,
+ this feature must not be enabled.";
+ reference "RFC 6241, Section 8.2";
+ }
+
+ feature candidate {
+ description
+ "NETCONF :candidate capability;
+ If the server advertises the :candidate
+ capability for a session, then this feature must
+ also be enabled for that session. Otherwise,
+ this feature must not be enabled.";
+ reference "RFC 6241, Section 8.3";
+ }
+
+ feature confirmed-commit {
+ if-feature candidate;
+ description
+ "NETCONF :confirmed-commit:1.1 capability;
+ If the server advertises the :confirmed-commit:1.1
+ capability for a session, then this feature must
+ also be enabled for that session. Otherwise,
+ this feature must not be enabled.";
+
+ reference "RFC 6241, Section 8.4";
+ }
+
+ feature rollback-on-error {
+ description
+ "NETCONF :rollback-on-error capability;
+ If the server advertises the :rollback-on-error
+ capability for a session, then this feature must
+ also be enabled for that session. Otherwise,
+ this feature must not be enabled.";
+ reference "RFC 6241, Section 8.5";
+ }
+
+ feature validate {
+ description
+ "NETCONF :validate:1.1 capability;
+ If the server advertises the :validate:1.1
+ capability for a session, then this feature must
+ also be enabled for that session. Otherwise,
+ this feature must not be enabled.";
+ reference "RFC 6241, Section 8.6";
+ }
+
+ feature startup {
+ description
+ "NETCONF :startup capability;
+ If the server advertises the :startup
+ capability for a session, then this feature must
+ also be enabled for that session. Otherwise,
+ this feature must not be enabled.";
+ reference "RFC 6241, Section 8.7";
+ }
+
+ feature url {
+ description
+ "NETCONF :url capability;
+ If the server advertises the :url
+ capability for a session, then this feature must
+ also be enabled for that session. Otherwise,
+ this feature must not be enabled.";
+ reference "RFC 6241, Section 8.8";
+ }
+
+ feature xpath {
+ description
+ "NETCONF :xpath capability;
+ If the server advertises the :xpath
+ capability for a session, then this feature must
+ also be enabled for that session. Otherwise,
+ this feature must not be enabled.";
+ reference "RFC 6241, Section 8.9";
+ }
+
+ // NETCONF Simple Types
+
+ typedef session-id-type {
+ type uint32 {
+ range "1..max";
+ }
+ description
+ "NETCONF Session Id";
+ }
+
+ typedef session-id-or-zero-type {
+ type uint32;
+ description
+ "NETCONF Session Id or Zero to indicate none";
+ }
+ typedef error-tag-type {
+ type enumeration {
+ enum in-use {
+ description
+ "The request requires a resource that
+ already is in use.";
+ }
+ enum invalid-value {
+ description
+ "The request specifies an unacceptable value for one
+ or more parameters.";
+ }
+ enum too-big {
+ description
+ "The request or response (that would be generated) is
+ too large for the implementation to handle.";
+ }
+ enum missing-attribute {
+ description
+ "An expected attribute is missing.";
+ }
+ enum bad-attribute {
+ description
+ "An attribute value is not correct; e.g., wrong type,
+ out of range, pattern mismatch.";
+ }
+ enum unknown-attribute {
+ description
+ "An unexpected attribute is present.";
+ }
+ enum missing-element {
+ description
+ "An expected element is missing.";
+ }
+ enum bad-element {
+ description
+ "An element value is not correct; e.g., wrong type,
+ out of range, pattern mismatch.";
+ }
+ enum unknown-element {
+ description
+ "An unexpected element is present.";
+ }
+ enum unknown-namespace {
+ description
+ "An unexpected namespace is present.";
+ }
+ enum access-denied {
+ description
+ "Access to the requested protocol operation or
+ data model is denied because authorization failed.";
+ }
+ enum lock-denied {
+ description
+ "Access to the requested lock is denied because the
+ lock is currently held by another entity.";
+ }
+ enum resource-denied {
+ description
+ "Request could not be completed because of
+ insufficient resources.";
+ }
+ enum rollback-failed {
+ description
+ "Request to roll back some configuration change (via
+ rollback-on-error or <discard-changes> operations)
+ was not completed for some reason.";
+
+ }
+ enum data-exists {
+ description
+ "Request could not be completed because the relevant
+ data model content already exists. For example,
+ a 'create' operation was attempted on data that
+ already exists.";
+ }
+ enum data-missing {
+ description
+ "Request could not be completed because the relevant
+ data model content does not exist. For example,
+ a 'delete' operation was attempted on
+ data that does not exist.";
+ }
+ enum operation-not-supported {
+ description
+ "Request could not be completed because the requested
+ operation is not supported by this implementation.";
+ }
+ enum operation-failed {
+ description
+ "Request could not be completed because the requested
+ operation failed for some reason not covered by
+ any other error condition.";
+ }
+ enum partial-operation {
+ description
+ "This error-tag is obsolete, and SHOULD NOT be sent
+ by servers conforming to this document.";
+ }
+ enum malformed-message {
+ description
+ "A message could not be handled because it failed to
+ be parsed correctly. For example, the message is not
+ well-formed XML or it uses an invalid character set.";
+ }
+ }
+ description "NETCONF Error Tag";
+ reference "RFC 6241, Appendix A";
+ }
+
+ typedef error-severity-type {
+ type enumeration {
+ enum error {
+ description "Error severity";
+ }
+ enum warning {
+ description "Warning severity";
+ }
+ }
+ description "NETCONF Error Severity";
+ reference "RFC 6241, Section 4.3";
+ }
+
+ typedef edit-operation-type {
+ type enumeration {
+ enum merge {
+ description
+ "The configuration data identified by the
+ element containing this attribute is merged
+ with the configuration at the corresponding
+ level in the configuration datastore identified
+ by the target parameter.";
+ }
+ enum replace {
+ description
+ "The configuration data identified by the element
+ containing this attribute replaces any related
+ configuration in the configuration datastore
+ identified by the target parameter. If no such
+ configuration data exists in the configuration
+ datastore, it is created. Unlike a
+ <copy-config> operation, which replaces the
+ entire target configuration, only the configuration
+ actually present in the config parameter is affected.";
+ }
+ enum create {
+ description
+ "The configuration data identified by the element
+ containing this attribute is added to the
+ configuration if and only if the configuration
+ data does not already exist in the configuration
+ datastore. If the configuration data exists, an
+ <rpc-error> element is returned with an
+ <error-tag> value of 'data-exists'.";
+ }
+ enum delete {
+ description
+ "The configuration data identified by the element
+ containing this attribute is deleted from the
+ configuration if and only if the configuration
+ data currently exists in the configuration
+ datastore. If the configuration data does not
+ exist, an <rpc-error> element is returned with
+ an <error-tag> value of 'data-missing'.";
+ }
+ enum remove {
+ description
+ "The configuration data identified by the element
+ containing this attribute is deleted from the
+ configuration if the configuration
+ data currently exists in the configuration
+ datastore. If the configuration data does not
+ exist, the 'remove' operation is silently ignored
+ by the server.";
+ }
+ }
+ default "merge";
+ description "NETCONF 'operation' attribute values";
+ reference "RFC 6241, Section 7.2";
+ }
+
+ // NETCONF Standard Protocol Operations
+
+ rpc get-config {
+ description
+ "Retrieve all or part of a specified configuration.";
+
+ reference "RFC 6241, Section 7.1";
+
+ input {
+ container source {
+ description
+ "Particular configuration to retrieve.";
+
+ choice config-source {
+ mandatory true;
+ description
+ "The configuration to retrieve.";
+ leaf candidate {
+ if-feature candidate;
+ type empty;
+ description
+ "The candidate configuration is the config source.";
+ }
+ leaf running {
+ type empty;
+ description
+ "The running configuration is the config source.";
+ }
+ leaf startup {
+ if-feature startup;
+ type empty;
+ description
+ "The startup configuration is the config source.
+ This is optional-to-implement on the server because
+ not all servers will support filtering for this
+ datastore.";
+ }
+ }
+ }
+
+ anyxml filter {
+ description
+ "Subtree or XPath filter to use.";
+ nc:get-filter-element-attributes;
+ }
+ }
+
+ output {
+ anyxml data {
+ description
+ "Copy of the source datastore subset that matched
+ the filter criteria (if any). An empty data container
+ indicates that the request did not produce any results.";
+ }
+ }
+ }
+
+ rpc edit-config {
+ description
+ "The <edit-config> operation loads all or part of a specified
+ configuration to the specified target configuration.";
+
+ reference "RFC 6241, Section 7.2";
+
+ input {
+ container target {
+ description
+ "Particular configuration to edit.";
+
+ choice config-target {
+ mandatory true;
+ description
+ "The configuration target.";
+
+ leaf candidate {
+ if-feature candidate;
+ type empty;
+ description
+ "The candidate configuration is the config target.";
+ }
+ leaf running {
+ if-feature writable-running;
+ type empty;
+ description
+ "The running configuration is the config source.";
+ }
+ }
+ }
+
+ leaf default-operation {
+ type enumeration {
+ enum merge {
+ description
+ "The default operation is merge.";
+ }
+ enum replace {
+ description
+ "The default operation is replace.";
+ }
+ enum none {
+ description
+ "There is no default operation.";
+ }
+ }
+ default "merge";
+ description
+ "The default operation to use.";
+ }
+
+ leaf test-option {
+ if-feature validate;
+ type enumeration {
+ enum test-then-set {
+ description
+ "The server will test and then set if no errors.";
+ }
+ enum set {
+ description
+ "The server will set without a test first.";
+ }
+
+ enum test-only {
+ description
+ "The server will only test and not set, even
+ if there are no errors.";
+ }
+ }
+ default "test-then-set";
+ description
+ "The test option to use.";
+ }
+
+ leaf error-option {
+ type enumeration {
+ enum stop-on-error {
+ description
+ "The server will stop on errors.";
+ }
+ enum continue-on-error {
+ description
+ "The server may continue on errors.";
+ }
+ enum rollback-on-error {
+ description
+ "The server will roll back on errors.
+ This value can only be used if the 'rollback-on-error'
+ feature is supported.";
+ }
+ }
+ default "stop-on-error";
+ description
+ "The error option to use.";
+ }
+
+ choice edit-content {
+ mandatory true;
+ description
+ "The content for the edit operation.";
+
+ anyxml config {
+ description
+ "Inline Config content.";
+ }
+ leaf url {
+ if-feature url;
+ type inet:uri;
+ description
+ "URL-based config content.";
+ }
+ }
+ }
+ }
+
+ rpc copy-config {
+ description
+ "Create or replace an entire configuration datastore with the
+ contents of another complete configuration datastore.";
+
+ reference "RFC 6241, Section 7.3";
+
+ input {
+ container target {
+ description
+ "Particular configuration to copy to.";
+
+ choice config-target {
+ mandatory true;
+ description
+ "The configuration target of the copy operation.";
+
+ leaf candidate {
+ if-feature candidate;
+ type empty;
+ description
+ "The candidate configuration is the config target.";
+ }
+ leaf running {
+ if-feature writable-running;
+ type empty;
+ description
+ "The running configuration is the config target.
+ This is optional-to-implement on the server.";
+ }
+ leaf startup {
+ if-feature startup;
+ type empty;
+ description
+ "The startup configuration is the config target.";
+ }
+ leaf url {
+ if-feature url;
+ type inet:uri;
+ description
+ "The URL-based configuration is the config target.";
+ }
+ }
+ }
+
+ container source {
+ description
+ "Particular configuration to copy from.";
+
+ choice config-source {
+ mandatory true;
+ description
+ "The configuration source for the copy operation.";
+
+ leaf candidate {
+ if-feature candidate;
+ type empty;
+ description
+ "The candidate configuration is the config source.";
+ }
+ leaf running {
+ type empty;
+ description
+ "The running configuration is the config source.";
+ }
+ leaf startup {
+ if-feature startup;
+ type empty;
+ description
+ "The startup configuration is the config source.";
+ }
+ leaf url {
+ if-feature url;
+ type inet:uri;
+ description
+ "The URL-based configuration is the config source.";
+ }
+ anyxml config {
+ description
+ "Inline Config content: <config> element. Represents
+ an entire configuration datastore, not
+ a subset of the running datastore.";
+ }
+ }
+ }
+ }
+ }
+
+ rpc delete-config {
+ description
+ "Delete a configuration datastore.";
+
+ reference "RFC 6241, Section 7.4";
+
+ input {
+ container target {
+ description
+ "Particular configuration to delete.";
+
+ choice config-target {
+ mandatory true;
+ description
+ "The configuration target to delete.";
+
+ leaf startup {
+ if-feature startup;
+ type empty;
+ description
+ "The startup configuration is the config target.";
+ }
+ leaf url {
+ if-feature url;
+ type inet:uri;
+ description
+ "The URL-based configuration is the config target.";
+ }
+ }
+ }
+ }
+ }
+
+ rpc lock {
+ description
+ "The lock operation allows the client to lock the configuration
+ system of a device.";
+
+ reference "RFC 6241, Section 7.5";
+
+ input {
+ container target {
+ description
+ "Particular configuration to lock.";
+
+ choice config-target {
+ mandatory true;
+ description
+ "The configuration target to lock.";
+
+ leaf candidate {
+ if-feature candidate;
+ type empty;
+ description
+ "The candidate configuration is the config target.";
+ }
+ leaf running {
+ type empty;
+ description
+ "The running configuration is the config target.";
+ }
+ leaf startup {
+ if-feature startup;
+ type empty;
+ description
+ "The startup configuration is the config target.";
+ }
+ }
+ }
+ }
+ }
+
+ rpc unlock {
+ description
+ "The unlock operation is used to release a configuration lock,
+ previously obtained with the 'lock' operation.";
+
+ reference "RFC 6241, Section 7.6";
+
+ input {
+ container target {
+ description
+ "Particular configuration to unlock.";
+
+ choice config-target {
+ mandatory true;
+ description
+ "The configuration target to unlock.";
+
+ leaf candidate {
+ if-feature candidate;
+ type empty;
+ description
+ "The candidate configuration is the config target.";
+ }
+ leaf running {
+ type empty;
+ description
+ "The running configuration is the config target.";
+ }
+ leaf startup {
+ if-feature startup;
+ type empty;
+ description
+ "The startup configuration is the config target.";
+ }
+ }
+ }
+ }
+ }
+
+ rpc get {
+ description
+ "Retrieve running configuration and device state information.";
+
+ reference "RFC 6241, Section 7.7";
+
+ input {
+ anyxml filter {
+ description
+ "This parameter specifies the portion of the system
+ configuration and state data to retrieve.";
+ nc:get-filter-element-attributes;
+ }
+ }
+
+ output {
+ anyxml data {
+ description
+ "Copy of the running datastore subset and/or state
+ data that matched the filter criteria (if any).
+ An empty data container indicates that the request did not
+ produce any results.";
+ }
+ }
+ }
+
+ rpc close-session {
+ description
+ "Request graceful termination of a NETCONF session.";
+
+ reference "RFC 6241, Section 7.8";
+ }
+
+ rpc kill-session {
+ description
+ "Force the termination of a NETCONF session.";
+
+ reference "RFC 6241, Section 7.9";
+
+ input {
+ leaf session-id {
+ type session-id-type;
+ mandatory true;
+ description
+ "Particular session to kill.";
+ }
+ }
+ }
+
+ rpc commit {
+ if-feature candidate;
+
+ description
+ "Commit the candidate configuration as the device's new
+ current configuration.";
+
+ reference "RFC 6241, Section 8.3.4.1";
+
+ input {
+ leaf confirmed {
+ if-feature confirmed-commit;
+ type empty;
+ description
+ "Requests a confirmed commit.";
+ reference "RFC 6241, Section 8.3.4.1";
+ }
+
+ leaf confirm-timeout {
+ if-feature confirmed-commit;
+ type uint32 {
+ range "1..max";
+ }
+ units "seconds";
+ default "600"; // 10 minutes
+ description
+ "The timeout interval for a confirmed commit.";
+ reference "RFC 6241, Section 8.3.4.1";
+ }
+
+ leaf persist {
+ if-feature confirmed-commit;
+ type string;
+ description
+ "This parameter is used to make a confirmed commit
+ persistent. A persistent confirmed commit is not aborted
+ if the NETCONF session terminates. The only way to abort
+ a persistent confirmed commit is to let the timer expire,
+ or to use the <cancel-commit> operation.
+
+ The value of this parameter is a token that must be given
+ in the 'persist-id' parameter of <commit> or
+ <cancel-commit> operations in order to confirm or cancel
+ the persistent confirmed commit.
+
+ The token should be a random string.";
+ reference "RFC 6241, Section 8.3.4.1";
+ }
+
+ leaf persist-id {
+ if-feature confirmed-commit;
+ type string;
+ description
+ "This parameter is given in order to commit a persistent
+ confirmed commit. The value must be equal to the value
+ given in the 'persist' parameter to the <commit> operation.
+ If it does not match, the operation fails with an
+ 'invalid-value' error.";
+ reference "RFC 6241, Section 8.3.4.1";
+ }
+
+ }
+ }
+
+ rpc discard-changes {
+ if-feature candidate;
+
+ description
+ "Revert the candidate configuration to the current
+ running configuration.";
+ reference "RFC 6241, Section 8.3.4.2";
+ }
+
+ rpc cancel-commit {
+ if-feature confirmed-commit;
+ description
+ "This operation is used to cancel an ongoing confirmed commit.
+ If the confirmed commit is persistent, the parameter
+ 'persist-id' must be given, and it must match the value of the
+ 'persist' parameter.";
+ reference "RFC 6241, Section 8.4.4.1";
+
+ input {
+ leaf persist-id {
+ type string;
+ description
+ "This parameter is given in order to cancel a persistent
+ confirmed commit. The value must be equal to the value
+ given in the 'persist' parameter to the <commit> operation.
+ If it does not match, the operation fails with an
+ 'invalid-value' error.";
+ }
+ }
+ }
+
+ rpc validate {
+ if-feature validate;
+
+ description
+ "Validates the contents of the specified configuration.";
+
+ reference "RFC 6241, Section 8.6.4.1";
+
+ input {
+ container source {
+ description
+ "Particular configuration to validate.";
+
+ choice config-source {
+ mandatory true;
+ description
+ "The configuration source to validate.";
+
+ leaf candidate {
+ if-feature candidate;
+ type empty;
+ description
+ "The candidate configuration is the config source.";
+ }
+ leaf running {
+ type empty;
+ description
+ "The running configuration is the config source.";
+ }
+ leaf startup {
+ if-feature startup;
+ type empty;
+ description
+ "The startup configuration is the config source.";
+ }
+ leaf url {
+ if-feature url;
+ type inet:uri;
+ description
+ "The URL-based configuration is the config source.";
+ }
+ anyxml config {
+ description
+ "Inline Config content: <config> element. Represents
+ an entire configuration datastore, not
+ a subset of the running datastore.";
+ }
+ }
+ }
+ }
+ }
+
+}
--- /dev/null
+module ietf-network-topology {
+ yang-version 1;
+ namespace "urn:ietf:params:xml:ns:yang:ietf-network-topology";
+ prefix lnk;
+
+ import ietf-inet-types {
+ prefix inet;
+ }
+ import ietf-network {
+ prefix nd;
+ }
+
+ organization "TBD";
+ contact
+ "WILL-BE-DEFINED-LATER";
+ description
+ "This module defines a common base model for network topology,
+ augmenting the base network model with links to connect nodes,
+ as well as termination points to terminate links on nodes.";
+
+ revision 2015-06-08 {
+ description
+ "Initial revision.";
+ reference "draft-ietf-i2rs-yang-network-topo-01";
+ }
+
+ typedef link-id {
+ type inet:uri;
+ description
+ "An identifier for a link in a topology.
+ The identifier may be opaque.
+ The identifier SHOULD be chosen such that the same link in a
+ real network topology will always be identified through the
+ same identifier, even if the model is instantiated in
+ separate datastores. An implementation MAY choose to capture
+ semantics in the identifier, for example to indicate the type
+ of link and/or the type of topology that the link is a part
+ of.";
+ }
+
+ typedef tp-id {
+ type inet:uri;
+ description
+ "An identifier for termination points on a node.
+ The identifier may be opaque.
+ The identifier SHOULD be chosen such that the same TP in a
+ real network topology will always be identified through the
+ same identifier, even if the model is instantiated in
+ separate datastores. An implementation MAY choose to capture
+ semantics in the identifier, for example to indicate the type
+ of TP and/or the type of node and topology that the TP is a
+ part of.";
+ }
+
+ grouping link-ref {
+ description
+ "References a link in a specific network.";
+ leaf link-ref {
+ type leafref {
+ path "/nd:network[nd:network-id=current()/../"+
+ "nd:network-ref]/link/link-id";
+ }
+ description
+ "A type for an absolute reference a link instance.
+ (This type should not be used for relative references.
+ In such a case, a relative path should be used instead.)";
+ }
+ uses nd:network-ref;
+ }
+
+ grouping tp-ref {
+ description
+ "References a termination point in a specific node.";
+ leaf tp-ref {
+ type leafref {
+ path "/nd:network[nd:network-id=current()/../"+
+ "nd:network-ref]/nd:node[nd:node-id=current()/../"+
+ "nd:node-ref]/termination-point/tp-id";
+ }
+ description
+ "A type for an absolute reference to a termination point.
+ (This type should not be used for relative references.
+ In such a case, a relative path should be used instead.)";
+ }
+ uses nd:node-ref;
+ }
+
+ augment "/nd:network" {
+ description
+ "Add links to the network model.";
+ list link {
+ key "link-id";
+ description
+ "A Network Link connects a by Local (Source) node and
+ a Remote (Destination) Network Nodes via a set of the
+ nodes' termination points.
+ As it is possible to have several links between the same
+ source and destination nodes, and as a link could
+ potentially be re-homed between termination points, to
+ ensure that we would always know to distinguish between
+ links, every link is identified by a dedicated link
+ identifier.
+ Note that a link models a point-to-point link, not a
+ multipoint link.
+ Layering dependencies on links in underlay topologies are
+ not represented as the layering information of nodes and of
+ termination points is sufficient.";
+ container source {
+ description
+ "This container holds the logical source of a particular
+ link.";
+ leaf source-node {
+ type leafref {
+ path "../../../nd:node/nd:node-id";
+ }
+ mandatory true;
+ description
+ "Source node identifier, must be in same topology.";
+ }
+ leaf source-tp {
+ type leafref {
+ path "../../../nd:node[nd:node-id=current()/../"+
+ "source-node]/termination-point/tp-id";
+ }
+ description
+ "Termination point within source node that terminates
+ the link.";
+ }
+ }
+ container destination {
+ description
+ "This container holds the logical destination of a
+ particular link.";
+ leaf dest-node {
+ type leafref {
+ path "../../../nd:node/nd:node-id";
+ }
+ mandatory true;
+ description
+ "Destination node identifier, must be in the same
+ network.";
+ }
+ leaf dest-tp {
+ type leafref {
+ path "../../../nd:node[nd:node-id=current()/../"+
+ "dest-node]/termination-point/tp-id";
+ }
+ description
+ "Termination point within destination node that
+ terminates the link.";
+ }
+ }
+ leaf link-id {
+ type link-id;
+ description
+ "The identifier of a link in the topology.
+ A link is specific to a topology to which it belongs.";
+ }
+ list supporting-link {
+ key "network-ref link-ref";
+ description
+ "Identifies the link, or links, that this link
+ is dependent on.";
+ leaf network-ref {
+ type leafref {
+ path "../../../nd:supporting-network/nd:network-ref";
+ }
+ description
+ "This leaf identifies in which underlay topology
+ supporting link is present.";
+ }
+ leaf link-ref {
+ type leafref {
+ path "/nd:network[nd:network-id=current()/.."+
+ "/network-ref]/link/link-id";
+ }
+ description
+ "This leaf identifies a link which is a part
+ of this link's underlay. Reference loops, in which
+ a link identifies itself as its underlay, either
+ directly or transitively, are not allowed.";
+ }
+ }
+ }
+ }
+ augment "/nd:network/nd:node" {
+ description
+ "Augment termination points which terminate links.
+ Termination points can ultimately be mapped to interfaces.";
+ list termination-point {
+ key "tp-id";
+ description
+ "A termination point can terminate a link.
+ Depending on the type of topology, a termination point
+ could, for example, refer to a port or an interface.";
+ leaf tp-id {
+ type tp-id;
+ description
+ "Termination point identifier.";
+ }
+ list supporting-termination-point {
+ key "network-ref node-ref tp-ref";
+ description
+ "The leaf list identifies any termination points that
+ the termination point is dependent on, or maps onto.
+ Those termination points will themselves be contained
+ in a supporting node.
+ This dependency information can be inferred from
+ the dependencies between links. For this reason,
+ this item is not separately configurable. Hence no
+ corresponding constraint needs to be articulated.
+ The corresponding information is simply provided by the
+ implementing system.";
+ leaf network-ref {
+ type leafref {
+ path "../../../nd:supporting-node/nd:network-ref";
+ }
+ description
+ "This leaf identifies in which topology the
+ supporting termination point is present.";
+ }
+ leaf node-ref {
+ type leafref {
+ path "../../../nd:supporting-node/nd:node-ref";
+ }
+ description
+ "This leaf identifies in which node the supporting
+ termination point is present.";
+ }
+ leaf tp-ref {
+ type leafref {
+ path "/nd:network[nd:network-id=current()/../"+
+ "network-ref]/nd:node[nd:node-id=current()/../"+
+ "node-ref]/termination-point/tp-id";
+ }
+ description
+ "Reference to the underlay node, must be in a
+ different topology";
+ }
+ }
+ }
+ }
+}
--- /dev/null
+module ietf-network {
+ yang-version 1;
+ namespace "urn:ietf:params:xml:ns:yang:ietf-network";
+ prefix nd;
+
+ import ietf-inet-types {
+ prefix inet;
+ }
+
+ organization "TBD";
+ contact
+ "WILL-BE-DEFINED-LATER";
+ description
+ "This module defines a common base model for a collection
+ of nodes in a network. Node definitions s are further used
+ in network topologies and inventories.";
+
+ revision 2015-06-08 {
+ description
+ "Initial revision.";
+ reference "draft-ietf-i2rs-yang-network-topo-01";
+ }
+
+ typedef node-id {
+ type inet:uri;
+ description
+ "Identifier for a node.";
+ }
+
+ typedef network-id {
+ type inet:uri;
+ description
+ "Identifier for a network.";
+ }
+
+ grouping network-ref {
+ description
+ "Contains the information necessary to reference a network,
+ for example an underlay network.";
+ leaf network-ref {
+ type leafref {
+ path "/network/network-id";
+ }
+ description
+ "Used to reference a network, for example an underlay
+ network.";
+ }
+ }
+
+ grouping node-ref {
+ description
+ "Contains the information necessary to reference a node.";
+ leaf node-ref {
+ type leafref {
+ path "/network[network-id=current()/../network-ref]"+
+ "/node/node-id";
+ }
+ description
+ "Used to reference a node.
+ Nodes are identified relative to the network they are
+ contained in.";
+ }
+ uses network-ref;
+ }
+
+ list network {
+ key "network-id";
+ description
+ "Describes a network.
+ A network typically contains an inventory of nodes,
+ topological information (augmented through
+ network-topology model), as well as layering
+ information.";
+ container network-types {
+ description
+ "Serves as an augmentation target.
+ The network type is indicated through corresponding
+ presence containers augmented into this container.";
+ }
+ leaf network-id {
+ type network-id;
+ description
+ "Identifies a network.";
+ }
+ leaf server-provided {
+ type boolean;
+ config false;
+ description
+ "Indicates whether the information concerning this
+ particular network is populated by the server
+ (server-provided true, the general case for network
+ information discovered from the server),
+ or whether it is configured by a client
+ (server-provided true, possible e.g. for
+ service overlays managed through a controller).";
+ }
+ list supporting-network {
+ key "network-ref";
+ description
+ "An underlay network, used to represent layered network
+ topologies.";
+ leaf network-ref {
+ type leafref {
+ path "/network/network-id";
+ }
+ description
+ "References the underlay network.";
+ }
+ }
+ list node {
+ key "node-id";
+ description
+ "The inventory of nodes of this network.";
+ leaf node-id {
+ type node-id;
+ description
+ "Identifies a node uniquely within the containing
+ network.";
+ }
+ list supporting-node {
+ key "network-ref node-ref";
+ description
+ "Represents another node, in an underlay network, that
+ this node is supported by. Used to represent layering
+ structure.";
+ leaf network-ref {
+ type leafref {
+ path "../../../supporting-network/network-ref";
+ }
+ description
+ "References the underlay network that the
+ underlay node is part of.";
+ }
+ leaf node-ref {
+ type leafref {
+ path "/network/node/node-id";
+ }
+ description
+ "References the underlay node itself.";
+ }
+ }
+ }
+ }
+}
--- /dev/null
+module ietf-yang-types {
+
+ namespace "urn:ietf:params:xml:ns:yang:ietf-yang-types";
+ prefix "yang";
+
+ organization
+ "IETF NETMOD (NETCONF Data Modeling Language) Working Group";
+
+ contact
+ "WG Web: <http://tools.ietf.org/wg/netmod/>
+ WG List: <mailto:netmod@ietf.org>
+ WG Chair: David Kessens
+ <mailto:david.kessens@nsn.com>
+
+ WG Chair: Juergen Schoenwaelder
+ <mailto:j.schoenwaelder@jacobs-university.de>
+
+ Editor: Juergen Schoenwaelder
+ <mailto:j.schoenwaelder@jacobs-university.de>";
+
+ description
+ "This module contains a collection of generally useful derived
+ YANG data types.
+
+ 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:
+ - yang-identifier
+ - hex-string
+ - uuid
+ - dotted-quad";
+ reference
+ "RFC 6991: Common YANG Data Types";
+ }
+
+ revision 2010-09-24 {
+ description
+ "Initial revision.";
+ reference
+ "RFC 6021: Common YANG Data Types";
+ }
+
+ /*** collection of counter and gauge types ***/
+
+ typedef counter32 {
+ type uint32;
+ description
+ "The counter32 type represents a non-negative integer
+ that monotonically increases until it reaches a
+ maximum value of 2^32-1 (4294967295 decimal), when it
+ wraps around and starts increasing again from zero.
+
+ Counters have no defined 'initial' value, and thus, a
+ single value of a counter has (in general) no information
+ content. Discontinuities in the monotonically increasing
+ value normally occur at re-initialization of the
+ management system, and at other times as specified in the
+ description of a schema node using this type. If such
+ other times can occur, for example, the creation of
+ a schema node of type counter32 at times other than
+ re-initialization, then a corresponding schema node
+ should be defined, with an appropriate type, to indicate
+ the last discontinuity.
+
+ The counter32 type should not be used for configuration
+ schema nodes. A default statement SHOULD NOT be used in
+ combination with the type counter32.
+
+ In the value set and its semantics, this type is equivalent
+ to the Counter32 type of the SMIv2.";
+ reference
+ "RFC 2578: Structure of Management Information Version 2
+ (SMIv2)";
+ }
+
+ typedef zero-based-counter32 {
+ type yang:counter32;
+ default "0";
+ description
+ "The zero-based-counter32 type represents a counter32
+ that has the defined 'initial' value zero.
+
+ A schema node of this type will be set to zero (0) on creation
+ and will thereafter increase monotonically until it reaches
+ a maximum value of 2^32-1 (4294967295 decimal), when it
+ wraps around and starts increasing again from zero.
+
+ Provided that an application discovers a new schema node
+ of this type within the minimum time to wrap, it can use the
+ 'initial' value as a delta. It is important for a management
+ station to be aware of this minimum time and the actual time
+ between polls, and to discard data if the actual time is too
+ long or there is no defined minimum time.
+ In the value set and its semantics, this type is equivalent
+ to the ZeroBasedCounter32 textual convention of the SMIv2.";
+ reference
+ "RFC 4502: Remote Network Monitoring Management Information
+ Base Version 2";
+ }
+
+ typedef counter64 {
+ type uint64;
+ description
+ "The counter64 type represents a non-negative integer
+ that monotonically increases until it reaches a
+ maximum value of 2^64-1 (18446744073709551615 decimal),
+ when it wraps around and starts increasing again from zero.
+
+ Counters have no defined 'initial' value, and thus, a
+ single value of a counter has (in general) no information
+ content. Discontinuities in the monotonically increasing
+ value normally occur at re-initialization of the
+ management system, and at other times as specified in the
+ description of a schema node using this type. If such
+ other times can occur, for example, the creation of
+ a schema node of type counter64 at times other than
+ re-initialization, then a corresponding schema node
+ should be defined, with an appropriate type, to indicate
+ the last discontinuity.
+
+ The counter64 type should not be used for configuration
+ schema nodes. A default statement SHOULD NOT be used in
+ combination with the type counter64.
+
+ In the value set and its semantics, this type is equivalent
+ to the Counter64 type of the SMIv2.";
+ reference
+ "RFC 2578: Structure of Management Information Version 2
+ (SMIv2)";
+ }
+
+ typedef zero-based-counter64 {
+ type yang:counter64;
+ default "0";
+ description
+ "The zero-based-counter64 type represents a counter64 that
+ has the defined 'initial' value zero.
+ A schema node of this type will be set to zero (0) on creation
+ and will thereafter increase monotonically until it reaches
+ a maximum value of 2^64-1 (18446744073709551615 decimal),
+ when it wraps around and starts increasing again from zero.
+
+ Provided that an application discovers a new schema node
+ of this type within the minimum time to wrap, it can use the
+ 'initial' value as a delta. It is important for a management
+ station to be aware of this minimum time and the actual time
+ between polls, and to discard data if the actual time is too
+ long or there is no defined minimum time.
+
+ In the value set and its semantics, this type is equivalent
+ to the ZeroBasedCounter64 textual convention of the SMIv2.";
+ reference
+ "RFC 2856: Textual Conventions for Additional High Capacity
+ Data Types";
+ }
+
+ typedef gauge32 {
+ type uint32;
+ description
+ "The gauge32 type represents a non-negative integer, which
+ may increase or decrease, but shall never exceed a maximum
+ value, nor fall below a minimum value. The maximum value
+ cannot be greater than 2^32-1 (4294967295 decimal), and
+ the minimum value cannot be smaller than 0. The value of
+ a gauge32 has its maximum value whenever the information
+ being modeled is greater than or equal to its maximum
+ value, and has its minimum value whenever the information
+ being modeled is smaller than or equal to its minimum value.
+ If the information being modeled subsequently decreases
+ below (increases above) the maximum (minimum) value, the
+ gauge32 also decreases (increases).
+
+ In the value set and its semantics, this type is equivalent
+ to the Gauge32 type of the SMIv2.";
+ reference
+ "RFC 2578: Structure of Management Information Version 2
+ (SMIv2)";
+ }
+
+ typedef gauge64 {
+ type uint64;
+ description
+ "The gauge64 type represents a non-negative integer, which
+ may increase or decrease, but shall never exceed a maximum
+ value, nor fall below a minimum value. The maximum value
+ cannot be greater than 2^64-1 (18446744073709551615), and
+ the minimum value cannot be smaller than 0. The value of
+ a gauge64 has its maximum value whenever the information
+ being modeled is greater than or equal to its maximum
+ value, and has its minimum value whenever the information
+ being modeled is smaller than or equal to its minimum value.
+ If the information being modeled subsequently decreases
+ below (increases above) the maximum (minimum) value, the
+ gauge64 also decreases (increases).
+
+ In the value set and its semantics, this type is equivalent
+ to the CounterBasedGauge64 SMIv2 textual convention defined
+ in RFC 2856";
+ reference
+ "RFC 2856: Textual Conventions for Additional High Capacity
+ Data Types";
+ }
+
+ /*** collection of identifier-related types ***/
+
+ typedef object-identifier {
+ type string {
+ pattern '(([0-1](\.[1-3]?[0-9]))|(2\.(0|([1-9]\d*))))'
+ + '(\.(0|([1-9]\d*)))*';
+ }
+ description
+ "The object-identifier type represents administratively
+ assigned names in a registration-hierarchical-name tree.
+
+ Values of this type are denoted as a sequence of numerical
+ non-negative sub-identifier values. Each sub-identifier
+ value MUST NOT exceed 2^32-1 (4294967295). Sub-identifiers
+ are separated by single dots and without any intermediate
+ whitespace.
+
+ The ASN.1 standard restricts the value space of the first
+ sub-identifier to 0, 1, or 2. Furthermore, the value space
+ of the second sub-identifier is restricted to the range
+ 0 to 39 if the first sub-identifier is 0 or 1. Finally,
+ the ASN.1 standard requires that an object identifier
+ has always at least two sub-identifiers. The pattern
+ captures these restrictions.
+
+ Although the number of sub-identifiers is not limited,
+ module designers should realize that there may be
+ implementations that stick with the SMIv2 limit of 128
+ sub-identifiers.
+ This type is a superset of the SMIv2 OBJECT IDENTIFIER type
+ since it is not restricted to 128 sub-identifiers. Hence,
+ this type SHOULD NOT be used to represent the SMIv2 OBJECT
+ IDENTIFIER type; the object-identifier-128 type SHOULD be
+ used instead.";
+ reference
+ "ISO9834-1: Information technology -- Open Systems
+ Interconnection -- Procedures for the operation of OSI
+ Registration Authorities: General procedures and top
+ arcs of the ASN.1 Object Identifier tree";
+ }
+
+ typedef object-identifier-128 {
+ type object-identifier {
+ pattern '\d*(\.\d*){1,127}';
+ }
+ description
+ "This type represents object-identifiers restricted to 128
+ sub-identifiers.
+
+ In the value set and its semantics, this type is equivalent
+ to the OBJECT IDENTIFIER type of the SMIv2.";
+ reference
+ "RFC 2578: Structure of Management Information Version 2
+ (SMIv2)";
+ }
+
+ typedef yang-identifier {
+ type string {
+ length "1..max";
+ pattern '[a-zA-Z_][a-zA-Z0-9\-_.]*';
+ pattern '.|..|[^xX].*|.[^mM].*|..[^lL].*';
+ }
+ description
+ "A YANG identifier string as defined by the 'identifier'
+ rule in Section 12 of RFC 6020. An identifier must
+ start with an alphabetic character or an underscore
+ followed by an arbitrary sequence of alphabetic or
+ numeric characters, underscores, hyphens, or dots.
+
+ A YANG identifier MUST NOT start with any possible
+ combination of the lowercase or uppercase character
+ sequence 'xml'.";
+ reference
+ "RFC 6020: YANG - A Data Modeling Language for the Network
+ Configuration Protocol (NETCONF)";
+ }
+ /*** collection of types related to date and time***/
+
+ typedef date-and-time {
+ type string {
+ pattern '\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d+)?'
+ + '(Z|[\+\-]\d{2}:\d{2})';
+ }
+ description
+ "The date-and-time type is a profile of the ISO 8601
+ standard for representation of dates and times using the
+ Gregorian calendar. The profile is defined by the
+ date-time production in Section 5.6 of RFC 3339.
+
+ The date-and-time type is compatible with the dateTime XML
+ schema type with the following notable exceptions:
+
+ (a) The date-and-time type does not allow negative years.
+
+ (b) The date-and-time time-offset -00:00 indicates an unknown
+ time zone (see RFC 3339) while -00:00 and +00:00 and Z
+ all represent the same time zone in dateTime.
+
+ (c) The canonical format (see below) of data-and-time values
+ differs from the canonical format used by the dateTime XML
+ schema type, which requires all times to be in UTC using
+ the time-offset 'Z'.
+
+ This type is not equivalent to the DateAndTime textual
+ convention of the SMIv2 since RFC 3339 uses a different
+ separator between full-date and full-time and provides
+ higher resolution of time-secfrac.
+
+ The canonical format for date-and-time values with a known time
+ zone uses a numeric time zone offset that is calculated using
+ the device's configured known offset to UTC time. A change of
+ the device's offset to UTC time will cause date-and-time values
+ to change accordingly. Such changes might happen periodically
+ in case a server follows automatically daylight saving time
+ (DST) time zone offset changes. The canonical format for
+ date-and-time values with an unknown time zone (usually
+ referring to the notion of local time) uses the time-offset
+ -00:00.";
+ reference
+ "RFC 3339: Date and Time on the Internet: Timestamps
+ RFC 2579: Textual Conventions for SMIv2
+ XSD-TYPES: XML Schema Part 2: Datatypes Second Edition";
+ }
+ typedef timeticks {
+ type uint32;
+ description
+ "The timeticks type represents a non-negative integer that
+ represents the time, modulo 2^32 (4294967296 decimal), in
+ hundredths of a second between two epochs. When a schema
+ node is defined that uses this type, the description of
+ the schema node identifies both of the reference epochs.
+
+ In the value set and its semantics, this type is equivalent
+ to the TimeTicks type of the SMIv2.";
+ reference
+ "RFC 2578: Structure of Management Information Version 2
+ (SMIv2)";
+ }
+
+ typedef timestamp {
+ type yang:timeticks;
+ description
+ "The timestamp type represents the value of an associated
+ timeticks schema node at which a specific occurrence
+ happened. The specific occurrence must be defined in the
+ description of any schema node defined using this type. When
+ the specific occurrence occurred prior to the last time the
+ associated timeticks attribute was zero, then the timestamp
+ value is zero. Note that this requires all timestamp values
+ to be reset to zero when the value of the associated timeticks
+ attribute reaches 497+ days and wraps around to zero.
+
+ The associated timeticks schema node must be specified
+ in the description of any schema node using this type.
+
+ In the value set and its semantics, this type is equivalent
+ to the TimeStamp textual convention of the SMIv2.";
+ reference
+ "RFC 2579: Textual Conventions for SMIv2";
+ }
+
+ /*** collection of generic address types ***/
+
+ typedef phys-address {
+ type string {
+ pattern '([0-9a-fA-F]{2}(:[0-9a-fA-F]{2})*)?';
+ }
+ description
+ "Represents media- or physical-level addresses represented
+ as a sequence octets, each octet represented by two hexadecimal
+ numbers. Octets are separated by colons. The canonical
+ representation uses lowercase characters.
+
+ In the value set and its semantics, this type is equivalent
+ to the PhysAddress textual convention of the SMIv2.";
+ reference
+ "RFC 2579: Textual Conventions for SMIv2";
+ }
+
+ typedef mac-address {
+ type string {
+ pattern '[0-9a-fA-F]{2}(:[0-9a-fA-F]{2}){5}';
+ }
+ description
+ "The mac-address type represents an IEEE 802 MAC address.
+ The canonical representation uses lowercase characters.
+
+ In the value set and its semantics, this type is equivalent
+ to the MacAddress textual convention of the SMIv2.";
+ reference
+ "IEEE 802: IEEE Standard for Local and Metropolitan Area
+ Networks: Overview and Architecture
+ RFC 2579: Textual Conventions for SMIv2";
+ }
+
+ /*** collection of XML-specific types ***/
+
+ typedef xpath1.0 {
+ type string;
+ description
+ "This type represents an XPATH 1.0 expression.
+
+ When a schema node is defined that uses this type, the
+ description of the schema node MUST specify the XPath
+ context in which the XPath expression is evaluated.";
+ reference
+ "XPATH: XML Path Language (XPath) Version 1.0";
+ }
+
+ /*** collection of string types ***/
+
+ typedef hex-string {
+ type string {
+ pattern '([0-9a-fA-F]{2}(:[0-9a-fA-F]{2})*)?';
+ }
+ description
+ "A hexadecimal string with octets represented as hex digits
+ separated by colons. The canonical representation uses
+ lowercase characters.";
+ }
+
+ typedef uuid {
+ type string {
+ pattern '[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-'
+ + '[0-9a-fA-F]{4}-[0-9a-fA-F]{12}';
+ }
+ description
+ "A Universally Unique IDentifier in the string representation
+ defined in RFC 4122. The canonical representation uses
+ lowercase characters.
+
+ The following is an example of a UUID in string representation:
+ f81d4fae-7dec-11d0-a765-00a0c91e6bf6
+ ";
+ reference
+ "RFC 4122: A Universally Unique IDentifier (UUID) URN
+ Namespace";
+ }
+
+ typedef dotted-quad {
+ 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])';
+ }
+ description
+ "An unsigned 32-bit number expressed in the dotted-quad
+ notation, i.e., four octets written as decimal numbers
+ and separated with the '.' (full stop) character.";
+ }
+ }
\ No newline at end of file
--- /dev/null
+module notifications {
+
+ namespace "urn:ietf:params:xml:ns:netconf:notification:1.0";
+ prefix "ncEvent";
+
+ import ietf-yang-types { prefix yang; revision-date "2013-07-15";}
+
+ organization
+ "IETF NETCONF WG";
+
+ contact
+ "netconf@ops.ietf.org";
+
+ description
+ "Conversion of the 'ncEvent' XSD in the
+ NETCONF Notifications RFC.";
+
+ reference
+ "RFC 5277.";
+
+ revision 2008-07-14 {
+ description "RFC 5277 version.";
+ }
+
+ typedef streamNameType {
+ description
+ "The name of an event stream.";
+ type string;
+ }
+
+ rpc create-subscription {
+ description
+ "The command to create a notification subscription. It
+ takes as argument the name of the notification stream
+ and filter. Both of those options limit the content of
+ the subscription. In addition, there are two time-related
+ parameters, startTime and stopTime, which can be used to
+ select the time interval of interest to the notification
+ replay feature.";
+
+ input {
+ leaf stream {
+ description
+ "An optional parameter that indicates which stream of events
+ is of interest. If not present, then events in the default
+ NETCONF stream will be sent.";
+ type streamNameType;
+ default "NETCONF";
+ }
+
+ anyxml filter {
+ description
+ "An optional parameter that indicates which subset of all
+ possible events is of interest. The format of this
+ parameter is the same as that of the filter parameter
+ in the NETCONF protocol operations. If not present,
+ all events not precluded by other parameters will
+ be sent.";
+ }
+
+ leaf startTime {
+ description
+ "A parameter used to trigger the replay feature and
+ indicates that the replay should start at the time
+ specified. If start time is not present, this is not a
+ replay subscription.";
+ type yang:date-and-time;
+ }
+
+ leaf stopTime {
+ // must ". >= ../startTime";
+ description
+ "An optional parameter used with the optional replay
+ feature to indicate the newest notifications of
+ interest. If stop time is not present, the notifications
+ will continue until the subscription is terminated.
+ Must be used with startTime.";
+ type yang:date-and-time;
+ }
+ }
+ }
+}
+
--- /dev/null
+module org-openroadm-alarm {
+ namespace "http://org/openroadm/alarm";
+ prefix org-openroadm-alarm;
+
+ import ietf-yang-types {
+ prefix yang;
+ }
+ import org-openroadm-common-types {
+ prefix org-openroadm-common-types;
+ }
+ import org-openroadm-resource {
+ prefix org-openroadm-resource;
+ }
+ import org-openroadm-probable-cause {
+ prefix org-openroadm-probable-cause;
+ }
+
+ organization "Open ROADM MSA";
+ contact
+ "OpenROADM.org";
+ description
+ "YANG definitions of an alarm.
+
+ Copyright of the Members of the Open ROADM MSA Agreement dated (c) 2016,
+ AT&T Intellectual Property. All other rights reserved.
+
+ Redistribution and use in source and binary forms, with or without modification,
+ are permitted provided that the following conditions are met:
+
+ * Redistributions of source code must retain the above copyright notice, this
+ list of conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions and the following disclaimer in the documentation and/or
+ other materials provided with the distribution.
+ * Neither the Members of the Open ROADM MSA Agreement nor the names of its
+ contributors may be used to endorse or promote products derived from this software
+ without specific prior written permission.
+
+ THIS SOFTWARE IS PROVIDED BY THE MEMBERS OF THE OPEN ROADM MSA AGREEMENT ''AS IS''
+ AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ IN NO EVENT THE MEMBERS OF THE OPEN ROADM MSA AGREEMENT BE LIABLE FOR ANY DIRECT,
+ INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
+ OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ POSSIBILITY OF SUCH DAMAGE.";
+
+ revision 2016-10-14 {
+ description
+ "Version 1.2";
+ }
+
+ grouping alarm {
+ leaf id {
+ description
+ "Uniquely id for this alarm, within the given management domain";
+ type string;
+ mandatory true;
+ }
+ container resource {
+ description
+ "Resource under alarm";
+ uses org-openroadm-resource:resource;
+ }
+ container probableCause {
+ description
+ "Probable cause of alarm";
+ uses org-openroadm-probable-cause:probable-cause;
+ }
+ leaf type {
+ description
+ "Type of alarm. Based on X.733 event Type.";
+ mandatory false;
+ type enumeration {
+ enum "communication" {
+ value 1;
+ }
+ enum "qualityOfService" {
+ value 2;
+ }
+ enum "processingError" {
+ value 3;
+ }
+ enum "equipment" {
+ value 4;
+ }
+ enum "environmental" {
+ value 5;
+ }
+ }
+ }
+ leaf raiseTime {
+ description
+ "Time alarm was raised";
+ type yang:date-and-time;
+ mandatory true;
+ }
+ leaf severity {
+ description
+ "Severity of alarm. Based on X.733 perceived severity.";
+ mandatory true;
+ type org-openroadm-common-types:severity;
+ }
+ leaf circuit-id {
+ description
+ "Circuit-id for alarm correlation.";
+ type string;
+ }
+ }
+
+ container active-alarm-list {
+ description
+ "List of currently active alarms. An alarm is removed from this table when the state transitions to clear.";
+ list activeAlarms {
+ key "id";
+ uses alarm;
+ }
+ config false;
+ }
+ notification alarm-notification {
+ description
+ "Notification sent on initial alarm creation, as well as any time the alarm changes state, including clear";
+ uses alarm;
+ }
+}
--- /dev/null
+module org-openroadm-common-service-types {
+ namespace "http://org/openroadm/common/service/types";
+ prefix org-openroadm-common-service-types;
+
+ import ietf-yang-types {
+ prefix yang;
+ }
+ import ietf-inet-types {
+ prefix inet;
+ }
+ import org-openroadm-routing-constraints {
+ prefix org-openroadm-routing-constraints;
+ revision-date 2016-10-14;
+ }
+ import org-openroadm-topology {
+ prefix org-openroadm-topology;
+ }
+ import org-openroadm-common-types {
+ prefix org-openroadm-common-types;
+ revision-date 2016-10-14;
+ }
+ import org-openroadm-resource-types {
+ prefix org-openroadm-resource-types;
+ }
+
+ organization
+ "Open ROADM MSA";
+ contact
+ "OpenROADM.org";
+ description
+ "YANG definitions of common service types.
+
+ Copyright of the Members of the Open ROADM MSA Agreement dated (c) 2016,
+ AT&T Intellectual Property. All other rights reserved.
+
+ Redistribution and use in source and binary forms, with or without modification,
+ are permitted provided that the following conditions are met:
+
+ * Redistributions of source code must retain the above copyright notice, this
+ list of conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions and the following disclaimer in the documentation and/or
+ other materials provided with the distribution.
+ * Neither the Members of the Open ROADM MSA Agreement nor the names of its
+ contributors may be used to endorse or promote products derived from this software
+ without specific prior written permission.
+
+ THIS SOFTWARE IS PROVIDED BY THE MEMBERS OF THE OPEN ROADM MSA AGREEMENT ''AS IS''
+ AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ IN NO EVENT THE MEMBERS OF THE OPEN ROADM MSA AGREEMENT BE LIABLE FOR ANY DIRECT,
+ INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
+ OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ POSSIBILITY OF SUCH DAMAGE";
+
+ revision 2016-10-14 {
+ description
+ "Version 1.2";
+ }
+
+ grouping configuration-response-common {
+ container configuration-response-common {
+ leaf request-id {
+ type string;
+ mandatory true;
+ }
+ leaf response-code {
+ type string;
+ mandatory true;
+ }
+ leaf response-message {
+ type string;
+ }
+ leaf ack-final-indicator {
+ type string;
+ mandatory true;
+ }
+ }
+ }
+
+ grouping response-parameters {
+ container response-parameters {
+ uses org-openroadm-routing-constraints:routing-constraints;
+ }
+ }
+
+ grouping service-endpoint {
+ leaf service-format {
+ type service-format;
+ mandatory true;
+ description
+ "Format of the requested service: Ethernet, OTU, etc.";
+ }
+ leaf service-rate {
+ when "../service-format!='OMS'"{
+ description "service rate not applicable when service
+ format is roadmline";
+ }
+ type uint32;
+ mandatory true;
+ description
+ "Rate of the requested service in GBps";
+ }
+ leaf clli {
+ type string;
+ mandatory true;
+ description
+ "CLLI";
+ }
+ uses org-openroadm-resource-types:device-id;
+ container site;
+ container tx-direction {
+ uses service-port;
+ uses service-lgx;
+ uses service-tail;
+ }
+ container rx-direction {
+ uses service-port;
+ uses service-lgx;
+ uses service-tail;
+ }
+ leaf optic-type {
+ type org-openroadm-common-types:optic-types;
+ }
+ container router {
+ description
+ "Needed for communication with DWDM pluggable";
+ leaf node-id {
+ type string;
+ description
+ "Node id. This is reported against the service, but may not get reflected in the service in the network.";
+ }
+ leaf ip-address {
+ type inet:ip-address;
+ description
+ "Router IP Address. This is reported against the service, but may not get reflected in the service in the network.";
+ }
+ leaf url {
+ type string;
+ description
+ "URL needed for communication with DWDM pluggable. This is reported against the service, but may not get reflected in the service in the network.";
+ }
+ }
+ leaf user-label {
+ type string;
+ mandatory false;
+ description
+ "Label for service endpoint, defined by the user";
+ }
+ }
+
+ typedef rpc-actions {
+ description "rpc-actions include all the rpc methods";
+ type enumeration {
+ enum service-create {
+ value "1";
+ }
+ enum service-feasibility-check {
+ value "2";
+ }
+ enum service-delete {
+ value "3";
+ }
+ enum equipment-notification {
+ value "4";
+ }
+ enum temp-service-create {
+ value "5";
+ }
+ enum temp-service-delete {
+ value "6";
+ }
+ enum service-roll {
+ value "7";
+ }
+ enum service-reconfigure {
+ value "8";
+ }
+ enum service-restoration {
+ value "9";
+ }
+ enum service-reversion {
+ value "10";
+ }
+ enum service-reroute {
+ value "11";
+ }
+ enum service-reroute-confirm {
+ value "12";
+ }
+ enum network-re-optimization {
+ value "13";
+ }
+ }
+ }
+
+ grouping sdnc-request-header {
+ container sdnc-request-header {
+ leaf request-id {
+ type string;
+ }
+ leaf rpc-action {
+ type rpc-actions;
+ }
+ leaf notification-url {
+ type string;
+ }
+ leaf request-system-id{
+ type string;
+ }
+ }
+ }
+
+ grouping service-port {
+ container port {
+ leaf port-device-name {
+ type string;
+ }
+ leaf port-type {
+ type string;
+ }
+ leaf port-name {
+ type string;
+ }
+ leaf port-rack {
+ type string;
+ }
+ leaf port-shelf {
+ type string;
+ }
+ leaf port-slot {
+ type string;
+ }
+ leaf port-sub-slot {
+ type string;
+ }
+ }
+ }
+
+ grouping service-lgx {
+ container lgx {
+ leaf lgx-device-name {
+ type string;
+ }
+ leaf lgx-port-name {
+ type string;
+ }
+ leaf lgx-port-rack {
+ type string;
+ }
+ leaf lgx-port-shelf {
+ type string;
+ }
+ }
+ }
+
+ grouping service-tail {
+ container tail {
+ container tail-roadm {
+ description
+ "ROADM on which the transponder is connected to (TID, IP Address,
+ or FQDN)";
+ uses org-openroadm-resource-types:device-id;
+ }
+ container xponder-port {
+ description
+ "Muxponder port used in tail, that will get used as a service endpoint.";
+ leaf circuit-pack-name {
+ type string;
+ }
+ leaf port-name {
+ type string;
+ }
+ }
+ leaf tail-roadm-port-aid {
+ type string;
+ description
+ "This will provide the transponder port needed to inter-city ROADM
+ connection";
+ }
+ leaf tail-roadm-port-rack-location {
+ type string;
+ description
+ "Transponder's location";
+ }
+ }
+ }
+
+ grouping service-information {
+ leaf due-date {
+ type yang:date-and-time;
+ description
+ "Date and time service to be turn up. If time is not specified for a given date, default to midnight. Service turned up immediately if no due date is specified";
+ }
+ leaf end-date {
+ type yang:date-and-time;
+ description
+ "Date and time service to be removed";
+ mandatory false;
+ }
+ leaf nc-code {
+ type string;
+ description
+ "NC code applied to wavelength service only.This is reported against the service, but may not get reflected in the service in the network.";
+ }
+ leaf nci-code {
+ type string;
+ description
+ "NCI code applied to wavelength service only.This is reported against the service, but may not get reflected in the service in the network.";
+ }
+ leaf secondary-nci-code {
+ type string;
+ description
+ "NC code applied to wavelength service only.This is reported against the service, but may not get reflected in the service in the network.";
+ }
+ leaf customer {
+ type string;
+ description
+ "To be included in ticket information.This is reported against the service, but may not get reflected in the service in the network.";
+ }
+ leaf customer-contact {
+ type string;
+ description
+ "Customer contact information To be included in ticket information. This is reported against the service, but may not get reflected in the service in the network.";
+ }
+ leaf operator-contact {
+ type string;
+ description
+ "Operator contact information to be included in ticket information. This is reported against the service, but may not get reflected in the service in the network.";
+ }
+ }
+
+ grouping service {
+ leaf service-name {
+ type string;
+ description
+ "Identifier for the service to be created in
+ the ROADM network, e.g., CLFI, CLCI, etc.";
+ mandatory true;
+ }
+ leaf common-id {
+ type string;
+ description
+ "To be used by the ROADM controller to identify the routing
+ constraints received from planning application (PED).";
+ }
+ uses sdnc-request-header;
+ leaf connection-type {
+ type connection-type;
+ mandatory true;
+ description
+ "Connection type";
+ }
+ leaf lifecycle-state {
+ type org-openroadm-common-types:lifecycle-state;
+ description
+ "Lifecycle State of service. Whether it is planned, deployed, in maintenance, etc.";
+ }
+ leaf administrative-state {
+ type org-openroadm-common-types:state;
+ description
+ "Administrative State: Intended state of service";
+ }
+ leaf operational-state {
+ type org-openroadm-common-types:state;
+ config false;
+ description
+ "Operational State: Actual state of service";
+ }
+ leaf condition {
+ type service-condition;
+ description
+ "Service Condition: Additional information about the state of the service. Only sent when applicable.";
+ }
+ container service-a-end {
+ uses service-endpoint;
+ }
+ container service-z-end {
+ uses service-endpoint;
+ }
+ uses org-openroadm-routing-constraints:routing-constraints;
+ uses service-information;
+ leaf latency {
+ type uint32;
+ description
+ "Latency on service";
+ }
+ leaf-list fiber-span-srlgs {
+ type string;
+ description
+ "Shared risk link group identifiers";
+ }
+ list equipment-srgs {
+ key "srg-number";
+ uses org-openroadm-resource-types:srg-number;
+ }
+ leaf-list supporting-service-name {
+ description
+ "The service name that this runs over top. If connection-type is service, then this is the related
+ connection-type = infrastructure service, for example.";
+ type string;
+ }
+ container topology {
+ uses org-openroadm-topology:topology;
+ }
+ }
+
+ grouping service-notification-result {
+ leaf service-name {
+ type string;
+ description
+ "Identifier for the service e.g., CLFI, CLCI, etc.";
+ mandatory true;
+ }
+ leaf actual-date {
+ type yang:date-and-time;
+ description
+ "Actual date and time (if successful)";
+ }
+ }
+
+ typedef service-format {
+ type enumeration {
+ enum "Ethernet" {
+ value 1;
+ }
+ enum "OTU" {
+ value 2;
+ }
+ enum "OC" {
+ value 3;
+ }
+ enum "STM" {
+ value 4;
+ }
+ enum "OMS" {
+ value 5;
+ }
+ enum "ODU" {
+ value 6;
+ }
+ enum "OTM" {
+ value 7;
+ }
+ }
+ }
+
+ typedef service-notification-types {
+ type enumeration {
+ enum "service-create-result" {
+ value 1;
+ }
+ enum "service-reconfigure-result" {
+ value 2;
+ }
+ enum "service-delete-result" {
+ value 3;
+ }
+ enum "service-roll-result" {
+ value 4;
+ }
+ enum "service-revert-result" {
+ value 5;
+ }
+ enum "service-reroute-result" {
+ value 6;
+ }
+ enum "service-restoration-result" {
+ value 7;
+ }
+ //Add Martial
+ enum "service-feasibility-check-result" {
+ value 8;
+ }
+ }
+ }
+
+ typedef connection-type {
+ type enumeration {
+ enum "service" {
+ value 1;
+ }
+ enum "infrastructure" {
+ value 2;
+ }
+ enum "roadm-line" {
+ value 3;
+ }
+ }
+ }
+
+ typedef service-condition {
+ type enumeration {
+ enum "restored-temporarily" {
+ value 1;
+ }
+ enum "re-routed-temporarily" {
+ value 2;
+ }
+ enum "activated-for-service" {
+ value 3;
+ }
+ enum "activated-for-further-check" {
+ value 4;
+ }
+ enum "activated-for-troubleshooting-failure" {
+ value 5;
+ }
+ }
+ }
+}
--- /dev/null
+module org-openroadm-common-types {
+ namespace "http://org/openroadm/common-types";
+ prefix org-openroadm-common-types;
+
+ organization "Open ROADM MSA";
+ contact
+ "OpenROADM.org";
+ description
+ "YANG definitions of common types.
+
+ Copyright of the Members of the Open ROADM MSA Agreement dated (c) 2016,
+ AT&T Intellectual Property. All other rights reserved.
+
+ Redistribution and use in source and binary forms, with or without modification,
+ are permitted provided that the following conditions are met:
+
+ * Redistributions of source code must retain the above copyright notice, this
+ list of conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions and the following disclaimer in the documentation and/or
+ other materials provided with the distribution.
+ * Neither the Members of the Open ROADM MSA Agreement nor the names of its
+ contributors may be used to endorse or promote products derived from this software
+ without specific prior written permission.
+
+ THIS SOFTWARE IS PROVIDED BY THE MEMBERS OF THE OPEN ROADM MSA AGREEMENT ''AS IS''
+ AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ IN NO EVENT THE MEMBERS OF THE OPEN ROADM MSA AGREEMENT BE LIABLE FOR ANY DIRECT,
+ INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
+ OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ POSSIBILITY OF SUCH DAMAGE";
+
+ revision 2016-10-14 {
+ description
+ "Version 1.2";
+ }
+
+ grouping physical-location {
+ leaf rack {
+ type string;
+ mandatory false;
+ }
+ leaf shelf {
+ type string;
+ mandatory false;
+ }
+ leaf slot {
+ type string;
+ mandatory false;
+ }
+ leaf subSlot {
+ type string;
+ mandatory false;
+ }
+ }
+
+ typedef node-types {
+ type enumeration {
+ enum "rdm" {
+ value 1;
+ }
+ enum "xpdr" {
+ value 2;
+ }
+ }
+ description
+ "3 digit identifier for node type
+ 1. rdm for ROADM
+ 2. xpdr for Transponder, Regen";
+ }
+
+ typedef power-dBm {
+ description
+ "Power value in dBm.";
+ type decimal64 {
+ fraction-digits 2;
+ }
+ units "dBm";
+ }
+
+ typedef ratio-dB {
+ description
+ "Power ratio in dB.";
+ type decimal64 {
+ fraction-digits 3;
+ }
+ units "dB";
+ }
+
+ typedef severity {
+ description
+ "Severity, based on X.733 perceived severity";
+ type enumeration {
+ enum "critical" {
+ value 1;
+ }
+ enum "major" {
+ value 2;
+ }
+ enum "minor" {
+ value 3;
+ }
+ enum "warning" {
+ value 4;
+ }
+ enum "clear" {
+ value 5;
+ }
+ enum "indeterminate" {
+ value 6;
+ }
+ }
+ }
+
+ typedef rpc-status {
+ description
+ "status of RPC ";
+ type enumeration {
+ enum "Successful" {
+ value 1;
+ }
+ enum "Failed" {
+ value 2;
+ }
+ }
+ }
+
+ grouping rpc-response-status {
+ leaf status {
+ type rpc-status;
+ mandatory true;
+ description
+ "Successful or Failed";
+ }
+ leaf status-message {
+ type string;
+ description
+ "Gives a more detailed reason for failure";
+ }
+ }
+
+ typedef lifecycle-state {
+ description
+ "Lifecycle state.";
+ type enumeration {
+ enum "deployed" {
+ value 1;
+ }
+ enum "planned" {
+ value 2;
+ }
+ enum "maintenance" {
+ value 3;
+ }
+ enum "deploying" {
+ value 4;
+ }
+ enum "undeploying" {
+ value 5;
+ }
+ }
+ }
+
+ typedef state {
+ description
+ "State that indicates whether the resource is able to provide fullfill its role - carry traffic, etc.";
+ type enumeration {
+ enum "inService" {
+ value 1;
+ }
+ enum "outOfService" {
+ value 2;
+ }
+ enum "degraded" {
+ value 3;
+ }
+ }
+ }
+
+ typedef optic-types {
+ type enumeration {
+ enum "gray" {
+ value 1;
+ }
+ enum "dwdm" {
+ value 2;
+ }
+ }
+ }
+ grouping equipment-type {
+ leaf type {
+ type equipment-type-enum;
+ mandatory true;
+ config false;
+ }
+ leaf extension {
+ description
+ "Populated with equipment type when enum value is set to vendorExtension";
+ type string;
+ mandatory false;
+ config false;
+ }
+ }
+
+ typedef equipment-type-enum {
+ type enumeration {
+ enum "other" {
+ value 1;
+ }
+ enum "powerSupply" {
+ value 2;
+ }
+ enum "shelfProcessor" {
+ value 3;
+ }
+ enum "crossConnect" {
+ value 4;
+ }
+ enum "fan" {
+ value 5;
+ }
+ enum "accessPanel" {
+ value 6;
+ }
+ enum "circuitPack" {
+ value 7;
+ }
+ }
+ }
+
+ typedef optical-control-mode {
+ description
+ "Optical Control Mode: identifies specific algorithm related to power management and general optical control.";
+ type enumeration {
+ enum "power" {
+ value 1;
+ }
+ enum "gainLoss" {
+ value 2;
+ }
+ enum "off" {
+ value 3;
+ }
+ }
+ reference "openroadm.org: Open ROADM MSA Specification.";
+ }
+
+ typedef direction {
+ type enumeration {
+ enum "tx" {
+ value 1;
+ }
+ enum "rx" {
+ value 2;
+ }
+ enum "bidirectional" {
+ value 3;
+ }
+ }
+ }
+
+ typedef pm-direction {
+ type enumeration {
+ enum "tx" {
+ value 1;
+ }
+ enum "rx" {
+ value 2;
+ }
+ enum "bidirectional" {
+ value 3;
+ }
+ enum "notApplicable" {
+ value 4;
+ }
+ }
+ }
+}
--- /dev/null
+module org-openroadm-common-types {
+ namespace "http://org/openroadm/common-types";
+ prefix org-openroadm-common-types;
+
+ organization
+ "Open ROADM MSA";
+ contact
+ "OpenROADM.org";
+ description
+ "YANG definitions of common types.
+
+ Copyright of the Members of the Open ROADM MSA Agreement dated (c) 2016,
+ AT&T Intellectual Property. All other rights reserved.
+
+ Redistribution and use in source and binary forms, with or without modification,
+ are permitted provided that the following conditions are met:
+
+ * Redistributions of source code must retain the above copyright notice, this
+ list of conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions and the following disclaimer in the documentation and/or
+ other materials provided with the distribution.
+ * Neither the Members of the Open ROADM MSA Agreement nor the names of its
+ contributors may be used to endorse or promote products derived from this software
+ without specific prior written permission.
+
+ THIS SOFTWARE IS PROVIDED BY THE MEMBERS OF THE OPEN ROADM MSA AGREEMENT ''AS IS''
+ AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ IN NO EVENT THE MEMBERS OF THE OPEN ROADM MSA AGREEMENT BE LIABLE FOR ANY DIRECT,
+ INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
+ OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ POSSIBILITY OF SUCH DAMAGE";
+
+ revision 2017-09-29 {
+ description
+ "Version 2.1";
+ }
+ revision 2017-06-26 {
+ description
+ "Version 2.0";
+ }
+ revision 2016-10-14 {
+ description
+ "Version 1.2";
+ }
+
+ grouping physical-location {
+ leaf rack {
+ type string;
+ mandatory false;
+ }
+ leaf shelf {
+ type string;
+ mandatory false;
+ }
+ leaf slot {
+ type string;
+ mandatory false;
+ }
+ leaf subSlot {
+ type string;
+ mandatory false;
+ }
+ }
+
+ typedef node-types {
+ type enumeration {
+ enum "rdm" {
+ value 1;
+ }
+ enum "xpdr" {
+ value 2;
+ }
+ enum "ila" {
+ value 3;
+ }
+ enum "extplug" {
+ value 4;
+ }
+ }
+ description
+ "Identifier for node type
+ 1. rdm for ROADM
+ 2. xpdr for Transponder, Regen
+ 3. ila for in-line amplifier
+ 4. extplug for external plugable";
+ }
+
+ typedef node-id-type {
+ type string {
+ length "7..63";
+ pattern "([a-zA-Z][a-zA-Z0-9-]{5,18}[a-zA-Z0-9])" {
+ error-message
+ "A node-id must be 7 to 63 characters in length.
+ A node-id can contain letters, numbers, and hyphens.
+ The first character must be a letter.
+ The last character must be a letter or number.";
+ }
+ }
+ description
+ "Globally unique identifer for a device.";
+ }
+
+ typedef xpdr-node-types {
+ type enumeration {
+ enum "tpdr" {
+ value 1;
+ }
+ enum "mpdr" {
+ value 2;
+ }
+ enum "switch" {
+ value 3;
+ }
+ enum "regen" {
+ value 4;
+ }
+ enum "regen-uni" {
+ value 5;
+ }
+ }
+ description
+ "Identifier for Xponder node type
+ 1. Transponder
+ 2. Muxponder
+ 3. OTN switchponder
+ 4. Regenerator
+ 5. Regenerator based on unidirectional model";
+ }
+
+ typedef frequency-THz {
+ description
+ "Frequency value in THz.";
+ type decimal64 {
+ fraction-digits 8;
+ }
+ units "THz";
+ }
+
+ typedef frequency-GHz {
+ description
+ "Frequency value in GHz.";
+ type decimal64 {
+ fraction-digits 5;
+ }
+ units "GHz";
+ }
+
+ typedef power-dBm {
+ description
+ "Power value in dBm.";
+ type decimal64 {
+ fraction-digits 2;
+ }
+ units "dBm";
+ }
+
+ typedef ratio-dB {
+ description
+ "Power ratio in dB.";
+ type decimal64 {
+ fraction-digits 3;
+ }
+ units "dB";
+ }
+
+ typedef fiber-pmd {
+ description
+ "Polarization Mode Dispersion expressed in ps/km(1/2).";
+ type decimal64 {
+ fraction-digits 2;
+ }
+ units "ps/(km[1/2])";
+ }
+
+ typedef amplifier-types {
+ type enumeration {
+ enum "standard" {
+ value 1;
+ }
+ }
+ description
+ "identifier for amplifier type
+ 1. standard for amplifier as defined initially in the ROADM MSA specifications
+ To be completed if/when additional amplifier types are required ";
+ }
+
+ typedef line-amplifier-control-mode {
+ description
+ "Identifies the line amplifier control mode, either off or gain.";
+ type enumeration {
+ enum "gainLoss" {
+ value 2;
+ }
+ enum "off" {
+ value 3;
+ }
+ }
+ }
+
+ typedef amplifier-gain-range {
+ description
+ "Operational mode for the amplifier:
+ this parameter allows modeling different operational modes (gain ranges) ,notably for switched-gain amplifiers.
+ It indicates which performance model shall be used by the path feasibility engine.
+ For standard amplifier, or when performance evaluation is based on incremental noise, use gain-range-1.
+ When performance evaluation is based on advanced parameters, specify used gain-range (1 to 4).
+ Up to release 2.1, only gain-range-1 is to be used (default value) ";
+ type enumeration {
+ enum "gain-range-1" {
+ value 1;
+ }
+ enum "gain-range-2" {
+ value 2;
+ }
+ enum "gain-range-3" {
+ value 3;
+ }
+ enum "gain-range-4" {
+ value 4;
+ }
+ }
+ }
+
+ typedef severity {
+ description
+ "Severity, based on X.733 perceived severity";
+ type enumeration {
+ enum "critical" {
+ value 1;
+ }
+ enum "major" {
+ value 2;
+ }
+ enum "minor" {
+ value 3;
+ }
+ enum "warning" {
+ value 4;
+ }
+ enum "clear" {
+ value 5;
+ }
+ enum "indeterminate" {
+ value 6;
+ }
+ }
+ }
+
+ typedef activate-notification-type {
+ description
+ "Type of notification on software or database activation events";
+ type enumeration {
+ enum "activate" {
+ value 1;
+ description
+ "software or database activation";
+ }
+ enum "commit" {
+ value 2;
+ description
+ "commit the software or database.
+ For software activate, this event can happen in the following scenarios:
+ 1) immediately when user issue db-activate command without rollBackTimer
+ or if the rollBackTimer is specified as 00-00-00;
+ 2) when user issue cancel-rollback-timer before it expires and with accept=true.
+ For database activate, this event can occur in the following scenarios:
+ 1) immediately when user issue db-activate command without rollBackTimer
+ or if the rollBackTimer is specified as 00-00-00;
+ 2) when user issue cancel-rollback-timer before it expires and with accept=true.";
+ }
+ enum "cancel" {
+ value 3;
+ description
+ "cancel the database or software activation operation.
+ For software activate, this event can happen in the following cases:
+ 1) when the rollBackTimer expires;
+ 2) when the user issues cancel-rollback-timer with accept=false.
+ For database activate, this event can happen in the following cases:
+ 1) when the rollBackTimer expires;
+ 2) when the user issues cancel-rollback-timer with accept=false.";
+ }
+ }
+ }
+
+ typedef rpc-status {
+ description
+ "status of RPC ";
+ type enumeration {
+ enum "Successful" {
+ value 1;
+ }
+ enum "Failed" {
+ value 2;
+ }
+ }
+ }
+
+ grouping rpc-response-status {
+ leaf status {
+ type rpc-status;
+ mandatory true;
+ description
+ "Successful or Failed";
+ }
+ leaf status-message {
+ type string;
+ description
+ "Gives a more detailed status";
+ }
+ }
+
+ typedef extended-rpc-status {
+ description
+ "status of RPC ";
+ type enumeration {
+ enum "Successful" {
+ value 1;
+ }
+ enum "Failed" {
+ value 2;
+ }
+ enum "In-progress" {
+ value 3;
+ }
+ }
+ }
+
+ grouping extended-rpc-response-status {
+ leaf status {
+ type extended-rpc-status;
+ mandatory true;
+ description
+ "Successful, Failed or In-progress";
+ }
+ leaf status-message {
+ type string;
+ description
+ "Gives a more detailed status.";
+ }
+ }
+
+ typedef lifecycle-state {
+ description
+ "Lifecycle state.";
+ type enumeration {
+ enum "deployed" {
+ value 1;
+ }
+ enum "planned" {
+ value 2;
+ }
+ enum "maintenance" {
+ value 3;
+ }
+ enum "deploying" {
+ value 4;
+ }
+ enum "undeploying" {
+ value 5;
+ }
+ enum "undeployed" {
+ value 6;
+ }
+ enum "proposed" {
+ value 7;
+ }
+ enum "draft" {
+ value 8;
+ }
+ }
+ }
+
+ typedef state {
+ description
+ "State that indicates whether the resource is able to provide fullfill its role - carry traffic, etc.";
+ type enumeration {
+ enum "inService" {
+ value 1;
+ }
+ enum "outOfService" {
+ value 2;
+ }
+ enum "degraded" {
+ value 3;
+ }
+ }
+ }
+
+ typedef optic-types {
+ type enumeration {
+ enum "gray" {
+ value 1;
+ }
+ enum "dwdm" {
+ value 2;
+ }
+ }
+ }
+
+ grouping equipment-type {
+ leaf type {
+ type equipment-type-enum;
+ mandatory true;
+ config false;
+ }
+ leaf extension {
+ description
+ "Populated with equipment type when enum value is set to vendorExtension";
+ type string;
+ mandatory false;
+ config false;
+ }
+ }
+
+ typedef equipment-type-enum {
+ type enumeration {
+ enum "other" {
+ value 1;
+ }
+ enum "powerSupply" {
+ value 2;
+ }
+ enum "shelfProcessor" {
+ value 3;
+ }
+ enum "crossConnect" {
+ value 4;
+ }
+ enum "fan" {
+ value 5;
+ }
+ enum "accessPanel" {
+ value 6;
+ }
+ enum "circuitPack" {
+ value 7;
+ }
+ }
+ }
+
+ typedef optical-control-mode {
+ description
+ "Optical Control Mode: identifies specific algorithm related to power management and general optical control.";
+ type enumeration {
+ enum "power" {
+ value 1;
+ }
+ enum "gainLoss" {
+ value 2;
+ }
+ enum "off" {
+ value 3;
+ }
+ }
+ reference "openroadm.org: Open ROADM MSA Specification.";
+ }
+
+ typedef direction {
+ type enumeration {
+ enum "tx" {
+ value 1;
+ }
+ enum "rx" {
+ value 2;
+ }
+ enum "bidirectional" {
+ value 3;
+ }
+ enum "notApplicable" {
+ value 4;
+ }
+ }
+ }
+
+ typedef location {
+ type enumeration {
+ enum "notApplicable" {
+ value 1;
+ }
+ enum "nearEnd" {
+ value 2;
+ }
+ enum "farEnd" {
+ value 3;
+ }
+ }
+ }
+
+ typedef wavelength-duplication-type {
+ description
+ "One per srg is applied to C/D add/drop group
+ one per degree is applied to C/D/C add drop group";
+ type enumeration {
+ enum "one-per-srg" {
+ description
+ "The SRG cannot handle wavelength duplication. Attempting to provision a connection on this SRG that uses the same wavelength as an existing service will result in failure.";
+ value 1;
+ }
+ enum "one-per-degree" {
+ description
+ "The SRG can handle wavelength duplication, but only one per degree. Attempting to provision a connection on this SRG that uses the same wavelength as an existing service will succeed, so long as the connections are not using the same degree.";
+ value 2;
+ }
+ }
+ }
+
+ typedef port-qual {
+ type enumeration {
+ enum "roadm-internal" {
+ value 1;
+ }
+ enum "roadm-external" {
+ value 2;
+ }
+ enum "xpdr-network" {
+ value 3;
+ }
+ enum "xpdr-client" {
+ value 4;
+ }
+ enum "otdr" {
+ value 5;
+ }
+ enum "switch-network" {
+ value 6;
+ }
+ enum "switch-client" {
+ value 7;
+ }
+ enum "ila-external" {
+ value 8;
+ }
+ enum "ila-internal" {
+ value 9;
+ }
+ }
+ }
+
+ identity och-rate-identity {
+ description
+ "A unique och rate identification";
+ }
+
+ identity R200G {
+ base och-rate-identity;
+ description
+ "Identity for 200G Rate";
+ }
+
+ identity R100G {
+ base och-rate-identity;
+ description
+ "Identity for 100G Rate";
+ }
+
+ identity R10.7G {
+ base och-rate-identity;
+ description
+ "Identity for 10.7G Rate";
+ }
+
+ identity R11.1G {
+ base och-rate-identity;
+ description
+ "Identity for 11.1G Rate";
+ }
+
+ typedef modulation-format {
+ type enumeration {
+ enum "bpsk" {
+ value 0;
+ description
+ "binary phase-shift keying";
+ }
+ enum "dc-dp-bpsk" {
+ value 1;
+ description
+ "DC dual-polarization binary phase-shift keying";
+ }
+ enum "qpsk" {
+ value 2;
+ description
+ "quadrature phase-shift keying";
+ }
+ enum "dp-qpsk" {
+ value 3;
+ description
+ "dual-polarization binary phase-shift keying";
+ }
+ enum "qam16" {
+ value 4;
+ description
+ "quadrature amplitude modulation 16";
+ }
+ enum "dp-qam16" {
+ value 5;
+ description
+ "dual-polarization quadrature amplitude modulation 16";
+ }
+ enum "dc-dp-qam16" {
+ value 6;
+ description
+ "DC dual-polarization quadrature amplitude modulation 16";
+ }
+ enum "qam8" {
+ value 7;
+ description
+ "quadrature amplitude modulation 8";
+ }
+ enum "dp-qam8" {
+ value 8;
+ description
+ "dual-polarization quadrature amplitude modulation 8";
+ }
+ enum "dc-dp-qam8" {
+ value 9;
+ description
+ "DC dual-polarization quadrature amplitude modulation 8";
+ }
+ }
+ description
+ "Modulation format";
+ }
+}
--- /dev/null
+module org-openroadm-database {
+ namespace "http://org/openroadm/database";
+ prefix org-openroadm-database;
+
+ import org-openroadm-common-types {
+ prefix org-openroadm-common-types;
+ }
+
+ organization "Open ROADM MSA";
+ contact
+ "OpenROADM.org";
+ description
+ "This module contains definitions for System Management.
+
+ Copyright of the Members of the Open ROADM MSA Agreement dated (c) 2016,
+ AT&T Intellectual Property. All other rights reserved.
+
+ Redistribution and use in source and binary forms, with or without modification,
+ are permitted provided that the following conditions are met:
+
+ * Redistributions of source code must retain the above copyright notice, this
+ list of conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions and the following disclaimer in the documentation and/or
+ other materials provided with the distribution.
+ * Neither the Members of the Open ROADM MSA Agreement nor the names of its
+ contributors may be used to endorse or promote products derived from this software
+ without specific prior written permission.
+
+ THIS SOFTWARE IS PROVIDED BY THE MEMBERS OF THE OPEN ROADM MSA AGREEMENT ''AS IS''
+ AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ IN NO EVENT THE MEMBERS OF THE OPEN ROADM MSA AGREEMENT BE LIABLE FOR ANY DIRECT,
+ INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
+ OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ POSSIBILITY OF SUCH DAMAGE.";
+
+ revision 2016-10-14 {
+ description
+ "Version 1.2";
+ }
+
+ rpc db-backup {
+ description
+ "copy running DB to user provided file to a given path";
+ input {
+ leaf filename {
+ type string {
+ length "10..255";
+ }
+ description
+ "Path and file name is used with back-up.(xxx.DBS)";
+ }
+ }
+ output {
+ uses org-openroadm-common-types:rpc-response-status;
+ }
+ }
+ rpc db-restore {
+ description
+ "Restore database ";
+ input {
+ leaf filename {
+ type string {
+ length "10..255";
+ }
+ description
+ "PATH/file name use file name.(xxx.DBS)";
+ }
+ leaf nodeIDCheck {
+ type boolean;
+ default "true";
+ description
+ "Flag to indicate if sysNameCheck is required";
+ }
+ }
+ output {
+ uses org-openroadm-common-types:rpc-response-status;
+ }
+ }
+ rpc db-activate {
+ description
+ "activate the database";
+ input {
+ leaf rollBackTimer {
+ type string;
+ description
+ "rollbackTimer ";
+ }
+ }
+ output {
+ uses org-openroadm-common-types:rpc-response-status;
+ }
+ }
+ rpc cancel-rollback-timer {
+ description
+ "Cancel roll back timer which user provisioned as part of activate command";
+ input {
+ leaf accept {
+ type boolean;
+ description
+ " TRUE means rollback timer is cancelled and new load is accepted";
+ }
+ }
+ output {
+ uses org-openroadm-common-types:rpc-response-status;
+ }
+ }
+ rpc database-init {
+ description
+ "Initialize the database to default DB";
+ output {
+ uses org-openroadm-common-types:rpc-response-status;
+ } //output
+ }
+}
--- /dev/null
+module org-openroadm-de-operations {
+ namespace "http://org/openroadm/de/operations";
+ prefix org-openroadm-de-operations;
+
+ import org-openroadm-resource {
+ prefix org-openroadm-resource;
+ }
+
+ import org-openroadm-common-types {
+ prefix org-openroadm-common-types;
+ }
+
+ organization "Open ROADM MSA";
+ contact
+ "OpenROADM.org";
+ description
+ "YANG definitions of operations.
+
+ Copyright of the Members of the Open ROADM MSA Agreement dated (c) 2016,
+ AT&T Intellectual Property. All other rights reserved.
+
+ Redistribution and use in source and binary forms, with or without modification,
+ are permitted provided that the following conditions are met:
+
+ * Redistributions of source code must retain the above copyright notice, this
+ list of conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions and the following disclaimer in the documentation and/or
+ other materials provided with the distribution.
+ * Neither the Members of the Open ROADM MSA Agreement nor the names of its
+ contributors may be used to endorse or promote products derived from this software
+ without specific prior written permission.
+
+ THIS SOFTWARE IS PROVIDED BY THE MEMBERS OF THE OPEN ROADM MSA AGREEMENT ''AS IS''
+ AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ IN NO EVENT THE MEMBERS OF THE OPEN ROADM MSA AGREEMENT BE LIABLE FOR ANY DIRECT,
+ INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
+ OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ POSSIBILITY OF SUCH DAMAGE.";
+
+ revision 2016-10-14 {
+ description
+ "Version 1.2";
+ }
+
+ rpc restart {
+ description
+ "Restart a resource with warm/cold option. If no resource is provided or only the device name is provded, then the device itself will be restarted.
+ Note that resources on the device will not be restartable";
+ input {
+ uses org-openroadm-resource:resource;
+ leaf option{
+ type enumeration{
+ enum "warm"{
+ value 1;
+ }
+ enum "cold"{
+ value 2;
+ }
+ }
+ }
+ }
+ output {
+ uses org-openroadm-common-types:rpc-response-status;
+ }
+ }
+ notification restart-notification {
+ description
+ "This Notification is sent when a resource on a device has completed a restart. This is sent as a result of restarts triggered via the
+ restart RPC and other means. The resource identified is the from the RPC request or the equivalment if the restart was triggered another way.";
+ uses org-openroadm-resource:resource;
+ }
+}
--- /dev/null
+module org-openroadm-device-resource-types {
+ namespace "http://org/openroadm/de/device-resource-types";
+ prefix org-openroadm-device-resource-types;
+
+ organization "Open ROADM MSA";
+ contact
+ "OpenROADM.org";
+ description
+ "YANG definitions of resource types.
+
+ Copyright of the Members of the Open ROADM MSA Agreement dated (c) 2016,
+ AT&T Intellectual Property. All other rights reserved.
+
+ Redistribution and use in source and binary forms, with or without modification,
+ are permitted provided that the following conditions are met:
+
+ * Redistributions of source code must retain the above copyright notice, this
+ list of conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions and the following disclaimer in the documentation and/or
+ other materials provided with the distribution.
+ * Neither the Members of the Open ROADM MSA Agreement nor the names of its
+ contributors may be used to endorse or promote products derived from this software
+ without specific prior written permission.
+
+ THIS SOFTWARE IS PROVIDED BY THE MEMBERS OF THE OPEN ROADM MSA AGREEMENT ''AS IS''
+ AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ IN NO EVENT THE MEMBERS OF THE OPEN ROADM MSA AGREEMENT BE LIABLE FOR ANY DIRECT,
+ INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
+ OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ POSSIBILITY OF SUCH DAMAGE.";
+
+ revision 2016-10-14 {
+ description
+ "Version 1.2";
+ }
+
+/* Currently not used; if used later, needs to move to org-openroadm-device.yang so leafref can be resolved.
+ grouping device-id {
+ description
+ "Device identifier. Unique within the Controller.";
+ leaf node-id {
+ description
+ "Node Id. Globally unique identifier for a device.";
+ type leafref {
+ path "/org-openroadm-device/info/node-id";
+ }
+ mandatory true;
+ }
+ }
+*/
+
+/* Currently not used; if used later, needs to move to org-openroadm-device.yang so leafref can be resolved.
+ grouping shelf-name {
+ leaf shelf-name {
+ description
+ "Shelf identifier. Unique within the context of a device.";
+ type leafref {
+ path "/org-openroadm-device/shelves/shelf-name";
+ }
+ mandatory true;
+ config false;
+ }
+ }
+*/
+
+/* Currently not used; if used later, needs to move to org-openroadm-device.yang so leafref can be resolved.
+ grouping physical-link-name {
+ leaf physical-link-name {
+ description
+ "Physical Link identifier. Unique within the context of a device.";
+ type leafref {
+ path "/org-openroadm-device/physical-link/physical-link-name";
+ }
+ mandatory true;
+ config false;
+ }
+ }
+*/
+
+/* Currently not used; if used later, needs to move to org-openroadm-device.yang so leafref can be resolved.
+ grouping internal-link-name {
+ uses org-openroadm-device:circuit-pack-name;
+ leaf internal-link-name {
+ description
+ "Internal Link identifier. Unique within the context of a circuit pack.";
+ type leafref {
+ path "/org-openroadm-device/internal-link/internal-link-name";
+ }
+ mandatory true;
+ config false;
+ }
+ }
+*/
+
+/* Currently not used; if used later, needs to move to org-openroadm-device.yang so leafref can be resolved.
+ grouping connection-number {
+ leaf connection-number {
+ description
+ "Connection identifier. Unique within the context of a device.";
+ type leafref {
+ path "/org-openroadm-device/connections/connection-number";
+ }
+ }
+ }
+*/
+
+/* Currently not used; if used later, needs to move to org-openroadm-device.yang so leafref can be resolved.
+ grouping this-will-test-ids {
+ uses device-id;
+ container shelf {
+ uses shelf-name;
+ }
+ container circuit-pack {
+ uses org-openroadm-device:circuit-pack-name;
+ }
+ container port {
+ uses org-openroadm-device:port-name;
+ }
+ uses internal-link-name;
+ uses physical-link-name;
+ uses connection-number;
+ uses org-openroadm-device:srg-number;
+ uses org-openroadm-device:degree-number;
+ }
+*/
+
+/* Currently not used; if used later, needs to move to org-openroadm-device.yang so leafref can be resolved.
+ grouping xponder-device-id {
+ description
+ "Xponder identifier. Unique within the Controller.";
+ leaf node-id {
+ description
+ "Xponder Id. Globally unique identifier for the device";
+ type leafref {
+ path "/org-openroadm-device/info/node-id";
+ }
+ mandatory true;
+ }
+ }
+*/
+
+/* Currently not used; if used later, needs to move to org-openroadm-device.yang so leafref can be resolved.
+ grouping xponder-number {
+ leaf xponder-number {
+ description
+ "Xponder identifier. Unique within the context of a device.";
+ type leafref {
+ path "/org-openroadm-device/xponders/xponder-number";
+ }
+ config false;
+ }
+ }
+*/
+
+/* Currently not used; if used later, needs to move to org-openroadm-device.yang so leafref can be resolved.
+ grouping xponder-shelf-name {
+ uses xponder-number;
+ leaf shelf-name {
+ description
+ "Shelf identifier. Unique within the context of a device.";
+ type leafref {
+ path "/org-openroadm-device/xponders[xponder-number=current()/../xponder-number]/shelves/shelf-name";
+ }
+ mandatory true;
+ config false;
+ }
+ }
+*/
+
+/* Currently not used; if used later, needs to move to org-openroadm-device.yang so leafref can be resolved.
+ grouping xponder-circuit-pack-name {
+ uses xponder-number;
+ leaf circuit-pack-name {
+ description
+ "Circuit Pack identifier. Unique within the context of a xponder.";
+ type leafref {
+ path "/org-openroadm-device/circuit-packs/circuit-pack-name";
+ }
+ config false;
+ }
+ }
+*/
+
+/* Currently not used; if used later, needs to move to org-openroadm-device.yang so leafref can be resolved.
+ grouping xponder-port-name {
+ uses xponder-circuit-pack-name;
+ leaf port-name {
+ description
+ "Port identifier. Unique within the context of a circuit-pack.";
+ type leafref {
+ path "/org-openroadm-device/circuit-packs[circuit-pack-name=current()/../circuit-pack-name]/ports/port-name";
+ }
+ config false;
+ }
+ }
+*/
+
+/* Currently not used; if used later, needs to move to org-openroadm-device.yang so leafref can be resolved.
+ grouping this-will-test-xponder-ids {
+ uses xponder-device-id;
+ container shelf {
+ uses xponder-shelf-name;
+ }
+ container circuit-pack {
+ uses xponder-circuit-pack-name;
+ }
+ container port {
+ uses xponder-port-name;
+ }
+ }
+*/
+}
--- /dev/null
+module org-openroadm-device {
+ namespace "http://org/openroadm/device";
+ prefix org-openroadm-device;
+
+ import ietf-yang-types {
+ prefix ietf-yang-types;
+ }
+ import ietf-inet-types {
+ prefix ietf-inet-types;
+ }
+ import ietf-netconf {
+ prefix ietf-nc;
+ }
+ import org-openroadm-common-types {
+ prefix org-openroadm-common-types;
+ revision-date 2016-10-14;
+ }
+ import org-openroadm-resource-types {
+ prefix org-openroadm-resource-types;
+ }
+ import org-openroadm-wavelength-map {
+ prefix org-openroadm-wavelength-map;
+ }
+ import org-openroadm-physical-types {
+ prefix org-openroadm-physical-types;
+ }
+ import org-openroadm-user-mgmt {
+ prefix org-openroadm-user-mgmt;
+ }
+ import org-openroadm-port-types {
+ prefix org-openroadm-port-types;
+ }
+ import org-openroadm-interfaces {
+ prefix org-openroadm-interfaces;
+ }
+ import org-openroadm-swdl {
+ prefix org-openroadm-swdl;
+ }
+ import org-openroadm-equipment-states-types {
+ prefix org-openroadm-equipment-states-types;
+ }
+
+ organization "Open ROADM MSA";
+ contact
+ "OpenROADM.org";
+ description
+ "YANG definitions of ROADM device
+
+ Copyright of the Members of the Open ROADM MSA Agreement dated (c) 2016,
+ AT&T Intellectual Property. All other rights reserved.
+
+ Redistribution and use in source and binary forms, with or without modification,
+ are permitted provided that the following conditions are met:
+
+ * Redistributions of source code must retain the above copyright notice, this
+ list of conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions and the following disclaimer in the documentation and/or
+ other materials provided with the distribution.
+ * Neither the Members of the Open ROADM MSA Agreement nor the names of its
+ contributors may be used to endorse or promote products derived from this software
+ without specific prior written permission.
+
+ THIS SOFTWARE IS PROVIDED BY THE MEMBERS OF THE OPEN ROADM MSA AGREEMENT ''AS IS''
+ AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ IN NO EVENT THE MEMBERS OF THE OPEN ROADM MSA AGREEMENT BE LIABLE FOR ANY DIRECT,
+ INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
+ OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ POSSIBILITY OF SUCH DAMAGE.
+
+ Also contains code components extracted from IETF netconf. These code components
+ are copyrighted and licensed as follows:
+
+ Copyright (c) 2016 IETF Trust and the persons identified as the document authors.
+ All rights reserved.
+
+ This document is subject to BCP 78 and the IETF Trust’s Legal Provisions Relating
+ to IETF Documents (http://trustee.ietf.org/license-info) in effect on the date of
+ publication of this document. Please review these documents carefully, as they
+ describe your rights and restrictions with respect to this document. Code Components
+ extracted from this document must include Simplified BSD License text as described in
+ Section 4.e of the Trust Legal Provisions and are provided without warranty as
+ described in the Simplified BSD License.";
+
+ revision 2017-02-06 {
+ description
+ "Version 1.2.1 - removed pattern for current-datetime in info tree and rpc";
+ }
+
+ revision 2016-10-14 {
+ description
+ "Version 1.2";
+ }
+
+ rpc get-connection-port-trail {
+ input {
+ leaf connection-number {
+ type string;
+ mandatory true;
+ }
+ }
+ output {
+ uses org-openroadm-common-types:rpc-response-status;
+ list ports {
+ uses org-openroadm-common-types:physical-location;
+ uses port-name {
+ refine "circuit-pack-name" {
+ mandatory true;
+ }
+ refine "port-name" {
+ mandatory true;
+ }
+ }
+ }
+ }
+ }
+ rpc disable-automatic-shutoff {
+ input {
+ leaf amp {
+ type leafref {
+ path "/org-openroadm-device/shelves/shelf-name";
+ }
+ mandatory true;
+ description
+ "The shelf where amp is located";
+ }
+ leaf degree-number {
+ type uint16;
+ mandatory true;
+ }
+ leaf support-timer {
+ type uint16 {
+ range "1..600";
+ }
+ default "20";
+ }
+ }
+ output {
+ uses org-openroadm-common-types:rpc-response-status;
+ }
+ }
+ rpc start-scan {
+ input {
+ leaf degree-number {
+ type uint16;
+ mandatory true;
+ }
+ leaf port-direction {
+ type org-openroadm-common-types:direction;
+ }
+ leaf distance {
+ type uint32;
+ }
+ leaf resolution {
+ type uint32;
+ }
+ }
+ output {
+ uses org-openroadm-common-types:rpc-response-status;
+ }
+ }
+
+ notification otdr-scan-result {
+ leaf status {
+ type enumeration {
+ enum "Completed" {
+ value 1;
+ }
+ enum "Failed" {
+ value 2;
+ }
+ }
+ mandatory true;
+ description
+ "Completed or Failed for the scan's final status";
+ }
+ leaf result-file {
+ type string;
+ }
+ }
+
+ rpc set-current-datetime {
+ description
+ "Set the info/current-datetime leaf to the specified value.";
+ input {
+ leaf current-datetime {
+ type ietf-yang-types:date-and-time;
+ mandatory true;
+ description
+ "The current system date and time in UTC. Format: YYYY-MM-DDTHH:MM:SS";
+ }
+ }
+
+ output {
+ uses org-openroadm-common-types:rpc-response-status;
+ }
+ }
+
+ grouping device-common {
+ leaf node-id {
+ type string;
+ description
+ "Globally unique identifer for a device.";
+ default "openroadm";
+ }
+ leaf node-number {
+ type uint32;
+ description
+ "Number assigned to a ROADM node at a
+ given office";
+ }
+ leaf node-type {
+ type org-openroadm-common-types:node-types;
+ description
+ "Identifier for node-type e.g Roadm, xponder";
+ config false;
+ mandatory true;
+ }
+ leaf clli {
+ type string;
+ description
+ "Common Language Location Identifier.";
+ }
+ uses org-openroadm-physical-types:node-info;
+ leaf ipAddress {
+ type ietf-inet-types:ip-address;
+ description
+ "IP Address of device";
+ }
+ leaf prefix-length {
+ type uint8 {
+ range "0..128";
+ }
+ description
+ "The length of the subnet prefix";
+ }
+ leaf defaultGateway {
+ type ietf-inet-types:ip-address;
+ description
+ "Default Gateway";
+ }
+ leaf source {
+ type enumeration {
+ enum "static" {
+ value 1;
+ }
+ enum "dhcp" {
+ value 2;
+ }
+ }
+ config false;
+ }
+ leaf current-ipAddress {
+ type ietf-inet-types:ip-address;
+ config false;
+ description
+ "Current IP Address of device";
+ }
+ leaf current-prefix-length {
+ type uint8 {
+ range "0..128";
+ }
+ config false;
+ description
+ "The current length of the subnet prefix";
+ }
+ leaf current-defaultGateway {
+ type ietf-inet-types:ip-address;
+ config false;
+ description
+ "Current Default Gateway";
+ }
+ leaf macAddress {
+ type ietf-yang-types:mac-address;
+ description
+ "MAC Address of device";
+ config false;
+ }
+ leaf softwareVersion {
+ type string;
+ config false;
+ description
+ "Software version";
+ }
+ leaf template {
+ type string;
+ description
+ "Template information used in the deployment.";
+ }
+ leaf current-datetime {
+ type ietf-yang-types:date-and-time;
+ config false;
+ description
+ "The current system date and time in UTC. Format: YYYY-MM-DDTHH:MM:SS.mm+ ";
+ }
+ container geoLocation {
+ description
+ "GPS location";
+ leaf latitude {
+ type decimal64 {
+ fraction-digits 16;
+ range "-90 .. 90";
+ }
+ description
+ "[From wikipedia] Latitude is an angle (defined below)
+ which ranges from 0° at the Equator to 90° (North or
+ South) at the poles";
+ }
+ leaf longitude {
+ type decimal64 {
+ fraction-digits 16;
+ range "-180 .. 180";
+ }
+ description
+ "[From wikipedia] The longitude is measured as the
+ angle east or west from the Prime Meridian, ranging
+ from 0° at the Prime Meridian to +180° eastward and
+ −180° westward.";
+ }
+ }
+ }
+
+ grouping slot-info {
+ description
+ "slots information. To be populated by NE during retrieval.";
+ leaf slot-name {
+ type string;
+ description
+ "The name of this slot.";
+ }
+ leaf label {
+ type string;
+ description
+ "Faceplate label";
+ }
+ leaf provisioned-circuit-pack {
+ type leafref {
+ path "/org-openroadm-device/circuit-packs/circuit-pack-name";
+ }
+ description
+ "The supported circuit-pack. It will be empty if no provision on this slot.";
+ }
+ }
+ grouping shelves {
+ list shelves {
+ key "shelf-name";
+ uses shelf;
+ }
+ }
+ grouping shelf {
+ leaf shelf-name {
+ description
+ "Unique identifier for this shelf within a device";
+ type string;
+ }
+ leaf shelf-type {
+ description
+ "The shelf type: describe the shelf with a unique string.";
+ type string;
+ mandatory true;
+ }
+ leaf rack {
+ description
+ "Reflect the shelf physical location data including floor, aisle, bay values.";
+ type string;
+ }
+ leaf shelf-position {
+ description
+ "Reflect the shelf vertical position within an equipment bay.";
+ type string;
+ }
+ leaf administrative-state {
+ description
+ "Admin State of the shelf";
+ type org-openroadm-equipment-states-types:admin-states;
+ }
+ uses org-openroadm-physical-types:common-info;
+ leaf equipment-state {
+ type org-openroadm-equipment-states-types:states;
+ description
+ "equipment state for the shelf, used to track the lifecycle state.";
+ }
+ leaf due-date {
+ type ietf-yang-types:date-and-time;
+ description
+ "due date for the shelf.";
+ }
+ list slots {
+ description
+ "List of slots on this shelf. To be populated by NE during retrieval.";
+ key "slot-name";
+ config false;
+ uses slot-info;
+ }
+ }
+
+ grouping circuit-packs {
+ list circuit-packs {
+ description
+ "List of circuit packs. This includes common equipment, like fans, power supplies, etc.";
+ key "circuit-pack-name";
+ leaf circuit-pack-type {
+ description
+ "Type of circuit-pack";
+ type string;
+ mandatory true;
+ }
+ leaf circuit-pack-product-code {
+ description
+ "Product Code for the circuit-pack";
+ type string;
+ }
+ uses circuit-pack;
+ }
+ }
+
+ grouping circuit-pack {
+ leaf circuit-pack-name {
+ description
+ "Unique identifier for this circuit-pack within a device";
+ type string;
+ }
+ leaf administrative-state {
+ description
+ "Administrative state of circuit-pack";
+ type org-openroadm-equipment-states-types:admin-states;
+ }
+ uses org-openroadm-physical-types:common-info;
+ container circuit-pack-category {
+ description
+ "General type of circuit-pack";
+ uses org-openroadm-common-types:equipment-type;
+ config false;
+ }
+ leaf equipment-state {
+ description
+ "Equipment state, which complements operational state.";
+ type org-openroadm-equipment-states-types:states;
+ }
+ leaf circuit-pack-mode {
+ description
+ "Circuit-pack mode allowed. e.g. NORMAL or REGEN";
+ type string;
+ default "NORMAL";
+ }
+ leaf shelf {
+ type leafref {
+ path "/org-openroadm-device/shelves/shelf-name";
+ }
+ mandatory true;
+ }
+ leaf slot {
+ type string;
+ mandatory true;
+ }
+ leaf subSlot {
+ type string;
+ mandatory false;
+ }
+ leaf due-date {
+ type ietf-yang-types:date-and-time;
+ description
+ "due date for this circuit-pack.";
+ }
+ container parent-circuit-pack {
+ description
+ "In the case of circuit packs that contain other equipment (modules or pluggables), this captures the hierarchy of that equipment. It is a vendor specific design decision if the ports for single-port pluggables are modeled as children of the parent circuit-pack, or as children of the pluggable circuit-pack contained in the parent circuit-pack. For modules with multiple ports, it is recommended that ports be children of the module and not the carrier, to help in fault correlation and isolation in the case of a module failure.";
+ uses circuit-pack-name;
+ leaf cp-slot-name {
+ type string;
+ description
+ "Slot name on parent-circuit-pack.";
+ }
+ }
+ list cp-slots {
+ description
+ "List of circuit-pack slots on this circuit-pack. To be populated by NE during retrieval.";
+ key "slot-name";
+ config false;
+ uses slot-info;
+ }
+ list ports {
+ key "port-name";
+ description
+ "List of ports on this circuit-pack. For single port pluggables, the port may be modeled against the pluggable itself, or against the parent-circuit-pack. For mulit-port pluggables, it is recommended that ports be modeled against the module itself. Modeling ports as close to the equipment hierarchy as possible will help in fault correlation and isolation since common failures associated with supporting equipment can be used to help identify symptomatic failures on the contained ports.";
+ uses port;
+ container roadm-port {
+ when "../port-qual='roadm-external'";
+ uses org-openroadm-port-types:roadm-port;
+ }
+ container transponder-port {
+ when "../port-qual='xpdr-network' or ../port-qual='xpdr-client'";
+ uses org-openroadm-port-types:common-port;
+ }
+ container otdr-port {
+ when "../port-qual='otdr'";
+ description
+ "Settings for otdr port.";
+ leaf launch-cable-length {
+ type uint32;
+ default "30";
+ units "m";
+ }
+ leaf port-direction {
+ type org-openroadm-common-types:direction;
+ }
+ }
+ }
+ }
+
+ grouping connection {
+ description
+ "Grouping used to define connections.";
+ leaf connection-number {
+ type string;
+ }
+ leaf wavelength-number {
+ type uint32;
+ mandatory true;
+ description
+ "wavelength-number, can be used to access wavelength-map
+ to get wavelength value in nm.";
+ }
+ leaf opticalControlMode {
+ description
+ "Whether connection is currently in power or gain/loss mode";
+ type org-openroadm-common-types:optical-control-mode;
+ reference "openroadm.org: Open ROADM MSA Specification.";
+ default "off";
+ }
+ leaf target-output-power {
+ type org-openroadm-common-types:power-dBm;
+ description
+ "The output target power for this connection. When set, the ROADM will work to ensure that current-output-power reaches this level.";
+ }
+ container source {
+ leaf src-if {
+ type leafref {
+ path "/org-openroadm-device/interface/name";
+ }
+ mandatory true;
+ }
+ }
+ container destination {
+ leaf dst-if {
+ type leafref {
+ path "/org-openroadm-device/interface/name";
+ }
+ mandatory true;
+ }
+ }
+ }
+
+ grouping degree {
+ leaf degree-number {
+ type uint16;
+ must "not( current() > /org-openroadm-device/info/max-degrees) and current() > 0" {
+ error-message "Degree not supported by device ";
+ description
+ "Validating if the degree is supported by device";
+ }
+ }
+ leaf max-wavelengths {
+ type uint16;
+ description
+ "maximum number of wavelengths";
+ config false;
+ mandatory true;
+ }
+ list circuit-packs {
+ key "index";
+ description
+ "list for Cards associated with a degree";
+ leaf index {
+ type uint32;
+ }
+ uses circuit-pack-name {
+ refine "circuit-pack-name" {
+ mandatory true;
+ }
+ }
+ }
+ list connection-ports {
+ description
+ "Port associated with degree: One if bi-directional; two if uni-directional";
+ key "index";
+ leaf index {
+ type uint32;
+ }
+ uses port-name {
+ refine "circuit-pack-name" {
+ mandatory true;
+ }
+ refine "port-name" {
+ mandatory true;
+ }
+ }
+ }
+ container otdr-port {
+ description
+ "otdr port associated with degree.";
+ uses port-name;
+ }
+ }
+
+ grouping external-links {
+ description
+ "YANG definitions for external links..
+ - physical links between ROADMs and between the ROADMs and XPonders, which can be added and removed maually.";
+ list external-link {
+ key "external-link-name";
+ uses external-link;
+ }
+ }
+
+ grouping external-link {
+ leaf external-link-name {
+ type string;
+ }
+ container source {
+ uses org-openroadm-resource-types:device-id {
+ refine "node-id" {
+ mandatory true;
+ }
+ }
+ uses org-openroadm-resource-types:port-name {
+ refine "circuit-pack-name" {
+ mandatory true;
+ }
+ refine "port-name" {
+ mandatory true;
+ }
+ }
+ }
+ container destination {
+ uses org-openroadm-resource-types:device-id {
+ refine "node-id" {
+ mandatory true;
+ }
+ }
+ uses org-openroadm-resource-types:port-name {
+ refine "circuit-pack-name" {
+ mandatory true;
+ }
+ refine "port-name" {
+ mandatory true;
+ }
+ }
+ }
+ }
+
+ grouping internal-links {
+ list internal-link {
+ key "internal-link-name";
+ config false;
+ uses internal-link;
+ }
+ }
+
+ grouping internal-link {
+ leaf internal-link-name {
+ type string;
+ }
+ container source {
+ uses port-name {
+ refine "circuit-pack-name" {
+ mandatory true;
+ }
+ refine "port-name" {
+ mandatory true;
+ }
+ }
+ }
+ container destination {
+ uses port-name {
+ refine "circuit-pack-name" {
+ mandatory true;
+ }
+ refine "port-name" {
+ mandatory true;
+ }
+ }
+ }
+ }
+
+ grouping physical-links {
+ description
+ "YANG definitions for physical links.
+ - phyical links between cards within a ROADM, which are populated by the ROADM and cannot be added or removed manually. ";
+ list physical-link {
+ key "physical-link-name";
+ uses physical-link;
+ }
+ }
+
+ grouping physical-link {
+ leaf physical-link-name {
+ type string;
+ }
+ container source {
+ uses port-name {
+ refine "circuit-pack-name" {
+ mandatory true;
+ }
+ refine "port-name" {
+ mandatory true;
+ }
+ }
+ }
+ container destination {
+ uses port-name {
+ refine "circuit-pack-name" {
+ mandatory true;
+ }
+ refine "port-name" {
+ mandatory true;
+ }
+ }
+ }
+ }
+
+ grouping srg {
+ leaf max-add-drop-ports {
+ type uint16;
+ config false;
+ mandatory true;
+ }
+ leaf srg-number {
+ type uint16;
+ must "not(current()>/org-openroadm-device/info/max-srgs) and current()>0" {
+ error-message "invalid SRG";
+ description
+ "Validating if the srg is supported by add/drop group";
+ }
+ }
+ leaf wavelengthDuplication {
+ description
+ "Whether the SRG can handle duplicate wavelengths and if so to what extent.";
+ config false;
+ mandatory true;
+ type enumeration {
+ enum "onePerSRG" {
+ description
+ "The SRG cannot handle wavelength duplication. Attempting to provision a connection on this SRG that uses the same wavelength as an existing service will result in failure.";
+ value 1;
+ }
+ enum "onePerDegree" {
+ description
+ "The SRG can handle wavelength duplication, but only one per degree. Attempting to provision a connection on this SRG that uses the same wavelength as an existing service will succeed, so long as the connections are not using the same degree.";
+ value 2;
+ }
+ }
+ }
+ list circuit-packs {
+ key "index";
+ description
+ "list for Cards associated with an add/drop group and srg";
+ leaf index {
+ type uint32;
+ }
+ uses circuit-pack-name {
+ refine "circuit-pack-name" {
+ mandatory true;
+ }
+ }
+ }
+ }
+
+ grouping degree-number {
+ leaf degree-number {
+ description
+ "Degree identifier. Unique within the context of a device.";
+ type leafref {
+ path "/org-openroadm-device/degree/degree-number";
+ }
+ }
+ }
+
+ grouping circuit-pack-name {
+ leaf circuit-pack-name {
+ description
+ "Circuit-Pack identifier. Unique within the context of a device.";
+ type leafref {
+ path "/org-openroadm-device/circuit-packs/circuit-pack-name";
+ }
+ }
+ }
+
+ grouping port-name {
+ uses circuit-pack-name;
+ leaf port-name {
+ description
+ "Port identifier. Unique within the context of a circuit-pack.";
+ type leafref {
+ path "/org-openroadm-device/circuit-packs[circuit-pack-name=current()/../circuit-pack-name]/ports/port-name";
+ }
+ }
+ }
+
+ grouping srg-number {
+ leaf srg-number {
+ description
+ "Shared Risk Group identifier. Unique within the context of a device.";
+ type leafref {
+ path "/org-openroadm-device/shared-risk-group/srg-number";
+ }
+ }
+ }
+
+ grouping supporting-port-name {
+ leaf supporting-circuit-pack-name {
+ description
+ "Identifier of the supporting circuit-pack.";
+ type leafref {
+ path "/org-openroadm-device/circuit-packs/circuit-pack-name";
+ }
+ mandatory true;
+ }
+ leaf supporting-port {
+ description
+ "Identifier of the supporting port.";
+ mandatory true;
+ type leafref {
+ path "/org-openroadm-device/circuit-packs[circuit-pack-name=current()/../supporting-circuit-pack-name]/ports/port-name";
+ }
+ }
+ }
+
+ grouping interface-name {
+ leaf interface-name {
+ description
+ "Name of an interface. Unique within the context of a device.";
+ type leafref {
+ path "/org-openroadm-device/interface/name";
+ }
+ config false;
+ }
+ }
+
+ grouping interfaces-grp {
+ description
+ "OpenROADM Interface configuration parameters.";
+ list interface {
+ key "name";
+ description
+ "The list of configured interfaces on the device.";
+ leaf name {
+ type string;
+ description
+ "The name of the interface.";
+ }
+ leaf description {
+ type string;
+ description
+ "A textual description of the interface.";
+ }
+ leaf type {
+ type identityref {
+ base org-openroadm-interfaces:interface-type;
+ }
+ mandatory true;
+ description
+ "The type of the interface.";
+ }
+ leaf administrative-state {
+ type org-openroadm-equipment-states-types:admin-states;
+ }
+ leaf operational-state {
+ type org-openroadm-common-types:state;
+ config false;
+ }
+ leaf circuit-id {
+ type string {
+ length "0..45";
+ }
+ description
+ "circuit identifier/user label,
+ can be used in alarm correlation and/or connection management ";
+ }
+ leaf supporting-interface {
+ type leafref {
+ path "/org-openroadm-device/interface/name";
+ }
+ }
+ uses supporting-port-name;
+ }
+ }
+
+ grouping port {
+ description
+ "Grouping of attributes related to a port object.";
+ leaf port-name {
+ type string;
+ mandatory true;
+ description
+ "Identifier for a port, unique within a circuit pack";
+ }
+ leaf port-type {
+ type string;
+ description
+ "Type of the pluggable or fixed port.";
+ }
+ leaf port-qual {
+ type enumeration {
+ enum "roadm-internal" {
+ value 1;
+ }
+ enum "roadm-external" {
+ value 2;
+ }
+ enum "xpdr-network" {
+ value 3;
+ }
+ enum "xpdr-client" {
+ value 4;
+ }
+ enum "otdr" {
+ value 5;
+ }
+ }
+ }
+ leaf port-wavelength-type {
+ type org-openroadm-port-types:port-wavelength-types;
+ config false;
+ description
+ "Type of port - single, multiple-wavelength, etc.";
+ }
+ leaf port-direction {
+ type org-openroadm-common-types:direction;
+ config false;
+ mandatory true;
+ description
+ "Whether port is uni (tx/rx) or bi-directional and";
+ }
+ leaf label {
+ type string;
+ config false;
+ description
+ "Faceplate label";
+ }
+ leaf circuit-id{
+ type string{
+ length "0..45";
+ }
+ description
+ "circuit identifier/user label,
+ can be used in alarm correlation and/or connection management ";
+
+ }
+ leaf administrative-state {
+ type org-openroadm-equipment-states-types:admin-states;
+ description
+ "Administrative state of port. The value of this field independant of the state of its contained and containing resources. Setting this a port to administratively down will impact both its operational state, as well the operational state of its contained resources. If this port is an endpoint to a connection, internal-link, physical-link, etc, then administratevely disabling this port will impact the operational state of those items unless they are using some form of port-protection schema.";
+ default "outOfService";
+ }
+ leaf operational-state {
+ type org-openroadm-common-types:state;
+ config false;
+ mandatory true;
+ description
+ "Operational state of a port";
+ }
+ leaf-list supported-interface-capability {
+ description
+ "Interface types supported on this port";
+ config false;
+ type identityref {
+ base org-openroadm-port-types:supported-if-capability;
+ }
+ }
+ leaf logical-connection-point {
+ type string;
+ description
+ "delete or replace with list logical-ports or connections?";
+ }
+ container partner-port {
+ config false;
+ description
+ "For ports which are not identified as having a direction of bidirectional, this field is used to identify the port which corresponds to the reverse direction. A port pair should include a port for each direction (tx, rx) and report their mate as partner-port.";
+ uses port-name;
+ }
+ container parent-port {
+ config false;
+ description
+ "In the case of port hierarchy, this is the parent port, which is also modeled as port within this circuit-pack. This is used in the case of a port that supports a parallel connector that contains subports. The parent-port of the subport will be the port that contains this subport. This can be used to help isolate faults when a single fault on a parallel connector introduces symptomatic failures on the contained subports.";
+ uses port-name;
+ }
+ list interfaces {
+ config false;
+ description
+ "List of the interfaces this port supports. This is a list of names of instances in the flat instance list";
+ uses interface-name;
+ }
+ }
+
+ uses org-openroadm-device-container;
+
+ grouping org-openroadm-device-container {
+ container org-openroadm-device {
+ container info {
+ uses device-common;
+ leaf max-degrees {
+ type uint16;
+ description
+ "Max. number of degrees supported by device";
+ config false;
+ }
+ leaf max-srgs {
+ type uint16;
+ description
+ "Max. number of SRGs in an add/drop group";
+ config false;
+ }
+ }
+ container users {
+ description
+ "Stores a list of users";
+ uses org-openroadm-user-mgmt:user-profile;
+ }
+ container pending-sw {
+ config false;
+ uses org-openroadm-swdl:sw-bank;
+ }
+ uses shelves;
+ uses circuit-packs;
+ uses interfaces-grp;
+ container protocols {
+ description
+ "Contains the supported protocols";
+ }
+ container wavelength-map {
+ description
+ "The wavelength-number and center frequency, wavelength mapping";
+ config false;
+ uses org-openroadm-wavelength-map:wavelength-map-g;
+ }
+ uses internal-links;
+ uses physical-links;
+ uses external-links;
+ list degree {
+ when "/org-openroadm-device/info/node-type='rdm'";
+ key "degree-number";
+ uses degree;
+ }
+ list shared-risk-group {
+ when "/org-openroadm-device/info/node-type='rdm'";
+ key "srg-number";
+ uses srg;
+ }
+ list roadm-connections {
+ when "/org-openroadm-device/info/node-type='rdm'";
+ key "connection-number";
+ uses connection;
+ }
+ list connection-map {
+ key "connection-map-number";
+ config false;
+ leaf connection-map-number {
+ description
+ "Unique identifier for this connection-map entry";
+ type uint32;
+ }
+ container source {
+ leaf circuit-pack-name {
+ type leafref {
+ path "/org-openroadm-device/circuit-packs/circuit-pack-name";
+ }
+ mandatory true;
+ }
+ leaf port-name {
+ description
+ "Port identifier. Unique within the context of a circuit-pack.";
+ type leafref {
+ path "/org-openroadm-device/circuit-packs[circuit-pack-name=current()/../circuit-pack-name]/ports/port-name";
+ }
+ mandatory true;
+ }
+ }
+ list destination {
+ key "circuit-pack-name port-name";
+ min-elements 1;
+ leaf circuit-pack-name {
+ type leafref {
+ path "/org-openroadm-device/circuit-packs/circuit-pack-name";
+ }
+ mandatory true;
+ }
+ leaf port-name {
+ description
+ "Port identifier. Unique within the context of a circuit-pack.";
+ type leafref {
+ path "/org-openroadm-device/circuit-packs[circuit-pack-name=current()/../circuit-pack-name]/ports/port-name";
+ }
+ mandatory true;
+ }
+ }
+ }
+ }
+ }
+
+ grouping common-session-parms {
+ description
+ "Common session parameters to identify a
+ management session.";
+
+ leaf username {
+ type string;
+ mandatory true;
+ description
+ "Name of the user for the session.";
+ }
+
+ leaf session-id {
+ type ietf-nc:session-id-or-zero-type;
+ mandatory true;
+ description
+ "Identifier of the session.
+ A NETCONF session MUST be identified by a non-zero value.
+ A non-NETCONF session MAY be identified by the value zero.";
+ }
+
+ leaf source-host {
+ type ietf-inet-types:ip-address;
+ description
+ "Address of the remote host for the session.";
+ }
+ }
+ grouping changed-by-parms {
+ description
+ "Common parameters to identify the source
+ of a change event, such as a configuration
+ or capability change.";
+
+ container changed-by {
+ description
+ "Indicates the source of the change.
+ If caused by internal action, then the
+ empty leaf 'server' will be present.
+ If caused by a management session, then
+ the name, remote host address, and session ID
+ of the session that made the change will be reported.";
+ choice server-or-user {
+ leaf server {
+ type empty;
+ description
+ "If present, the change was caused
+ by the server.";
+ }
+
+ case by-user {
+ uses common-session-parms;
+ }
+ } // choice server-or-user
+ } // container changed-by-parms
+ }
+ notification change-notification {
+ description
+ "The Notification that a resource has been added, modified or removed.
+ This notification can be triggered by changes in configuration and operational data.
+ It shall contain the changed field pointed by the xpath.
+ Typically it is not intended for frequently changing volatile data e.g. PM, power levels";
+
+ leaf change-time {
+ description "The time the change occurs.";
+ type ietf-yang-types:date-and-time;
+ }
+ uses changed-by-parms;
+
+ leaf datastore {
+ type enumeration {
+ enum running {
+ description "The <running> datastore has changed.";
+ }
+ enum startup {
+ description "The <startup> datastore has changed";
+ }
+ }
+ default "running";
+ description
+ "Indicates which configuration datastore has changed.";
+ }
+ list edit {
+ description
+ "An edit (change) record SHOULD be present for each distinct
+ edit operation that the server has detected on
+ the target datastore. This list MAY be omitted
+ if the detailed edit operations are not known.
+ The server MAY report entries in this list for
+ changes not made by a NETCONF session.";
+
+ leaf target {
+ type instance-identifier;
+ description
+ "Topmost node associated with the configuration or operationa change.
+ A server SHOULD set this object to the node within
+ the datastore that is being altered. A server MAY
+ set this object to one of the ancestors of the actual
+ node that was changed, or omit this object, if the
+ exact node is not known.";
+ }
+ leaf operation {
+ type ietf-nc:edit-operation-type;
+ description
+ "Type of edit operation performed.
+ A server MUST set this object to the NETCONF edit
+ operation performed on the target datastore.";
+ }
+ } // list edit
+ } // notification change-notification
+}
\ No newline at end of file
--- /dev/null
+module org-openroadm-equipment-states-types {
+ namespace "http://org/openroadm/equipment/states/types";
+ prefix org-openroadm-equipment-states-types;
+
+ organization "Open ROADM MSA";
+ contact
+ "OpenROADM.org";
+ description
+ "YANG definitions for types of states of equipment (slot/subslot).
+
+ Copyright of the Members of the Open ROADM MSA Agreement dated (c) 2016,
+ AT&T Intellectual Property. All other rights reserved.
+
+ Redistribution and use in source and binary forms, with or without modification,
+ are permitted provided that the following conditions are met:
+
+ * Redistributions of source code must retain the above copyright notice, this
+ list of conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions and the following disclaimer in the documentation and/or
+ other materials provided with the distribution.
+ * Neither the Members of the Open ROADM MSA Agreement nor the names of its
+ contributors may be used to endorse or promote products derived from this software
+ without specific prior written permission.
+
+ THIS SOFTWARE IS PROVIDED BY THE MEMBERS OF THE OPEN ROADM MSA AGREEMENT ''AS IS''
+ AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ IN NO EVENT THE MEMBERS OF THE OPEN ROADM MSA AGREEMENT BE LIABLE FOR ANY DIRECT,
+ INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
+ OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ POSSIBILITY OF SUCH DAMAGE.";
+
+ revision 2016-10-14 {
+ description
+ "Version 1.2";
+ }
+
+ typedef admin-states {
+ type enumeration {
+ enum "inService" {
+ value 1;
+ }
+ enum "outOfService" {
+ value 2;
+ }
+ enum "maintenance" {
+ value 3;
+ }
+ }
+ }
+
+ typedef states {
+ type enumeration {
+ enum "reserved-for-facility-planned" {
+ value 1;
+ description
+ "equipment is planned for use by a service";
+ }
+ enum "not-reserved-planned" {
+ value 2;
+ description
+ "equipment is planned by not reserved for any purpose";
+ }
+ enum "reserved-for-maintenance-planned" {
+ value 3;
+ description
+ "equipment is planned for use as a maintenance spare";
+ }
+ enum "reserved-for-facility-unvalidated" {
+ value 4;
+ description
+ "equipment is reserved for use by a service but not
+ validated against planned equipment";
+ }
+ enum "not-reserved-unvalidated" {
+ value 5;
+ description
+ "equipment is not reserved for any purpose and
+ not validated against planned equipment";
+ }
+ enum "unknown-unvalidated" {
+ value 6;
+ description
+ "unknown equipment not validated against planned equipment";
+ }
+ enum "reserved-for-maintenance-unvalidated" {
+ value 7;
+ description
+ "equipment is to be used for use as a maintenance spare
+ but not validated against planned equipment";
+ }
+ enum "reserved-for-facility-available" {
+ value 8;
+ description
+ "reserved for use by a service and available";
+ }
+ enum "not-reserved-available" {
+ value 9;
+ description
+ "not reserved for use by a service and available";
+ }
+ enum "reserved-for-maintenance-available" {
+ value 10;
+ description
+ "reserved as a maintenance spare and available";
+ }
+ enum "reserved-for-reversion-inuse" {
+ value 11;
+ description
+ "equipiment that is reserved as part of a home path
+ for a service that has been temporarily re-routed";
+ }
+ enum "not-reserved-inuse" {
+ value 12;
+ description
+ "equipment in use for a service";
+ }
+ enum "reserved-for-maintenance-inuse" {
+ value 13;
+ description
+ "maintenance spare equipment that is in use as a
+ maintenance spare";
+ }
+ }
+ }
+}
--- /dev/null
+module org-openroadm-ethernet-interfaces {
+ namespace "http://org/openroadm/ethernet-interfaces";
+ prefix org-openroadm-eth-interfaces;
+
+ import org-openroadm-device {
+ prefix org-openroadm-device;
+ }
+ import org-openroadm-interfaces {
+ prefix openROADM-if;
+ }
+
+ organization "Open ROADM MSA";
+ contact
+ "OpenROADM.org";
+ description
+ "YANG definitions for device facility ethernet interfaces.
+
+ Copyright of the Members of the Open ROADM MSA Agreement dated (c) 2016,
+ AT&T Intellectual Property. All other rights reserved.
+
+ Redistribution and use in source and binary forms, with or without modification,
+ are permitted provided that the following conditions are met:
+
+ * Redistributions of source code must retain the above copyright notice, this
+ list of conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions and the following disclaimer in the documentation and/or
+ other materials provided with the distribution.
+ * Neither the Members of the Open ROADM MSA Agreement nor the names of its
+ contributors may be used to endorse or promote products derived from this software
+ without specific prior written permission.
+
+ THIS SOFTWARE IS PROVIDED BY THE MEMBERS OF THE OPEN ROADM MSA AGREEMENT ''AS IS''
+ AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ IN NO EVENT THE MEMBERS OF THE OPEN ROADM MSA AGREEMENT BE LIABLE FOR ANY DIRECT,
+ INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
+ OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ POSSIBILITY OF SUCH DAMAGE.
+
+ Also contains code components extracted from IETF Interfaces. These code components
+ are copyrighted and licensed as follows:
+
+ Copyright (c) 2016 IETF Trust and the persons identified as the document authors.
+ All rights reserved.
+
+ This document is subject to BCP 78 and the IETF Trust’s Legal Provisions Relating
+ to IETF Documents (http://trustee.ietf.org/license-info) in effect on the date of
+ publication of this document. Please review these documents carefully, as they
+ describe your rights and restrictions with respect to this document. Code Components
+ extracted from this document must include Simplified BSD License text as described in
+ Section 4.e of the Trust Legal Provisions and are provided without warranty as
+ described in the Simplified BSD License.";
+
+ revision 2016-10-14 {
+ description
+ "Version 1.2";
+ }
+
+ grouping eth-attributes {
+ leaf speed {
+ type uint32;
+ description
+ "Set speed of the interface, unit mbps.
+ This is for ETH facility. ";
+ }
+ leaf fec {
+ type enumeration {
+ enum off;
+ enum rsfec;
+ }
+ description "Forward Error Correction Choices. ";
+ }
+ leaf duplex {
+ type enumeration {
+ enum "half" {
+ value 0;
+ description
+ "half duplex";
+ }
+ enum "full" {
+ value 1;
+ description
+ "full duplex";
+ }
+ }
+ default "full";
+ description
+ "Set duplex selections.";
+ }
+ leaf mtu {
+ type uint32 {
+ range "1518..9000";
+ }
+ default "1522";
+ description
+ "Set Maximum Frame Size.";
+ }
+ leaf auto-negotiation {
+ type enumeration {
+ enum "enabled" {
+ value 1;
+ description
+ "Auto Negotiation enabled";
+ }
+ enum "disabled" {
+ value 0;
+ description
+ "Auto Negotiation disabled";
+ }
+ }
+ default "enabled";
+ description
+ "Set Auto Negotiation: Enabled/Disabled.";
+ }
+ leaf curr-speed {
+ config false;
+ type string;
+ description
+ "speed (UNKNOWN/AUTO/10/100/1000/10000) corresponding to the interface";
+ }
+ leaf curr-duplex {
+ config false;
+ type string;
+ description
+ "duplex (HALF/FULL) corresponding to the interface";
+ }
+ }
+
+ grouping ethernet-container {
+ container ethernet {
+ description
+ "Ethernet Interfaces";
+ uses eth-attributes;
+ }
+ }
+
+ augment "/org-openroadm-device:org-openroadm-device/org-openroadm-device:interface" {
+ when "org-openroadm-device:type = 'openROADM-if:ethernetCsmacd'";
+ uses ethernet-container;
+ }
+}
--- /dev/null
+module org-openroadm-file-transfer {
+ namespace "http://org/openroadm/file-transfer";
+ prefix org-openroadm-file-txr;
+
+ import ietf-inet-types {
+ prefix inet;
+ }
+
+ import org-openroadm-common-types {
+ prefix org-openroadm-common-types;
+ }
+
+ organization "Open ROADM MSA";
+ contact
+ "OpenROADM.org";
+ description
+ "YANG definitions for file management related rpcs.
+
+ Copyright of the Members of the Open ROADM MSA Agreement dated (c) 2016,
+ AT&T Intellectual Property. All other rights reserved.
+
+ Redistribution and use in source and binary forms, with or without modification,
+ are permitted provided that the following conditions are met:
+
+ * Redistributions of source code must retain the above copyright notice, this
+ list of conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions and the following disclaimer in the documentation and/or
+ other materials provided with the distribution.
+ * Neither the Members of the Open ROADM MSA Agreement nor the names of its
+ contributors may be used to endorse or promote products derived from this software
+ without specific prior written permission.
+
+ THIS SOFTWARE IS PROVIDED BY THE MEMBERS OF THE OPEN ROADM MSA AGREEMENT ''AS IS''
+ AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ IN NO EVENT THE MEMBERS OF THE OPEN ROADM MSA AGREEMENT BE LIABLE FOR ANY DIRECT,
+ INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
+ OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ POSSIBILITY OF SUCH DAMAGE.";
+
+ revision 2016-10-14 {
+ description
+ "Version 1.2";
+ }
+
+ rpc transfer {
+ description
+ "File transfer using FTP/SFTP";
+ input {
+ leaf action {
+ mandatory true;
+ description
+ "Type of action - download/upload.";
+ type enumeration {
+ enum "upload" {
+ description
+ "Specify the upload action. The server sends
+ the file identified by the local-file-path
+ to the remote-file-path.";
+ }
+ enum "download" {
+ description
+ "Specify the download action. The server retrieves
+ the file identified by the remote-file-path
+ to the local-file-path.";
+ }
+ }
+ }
+ leaf local-file-path {
+ type string;
+ mandatory true;
+ description
+ "Local file path.
+ Ex: /var/shared/example.txt";
+ }
+ leaf remote-file-path {
+ type inet:uri;
+ mandatory true;
+ description
+ "Remote file path.
+ A URI for the remote file path.
+
+ Format:sftp://user[:password]@host[:port]/path.
+ Ex: sftp://test:verify@[2001:db8:0:1::10]:22/home/user/sample";
+ }
+ }
+ output {
+ uses org-openroadm-common-types:rpc-response-status;
+ }
+ }
+ rpc show-file {
+ description
+ "Show one or more files in the specified directory.";
+ input {
+ leaf filename {
+ type string {
+ length "1..255";
+ }
+ description
+ "Specify file(s) to be listed (* is allowed as wild-card). ";
+ }
+ }
+ output {
+ leaf status {
+ type enumeration {
+ enum "Successful" {
+ value 1;
+ }
+ enum "Failed" {
+ value 2;
+ }
+ }
+ mandatory true;
+ description
+ "Successful or Failed";
+ }
+ leaf-list status-message {
+ type string;
+ description
+ "Gives a more detailed reason for success / failure";
+ }
+ }
+ }
+ rpc delete-file {
+ description
+ "Delete one or more files in the specified directory.";
+ input {
+ leaf filename {
+ type string {
+ length "1..255";
+ }
+ mandatory true;
+ description
+ "Specify file(s) to be deleted (* is allowed as wild-card).";
+ }
+ }
+ output {
+ uses org-openroadm-common-types:rpc-response-status;
+ }
+ }
+}
--- /dev/null
+module org-openroadm-fwdl {
+ namespace "http://org/openroadm/fwdl";
+ prefix org-openroadm-fwdl;
+
+ import org-openroadm-common-types {
+ prefix org-openroadm-common-types;
+ }
+ organization "Open ROADM MSA";
+ contact
+ "OpenROADM.org";
+ description
+ "This module contains definitions for System Management.
+
+ Copyright of the Members of the Open ROADM MSA Agreement dated (c) 2016,
+ AT&T Intellectual Property. All other rights reserved.
+
+ Redistribution and use in source and binary forms, with or without modification,
+ are permitted provided that the following conditions are met:
+
+ * Redistributions of source code must retain the above copyright notice, this
+ list of conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions and the following disclaimer in the documentation and/or
+ other materials provided with the distribution.
+ * Neither the Members of the Open ROADM MSA Agreement nor the names of its
+ contributors may be used to endorse or promote products derived from this software
+ without specific prior written permission.
+
+ THIS SOFTWARE IS PROVIDED BY THE MEMBERS OF THE OPEN ROADM MSA AGREEMENT ''AS IS''
+ AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ IN NO EVENT THE MEMBERS OF THE OPEN ROADM MSA AGREEMENT BE LIABLE FOR ANY DIRECT,
+ INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
+ OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ POSSIBILITY OF SUCH DAMAGE.";
+
+ revision 2016-10-14 {
+ description
+ "Version 1.2";
+ }
+
+ rpc fw-update {
+ description
+ "Fpga data update";
+ input {
+ leaf circuit-pack-name {
+ type string;
+ description
+ "Name of the circuit pack";
+ }
+ }
+ output {
+ uses org-openroadm-common-types:rpc-response-status;
+ }
+ }
+}
--- /dev/null
+module org-openroadm-interfaces {
+ namespace "http://org/openroadm/interfaces";
+ prefix openROADM-if;
+
+ organization "Open ROADM MSA";
+ contact
+ "OpenROADM.org";
+ description
+ "YANG definitions for device facility interfaces.
+ Reused ietf-interfaces and some interface-type defined in iana-if-type.
+
+ Copyright of the Members of the Open ROADM MSA Agreement dated (c) 2016,
+ AT&T Intellectual Property. All other rights reserved.
+
+ Redistribution and use in source and binary forms, with or without modification,
+ are permitted provided that the following conditions are met:
+
+ * Redistributions of source code must retain the above copyright notice, this
+ list of conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions and the following disclaimer in the documentation and/or
+ other materials provided with the distribution.
+ * Neither the Members of the Open ROADM MSA Agreement nor the names of its
+ contributors may be used to endorse or promote products derived from this software
+ without specific prior written permission.
+
+ THIS SOFTWARE IS PROVIDED BY THE MEMBERS OF THE OPEN ROADM MSA AGREEMENT ''AS IS''
+ AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ IN NO EVENT THE MEMBERS OF THE OPEN ROADM MSA AGREEMENT BE LIABLE FOR ANY DIRECT,
+ INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
+ OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ POSSIBILITY OF SUCH DAMAGE.
+
+ Also contains code components extracted from IETF Interfaces. These code components
+ are copyrighted and licensed as follows:
+
+ Copyright (c) 2016 IETF Trust and the persons identified as the document authors.
+ All rights reserved.
+
+ This document is subject to BCP 78 and the IETF Trust’s Legal Provisions Relating
+ to IETF Documents (http://trustee.ietf.org/license-info) in effect on the date of
+ publication of this document. Please review these documents carefully, as they
+ describe your rights and restrictions with respect to this document. Code Components
+ extracted from this document must include Simplified BSD License text as described in
+ Section 4.e of the Trust Legal Provisions and are provided without warranty as
+ described in the Simplified BSD License.";
+
+ revision 2016-10-14 {
+ description
+ "Version 1.2";
+ }
+
+ identity interface-type {
+ description
+ "Base identity from which specific interface types are
+ derived.";
+ }
+
+ identity ethernetCsmacd {
+ base interface-type;
+ description
+ "For all Ethernet-like interfaces, regardless of speed,
+ as per RFC 3635.";
+ reference
+ "RFC 3635 - Definitions of Managed Objects for the
+ Ethernet-like Interface Types";
+ }
+
+ identity ip {
+ base interface-type;
+ description
+ "IP (for APPN HPR in IP networks).";
+ }
+
+ identity opticalChannel {
+ base interface-type;
+ description
+ "Optical Channel.";
+ }
+
+ identity opticalTransport {
+ base interface-type;
+ description
+ "Optical Transport.";
+ }
+
+ identity otnOdu {
+ base interface-type;
+ description
+ "OTN Optical Data Unit.";
+ }
+
+ identity otnOtu {
+ base interface-type;
+ description
+ "OTN Optical channel Transport Unit.";
+ }
+
+ identity openROADMOpticalMultiplex {
+ base interface-type;
+ description
+ "Optical Transport Multiplex type for openROADM";
+ }
+}
--- /dev/null
+module org-openroadm-layerRate {
+ namespace "http://org/openroadm/layerRate";
+ prefix org-openroadm-layerRate;
+
+ organization "Open ROADM MSA";
+ contact
+ "OpenROADM.org";
+ description
+ "YANG definitions of layer rates.
+
+ Copyright of the Members of the Open ROADM MSA Agreement dated (c) 2016,
+ AT&T Intellectual Property. All other rights reserved.
+
+ Redistribution and use in source and binary forms, with or without modification,
+ are permitted provided that the following conditions are met:
+
+ * Redistributions of source code must retain the above copyright notice, this
+ list of conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions and the following disclaimer in the documentation and/or
+ other materials provided with the distribution.
+ * Neither the Members of the Open ROADM MSA Agreement nor the names of its
+ contributors may be used to endorse or promote products derived from this software
+ without specific prior written permission.
+
+ THIS SOFTWARE IS PROVIDED BY THE MEMBERS OF THE OPEN ROADM MSA AGREEMENT ''AS IS''
+ AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ IN NO EVENT THE MEMBERS OF THE OPEN ROADM MSA AGREEMENT BE LIABLE FOR ANY DIRECT,
+ INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
+ OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ POSSIBILITY OF SUCH DAMAGE";
+
+ revision 2016-10-14 {
+ description
+ "Version 1.2";
+ }
+
+ grouping layer-rate {
+ description
+ "Set list of layer rates, plus the ability to report layer rates not yet in set list.";
+ leaf type {
+ type layer-rate-enum;
+ mandatory true;
+ }
+ leaf extension {
+ type string;
+ mandatory false;
+ }
+ }
+
+ typedef layer-rate-enum {
+ type enumeration {
+ enum "vendorExtension" {
+ value 1;
+ description
+ "vendor extension";
+ }
+ enum "layer2" {
+ value 2;
+ description
+ "2";
+ }
+ enum "layer3" {
+ value 3;
+ description
+ "3";
+ }
+ enum "layer4" {
+ value 4;
+ description
+ "4";
+ }
+ enum "layer5" {
+ value 5;
+ description
+ "5";
+ }
+ enum "layer6" {
+ value 6;
+ description
+ "6";
+ }
+ }
+ }
+}
--- /dev/null
+module org-openroadm-lldp {
+ namespace "http://org/openroadm/lldp";
+ prefix org-openroadm-lldp;
+
+ import ietf-inet-types {
+ prefix inet;
+ }
+ import org-openroadm-device {
+ prefix org-openroadm-device;
+ }
+ import iana-afn-safi {
+ prefix ianaaf;
+ }
+ import org-openroadm-resource-types {
+ prefix org-openroadm-resource-types;
+ }
+ import ietf-yang-types {
+ prefix yang;
+ }
+
+ organization "Open ROADM MSA";
+ contact
+ "OpenROADM.org";
+ description
+ "YANG definitions for lldp protocol.
+
+ Copyright of the Members of the Open ROADM MSA Agreement dated (c) 2016,
+ AT&T Intellectual Property. All other rights reserved.
+
+ Redistribution and use in source and binary forms, with or without modification,
+ are permitted provided that the following conditions are met:
+
+ * Redistributions of source code must retain the above copyright notice, this
+ list of conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions and the following disclaimer in the documentation and/or
+ other materials provided with the distribution.
+ * Neither the Members of the Open ROADM MSA Agreement nor the names of its
+ contributors may be used to endorse or promote products derived from this software
+ without specific prior written permission.
+
+ THIS SOFTWARE IS PROVIDED BY THE MEMBERS OF THE OPEN ROADM MSA AGREEMENT ''AS IS''
+ AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ IN NO EVENT THE MEMBERS OF THE OPEN ROADM MSA AGREEMENT BE LIABLE FOR ANY DIRECT,
+ INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
+ OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ POSSIBILITY OF SUCH DAMAGE.";
+
+ revision 2016-10-14 {
+ description
+ "Version 1.2";
+ }
+ grouping nbr-info-grp {
+ description
+ "Display LLDP Neighbour ";
+
+ leaf remoteSysName {
+ type string;
+ description
+ "remote neighbour system name";
+ }
+ leaf remoteMgmtAddressSubType {
+ type ianaaf:address-family;
+ description
+ "remote neighbour Management Address Subtype Enumeration";
+ }
+ leaf remoteMgmtAddress {
+ type inet:ip-address;
+ description
+ "remote neighbour management address";
+ }
+ leaf remotePortIdSubType {
+ type enumeration {
+ enum "other" {
+ value 0;
+ description
+ "reserved";
+ }
+ enum "ifalias" {
+ value 1;
+ description
+ "Interface Alias (IfAlias - IETF RFC 2863) ";
+ }
+ enum "portcomponent" {
+ value 2;
+ description
+ "Port component (EntPhysicalAlias IETF RFC 4133)";
+ }
+ enum "macaddress" {
+ value 3;
+ description
+ "MAC address (IEEE Std 802) ";
+ }
+ enum "networkaddress" {
+ value 4;
+ description
+ "Network Address";
+ }
+ enum "ifname" {
+ value 5;
+ description
+ "Interface Name (ifName - IETF RFC 2863)";
+ }
+ enum "agentcircuitid" {
+ value 6;
+ description
+ "Agent Circuit Id (IETF RFC 3046)";
+ }
+ enum "local" {
+ value 7;
+ description
+ "Locally assigned";
+ }
+ }
+ description
+ "remote neighbour Port ID Subtype Enumeration";
+ }
+ leaf remotePortId {
+ type string;
+ description
+ "remote neighbour port Id";
+ }
+ leaf remoteChassisIdSubType {
+ type enumeration {
+ enum "reserved" {
+ value 0;
+ description
+ "reserved";
+ }
+ enum "chassiscomponent" {
+ value 1;
+ description
+ "Chassis component (EntPhysicalAlias IETF RFC 4133)";
+ }
+ enum "ifalias" {
+ value 2;
+ description
+ "Interface Alias (IfAlias - IETF RFC 2863) ";
+ }
+ enum "portcomponent" {
+ value 3;
+ description
+ "Port component (EntPhysicalAlias IETF RFC 4133)";
+ }
+ enum "macaddress" {
+ value 4;
+ description
+ "MAC address (IEEE Std 802) ";
+ }
+ enum "networkaddress" {
+ value 5;
+ description
+ "Network Address";
+ }
+ enum "ifname" {
+ value 6;
+ description
+ "Interface Name (ifName - IETF RFC 2863)";
+ }
+ enum "local" {
+ value 7;
+ description
+ "Locally assigned";
+ }
+ }
+ description
+ "Chassis ID Subtype Enumeration";
+ }
+ leaf remoteChassisId {
+ type string;
+ description
+ "remote neighbour Chassis Id";
+ }
+ }
+
+ grouping lldp-container {
+ container lldp {
+ description
+ "LLDP configurable and retrievable";
+ container global-config {
+ description
+ "LLDP global configurations";
+ leaf adminStatus {
+ type enumeration {
+ enum "disable" {
+ value 0;
+ description
+ "Disable the LLDP feature per NE";
+ }
+ enum "enable" {
+ value 1;
+ description
+ "Enable the LLDP feature per NE";
+ }
+ }
+ description
+ "LLDP feature Enable/Disable per NE";
+ default "enable";
+ }
+ leaf msgTxInterval {
+ type uint16 {
+ range "5..32768";
+ }
+ description
+ "LLDP frame Retransmit Interval in seconds";
+ default "30";
+ }
+ leaf msgTxHoldMultiplier {
+ type uint8 {
+ range "2..10";
+ }
+ description
+ "TTL value for the TLVs transmitter over wire in seconds";
+ default "4";
+ }
+ }
+ list port-config {
+ description
+ "LLDP port configurations";
+ key "ifName";
+ leaf ifName {
+ type leafref {
+ path "/org-openroadm-device:org-openroadm-device/org-openroadm-device:interface/org-openroadm-device:name";
+ }
+ description
+ "Ethernet interface name where LLDP runs";
+ }
+ leaf adminStatus {
+ type enumeration {
+ enum "disable" {
+ value 0;
+ description
+ "Disables the LLDP frames transmit and receive on specific interface";
+ }
+ enum "txandrx" {
+ value 1;
+ description
+ "Enable Transmit and Receive LLDP frames on specific interface";
+ }
+ }
+ description
+ "LLDP enable per port basis";
+ default "txandrx";
+ }
+ }
+ container nbr-list {
+ description
+ "LLDP Oper data - Neighbour List information";
+ config false;
+ list if-name {
+ key "ifName";
+ leaf ifName {
+ type string;
+ description
+ "Ethernet interface name where LLDP runs";
+ }
+ uses nbr-info-grp;
+ }
+ }
+ }
+ }
+
+ augment "/org-openroadm-device:org-openroadm-device/org-openroadm-device:protocols" {
+ when "/org-openroadm-device:org-openroadm-device/org-openroadm-device:info/org-openroadm-device:node-type='rdm'";
+ uses lldp-container;
+ }
+
+ notification lldp-nbr-info-change {
+ description "LLDP: Neighbor Information Changed
+ remoteSysName
+ remoteSysMgmtAddressSubType
+ remoteSysMgmtAddress
+ remotePortIdSubType
+ remotePortId
+ remoteChassisIdSubType
+ remoteChassisId
+ All of the above attributes are sent in event";
+ leaf notification-type {
+ type org-openroadm-resource-types:resource-notification-type;
+ }
+ leaf resource-type {
+ type org-openroadm-resource-types:resource-type-enum;
+ description
+ "resource-type for this notification is interface";
+ }
+ leaf resource {
+ type string;
+ description
+ "resource interface-name";
+ }
+ container nbr-info {
+ uses nbr-info-grp;
+ }
+ leaf event-time {
+ type yang:date-and-time;
+ }
+ }
+}
--- /dev/null
+module org-openroadm-maintenance-loopback {
+ namespace "http://org/openroadm/maintenance-loopback";
+ prefix org-openroadm-maint-loopback;
+
+ organization "Open ROADM MSA";
+ contact
+ "OpenROADM.org";
+ description
+ "YANG definitions for maintenance loopback.
+
+ Copyright of the Members of the Open ROADM MSA Agreement dated (c) 2016,
+ AT&T Intellectual Property. All other rights reserved.
+
+ Redistribution and use in source and binary forms, with or without modification,
+ are permitted provided that the following conditions are met:
+
+ * Redistributions of source code must retain the above copyright notice, this
+ list of conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions and the following disclaimer in the documentation and/or
+ other materials provided with the distribution.
+ * Neither the Members of the Open ROADM MSA Agreement nor the names of its
+ contributors may be used to endorse or promote products derived from this software
+ without specific prior written permission.
+
+ THIS SOFTWARE IS PROVIDED BY THE MEMBERS OF THE OPEN ROADM MSA AGREEMENT ''AS IS''
+ AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ IN NO EVENT THE MEMBERS OF THE OPEN ROADM MSA AGREEMENT BE LIABLE FOR ANY DIRECT,
+ INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
+ OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ POSSIBILITY OF SUCH DAMAGE.";
+
+ revision 2016-10-14 {
+ description
+ "Version 1.2";
+ }
+
+ grouping maint-loopback {
+ container maint-loopback {
+ leaf enabled {
+ type boolean;
+ default "false";
+ description
+ "loopback operation enable flag";
+ }
+ leaf type {
+ when "../enabled = 'true'";
+ type enumeration {
+ enum "fac" {
+ value 0;
+ description
+ "pre-FEC Loopback in the facility direction";
+ }
+ enum "term" {
+ value 1;
+ description
+ "Loopback in the terminal direction";
+ }
+ enum "fac2" {
+ value 2;
+ description
+ "post-FEC Loopback in the facility direction";
+ }
+ }
+ default "fac";
+ description
+ "Set Loopback type (or direction).";
+ }
+ }
+ }
+}
--- /dev/null
+module org-openroadm-maintenance-testsignal {
+ namespace "http://org/openroadm/maintenance-testsignal";
+ prefix org-openroadm-maint-testsignal;
+
+ organization "Open ROADM MSA";
+ contact
+ "OpenROADM.org";
+ description
+ "YANG definitions for maintenance testsignal.
+
+ Copyright of the Members of the Open ROADM MSA Agreement dated (c) 2016,
+ AT&T Intellectual Property. All other rights reserved.
+
+ Redistribution and use in source and binary forms, with or without modification,
+ are permitted provided that the following conditions are met:
+
+ * Redistributions of source code must retain the above copyright notice, this
+ list of conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions and the following disclaimer in the documentation and/or
+ other materials provided with the distribution.
+ * Neither the Members of the Open ROADM MSA Agreement nor the names of its
+ contributors may be used to endorse or promote products derived from this software
+ without specific prior written permission.
+
+ THIS SOFTWARE IS PROVIDED BY THE MEMBERS OF THE OPEN ROADM MSA AGREEMENT ''AS IS''
+ AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ IN NO EVENT THE MEMBERS OF THE OPEN ROADM MSA AGREEMENT BE LIABLE FOR ANY DIRECT,
+ INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
+ OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ POSSIBILITY OF SUCH DAMAGE.";
+
+ revision 2016-10-14 {
+ description
+ "Version 1.2";
+ }
+
+ grouping maint-testsignal {
+ container maint-testsignal {
+ leaf enabled {
+ type boolean;
+ default "false";
+ description
+ "testsignal enabled flag";
+ }
+ leaf testPattern {
+ when "../enabled = 'true'";
+ type enumeration {
+ enum "PRBS" {
+ value 0;
+ description
+ "Unframed, inverted PN-31 pattern or PRBS31 pattern per IEEE 802.3 clause 50.3.8.2 (inverted PN-31at line rate)";
+ }
+ enum "PRBS31" {
+ value 1;
+ description
+ "PRBS31 with standard mapping per G.709";
+ }
+ enum "PRBS23" {
+ value 2;
+ description
+ "SONET/SDH Framed,inverted PN-23 pattern.";
+ }
+ enum "PRZEROS" {
+ value 3;
+ description
+ "pseudo-random with zeros data pattern per IEEE 802.3 clause 49.2.8";
+ }
+ enum "IDLE" {
+ value 4;
+ description
+ "Scrambled IDLE test-pattern per IEEE 802.3ba";
+ }
+ }
+ description
+ "Set test signal pattern";
+ }
+ leaf type {
+ when "../enabled = 'true'";
+ type enumeration {
+ enum "fac" {
+ value 0;
+ description
+ "test signal in the facility direction";
+ }
+ enum "term" {
+ value 1;
+ description
+ "test signal in the terminal direction";
+ }
+ }
+ default "fac";
+ description
+ "Set test signal type (or direction).";
+ }
+ leaf bitErrors {
+ when "../enabled = 'true' and ../type = 'fac'";
+ type uint32 {
+ range "0..4294967295";
+ }
+ config false;
+ description
+ "bit errors for test signal in facility direction.";
+ }
+ leaf bitErrorsTerminal {
+ when "../enabled = 'true' and ../type = 'term'";
+ type uint32 {
+ range "0..4294967295";
+ }
+ config false;
+ description
+ "bit errors for test signal in terminal direction.";
+ }
+ leaf syncSeconds {
+ when "../enabled = 'true' and ../type = 'fac'";
+ type string;
+ config false;
+ description
+ "number of seconds the received facility test signal is in sync.";
+ }
+ leaf syncSecondsTerminal {
+ when "../enabled = 'true' and ../type = 'term'";
+ type string;
+ config false;
+ description
+ "number of seconds the received terminal test signal is in sync.";
+ }
+ }
+ }
+}
--- /dev/null
+module org-openroadm-maintenance {
+ namespace "http://org/openroadm/maintenance";
+ prefix org-openroadm-mainteance;
+
+ import org-openroadm-resource {
+ prefix org-openroadm-resource;
+ }
+
+ organization "Open ROADM MSA";
+ contact
+ "OpenROADM.org";
+ description
+ "YANG definitions of maintenace operations.
+
+ Copyright of the Members of the Open ROADM MSA Agreement dated (c) 2016,
+ AT&T Intellectual Property. All other rights reserved.
+
+ Redistribution and use in source and binary forms, with or without modification,
+ are permitted provided that the following conditions are met:
+
+ * Redistributions of source code must retain the above copyright notice, this
+ list of conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions and the following disclaimer in the documentation and/or
+ other materials provided with the distribution.
+ * Neither the Members of the Open ROADM MSA Agreement nor the names of its
+ contributors may be used to endorse or promote products derived from this software
+ without specific prior written permission.
+
+ THIS SOFTWARE IS PROVIDED BY THE MEMBERS OF THE OPEN ROADM MSA AGREEMENT ''AS IS''
+ AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ IN NO EVENT THE MEMBERS OF THE OPEN ROADM MSA AGREEMENT BE LIABLE FOR ANY DIRECT,
+ INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
+ OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ POSSIBILITY OF SUCH DAMAGE";
+
+ revision 2016-10-14 {
+ description
+ "Version 1.2";
+ }
+
+ grouping maintenance {
+ leaf id {
+ description
+ "Uniquely identify maintenance activity";
+ type string;
+ mandatory true;
+ }
+ container resource {
+ description
+ "Resource under maintenance";
+ uses org-openroadm-resource:resource;
+ }
+ leaf operation {
+ type maintenance-operation;
+ }
+ }
+
+ container maintenance-list {
+ description
+ "A list of active maintenance operations. Adding an entry to this list creates an active maintenance operation. Removing an entry from this terminates a maintenance activity";
+ list maintenance {
+ key "id";
+ uses maintenance;
+ }
+ }
+
+ typedef maintenance-operation {
+ description
+ "Maintenance Operation.";
+ type enumeration {
+ enum "terminalLoopback" {
+ value 1;
+ }
+ enum "facilityLoopback" {
+ value 2;
+ }
+ enum "testSignal" {
+ value 3;
+ }
+ }
+ }
+}
--- /dev/null
+module org-openroadm-network-types {
+ namespace "http://org/openroadm/network/types";
+ prefix nt;
+
+ import ietf-network-topology {
+ prefix nwt;
+ revision-date 2015-06-08;
+ }
+ import ietf-yang-types {
+ prefix yang;
+ revision-date 2013-07-15;
+ }
+ import org-openroadm-common-types {
+ prefix org-openroadm-common-types;
+ revision-date 2017-09-29;
+ }
+ import org-openroadm-port-types {
+ prefix org-openroadm-port-types;
+ revision-date 2017-09-29;
+ }
+
+ organization
+ "OPEN ROADM MSA";
+ contact
+ "www.OpenROADM.org.";
+ description
+ "Copyright of the Members of the Open ROADM MSA Agreement dated (c) 2016,
+ AT&T Intellectual Property. All other rights reserved.
+
+ Redistribution and use in source and binary forms, with or without modification,
+ are permitted provided that the following conditions are met:
+
+ * Redistributions of source code must retain the above copyright notice, this
+ list of conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions and the following disclaimer in the documentation and/or
+ other materials provided with the distribution.
+ * Neither the Members of the Open ROADM MSA Agreement nor the names of its
+ contributors may be used to endorse or promote products derived from this software
+ without specific prior written permission.
+
+ THIS SOFTWARE IS PROVIDED BY THE MEMBERS OF THE OPEN ROADM MSA AGREEMENT ''AS IS''
+ AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ IN NO EVENT THE MEMBERS OF THE OPEN ROADM MSA AGREEMENT BE LIABLE FOR ANY DIRECT,
+ INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
+ OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ POSSIBILITY OF SUCH DAMAGE.";
+
+ revision 2017-09-29 {
+ description
+ "Version 2.1";
+ }
+ revision 2017-07-28 {
+ description
+ "Version 2.0.1 - added revision-date to imports";
+ }
+ revision 2017-06-26 {
+ description
+ "Version 2.0";
+ }
+
+ typedef openroadm-node-type {
+ type enumeration {
+ enum "ROADM" {
+ value 1;
+ }
+ enum "DEGREE" {
+ value 11;
+ }
+ enum "SRG" {
+ value 12;
+ }
+ enum "XPONDER" {
+ value 3;
+ }
+ enum "EXT-PLUGGABLE" {
+ value 4;
+ }
+ enum "TPDR" {
+ value 13;
+ }
+ enum "MUXPDR" {
+ value 14;
+ }
+ enum "REGEN" {
+ value 15;
+ }
+ enum "REGEN-UNI" {
+ value 16;
+ }
+ enum "SWITCH" {
+ value 17;
+ }
+ }
+ }
+
+ typedef openroadm-tp-type {
+ type enumeration {
+ enum "DEGREE-TX-TTP" {
+ value 1;
+ }
+ enum "DEGREE-RX-TTP" {
+ value 2;
+ }
+ enum "DEGREE-TX-CTP" {
+ value 3;
+ }
+ enum "DEGREE-RX-CTP" {
+ value 4;
+ }
+ enum "SRG-TX-CP" {
+ value 5;
+ }
+ enum "SRG-RX-CP" {
+ value 6;
+ }
+ enum "SRG-TXRX-PP" {
+ value 7;
+ }
+ enum "SRG-RX-PP" {
+ value 8;
+ }
+ enum "SRG-TX-PP" {
+ value 9;
+ }
+ enum "XPONDER-NETWORK" {
+ value 10;
+ }
+ enum "XPONDER-CLIENT" {
+ value 11;
+ }
+ enum "EXT-PLUGGABLE-TP" {
+ value 12;
+ }
+ enum "DEGREE-TXRX-TTP" {
+ value 13;
+ }
+ enum "SRG-TXRX-CP" {
+ value 14;
+ }
+ enum "XPONDER-PORT" {
+ value 15;
+ }
+ enum "DEGREE-TXRX-CTP" {
+ value 16;
+ }
+ }
+ }
+
+ typedef openroadm-link-type {
+ type enumeration {
+ enum "EXPRESS-LINK" {
+ value 1;
+ }
+ enum "ADD-LINK" {
+ value 2;
+ }
+ enum "DROP-LINK" {
+ value 3;
+ }
+ enum "ROADM-TO-ROADM" {
+ value 4;
+ }
+ enum "XPONDER-INPUT" {
+ value 5;
+ }
+ enum "XPONDER-OUTPUT" {
+ value 6;
+ }
+ enum "OTN-LINK" {
+ value 7;
+ }
+ }
+ }
+
+ typedef openroadm-node-status {
+ type enumeration {
+ enum "PLANNED" {
+ value 1;
+ }
+ enum "DEPLOYED" {
+ value 2;
+ }
+ enum "MAINTENANCE" {
+ value 3;
+ }
+ }
+ }
+
+ typedef openroadm-node-mount-status {
+ type enumeration {
+ enum "MOUNTED" {
+ value 1;
+ }
+ enum "UNMOUNTED" {
+ value 2;
+ }
+ }
+ }
+
+ grouping wavelengths {
+ leaf index {
+ type uint32;
+ }
+ uses flex-wave;
+ }
+
+ grouping flex-wave {
+ leaf frequency {
+ type org-openroadm-common-types:frequency-THz;
+ description
+ "Center Frequency in THz";
+ config true;
+ }
+ leaf width {
+ type org-openroadm-common-types:frequency-GHz;
+ description
+ "Frequency width in GHz.";
+ config true;
+ }
+ }
+
+ grouping xpdr-tp-supported-interfaces {
+ list supported-interface-capability {
+ key "if-cap-type";
+ description
+ "Supported interface capability on the port.";
+ leaf if-cap-type {
+ description
+ "Interface type/hierarchy/rate supported on this port";
+ type identityref {
+ base org-openroadm-port-types:supported-if-capability;
+ }
+ }
+ }
+ }
+
+ grouping xpdr-tp-bandwidth-sharing {
+ list tp-bandwidth-sharing {
+ key "tp-sharing-id";
+ leaf tp-sharing-id {
+ type uint16;
+ }
+ leaf-list tp-list {
+ type nwt:tp-id;
+ }
+ leaf shared-bandwidth {
+ type uint16;
+ units "Gbps";
+ }
+ }
+ }
+
+ grouping xpdr-odu-switching-pools {
+ list odu-switching-pools {
+ key "switching-pool-number";
+ leaf switching-pool-number {
+ description
+ "Unique identifier for this odu-switching-pool";
+ type uint16;
+ }
+ leaf switching-pool-type {
+ type enumeration {
+ enum "non-blocking" {
+ value 1;
+ description
+ "Single non-blocking element";
+ }
+ enum "blocking" {
+ value 2;
+ description
+ "Multiple connected non-blocking lists";
+ }
+ }
+ }
+ list non-blocking-list {
+ description
+ "List of ports in a non-blocking switch element";
+ key "nbl-number";
+ leaf nbl-number {
+ description
+ "Identifier for this non-blocking-list. Unique within odu-switching-pool";
+ type uint16;
+ }
+ leaf interconnect-bandwidth-unit {
+ description
+ "Switch fabric interconnect bandwidth unit rate in bits per second.
+ Represents granularity of switch fabric";
+ type uint32;
+ }
+ leaf capable-interconnect-bandwidth {
+ description
+ "Total interconnect bandwidth for a non-blocking element expressed as
+ number of inter-connect-bandwidth units";
+ type uint32;
+ }
+ leaf available-interconnect-bandwidth {
+ description
+ "Total interconnect bandwidth available for a non-blocking element can use as
+ number of inter-connect-bandwidth units";
+ type uint32;
+ }
+ leaf-list tp-list {
+ description
+ "Termination point. Unique within device";
+ type nwt:tp-id;
+ }
+ }
+ }
+ }
+
+ grouping node-due-date-list {
+ list due-dates {
+ key "id";
+ leaf id {
+ type uint16;
+ }
+ leaf start-date {
+ type yang:date-and-time;
+ description
+ "date and time node will begin maintenance status or date when node is planned";
+ }
+ leaf end-date {
+ type yang:date-and-time;
+ description
+ "date and time node will end maintenance or date when node is deployed";
+ }
+ }
+ }
+}
--- /dev/null
+module org-openroadm-opposite-links {
+ namespace "http://org/openroadm/opposite/links";
+ prefix opp-links;
+
+ import ietf-network {
+ prefix nd;
+ revision-date 2015-06-08;
+ }
+ import ietf-network-topology {
+ prefix nwt;
+ revision-date 2015-06-08;
+ }
+
+ revision 2017-09-29 {
+ description
+ "Version 2.1";
+ }
+
+ augment "/nd:network/nwt:link" {
+ when "../nd:network-types/openroadm-topology";
+ description
+ "Introduce new field opposite-links";
+ leaf opposite-link {
+ type leafref {
+ path "../../nwt:link/nwt:link-id";
+ }
+ description
+ "optional - pointer to reverse link in case of bidirectional link";
+ }
+ }
+}
--- /dev/null
+module org-openroadm-optical-channel-interfaces {
+ namespace "http://org/openroadm/optical-channel-interfaces";
+ prefix org-openroadm-optical-channel-interfaces;
+
+ import org-openroadm-device {
+ prefix org-openroadm-device;
+ }
+ import org-openroadm-interfaces {
+ prefix openROADM-if;
+ }
+ import org-openroadm-common-types {
+ prefix org-openroadm-common-types;
+ }
+
+ organization "Open ROADM MSA";
+ contact
+ "OpenROADM.org";
+ description
+ "YANG definitions for device facility och interfaces.
+
+ Copyright of the Members of the Open ROADM MSA Agreement dated (c) 2016,
+ AT&T Intellectual Property. All other rights reserved.
+
+ Redistribution and use in source and binary forms, with or without modification,
+ are permitted provided that the following conditions are met:
+
+ * Redistributions of source code must retain the above copyright notice, this
+ list of conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions and the following disclaimer in the documentation and/or
+ other materials provided with the distribution.
+ * Neither the Members of the Open ROADM MSA Agreement nor the names of its
+ contributors may be used to endorse or promote products derived from this software
+ without specific prior written permission.
+
+ THIS SOFTWARE IS PROVIDED BY THE MEMBERS OF THE OPEN ROADM MSA AGREEMENT ''AS IS''
+ AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ IN NO EVENT THE MEMBERS OF THE OPEN ROADM MSA AGREEMENT BE LIABLE FOR ANY DIRECT,
+ INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
+ OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ POSSIBILITY OF SUCH DAMAGE.
+
+ Also contains code components extracted from IETF Interfaces. These code components
+ are copyrighted and licensed as follows:
+
+ Copyright (c) 2016 IETF Trust and the persons identified as the document authors.
+ All rights reserved.
+
+ This document is subject to BCP 78 and the IETF Trust’s Legal Provisions Relating
+ to IETF Documents (http://trustee.ietf.org/license-info) in effect on the date of
+ publication of this document. Please review these documents carefully, as they
+ describe your rights and restrictions with respect to this document. Code Components
+ extracted from this document must include Simplified BSD License text as described in
+ Section 4.e of the Trust Legal Provisions and are provided without warranty as
+ described in the Simplified BSD License.";
+
+ revision 2016-10-14 {
+ description
+ "Version 1.2";
+ }
+
+ identity rate-identity {
+ description
+ "A unique rate identification";
+ }
+
+ identity R200G {
+ base rate-identity;
+ description
+ "Identity for 200G Rate";
+ }
+
+ identity R100G {
+ base rate-identity;
+ description
+ "Identity for 100G Rate";
+ }
+
+ identity R10.7G {
+ base rate-identity;
+ description
+ "Identity for 10.7G Rate";
+ }
+
+ identity R11.1G {
+ base rate-identity;
+ description
+ "Identity for 11.1G Rate";
+ }
+
+ grouping och-attributes {
+ description
+ "Optical Channel attributes";
+ leaf rate {
+ type identityref {
+ base rate-identity;
+ }
+ description
+ "rate";
+ }
+ leaf wavelength-number {
+ type uint32;
+ }
+ leaf modulation-format {
+ type enumeration {
+ enum "bpsk" {
+ value 0;
+ description
+ "binary phase-shift keying";
+ }
+ enum "dc-dp-bpsk" {
+ value 1;
+ description
+ "DC dual-polarization binary phase-shift keying";
+ }
+ enum "qpsk" {
+ value 2;
+ description
+ "quadrature phase-shift keying";
+ }
+ enum "dp-qpsk" {
+ value 3;
+ description
+ "dual-polarization binary phase-shift keying";
+ }
+ enum "qam16" {
+ value 4;
+ description
+ "quadrature amplitude modulation 16";
+ }
+ enum "dp-qam16" {
+ value 5;
+ description
+ "dual-polarization quadrature amplitude modulation 16";
+ }
+ enum "dc-dp-qam16" {
+ value 6;
+ description
+ "DC dual-polarization quadrature amplitude modulation 16";
+ }
+ enum "qam8" {
+ value 7;
+ description
+ "quadrature amplitude modulation 8";
+ }
+ enum "dp-qam8" {
+ value 8;
+ description
+ "dual-polarization quadrature amplitude modulation 8";
+ }
+ enum "dc-dp-qam8" {
+ value 9;
+ description
+ "DC dual-polarization quadrature amplitude modulation 8";
+ }
+ }
+ description
+ "modulation format";
+ }
+ leaf transmit-power {
+ type org-openroadm-common-types:power-dBm;
+ description
+ "The target transmit power for this channel. When set, the xponder will work to ensure that port-current-power reaches this level. Applicable only to channel on top of xpdr-network port";
+ }
+ }
+
+ grouping och-container {
+ container och {
+ description
+ "Optical Channel (OCh):
+ Models the optical channel interfaces for an Optical White Box.";
+ uses och-attributes;
+ }
+ }
+
+ augment "/org-openroadm-device:org-openroadm-device/org-openroadm-device:interface" {
+ when "org-openroadm-device:type = 'openROADM-if:opticalChannel'";
+ uses och-container;
+ }
+}
--- /dev/null
+module org-openroadm-optical-multiplex-interfaces {
+ namespace "http://org/openroadm/optical-multiplex-interfaces";
+ prefix org-openroadm-optical-multiplex-interfaces;
+
+ import org-openroadm-device {
+ prefix org-openroadm-device;
+ }
+
+ organization "Open ROADM MSA";
+ contact
+ "OpenROADM.org";
+ description
+ "This module contains YANG definitions
+ for the Optical multiplex Interfaces (OMS).
+
+ Copyright of the Members of the Open ROADM MSA Agreement dated (c) 2016,
+ AT&T Intellectual Property. All other rights reserved.
+
+ Redistribution and use in source and binary forms, with or without modification,
+ are permitted provided that the following conditions are met:
+
+ * Redistributions of source code must retain the above copyright notice, this
+ list of conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions and the following disclaimer in the documentation and/or
+ other materials provided with the distribution.
+ * Neither the Members of the Open ROADM MSA Agreement nor the names of its
+ contributors may be used to endorse or promote products derived from this software
+ without specific prior written permission.
+
+ THIS SOFTWARE IS PROVIDED BY THE MEMBERS OF THE OPEN ROADM MSA AGREEMENT ''AS IS''
+ AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ IN NO EVENT THE MEMBERS OF THE OPEN ROADM MSA AGREEMENT BE LIABLE FOR ANY DIRECT,
+ INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
+ OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ POSSIBILITY OF SUCH DAMAGE.
+
+ Also contains code components extracted from IETF Interfaces. These code components
+ are copyrighted and licensed as follows:
+
+ Copyright (c) 2016 IETF Trust and the persons identified as the document authors.
+ All rights reserved.
+
+ This document is subject to BCP 78 and the IETF Trust’s Legal Provisions Relating
+ to IETF Documents (http://trustee.ietf.org/license-info) in effect on the date of
+ publication of this document. Please review these documents carefully, as they
+ describe your rights and restrictions with respect to this document. Code Components
+ extracted from this document must include Simplified BSD License text as described in
+ Section 4.e of the Trust Legal Provisions and are provided without warranty as
+ described in the Simplified BSD License.";
+
+ revision 2016-10-14 {
+ description
+ "Version 1.2";
+ }
+
+ augment "/org-openroadm-device:org-openroadm-device/org-openroadm-device:interface" {
+ description
+ "Optical Multiplex Section (OMS)
+ allow setting of OMS in the openROADM interfaces tree.";
+ }
+}
--- /dev/null
+module org-openroadm-optical-transport-interfaces {
+ namespace "http://org/openroadm/optical-transport-interfaces";
+ prefix org-openroadm-optical-transport-interfaces;
+
+ import org-openroadm-device {
+ prefix org-openroadm-device;
+ }
+ import org-openroadm-interfaces {
+ prefix openROADM-if;
+ }
+ import org-openroadm-common-types {
+ prefix org-openroadm-common-types;
+ }
+
+ organization "Open ROADM MSA";
+ contact
+ "OpenROADM.org";
+ description
+ "This module contains YANG definitions
+ for the Optical Transport Interfaces.
+
+ Copyright of the Members of the Open ROADM MSA Agreement dated (c) 2016,
+ AT&T Intellectual Property. All other rights reserved.
+
+ Redistribution and use in source and binary forms, with or without modification,
+ are permitted provided that the following conditions are met:
+
+ * Redistributions of source code must retain the above copyright notice, this
+ list of conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions and the following disclaimer in the documentation and/or
+ other materials provided with the distribution.
+ * Neither the Members of the Open ROADM MSA Agreement nor the names of its
+ contributors may be used to endorse or promote products derived from this software
+ without specific prior written permission.
+
+ THIS SOFTWARE IS PROVIDED BY THE MEMBERS OF THE OPEN ROADM MSA AGREEMENT ''AS IS''
+ AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ IN NO EVENT THE MEMBERS OF THE OPEN ROADM MSA AGREEMENT BE LIABLE FOR ANY DIRECT,
+ INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
+ OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ POSSIBILITY OF SUCH DAMAGE.
+
+ Also contains code components extracted from IETF Interfaces. These code components
+ are copyrighted and licensed as follows:
+
+ Copyright (c) 2016 IETF Trust and the persons identified as the document authors.
+ All rights reserved.
+
+ This document is subject to BCP 78 and the IETF Trust’s Legal Provisions Relating
+ to IETF Documents (http://trustee.ietf.org/license-info) in effect on the date of
+ publication of this document. Please review these documents carefully, as they
+ describe your rights and restrictions with respect to this document. Code Components
+ extracted from this document must include Simplified BSD License text as described in
+ Section 4.e of the Trust Legal Provisions and are provided without warranty as
+ described in the Simplified BSD License.";
+
+ revision 2016-10-14 {
+ description
+ "Version 1.2";
+ }
+
+ grouping ots-attributes {
+ description
+ "Optical Transport Section (OTS) attributes";
+ leaf fiber-type {
+ type enumeration {
+ enum "smf" {
+ value 0;
+ description
+ "Single Mode Fiber";
+ }
+ enum "eleaf" {
+ value 1;
+ description
+ "ELEAF";
+ }
+ enum "oleaf" {
+ value 2;
+ description
+ "OLEAF";
+ }
+ enum "dsf" {
+ value 3;
+ description
+ "DSF";
+ }
+ enum "truewave" {
+ value 4;
+ description
+ "TRUEWAVE Reduced Slope";
+ }
+ enum "truewavec" {
+ value 5;
+ description
+ "TRUEWAVE Classic";
+ }
+ enum "nz-dsf" {
+ value 6;
+ description
+ "NZ-DSF";
+ }
+ enum "ull" {
+ value 7;
+ description
+ "Ultra Low Loss (ULL)";
+ }
+ }
+ default "smf";
+ description
+ "fiber type
+ Default : SMF ";
+ }
+ leaf span-loss-receive {
+ description
+ "Span loss on the receiver side. Set by the controller and used by device to set AMP gain.";
+ type org-openroadm-common-types:ratio-dB;
+ }
+ leaf span-loss-transmit {
+ description
+ "Span loss on the transmitter side. Set by the controller and used by device to configure MSA compliant channel launch power";
+ type org-openroadm-common-types:ratio-dB;
+ }
+ }
+
+ grouping ots-container {
+ container ots {
+ description
+ "Optical Transport Section (OTS):
+ Models the optical interfaces for an Optical White Box.
+ The network side is represented by the OTS/OMS.";
+ uses ots-attributes;
+ }
+ }
+
+ augment "/org-openroadm-device:org-openroadm-device/org-openroadm-device:interface" {
+ when "org-openroadm-device:type = 'openROADM-if:opticalTransport'";
+ uses ots-container;
+ }
+}
--- /dev/null
+module org-openroadm-otn-common-types {
+ namespace "http://org/openroadm/otn-common-types";
+ prefix org-openroadm-otn-common-types;
+
+ organization
+ "Open ROADM MSA";
+ contact
+ "OpenROADM.org";
+ description
+ "YANG definitions for common otn related type definitions.
+
+ Copyright of the Members of the Open ROADM MSA Agreement dated (c) 2016,
+ AT&T Intellectual Property. All other rights reserved.
+
+ Redistribution and use in source and binary forms, with or without modification,
+ are permitted provided that the following conditions are met:
+
+ * Redistributions of source code must retain the above copyright notice, this
+ list of conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions and the following disclaimer in the documentation and/or
+ other materials provided with the distribution.
+ * Neither the Members of the Open ROADM MSA Agreement nor the names of its
+ contributors may be used to endorse or promote products derived from this software
+ without specific prior written permission.
+
+ THIS SOFTWARE IS PROVIDED BY THE MEMBERS OF THE OPEN ROADM MSA AGREEMENT ''AS IS''
+ AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ IN NO EVENT THE MEMBERS OF THE OPEN ROADM MSA AGREEMENT BE LIABLE FOR ANY DIRECT,
+ INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
+ OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ POSSIBILITY OF SUCH DAMAGE.
+
+ Also contains code components extracted from IETF Interfaces. These code components
+ are copyrighted and licensed as follows:
+
+ Copyright (c) 2016 IETF Trust and the persons identified as the document authors.
+ All rights reserved.
+
+ This document is subject to BCP 78 and the IETF Trust’s Legal Provisions Relating
+ to IETF Documents (http://trustee.ietf.org/license-info) in effect on the date of
+ publication of this document. Please review these documents carefully, as they
+ describe your rights and restrictions with respect to this document. Code Components
+ extracted from this document must include Simplified BSD License text as described in
+ Section 4.e of the Trust Legal Provisions and are provided without warranty as
+ described in the Simplified BSD License.";
+
+ revision 2017-09-29 {
+ description
+ "Version 2.1";
+ }
+
+ identity otu-rate-identity {
+ description
+ "A unique rate identification of the OTU.";
+ }
+
+ identity OTU4 {
+ base otu-rate-identity;
+ description
+ "Identity for an OTU4";
+ }
+
+ identity OTU3 {
+ base otu-rate-identity;
+ description
+ "Identity for an OTU3";
+ }
+
+ identity OTU2 {
+ base otu-rate-identity;
+ description
+ "Identity for an OTU2";
+ }
+
+ identity OTU2e {
+ base otu-rate-identity;
+ description
+ "Identity for an OTU2e";
+ }
+
+ identity OTU1 {
+ base otu-rate-identity;
+ description
+ "Identity for an OTU1";
+ }
+
+ identity OTU0 {
+ base otu-rate-identity;
+ description
+ "Identity for an OTU0";
+ }
+
+ identity OTUflex {
+ base otu-rate-identity;
+ description
+ "Identity for an OTUflex";
+ }
+
+ identity odu-payload-type-identity {
+ description
+ "A unique payload type identification of the ODU.";
+ }
+
+ identity PT20 {
+ base odu-payload-type-identity;
+ description
+ "Identity for an ODU Payload 20";
+ }
+
+ identity PT21 {
+ base odu-payload-type-identity;
+ description
+ "Identity for an ODU Payload 21";
+ }
+
+ identity PT22 {
+ base odu-payload-type-identity;
+ description
+ "Identity for an ODU Payload 22";
+ }
+
+ identity odu-rate-identity {
+ description
+ "A unique rate identification of the ODU.";
+ }
+
+ identity ODU4 {
+ base odu-rate-identity;
+ description
+ "Identity for an ODU4";
+ }
+
+ identity ODU3 {
+ base odu-rate-identity;
+ description
+ "Identity for an ODU3";
+ }
+
+ identity ODU2 {
+ base odu-rate-identity;
+ description
+ "Identity for an ODU2";
+ }
+
+ identity ODU2e {
+ base odu-rate-identity;
+ description
+ "Identity for an ODU2e";
+ }
+
+ identity ODU1 {
+ base odu-rate-identity;
+ description
+ "Identity for an ODU1";
+ }
+
+ identity ODU0 {
+ base odu-rate-identity;
+ description
+ "Identity for an ODU0";
+ }
+
+ identity ODUflex-cbr {
+ base odu-rate-identity;
+ description
+ "Identity for an ODUflex-cbr";
+ }
+
+ identity ODUflex-gfp {
+ base odu-rate-identity;
+ description
+ "Identity for an ODUflex-gfp";
+ }
+
+ identity odtu-type-identity {
+ description
+ "A unique identification for the MSI odtu type.";
+ }
+
+ identity ODTU4.ts-Allocated {
+ base odtu-type-identity;
+ description
+ "OPU4 MSI - ODTU4.ts, OPU4 MSI TS is occupied/allocated.
+ Applies to all ODTU4.x mappings";
+ }
+
+ identity ODTU01 {
+ base odtu-type-identity;
+ description
+ "ODTU01 MSI type";
+ }
+
+ identity ODTU12 {
+ base odtu-type-identity;
+ description
+ "ODTU12 MSI type";
+ }
+
+ identity ODTU13 {
+ base odtu-type-identity;
+ description
+ "ODTU13 MSI type";
+ }
+
+ identity ODTU23 {
+ base odtu-type-identity;
+ description
+ "ODTU23 MSI type";
+ }
+
+ identity ODTU2.ts {
+ base odtu-type-identity;
+ description
+ "ODTU2.ts MSI type";
+ }
+
+ identity ODTU3.ts {
+ base odtu-type-identity;
+ description
+ "ODTU3.ts MSI type";
+ }
+
+ identity unallocated {
+ base odtu-type-identity;
+ description
+ "Unallocated MSI type";
+ }
+
+ identity odu-function-identity {
+ description
+ "A unique identification of the ODUk interface function.";
+ }
+
+ identity ODU-TTP {
+ base odu-function-identity;
+ description
+ "ODU TTP facility facing trail termination";
+ }
+
+ identity ODU-CTP {
+ base odu-function-identity;
+ description
+ "ODU CTP connection termination";
+ }
+
+ identity ODU-TTP-CTP {
+ base odu-function-identity;
+ description
+ "ODU CTP mapper level connection termination with trail termination and client adaptation";
+ }
+
+}
--- /dev/null
+module org-openroadm-otn-network-topology {
+ namespace "http://org/openroadm/otn/network/topology";
+ prefix otn-topo;
+
+ import ietf-network {
+ prefix nd;
+ revision-date 2015-06-08;
+ }
+ import ietf-network-topology {
+ prefix nwt;
+ revision-date 2015-06-08;
+ }
+ import org-openroadm-network-types {
+ prefix org-openroadm-network-types;
+ revision-date 2017-09-29;
+ }
+ import org-openroadm-xponder {
+ prefix xpdr;
+ revision-date 2017-09-29;
+ }
+ import org-openroadm-common-types {
+ prefix ct;
+ revision-date 2017-09-29;
+ }
+
+ organization
+ "OPEN ROADM MSA";
+ contact
+ "OpenROADM.org.";
+ description
+ "YANG definitions for network view of a ROADM
+
+ Copyright of the Members of the Open ROADM MSA Agreement dated (c) 2016,
+ AT&T Intellectual Property. All other rights reserved.
+
+ Redistribution and use in source and binary forms, with or without modification,
+ are permitted provided that the following conditions are met:
+
+ * Redistributions of source code must retain the above copyright notice, this
+ list of conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions and the following disclaimer in the documentation and/or
+ other materials provided with the distribution.
+ * Neither the Members of the Open ROADM MSA Agreement nor the names of its
+ contributors may be used to endorse or promote products derived from this software
+ without specific prior written permission.
+
+ THIS SOFTWARE IS PROVIDED BY THE MEMBERS OF THE OPEN ROADM MSA AGREEMENT ''AS IS''
+ AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ IN NO EVENT THE MEMBERS OF THE OPEN ROADM MSA AGREEMENT BE LIABLE FOR ANY DIRECT,
+ INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
+ OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ POSSIBILITY OF SUCH DAMAGE.";
+
+ revision 2017-09-29 {
+ description
+ "Version 2.1";
+ }
+
+ augment "/nd:network/nd:network-types" {
+ description
+ "Introduce new network type for the Open ROADM OTN
+ ` network topology";
+ container otn-topology {
+ presence "indicates OTN topology for Muxponder, Switchponder and OTN-switch";
+ }
+ }
+ augment "/nd:network/nd:node" {
+ when "../nd:network-types/otn-topology";
+ description
+ "This augmentations adds the OTN Node type to the generic node
+ definition and defines node-sepcific attributes for each node type
+ in the OTN Topology.";
+ leaf node-type {
+ type org-openroadm-network-types:openroadm-node-type;
+ description
+ "The type of a node in the OTN topology. Valid node types are 'MUXPDR' and 'SWITCH'";
+ }
+ container tp-bandwidth-sharing {
+ when "../node-type = 'MUXPDR' or ../node-type = 'SWITCH'";
+ uses org-openroadm-network-types:xpdr-tp-bandwidth-sharing;
+ }
+ container switching-pools {
+ when "../node-type = 'MUXPDR' or ../node-type = 'SWITCH'";
+ uses org-openroadm-network-types:xpdr-odu-switching-pools;
+ description
+ "ODU Switching pool";
+ }
+ container xpdr-attributes {
+ when "../node-type = 'MUXPDR' or ../node-type = 'SWITCH'";
+ uses xpdr:xpdr-topo-node-attributes;
+ description
+ "Topology-related attributes for Xponder nodes";
+ }
+ }
+ augment "/nd:network/nd:node/nwt:termination-point" {
+ when "../../nd:network-types/otn-topology";
+ description
+ "Defines the type of a termination point in the OTN topology and
+ TP-specific attributes for each termination point type.";
+ leaf tp-type {
+ type org-openroadm-network-types:openroadm-tp-type;
+ must "(../../otn-topo:node-type != 'MUXPDR' and ../../otn-topo:node-type != 'SWITCH') or
+ ((../../otn-topo:node-type = 'MUXPDR' or ../../otn-topo:node-type = 'SWITCH') and
+ (../otn-topo:tp-type = 'XPONDER-NETWORK' or ../otn-topo:tp-type = 'XPONDER-CLIENT' or ../otn-topo:tp-type = 'XPONDER-PORT'))" {
+ error-message "Invalid TP for node type Xponder";
+ }
+ description
+ "The TP type; also defines which TP types can be instantiated
+ on which Node types";
+ }
+ leaf eqpt-srg-id {
+ description
+ "Shared Risk Group identifier. All ports in a circuit-pack will have same srg-id";
+ type uint32;
+ }
+ container tp-supported-interfaces {
+ when "../tp-type = 'XPONDER-NETWORK' or ../tp-type = 'XPONDER-CLIENT' or ../tp-type = 'XPONDER-PORT'";
+ uses org-openroadm-network-types:xpdr-tp-supported-interfaces;
+ description
+ "Supported interface capability on the port.";
+ }
+ container xpdr-tp-port-connection-attributes {
+ when "../tp-type = 'XPONDER-NETWORK' or ../tp-type = 'XPONDER-CLIENT' or ../tp-type = 'XPONDER-PORT'";
+ description
+ "Topology-related attributes for Xpdr nodes";
+ uses xpdr:xpdr-otn-tp-attributes;
+ uses xpdr:xpdr-port-connection-attributes;
+ uses xpdr:xpdr-otn-tail-attributes;
+ }
+ }
+ augment "/nd:network/nwt:link" {
+ when "../nd:network-types/otn-topology";
+ description
+ "This augmentation defines Logical link types in the OTN topology connecting OTN elements";
+ leaf link-type {
+ type org-openroadm-network-types:openroadm-link-type;
+ }
+ leaf administrative-group {
+ type uint32;
+ description
+ "according to RFC 3630 definition";
+ }
+ leaf operational-state {
+ type ct:state;
+ description
+ "according to RFC 3630 definition";
+ }
+ leaf administrative-state {
+ type ct:state;
+ description
+ "according to RFC 3630 definition";
+ }
+ leaf available-bandwidth {
+ type uint32;
+ description
+ "Availabled bandwidth between OTN elements";
+ }
+ leaf used-bandwidth {
+ type uint32;
+ description
+ "Used bandwidth between OTN elements";
+ }
+ leaf ODU-protected {
+ type boolean;
+ description
+ "ODU protection flag";
+ }
+ }
+}
--- /dev/null
+module org-openroadm-otn-odu-interfaces {
+ namespace "http://org/openroadm/otn-odu-interfaces";
+ prefix org-openroadm-otn-odu-interfaces;
+
+ import org-openroadm-device {
+ prefix org-openroadm-device;
+ }
+ import org-openroadm-interfaces {
+ prefix openROADM-if;
+ }
+ import org-openroadm-maintenance-testsignal {
+ prefix org-openroadm-maint-testsignal;
+ }
+
+ organization "Open ROADM MSA";
+ contact
+ "OpenROADM.org";
+ description
+ "YANG definitions for device facility otnodu interfaces.
+
+ Copyright of the Members of the Open ROADM MSA Agreement dated (c) 2016,
+ AT&T Intellectual Property. All other rights reserved.
+
+ Redistribution and use in source and binary forms, with or without modification,
+ are permitted provided that the following conditions are met:
+
+ * Redistributions of source code must retain the above copyright notice, this
+ list of conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions and the following disclaimer in the documentation and/or
+ other materials provided with the distribution.
+ * Neither the Members of the Open ROADM MSA Agreement nor the names of its
+ contributors may be used to endorse or promote products derived from this software
+ without specific prior written permission.
+
+ THIS SOFTWARE IS PROVIDED BY THE MEMBERS OF THE OPEN ROADM MSA AGREEMENT ''AS IS''
+ AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ IN NO EVENT THE MEMBERS OF THE OPEN ROADM MSA AGREEMENT BE LIABLE FOR ANY DIRECT,
+ INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
+ OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ POSSIBILITY OF SUCH DAMAGE.
+
+ Also contains code components extracted from IETF Interfaces. These code components
+ are copyrighted and licensed as follows:
+
+ Copyright (c) 2016 IETF Trust and the persons identified as the document authors.
+ All rights reserved.
+
+ This document is subject to BCP 78 and the IETF Trust’s Legal Provisions Relating
+ to IETF Documents (http://trustee.ietf.org/license-info) in effect on the date of
+ publication of this document. Please review these documents carefully, as they
+ describe your rights and restrictions with respect to this document. Code Components
+ extracted from this document must include Simplified BSD License text as described in
+ Section 4.e of the Trust Legal Provisions and are provided without warranty as
+ described in the Simplified BSD License.";
+
+ revision 2016-10-14 {
+ description
+ "Version 1.2";
+ }
+
+ identity odu-rate-identity {
+ description
+ "A unique rate identification of the ODUk.";
+ }
+
+ identity ODU4 {
+ base odu-rate-identity;
+ description
+ "Identity for an ODU4";
+ }
+
+ identity ODU3 {
+ base odu-rate-identity;
+ description
+ "Identity for an ODU3";
+ }
+
+ identity ODU2 {
+ base odu-rate-identity;
+ description
+ "Identity for an ODU2";
+ }
+
+ identity ODU2e {
+ base odu-rate-identity;
+ description
+ "Identity for an ODU2e";
+ }
+
+ identity ODU1 {
+ base odu-rate-identity;
+ description
+ "Identity for an ODU1";
+ }
+
+ identity ODU0 {
+ base odu-rate-identity;
+ description
+ "Identity for an ODU0";
+ }
+
+ identity ODUflex {
+ base odu-rate-identity;
+ description
+ "Identity for an ODUflex";
+ }
+
+ identity odtu-type-identity {
+ description
+ "A unique identification for the MSI odtu type.";
+ }
+
+ identity ODTU4.ts-Allocated {
+ base odtu-type-identity;
+ description
+ "OPU4 MSI - ODTU4.ts, TS is occupied/allocated";
+ }
+
+ identity ODTU4.1 {
+ base odtu-type-identity;
+ description
+ "ODTU4.1 MSI type";
+ }
+
+ identity ODTU4.2 {
+ base odtu-type-identity;
+ description
+ "ODTU4.2 MSI type";
+ }
+
+ identity ODTU4.8 {
+ base odtu-type-identity;
+ description
+ "ODTU4.8 MSI type";
+ }
+
+ identity ODTU4.31 {
+ base odtu-type-identity;
+ description
+ "ODTU4.31 MSI type";
+ }
+
+ identity ODTU01 {
+ base odtu-type-identity;
+ description
+ "ODTU01 MSI type";
+ }
+
+ identity ODTU12 {
+ base odtu-type-identity;
+ description
+ "ODTU12 MSI type";
+ }
+
+ identity ODTU13 {
+ base odtu-type-identity;
+ description
+ "ODTU13 MSI type";
+ }
+
+ identity ODTU23 {
+ base odtu-type-identity;
+ description
+ "ODTU23 MSI type";
+ }
+
+ identity ODTU2.ts {
+ base odtu-type-identity;
+ description
+ "ODTU2.ts MSI type";
+ }
+
+ identity ODTU3.ts {
+ base odtu-type-identity;
+ description
+ "ODTU3.ts MSI type";
+ }
+
+ identity unallocated {
+ base odtu-type-identity;
+ description
+ "Unallocated MSI type";
+ }
+
+ grouping msi-entry {
+ leaf trib-slot {
+ type uint16;
+ description
+ "tributary slot (TS)";
+ }
+ leaf odtu-type {
+ type identityref {
+ base odtu-type-identity;
+ }
+ description
+ "ODTU type, part of the MSI (Multiplex Structure Identifier)";
+ }
+ leaf trib-port {
+ type uint8;
+ description
+ "Tributray Port Number (0-based), part of the MSI";
+ }
+ leaf trib-port-payload {
+ type string;
+ description
+ "interface name being mapped to trib-port";
+ }
+ }
+
+ grouping odu-attributes {
+ description
+ "ODU attributes";
+ leaf rate {
+ type identityref {
+ base odu-rate-identity;
+ }
+ description
+ "rate identity of the ODU. 'identityref' is used
+ to allow to extend for future higher rates";
+ }
+ leaf monitoring-mode {
+ type enumeration {
+ enum "not-terminated" {
+ description
+ "Not Terminated: no detection or generation.
+ Overhead is passed through the interface transparently in receive direction";
+ }
+ enum "terminated" {
+ description
+ "Terminated: detection and generation enabled.
+ Overhead is erased (replaced with all zeros) in receive direction";
+ }
+ enum "monitored" {
+ description
+ "Monitored: detection enabled.
+ Overhead is passed through the interface transparently in receive direction";
+ }
+ }
+ description
+ "Monitoring mode of the ODU Overhead";
+ }
+ leaf proactive-delay-measurement-enabled {
+ type boolean;
+ description
+ "enable/disable proactive Delay Measurement";
+ }
+ list tcm {
+ key "layer";
+ uses tcm-attributes;
+ max-elements "6";
+ description
+ "Tandem Connection Management";
+ }
+ uses opu;
+ }
+
+ grouping opu {
+ container opu {
+ when "../monitoring-mode = 'terminated' or ../monitoring-mode = 'monitored'";
+ description
+ "Optical Channel Payload Unit (OPU)";
+ leaf payload-type {
+ type string {
+ length "2";
+ pattern "[0-9a-fA-F]*";
+ }
+ description
+ "Payload Type";
+ }
+ leaf rx-payload-type {
+ type string {
+ length "2";
+ pattern "[0-9a-fA-F]*";
+ }
+ description
+ "Received Payload Type";
+ }
+ leaf exp-payload-type {
+ type string {
+ length "2";
+ pattern "[0-9a-fA-F]*";
+ }
+ description
+ "Expected Payload Type";
+ }
+ leaf payload-interface {
+ type string;
+ description
+ "Expected Payload of OPU. It designates client interface name";
+ }
+ container msi {
+ when "../payload-type = '20' or ../payload-type = '21'";
+ list tx-msi {
+ key "trib-slot";
+ uses msi-entry;
+ description
+ "Transmit MSI";
+ }
+ list rx-msi {
+ key "trib-slot";
+ uses msi-entry;
+ description
+ "Receive MSI";
+ }
+ list exp-msi {
+ key "trib-slot";
+ uses msi-entry;
+ description
+ "Expected MSI";
+ }
+ }
+ }
+ }
+
+ grouping tcm-attributes {
+ description
+ "Tandem Connection Monitoring (TCM) attributes";
+ leaf layer {
+ type uint8 {
+ range "1..6";
+ }
+ description
+ "TCM layer";
+ }
+ leaf monitoring-mode {
+ type enumeration {
+ enum "not-terminated" {
+ description
+ "Not Terminated: no detection or generation.
+ Overhead is passed through the interface transparently in receive direction
+ unless extension is set for erase";
+ }
+ enum "terminated" {
+ description
+ "Terminated: detection and generation enabled.
+ Overhead is erased (replaced with all zeros) in receive direction, unless
+ extension is set to passthrough";
+ }
+ enum "monitored" {
+ description
+ "Monitored: detection enabled.
+ Overhead is passed through the interface transparently in receive direction
+ unless extension is set for erase";
+ }
+ }
+ description
+ "Monitoring mode of the TCM layer";
+ }
+ leaf ltc-act-enabled {
+ type boolean;
+ description
+ "enable/disable alarm transfer on detection of Loss of Tandem Connection (LTC)";
+ }
+ leaf proactive-delay-measurement-enabled {
+ type boolean;
+ description
+ "enable/disable proactive Delay Measurement";
+ }
+ }
+
+ grouping odu-container {
+ container odu {
+ presence "Attribute Nodes for Optical Data Unit (ODU)";
+ description
+ "Optical Channel Data Unit (ODU)";
+ uses odu-attributes {
+ refine "opu/rx-payload-type" {
+ config false;
+ }
+ refine "opu/msi" {
+ config false;
+ }
+ }
+ uses org-openroadm-maint-testsignal:maint-testsignal;
+ }
+ }
+
+ augment "/org-openroadm-device:org-openroadm-device/org-openroadm-device:interface" {
+ when "org-openroadm-device:type = 'openROADM-if:otnOdu'";
+ uses odu-container;
+ }
+}
--- /dev/null
+module org-openroadm-otn-otu-interfaces {
+ namespace "http://org/openroadm/otn-otu-interfaces";
+ prefix org-openroadm-otn-otu-interfaces;
+
+ import org-openroadm-device {
+ prefix org-openroadm-device;
+ }
+ import org-openroadm-interfaces {
+ prefix openROADM-if;
+ }
+ import org-openroadm-maintenance-loopback {
+ prefix org-openroadm-maint-loopback;
+ }
+
+ organization "Open ROADM MSA";
+ contact
+ "OpenROADM.org";
+ description
+ "YANG definitions for device facility otnotu interfaces.
+
+ Copyright of the Members of the Open ROADM MSA Agreement dated (c) 2016,
+ AT&T Intellectual Property. All other rights reserved.
+
+ Redistribution and use in source and binary forms, with or without modification,
+ are permitted provided that the following conditions are met:
+
+ * Redistributions of source code must retain the above copyright notice, this
+ list of conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions and the following disclaimer in the documentation and/or
+ other materials provided with the distribution.
+ * Neither the Members of the Open ROADM MSA Agreement nor the names of its
+ contributors may be used to endorse or promote products derived from this software
+ without specific prior written permission.
+
+ THIS SOFTWARE IS PROVIDED BY THE MEMBERS OF THE OPEN ROADM MSA AGREEMENT ''AS IS''
+ AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ IN NO EVENT THE MEMBERS OF THE OPEN ROADM MSA AGREEMENT BE LIABLE FOR ANY DIRECT,
+ INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
+ OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ POSSIBILITY OF SUCH DAMAGE.
+
+ Also contains code components extracted from IETF Interfaces. These code components
+ are copyrighted and licensed as follows:
+
+ Copyright (c) 2016 IETF Trust and the persons identified as the document authors.
+ All rights reserved.
+
+ This document is subject to BCP 78 and the IETF Trust’s Legal Provisions Relating
+ to IETF Documents (http://trustee.ietf.org/license-info) in effect on the date of
+ publication of this document. Please review these documents carefully, as they
+ describe your rights and restrictions with respect to this document. Code Components
+ extracted from this document must include Simplified BSD License text as described in
+ Section 4.e of the Trust Legal Provisions and are provided without warranty as
+ described in the Simplified BSD License.";
+
+ revision 2016-10-14 {
+ description
+ "Version 1.2";
+ }
+
+ identity otu-rate-identity {
+ description
+ "A unique rate identification of the OTU.";
+ }
+
+ identity OTU4 {
+ base otu-rate-identity;
+ description
+ "Identity for an OTU4";
+ }
+
+ identity OTU3 {
+ base otu-rate-identity;
+ description
+ "Identity for an OTU3";
+ }
+
+ identity OTU2 {
+ base otu-rate-identity;
+ description
+ "Identity for an OTU2";
+ }
+
+ identity OTU2e {
+ base otu-rate-identity;
+ description
+ "Identity for an OTU2e";
+ }
+
+ identity OTU1 {
+ base otu-rate-identity;
+ description
+ "Identity for an OTU1";
+ }
+
+ identity OTU0 {
+ base otu-rate-identity;
+ description
+ "Identity for an OTU0";
+ }
+
+ identity OTUflex {
+ base otu-rate-identity;
+ description
+ "Identity for an OTUflex";
+ }
+
+ grouping otu-attributes {
+ description
+ "OTU attributes";
+ leaf rate {
+ type identityref {
+ base otu-rate-identity;
+ }
+ description
+ "rate identity of the OTU. 'identityref' is used
+ to allow to extend for future higher rates";
+ }
+ leaf fec {
+ type enumeration {
+ enum "off" {
+ value 0;
+ description
+ "fec off";
+ }
+ enum "rsfec" {
+ value 1;
+ description
+ "rsfec";
+ }
+ enum "sdfeca1" {
+ value 2;
+ description
+ "Clariphy SDFEC";
+ }
+ enum "efec" {
+ value 3;
+ description
+ "G.975.1 I.4";
+ }
+ enum "ufec" {
+ value 4;
+ description
+ "G.975.1 I.7";
+ }
+ enum "sdfec" {
+ value 5;
+ description
+ "Soft decision FEC";
+ }
+ enum "sdfecb1" {
+ value 6;
+ description
+ "SDFEC with SCFEC";
+ }
+ enum "scfec" {
+ value 7;
+ description
+ "Stair case FEC";
+ }
+ }
+ description
+ "Forward Error Correction";
+ }
+ }
+
+ grouping otu-container {
+ container otu {
+ description
+ "Optical Channel Transport Unit (OTU)";
+ uses otu-attributes;
+ uses org-openroadm-maint-loopback:maint-loopback;
+ }
+ }
+
+ augment "/org-openroadm-device:org-openroadm-device/org-openroadm-device:interface" {
+ when "org-openroadm-device:type = 'openROADM-if:otnOtu'";
+ uses otu-container;
+ }
+}
--- /dev/null
+module org-openroadm-physical-types {
+ namespace "http://org/openroadm/physical/types";
+ prefix org-openroadm-physical-types;
+
+ import org-openroadm-common-types {
+ prefix org-openroadm-common-types;
+ }
+ import ietf-yang-types {
+ prefix yang;
+ }
+
+ organization "Open ROADM MSA";
+ contact
+ "OpenROADM.org";
+ description
+ "YANG definitions of physical types.
+
+ Copyright of the Members of the Open ROADM MSA Agreement dated (c) 2016,
+ AT&T Intellectual Property. All other rights reserved.
+
+ Redistribution and use in source and binary forms, with or without modification,
+ are permitted provided that the following conditions are met:
+
+ * Redistributions of source code must retain the above copyright notice, this
+ list of conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions and the following disclaimer in the documentation and/or
+ other materials provided with the distribution.
+ * Neither the Members of the Open ROADM MSA Agreement nor the names of its
+ contributors may be used to endorse or promote products derived from this software
+ without specific prior written permission.
+
+ THIS SOFTWARE IS PROVIDED BY THE MEMBERS OF THE OPEN ROADM MSA AGREEMENT ''AS IS''
+ AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ IN NO EVENT THE MEMBERS OF THE OPEN ROADM MSA AGREEMENT BE LIABLE FOR ANY DIRECT,
+ INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
+ OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ POSSIBILITY OF SUCH DAMAGE.";
+
+ revision 2016-10-14 {
+ description
+ "Version 1.2";
+ }
+
+ grouping node-info {
+ description
+ "Physical inventory data used by the node";
+ leaf vendor {
+ description
+ "Vendor of the equipment";
+ type string;
+ config false;
+ mandatory true;
+ }
+ leaf model {
+ type string;
+ description
+ "Physical resource model information.";
+ config false;
+ mandatory true;
+ }
+ leaf serial-id {
+ description
+ "Product Code for this physical resource";
+ type string;
+ config false;
+ mandatory true;
+ }
+ }
+
+ grouping common-info {
+ description
+ "Physical inventory data used by all other entities";
+ uses node-info;
+ leaf type {
+ description
+ "The specific type of this physical resource - ie the type of
+ shelf, type of circuit-pack, etc.";
+ type string;
+ config false;
+ }
+ leaf product-code {
+ description
+ "Product Code for this physical resource";
+ type string;
+ config false;
+ }
+ leaf manufacture-date {
+ description
+ "Manufactor date of physical resource";
+ type yang:date-and-time;
+ config false;
+ }
+ leaf clei {
+ description
+ "CLEI for this physical resource";
+ type string;
+ config false;
+ }
+ leaf hardware-version {
+ description
+ "The version of the hardware.";
+ type string;
+ config false;
+ }
+ leaf operational-state {
+ description
+ "Operational state of the physical resource";
+ type org-openroadm-common-types:state;
+ config false;
+ }
+ }
+}
--- /dev/null
+module org-openroadm-pm-types {
+ namespace "http://org/openroadm/pm-types";
+ prefix org-openroadm-pm-types;
+
+ import org-openroadm-common-types {
+ prefix org-openroadm-common-types;
+ revision-date 2016-10-14;
+ }
+
+ organization "Open ROADM MSA";
+ contact
+ "OpenROADM.org";
+ description
+ "YANG definitions of performance management types.
+
+ Copyright of the Members of the Open ROADM MSA Agreement dated (c) 2016,
+ AT&T Intellectual Property. All other rights reserved.
+
+ Redistribution and use in source and binary forms, with or without modification,
+ are permitted provided that the following conditions are met:
+
+ * Redistributions of source code must retain the above copyright notice, this
+ list of conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions and the following disclaimer in the documentation and/or
+ other materials provided with the distribution.
+ * Neither the Members of the Open ROADM MSA Agreement nor the names of its
+ contributors may be used to endorse or promote products derived from this software
+ without specific prior written permission.
+
+ THIS SOFTWARE IS PROVIDED BY THE MEMBERS OF THE OPEN ROADM MSA AGREEMENT ''AS IS''
+ AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ IN NO EVENT THE MEMBERS OF THE OPEN ROADM MSA AGREEMENT BE LIABLE FOR ANY DIRECT,
+ INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
+ OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ POSSIBILITY OF SUCH DAMAGE";
+
+ revision 2016-10-14 {
+ description
+ "Version 1.2";
+ }
+
+ typedef pm-granularity {
+ description
+ "Granularity of PM bin";
+ type enumeration {
+ enum "notApplicable" {
+ description
+ "This is for total statistic counters on devices that support
+ them.";
+ value 1;
+ }
+ enum "15min" {
+ value 2;
+ }
+ enum "24Hour" {
+ value 3;
+ }
+ }
+ }
+
+ typedef pm-data-type {
+ type union {
+ type uint64;
+ type decimal64 {
+ fraction-digits 2;
+ }
+ type decimal64 {
+ fraction-digits 17;
+ }
+ }
+ }
+
+ grouping pm-measurement {
+ description
+ "Set of parameters related to a PM Measurement";
+ container pmParameterName {
+ uses pm-names;
+ }
+ leaf pmParameterValue {
+ type pm-data-type;
+ mandatory true;
+ config false;
+ }
+ leaf pmParameterUnit {
+ description
+ "Unit PM parameter has been measured - frames, packets, u, etc";
+ type string;
+ mandatory false;
+ }
+ leaf location {
+ description
+ "Location PM parameter measurement";
+ type enumeration {
+ enum "notApplicable" {
+ value 1;
+ }
+ enum "nearEnd" {
+ value 2;
+ }
+ enum "farEnd" {
+ value 3;
+ }
+ }
+ mandatory false;
+ }
+ leaf direction {
+ description
+ "Direction PM parameter measurement";
+ type org-openroadm-common-types:pm-direction;
+ mandatory false;
+ }
+ leaf validity {
+ description
+ "Validity of data";
+ type enumeration {
+ enum "complete" {
+ value 1;
+ }
+ enum "partial" {
+ value 2;
+ }
+ enum "suspect" {
+ value 3;
+ }
+ }
+ mandatory false;
+ config false;
+ }
+ }
+
+ grouping pm-names {
+ description
+ "Name of PM parameter. Consisists of a set list of parameters,
+ plus an extension field to support addition parameters.";
+ leaf type {
+ type pm-names-enum;
+ mandatory true;
+ }
+ leaf extension {
+ description
+ "name of parameter, when enum value set to vendorExtension because
+ name not found in pm-names-enum";
+ type string;
+ mandatory false;
+ }
+ }
+
+ typedef pm-names-enum {
+ type enumeration {
+ enum "vendorExtension" {
+ value 1;
+ description
+ "vendor extension";
+ }
+ enum "bitErrorRate" {
+ value 2;
+ description
+ "Bit error rate (BER)";
+ }
+ enum "opticalPowerOutput" {
+ value 3;
+ description
+ "Optical Power Output (OPOUT-OTS). Total optical power includes Variable Optical Attenuator (VOA) attenuation";
+ }
+ enum "opticalReturnLoss" {
+ value 4;
+ description
+ "Optical Return Loss (ORL-OTS) - at MW port(s) B";
+ }
+ enum "opticalPowerInput" {
+ value 5;
+ description
+ "Optical Power Input (OPIN-OTS). Total optical power";
+ }
+ enum "opticalPower" {
+ value 6;
+ description
+ "Optical Power Receive (OPR-OTS); Optical Power Transmit (OPT-OSC)";
+ }
+ enum "opticalChannelPowerTransmit" {
+ value 7;
+ description
+ "Optical Channel Power Transmit (OPT-OCH). Individual channel power includes Variable Optical Attenuator (VOA) attenuation";
+ }
+ enum "codeViolations" {
+ value 8;
+ description
+ "Code Violations (CV-PCS). 8B/10B errors";
+ reference "IEEE 802.3ah, Section 45.2.1.44";
+ }
+ enum "erroredSecondsSection" {
+ value 9;
+ description
+ "Errored Seconds Section (ES-PCS)";
+ reference "IEEE 802.3ah, Section 45.2.1.46";
+ }
+ enum "severlyErrorSeconds" {
+ value 10;
+ description
+ "Severely Errored Seconds (SES-PCS)";
+ reference "IEEE 802.3ah, Section 45.2.1.48";
+ }
+ enum "unavailableSecondsPCS" {
+ value 11;
+ description
+ "Unavailable Seconds PCS (UAS-PCS)";
+ reference "IEEE 802.3ah, Section 45.2.1.52";
+ }
+ enum "inFrames" {
+ value 12;
+ description
+ "In frames (INFRAMES-E)";
+ }
+ enum "inFramesErrored" {
+ value 13;
+ description
+ "In frames errored (INFRAMESERR-E)";
+ }
+ enum "outFrames" {
+ value 14;
+ description
+ "Out frames (OUTFRAMES-E)";
+ }
+ enum "erroredSecondsEthernet" {
+ value 15;
+ description
+ "Errored Seconds Ethernet (ES-E)";
+ reference "IEEE 802.3ah, Section 45.2.1.46";
+ }
+ enum "severelyErroredSecondsEthernet" {
+ value 16;
+ description
+ "Severly Errored Seconds, Ethernet (SES-E)";
+ reference "IEEE 802.3ah, Section 45.2.1.48";
+ }
+ enum "unavailableSecondsEthernet" {
+ value 17;
+ description
+ "Unavailable Seconds, Ethernet (UAS-E)";
+ reference "IEEE 802.3ah, Section 45.2.1.52";
+ }
+ enum "erroredBlockCount" {
+ value 18;
+ description
+ "Errored block count";
+ reference "G.798 : 6.5.1.1";
+ }
+ enum "delay" {
+ value 19;
+ description
+ "Number of frames between a DMValue toggle event and the received DMp signal value toggle event";
+ reference "G.798";
+ }
+ enum "defectSeconds" {
+ value 20;
+ description
+ "Defect Seconds (DS)";
+ reference "";
+ }
+ enum "backwardIncomingAlignmentError" {
+ value 21;
+ description
+ "Backward Incoming Alignment Error (BIAE)";
+ reference "Ref: G.798: 14.5.1.1.2";
+ }
+ enum "incomingAlignmentError" {
+ value 22;
+ description
+ "Incoming Alignment Error (IAE)";
+ reference "Ref: G.798: 14.5.1.1.2";
+ }
+ }
+ }
+}
--- /dev/null
+module org-openroadm-pm {
+ namespace "http://org/openroadm/pm";
+ prefix org-openroadm-pm;
+
+ import ietf-yang-types {
+ prefix yang;
+ }
+ import org-openroadm-resource {
+ prefix org-openroadm-resource;
+ }
+ import org-openroadm-layerRate {
+ prefix org-openroadm-layerRate;
+ }
+ import org-openroadm-pm-types {
+ prefix org-openroadm-pm-types;
+ }
+
+ organization "Open ROADM MSA";
+ contact
+ "OpenROADM.org";
+ description
+ "YANG definitions of performance management.
+
+ Copyright of the Members of the Open ROADM MSA Agreement dated (c) 2016,
+ AT&T Intellectual Property. All other rights reserved.
+
+ Redistribution and use in source and binary forms, with or without modification,
+ are permitted provided that the following conditions are met:
+
+ * Redistributions of source code must retain the above copyright notice, this
+ list of conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions and the following disclaimer in the documentation and/or
+ other materials provided with the distribution.
+ * Neither the Members of the Open ROADM MSA Agreement nor the names of its
+ contributors may be used to endorse or promote products derived from this software
+ without specific prior written permission.
+
+ THIS SOFTWARE IS PROVIDED BY THE MEMBERS OF THE OPEN ROADM MSA AGREEMENT ''AS IS''
+ AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ IN NO EVENT THE MEMBERS OF THE OPEN ROADM MSA AGREEMENT BE LIABLE FOR ANY DIRECT,
+ INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
+ OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ POSSIBILITY OF SUCH DAMAGE";
+
+ revision 2016-10-14 {
+ description
+ "Version 1.2";
+ }
+
+ grouping current-pm {
+ description
+ "PM Data with current values - both realtime (granularity=notApplicable) and binned (granularity=15 minute, 24h))";
+ leaf id {
+ type string;
+ mandatory true;
+ config false;
+ }
+ container resource {
+ uses org-openroadm-resource:resource;
+ }
+ container layerRate {
+ uses org-openroadm-layerRate:layer-rate;
+ }
+ list measurements {
+ container measurement {
+ uses org-openroadm-pm-types:pm-measurement;
+ }
+ }
+ leaf retrievalTime {
+ type yang:date-and-time;
+ mandatory true;
+ config false;
+ }
+ leaf granularity {
+ type org-openroadm-pm-types:pm-granularity;
+ }
+ }
+
+ container currentPmlist {
+ description
+ "List of current PMs.";
+ list currentPm {
+ key "id";
+ uses current-pm;
+ }
+ config false;
+ }
+
+ grouping historical-pm {
+ description
+ "PM Data with historical values - binned (granularity=15 minute, 24h))";
+ leaf id {
+ type string;
+ mandatory true;
+ config false;
+ }
+ container resource {
+ uses org-openroadm-resource:resource;
+ }
+ container layerRate {
+ uses org-openroadm-layerRate:layer-rate;
+ }
+ list binned-pm {
+ key "bin-number";
+ uses bin-pm;
+ }
+ leaf granularity {
+ type org-openroadm-pm-types:pm-granularity;
+ }
+ }
+
+ grouping bin-pm {
+ description
+ "PM Data with historical values";
+ leaf bin-number {
+ type uint16 {
+ range "1..max";
+ }
+ mandatory true;
+ config false;
+ }
+ list measurements {
+ container measurement {
+ uses org-openroadm-pm-types:pm-measurement;
+ }
+ }
+ leaf completionTime {
+ type yang:date-and-time;
+ mandatory true;
+ config false;
+ }
+ }
+
+ container historicalPmlist {
+ description
+ "List of historical PM";
+ list historicalPm {
+ key "id";
+ uses historical-pm;
+ }
+ config false;
+ }
+ rpc clear-pm {
+ description "Command to initialize PM data";
+ input {
+ uses org-openroadm-resource:resource;
+ leaf pm-type {
+ default "current";
+ type enumeration {
+ enum "current" {
+ value 1;
+ }
+ enum "all" {
+ value 2;
+ }
+ }
+ }
+ leaf granularity {
+ default "15min";
+ type org-openroadm-pm-types:pm-granularity;
+ }
+ }
+ output {
+ leaf status {
+ type enumeration {
+ enum "Successful" {
+ value 1;
+ }
+ enum "Failed" {
+ value 2;
+ }
+ }
+ mandatory true;
+ description
+ "Successful or Failed";
+ }
+ leaf status-message {
+ type string;
+ description
+ "Gives a more detailed reason for success / failure";
+ }
+ }
+ }
+}
--- /dev/null
+module org-openroadm-port-types {
+ namespace "http://org/openroadm/port/types";
+ prefix org-openroadm-port-types;
+
+ import org-openroadm-common-types {
+ prefix org-openroadm-common-types;
+ revision-date 2017-09-29;
+ }
+
+ organization
+ "Open ROADM MSA";
+ contact
+ "OpenROADM.org";
+ description
+ "YANG definitions for port types.
+
+ Copyright of the Members of the Open ROADM MSA Agreement dated (c) 2016,
+ AT&T Intellectual Property. All other rights reserved.
+
+ Redistribution and use in source and binary forms, with or without modification,
+ are permitted provided that the following conditions are met:
+
+ * Redistributions of source code must retain the above copyright notice, this
+ list of conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions and the following disclaimer in the documentation and/or
+ other materials provided with the distribution.
+ * Neither the Members of the Open ROADM MSA Agreement nor the names of its
+ contributors may be used to endorse or promote products derived from this software
+ without specific prior written permission.
+
+ THIS SOFTWARE IS PROVIDED BY THE MEMBERS OF THE OPEN ROADM MSA AGREEMENT ''AS IS''
+ AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ IN NO EVENT THE MEMBERS OF THE OPEN ROADM MSA AGREEMENT BE LIABLE FOR ANY DIRECT,
+ INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
+ OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ POSSIBILITY OF SUCH DAMAGE.";
+
+ revision 2017-09-29 {
+ description
+ "Version 2.1";
+ }
+ revision 2017-07-28 {
+ description
+ "Version 2.0.1 - added revision-date to imports";
+ }
+ revision 2017-06-26 {
+ description
+ "Version 2.0";
+ }
+ revision 2016-10-14 {
+ description
+ "Version 1.2";
+ }
+
+ identity supported-if-capability {
+ description
+ "Base identity from which specific supported interfaces are derived";
+ }
+
+ identity if-100GE {
+ base supported-if-capability;
+ }
+
+ identity if-OMS {
+ base supported-if-capability;
+ }
+
+ identity if-OTS {
+ base supported-if-capability;
+ }
+
+ identity if-OCH {
+ base supported-if-capability;
+ }
+
+ identity if-1GE {
+ base supported-if-capability;
+ }
+
+ identity if-10GE {
+ base supported-if-capability;
+ }
+
+ identity if-40GE {
+ base supported-if-capability;
+ }
+
+ identity if-OCH-OTU1-ODU1 {
+ base supported-if-capability;
+ }
+
+ identity if-OCH-OTU2-ODU2 {
+ base supported-if-capability;
+ }
+
+ identity if-OCH-OTU2E-ODU2E {
+ base supported-if-capability;
+ }
+
+ identity if-OCH-OTU3-ODU3 {
+ base supported-if-capability;
+ }
+
+ identity if-OCH-OTU4-ODU4 {
+ base supported-if-capability;
+ }
+
+ identity if-OTU4-ODU4 {
+ base supported-if-capability;
+ }
+
+ identity supported-xpdr-capability {
+ description
+ "Base identity from which specific supported xponder are derived";
+ }
+
+ identity Transponder {
+ base supported-xpdr-capability;
+ }
+
+ identity Regen {
+ base supported-xpdr-capability;
+ }
+
+ typedef port-wavelength-types {
+ type enumeration {
+ enum "wavelength" {
+ value 1;
+ description
+ "Port on a transponder or ROADM SRG add drop";
+ }
+ enum "multi-wavelength" {
+ value 2;
+ description
+ "External port connecting to other roadm.";
+ }
+ }
+ description
+ "Port types.";
+ }
+
+ grouping common-port {
+ leaf port-power-capability-min-rx {
+ type org-openroadm-common-types:power-dBm;
+ config false;
+ description
+ "Based on port capabilities, the minimum power in the system spec for this port to
+ provide optimum function in rx direction";
+ }
+ leaf port-power-capability-min-tx {
+ type org-openroadm-common-types:power-dBm;
+ config false;
+ description
+ "Based on port capabilities, the minimum power in the system spec for this port to
+ provide optimum function in tx direction.";
+ }
+ leaf port-power-capability-max-rx {
+ type org-openroadm-common-types:power-dBm;
+ config false;
+ description
+ "Based on port capabilities, the maximum power in the system spec for this port to
+ provide optimum function in rx direction.";
+ }
+ leaf port-power-capability-max-tx {
+ type org-openroadm-common-types:power-dBm;
+ config false;
+ description
+ "Based on port capabilities, the maximum power in the system spec for this port to
+ provide optimum function in tx direction.";
+ }
+ }
+
+ grouping roadm-port {
+ uses common-port;
+ }
+}
--- /dev/null
+module org-openroadm-probable-cause {
+ namespace "http://org/openroadm/probableCause";
+ prefix org-openroadm-probable-cause;
+
+ import org-openroadm-common-types {
+ prefix org-openroadm-common-types;
+ }
+
+ organization "Open ROADM MSA";
+ contact
+ "OpenROADM.org";
+ description
+ "YANG definitions of Probable Causes.
+
+ Copyright of the Members of the Open ROADM MSA Agreement dated (c) 2016,
+ AT&T Intellectual Property. All other rights reserved.
+
+ Redistribution and use in source and binary forms, with or without modification,
+ are permitted provided that the following conditions are met:
+
+ * Redistributions of source code must retain the above copyright notice, this
+ list of conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions and the following disclaimer in the documentation and/or
+ other materials provided with the distribution.
+ * Neither the Members of the Open ROADM MSA Agreement nor the names of its
+ contributors may be used to endorse or promote products derived from this software
+ without specific prior written permission.
+
+ THIS SOFTWARE IS PROVIDED BY THE MEMBERS OF THE OPEN ROADM MSA AGREEMENT ''AS IS''
+ AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ IN NO EVENT THE MEMBERS OF THE OPEN ROADM MSA AGREEMENT BE LIABLE FOR ANY DIRECT,
+ INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
+ OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ POSSIBILITY OF SUCH DAMAGE";
+
+ revision 2016-10-14 {
+ description
+ "Version 1.2";
+ }
+
+ grouping probable-cause {
+ leaf cause {
+ type probable-cause-enum;
+ mandatory true;
+ }
+ leaf extension {
+ type string;
+ mandatory false;
+ }
+ leaf direction {
+ description
+ "Direction indication of the alarm.";
+ type org-openroadm-common-types:direction;
+ }
+ leaf location {
+ description
+ "location indication of the alarm.";
+ type enumeration {
+ enum "NEND" {
+ value 1;
+ description
+ "Near End location";
+ }
+ enum "FEND" {
+ value 2;
+ description
+ "Far End location";
+ }
+ }
+ }
+ }
+
+ typedef probable-cause-enum {
+ type enumeration {
+ enum "vendorExtension" {
+ value 1;
+ description
+ "vendorExtension";
+ }
+ enum "openConnectionIndication" {
+ value 2;
+ description
+ "Open connection indication (OCI)";
+ reference "G.798";
+ }
+ enum "alarmIndicationSignal" {
+ value 3;
+ description
+ "Alarm indication signal";
+ reference "G.798";
+ }
+ enum "lossOfSignal" {
+ value 4;
+ description
+ "Loss of Signal";
+ }
+ enum "opticalLineFail" {
+ value 5;
+ description
+ "Optical Line Fail";
+ }
+ enum "opticalPowerDegraded" {
+ value 6;
+ description
+ "Optical Line Fail";
+ }
+ enum "automaticLaserShutdown" {
+ value 7;
+ description
+ "Optical Line Fail";
+ }
+ enum "serverSignalFail" {
+ value 8;
+ description
+ "Server Signal Fail (SSF)";
+ reference "G.798";
+ }
+ enum "lossofTandemConnection" {
+ value 9;
+ description
+ "Loss of Tandem Connection (LTC)";
+ reference "G.798";
+ }
+ enum "lockedDefect" {
+ value 10;
+ description
+ "Locked defect (LCK)";
+ reference "G.798";
+ }
+ enum "trailTraceIdentifierMismatch" {
+ value 11;
+ description
+ "Trail trace Identifier Mismatch (TIM)";
+ reference "G.798";
+ }
+ enum "degradedEffect" {
+ value 12;
+ description
+ "Degraded defect (DEG)";
+ reference "G.798";
+ }
+ enum "backwardsDefectIndication" {
+ value 13;
+ description
+ "Backward Defect Indication (BDI)";
+ reference "G.798";
+ }
+ enum "otsSpanlossPowerOutOfSpecificationHigh" {
+ value 14;
+ }
+ enum "automaticShutoffDisabled" {
+ value 15;
+ }
+ enum "postBlockManualLaserShutdown" {
+ value 16;
+ }
+ enum "portLossOfLight" {
+ value 17;
+ }
+ enum "reflectionTooHigh" {
+ value 18;
+ }
+ enum "shutoffThresholdCrossed" {
+ value 19;
+ }
+ enum "preBlockSpanAdjustmentInProgress" {
+ value 20;
+ }
+ enum "postBlockSpanAdjustmentInProgress" {
+ value 21;
+ }
+ enum "payloadMissingIndication" {
+ value 22;
+ description
+ "Will be applicable to ROADM when OSC signaling supported in future (G.709 2016-06 Figure 15-1A, 1B)";
+ }
+ enum "forwardDefectIndication" {
+ value 23;
+ description
+ "Will be applicable to ROADM when OSC signaling supported in future (G.709 2016-06 Figure 15-1A, 1B)";
+ }
+ enum "oscPowerOutOfSpecificationHigh" {
+ value 24;
+ }
+ enum "oscPowerOutOfSpecificationLow" {
+ value 25;
+ }
+ enum "powerOutOfSpecificationHigh" {
+ value 26;
+ }
+ enum "lossOfSynchronization" {
+ value 27;
+ }
+ enum "linkDown" {
+ value 28;
+ }
+ enum "equipmentFault" {
+ value 29;
+ }
+ enum "equipmentRemoved" {
+ value 30;
+ }
+ enum "equipmentMismatch" {
+ value 31;
+ }
+ enum "equipmentWarmup" {
+ value 32;
+ }
+ enum "equipmentLedOn" {
+ value 33;
+ }
+ enum "equipmentInterConnectFailure" {
+ value 34;
+ }
+ enum "equipmentMiscabledConnection" {
+ value 35;
+ }
+ enum "softwareVersionMismatch" {
+ value 36;
+ }
+ enum "softwareStageInProgress" {
+ value 37;
+ }
+ enum "databaseCorruption" {
+ value 38;
+ }
+ enum "databaseLockedSoftwareUpgradeInProgress" {
+ value 39;
+ }
+ enum "databaseLockedDbRestoreInProgress" {
+ value 40;
+ }
+ enum "databaseLockedSysInitInProgress" {
+ value 41;
+ }
+ enum "databaseLockedDbAlarmPresent" {
+ value 42;
+ }
+ enum "databaseLockedIlfViolation" {
+ value 43;
+ }
+ enum "databaseVersionMismatch" {
+ value 44;
+ }
+ enum "databaseLockedShelfProvModePresent" {
+ value 45;
+ }
+ enum "firmwareVersionMismatch" {
+ value 46;
+ }
+ enum "firmwareBackwardCompatibleLimited" {
+ value 47;
+ }
+ enum "firmwareBackwardCompatibleAll" {
+ value 48;
+ }
+ enum "incompatibleFirmware" {
+ value 49;
+ }
+ enum "firmwareDownloadOrActivationFailure" {
+ value 50;
+ }
+ enum "firmwareInitInProgress" {
+ value 51;
+ }
+ enum "softwareReset" {
+ value 52;
+ }
+ enum "fanCoolingFail" {
+ value 53;
+ }
+ enum "administrativeDown" {
+ value 54;
+ }
+ enum "lampTest" {
+ value 55;
+ }
+ enum "powerProblemA" {
+ value 56;
+ }
+ enum "powerProblemB" {
+ value 57;
+ }
+ enum "shelfProvisioningMode" {
+ value 58;
+ }
+ enum "sysNameChanged" {
+ value 59;
+ }
+ enum "sysNtpNotSynchronized" {
+ value 60;
+ }
+ enum "ilfViolationMajor" {
+ value 61;
+ }
+ enum "ilfViolationCritical" {
+ value 62;
+ }
+ enum "lossOfFrame" {
+ value 63;
+ }
+ enum "lossOfMultiframe" {
+ value 64;
+ }
+ enum "backwardIncomingAlignmentError" {
+ value 65;
+ }
+ enum "incomingAlignmentError" {
+ value 66;
+ }
+ enum "payloadMismatch" {
+ value 67;
+ }
+ enum "clientSignalFailDefect" {
+ value 68;
+ }
+ enum "backwardIncomingAlignmentErrorTCM1" {
+ value 69;
+ }
+ enum "backwardIncomingAlignmentErrorTCM2" {
+ value 70;
+ }
+ enum "backwardIncomingAlignmentErrorTCM3" {
+ value 71;
+ }
+ enum "backwardIncomingAlignmentErrorTCM4" {
+ value 72;
+ }
+ enum "backwardIncomingAlignmentErrorTCM5" {
+ value 73;
+ }
+ enum "backwardIncomingAlignmentErrorTCM6" {
+ value 74;
+ }
+ enum "incomingAlignmentErrorTCM1" {
+ value 75;
+ }
+ enum "incomingAlignmentErrorTCM2" {
+ value 76;
+ }
+ enum "incomingAlignmentErrorTCM3" {
+ value 77;
+ }
+ enum "incomingAlignmentErrorTCM4" {
+ value 78;
+ }
+ enum "incomingAlignmentErrorTCM5" {
+ value 79;
+ }
+ enum "incomingAlignmentErrorTCM6" {
+ value 80;
+ }
+ enum "backwardsDefectIndicationTCM1" {
+ value 81;
+ }
+ enum "backwardsDefectIndicationTCM2" {
+ value 82;
+ }
+ enum "backwardsDefectIndicationTCM3" {
+ value 83;
+ }
+ enum "backwardsDefectIndicationTCM4" {
+ value 84;
+ }
+ enum "backwardsDefectIndicationTCM5" {
+ value 85;
+ }
+ enum "backwardsDefectIndicationTCM6" {
+ value 86;
+ }
+ enum "degradedDefectTCM1" {
+ value 87;
+ }
+ enum "degradedDefectTCM2" {
+ value 88;
+ }
+ enum "degradedDefectTCM3" {
+ value 89;
+ }
+ enum "degradedDefectTCM4" {
+ value 90;
+ }
+ enum "degradedDefectTCM5" {
+ value 91;
+ }
+ enum "degradedDefectTCM6" {
+ value 92;
+ }
+ enum "trailTraceIdentifierMisMatchTCM1" {
+ value 93;
+ }
+ enum "trailTraceIdentifierMisMatchTCM2" {
+ value 94;
+ }
+ enum "trailTraceIdentifierMisMatchTCM3" {
+ value 95;
+ }
+ enum "trailTraceIdentifierMisMatchTCM4" {
+ value 96;
+ }
+ enum "trailTraceIdentifierMisMatchTCM5" {
+ value 97;
+ }
+ enum "trailTraceIdentifierMisMatchTCM6" {
+ value 98;
+ }
+ enum "alarmIndicationSignalTCM1" {
+ value 99;
+ }
+ enum "alarmIndicationSignalTCM2" {
+ value 100;
+ }
+ enum "alarmIndicationSignalTCM3" {
+ value 101;
+ }
+ enum "alarmIndicationSignalTCM4" {
+ value 102;
+ }
+ enum "alarmIndicationSignalTCM5" {
+ value 103;
+ }
+ enum "alarmIndicationSignalTCM6" {
+ value 104;
+ }
+ enum "openConnectionIndicationTCM1" {
+ value 105;
+ }
+ enum "openConnectionIndicationTCM2" {
+ value 106;
+ }
+ enum "openConnectionIndicationTCM3" {
+ value 107;
+ }
+ enum "openConnectionIndicationTCM4" {
+ value 108;
+ }
+ enum "openConnectionIndicationTCM5" {
+ value 109;
+ }
+ enum "openConnectionIndicationTCM6" {
+ value 110;
+ }
+ enum "lockedDefectTCM1" {
+ value 111;
+ }
+ enum "lockedDefectTCM2" {
+ value 112;
+ }
+ enum "lockedDefectTCM3" {
+ value 113;
+ }
+ enum "lockedDefectTCM4" {
+ value 114;
+ }
+ enum "lockedDefectTCM5" {
+ value 115;
+ }
+ enum "lockedDefectTCM6" {
+ value 116;
+ }
+ enum "lossofTandemConnectionTCM1" {
+ value 117;
+ }
+ enum "lossofTandemConnectionTCM2" {
+ value 118;
+ }
+ enum "lossofTandemConnectionTCM3" {
+ value 119;
+ }
+ enum "lossofTandemConnectionTCM4" {
+ value 120;
+ }
+ enum "lossofTandemConnectionTCM5" {
+ value 121;
+ }
+ enum "lossofTandemConnectionTCM6" {
+ value 122;
+ }
+ enum "highBER" {
+ value 123;
+ }
+ enum "localFault" {
+ value 124;
+ }
+ enum "remoteFault" {
+ value 125;
+ }
+ enum "lossOfAlignment" {
+ value 126;
+ }
+ enum "lossOfFECAlignment" {
+ value 127;
+ }
+ enum "facilityLoopbackActive" {
+ value 128;
+ }
+ enum "facilityLoopback2Active" {
+ value 129;
+ }
+ enum "terminalLoopbackActive" {
+ value 130;
+ }
+ enum "facilityTestsignalActive" {
+ value 131;
+ }
+ enum "terminalTestsignalActive" {
+ value 132;
+ }
+ enum "automaticLaserShutdownDisabled" {
+ value 133;
+ }
+ enum "certificateNotInstalled" {
+ value 134;
+ }
+ }
+ }
+}
--- /dev/null
+module org-openroadm-resource-types {
+ namespace "http://org/openroadm/resource/types";
+ prefix org-openroadm-resource-types;
+
+ organization "Open ROADM MSA";
+ contact
+ "OpenROADM.org";
+ description
+ "YANG definitions of common resource types.
+
+ Copyright of the Members of the Open ROADM MSA Agreement dated (c) 2016,
+ AT&T Intellectual Property. All other rights reserved.
+
+ Redistribution and use in source and binary forms, with or without modification,
+ are permitted provided that the following conditions are met:
+
+ * Redistributions of source code must retain the above copyright notice, this
+ list of conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions and the following disclaimer in the documentation and/or
+ other materials provided with the distribution.
+ * Neither the Members of the Open ROADM MSA Agreement nor the names of its
+ contributors may be used to endorse or promote products derived from this software
+ without specific prior written permission.
+
+ THIS SOFTWARE IS PROVIDED BY THE MEMBERS OF THE OPEN ROADM MSA AGREEMENT ''AS IS''
+ AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ IN NO EVENT THE MEMBERS OF THE OPEN ROADM MSA AGREEMENT BE LIABLE FOR ANY DIRECT,
+ INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
+ OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ POSSIBILITY OF SUCH DAMAGE";
+
+ revision 2016-10-14 {
+ description
+ "Version 1.2";
+ }
+
+ grouping resource-type {
+ leaf type {
+ type resource-type-enum;
+ mandatory true;
+ }
+ leaf extension {
+ type string;
+ mandatory false;
+ }
+ }
+
+ typedef resource-type-enum {
+ type enumeration {
+ enum "other" {
+ value 1;
+ description
+ "Resource of type not found in list.";
+ }
+ enum "device" {
+ value 2;
+ description
+ "device - ROAMD, Xponder, etc";
+ }
+ enum "degree" {
+ value 3;
+ description
+ "degree";
+ }
+ enum "shared-risk-group" {
+ value 4;
+ description
+ "shared-risk-group";
+ }
+ enum "connection" {
+ value 5;
+ description
+ "connection";
+ }
+ enum "connection-map" {
+ value 6;
+ description
+ "connection-map";
+ }
+ enum "port" {
+ value 7;
+ description
+ "port";
+ }
+ enum "circuit-pack" {
+ value 8;
+ description
+ "circuit pack";
+ }
+ enum "internal-link" {
+ value 9;
+ description
+ "internal-link";
+ }
+ enum "physical-link" {
+ value 10;
+ description
+ "physical-link";
+ }
+ enum "interface" {
+ value 11;
+ description
+ "interface";
+ }
+ enum "shelf" {
+ value 12;
+ description
+ "shelf";
+ }
+ enum "service" {
+ value 13;
+ description
+ "service";
+ }
+ }
+ }
+
+ grouping device-id {
+ description
+ "Device identifier. Unique within the Controller.";
+ leaf node-id {
+ description
+ "Node Id is a globally unique identifier for a device.
+ Same as leafref value in model, if applicable.";
+ type string;
+ }
+ }
+
+ grouping circuit-pack-name {
+ leaf circuit-pack-name {
+ description
+ "Circuit-Pack identifier. Unique within the context of a device.
+ Same as leafref value in model, if applicable.";
+ type string;
+ mandatory true;
+ }
+ }
+
+ grouping port-name {
+ uses circuit-pack-name;
+ leaf port-name {
+ description
+ "Port identifier. Unique within the context of a circuit-pack.
+ Same as leafref value in model, if applicable.";
+ type string;
+ }
+ }
+
+ grouping physical-link-name {
+ leaf physical-link-name {
+ description
+ "Physical Link identifier. Unique within the context of a device.
+ Same as leafref value in model, if applicable.";
+ type string;
+ mandatory true;
+ }
+ }
+
+ grouping internal-link-name {
+ leaf internal-link-name {
+ description
+ "Internal Link identifier. Unique within the context of a device.
+ Same as leafref value in model, if applicable.";
+ type string;
+ mandatory true;
+ }
+ }
+
+ grouping connection-number {
+ leaf connection-number {
+ description
+ "Connection identifier. Unique within the context of a device.
+ Same as leafref value in model, if applicable.";
+ type string;
+ }
+ }
+
+ grouping degree-number {
+ leaf degree-number {
+ description
+ "Degree identifier. Unique within the context of a device.
+ Same as leafref value in model, if applicable.";
+ type uint16;
+ }
+ }
+
+ grouping srg-number {
+ leaf srg-number {
+ description
+ "Shared Risk Group identifier. Unique within the context of a device.
+ Same as leafref value in model, if applicable.";
+ type uint16;
+ }
+ }
+
+ grouping shelf-name {
+ leaf shelf-name {
+ description
+ "Shelf-id identifier. Unique within the context of a device.
+ Same as leafref value in model, if applicable.";
+ type string;
+ mandatory true;
+ }
+ }
+
+ grouping service-name {
+ leaf service-name {
+ description
+ "Service identifier. Unique within the context of a network.
+ Same as leafref value in model, if applicable.";
+ type string;
+ mandatory true;
+ }
+ }
+
+ grouping interface-name {
+ leaf interface-name {
+ description
+ "Interface identifier.";
+ type string;
+ mandatory true;
+ }
+ }
+
+ typedef resource-notification-type {
+ description
+ "Type of notification about a resource";
+ type enumeration {
+ enum "resourceCreation" {
+ value 1;
+ description
+ "A new instance of a resource has been created.";
+ }
+ enum "resourceModification" {
+ value 2;
+ description
+ "An exhisting instance of a resource has been modified. This shall be triggered by changes in configuration, state, status etc.
+ It shall not be triggered by changes in performance measurements, power and temperature readings or any other data that is highlyvolatile. ";
+ }
+ enum "resourceDeletion" {
+ value 3;
+ description
+ "An exhisting instance of a resource has been removed.";
+ }
+ }
+ }
+}
--- /dev/null
+module org-openroadm-resource {
+ namespace "http://org/openroadm/resource";
+ prefix org-openroadm-resource;
+
+ import org-openroadm-resource-types {
+ prefix org-openroadm-resource-types;
+ }
+
+ organization "Open ROADM MSA";
+ contact
+ "OpenROADM.org";
+ description
+ "YANG definitions of resources.
+
+ Copyright of the Members of the Open ROADM MSA Agreement dated (c) 2016,
+ AT&T Intellectual Property. All other rights reserved.
+
+ Redistribution and use in source and binary forms, with or without modification,
+ are permitted provided that the following conditions are met:
+
+ * Redistributions of source code must retain the above copyright notice, this
+ list of conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions and the following disclaimer in the documentation and/or
+ other materials provided with the distribution.
+ * Neither the Members of the Open ROADM MSA Agreement nor the names of its
+ contributors may be used to endorse or promote products derived from this software
+ without specific prior written permission.
+
+ THIS SOFTWARE IS PROVIDED BY THE MEMBERS OF THE OPEN ROADM MSA AGREEMENT ''AS IS''
+ AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ IN NO EVENT THE MEMBERS OF THE OPEN ROADM MSA AGREEMENT BE LIABLE FOR ANY DIRECT,
+ INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
+ OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ POSSIBILITY OF SUCH DAMAGE";
+
+ revision 2016-10-14 {
+ description
+ "Version 1.2";
+ }
+
+ grouping resource {
+ description
+ "This resource identifier is intended to provide a generic identifer
+ for any resource that can be used without specific knowledge of
+ the resource.";
+ container device {
+ description
+ "Device of the resource, used only when the system using this
+ model report on more than one device. ";
+ uses org-openroadm-resource-types:device-id;
+ }
+ container resource {
+ choice resource {
+ case circuit-pack {
+ uses org-openroadm-resource-types:circuit-pack-name;
+ }
+ case port {
+ container port {
+ uses org-openroadm-resource-types:port-name;
+ }
+ }
+ case connection {
+ uses org-openroadm-resource-types:connection-number {
+ refine connection-number {
+ mandatory true;
+ }
+ }
+ }
+ case physical-link {
+ uses org-openroadm-resource-types:physical-link-name;
+ }
+ case internal-link {
+ uses org-openroadm-resource-types:internal-link-name;
+ }
+ case shelf {
+ uses org-openroadm-resource-types:shelf-name;
+ }
+ case srg {
+ uses org-openroadm-resource-types:srg-number {
+ refine srg-number {
+ mandatory true;
+ }
+ }
+ }
+ case degree {
+ uses org-openroadm-resource-types:degree-number {
+ refine degree-number {
+ mandatory true;
+ }
+ }
+ }
+ case service {
+ uses org-openroadm-resource-types:service-name;
+ }
+ case interface {
+ uses org-openroadm-resource-types:interface-name;
+ }
+ }
+ }
+ container resourceType {
+ uses org-openroadm-resource-types:resource-type;
+ }
+ }
+}
--- /dev/null
+module org-openroadm-routing-constraints {
+ namespace "http://org/openroadm/routing/constrains";
+ prefix org-openroadm-routing-constraints;
+
+ organization
+ "Open ROADM MSA";
+ contact
+ "OpenROADM.org";
+ description
+ "YANG definitions of routing constraints.
+
+ Copyright of the Members of the Open ROADM MSA Agreement dated (c) 2016,
+ AT&T Intellectual Property. All other rights reserved.
+
+ Redistribution and use in source and binary forms, with or without modification,
+ are permitted provided that the following conditions are met:
+
+ * Redistributions of source code must retain the above copyright notice, this
+ list of conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions and the following disclaimer in the documentation and/or
+ other materials provided with the distribution.
+ * Neither the Members of the Open ROADM MSA Agreement nor the names of its
+ contributors may be used to endorse or promote products derived from this software
+ without specific prior written permission.
+
+ THIS SOFTWARE IS PROVIDED BY THE MEMBERS OF THE OPEN ROADM MSA AGREEMENT ''AS IS''
+ AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ IN NO EVENT THE MEMBERS OF THE OPEN ROADM MSA AGREEMENT BE LIABLE FOR ANY DIRECT,
+ INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
+ OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ POSSIBILITY OF SUCH DAMAGE";
+
+ revision 2016-10-14 {
+ description
+ "Version 1.2";
+ }
+
+ grouping routing-constraints {
+ container hard-constraints {
+ uses constraints;
+ }
+ container soft-constraints {
+ uses constraints;
+ }
+ }
+
+ grouping constraints {
+ leaf-list customer-code {
+ type string;
+ }
+ choice co-routing-or-general {
+ case general {
+ container diversity {
+ uses diversity-existing-service-contraints;
+ }
+ container exclude {
+ uses common-constraints;
+ leaf-list supporting-service-name {
+ description
+ "Supporting service(s) to exclude from this route.";
+ type string;
+ }
+ }
+ container include {
+ uses common-constraints;
+ leaf-list supporting-service-name {
+ description
+ "Supporting service(s) to include in this route.";
+ type string;
+ }
+ }
+ container latency {
+ description
+ "Maximum latency allowed";
+ leaf max-latency {
+ type uint32;
+ units "ms";
+ }
+ }
+ }
+ case co-routing {
+ container co-routing {
+ leaf-list existing-service {
+ type string;
+ description
+ "Diverse from existing services identified by facility CLFI";
+ }
+ }
+ }
+ }
+ }
+
+ grouping common-constraints {
+ leaf-list fiber-bundle {
+ type string;
+ }
+ leaf-list site {
+ type string;
+ }
+ leaf-list node-id {
+ type string;
+ }
+ }
+
+ grouping diversity-existing-service-contraints {
+ leaf-list existing-service {
+ type string;
+ description
+ "Diverse from existing services identified by facility CLFI";
+ }
+ container existing-service-applicability {
+ leaf site {
+ type boolean;
+ }
+ leaf node {
+ type boolean;
+ }
+ leaf srlg {
+ type boolean;
+ }
+ }
+ }
+}
--- /dev/null
+module org-openroadm-rstp {
+ namespace "http://org/openroadm/rstp";
+ prefix org-openroadm-rstp;
+
+ import org-openroadm-device {
+ prefix org-openroadm-device;
+ }
+
+ organization "Open ROADM MSA";
+ contact
+ "OpenROADM.org";
+ description
+ "YANG definitions for rstp protocol.
+
+
+ Copyright of the Members of the Open ROADM MSA Agreement dated (c) 2016,
+ AT&T Intellectual Property. All other rights reserved.
+
+ Redistribution and use in source and binary forms, with or without modification,
+ are permitted provided that the following conditions are met:
+
+ * Redistributions of source code must retain the above copyright notice, this
+ list of conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions and the following disclaimer in the documentation and/or
+ other materials provided with the distribution.
+ * Neither the Members of the Open ROADM MSA Agreement nor the names of its
+ contributors may be used to endorse or promote products derived from this software
+ without specific prior written permission.
+
+ THIS SOFTWARE IS PROVIDED BY THE MEMBERS OF THE OPEN ROADM MSA AGREEMENT ''AS IS''
+ AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ IN NO EVENT THE MEMBERS OF THE OPEN ROADM MSA AGREEMENT BE LIABLE FOR ANY DIRECT,
+ INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
+ OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ POSSIBILITY OF SUCH DAMAGE.";
+
+ revision 2016-10-14 {
+ description
+ "Version 1.2";
+ }
+
+ typedef bridge-id-type {
+ type string;
+ description
+ "Unique Bridge Identifier";
+ }
+
+ grouping rstp-common-bridge-config {
+ leaf bridge-priority {
+ description
+ "Bridge Priority Value";
+ type uint32 {
+ range "0..61440";
+ }
+ default "32768";
+ }
+ leaf shutdown {
+ description
+ "Bridge admin state";
+ type empty;
+ }
+ leaf hold-time {
+ description
+ "The time interval during which no more than two
+ BPDUs transmitted by this node in seconds - not used in rstp mode (in seconds)";
+ type uint32 {
+ range "1..10";
+ }
+ default "2";
+ }
+ leaf hello-time {
+ description
+ "The time between the transmission of BPDU's by this node on any
+ port, when role is rooti (in seconds)";
+ type uint32 {
+ range "1..10";
+ }
+ default "2";
+ }
+ leaf max-age {
+ description
+ "The value that all bridges use for MaxAge when this bridge
+ is acting as the root";
+ type uint32 {
+ range "6..40";
+ }
+ default "20";
+ }
+ leaf forward-delay {
+ description
+ "The port on the Switch spends this time in the listening
+ state while moving from the blocking state to the forwarding state (in seconds)";
+ type uint32 {
+ range "4..30";
+ }
+ default "15";
+ }
+ leaf transmit-hold-count {
+ description
+ "Maximum BPDU transmission rate";
+ type uint32 {
+ range "1..10";
+ }
+ default "2";
+ }
+ }
+
+ grouping rstp-root-bridge-attr {
+ leaf root-bridge-port {
+ description
+ "Port id of the root port";
+ type uint32;
+ }
+ leaf root-path-cost {
+ description
+ "The cost of the path to the root as
+ seen from this bridge";
+ type uint32;
+ }
+ leaf root-bridge-priority {
+ description
+ "Root Bridge Priority Value";
+ type uint32;
+ }
+ leaf root-bridge-id {
+ description
+ "Root Bridge identifier";
+ type bridge-id-type;
+ }
+ leaf root-hold-time {
+ description
+ "The time interval during which no more than two
+ BPDUs transmitted by this node in seconds at root node (in seconds)";
+ type uint32;
+ }
+ leaf root-hello-time {
+ description
+ "The time between the transmission of BPDU's used at root node (in seconds)";
+ type uint32;
+ }
+ leaf root-max-age {
+ description
+ "The value that all bridges use for MaxAge used at root node";
+ type uint32;
+ }
+ leaf root-forward-delay {
+ description
+ "The time in seconds spent on the listening state used at root node (in seconds)";
+ type uint32;
+ }
+ }
+
+ grouping rstp-bridge-port-state-attr {
+ list rstp-bridge-port-table {
+ max-elements "15";
+ description
+ "This table contains port-specific information for rstp state attributes";
+ key "ifname";
+ leaf ifname {
+ description
+ "Interface name of the port";
+ type string {
+ length "1..255";
+ }
+ }
+ leaf bridge-port-state {
+ description
+ "The port's current state";
+ type enumeration {
+ enum "discarding";
+ enum "blocked";
+ enum "learning";
+ enum "forwarding";
+ enum "unknown";
+ }
+ }
+ leaf bridge-port-role {
+ description
+ "The role payed by this port in the bridge";
+ type enumeration {
+ enum "designated";
+ enum "root";
+ enum "alternate";
+ enum "disabled";
+ enum "backup";
+ enum "unknown";
+ }
+ }
+ leaf bridge-port-id {
+ description
+ "Unique port id of this port";
+ type uint32;
+ }
+ leaf oper-edge-bridge-port {
+ description
+ "The operational value of the Edge Port parameter";
+ type empty;
+ }
+ leaf designated-bridge-port {
+ description
+ "Port id of the designated port";
+ type uint32;
+ }
+ leaf designated-bridgeid {
+ description
+ "The Bridge Identifier of the bridge that this port considers
+ to be the Designated Bridge for this port's segment";
+ type bridge-id-type;
+ }
+ }
+ }
+
+ grouping rstp-bridge-port-attr {
+ list rstp-bridge-port-table {
+ max-elements "15";
+ description
+ "Table contains port-specific information for rstp config";
+ key "ifname";
+ leaf ifname {
+ description
+ "Interface name of the port";
+ type leafref {
+ path "/org-openroadm-device:org-openroadm-device/org-openroadm-device:interface/org-openroadm-device:name";
+ }
+ }
+ leaf cost {
+ description
+ "The contribution of this port to the path cost of
+ paths towards the spanning tree root which include this port also";
+ type uint32 {
+ range "2000..200000";
+ }
+ default "20000";
+ }
+ leaf priority {
+ description
+ "The value of the priority field";
+ type uint32 {
+ range "0..240";
+ }
+ }
+ }
+ }
+
+ grouping rstp-container {
+ container rstp {
+ description
+ "Open ROADM RSTP top level";
+ list rstp-bridge-instance {
+ max-elements "1";
+ description
+ "rstp bridge instance, max instance = 1";
+ key "bridge-name";
+ leaf bridge-name {
+ description
+ "unique name of the bridge";
+ type string {
+ length "1..255";
+ }
+ }
+ container rstp-config {
+ description
+ "Collection of rstp configuration attributes";
+ uses rstp-common-bridge-config;
+ uses rstp-bridge-port-attr;
+ }
+ container rstp-state {
+ description
+ "Collection of rstp operational attributes";
+ config false;
+ container rstp-bridge-attr {
+ description
+ "Collection of operational rstp bridge attributes";
+ uses rstp-root-bridge-attr;
+ leaf bridge-id {
+ description
+ "Bridge identifier of the bridge";
+ type bridge-id-type;
+ }
+ leaf topo-change-count {
+ description
+ "The total number of topology changes";
+ type uint32;
+ }
+ leaf time-since-topo-change {
+ description
+ "Time since last topology changes occured (in seconds)";
+ type uint32;
+ }
+ }
+ container rstp-bridge-port-attr {
+ description
+ "Collection of operational rstp port related attributes";
+ uses rstp-bridge-port-state-attr;
+ }
+ }
+ }
+ }
+ }
+
+ augment "/org-openroadm-device:org-openroadm-device/org-openroadm-device:protocols" {
+ when "/org-openroadm-device:org-openroadm-device/org-openroadm-device:info/org-openroadm-device:node-type='rdm'";
+ uses rstp-container;
+ }
+}
--- /dev/null
+module org-openroadm-service {
+ namespace "http://org/openroadm/service";
+ prefix org-openroadm-service;
+
+ import ietf-yang-types {
+ prefix yang;
+ }
+ import org-openroadm-routing-constraints {
+ prefix org-openroadm-routing-constraints;
+ }
+ import org-openroadm-common-types {
+ prefix org-openroadm-common-types;
+ revision-date 2016-10-14;
+ }
+ import org-openroadm-resource-types {
+ prefix org-openroadm-resource-types;
+ }
+ import org-openroadm-common-service-types {
+ prefix org-openroadm-common-service-types;
+ }
+
+ organization
+ "Open ROADM MSA";
+ contact
+ "OpenROADM.org";
+ description
+ "YANG definitions of services.
+
+ Copyright of the Members of the Open ROADM MSA Agreement dated (c) 2016,
+ AT&T Intellectual Property. All other rights reserved.
+
+ Redistribution and use in source and binary forms, with or without modification,
+ are permitted provided that the following conditions are met:
+
+ * Redistributions of source code must retain the above copyright notice, this
+ list of conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions and the following disclaimer in the documentation and/or
+ other materials provided with the distribution.
+ * Neither the Members of the Open ROADM MSA Agreement nor the names of its
+ contributors may be used to endorse or promote products derived from this software
+ without specific prior written permission.
+
+ THIS SOFTWARE IS PROVIDED BY THE MEMBERS OF THE OPEN ROADM MSA AGREEMENT ''AS IS''
+ AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ IN NO EVENT THE MEMBERS OF THE OPEN ROADM MSA AGREEMENT BE LIABLE FOR ANY DIRECT,
+ INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
+ OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ POSSIBILITY OF SUCH DAMAGE";
+
+ revision 2016-10-14 {
+ description
+ "Version 1.2";
+ }
+
+ rpc service-create {
+ input {
+ leaf service-name {
+ type string;
+ description
+ "Identifier for the service to be created in
+ the ROADM network, e.g., CLFI, CLCI, etc. This is reported against the service, but may not get reflected in the service in the network.";
+ mandatory true;
+ }
+ leaf common-id {
+ type string;
+ description
+ "To be used by the ROADM controller to identify the routing constraints received from planning application (PED).";
+ }
+ uses org-openroadm-common-service-types:sdnc-request-header;
+ leaf connection-type {
+ type org-openroadm-common-service-types:connection-type;
+ mandatory true;
+ }
+ container service-a-end {
+ uses org-openroadm-common-service-types:service-endpoint;
+ }
+ container service-z-end {
+ uses org-openroadm-common-service-types:service-endpoint;
+ }
+ uses org-openroadm-routing-constraints:routing-constraints;
+ uses org-openroadm-common-service-types:service-information;
+ }
+ output {
+ uses org-openroadm-common-service-types:configuration-response-common;
+ uses org-openroadm-common-service-types:response-parameters;
+ }
+ description
+ "Whether this request passed initial validation and was accepted for processing. Once the request completes processing, a
+ service-rpc-result Notification shall be sent.";
+ }
+ rpc service-feasibility-check {
+ input {
+ leaf common-id {
+ type string;
+ mandatory true;
+ description
+ "To be used by the ROADM controller to identify the routing
+ constraints received from planning application (PED).";
+ }
+ uses org-openroadm-common-service-types:sdnc-request-header;
+ leaf connection-type {
+ type org-openroadm-common-service-types:connection-type;
+ }
+ container service-a-end {
+ uses org-openroadm-common-service-types:service-endpoint;
+ }
+ container service-z-end {
+ uses org-openroadm-common-service-types:service-endpoint;
+ }
+ uses org-openroadm-routing-constraints:routing-constraints;
+ uses org-openroadm-common-service-types:service-information;
+ }
+ output {
+ uses org-openroadm-common-service-types:configuration-response-common;
+ uses org-openroadm-common-service-types:response-parameters;
+ container service-a-end {
+ uses org-openroadm-common-service-types:service-endpoint;
+ list equipment-required {
+ description
+ "List of required equipment, including equipment type and quantity";
+ key "eqipment-identifier";
+ leaf eqipment-identifier {
+ type string;
+ }
+ leaf equipment-type {
+ type string;
+ }
+ leaf equipment-quantity {
+ type uint32;
+ }
+ }
+ }
+ container service-z-end {
+ uses org-openroadm-common-service-types:service-endpoint;
+ list equipment-required {
+ description
+ "List of required equipment, including equipment type and quantity";
+ key "eqipment-identifier";
+ leaf eqipment-identifier {
+ type string;
+ }
+ leaf equipment-type {
+ type string;
+ }
+ leaf equipment-quantity {
+ type uint32;
+ }
+ }
+ }
+ list intermediate-sites {
+ key "clli";
+ uses org-openroadm-common-service-types:service-endpoint;
+ list equipment-required {
+ description
+ "List of required equipment, including equipment type and quantity";
+ key "eqipment-identifier";
+ leaf eqipment-identifier {
+ type string;
+ }
+ leaf equipment-type {
+ type string;
+ }
+ leaf equipment-quantity {
+ type uint32;
+ }
+ }
+ }
+ }
+ description
+ "Whether a service was possible to be created, and if so
+ the routing constraints match and the a and z end connection that have
+ to match";
+ }
+ rpc service-delete {
+ input {
+ uses org-openroadm-common-service-types:sdnc-request-header;
+ container service-delete-req-info {
+ leaf service-name {
+ type string;
+ description
+ "Identifier for the service to be deleted in
+ the ROADM network, e.g., CLFI, CLCI, etc.";
+ mandatory true;
+ }
+ leaf due-date {
+ type yang:date-and-time;
+ description
+ "date and time service to be turned down. If missing, now.";
+ }
+ leaf tail-retention {
+ type enumeration {
+ enum "yes" {
+ value 1;
+ description
+ "tails are left intact ";
+ }
+ enum "no" {
+ value 2;
+ description
+ "tails are deleted";
+ }
+ }
+ mandatory true;
+ }
+ }
+ }
+ output {
+ uses org-openroadm-common-service-types:configuration-response-common;
+ }
+ description
+ "Whether this request passed initial validation and was accepted for processing. Once the request completes processing, a
+ service-rpc-result Notification shall be sent. Once the service has been deleted, it no longer will appear in the service list";
+ }
+ rpc equipment-notification {
+ input {
+ uses org-openroadm-common-service-types:sdnc-request-header;
+ leaf equiptment-id {
+ type string;
+ mandatory true;
+ }
+ leaf equipment-name {
+ type string;
+ }
+ leaf equipemt-type {
+ type string;
+ mandatory true;
+ }
+ leaf equipment-vendor {
+ type string;
+ mandatory true;
+ }
+ leaf equipment-customer {
+ type string;
+ }
+ leaf equipment-clli {
+ type string;
+ mandatory true;
+ }
+ leaf equipment-ip {
+ type string;
+ }
+ leaf controller-id {
+ type string;
+ mandatory true;
+ }
+ }
+ output {
+ uses org-openroadm-common-service-types:configuration-response-common;
+ }
+ }
+ rpc temp-service-create {
+ input {
+ leaf common-id {
+ type string;
+ description
+ "To be used by the ROADM controller to identify the routing constraints received from planning application (PED).";
+ mandatory true;
+ }
+ uses org-openroadm-common-service-types:sdnc-request-header;
+ leaf connection-type {
+ type org-openroadm-common-service-types:connection-type;
+ mandatory true;
+ }
+ container service-a-end {
+ uses org-openroadm-common-service-types:service-endpoint;
+ }
+ container service-z-end {
+ uses org-openroadm-common-service-types:service-endpoint;
+ }
+ uses org-openroadm-routing-constraints:routing-constraints;
+ uses org-openroadm-common-service-types:service-information;
+ }
+ output {
+ uses org-openroadm-common-service-types:configuration-response-common;
+ uses org-openroadm-common-service-types:response-parameters;
+ }
+ }
+ rpc temp-service-delete {
+ input {
+ leaf common-id {
+ type string;
+ mandatory true;
+ }
+ }
+ output {
+ uses org-openroadm-common-service-types:configuration-response-common;
+ }
+ }
+ rpc service-roll {
+ input {
+ leaf service-name {
+ type string;
+ mandatory true;
+ description
+ "Identifier for the service to be rolled in
+ the ROADM network, e.g., CLFI, CLCI, etc.";
+ }
+ leaf due-date {
+ type yang:date-and-time;
+ description
+ "date and time service to be rolled";
+ }
+ }
+ output {
+ uses org-openroadm-common-types:rpc-response-status;
+ }
+ }
+ rpc service-reconfigure {
+ input {
+ leaf service-name {
+ type string;
+ mandatory true;
+ description
+ "Existing identifier for the service to be
+ reconfigured in the ROADM network, e.g., CLFI, CLCI, etc.";
+ }
+ leaf new-service-name {
+ type string;
+ description
+ "New identifier for the service to be
+ reconfigured in the ROADM network, e.g., CLFI, CLCI, etc.";
+ }
+ leaf common-id {
+ type string;
+ description
+ "To be used by the ROADM controller to identify the routing
+ constraints received from planning application (PED).";
+ }
+ leaf connection-type {
+ type org-openroadm-common-service-types:connection-type;
+ }
+ container service-a-end {
+ uses org-openroadm-common-service-types:service-endpoint;
+ }
+ container service-z-end {
+ uses org-openroadm-common-service-types:service-endpoint;
+ }
+ uses org-openroadm-routing-constraints:routing-constraints;
+ uses org-openroadm-common-service-types:service-information;
+ }
+ output {
+ uses org-openroadm-common-types:rpc-response-status;
+ }
+ description
+ "Whether this request passed initial validation and was accepted for processing. Once the request completes processing, a
+ service-rpc-result Notification shall be sent.";
+ }
+ rpc service-restoration {
+ input {
+ leaf service-name {
+ type string;
+ mandatory true;
+ description
+ "Identifier for the service to be restored in
+ the ROADM network, e.g., CLFI, CLCI, etc.";
+ }
+ leaf option {
+ type enumeration {
+ enum "permanent" {
+ value 1;
+ description
+ "A spare regen can be used to restore the
+ service permanently without reverting back to the
+ original regen";
+ }
+ enum "temporary" {
+ value 2;
+ description
+ "a spare regen can be used to restore the
+ service temporarily. The service needs to be reverted
+ back to the original regen transponder";
+ }
+ }
+ mandatory true;
+ }
+ }
+ output {
+ uses org-openroadm-common-types:rpc-response-status;
+ }
+ description
+ "Whether this request passed initial validation and was accepted for processing. Once the request completes processing, a
+ service-rpc-result Notification shall be sent.";
+ }
+ rpc service-reversion {
+ input {
+ leaf service-name {
+ type string;
+ mandatory true;
+ description
+ "Identifier for the service to be reverted
+ in the ROADM network, e.g., CLFI, CLCI, etc. ";
+ }
+ leaf due-date {
+ type yang:date-and-time;
+ description
+ "date and time service to be reverted";
+ }
+ }
+ output {
+ uses org-openroadm-common-types:rpc-response-status;
+ }
+ description
+ "Whether this request passed initial validation and was accepted for processing. Once the request completes processing, a
+ service-rpc-result Notification shall be sent.";
+ }
+ rpc service-reroute {
+ input {
+ leaf service-name {
+ type string;
+ mandatory true;
+ description
+ "Identifier for the service to be re-routed in
+ the ROADM network, e.g., CLFI, CLCI, etc.";
+ }
+ }
+ output {
+ uses org-openroadm-common-types:rpc-response-status;
+ uses org-openroadm-routing-constraints:routing-constraints;
+ }
+ description
+ "Whether this request was validated and processed correct. If sucessful, it return the proposed new route.
+ If acceptable, this request should be followed by a service-reroute-confirm to complete the reroute operation.";
+ }
+ rpc service-reroute-confirm {
+ input {
+ leaf service-name {
+ type string;
+ mandatory true;
+ description
+ "Identifier for the service to be re-routed in
+ the ROADM network, e.g., CLFI, CLCI, etc.";
+ }
+ uses org-openroadm-routing-constraints:routing-constraints;
+ }
+ output {
+ uses org-openroadm-common-types:rpc-response-status;
+ }
+ description
+ "Whether this request passed initial validation and was accepted for processing. Once the request completes processing, a
+ service-rpc-result Notification shall be sent.";
+ }
+ rpc network-re-optimization {
+ input {
+ leaf service-name {
+ type string;
+ description
+ "Identifier for the service in the ROADM network,
+ e.g., CLFI, CLCI, etc. whose path is to be checked by the RNC
+ for re-optimization";
+ }
+ leaf a-end {
+ type string;
+ description
+ "Services whose A-ends are terminated at the
+ specified office location are to be checked by the RNC for
+ re-optimization";
+ }
+ leaf z-end {
+ type string;
+ description
+ "Services whose Z-ends are terminated at the
+ specified office location are to be checked by the RNC for
+ re-optimization ";
+ }
+ leaf pass-through {
+ type string;
+ description
+ "Services that are pass-through (either via
+ regen or express) at the specified office location are to
+ be checked by the RNC for re-optimization";
+ }
+ leaf customer-code {
+ type string;
+ description
+ "Services that belong to the specified customer
+ are to be checked by the RNC for re-optimization ";
+ }
+ }
+ output {
+ uses org-openroadm-common-types:rpc-response-status;
+ leaf optimization-candidate {
+ type string;
+ }
+ }
+ }
+ container service-list {
+ description
+ "List of service. Can only be created, deleted, modified, etc. using special RPCs.";
+ list services {
+ key "service-name";
+ uses org-openroadm-common-service-types:service;
+ }
+ }
+ container temp-service-list {
+ description
+ "List of temporary services Can only be created, deleted, modified, etc. using special RPCs.";
+ list services {
+ key "common-id";
+ uses org-openroadm-common-service-types:service {
+ refine "service-name" {
+ mandatory false;
+ }
+ }
+ }
+ }
+ notification service-rpc-result {
+ description
+ "This Notification indicates result of service RPC";
+ leaf notification-type {
+ type org-openroadm-common-service-types:service-notification-types;
+ }
+ uses org-openroadm-common-types:rpc-response-status;
+ uses org-openroadm-common-service-types:service-notification-result;
+ }
+ notification service-traffic-flow {
+ description
+ "This Notification indicates that traffic is flowing again on the service after an administrative action has completed";
+ leaf service-name {
+ type string;
+ description
+ "Identifier for the service being reported on";
+ mandatory true;
+ }
+ leaf actual-date {
+ type yang:date-and-time;
+ description
+ "Actual date and time traffic started flowing";
+ }
+ }
+ notification service-notification {
+ description
+ "This Notification that a service has been added, modified or removed.
+ A resourceCreation notification shall contain the created service in its entirety.
+ A resourceMofified notification shall contain just the modified field, plus the service identifier
+ A resourceDeleted notification shall just contain the service identifier";
+ leaf notificationType {
+ type org-openroadm-resource-types:resource-notification-type;
+ description
+ "Whether this notification indicates a service creation, service modification or service deletion.";
+ }
+ uses org-openroadm-common-service-types:service;
+ }
+}
--- /dev/null
+module org-openroadm-swdl {
+ namespace "http://org/openroadm/de/swdl";
+ prefix org-openroadm-swdl;
+
+ import ietf-yang-types {
+ prefix yang;
+ }
+
+ import org-openroadm-common-types {
+ prefix org-openroadm-common-types;
+ }
+
+ organization "Open ROADM MSA";
+ contact
+ "OpenROADM.org";
+ description
+ "Yang definitions for System Management.
+
+ Copyright of the Members of the Open ROADM MSA Agreement dated (c) 2016,
+ AT&T Intellectual Property. All other rights reserved.
+
+ Redistribution and use in source and binary forms, with or without modification,
+ are permitted provided that the following conditions are met:
+
+ * Redistributions of source code must retain the above copyright notice, this
+ list of conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions and the following disclaimer in the documentation and/or
+ other materials provided with the distribution.
+ * Neither the Members of the Open ROADM MSA Agreement nor the names of its
+ contributors may be used to endorse or promote products derived from this software
+ without specific prior written permission.
+
+ THIS SOFTWARE IS PROVIDED BY THE MEMBERS OF THE OPEN ROADM MSA AGREEMENT ''AS IS''
+ AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ IN NO EVENT THE MEMBERS OF THE OPEN ROADM MSA AGREEMENT BE LIABLE FOR ANY DIRECT,
+ INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
+ OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ POSSIBILITY OF SUCH DAMAGE.";
+
+ revision 2016-10-14 {
+ description
+ "Version 1.2";
+ }
+
+ grouping sw-bank {
+ leaf sw-version {
+ type string;
+ description
+ "Gissue of the SW in this bank";
+ }
+ leaf sw-validation-timer {
+ type string {
+ pattern "(([0-1][0-9]|2[0-3])-([0-5][0-9])-([0-5][0-9]))";
+ }
+ description
+ "value of validation timer in hh-mm-ss";
+ }
+ leaf activation-date-time {
+ type yang:date-and-time;
+ description
+ "activation date and time: The date load was activated";
+ }
+ }
+
+ rpc sw-stage {
+ description
+ "SW stage - copies the SW from repo to staging bank";
+ input {
+ leaf filename {
+ type string {
+ length "10..255";
+ }
+ description
+ "file name which has the load";
+ }
+ }
+ output {
+ uses org-openroadm-common-types:rpc-response-status;
+ }
+ }
+ rpc sw-activate {
+ description
+ "Activate new load";
+ input {
+ leaf version {
+ type string;
+ description
+ " software version of the new load which is being activated";
+ }
+ leaf validationTimer {
+ type string;
+ description
+ "validation timer hh-mm-ss";
+ }
+ }
+ output {
+ uses org-openroadm-common-types:rpc-response-status;
+ }
+ }
+ rpc cancel-validation-timer {
+ description
+ "Cancel validation timer which user provisioned as part of activate command";
+ input {
+ leaf accept {
+ type boolean;
+ default "true";
+ description
+ " TRUE means validation timer is cancelled and new load is accepted";
+ }
+ }
+ output {
+ uses org-openroadm-common-types:rpc-response-status;
+ }
+ }
+}
--- /dev/null
+module org-openroadm-syslog {
+ namespace "http://org/openroadm/syslog";
+ prefix org-openroadm-syslog;
+
+ import ietf-inet-types {
+ prefix inet;
+ }
+
+ organization "Open ROADM MSA";
+ contact
+ "OpenROADM.org";
+ description
+ "This module contains a collection of YANG definitions
+ for Syslog configuration.
+
+ Copyright of the Members of the Open ROADM MSA Agreement dated (c) 2016,
+ AT&T Intellectual Property. All other rights reserved.
+
+ Redistribution and use in source and binary forms, with or without modification,
+ are permitted provided that the following conditions are met:
+
+ * Redistributions of source code must retain the above copyright notice, this
+ list of conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions and the following disclaimer in the documentation and/or
+ other materials provided with the distribution.
+ * Neither the Members of the Open ROADM MSA Agreement nor the names of its
+ contributors may be used to endorse or promote products derived from this software
+ without specific prior written permission.
+
+ THIS SOFTWARE IS PROVIDED BY THE MEMBERS OF THE OPEN ROADM MSA AGREEMENT ''AS IS''
+ AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ IN NO EVENT THE MEMBERS OF THE OPEN ROADM MSA AGREEMENT BE LIABLE FOR ANY DIRECT,
+ INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
+ OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ POSSIBILITY OF SUCH DAMAGE.
+
+ Also contains code components extracted from IETF Interfaces. These code components
+ are copyrighted and licensed as follows:
+
+ Copyright (c) 2016 IETF Trust and the persons identified as the document authors.
+ All rights reserved.
+
+ This document is subject to BCP 78 and the IETF Trust’s Legal Provisions Relating
+ to IETF Documents (http://trustee.ietf.org/license-info) in effect on the date of
+ publication of this document. Please review these documents carefully, as they
+ describe your rights and restrictions with respect to this document. Code Components
+ extracted from this document must include Simplified BSD License text as described in
+ Section 4.e of the Trust Legal Provisions and are provided without warranty as
+ described in the Simplified BSD License.";
+ reference "RFC 5424: The Syslog Protocol";
+
+ revision 2016-10-14 {
+ description
+ "Version 1.2";
+ }
+
+ feature selector-sevop-config {
+ description
+ "This feature represents the ability to select messages
+ using the additional operators equal to, or not equal to
+ when comparing the Syslog message severity.";
+ }
+
+ feature selector-match-config {
+ description
+ "This feature represents the ability to select messages based
+ on a Posix 1003.2 regular expression pattern match.";
+ }
+
+ // copied from draft of ietf-ietf-syslog-types.yang
+ identity syslog-facility {
+ description
+ "The base identity to represent syslog facilities";
+ }
+
+ // copied from draft of ietf-ietf-syslog-types.yang;
+ // extended the enum set to include all and none
+ typedef severity {
+ type enumeration {
+ enum "emergency" {
+ value 0;
+ description
+ "Emergency Level Msg";
+ }
+ enum "alert" {
+ value 1;
+ description
+ "Alert Level Msg";
+ }
+ enum "critical" {
+ value 2;
+ description
+ "Critical Level Msg";
+ }
+ enum "error" {
+ value 3;
+ description
+ "Error Level Msg";
+ }
+ enum "warning" {
+ value 4;
+ description
+ "Warning Level Msg";
+ }
+ enum "notice" {
+ value 5;
+ description
+ "Notification Level Msg";
+ }
+ enum "info" {
+ value 6;
+ description
+ "Informational Level Msg";
+ }
+ enum "debug" {
+ value 7;
+ description
+ "Debugging Level Msg";
+ }
+ enum "all" {
+ value 8;
+ description
+ "This enum describes the case where all severities
+ are selected.";
+ }
+ enum "none" {
+ value 9;
+ description
+ "This enum describes the case where no severities
+ are selected.";
+ }
+ }
+ description
+ "The definitions for Syslog message severity as per RFC 5424.
+ Extended the RFC definition with enums for all and none";
+ }
+
+ grouping syslog-severity {
+ description
+ "This grouping defines the Syslog severity which is used to
+ select log messages.";
+ leaf severity {
+ type severity;
+ mandatory true;
+ description
+ "This leaf specifies the Syslog message severity. When
+ severity is specified, the default severity comparison
+ is all messages of the specified severity and greater are
+ selected. 'all' is a special case which means all severities
+ are selected. 'none' is a special case which means that
+ no selection should occur or disable this filter.";
+ }
+ leaf severity-operator {
+ when
+ "../severity != 'all' and
+ ../severity != 'none'" {
+ description
+ "The severity-operator is not applicable for severity 'all' or
+ severity 'none'";
+ }
+ if-feature selector-sevop-config;
+ type enumeration {
+ enum "equals-or-higher" {
+ description
+ "This enum specifies all messages of the specified
+ severity and higher are logged according to the
+ given log-action";
+ }
+ enum "equals" {
+ description
+ "This enum specifies all messages that are for
+ the specified severity are logged according to the
+ given log-action";
+ }
+ enum "not-equals" {
+ description
+ "This enum specifies all messages that are not for
+ the specified severity are logged according to the
+ given log-action";
+ }
+ }
+ default "equals-or-higher";
+ description
+ "This leaf describes the option to specify how the
+ severity comparison is performed.";
+ }
+ }
+
+ grouping syslog-selector {
+ description
+ "This grouping defines a Syslog selector which is used to
+ select log messages for the log-action (buffer, file,
+ etc). Choose one of the following:
+ no-log-facility
+ log-facility [<facility> <severity>...]";
+ container log-selector {
+ description
+ "This container describes the log selector parameters
+ for Syslog.";
+ choice selector-facility {
+ mandatory true;
+ description
+ "This choice describes the option to specify no
+ facilities, or a specific facility which can be
+ all for all facilities.";
+ case no-log-facility {
+ description
+ "This case specifies no facilities will match when
+ comparing the Syslog message facility. This is a
+ method that can be used to effectively disable a
+ particular log-action (buffer, file, etc).";
+ leaf no-facilities {
+ type empty;
+ description
+ "This leaf specifies that no facilities are selected
+ for this log-action.";
+ }
+ }
+ case log-facility {
+ description
+ "This case specifies one or more specified facilities
+ will match when comparing the Syslog message facility.";
+ list log-facility {
+ key "facility";
+ description
+ "This list describes a collection of Syslog
+ facilities and severities.";
+ leaf facility {
+ type union {
+ type identityref {
+ base syslog-facility;
+ }
+ type enumeration {
+ enum "all" {
+ description
+ "This enum describes the case where all
+ facilities are requested.";
+ }
+ }
+ }
+ description
+ "The leaf uniquely identifies a Syslog facility.";
+ }
+ uses syslog-severity;
+ }
+ }
+ }
+ }
+ }
+
+ container syslog {
+ description
+ "This container describes the configuration parameters for
+ Syslog.";
+ container log-actions {
+ description
+ "This container describes the log-action parameters
+ for Syslog.";
+ container remote {
+ description
+ "This container describes the configuration parameters for
+ remote logging.";
+ list destination {
+ key "name";
+ description
+ "This list describes a collection of remote logging
+ destinations.";
+ leaf name {
+ type string;
+ description
+ "An arbitrary name for the endpoint to connect to.";
+ }
+ choice transport {
+ mandatory true;
+ description
+ "This choice describes the transport option.";
+ case tcp {
+ container tcp {
+ description
+ "This container describes the TCP transport
+ options.";
+ reference "RFC 6587: Transmission of Syslog Messages over TCP";
+ leaf address {
+ type inet:host;
+ description
+ "The leaf uniquely specifies the address of
+ the remote host. One of the following must
+ be specified: an ipv4 address, an ipv6
+ address, or a host name.";
+ }
+ leaf port {
+ type inet:port-number;
+ default "514";
+ description
+ "This leaf specifies the port number used to
+ deliver messages to the remote server.";
+ }
+ }
+ }
+ case udp {
+ container udp {
+ description
+ "This container describes the UDP transport
+ options.";
+ reference "RFC 5426: Transmission of Syslog Messages over UDP";
+ leaf address {
+ type inet:host;
+ description
+ "The leaf uniquely specifies the address of
+ the remote host. One of the following must be
+ specified: an ipv4 address, an ipv6 address,
+ or a host name.";
+ }
+ leaf port {
+ type inet:port-number;
+ default "514";
+ description
+ "This leaf specifies the port number used to
+ deliver messages to the remote server.";
+ }
+ }
+ }
+ }
+ uses syslog-selector;
+ }
+ }
+ }
+ }
+}
--- /dev/null
+module org-openroadm-tca {
+ namespace "http://org/openroadm/tca";
+ prefix org-openroadm-tca;
+
+ import ietf-yang-types {
+ prefix yang;
+ }
+ import org-openroadm-common-types {
+ prefix org-openroadm-common-types;
+ revision-date 2016-10-14;
+ }
+ import org-openroadm-pm-types {
+ prefix org-openroadm-pm-types;
+ }
+ import org-openroadm-resource {
+ prefix org-openroadm-resource;
+ }
+ import org-openroadm-layerRate {
+ prefix org-openroadm-layerRate;
+ }
+
+ organization "Open ROADM MSA";
+ contact
+ "OpenROADM.org";
+ description
+ "YANG definitions of Threshold Crossing Alert types.
+
+ Copyright of the Members of the Open ROADM MSA Agreement dated (c) 2016,
+ AT&T Intellectual Property. All other rights reserved.
+
+ Redistribution and use in source and binary forms, with or without modification,
+ are permitted provided that the following conditions are met:
+
+ * Redistributions of source code must retain the above copyright notice, this
+ list of conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions and the following disclaimer in the documentation and/or
+ other materials provided with the distribution.
+ * Neither the Members of the Open ROADM MSA Agreement nor the names of its
+ contributors may be used to endorse or promote products derived from this software
+ without specific prior written permission.
+
+ THIS SOFTWARE IS PROVIDED BY THE MEMBERS OF THE OPEN ROADM MSA AGREEMENT ''AS IS''
+ AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ IN NO EVENT THE MEMBERS OF THE OPEN ROADM MSA AGREEMENT BE LIABLE FOR ANY DIRECT,
+ INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
+ OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ POSSIBILITY OF SUCH DAMAGE";
+
+ revision 2016-10-14 {
+ description
+ "Version 1.2";
+ }
+
+ grouping tca {
+ leaf id {
+ type string;
+ mandatory true;
+ }
+ container resource {
+ uses org-openroadm-resource:resource;
+ }
+ leaf granularity {
+ type org-openroadm-pm-types:pm-granularity;
+ }
+ leaf raiseTime {
+ type yang:date-and-time;
+ mandatory true;
+ config false;
+ }
+ container layerRate {
+ uses org-openroadm-layerRate:layer-rate;
+ }
+ leaf severity {
+ mandatory true;
+ type org-openroadm-common-types:severity;
+ description
+ "Severity of alarm. Based on X.733 perceived severity.";
+ }
+ leaf thresholdType {
+ mandatory false;
+ type enumeration {
+ enum "high" {
+ value 1;
+ }
+ enum "low" {
+ value 2;
+ }
+ }
+ description
+ "Threshold Crossed";
+ }
+ container thresholdMeasurement {
+ uses org-openroadm-pm-types:pm-measurement;
+ }
+ }
+
+ grouping potential-tca {
+ leaf lowThresholdValue {
+ mandatory false;
+ type uint64;
+ }
+ leaf highThresholdValue {
+ mandatory false;
+ type uint64;
+ }
+ uses tca;
+ }
+
+ container potential-tca-list {
+ list tca {
+ key "id";
+ uses potential-tca;
+ }
+ }
+ notification tca-notification {
+ uses tca;
+ }
+}
--- /dev/null
+module org-openroadm-topology {
+ namespace "http://org/openroadm/topology";
+ prefix org-openroadm-topology;
+
+ import org-openroadm-resource {
+ prefix org-openroadm-resource;
+ }
+
+ organization
+ "Open ROADM MSA";
+ contact
+ "OpenROADM.org";
+ description
+ "YANG definitions of topology.
+
+ Copyright of the Members of the Open ROADM MSA Agreement dated (c) 2016,
+ AT&T Intellectual Property. All other rights reserved.
+
+ Redistribution and use in source and binary forms, with or without modification,
+ are permitted provided that the following conditions are met:
+
+ * Redistributions of source code must retain the above copyright notice, this
+ list of conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions and the following disclaimer in the documentation and/or
+ other materials provided with the distribution.
+ * Neither the Members of the Open ROADM MSA Agreement nor the names of its
+ contributors may be used to endorse or promote products derived from this software
+ without specific prior written permission.
+
+ THIS SOFTWARE IS PROVIDED BY THE MEMBERS OF THE OPEN ROADM MSA AGREEMENT ''AS IS''
+ AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ IN NO EVENT THE MEMBERS OF THE OPEN ROADM MSA AGREEMENT BE LIABLE FOR ANY DIRECT,
+ INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
+ OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ POSSIBILITY OF SUCH DAMAGE";
+
+ revision 2016-10-14 {
+ description
+ "Version 1.2";
+ }
+
+ grouping topology {
+ description
+ "Topology reports the individual hops along the service in the A to Z direction and Z to A directions. This includes both ports internal to a device and those
+ at its edge that are available for externally connections. It includes both physical and logical ports.
+ Physical ports are ordered with the logical ports that run over them as follows:
+ a.\tOn ingress to a node/card, physical then logical
+ b.\tOn egress to a node/card, logical then physical";
+ list aToZ {
+ key "id";
+ leaf id {
+ description
+ "Unigue identifier for this topology component within this service";
+ type string;
+ }
+ uses hop;
+ }
+ list zToA {
+ key "id";
+ leaf id {
+ description
+ "Unigue identifier for this topology component within this service";
+ type string;
+ }
+ uses hop;
+ }
+ }
+
+ grouping hop {
+ leaf hop-type {
+ type enumeration {
+ enum "node-external" {
+ description
+ "The given resource is on the edge of the node, and used in relationships to resources outside of the node.";
+ value 1;
+ }
+ enum "node-internal" {
+ description
+ "The given resource is internally to the node";
+ value 2;
+ }
+ }
+ }
+ uses org-openroadm-resource:resource;
+ }
+}
--- /dev/null
+module org-openroadm-user-mgmt {
+ namespace "http://org/openroadm/user-mgmt";
+ prefix org-openroadm-user-mgmt;
+
+ organization "Open ROADM MSA";
+ contact
+ "OpenROADM.org";
+ description
+ "YANG definitions of user managements.
+
+ Copyright of the Members of the Open ROADM MSA Agreement dated (c) 2016,
+ AT&T Intellectual Property. All other rights reserved.
+
+ Redistribution and use in source and binary forms, with or without modification,
+ are permitted provided that the following conditions are met:
+
+ * Redistributions of source code must retain the above copyright notice, this
+ list of conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions and the following disclaimer in the documentation and/or
+ other materials provided with the distribution.
+ * Neither the Members of the Open ROADM MSA Agreement nor the names of its
+ contributors may be used to endorse or promote products derived from this software
+ without specific prior written permission.
+
+ THIS SOFTWARE IS PROVIDED BY THE MEMBERS OF THE OPEN ROADM MSA AGREEMENT ''AS IS''
+ AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ IN NO EVENT THE MEMBERS OF THE OPEN ROADM MSA AGREEMENT BE LIABLE FOR ANY DIRECT,
+ INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
+ OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ POSSIBILITY OF SUCH DAMAGE";
+
+ revision 2016-10-14 {
+ description
+ "Version 1.2";
+ }
+
+ grouping user-profile {
+ list user {
+ key "name";
+ description
+ "The list of local users configured on this device.";
+ leaf name {
+ type string;
+ description
+ "The user name string identifying this entry.";
+ }
+ leaf password {
+ type string;
+ description
+ "The password for this entry. This shouldn't be in clear text";
+ }
+ leaf group {
+ type enumeration {
+ enum "sudo";
+ }
+ description
+ "The group to which the user is associated to.";
+ }
+ }
+ }
+
+ rpc chg-password {
+ input {
+ leaf currentPassword {
+ type string;
+ description
+ "provide the current password";
+ mandatory true;
+ }
+ leaf newPassword {
+ type string;
+ description
+ "provide a new password";
+ mandatory true;
+ }
+ leaf newPasswordConfirm {
+ type string;
+ description
+ "re-enter the new password ";
+ mandatory true;
+ }
+ }
+ output {
+ leaf status {
+ type enumeration {
+ enum "Successful" {
+ value 1;
+ }
+ enum "Failed" {
+ value 2;
+ }
+ }
+ mandatory true;
+ description
+ "Successful or Failed";
+ }
+ leaf status-message {
+ type string;
+ description
+ "Gives a more detailed reason for success / failure";
+ }
+ }
+ }
+}
--- /dev/null
+module org-openroadm-wavelength-map {
+ namespace "http://org/openroadm/wavelength-map";
+ prefix org-openroadm-wavelength-map;
+
+ organization "Open ROADM MSA";
+ contact
+ "OpenROADM.org";
+ description
+ "YANG definitions for mapping wavelength-number to center frequency and wavelength value.
+
+ Copyright of the Members of the Open ROADM MSA Agreement dated (c) 2016,
+ AT&T Intellectual Property. All other rights reserved.
+
+ Redistribution and use in source and binary forms, with or without modification,
+ are permitted provided that the following conditions are met:
+
+ * Redistributions of source code must retain the above copyright notice, this
+ list of conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions and the following disclaimer in the documentation and/or
+ other materials provided with the distribution.
+ * Neither the Members of the Open ROADM MSA Agreement nor the names of its
+ contributors may be used to endorse or promote products derived from this software
+ without specific prior written permission.
+
+ THIS SOFTWARE IS PROVIDED BY THE MEMBERS OF THE OPEN ROADM MSA AGREEMENT ''AS IS''
+ AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ IN NO EVENT THE MEMBERS OF THE OPEN ROADM MSA AGREEMENT BE LIABLE FOR ANY DIRECT,
+ INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
+ OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ POSSIBILITY OF SUCH DAMAGE.";
+
+ revision 2016-10-14 {
+ description
+ "Version 1.2";
+ }
+
+ grouping wavelength-map-g {
+ list wavelengths {
+ key "wavelength-number";
+ leaf wavelength-number {
+ type uint32;
+ }
+ config false;
+ leaf center-frequency {
+ type decimal64 {
+ fraction-digits 3;
+ range "191.350..196.100";
+ }
+ units "THz";
+ description
+ "Frequency of the transmit optical channel
+ Domain range: 191.350THz .. 196.100THz ";
+ }
+ leaf wavelength {
+ type decimal64 {
+ fraction-digits 2;
+ range "1528.77..1566.72";
+ }
+ units "nm";
+ description
+ "Lambda corresponding to transmit frequency
+ Domain range: 1528.72nm .. 1566.72nm ";
+ }
+ }
+ }
+}
--- /dev/null
+module org-openroadm-xponder {
+ namespace "http://org/openroadm/xponder";
+ prefix xpndr;
+
+ import ietf-network {
+ prefix nd;
+ revision-date 2015-06-08;
+ }
+ import ietf-network-topology {
+ prefix nwt;
+ revision-date 2015-06-08;
+ }
+ import org-openroadm-network-types {
+ prefix org-openroadm-network-types;
+ revision-date 2017-09-29;
+ }
+ import org-openroadm-common-types {
+ prefix org-openroadm-common-types;
+ revision-date 2017-09-29;
+ }
+ import org-openroadm-otn-common-types {
+ prefix org-openroadm-otn-common-types;
+ revision-date 2017-09-29;
+ }
+
+ organization
+ "OPEN ROADM MSA";
+ contact
+ "OpenROADM.org.";
+ description
+ "YANG definitions for xponder
+
+ Copyright of the Members of the Open ROADM MSA Agreement dated (c) 2016,
+ AT&T Intellectual Property. All other rights reserved.
+
+ Redistribution and use in source and binary forms, with or without modification,
+ are permitted provided that the following conditions are met:
+
+ * Redistributions of source code must retain the above copyright notice, this
+ list of conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions and the following disclaimer in the documentation and/or
+ other materials provided with the distribution.
+ * Neither the Members of the Open ROADM MSA Agreement nor the names of its
+ contributors may be used to endorse or promote products derived from this software
+ without specific prior written permission.
+
+ THIS SOFTWARE IS PROVIDED BY THE MEMBERS OF THE OPEN ROADM MSA AGREEMENT ''AS IS''
+ AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ IN NO EVENT THE MEMBERS OF THE OPEN ROADM MSA AGREEMENT BE LIABLE FOR ANY DIRECT,
+ INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
+ OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ POSSIBILITY OF SUCH DAMAGE.";
+
+ revision 2017-09-29 {
+ description
+ "Version 2.1";
+ }
+ revision 2017-07-28 {
+ description
+ "Version 2.0.1 - added revision-date to imports";
+ }
+ revision 2017-06-26 {
+ description
+ "Version 2.0";
+ }
+ revision 2016-10-14 {
+ description
+ "Version 1.2";
+ }
+
+ grouping xpdr-node-attributes {
+ leaf customer-code {
+ type string;
+ description
+ "Owner of the xponder";
+ }
+ }
+
+ grouping xpdr-topo-node-attributes {
+ leaf xpdr-number {
+ type uint16;
+ }
+ }
+
+ grouping xpdr-connection-attributes {
+ leaf local-lgx {
+ type string;
+ }
+ leaf rate {
+ type identityref {
+ base org-openroadm-common-types:och-rate-identity;
+ }
+ description
+ "rate";
+ }
+ leaf modulation-format {
+ type org-openroadm-common-types:modulation-format;
+ }
+ leaf optic {
+ type org-openroadm-common-types:optic-types;
+ }
+ leaf state {
+ type org-openroadm-common-types:state;
+ description
+ "A xponder can be in one of the following
+ states";
+ }
+ }
+
+ grouping xpdr-port-connection-attributes {
+ container wavelength {
+ uses org-openroadm-network-types:wavelengths;
+ }
+ leaf tail-equipment {
+ type string;
+ }
+ leaf tail-equipment-id {
+ type string;
+ }
+ leaf tail-clfi {
+ type string;
+ }
+ }
+
+ grouping xpdr-otn-tail-attributes {
+ leaf tp-id {
+ type nwt:tp-id;
+ }
+ leaf network-ref {
+ type leafref {
+ path "/nd:network/nd:network-id";
+ }
+ description
+ "Used to reference a network, for example an underlay
+ network.";
+ }
+ leaf node-ref {
+ type leafref {
+ path "/nd:network[nd:network-id=current()/../network-ref]"+
+ "/nd:node/nd:node-id";
+ }
+ description
+ "Used to reference a node.
+ Nodes are identified relative to the network they are
+ contained in.";
+ }
+ }
+
+ grouping xpdr-otn-tp-attributes {
+ leaf rate {
+ type identityref {
+ base org-openroadm-otn-common-types:odu-rate-identity;
+ }
+ description
+ "rate identity of the ODU. 'identityref' is used
+ to allow to extend for future higher rates";
+ }
+ list odtu-tpn-pool {
+ key "odtu-type";
+ leaf odtu-type {
+ type identityref {
+ base org-openroadm-otn-common-types:odtu-type-identity;
+ }
+ description
+ "ODTU type, part of the MSI (Multiplex Structure Identifier)";
+ }
+ leaf-list tpn-pool {
+ type uint8;
+ description
+ "Tributary Port Number (0-based), part of the MSI";
+ }
+ }
+ leaf-list ts-pool {
+ type uint16;
+ description
+ "Timeslots used by port";
+ }
+ }
+
+}
@classmethod
def setUpClass(cls):
cls.__start_honeynode1()
- time.sleep(40)
+ time.sleep(20)
cls.__start_honeynode2()
- time.sleep(40)
+ time.sleep(20)
cls.__start_odl()
time.sleep(60)
def test_11_xpdr_portmapping_NETWORK2(self):
url = ("{}/config/portmapping:network/"
- "nodes/XPDRA/mapping/XPDR0-NETWORK2"
+ "nodes/XPDRA/mapping/XPDR1-NETWORK2"
.format(self.restconf_baseurl))
headers = {'content-type': 'application/json'}
response = requests.request(
res = response.json()
self.assertIn(
{'supporting-port': '2', 'supporting-circuit-pack-name': '1/0/2-PLUG-NET',
- 'logical-connection-point': 'XPDR0-NETWORK2'},
+ 'logical-connection-point': 'XPDR1-NETWORK2'},
res['mapping'])
def test_12_xpdr_portmapping_CLIENT1(self):
headers = {'content-type': 'application/json'}
response = requests.request(
"GET", url, headers=headers, auth=('admin', 'admin'))
- self.assertEqual(response.status_code, requests.codes.not_found)
+ self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertIn(
- {"error-type":"application","error-tag":"data-missing",
- "error-message":"Request could not be completed because the relevant data model content does not exist "},
- res['errors']['error'])
+ {'supporting-port': 'C2',
+ 'supporting-circuit-pack-name': '1/0/C2-PLUG-CLIENT',
+ 'logical-connection-point': 'XPDR1-CLIENT2'},
+ res['mapping'])
def test_14_xpdr_portmapping_CLIENT4(self):
url = ("{}/config/portmapping:network/"
- "nodes/XPDRA/mapping/XPDR0-CLIENT4"
+ "nodes/XPDRA/mapping/XPDR1-CLIENT4"
.format(self.restconf_baseurl))
headers = {'content-type': 'application/json'}
response = requests.request(
self.assertIn(
{'supporting-port': 'C4',
'supporting-circuit-pack-name': '1/0/C4-PLUG-CLIENT',
- 'logical-connection-point': 'XPDR0-CLIENT4'},
+ 'logical-connection-point': 'XPDR1-CLIENT4'},
res['mapping'])
def test_15_xpdr_device_disconnected(self):
import shutil
from unittest.result import failfast
+
class TransportPCERendererTesting(unittest.TestCase):
honeynode_process1 = None
'logical-connection-point': 'XPDR1-CLIENT1'},
res['nodes'][0]['mapping'])
-
def test_05_service_path_create(self):
url = "{}/operations/renderer:service-path".format(self.restconf_baseurl)
data = {"renderer:input": {
res['interface'][0])
self.assertDictEqual(
{u'rate': u'org-openroadm-optical-channel-interfaces:R100G',
- u'transmit-power': -5,
+ u'transmit-power':-5,
u'wavelength-number': 7,
u'modulation-format': u'dp-qpsk'},
res['interface'][0]['org-openroadm-optical-channel-interfaces:och'])
headers=headers, auth=('admin', 'admin'))
self.assertEqual(response.status_code, requests.codes.ok)
self.assertEqual(response.json(), {
- 'output': {'result': 'Request processed'}})
-
+ 'output': {'result': 'Request processed', 'success': True}})
def test_15_service_path_delete_rdm_check(self):
url = ("{}/config/network-topology:network-topology/topology/topology-netconf/"
self.assertEqual(response.status_code, requests.codes.not_found)
res = response.json()
self.assertIn(
- {"error-type":"application","error-tag":"data-missing",
+ {"error-type":"application", "error-tag":"data-missing",
"error-message":"Request could not be completed because the relevant data model content does not exist "},
res['errors']['error'])
self.assertEqual(response.status_code, requests.codes.not_found)
res = response.json()
self.assertIn(
- {"error-type":"application","error-tag":"data-missing","error-message":"Request could not be completed because the relevant data model content does not exist "},
+ {"error-type":"application", "error-tag":"data-missing", "error-message":"Request could not be completed because the relevant data model content does not exist "},
res['errors']['error'])
def test_17_service_path_delete_rdm_check(self):
self.assertEqual(response.status_code, requests.codes.not_found)
res = response.json()
self.assertIn(
- {"error-type":"application","error-tag":"data-missing","error-message":"Request could not be completed because the relevant data model content does not exist "},
+ {"error-type":"application", "error-tag":"data-missing", "error-message":"Request could not be completed because the relevant data model content does not exist "},
res['errors']['error'])
def test_18_service_path_delete_xpdr_check(self):
self.assertEqual(response.status_code, requests.codes.not_found)
res = response.json()
self.assertIn(
- {"error-type":"application","error-tag":"data-missing","error-message":"Request could not be completed because the relevant data model content does not exist "},
+ {"error-type":"application", "error-tag":"data-missing", "error-message":"Request could not be completed because the relevant data model content does not exist "},
res['errors']['error'])
def test_19_service_path_delete_xpdr_check(self):
self.assertEqual(response.status_code, requests.codes.not_found)
res = response.json()
self.assertIn(
- {"error-type":"application","error-tag":"data-missing","error-message":"Request could not be completed because the relevant data model content does not exist "},
+ {"error-type":"application", "error-tag":"data-missing", "error-message":"Request could not be completed because the relevant data model content does not exist "},
res['errors']['error'])
def test_20_service_path_delete_xpdr_check(self):
self.assertEqual(response.status_code, requests.codes.not_found)
res = response.json()
self.assertIn(
- {"error-type":"application","error-tag":"data-missing","error-message":"Request could not be completed because the relevant data model content does not exist "},
+ {"error-type":"application", "error-tag":"data-missing", "error-message":"Request could not be completed because the relevant data model content does not exist "},
res['errors']['error'])
def test_21_service_path_delete_xpdr_check(self):
self.assertEqual(response.status_code, requests.codes.not_found)
res = response.json()
self.assertIn(
- {"error-type":"application","error-tag":"data-missing","error-message":"Request could not be completed because the relevant data model content does not exist "},
+ {"error-type":"application", "error-tag":"data-missing", "error-message":"Request could not be completed because the relevant data model content does not exist "},
res['errors']['error'])
def test_22_service_path_delete_xpdr_check(self):
self.assertEqual(response.status_code, requests.codes.ok)
time.sleep(20)
+
if __name__ == "__main__":
unittest.main(verbosity=2, failfast=True)
Code Review / transportpce.git / commitdiff