From 14e29006648677bb5c9c6e82e1a2201e005cdeca Mon Sep 17 00:00:00 2001 From: Jakub Toth Date: Tue, 20 Dec 2016 13:14:38 +0100 Subject: [PATCH] Bug 5679 - implement new service RestconfService * update constants of RestconfModule in Draft18 by latest draft of ietf-restconf * implement servic for getting yang library version * path - /restconf/18/yang-library-version * test for new implementation * move tests from ../rest/services/impl to ../base/services/impl Change-Id: I6caf4dce2ce3000ba8ac2b9f0f98d90e25f36d31 Signed-off-by: Jakub Toth --- .../org/opendaylight/restconf/Draft18.java | 50 ++- .../services/api/BaseServicesWrapper.java | 2 +- .../base/services/api/RestconfService.java | 34 ++ .../base/services/impl/RestconfImpl.java | 54 +++ .../wrapper/services/ServicesWrapperImpl.java | 29 +- .../mapping/RestconfMappingNodeUtil.java | 13 +- .../base/services/impl/RestconfImplTest.java | 47 ++ .../impl/RestconfOperationsServiceTest.java | 2 +- .../impl/RestconfSchemaServiceTest.java | 2 +- .../restconf/impl/ietf-inet-types.yang | 418 ++++++++++++++++++ .../ietf-restconf-monitoring@2016-08-15.yang | 148 +++++++ .../impl/ietf-restconf@2016-08-15.yang | 256 +++++++++++ .../impl/ietf-yang-library@2016-06-21.yang | 208 +++++++++ .../restconf/impl/ietf-yang-types.yang | 417 +++++++++++++++++ 14 files changed, 1638 insertions(+), 42 deletions(-) create mode 100644 restconf/sal-rest-connector/src/main/java/org/opendaylight/restconf/base/services/api/RestconfService.java create mode 100644 restconf/sal-rest-connector/src/main/java/org/opendaylight/restconf/base/services/impl/RestconfImpl.java create mode 100644 restconf/sal-rest-connector/src/test/java/org/opendaylight/restconf/base/services/impl/RestconfImplTest.java rename restconf/sal-rest-connector/src/test/java/org/opendaylight/restconf/{rest => base}/services/impl/RestconfOperationsServiceTest.java (98%) rename restconf/sal-rest-connector/src/test/java/org/opendaylight/restconf/{rest => base}/services/impl/RestconfSchemaServiceTest.java (99%) create mode 100644 restconf/sal-rest-connector/src/test/resources/restconf/impl/ietf-inet-types.yang create mode 100644 restconf/sal-rest-connector/src/test/resources/restconf/impl/ietf-restconf-monitoring@2016-08-15.yang create mode 100644 restconf/sal-rest-connector/src/test/resources/restconf/impl/ietf-restconf@2016-08-15.yang create mode 100644 restconf/sal-rest-connector/src/test/resources/restconf/impl/ietf-yang-library@2016-06-21.yang create mode 100644 restconf/sal-rest-connector/src/test/resources/restconf/impl/ietf-yang-types.yang diff --git a/restconf/sal-rest-connector/src/main/java/org/opendaylight/restconf/Draft18.java b/restconf/sal-rest-connector/src/main/java/org/opendaylight/restconf/Draft18.java index 61660e085a..9f0e93ef77 100644 --- a/restconf/sal-rest-connector/src/main/java/org/opendaylight/restconf/Draft18.java +++ b/restconf/sal-rest-connector/src/main/java/org/opendaylight/restconf/Draft18.java @@ -61,49 +61,57 @@ public final class Draft18 { */ public static final class RestconfModule { + private static final Logger LOG = LoggerFactory.getLogger(RestconfModule.class); + private RestconfModule() { throw new UnsupportedOperationException("Util class"); } - public static final String REVISION = "2013-10-19"; - + public static final String REVISION = "2016-08-15"; public static final String NAME = "ietf-restconf"; - public static final String NAMESPACE = "urn:ietf:params:xml:ns:yang:ietf-restconf"; - public static final String RESTCONF_GROUPING_SCHEMA_NODE = "restconf"; - - public static final String RESTCONF_CONTAINER_SCHEMA_NODE = "restconf"; + public static final QName IETF_RESTCONF_QNAME = QName.create(Draft18.RestconfModule.NAMESPACE, + Draft18.RestconfModule.REVISION, Draft18.RestconfModule.NAME); - public static final String MODULES_CONTAINER_SCHEMA_NODE = "modules"; + public static Date DATE = null; + public static URI URI_MODULE = null; - public static final String MODULE_LIST_SCHEMA_NODE = "module"; + static { + try { + DATE = new SimpleDateFormat("yyyy-MM-dd").parse(REVISION); + URI_MODULE = new URI(NAMESPACE); + } catch (final ParseException | URISyntaxException e) { + LOG.error(e.getMessage()); + } + } + // RESTCONF + public static final String RESTCONF_GROUPING_SCHEMA_NODE = "restconf"; + public static final String RESTCONF_CONTAINER_SCHEMA_NODE = "restconf"; public static final String OPERATIONS_CONTAINER_SCHEMA_NODE = "operations"; + public static final String DATA_CONTAINER_SCHEMA_NODE = "data"; + public static final String LIB_VER_LEAF_SCHEMA_NODE = "yang-library-version"; - public static final String ERRORS_GROUPING_SCHEMA_NODE = "errors"; + public static final QName RESTCONF_GROUPING_QNAME = + QName.create(IETF_RESTCONF_QNAME, RESTCONF_GROUPING_SCHEMA_NODE); + public static final QName RESTCONF_CONTAINER_QNAME = + QName.create(IETF_RESTCONF_QNAME, RESTCONF_CONTAINER_SCHEMA_NODE); + public static final QName LIB_VER_LEAF_QNAME = QName.create(IETF_RESTCONF_QNAME, LIB_VER_LEAF_SCHEMA_NODE); + // ERRORS + public static final String ERRORS_GROUPING_SCHEMA_NODE = "errors"; public static final String ERRORS_CONTAINER_SCHEMA_NODE = "errors"; - public static final String ERROR_LIST_SCHEMA_NODE = "error"; - public static final QName IETF_RESTCONF_QNAME = QName.create(Draft18.RestconfModule.NAMESPACE, Draft18.RestconfModule.REVISION, - Draft18.RestconfModule.NAME); - - public static final QName ERRORS_CONTAINER_QNAME = QName.create(IETF_RESTCONF_QNAME, ERRORS_CONTAINER_SCHEMA_NODE); - + public static final QName ERRORS_CONTAINER_QNAME = + QName.create(IETF_RESTCONF_QNAME, ERRORS_CONTAINER_SCHEMA_NODE); public static final QName ERROR_LIST_QNAME = QName.create(IETF_RESTCONF_QNAME, ERROR_LIST_SCHEMA_NODE); - public static final QName ERROR_TYPE_QNAME = QName.create(IETF_RESTCONF_QNAME, "error-type"); - public static final QName ERROR_TAG_QNAME = QName.create(IETF_RESTCONF_QNAME, "error-tag"); - public static final QName ERROR_APP_TAG_QNAME = QName.create(IETF_RESTCONF_QNAME, "error-app-tag"); - public static final QName ERROR_MESSAGE_QNAME = QName.create(IETF_RESTCONF_QNAME, "error-message"); - public static final QName ERROR_INFO_QNAME = QName.create(IETF_RESTCONF_QNAME, "error-info"); - public static final QName ERROR_PATH_QNAME = QName.create(IETF_RESTCONF_QNAME, "error-path"); } diff --git a/restconf/sal-rest-connector/src/main/java/org/opendaylight/restconf/base/services/api/BaseServicesWrapper.java b/restconf/sal-rest-connector/src/main/java/org/opendaylight/restconf/base/services/api/BaseServicesWrapper.java index ff1bf3ae56..e70b346f43 100644 --- a/restconf/sal-rest-connector/src/main/java/org/opendaylight/restconf/base/services/api/BaseServicesWrapper.java +++ b/restconf/sal-rest-connector/src/main/java/org/opendaylight/restconf/base/services/api/BaseServicesWrapper.java @@ -15,5 +15,5 @@ package org.opendaylight.restconf.base.services.api; * * */ -public interface BaseServicesWrapper extends RestconfOperationsService, RestconfSchemaService { +public interface BaseServicesWrapper extends RestconfOperationsService, RestconfSchemaService, RestconfService { } diff --git a/restconf/sal-rest-connector/src/main/java/org/opendaylight/restconf/base/services/api/RestconfService.java b/restconf/sal-rest-connector/src/main/java/org/opendaylight/restconf/base/services/api/RestconfService.java new file mode 100644 index 0000000000..acdcefc9e0 --- /dev/null +++ b/restconf/sal-rest-connector/src/main/java/org/opendaylight/restconf/base/services/api/RestconfService.java @@ -0,0 +1,34 @@ +/* + * Copyright (c) 2016 Cisco Systems, Inc. and others. All rights reserved. + * + * This program and the accompanying materials are made available under the + * terms of the Eclipse Public License v1.0 which accompanies this distribution, + * and is available at http://www.eclipse.org/legal/epl-v10.html + */ +package org.opendaylight.restconf.base.services.api; + +import javax.ws.rs.GET; +import javax.ws.rs.Path; +import javax.ws.rs.Produces; +import javax.ws.rs.core.MediaType; +import org.opendaylight.netconf.sal.restconf.impl.NormalizedNodeContext; +import org.opendaylight.restconf.Draft18; +import org.opendaylight.restconf.utils.RestconfConstants; + +/** + * Service for getting yang library version + * + */ +public interface RestconfService { + + /** + * Get yang library version + * + * @return {@link NormalizedNodeContext} + */ + @GET + @Path("/yang-library-version") + @Produces({ Draft18.MediaTypes.DATA + RestconfConstants.JSON, Draft18.MediaTypes.DATA, MediaType.APPLICATION_JSON, + MediaType.APPLICATION_XML, MediaType.TEXT_XML }) + public NormalizedNodeContext getLibraryVersion(); +} diff --git a/restconf/sal-rest-connector/src/main/java/org/opendaylight/restconf/base/services/impl/RestconfImpl.java b/restconf/sal-rest-connector/src/main/java/org/opendaylight/restconf/base/services/impl/RestconfImpl.java new file mode 100644 index 0000000000..bd76052d21 --- /dev/null +++ b/restconf/sal-rest-connector/src/main/java/org/opendaylight/restconf/base/services/impl/RestconfImpl.java @@ -0,0 +1,54 @@ +/* + * Copyright (c) 2016 Cisco Systems, Inc. and others. All rights reserved. + * + * This program and the accompanying materials are made available under the + * terms of the Eclipse Public License v1.0 which accompanies this distribution, + * and is available at http://www.eclipse.org/legal/epl-v10.html + */ +package org.opendaylight.restconf.base.services.impl; + +import org.opendaylight.netconf.sal.restconf.impl.InstanceIdentifierContext; +import org.opendaylight.netconf.sal.restconf.impl.NormalizedNodeContext; +import org.opendaylight.restconf.Draft18.IetfYangLibrary; +import org.opendaylight.restconf.Draft18.RestconfModule; +import org.opendaylight.restconf.base.services.api.RestconfService; +import org.opendaylight.restconf.handlers.SchemaContextHandler; +import org.opendaylight.yangtools.yang.common.QName; +import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier; +import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode; +import org.opendaylight.yangtools.yang.data.impl.schema.Builders; +import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode; +import org.opendaylight.yangtools.yang.model.api.GroupingDefinition; +import org.opendaylight.yangtools.yang.model.api.LeafSchemaNode; +import org.opendaylight.yangtools.yang.model.api.SchemaContext; +import org.opendaylight.yangtools.yang.model.api.SchemaNode; + +public class RestconfImpl implements RestconfService { + + private final SchemaContextHandler schemaContextHandler; + + public RestconfImpl(final SchemaContextHandler schemaContextHandler) { + this.schemaContextHandler = schemaContextHandler; + } + + @Override + public NormalizedNodeContext getLibraryVersion() { + final SchemaContext context = this.schemaContextHandler.get(); + SchemaNode schemaNode = null; + for (final GroupingDefinition groupingDefinition : context + .findModuleByNamespaceAndRevision(RestconfModule.URI_MODULE, RestconfModule.DATE).getGroupings()) { + if (groupingDefinition.getQName().equals(RestconfModule.RESTCONF_GROUPING_QNAME)) { + schemaNode = ((ContainerSchemaNode) groupingDefinition + .getDataChildByName(RestconfModule.RESTCONF_CONTAINER_QNAME)) + .getDataChildByName(RestconfModule.LIB_VER_LEAF_QNAME); + } + } + final YangInstanceIdentifier yangIId = YangInstanceIdentifier.of( + QName.create(RestconfModule.NAME, RestconfModule.REVISION, RestconfModule.LIB_VER_LEAF_SCHEMA_NODE)); + final InstanceIdentifierContext iid = + new InstanceIdentifierContext(yangIId, schemaNode, null, context); + final NormalizedNode data = + Builders.leafBuilder((LeafSchemaNode) schemaNode).withValue(IetfYangLibrary.REVISION).build(); + return new NormalizedNodeContext(iid, data); + } +} diff --git a/restconf/sal-rest-connector/src/main/java/org/opendaylight/restconf/common/wrapper/services/ServicesWrapperImpl.java b/restconf/sal-rest-connector/src/main/java/org/opendaylight/restconf/common/wrapper/services/ServicesWrapperImpl.java index dfc6620287..21d8acb930 100644 --- a/restconf/sal-rest-connector/src/main/java/org/opendaylight/restconf/common/wrapper/services/ServicesWrapperImpl.java +++ b/restconf/sal-rest-connector/src/main/java/org/opendaylight/restconf/common/wrapper/services/ServicesWrapperImpl.java @@ -17,6 +17,8 @@ import org.opendaylight.netconf.sal.restconf.impl.PATCHStatusContext; import org.opendaylight.restconf.base.services.api.BaseServicesWrapper; import org.opendaylight.restconf.base.services.api.RestconfOperationsService; import org.opendaylight.restconf.base.services.api.RestconfSchemaService; +import org.opendaylight.restconf.base.services.api.RestconfService; +import org.opendaylight.restconf.base.services.impl.RestconfImpl; import org.opendaylight.restconf.base.services.impl.RestconfOperationsServiceImpl; import org.opendaylight.restconf.base.services.impl.RestconfSchemaServiceImpl; import org.opendaylight.restconf.handlers.DOMDataBrokerHandler; @@ -49,6 +51,7 @@ public class ServicesWrapperImpl implements BaseServicesWrapper, TransactionServ private RestconfStreamsSubscriptionService delegRestconfSubscrService; private RestconfOperationsService delegRestOpsService; private RestconfSchemaService delegRestSchService; + private RestconfService delegRestService; private ServicesWrapperImpl() { } @@ -118,7 +121,7 @@ public class ServicesWrapperImpl implements BaseServicesWrapper, TransactionServ @Override public NormalizedNodeContext invokeRpc(final String identifier, final NormalizedNodeContext payload, - final UriInfo uriInfo) { + final UriInfo uriInfo) { return this.delegRestconfInvokeOpsService.invokeRpc(identifier, payload, uriInfo); } @@ -127,19 +130,23 @@ public class ServicesWrapperImpl implements BaseServicesWrapper, TransactionServ return this.delegRestconfSubscrService.subscribeToStream(identifier, uriInfo); } + @Override + public NormalizedNodeContext getLibraryVersion() { + return this.delegRestService.getLibraryVersion(); + } + public void setHandlers(final SchemaContextHandler schemaCtxHandler, - final DOMMountPointServiceHandler domMountPointServiceHandler, - final TransactionChainHandler transactionChainHandler, - final DOMDataBrokerHandler domDataBrokerHandler, + final DOMMountPointServiceHandler domMountPointServiceHandler, + final TransactionChainHandler transactionChainHandler, final DOMDataBrokerHandler domDataBrokerHandler, final RpcServiceHandler rpcServiceHandler, final NotificationServiceHandler notificationServiceHandler) { this.delegRestOpsService = new RestconfOperationsServiceImpl(schemaCtxHandler, domMountPointServiceHandler); this.delegRestSchService = new RestconfSchemaServiceImpl(schemaCtxHandler, domMountPointServiceHandler); - this.delegRestconfDataService = new RestconfDataServiceImpl(schemaCtxHandler, transactionChainHandler, - domMountPointServiceHandler); - this.delegRestconfInvokeOpsService = new RestconfInvokeOperationsServiceImpl(rpcServiceHandler, - schemaCtxHandler); - this.delegRestconfSubscrService = - new RestconfStreamsSubscriptionServiceImpl(domDataBrokerHandler, notificationServiceHandler, - schemaCtxHandler, transactionChainHandler); + this.delegRestconfDataService = + new RestconfDataServiceImpl(schemaCtxHandler, transactionChainHandler, domMountPointServiceHandler); + this.delegRestconfInvokeOpsService = + new RestconfInvokeOperationsServiceImpl(rpcServiceHandler, schemaCtxHandler); + this.delegRestconfSubscrService = new RestconfStreamsSubscriptionServiceImpl(domDataBrokerHandler, + notificationServiceHandler, schemaCtxHandler, transactionChainHandler); + this.delegRestService = new RestconfImpl(schemaCtxHandler); } } diff --git a/restconf/sal-rest-connector/src/main/java/org/opendaylight/restconf/utils/mapping/RestconfMappingNodeUtil.java b/restconf/sal-rest-connector/src/main/java/org/opendaylight/restconf/utils/mapping/RestconfMappingNodeUtil.java index a081989469..5365413296 100644 --- a/restconf/sal-rest-connector/src/main/java/org/opendaylight/restconf/utils/mapping/RestconfMappingNodeUtil.java +++ b/restconf/sal-rest-connector/src/main/java/org/opendaylight/restconf/utils/mapping/RestconfMappingNodeUtil.java @@ -471,8 +471,8 @@ public final class RestconfMappingNodeUtil { */ @SuppressWarnings("rawtypes") public static NormalizedNode mapYangNotificationStreamByIetfRestconfMonitoring(final QName notifiQName, - final Set notifications, final Date start, final String outputType, - final URI uri, final Module monitoringModule, final boolean existParent) { + final Set notifications, final Date start, final String outputType, final URI uri, + final Module monitoringModule, final boolean existParent) { for (final NotificationDefinition notificationDefinition : notifications) { if (notificationDefinition.getQName().equals(notifiQName)) { final DataSchemaNode streamListSchema = ((ContainerSchemaNode) ((ContainerSchemaNode) monitoringModule @@ -506,8 +506,8 @@ public final class RestconfMappingNodeUtil { .getDataChildByName(MonitoringModule.CONT_RESTCONF_STATE_QNAME)) .getDataChildByName(MonitoringModule.CONT_STREAMS_QNAME); return Builders.containerBuilder((ContainerSchemaNode) contStreamsSchema).withChild(Builders - .mapBuilder((ListSchemaNode) streamListSchema).withChild(streamEntry.build()) - .build()).build(); + .mapBuilder((ListSchemaNode) streamListSchema).withChild(streamEntry.build()).build()) + .build(); } return streamEntry.build(); } @@ -567,9 +567,8 @@ public final class RestconfMappingNodeUtil { */ @SuppressWarnings("rawtypes") public static NormalizedNode mapDataChangeNotificationStreamByIetfRestconfMonitoring( - final YangInstanceIdentifier path, final Date start, - final String outputType, final URI uri, final Module monitoringModule, final boolean existParent, - final SchemaContext schemaContext) { + final YangInstanceIdentifier path, final Date start, final String outputType, final URI uri, + final Module monitoringModule, final boolean existParent, final SchemaContext schemaContext) { final SchemaNode schemaNode = ParserIdentifier .toInstanceIdentifier(ParserIdentifier.stringFromYangInstanceIdentifier(path, schemaContext), schemaContext, null) diff --git a/restconf/sal-rest-connector/src/test/java/org/opendaylight/restconf/base/services/impl/RestconfImplTest.java b/restconf/sal-rest-connector/src/test/java/org/opendaylight/restconf/base/services/impl/RestconfImplTest.java new file mode 100644 index 0000000000..2d1e64517d --- /dev/null +++ b/restconf/sal-rest-connector/src/test/java/org/opendaylight/restconf/base/services/impl/RestconfImplTest.java @@ -0,0 +1,47 @@ +/* + * Copyright (c) 2016 Cisco Systems, Inc. and others. All rights reserved. + * + * This program and the accompanying materials are made available under the + * terms of the Eclipse Public License v1.0 which accompanies this distribution, + * and is available at http://www.eclipse.org/legal/epl-v10.html + */ +package org.opendaylight.restconf.base.services.impl; + +import com.google.common.util.concurrent.CheckedFuture; +import org.junit.Assert; +import org.junit.Test; +import org.mockito.Mockito; +import org.opendaylight.controller.md.sal.dom.api.DOMDataWriteTransaction; +import org.opendaylight.controller.md.sal.dom.api.DOMTransactionChain; +import org.opendaylight.controller.md.sal.rest.common.TestRestconfUtils; +import org.opendaylight.netconf.sal.restconf.impl.NormalizedNodeContext; +import org.opendaylight.restconf.Draft18.IetfYangLibrary; +import org.opendaylight.restconf.handlers.SchemaContextHandler; +import org.opendaylight.restconf.handlers.TransactionChainHandler; +import org.opendaylight.yangtools.yang.data.api.schema.LeafNode; +import org.opendaylight.yangtools.yang.model.api.SchemaContext; + +public class RestconfImplTest { + + @Test + public void RestImplTest() throws Exception { + final SchemaContext schemaContext = TestRestconfUtils.loadSchemaContext("/restconf/impl"); + + final TransactionChainHandler txHandler = Mockito.mock(TransactionChainHandler.class); + final DOMTransactionChain domTx = Mockito.mock(DOMTransactionChain.class); + Mockito.when(txHandler.get()).thenReturn(domTx); + final DOMDataWriteTransaction wTx = Mockito.mock(DOMDataWriteTransaction.class); + Mockito.when(domTx.newWriteOnlyTransaction()).thenReturn(wTx); + final CheckedFuture checked = Mockito.mock(CheckedFuture.class); + Mockito.when(wTx.submit()).thenReturn(checked); + final Object valueObj = null; + Mockito.when(checked.checkedGet()).thenReturn(valueObj); + final SchemaContextHandler schemaContextHandler = new SchemaContextHandler(txHandler); + schemaContextHandler.onGlobalContextUpdated(schemaContext); + + final RestconfImpl restconfImpl = new RestconfImpl(schemaContextHandler); + final NormalizedNodeContext libraryVersion = restconfImpl.getLibraryVersion(); + final LeafNode value = (LeafNode) libraryVersion.getData(); + Assert.assertEquals(IetfYangLibrary.REVISION, value.getValue()); + } +} diff --git a/restconf/sal-rest-connector/src/test/java/org/opendaylight/restconf/rest/services/impl/RestconfOperationsServiceTest.java b/restconf/sal-rest-connector/src/test/java/org/opendaylight/restconf/base/services/impl/RestconfOperationsServiceTest.java similarity index 98% rename from restconf/sal-rest-connector/src/test/java/org/opendaylight/restconf/rest/services/impl/RestconfOperationsServiceTest.java rename to restconf/sal-rest-connector/src/test/java/org/opendaylight/restconf/base/services/impl/RestconfOperationsServiceTest.java index 7138f1dc0b..7037bf8429 100644 --- a/restconf/sal-rest-connector/src/test/java/org/opendaylight/restconf/rest/services/impl/RestconfOperationsServiceTest.java +++ b/restconf/sal-rest-connector/src/test/java/org/opendaylight/restconf/base/services/impl/RestconfOperationsServiceTest.java @@ -5,7 +5,7 @@ * 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.restconf.rest.services.impl; +package org.opendaylight.restconf.base.services.impl; import static org.junit.Assert.assertEquals; import static org.junit.Assert.assertNull; diff --git a/restconf/sal-rest-connector/src/test/java/org/opendaylight/restconf/rest/services/impl/RestconfSchemaServiceTest.java b/restconf/sal-rest-connector/src/test/java/org/opendaylight/restconf/base/services/impl/RestconfSchemaServiceTest.java similarity index 99% rename from restconf/sal-rest-connector/src/test/java/org/opendaylight/restconf/rest/services/impl/RestconfSchemaServiceTest.java rename to restconf/sal-rest-connector/src/test/java/org/opendaylight/restconf/base/services/impl/RestconfSchemaServiceTest.java index 4480c0e25c..e3f65e7a67 100644 --- a/restconf/sal-rest-connector/src/test/java/org/opendaylight/restconf/rest/services/impl/RestconfSchemaServiceTest.java +++ b/restconf/sal-rest-connector/src/test/java/org/opendaylight/restconf/base/services/impl/RestconfSchemaServiceTest.java @@ -6,7 +6,7 @@ * and is available at http://www.eclipse.org/legal/epl-v10.html */ -package org.opendaylight.restconf.rest.services.impl; +package org.opendaylight.restconf.base.services.impl; import static org.junit.Assert.assertEquals; import static org.junit.Assert.assertNotNull; diff --git a/restconf/sal-rest-connector/src/test/resources/restconf/impl/ietf-inet-types.yang b/restconf/sal-rest-connector/src/test/resources/restconf/impl/ietf-inet-types.yang new file mode 100644 index 0000000000..de20febbb7 --- /dev/null +++ b/restconf/sal-rest-connector/src/test/resources/restconf/impl/ietf-inet-types.yang @@ -0,0 +1,418 @@ + module ietf-inet-types { + + namespace "urn:ietf:params:xml:ns:yang:ietf-inet-types"; + prefix "inet"; + + organization + "IETF NETMOD (NETCONF Data Modeling Language) Working Group"; + + contact + "WG Web: + WG List: + + WG Chair: David Partain + + + WG Chair: David Kessens + + + Editor: Juergen Schoenwaelder + "; + + description + "This module contains a collection of generally useful derived + YANG data types for Internet addresses and related things. + + 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 6021; see + the RFC itself for full legal notices."; + + revision 2010-09-24 { + description + "Initial revision."; + reference + "RFC 6021: Common YANG Data Types"; + } + + /*** collection of protocol field related types ***/ + + 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 flow-label type represents flow identifier or Flow Label + in an IPv6 packet header that may be used to discriminate + traffic flows. + + In the value set and its semantics, this type is equivalent + to the IPv6FlowLabel textual convention of the SMIv2."; + reference + "RFC 3595: Textual Conventions for IPv6 Flow Label + RFC 2460: Internet Protocol, Version 6 (IPv6) Specification"; + } + + typedef port-number { + type uint16 { + range "0..65535"; + } + description + "The port-number type represents a 16-bit port number of an + Internet transport layer protocol such as UDP, TCP, DCCP, or + SCTP. Port numbers are assigned by IANA. A current list of + all assignments is available from . + + Note that the port number value zero is reserved by IANA. In + situations where the value zero does not make sense, it can + be excluded by subtyping the port-number type. + + In the value set and its semantics, this type is equivalent + to the InetPortNumber textual convention of the SMIv2."; + reference + "RFC 768: User Datagram Protocol + RFC 793: Transmission Control Protocol + RFC 4960: Stream Control Transmission Protocol + RFC 4340: Datagram Congestion Control Protocol (DCCP) + RFC 4001: Textual Conventions for Internet Network Addresses"; + } + + /*** collection of autonomous system related types ***/ + + 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 ASs'. 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 4893: BGP Support for Four-octet AS Number Space + RFC 4001: Textual Conventions for Internet Network Addresses"; + } + + /*** collection of IP address and hostname related types ***/ + + 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 representations + implies the IP version."; + } + + 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 compressed + format described in RFC 4291, Section 2.2, item 2 with the + following additional rules: the :: substitution must be + applied to the longest sequence of all-zero 16-bit chunks + in an IPv6 address. If there is a tie, the first sequence + of all-zero 16-bit chunks is replaced by ::. Single + all-zero 16-bit chunks are not compressed. The canonical + format uses lowercase characters and leading zeros are + not allowed. The canonical format for the zone index is + the numerical format as described in RFC 4007, Section + 11.2."; + 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 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, IPv6 address is represented + in the compressed format described in RFC 4291, Section + 2.2, item 2 with the following additional rules: the :: + substitution must be applied to the longest sequence of + all-zero 16-bit chunks in an IPv6 address. If there is + a tie, the first sequence of all-zero 16-bit chunks is + replaced by ::. Single all-zero 16-bit chunks are not + compressed. The canonical format uses lowercase + characters and leading zeros are not allowed."; + reference + "RFC 4291: IP Version 6 Addressing Architecture"; + } + + /*** 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 + explicitely or it 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 encoded in punycode as described in RFC + 3492"; + 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 3492: Punycode: A Bootstring encoding of Unicode for + Internationalized Domain Names in Applications + (IDNA) + RFC 5891: Internationalizing Domain Names in Applications + (IDNA): Protocol"; + } + + 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)"; + } + + } diff --git a/restconf/sal-rest-connector/src/test/resources/restconf/impl/ietf-restconf-monitoring@2016-08-15.yang b/restconf/sal-rest-connector/src/test/resources/restconf/impl/ietf-restconf-monitoring@2016-08-15.yang new file mode 100644 index 0000000000..82041414d1 --- /dev/null +++ b/restconf/sal-rest-connector/src/test/resources/restconf/impl/ietf-restconf-monitoring@2016-08-15.yang @@ -0,0 +1,148 @@ +module ietf-restconf-monitoring { + namespace "urn:ietf:params:xml:ns:yang:ietf-restconf-monitoring"; + prefix "rcmon"; + + import ietf-yang-types { prefix yang; } + import ietf-inet-types { prefix inet; } + + organization + "IETF NETCONF (Network Configuration) Working Group"; + + contact + "WG Web: + WG List: + Author: Andy Bierman + + Author: Martin Bjorklund + + Author: Kent Watsen + "; + + description + "This module contains monitoring information for the + RESTCONF protocol. + Copyright (c) 2016 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.: remove this note + // Note: extracted from draft-ietf-netconf-restconf-17.txt + + // RFC Ed.: update the date below with the date of RFC publication + // and remove this note. + revision 2016-08-15 { + description + "Initial revision."; + reference + "RFC XXXX: RESTCONF Protocol."; + } + + container restconf-state { + config false; + description + "Contains RESTCONF protocol monitoring information."; + + container capabilities { + description + "Contains a list of protocol capability URIs"; + + leaf-list capability { + type inet:uri; + description "A RESTCONF protocol capability URI."; + } + } + + container streams { + description + "Container representing the notification event streams + supported by the server."; + reference + "RFC 5277, Section 3.4, element."; + + list stream { + key name; + description + "Each entry describes an event stream supported by + the server."; + + leaf name { + type string; + description "The stream name"; + reference "RFC 5277, Section 3.4, element."; + } + + leaf description { + type string; + description "Description of stream content"; + reference + "RFC 5277, Section 3.4, element."; + } + + leaf replay-support { + type boolean; + default false; + description + "Indicates if replay buffer supported for this stream. + If 'true', then the server MUST support the 'start-time' + and 'stop-time' query parameters for this stream."; + reference + "RFC 5277, Section 3.4, element."; + } + + leaf replay-log-creation-time { + when "../replay-support" { + description + "Only present if notification replay is supported"; + } + type yang:date-and-time; + description + "Indicates the time the replay log for this stream + was created."; + reference + "RFC 5277, Section 3.4, + element."; + } + + list access { + key encoding; + min-elements 1; + description + "The server will create an entry in this list for each + encoding format that is supported for this stream. + The media type 'text/event-stream' is expected + for all event streams. This list identifies the + sub-types supported for this stream."; + + leaf encoding { + type string; + description + "This is the secondary encoding format within the + 'text/event-stream' encoding used by all streams. + The type 'xml' is supported for XML encoding. + The type 'json' is supported for JSON encoding."; + } + + leaf location { + type inet:uri; + mandatory true; + description + "Contains a URL that represents the entry point + for establishing notification delivery via server + sent events."; + } + } + } + } + } + +} diff --git a/restconf/sal-rest-connector/src/test/resources/restconf/impl/ietf-restconf@2016-08-15.yang b/restconf/sal-rest-connector/src/test/resources/restconf/impl/ietf-restconf@2016-08-15.yang new file mode 100644 index 0000000000..2f642de75f --- /dev/null +++ b/restconf/sal-rest-connector/src/test/resources/restconf/impl/ietf-restconf@2016-08-15.yang @@ -0,0 +1,256 @@ +module ietf-restconf { + yang-version 1.1; + namespace "urn:ietf:params:xml:ns:yang:ietf-restconf"; + prefix "rc"; + + organization + "IETF NETCONF (Network Configuration) Working Group"; + + contact + "WG Web: + WG List: + Author: Andy Bierman + + Author: Martin Bjorklund + + Author: Kent Watsen + "; + + description + "This module contains conceptual YANG specifications + for basic RESTCONF media type definitions used in + RESTCONF protocol messages. + Note that the YANG definitions within this module do not + represent configuration data of any kind. + The 'restconf-media-type' YANG extension statement + provides a normative syntax for XML and JSON message + encoding purposes. + Copyright (c) 2016 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.: remove this note + // Note: extracted from draft-ietf-netconf-restconf-17.txt + + // RFC Ed.: update the date below with the date of RFC publication + // and remove this note. + revision 2016-08-15 { + description + "Initial revision."; + reference + "RFC XXXX: RESTCONF Protocol."; + } + + extension yang-data { + argument name { + yin-element true; + } + description + "This extension is used to specify a YANG data template which + represents conceptual data defined in YANG. It is + intended to describe hierarchical data independent of + protocol context or specific message encoding format. + Data definition statements within a yang-data extension + specify the generic syntax for the specific YANG data + template, whose name is the argument of the yang-data + extension statement. + Note that this extension does not define a media-type. + A specification using this extension MUST specify the + message encoding rules, including the content media type. + The mandatory 'name' parameter value identifies the YANG + data template that is being defined. It contains the + template name. + This extension is ignored unless it appears as a top-level + statement. It MUST contain data definition statements + that result in exactly one container data node definition. + An instance of a YANG data template can thus be translated + into an XML instance document, whose top-level element + corresponds to the top-level container. + The module name and namespace value for the YANG module using + the extension statement is assigned to instance document data + conforming to the data definition statements within + this extension. + The sub-statements of this extension MUST follow the + 'data-def-stmt' rule in the YANG ABNF. + The XPath document root is the extension statement itself, + such that the child nodes of the document root are + represented by the data-def-stmt sub-statements within + this extension. This conceptual document is the context + for the following YANG statements: + - must-stmt + - when-stmt + - path-stmt + - min-elements-stmt + - max-elements-stmt + - mandatory-stmt + - unique-stmt + - ordered-by + - instance-identifier data type + The following data-def-stmt sub-statements are constrained + when used within a yang-data-resource extension statement. + - The list-stmt is not required to have a key-stmt defined. + - The if-feature-stmt is ignored if present. + - The config-stmt is ignored if present. + - The available identity values for any 'identityref' + leaf or leaf-list nodes is limited to the module + containing this extension statement, and the modules + imported into that module. + "; + } + + rc:yang-data yang-errors { + uses errors; + } + + rc:yang-data yang-api { + uses restconf; + } + + grouping errors { + description + "A grouping that contains a YANG container + representing the syntax and semantics of a + YANG Patch errors report within a response message."; + + container errors { + description + "Represents an error report returned by the server if + a request results in an error."; + + list error { + description + "An entry containing information about one + specific error that occurred while processing + a RESTCONF request."; + reference "RFC 6241, Section 4.3"; + + leaf error-type { + type enumeration { + enum transport { + description "The transport layer"; + } + enum rpc { + description "The rpc or notification layer"; + } + enum protocol { + description "The protocol operation layer"; + } + enum application { + description "The server application layer"; + } + } + mandatory true; + description + "The protocol layer where the error occurred."; + } + + leaf error-tag { + type string; + mandatory true; + description + "The enumerated error tag."; + } + + leaf error-app-tag { + type string; + description + "The application-specific error tag."; + } + + leaf error-path { + type instance-identifier; + description + "The YANG instance identifier associated + with the error node."; + } + + leaf error-message { + type string; + description + "A message describing the error."; + } + + anydata error-info { + description + "This anydata value MUST represent a container with + zero or more data nodes representing additional + error information."; + } + } + } + } + + grouping restconf { + description + "Conceptual grouping representing the RESTCONF + root resource."; + + container restconf { + description + "Conceptual container representing the RESTCONF + root resource."; + + container data { + description + "Container representing the datastore resource. + Represents the conceptual root of all state data + and configuration data supported by the server. + The child nodes of this container can be any data + resource which are defined as top-level data nodes + from the YANG modules advertised by the server in + the ietf-yang-library module."; + } + + container operations { + description + "Container for all operation resources. + Each resource is represented as an empty leaf with the + name of the RPC operation from the YANG rpc statement. + For example, the 'system-restart' RPC operation defined + in the 'ietf-system' module would be represented as + an empty leaf in the 'ietf-system' namespace. This is + a conceptual leaf, and will not actually be found in + the module: + module ietf-system { + leaf system-reset { + type empty; + } + } + To invoke the 'system-restart' RPC operation: + POST /restconf/operations/ietf-system:system-restart + To discover the RPC operations supported by the server: + GET /restconf/operations + In XML the YANG module namespace identifies the module: + + In JSON the YANG module name identifies the module: + { 'ietf-system:system-restart' : [null] } + "; + } + + leaf yang-library-version { + type string { + pattern '\d{4}-\d{2}-\d{2}'; + } + config false; + mandatory true; + description + "Identifies the revision date of the ietf-yang-library + module that is implemented by this RESTCONF server. + Indicates the year, month, and day in YYYY-MM-DD + numeric format."; + } + } + } + +} diff --git a/restconf/sal-rest-connector/src/test/resources/restconf/impl/ietf-yang-library@2016-06-21.yang b/restconf/sal-rest-connector/src/test/resources/restconf/impl/ietf-yang-library@2016-06-21.yang new file mode 100644 index 0000000000..bc466ee09d --- /dev/null +++ b/restconf/sal-rest-connector/src/test/resources/restconf/impl/ietf-yang-library@2016-06-21.yang @@ -0,0 +1,208 @@ +module ietf-yang-library { + namespace "urn:ietf:params:xml:ns:yang:ietf-yang-library"; + prefix "yanglib"; + import ietf-yang-types { + prefix yang; + } + import ietf-inet-types { + prefix inet; + } + organization + "IETF NETCONF (Network Configuration) Working Group"; + contact + "WG Web: + WG List: + WG Chair: Mehmet Ersue + + WG Chair: Mahesh Jethanandani + + Editor: Andy Bierman + + Editor: Martin Bjorklund + + Editor: Kent Watsen + "; + description + "This module contains monitoring information about the YANG + modules and submodules that are used within a YANG-based + server. + Copyright (c) 2016 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 7895; see + the RFC itself for full legal notices."; + revision 2016-06-21 { + description + "Initial revision."; + reference + "RFC 7895: YANG Module Library."; + } + /* + * Typedefs + */ + typedef revision-identifier { + type string { + pattern '\d{4}-\d{2}-\d{2}'; + } + description + "Represents a specific date in YYYY-MM-DD format."; + } + /* + * Groupings + */ + grouping module-list { + description + "The module data structure is represented as a grouping + so it can be reused in configuration or another monitoring + data structure."; + grouping common-leafs { + description + "Common parameters for YANG modules and submodules."; + leaf name { + type yang:yang-identifier; + description + "The YANG module or submodule name."; + } + leaf revision { + type union { + type revision-identifier; + type string { length 0; } + } + description + "The YANG module or submodule revision date. + A zero-length string is used if no revision statement + is present in the YANG module or submodule."; + } + } + grouping schema-leaf { + description + "Common schema leaf parameter for modules and submodules."; + leaf schema { + type inet:uri; + description + "Contains a URL that represents the YANG schema + resource for this module or submodule. + This leaf will only be present if there is a URL + available for retrieval of the schema for this entry."; + } + } + list module { + key "name revision"; + description + "Each entry represents one revision of one module + currently supported by the server."; + uses common-leafs; + uses schema-leaf; + leaf namespace { + type inet:uri; + mandatory true; + description + "The XML namespace identifier for this module."; + } + leaf-list feature { + type yang:yang-identifier; + description + "List of YANG feature names from this module that are + supported by the server, regardless of whether they are + defined in the module or any included submodule."; + } + list deviation { + key "name revision"; + description + "List of YANG deviation module names and revisions + used by this server to modify the conformance of + the module associated with this entry. Note that + the same module can be used for deviations for + multiple modules, so the same entry MAY appear + within multiple 'module' entries. + The deviation module MUST be present in the 'module' + list, with the same name and revision values. + The 'conformance-type' value will be 'implement' for + the deviation module."; + uses common-leafs; + } + leaf conformance-type { + type enumeration { + enum implement { + description + "Indicates that the server implements one or more + protocol-accessible objects defined in the YANG module + identified in this entry. This includes deviation + statements defined in the module. + For YANG version 1.1 modules, there is at most one + module entry with conformance type 'implement' for a + particular module name, since YANG 1.1 requires that, + at most, one revision of a module is implemented. + For YANG version 1 modules, there SHOULD NOT be more + than one module entry for a particular module name."; + } + enum import { + description + "Indicates that the server imports reusable definitions + from the specified revision of the module but does + not implement any protocol-accessible objects from + this revision. + Multiple module entries for the same module name MAY + exist. This can occur if multiple modules import the + same module but specify different revision dates in + the import statements."; + } + } + mandatory true; + description + "Indicates the type of conformance the server is claiming + for the YANG module identified by this entry."; + } + list submodule { + key "name revision"; + description + "Each entry represents one submodule within the + parent module."; + uses common-leafs; + uses schema-leaf; + } + } + } + /* + * Operational state data nodes + */ + container modules-state { + config false; + description + "Contains YANG module monitoring information."; + leaf module-set-id { + type string; + mandatory true; + description + "Contains a server-specific identifier representing + the current set of modules and submodules. The + server MUST change the value of this leaf if the + information represented by the 'module' list instances + has changed."; + } + uses module-list; + } + /* + * Notifications + */ + notification yang-library-change { + description + "Generated when the set of modules and submodules supported + by the server has changed."; + leaf module-set-id { + type leafref { + path "/yanglib:modules-state/yanglib:module-set-id"; + } + mandatory true; + description + "Contains the module-set-id value representing the + set of modules and submodules supported at the server at + the time the notification is generated."; + } + } +} diff --git a/restconf/sal-rest-connector/src/test/resources/restconf/impl/ietf-yang-types.yang b/restconf/sal-rest-connector/src/test/resources/restconf/impl/ietf-yang-types.yang new file mode 100644 index 0000000000..c3f952cf25 --- /dev/null +++ b/restconf/sal-rest-connector/src/test/resources/restconf/impl/ietf-yang-types.yang @@ -0,0 +1,417 @@ + 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: + WG List: + + WG Chair: David Partain + + + WG Chair: David Kessens + + + Editor: Juergen Schoenwaelder + "; + + description + "This module contains a collection of generally useful derived + YANG data types. + + 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 6021; see + the RFC itself for full legal notices."; + + 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-identifier. 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 date and time related types ***/ + + 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"; + } + + } -- 2.36.6