From f5cb5dd25e896eb6cdcb37c897ee4451f7ec4cbf Mon Sep 17 00:00:00 2001 From: Roshan Joyce Date: Fri, 17 Mar 2023 17:31:36 +0530 Subject: [PATCH] Catalog RPC Implementation Also, declare CatalogDataStoreOperations as a Component JIRA: TRNSPRTPCE-714 Signed-off-by: Roshan Joyce Co-authored-by: Gilles Thouenon Change-Id: I9fe5b5c00d0145ceabd2edb7961f1f3e46065fee (cherry picked from commit 30a7633eb11290b9fc0da5116fb9f6bec50710cc) --- .../tpce/module/TransportPCEImpl.java | 9 +- .../servicehandler/CatalogInput.java | 66 +++++++ .../servicehandler/ModelMappingUtils.java | 47 +++++ .../catalog/CatalogDataStoreOperations.java | 28 +++ .../CatalogDataStoreOperationsImpl.java | 68 +++++++ .../servicehandler/catalog/CatalogMapper.java | 178 ++++++++++++++++++ .../impl/ServicehandlerImpl.java | 82 +++++++- .../utils/CatalogDataUtils.java | 84 +++++++++ .../validation/CatalogValidation.java | 61 ++++++ .../checks/ServicehandlerComplianceCheck.java | 77 ++++++++ .../impl/ServicehandlerImplTest.java | 116 +++++++++--- .../TapiConnectivityImplTest.java | 13 +- 12 files changed, 793 insertions(+), 36 deletions(-) create mode 100644 servicehandler/src/main/java/org/opendaylight/transportpce/servicehandler/CatalogInput.java create mode 100644 servicehandler/src/main/java/org/opendaylight/transportpce/servicehandler/catalog/CatalogDataStoreOperations.java create mode 100644 servicehandler/src/main/java/org/opendaylight/transportpce/servicehandler/catalog/CatalogDataStoreOperationsImpl.java create mode 100644 servicehandler/src/main/java/org/opendaylight/transportpce/servicehandler/catalog/CatalogMapper.java create mode 100644 servicehandler/src/main/java/org/opendaylight/transportpce/servicehandler/utils/CatalogDataUtils.java create mode 100644 servicehandler/src/main/java/org/opendaylight/transportpce/servicehandler/validation/CatalogValidation.java diff --git a/lighty/src/main/java/io/lighty/controllers/tpce/module/TransportPCEImpl.java b/lighty/src/main/java/io/lighty/controllers/tpce/module/TransportPCEImpl.java index 8eb97e47f..b11aab467 100644 --- a/lighty/src/main/java/io/lighty/controllers/tpce/module/TransportPCEImpl.java +++ b/lighty/src/main/java/io/lighty/controllers/tpce/module/TransportPCEImpl.java @@ -9,6 +9,8 @@ package io.lighty.controllers.tpce.module; import io.lighty.core.controller.api.AbstractLightyModule; import io.lighty.core.controller.api.LightyServices; +import org.opendaylight.transportpce.servicehandler.catalog.CatalogDataStoreOperations; +import org.opendaylight.transportpce.servicehandler.catalog.CatalogDataStoreOperationsImpl; import org.opendaylight.transportpce.common.crossconnect.CrossConnect; import org.opendaylight.transportpce.common.crossconnect.CrossConnectImpl; import org.opendaylight.transportpce.common.crossconnect.CrossConnectImpl121; @@ -171,9 +173,10 @@ public class TransportPCEImpl extends AbstractLightyModule implements TransportP lightyServices.getBindingNotificationPublishService(), serviceDataStoreOperations); NetworkModelListenerImpl networkModelListenerImpl = new NetworkModelListenerImpl( lightyServices.getBindingNotificationPublishService(), serviceDataStoreOperations); - ServicehandlerImpl servicehandler = new ServicehandlerImpl(pathComputationService, rendererServiceOperations, - lightyServices.getBindingNotificationPublishService(), pceListenerImpl, rendererListenerImpl, - networkModelListenerImpl, serviceDataStoreOperations); + CatalogDataStoreOperations catalogDataStoreOperations = new CatalogDataStoreOperationsImpl(networkTransaction); + OrgOpenroadmServiceService servicehandler = new ServicehandlerImpl(pathComputationService, + rendererServiceOperations, lightyServices.getBindingNotificationPublishService(), pceListenerImpl, + rendererListenerImpl, networkModelListenerImpl, serviceDataStoreOperations, catalogDataStoreOperations); ServiceListener serviceListener = new ServiceListener(servicehandler, serviceDataStoreOperations, lightyServices.getBindingNotificationPublishService()); servicehandlerProvider = new ServicehandlerProvider(lightyServices.getBindingDataBroker(), diff --git a/servicehandler/src/main/java/org/opendaylight/transportpce/servicehandler/CatalogInput.java b/servicehandler/src/main/java/org/opendaylight/transportpce/servicehandler/CatalogInput.java new file mode 100644 index 000000000..1cfc8bc3d --- /dev/null +++ b/servicehandler/src/main/java/org/opendaylight/transportpce/servicehandler/CatalogInput.java @@ -0,0 +1,66 @@ +/* + * Copyright © 2023 Fujitsu Network Communications, 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.transportpce.servicehandler; + +import org.opendaylight.yang.gen.v1.http.org.openroadm.common.service.types.rev211210.sdnc.request.header.SdncRequestHeader; +import org.opendaylight.yang.gen.v1.http.org.openroadm.service.rev211210.AddOpenroadmOperationalModesToCatalogInput; +import org.opendaylight.yang.gen.v1.http.org.openroadm.service.rev211210.AddSpecificOperationalModesToCatalogInput; +import org.opendaylight.yang.gen.v1.http.org.openroadm.service.rev211210.add.openroadm.operational.modes.to.catalog.input.OperationalModeInfo; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +public class CatalogInput { + + private static final Logger LOG = LoggerFactory.getLogger(CatalogInput.class); + private SdncRequestHeader sdncRequestHeader; + private OperationalModeInfo operationalModeInfo; + + private org.opendaylight.yang.gen.v1.http.org.openroadm.service.rev211210.add.specific.operational.modes + .to.catalog.input.OperationalModeInfo operationalModeInfoSpecific; + + public CatalogInput(AddOpenroadmOperationalModesToCatalogInput addORToCatalogInput) { + LOG.info("CatalogInput AddOpenroadmOperationalModesToCatalogInput"); + setSdncRequestHeader(addORToCatalogInput.getSdncRequestHeader()); + setOperationalModeInfo(addORToCatalogInput.getOperationalModeInfo()); + } + + public CatalogInput(AddSpecificOperationalModesToCatalogInput addSpecificToCatalogInput) { + LOG.info("CatalogInput AddSpecificOperationalModesToCatalogInput"); + setSdncRequestHeader(addSpecificToCatalogInput.getSdncRequestHeader()); + setOperationalModeInfoSpecific(addSpecificToCatalogInput.getOperationalModeInfo()); + } + + public SdncRequestHeader getSdncRequestHeader() { + return sdncRequestHeader; + } + + public void setSdncRequestHeader(SdncRequestHeader sdncRequestHeader) { + this.sdncRequestHeader = sdncRequestHeader; + } + + public OperationalModeInfo getOperationalModeInfo() { + return operationalModeInfo; + } + + public void setOperationalModeInfo(OperationalModeInfo operationalModeInfo) { + this.operationalModeInfo = operationalModeInfo; + } + + public org.opendaylight.yang.gen.v1.http.org.openroadm.service.rev211210.add.specific.operational.modes + .to.catalog.input.OperationalModeInfo getOperationalModeInfoSpecific() { + return operationalModeInfoSpecific; + } + + public void setOperationalModeInfoSpecific( + org.opendaylight.yang.gen.v1.http.org.openroadm.service.rev211210 + .add.specific.operational.modes.to.catalog.input.OperationalModeInfo + operationalModeInfoSpecific) { + this.operationalModeInfoSpecific = operationalModeInfoSpecific; + } +} diff --git a/servicehandler/src/main/java/org/opendaylight/transportpce/servicehandler/ModelMappingUtils.java b/servicehandler/src/main/java/org/opendaylight/transportpce/servicehandler/ModelMappingUtils.java index 7ef1bab19..59ee4570d 100644 --- a/servicehandler/src/main/java/org/opendaylight/transportpce/servicehandler/ModelMappingUtils.java +++ b/servicehandler/src/main/java/org/opendaylight/transportpce/servicehandler/ModelMappingUtils.java @@ -46,6 +46,12 @@ import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.common.types.rev21092 import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.common.types.rev210924.OTUflex; import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.common.types.rev210924.OduRateIdentity; import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.common.types.rev210924.OtuRateIdentity; +import org.opendaylight.yang.gen.v1.http.org.openroadm.service.rev211210.AddOpenroadmOperationalModesToCatalogInput; +import org.opendaylight.yang.gen.v1.http.org.openroadm.service.rev211210.AddOpenroadmOperationalModesToCatalogOutput; +import org.opendaylight.yang.gen.v1.http.org.openroadm.service.rev211210.AddOpenroadmOperationalModesToCatalogOutputBuilder; +import org.opendaylight.yang.gen.v1.http.org.openroadm.service.rev211210.AddSpecificOperationalModesToCatalogInput; +import org.opendaylight.yang.gen.v1.http.org.openroadm.service.rev211210.AddSpecificOperationalModesToCatalogOutput; +import org.opendaylight.yang.gen.v1.http.org.openroadm.service.rev211210.AddSpecificOperationalModesToCatalogOutputBuilder; import org.opendaylight.yang.gen.v1.http.org.openroadm.service.rev211210.ServiceCreateInput; import org.opendaylight.yang.gen.v1.http.org.openroadm.service.rev211210.ServiceCreateOutput; import org.opendaylight.yang.gen.v1.http.org.openroadm.service.rev211210.ServiceCreateOutputBuilder; @@ -632,4 +638,45 @@ public final class ModelMappingUtils { } return new int[] { endPos - maxLen, endPos }; } + + public static ListenableFuture> + addOpenroadmServiceReply(AddOpenroadmOperationalModesToCatalogInput input, String finalAck, + String message,String responseCode) { + return RpcResultBuilder + .success( + new AddOpenroadmOperationalModesToCatalogOutputBuilder() + .setConfigurationResponseCommon( + new ConfigurationResponseCommonBuilder() + .setAckFinalIndicator(finalAck) + .setResponseMessage(message) + .setResponseCode(responseCode) + .setRequestId( + input.getSdncRequestHeader() == null + ? null + : input.getSdncRequestHeader().getRequestId()) + .build()) + .build()) + .buildFuture(); + } + + public static ListenableFuture> + addSpecificOpenroadmServiceReply(AddSpecificOperationalModesToCatalogInput input, String finalAck, + String message,String responseCode) { + return RpcResultBuilder + .success( + new AddSpecificOperationalModesToCatalogOutputBuilder() + .setConfigurationResponseCommon( + new ConfigurationResponseCommonBuilder() + .setAckFinalIndicator(finalAck) + .setResponseMessage(message) + .setResponseCode(responseCode) + .setRequestId( + input.getSdncRequestHeader() == null + ? null + : input.getSdncRequestHeader().getRequestId()) + .build()) + .build()) + .buildFuture(); + } + } diff --git a/servicehandler/src/main/java/org/opendaylight/transportpce/servicehandler/catalog/CatalogDataStoreOperations.java b/servicehandler/src/main/java/org/opendaylight/transportpce/servicehandler/catalog/CatalogDataStoreOperations.java new file mode 100644 index 000000000..6a0d01dde --- /dev/null +++ b/servicehandler/src/main/java/org/opendaylight/transportpce/servicehandler/catalog/CatalogDataStoreOperations.java @@ -0,0 +1,28 @@ +/* + * Copyright © 2023 Fujitsu Network Communications, 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.transportpce.servicehandler.catalog; + +import org.opendaylight.yang.gen.v1.http.org.openroadm.operational.mode.catalog.rev211210.operational.mode.catalog.OpenroadmOperationalModes; +import org.opendaylight.yang.gen.v1.http.org.openroadm.operational.mode.catalog.rev211210.operational.mode.catalog.SpecificOperationalModes; + +/** + * Store operational mode catalog into MDSAL . + */ +public interface CatalogDataStoreOperations { + + /** + * Store OpenroadmOperationalModes object in the config data store. + */ + void addOpenroadmOperationalModesToCatalog(OpenroadmOperationalModes objToSave); + + /** + * Store SpecificOperationalModes object in the config data store. + */ + void addSpecificOperationalModesToCatalog(SpecificOperationalModes objToSave); + +} diff --git a/servicehandler/src/main/java/org/opendaylight/transportpce/servicehandler/catalog/CatalogDataStoreOperationsImpl.java b/servicehandler/src/main/java/org/opendaylight/transportpce/servicehandler/catalog/CatalogDataStoreOperationsImpl.java new file mode 100644 index 000000000..9fd17a907 --- /dev/null +++ b/servicehandler/src/main/java/org/opendaylight/transportpce/servicehandler/catalog/CatalogDataStoreOperationsImpl.java @@ -0,0 +1,68 @@ +/* + * Copyright © 2023 Fujitsu Network Communications, 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.transportpce.servicehandler.catalog; + +import java.util.concurrent.ExecutionException; +import java.util.concurrent.TimeUnit; +import java.util.concurrent.TimeoutException; +import org.opendaylight.mdsal.common.api.LogicalDatastoreType; +import org.opendaylight.transportpce.common.Timeouts; +import org.opendaylight.transportpce.common.network.NetworkTransactionService; +import org.opendaylight.yang.gen.v1.http.org.openroadm.operational.mode.catalog.rev211210.operational.mode.catalog.OpenroadmOperationalModes; +import org.opendaylight.yang.gen.v1.http.org.openroadm.operational.mode.catalog.rev211210.operational.mode.catalog.SpecificOperationalModes; +import org.opendaylight.yang.gen.v1.http.org.openroadm.service.rev211210.OperationalModeCatalog; +import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; +import org.osgi.service.component.annotations.Activate; +import org.osgi.service.component.annotations.Component; +import org.osgi.service.component.annotations.Reference; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +@Component +public class CatalogDataStoreOperationsImpl implements CatalogDataStoreOperations { + private static final Logger LOG = LoggerFactory.getLogger(CatalogDataStoreOperationsImpl.class); + + private NetworkTransactionService networkTransactionService; + + @Activate + public CatalogDataStoreOperationsImpl(@Reference NetworkTransactionService networkTransactionService) { + this.networkTransactionService = networkTransactionService; + } + + /** + * Store OpenroadmOperationalModes object in the config data store. + */ + @Override + public void addOpenroadmOperationalModesToCatalog(OpenroadmOperationalModes objToSave) { + LOG.info("Inside addOpenroadmOperationalModesToCatalog method of CatalogDataStoreOperationsImpl"); + try { + InstanceIdentifier instanceIdentifier = + InstanceIdentifier.create(OperationalModeCatalog.class).child(OpenroadmOperationalModes.class); + networkTransactionService.merge(LogicalDatastoreType.CONFIGURATION, instanceIdentifier , objToSave); + networkTransactionService.commit().get(Timeouts.DATASTORE_WRITE, TimeUnit.MILLISECONDS); + } catch (TimeoutException | InterruptedException | ExecutionException e) { + LOG.warn("Warning addOpenroadmOperationalModesToCatalog CatalogDataStoreOperationsImpl"); + } + } + + /** + * Store SpecificOperationalModes object in the config data store. + */ + @Override + public void addSpecificOperationalModesToCatalog(SpecificOperationalModes objToSave) { + LOG.info("Inside addSpecificOperationalModesToCatalog method of CatalogDataStoreOperationsImpl"); + try { + InstanceIdentifier instanceIdentifier = InstanceIdentifier + .create(OperationalModeCatalog.class).child(SpecificOperationalModes.class); + networkTransactionService.merge(LogicalDatastoreType.CONFIGURATION, instanceIdentifier , objToSave); + networkTransactionService.commit().get(Timeouts.DATASTORE_WRITE, TimeUnit.MILLISECONDS); + } catch (TimeoutException | InterruptedException | ExecutionException e) { + LOG.warn("Warning addSpecificOperationalModesToCatalog CatalogDataStoreOperationsImpl"); + } + } +} diff --git a/servicehandler/src/main/java/org/opendaylight/transportpce/servicehandler/catalog/CatalogMapper.java b/servicehandler/src/main/java/org/opendaylight/transportpce/servicehandler/catalog/CatalogMapper.java new file mode 100644 index 000000000..b67d5bb4b --- /dev/null +++ b/servicehandler/src/main/java/org/opendaylight/transportpce/servicehandler/catalog/CatalogMapper.java @@ -0,0 +1,178 @@ +/* + * Copyright © 2023 Fujitsu Network Communications, 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.transportpce.servicehandler.catalog; + +import java.util.HashMap; +import java.util.Iterator; +import java.util.Map; +import org.opendaylight.yang.gen.v1.http.org.openroadm.operational.mode.catalog.rev211210.operational.mode.catalog.OpenroadmOperationalModes; +import org.opendaylight.yang.gen.v1.http.org.openroadm.operational.mode.catalog.rev211210.operational.mode.catalog.OpenroadmOperationalModesBuilder; +import org.opendaylight.yang.gen.v1.http.org.openroadm.operational.mode.catalog.rev211210.operational.mode.catalog.SpecificOperationalModes; +import org.opendaylight.yang.gen.v1.http.org.openroadm.operational.mode.catalog.rev211210.operational.mode.catalog.SpecificOperationalModesBuilder; +import org.opendaylight.yang.gen.v1.http.org.openroadm.operational.mode.catalog.rev211210.operational.mode.catalog.openroadm.operational.modes.AmplifiersBuilder; +import org.opendaylight.yang.gen.v1.http.org.openroadm.operational.mode.catalog.rev211210.operational.mode.catalog.openroadm.operational.modes.GridParametersBuilder; +import org.opendaylight.yang.gen.v1.http.org.openroadm.operational.mode.catalog.rev211210.operational.mode.catalog.openroadm.operational.modes.RoadmsBuilder; +import org.opendaylight.yang.gen.v1.http.org.openroadm.operational.mode.catalog.rev211210.operational.mode.catalog.openroadm.operational.modes.XpondersPluggablesBuilder; +import org.opendaylight.yang.gen.v1.http.org.openroadm.operational.mode.catalog.rev211210.operational.mode.catalog.openroadm.operational.modes.xponders.pluggables.XponderPluggableOpenroadmOperationalModeBuilder; +import org.opendaylight.yang.gen.v1.http.org.openroadm.operational.mode.catalog.rev211210.operational.mode.catalog.specific.operational.modes.SpecificOperationalModeBuilder; +import org.opendaylight.yang.gen.v1.http.org.openroadm.operational.mode.catalog.rev211210.operational.mode.roadm.add.parameters.Add; +import org.opendaylight.yang.gen.v1.http.org.openroadm.operational.mode.catalog.rev211210.operational.mode.roadm.drop.parameters.Drop; +import org.opendaylight.yang.gen.v1.http.org.openroadm.operational.mode.catalog.rev211210.operational.mode.roadm.express.parameters.Express; +import org.opendaylight.yang.gen.v1.http.org.openroadm.service.rev211210.AddOpenroadmOperationalModesToCatalogInput; +import org.opendaylight.yang.gen.v1.http.org.openroadm.service.rev211210.AddSpecificOperationalModesToCatalogInput; +import org.opendaylight.yang.gen.v1.http.org.openroadm.service.rev211210.add.openroadm.operational.modes.to.catalog.input.OperationalModeInfo; +import org.opendaylight.yang.gen.v1.http.org.openroadm.service.rev211210.add.openroadm.operational.modes.to.catalog.input.operational.mode.info.xponders.pluggables.XponderPluggableOpenroadmOperationalMode; +import org.opendaylight.yang.gen.v1.http.org.openroadm.service.rev211210.add.openroadm.operational.modes.to.catalog.input.operational.mode.info.xponders.pluggables.XponderPluggableOpenroadmOperationalModeKey; +import org.opendaylight.yang.gen.v1.http.org.openroadm.service.rev211210.add.specific.operational.modes.to.catalog.input.operational.mode.info.specific.operational.modes.SpecificOperationalMode; +import org.opendaylight.yang.gen.v1.http.org.openroadm.service.rev211210.add.specific.operational.modes.to.catalog.input.operational.mode.info.specific.operational.modes.SpecificOperationalModeKey; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + + +public final class CatalogMapper { + private static final Logger LOG = LoggerFactory.getLogger(CatalogMapper.class); + + private CatalogMapper() { + } + + static SpecificOperationalModesBuilder specificObjBuilder = new SpecificOperationalModesBuilder(); + + static OpenroadmOperationalModesBuilder objBuilder = new OpenroadmOperationalModesBuilder(); + + /** + * Preparation of SpecificOperationalModes object which will be stored in the config data store + * and returning the same. + */ + public static SpecificOperationalModes createSpecificModesToSave(AddSpecificOperationalModesToCatalogInput input) { + LOG.info("Inside createSpecificModesToSave method of CatalogMapper"); + org.opendaylight.yang.gen.v1.http.org.openroadm.service.rev211210.add.specific.operational.modes.to.catalog + .input.operational.mode.info.SpecificOperationalModes specificModesFromInput = + input.getOperationalModeInfo().getSpecificOperationalModes(); + saveSpecificOperationalModes(specificModesFromInput); + return specificObjBuilder.build(); + } + + /** + * Preparation of OpenroadmOperationalModes object which will be stored in the config data store + * and returning the same. + */ + public static OpenroadmOperationalModes createORModesToSave(AddOpenroadmOperationalModesToCatalogInput input) { + LOG.info("Inside createORModesToSave method of CatalogMapper"); + OperationalModeInfo modesFromInput = input.getOperationalModeInfo(); + + saveGridParameters(modesFromInput); + saveXpondersPlugabbles(modesFromInput); + saveRoadms(modesFromInput); + saveAmplifiers(modesFromInput); + + return objBuilder.build(); + } + + /** + * Preparation of Amplifiers for OpenroadmOperationalModes object. + */ + private static void saveAmplifiers(OperationalModeInfo modesFromInput) { + objBuilder.setAmplifiers( + new AmplifiersBuilder() + .setAmplifier(modesFromInput.getAmplifiers().getAmplifier()) + .build()); + } + + /** + * Preparation of Grid Parameters for OpenroadmOperationalModes object. + */ + private static void saveGridParameters(OperationalModeInfo modesFromInput) { + objBuilder.setGridParameters(new GridParametersBuilder(modesFromInput.getGridParameters()).build()); + } + + /** + * Preparation of Xponders Pluggables for OpenroadmOperationalModes object. + */ + private static void saveXpondersPlugabbles(OperationalModeInfo modesFromInput) { + Map map = + modesFromInput.getXpondersPluggables().getXponderPluggableOpenroadmOperationalMode(); + Iterator> itr = + map.entrySet().iterator(); + + XpondersPluggablesBuilder xpondersPluggablesBuilder = new XpondersPluggablesBuilder(); + Map mapFinal = new HashMap<>(); + + while (itr.hasNext()) { + Map.Entry entry = + itr.next(); + + XponderPluggableOpenroadmOperationalModeBuilder + modeBuilder = new XponderPluggableOpenroadmOperationalModeBuilder(entry.getValue()); + + org.opendaylight.yang.gen.v1.http.org.openroadm.operational.mode.catalog.rev211210 + .operational.mode.catalog.openroadm.operational.modes.xponders.pluggables + .XponderPluggableOpenroadmOperationalModeKey key = + new org.opendaylight.yang.gen.v1.http.org.openroadm.operational.mode.catalog.rev211210 + .operational.mode.catalog.openroadm.operational.modes.xponders.pluggables + .XponderPluggableOpenroadmOperationalModeKey(entry.getKey().toString()); + + modeBuilder.setOpenroadmOperationalModeId(entry.getValue().getOpenroadmOperationalModeId()); + org.opendaylight.yang.gen.v1.http.org.openroadm.operational.mode.catalog.rev211210 + .operational.mode.catalog.openroadm.operational.modes.xponders.pluggables + .XponderPluggableOpenroadmOperationalMode mode = modeBuilder.build(); + mapFinal.put(key, mode); + xpondersPluggablesBuilder.setXponderPluggableOpenroadmOperationalMode(mapFinal); + objBuilder.setXpondersPluggables(xpondersPluggablesBuilder + .setXponderPluggableOpenroadmOperationalMode(mapFinal).build()); + } + } + + /** + * Preparation of Roadms for OpenroadmOperationalModes object. + */ + private static void saveRoadms(OperationalModeInfo modesFromInput) { + Add add = modesFromInput.getRoadms().getAdd(); + Drop drop = modesFromInput.getRoadms().getDrop(); + Express express = modesFromInput.getRoadms().getExpress(); + RoadmsBuilder roadmsBuilder = new RoadmsBuilder().setAdd(add).setDrop(drop).setExpress(express); + objBuilder.setRoadms(roadmsBuilder.build()); + } + + /** + * Preparation of Specific Operational Modes for SpecificOperationalModes object. + */ + private static void saveSpecificOperationalModes(org.opendaylight.yang.gen.v1.http.org.openroadm.service.rev211210 + .add.specific.operational.modes.to.catalog.input.operational.mode.info.SpecificOperationalModes + specificModesFromInput) { + Map map = + specificModesFromInput.getSpecificOperationalMode(); + Iterator> itr = map.entrySet().iterator(); + Map + mapFinal = new HashMap<>(); + while (itr.hasNext()) { + Map.Entry entry = itr.next(); + SpecificOperationalModeBuilder specificModeBuilder = new SpecificOperationalModeBuilder(); + specificModeBuilder.fieldsFrom(entry.getValue()); + org.opendaylight.yang.gen.v1.http.org.openroadm.operational.mode.catalog.rev211210 + .operational.mode.catalog.specific.operational.modes.SpecificOperationalModeKey specificModeKey = + new org.opendaylight.yang.gen.v1.http.org.openroadm.operational.mode.catalog.rev211210 + .operational.mode.catalog.specific.operational.modes.SpecificOperationalModeKey( + entry.getKey().toString()); + specificModeBuilder.setOperationalModeId(entry.getValue().getOperationalModeId()); + specificModeBuilder.setConfigurableOutputPower(true); + org.opendaylight.yang.gen.v1.http.org.openroadm.operational.mode.catalog.rev211210 + .operational.mode.catalog.specific.operational.modes.SpecificOperationalMode specificMode = + specificModeBuilder.build(); + mapFinal.put(specificModeKey, specificMode); + specificObjBuilder.setSpecificOperationalMode(mapFinal); + } + } +} diff --git a/servicehandler/src/main/java/org/opendaylight/transportpce/servicehandler/impl/ServicehandlerImpl.java b/servicehandler/src/main/java/org/opendaylight/transportpce/servicehandler/impl/ServicehandlerImpl.java index 40dd9bde7..0c1fcf2d7 100644 --- a/servicehandler/src/main/java/org/opendaylight/transportpce/servicehandler/impl/ServicehandlerImpl.java +++ b/servicehandler/src/main/java/org/opendaylight/transportpce/servicehandler/impl/ServicehandlerImpl.java @@ -18,15 +18,19 @@ import org.opendaylight.transportpce.common.OperationResult; import org.opendaylight.transportpce.common.ResponseCodes; import org.opendaylight.transportpce.pce.service.PathComputationService; import org.opendaylight.transportpce.renderer.provisiondevice.RendererServiceOperations; +import org.opendaylight.transportpce.servicehandler.CatalogInput; import org.opendaylight.transportpce.servicehandler.DowngradeConstraints; import org.opendaylight.transportpce.servicehandler.ModelMappingUtils; import org.opendaylight.transportpce.servicehandler.ServiceInput; +import org.opendaylight.transportpce.servicehandler.catalog.CatalogDataStoreOperations; +import org.opendaylight.transportpce.servicehandler.catalog.CatalogMapper; import org.opendaylight.transportpce.servicehandler.listeners.NetworkListener; import org.opendaylight.transportpce.servicehandler.listeners.PceListener; import org.opendaylight.transportpce.servicehandler.listeners.RendererListener; import org.opendaylight.transportpce.servicehandler.service.PCEServiceWrapper; import org.opendaylight.transportpce.servicehandler.service.RendererServiceWrapper; import org.opendaylight.transportpce.servicehandler.service.ServiceDataStoreOperations; +import org.opendaylight.transportpce.servicehandler.validation.CatalogValidation; import org.opendaylight.transportpce.servicehandler.validation.ServiceCreateValidation; import org.opendaylight.transportpce.servicehandler.validation.checks.ComplianceCheckResult; import org.opendaylight.transportpce.servicehandler.validation.checks.ServicehandlerComplianceCheck; @@ -38,6 +42,8 @@ import org.opendaylight.yang.gen.v1.http.org.openroadm.common.service.types.rev2 import org.opendaylight.yang.gen.v1.http.org.openroadm.common.service.types.rev211210.configuration.response.common.ConfigurationResponseCommon; import org.opendaylight.yang.gen.v1.http.org.openroadm.common.service.types.rev211210.sdnc.request.header.SdncRequestHeaderBuilder; import org.opendaylight.yang.gen.v1.http.org.openroadm.common.state.types.rev191129.State; +import org.opendaylight.yang.gen.v1.http.org.openroadm.operational.mode.catalog.rev211210.operational.mode.catalog.OpenroadmOperationalModes; +import org.opendaylight.yang.gen.v1.http.org.openroadm.operational.mode.catalog.rev211210.operational.mode.catalog.SpecificOperationalModes; import org.opendaylight.yang.gen.v1.http.org.openroadm.routing.constraints.rev211210.routing.constraints.HardConstraints; import org.opendaylight.yang.gen.v1.http.org.openroadm.routing.constraints.rev211210.routing.constraints.SoftConstraints; import org.opendaylight.yang.gen.v1.http.org.openroadm.service.rev211210.AddOpenroadmOperationalModesToCatalogInput; @@ -138,6 +144,8 @@ public class ServicehandlerImpl implements OrgOpenroadmServiceService { private static final String SERVICE_FEASIBILITY_CHECK_MSG = "serviceFeasibilityCheck: {}"; private static final String SERVICE_DELETE_MSG = "serviceDelete: {}"; private static final String SERVICE_CREATE_MSG = "serviceCreate: {}"; + private static final String ADD_OR_TO_CATALOG_MSG = "addORToCatalog: {}"; + private static final String ADD_SPECIFIC_TO_CATALOG_MSG = "addSpecificToCatalog: {}"; private ServiceDataStoreOperations serviceDataStoreOperations; private PCEServiceWrapper pceServiceWrapper; @@ -146,6 +154,7 @@ public class ServicehandlerImpl implements OrgOpenroadmServiceService { private RendererListener rendererListenerImpl; private NetworkListener networkModelListenerImpl; private NotificationPublishService notificationPublishService; + private CatalogDataStoreOperations catalogDataStoreOperations; @Activate public ServicehandlerImpl(@Reference PathComputationService pathComputationService, @@ -154,7 +163,9 @@ public class ServicehandlerImpl implements OrgOpenroadmServiceService { @Reference PceListener pceListenerImpl, @Reference RendererListener rendererListenerImpl, @Reference NetworkListener networkModelListenerImpl, - @Reference ServiceDataStoreOperations serviceDataStoreOperations) { + @Reference ServiceDataStoreOperations serviceDataStoreOperations, + @Reference CatalogDataStoreOperations catalogDataStoreOperations) { + this.catalogDataStoreOperations = catalogDataStoreOperations; this.serviceDataStoreOperations = serviceDataStoreOperations; this.notificationPublishService = notificationPublishService; this.pceServiceWrapper = new PCEServiceWrapper(pathComputationService, notificationPublishService); @@ -176,6 +187,8 @@ public class ServicehandlerImpl implements OrgOpenroadmServiceService { public static final String SERVICE_NON_COMPLIANT; public static final String RENDERER_DELETE_FAILED; public static final String ABORT_VALID_FAILED; + public static final String ABORT_OR_TO_CATALOG_FAILED; + public static final String ABORT_SPECIFIC_TO_CATALOG_FAILED; // Static blocks are generated once and spare memory. static { @@ -186,6 +199,8 @@ public class ServicehandlerImpl implements OrgOpenroadmServiceService { SERVICE_NON_COMPLIANT = "non-compliant service"; RENDERER_DELETE_FAILED = "Renderer service delete failed"; ABORT_VALID_FAILED = "Aborting: validation of service create request failed"; + ABORT_OR_TO_CATALOG_FAILED = "Aborting: validation of add OR to catalog request failed"; + ABORT_SPECIFIC_TO_CATALOG_FAILED = "Aborting: validation of add Specific to catalog request failed"; } public static String serviceInDS(String serviceName) { @@ -791,17 +806,71 @@ public class ServicehandlerImpl implements OrgOpenroadmServiceService { } @Override + /** + * Implementation of the RPC to set OR operational modes in the catalog of the controller. + * Semantics of the RPC is such that the information in the input replaces the full content + * of the OR operational modes catalog in the config data store. Incremental changes to the + * catalog, if required, must be done via individual PUT/POST/DELETE RESTconf APIs. + * + * @param input AddOpenroadmOperationalModesToCatalogInput to be added to Catalog + * @return Result of the request + */ public ListenableFuture> - addOpenroadmOperationalModesToCatalog(AddOpenroadmOperationalModesToCatalogInput input) { - // TODO Auto-generated method stub - return null; + addOpenroadmOperationalModesToCatalog(AddOpenroadmOperationalModesToCatalogInput input) { + + LOG.info("RPC addOpenroadmOperationalModesToCatalog in progress"); + LOG.debug(" Input openRoadm {}", input); + // Validation + OperationResult validationResult = CatalogValidation.validateORCatalogRequest( + new CatalogInput(input), RpcActions.FillCatalogWithOrOperationalModes); + if (! validationResult.isSuccess()) { + LOG.warn(ADD_OR_TO_CATALOG_MSG, LogMessages.ABORT_OR_TO_CATALOG_FAILED); + return ModelMappingUtils.addOpenroadmServiceReply( + input, ResponseCodes.FINAL_ACK_YES, + validationResult.getResultMessage(), ResponseCodes.RESPONSE_FAILED); + } + LOG.info(" Request System Id {} " ,input.getSdncRequestHeader().getRequestSystemId()); + LOG.info(" Rpc Action {} " ,input.getSdncRequestHeader().getRpcAction()); + + OpenroadmOperationalModes objToSave = CatalogMapper.createORModesToSave(input); + catalogDataStoreOperations.addOpenroadmOperationalModesToCatalog(objToSave); + LOG.info("RPC addOpenroadmOperationalModesToCatalog Completed"); + return ModelMappingUtils.addOpenroadmServiceReply(input, ResponseCodes.FINAL_ACK_YES, + validationResult.getResultMessage(), ResponseCodes.RESPONSE_OK); } @Override + /** + * Implementation of the RPC to set specific operational modes in the catalog of the controller. + * Semantics of the RPC is such that the information in the input replaces the full content + * of the specific operational modes catalog in the config data store. Incremental changes to the + * catalog, if required, must be done via individual PUT/POST/DELETE RESTconf APIs. + * + * @param input AddSpecificOperationalModesToCatalogInput to be added to Catalog + * @return Result of the request + */ public ListenableFuture> addSpecificOperationalModesToCatalog( AddSpecificOperationalModesToCatalogInput input) { - // TODO Auto-generated method stub - return null; + + LOG.info("RPC addSpecificOperationalModesToCatalog in progress"); + LOG.debug(" Input openSpecificRoadm {}", input); + // Validation + OperationResult validationResult = CatalogValidation.validateSpecificCatalogRequest( + new CatalogInput(input), RpcActions.FillCatalogWithSpecificOperationalModes); + if (! validationResult.isSuccess()) { + LOG.warn(ADD_SPECIFIC_TO_CATALOG_MSG, LogMessages.ABORT_SPECIFIC_TO_CATALOG_FAILED); + return ModelMappingUtils.addSpecificOpenroadmServiceReply( + input, ResponseCodes.FINAL_ACK_YES, + validationResult.getResultMessage(), ResponseCodes.RESPONSE_FAILED); + } + LOG.info(" Request System Id {} " ,input.getSdncRequestHeader().getRequestSystemId()); + LOG.info(" Rpc Action {} " ,input.getSdncRequestHeader().getRpcAction()); + + SpecificOperationalModes objToSave = CatalogMapper.createSpecificModesToSave(input); + catalogDataStoreOperations.addSpecificOperationalModesToCatalog(objToSave); + LOG.info("RPC addSpecificOperationalModesToCatalog Completed"); + return ModelMappingUtils.addSpecificOpenroadmServiceReply(input, ResponseCodes.FINAL_ACK_YES, + validationResult.getResultMessage(), ResponseCodes.RESPONSE_OK); } @Override @@ -810,3 +879,4 @@ public class ServicehandlerImpl implements OrgOpenroadmServiceService { return null; } } + diff --git a/servicehandler/src/main/java/org/opendaylight/transportpce/servicehandler/utils/CatalogDataUtils.java b/servicehandler/src/main/java/org/opendaylight/transportpce/servicehandler/utils/CatalogDataUtils.java new file mode 100644 index 000000000..127b04e35 --- /dev/null +++ b/servicehandler/src/main/java/org/opendaylight/transportpce/servicehandler/utils/CatalogDataUtils.java @@ -0,0 +1,84 @@ +/* + * Copyright © 2023 Fujitsu Network Communications, 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.transportpce.servicehandler.utils; + +import java.util.HashMap; +import java.util.Map; +import org.opendaylight.yang.gen.v1.http.org.openroadm.common.service.types.rev211210.RpcActions; +import org.opendaylight.yang.gen.v1.http.org.openroadm.common.service.types.rev211210.sdnc.request.header.SdncRequestHeaderBuilder; +import org.opendaylight.yang.gen.v1.http.org.openroadm.service.rev211210.AddOpenroadmOperationalModesToCatalogInput; +import org.opendaylight.yang.gen.v1.http.org.openroadm.service.rev211210.AddOpenroadmOperationalModesToCatalogInputBuilder; +import org.opendaylight.yang.gen.v1.http.org.openroadm.service.rev211210.AddSpecificOperationalModesToCatalogInput; +import org.opendaylight.yang.gen.v1.http.org.openroadm.service.rev211210.AddSpecificOperationalModesToCatalogInputBuilder; +import org.opendaylight.yang.gen.v1.http.org.openroadm.service.rev211210.add.openroadm.operational.modes.to.catalog.input.OperationalModeInfoBuilder; +import org.opendaylight.yang.gen.v1.http.org.openroadm.service.rev211210.add.openroadm.operational.modes.to.catalog.input.operational.mode.info.AmplifiersBuilder; +import org.opendaylight.yang.gen.v1.http.org.openroadm.service.rev211210.add.openroadm.operational.modes.to.catalog.input.operational.mode.info.GridParametersBuilder; +import org.opendaylight.yang.gen.v1.http.org.openroadm.service.rev211210.add.openroadm.operational.modes.to.catalog.input.operational.mode.info.RoadmsBuilder; +import org.opendaylight.yang.gen.v1.http.org.openroadm.service.rev211210.add.openroadm.operational.modes.to.catalog.input.operational.mode.info.XpondersPluggablesBuilder; +import org.opendaylight.yang.gen.v1.http.org.openroadm.service.rev211210.add.openroadm.operational.modes.to.catalog.input.operational.mode.info.xponders.pluggables.XponderPluggableOpenroadmOperationalMode; +import org.opendaylight.yang.gen.v1.http.org.openroadm.service.rev211210.add.openroadm.operational.modes.to.catalog.input.operational.mode.info.xponders.pluggables.XponderPluggableOpenroadmOperationalModeBuilder; +import org.opendaylight.yang.gen.v1.http.org.openroadm.service.rev211210.add.openroadm.operational.modes.to.catalog.input.operational.mode.info.xponders.pluggables.XponderPluggableOpenroadmOperationalModeKey; +import org.opendaylight.yang.gen.v1.http.org.openroadm.service.rev211210.add.specific.operational.modes.to.catalog.input.operational.mode.info.SpecificOperationalModesBuilder; +import org.opendaylight.yang.gen.v1.http.org.openroadm.service.rev211210.add.specific.operational.modes.to.catalog.input.operational.mode.info.specific.operational.modes.SpecificOperationalMode; +import org.opendaylight.yang.gen.v1.http.org.openroadm.service.rev211210.add.specific.operational.modes.to.catalog.input.operational.mode.info.specific.operational.modes.SpecificOperationalModeBuilder; +import org.opendaylight.yang.gen.v1.http.org.openroadm.service.rev211210.add.specific.operational.modes.to.catalog.input.operational.mode.info.specific.operational.modes.SpecificOperationalModeKey; + +public final class CatalogDataUtils { + + private CatalogDataUtils() { + + } + + public static AddOpenroadmOperationalModesToCatalogInput buildAddORToCatalogInput() { + Map map = + new HashMap<>(); + XponderPluggableOpenroadmOperationalModeBuilder modeBuilder = + new XponderPluggableOpenroadmOperationalModeBuilder(); + XponderPluggableOpenroadmOperationalModeKey key = + new XponderPluggableOpenroadmOperationalModeKey("testOROperationalMode"); + modeBuilder.setOpenroadmOperationalModeId(key.toString()); + map.put(key, modeBuilder.build()); + XpondersPluggablesBuilder xpondersPluggablesBuilder = + new XpondersPluggablesBuilder().setXponderPluggableOpenroadmOperationalMode(map); + return new AddOpenroadmOperationalModesToCatalogInputBuilder() + .setSdncRequestHeader(new SdncRequestHeaderBuilder() + .setRequestId("load-OM-Catalog") + .setRequestSystemId("appname") + .setRpcAction(RpcActions.FillCatalogWithOrOperationalModes) + .build()) + .setOperationalModeInfo(new OperationalModeInfoBuilder() + .setGridParameters(new GridParametersBuilder().build()) + .setXpondersPluggables(xpondersPluggablesBuilder.build()) + .setRoadms(new RoadmsBuilder().build()) + .setAmplifiers(new AmplifiersBuilder().build()) + .build()) + .build(); + } + + public static AddSpecificOperationalModesToCatalogInput buildAddSpecificToCatalogInput() { + Map map = new HashMap<>(); + SpecificOperationalModeKey key = new SpecificOperationalModeKey("testSpecificOperationalMode"); + SpecificOperationalModeBuilder modeBuilder = new SpecificOperationalModeBuilder(); + modeBuilder.setOperationalModeId(key.toString()); + map.put(key, modeBuilder.build()); + SpecificOperationalModesBuilder specificOperationalModesBuilder = + new SpecificOperationalModesBuilder().setSpecificOperationalMode(map); + return new AddSpecificOperationalModesToCatalogInputBuilder() + .setSdncRequestHeader(new SdncRequestHeaderBuilder() + .setRequestId("load-specific-OM-Catalog") + .setRequestSystemId("test") + .setRpcAction(RpcActions.FillCatalogWithSpecificOperationalModes) + .build()) + .setOperationalModeInfo(new org.opendaylight.yang.gen.v1.http.org.openroadm.service.rev211210 + .add.specific.operational.modes.to.catalog.input.OperationalModeInfoBuilder() + .setSpecificOperationalModes(specificOperationalModesBuilder.build()) + .build()) + .build(); + } +} diff --git a/servicehandler/src/main/java/org/opendaylight/transportpce/servicehandler/validation/CatalogValidation.java b/servicehandler/src/main/java/org/opendaylight/transportpce/servicehandler/validation/CatalogValidation.java new file mode 100644 index 000000000..96577ffed --- /dev/null +++ b/servicehandler/src/main/java/org/opendaylight/transportpce/servicehandler/validation/CatalogValidation.java @@ -0,0 +1,61 @@ +/* + * Copyright © 2023 Fujitsu Network Communications, 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.transportpce.servicehandler.validation; + +import org.opendaylight.transportpce.common.OperationResult; +import org.opendaylight.transportpce.servicehandler.CatalogInput; +import org.opendaylight.transportpce.servicehandler.validation.checks.ComplianceCheckResult; +import org.opendaylight.transportpce.servicehandler.validation.checks.ServicehandlerComplianceCheck; +import org.opendaylight.yang.gen.v1.http.org.openroadm.common.service.types.rev211210.RpcActions; +import org.opendaylight.yang.gen.v1.http.org.openroadm.common.service.types.rev211210.sdnc.request.header.SdncRequestHeader; +import org.opendaylight.yang.gen.v1.http.org.openroadm.service.rev211210.add.openroadm.operational.modes.to.catalog.input.OperationalModeInfo; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +public final class CatalogValidation { + + private CatalogValidation() { + } + + private static final Logger LOG = LoggerFactory.getLogger(CatalogValidation.class); + + public static OperationResult validateORCatalogRequest(CatalogInput input, RpcActions rpcActions) { + /* + * -OR request header and operational mode info compliance are verified. + */ + LOG.debug("checking OR Catalog Compliance ..."); + SdncRequestHeader sdncRequestHeader = input.getSdncRequestHeader(); + OperationalModeInfo operationalModeInfo = input.getOperationalModeInfo(); + ComplianceCheckResult serviceHandlerCheckResult = ServicehandlerComplianceCheck.checkORCatalog( + sdncRequestHeader, operationalModeInfo, rpcActions, true); + if (!serviceHandlerCheckResult.hasPassed()) { + return OperationResult.failed(serviceHandlerCheckResult.getMessage()); + } + LOG.debug("Catalog OR request compliant !"); + return OperationResult.ok("Validation successful."); + } + + public static OperationResult validateSpecificCatalogRequest(CatalogInput input, RpcActions rpcActions) { + /* + * -Specific request header and operational mode info compliance are verified. + */ + LOG.debug("checking specific Catalog Compliance ..."); + SdncRequestHeader sdncRequestHeader = input.getSdncRequestHeader(); + org.opendaylight.yang.gen.v1.http.org.openroadm.service.rev211210 + .add.specific.operational.modes.to.catalog.input.OperationalModeInfo operationalModeInfoSpecific + = input.getOperationalModeInfoSpecific(); + ComplianceCheckResult serviceHandlerCheckResult = ServicehandlerComplianceCheck.checkSpecificCatalog( + sdncRequestHeader, operationalModeInfoSpecific, rpcActions, true); + if (!serviceHandlerCheckResult.hasPassed()) { + return OperationResult.failed(serviceHandlerCheckResult.getMessage()); + } + LOG.debug("Catalog specific request compliant !"); + return OperationResult.ok("Validation successful."); + } +} diff --git a/servicehandler/src/main/java/org/opendaylight/transportpce/servicehandler/validation/checks/ServicehandlerComplianceCheck.java b/servicehandler/src/main/java/org/opendaylight/transportpce/servicehandler/validation/checks/ServicehandlerComplianceCheck.java index 85b8a1d08..f59a3e7d6 100644 --- a/servicehandler/src/main/java/org/opendaylight/transportpce/servicehandler/validation/checks/ServicehandlerComplianceCheck.java +++ b/servicehandler/src/main/java/org/opendaylight/transportpce/servicehandler/validation/checks/ServicehandlerComplianceCheck.java @@ -10,6 +10,9 @@ package org.opendaylight.transportpce.servicehandler.validation.checks; import org.opendaylight.yang.gen.v1.http.org.openroadm.common.service.types.rev211210.ConnectionType; import org.opendaylight.yang.gen.v1.http.org.openroadm.common.service.types.rev211210.RpcActions; import org.opendaylight.yang.gen.v1.http.org.openroadm.common.service.types.rev211210.sdnc.request.header.SdncRequestHeader; +import org.opendaylight.yang.gen.v1.http.org.openroadm.service.rev211210.add.openroadm.operational.modes.to.catalog.input.OperationalModeInfo; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; /** * Class for checking service sdnc-request-header compliance. @@ -17,6 +20,8 @@ import org.opendaylight.yang.gen.v1.http.org.openroadm.common.service.types.rev2 */ public final class ServicehandlerComplianceCheck { + private static final Logger LOG = LoggerFactory.getLogger(ServicehandlerComplianceCheck.class); + // This is class is public so that these messages can be accessed from Junit (avoid duplications). public static final class LogMessages { @@ -26,6 +31,12 @@ public final class ServicehandlerComplianceCheck { public static final String RPCACTION_NOT_SET; public static final String HEADER_NOT_SET; + public static final String CATALOG_REQUESTID_NOT_SET; + public static final String CATALOG_HEADER_NOT_SET; + public static final String CATALOG_REQUESTSYSTEMID_NOT_SET; + public static final String CATALOG_RPCACTION_NOT_SET; + public static final String CATALOG_OPERATIONAL_MODE_INFO_NOT_SET; + // Static blocks are generated once and spare memory. static { SERVICENAME_NOT_SET = "Service Name (common-id for Temp service) is not set"; @@ -33,6 +44,11 @@ public final class ServicehandlerComplianceCheck { REQUESTID_NOT_SET = "Service sdncRequestHeader 'request-id' is not set"; RPCACTION_NOT_SET = "Service sdncRequestHeader 'rpc-action' is not set"; HEADER_NOT_SET = "Service sdncRequestHeader is not set"; + CATALOG_REQUESTID_NOT_SET = "sdnc-request-header 'request-id' is not set"; + CATALOG_REQUESTSYSTEMID_NOT_SET = "sdnc-request-header 'request-system-id' is not set"; + CATALOG_HEADER_NOT_SET = "sdnc-request-header is not set"; + CATALOG_RPCACTION_NOT_SET = "sdnc-request-header 'rpc-action' is not set"; + CATALOG_OPERATIONAL_MODE_INFO_NOT_SET = "operational-mode-info is not set"; } public static String rpcactionsDiffers(RpcActions action1, RpcActions action2) { @@ -40,6 +56,12 @@ public final class ServicehandlerComplianceCheck { "Service sdncRequestHeader rpc-action '" + action1.name() + "' not equal to '" + action2.name() + "'"; } + public static String catalogRpcactionsDiffers(RpcActions action1, RpcActions action2) { + return + "Catalog sdnc-request-header rpc-action '" + action1.name() + "' not equal to '" + action2.name() + + "'"; + } + private LogMessages() { } } @@ -101,6 +123,61 @@ public final class ServicehandlerComplianceCheck { return new ComplianceCheckResult(true, ""); } + public static ComplianceCheckResult checkORCatalog(SdncRequestHeader sdncRequestHeader, + OperationalModeInfo operationalModeInfo, RpcActions action, + Boolean sdncRequest) { + + ComplianceCheckResult result = sdncRequestHeaderValidate(sdncRequest, sdncRequestHeader, action); + if (result.getMessage().contains("sdnc-request-header")) { + return new ComplianceCheckResult(false,result.getMessage()); + } + if (operationalModeInfo == null) { + return new ComplianceCheckResult(false, LogMessages.CATALOG_OPERATIONAL_MODE_INFO_NOT_SET); + } + + return new ComplianceCheckResult(true, ""); + } + + public static ComplianceCheckResult checkSpecificCatalog(SdncRequestHeader sdncRequestHeader, org.opendaylight.yang + .gen.v1.http.org.openroadm.service.rev211210.add.specific.operational.modes.to.catalog.input + .OperationalModeInfo operationalModeInfoSpecific, RpcActions action, Boolean sdncRequest) { + + ComplianceCheckResult result = sdncRequestHeaderValidate(sdncRequest, sdncRequestHeader, action); + if (result.getMessage().contains("sdnc-request-header")) { + return new ComplianceCheckResult(false,result.getMessage()); + } + if (operationalModeInfoSpecific == null) { + return new ComplianceCheckResult(false, LogMessages.CATALOG_OPERATIONAL_MODE_INFO_NOT_SET); + } + return new ComplianceCheckResult(true, ""); + } + + public static ComplianceCheckResult sdncRequestHeaderValidate(Boolean sdncRequest, SdncRequestHeader + sdncRequestHeader, RpcActions action) { + if (sdncRequest) { + if (sdncRequestHeader == null) { + return new ComplianceCheckResult(false, LogMessages.CATALOG_HEADER_NOT_SET); + } + RpcActions serviceAction = sdncRequestHeader.getRpcAction(); + String requestId = sdncRequestHeader.getRequestId(); + String requestSystemId = sdncRequestHeader.getRequestSystemId(); + if (!checkString(requestId)) { + return new ComplianceCheckResult(false, LogMessages.CATALOG_REQUESTID_NOT_SET); + } + if (!checkString(requestSystemId)) { + return new ComplianceCheckResult(false, LogMessages.CATALOG_REQUESTSYSTEMID_NOT_SET); + } + if (serviceAction == null) { + return new ComplianceCheckResult(false, LogMessages.CATALOG_RPCACTION_NOT_SET); + } + if (serviceAction.compareTo(action) != 0) { + return new ComplianceCheckResult(false, LogMessages.catalogRpcactionsDiffers(serviceAction, action)); + } + } + return new ComplianceCheckResult(true, ""); + } + + private ServicehandlerComplianceCheck() { } diff --git a/servicehandler/src/test/java/org/opendaylight/transportpce/servicehandler/impl/ServicehandlerImplTest.java b/servicehandler/src/test/java/org/opendaylight/transportpce/servicehandler/impl/ServicehandlerImplTest.java index 1476041af..ffa83e81d 100644 --- a/servicehandler/src/test/java/org/opendaylight/transportpce/servicehandler/impl/ServicehandlerImplTest.java +++ b/servicehandler/src/test/java/org/opendaylight/transportpce/servicehandler/impl/ServicehandlerImplTest.java @@ -22,6 +22,7 @@ import java.util.Optional; import java.util.concurrent.CountDownLatch; import java.util.concurrent.ExecutionException; import java.util.concurrent.Executors; +import org.junit.Assert; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; import org.junit.jupiter.api.extension.ExtendWith; @@ -29,20 +30,30 @@ import org.mockito.Mock; import org.mockito.junit.jupiter.MockitoExtension; import org.opendaylight.mdsal.binding.api.NotificationPublishService; import org.opendaylight.transportpce.common.ResponseCodes; +import org.opendaylight.transportpce.common.network.NetworkTransactionImpl; import org.opendaylight.transportpce.pce.service.PathComputationService; import org.opendaylight.transportpce.renderer.provisiondevice.RendererServiceOperations; import org.opendaylight.transportpce.servicehandler.ServiceInput; +import org.opendaylight.transportpce.servicehandler.catalog.CatalogDataStoreOperations; +import org.opendaylight.transportpce.servicehandler.catalog.CatalogDataStoreOperationsImpl; import org.opendaylight.transportpce.servicehandler.listeners.NetworkListener; import org.opendaylight.transportpce.servicehandler.listeners.PceListener; import org.opendaylight.transportpce.servicehandler.listeners.RendererListener; import org.opendaylight.transportpce.servicehandler.service.ServiceDataStoreOperations; import org.opendaylight.transportpce.servicehandler.service.ServiceDataStoreOperationsImpl; +import org.opendaylight.transportpce.servicehandler.utils.CatalogDataUtils; import org.opendaylight.transportpce.servicehandler.utils.ServiceDataUtils; import org.opendaylight.transportpce.test.AbstractTest; import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.pce.rev220808.PathComputationRequestOutputBuilder; import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.pce.rev220808.PathComputationRerouteRequestOutputBuilder; import org.opendaylight.yang.gen.v1.http.org.openroadm.common.service.types.rev211210.configuration.response.common.ConfigurationResponseCommonBuilder; import org.opendaylight.yang.gen.v1.http.org.openroadm.common.state.types.rev191129.State; +import org.opendaylight.yang.gen.v1.http.org.openroadm.service.rev211210.AddOpenroadmOperationalModesToCatalogInput; +import org.opendaylight.yang.gen.v1.http.org.openroadm.service.rev211210.AddOpenroadmOperationalModesToCatalogInputBuilder; +import org.opendaylight.yang.gen.v1.http.org.openroadm.service.rev211210.AddOpenroadmOperationalModesToCatalogOutput; +import org.opendaylight.yang.gen.v1.http.org.openroadm.service.rev211210.AddSpecificOperationalModesToCatalogInput; +import org.opendaylight.yang.gen.v1.http.org.openroadm.service.rev211210.AddSpecificOperationalModesToCatalogInputBuilder; +import org.opendaylight.yang.gen.v1.http.org.openroadm.service.rev211210.AddSpecificOperationalModesToCatalogOutput; import org.opendaylight.yang.gen.v1.http.org.openroadm.service.rev211210.ServiceCreateInput; import org.opendaylight.yang.gen.v1.http.org.openroadm.service.rev211210.ServiceCreateInputBuilder; import org.opendaylight.yang.gen.v1.http.org.openroadm.service.rev211210.ServiceCreateOutput; @@ -97,6 +108,7 @@ public class ServicehandlerImplTest extends AbstractTest { private NetworkListener networkModelListenerImpl; private ServiceDataStoreOperations serviceDataStoreOperations; + private CatalogDataStoreOperations catalogDataStoreOperations; private ServiceCreateInput serviceCreateInput; private ServiceDeleteInput serviceDeleteInput; private ServiceReconfigureInput serviceReconfigureInput; @@ -111,6 +123,8 @@ public class ServicehandlerImplTest extends AbstractTest { executorService = MoreExecutors.listeningDecorator(Executors.newFixedThreadPool(NUM_THREADS)); endSignal = new CountDownLatch(1); this.serviceDataStoreOperations = new ServiceDataStoreOperationsImpl(getNewDataBroker()); + this.catalogDataStoreOperations = new CatalogDataStoreOperationsImpl( + new NetworkTransactionImpl(getDataBroker())); serviceCreateInput = ServiceDataUtils.buildServiceCreateInput(); serviceDeleteInput = ServiceDataUtils.buildServiceDeleteInput(); serviceReconfigureInput = ServiceDataUtils.buildServiceReconfigureInput(); @@ -122,7 +136,7 @@ public class ServicehandlerImplTest extends AbstractTest { void createServiceShouldBeFailedWithEmptyInput() throws ExecutionException, InterruptedException { ServicehandlerImpl servicehandlerImpl = new ServicehandlerImpl(pathComputationService, rendererServiceOperations, notificationPublishService, pceListenerImpl, rendererListenerImpl, - networkModelListenerImpl, serviceDataStoreOperations); + networkModelListenerImpl, serviceDataStoreOperations, catalogDataStoreOperations); ListenableFuture> result = servicehandlerImpl .serviceCreate(new ServiceCreateInputBuilder().build()); result.addListener(() -> endSignal.countDown(), executorService); @@ -143,7 +157,7 @@ public class ServicehandlerImplTest extends AbstractTest { .build())); ServicehandlerImpl servicehandlerImpl = new ServicehandlerImpl(pathComputationService, rendererServiceOperations, notificationPublishService, pceListenerImpl, rendererListenerImpl, - networkModelListenerImpl, serviceDSOperations); + networkModelListenerImpl, serviceDSOperations, catalogDataStoreOperations); ListenableFuture> result = servicehandlerImpl.serviceCreate(serviceCreateInput); result.addListener(() -> endSignal.countDown(), executorService); @@ -159,7 +173,7 @@ public class ServicehandlerImplTest extends AbstractTest { when(pathComputationService.pathComputationRequest(any())).thenReturn(Futures.immediateFuture(any())); ServicehandlerImpl servicehandlerImpl = new ServicehandlerImpl(pathComputationService, rendererServiceOperations, notificationPublishService, pceListenerImpl, rendererListenerImpl, - networkModelListenerImpl, serviceDataStoreOperations); + networkModelListenerImpl, serviceDataStoreOperations, catalogDataStoreOperations); ListenableFuture> result = servicehandlerImpl.serviceCreate(serviceCreateInput); result.addListener(() -> endSignal.countDown(), executorService); @@ -173,7 +187,7 @@ public class ServicehandlerImplTest extends AbstractTest { void deleteServiceShouldBeFailedWithEmptyInput() throws ExecutionException, InterruptedException { ServicehandlerImpl servicehandlerImpl = new ServicehandlerImpl(pathComputationService, rendererServiceOperations, notificationPublishService, pceListenerImpl, rendererListenerImpl, - networkModelListenerImpl, serviceDataStoreOperations); + networkModelListenerImpl, serviceDataStoreOperations, catalogDataStoreOperations); ListenableFuture> result = servicehandlerImpl.serviceDelete( new ServiceDeleteInputBuilder() .setServiceDeleteReqInfo(new ServiceDeleteReqInfoBuilder() @@ -193,7 +207,7 @@ public class ServicehandlerImplTest extends AbstractTest { ServicehandlerImpl servicehandlerImpl = new ServicehandlerImpl(pathComputationService, rendererServiceOperations, notificationPublishService, pceListenerImpl, rendererListenerImpl, networkModelListenerImpl, - serviceDataStoreOperations); + serviceDataStoreOperations, catalogDataStoreOperations); ListenableFuture> result = servicehandlerImpl.serviceDelete(serviceDeleteInput); result.addListener(() -> endSignal.countDown(), executorService); @@ -208,7 +222,7 @@ public class ServicehandlerImplTest extends AbstractTest { when(rendererServiceOperations.serviceDelete(any(), any())).thenReturn(Futures.immediateFuture(any())); ServicehandlerImpl servicehandlerImpl = new ServicehandlerImpl(pathComputationService, rendererServiceOperations, notificationPublishService, pceListenerImpl, rendererListenerImpl, - networkModelListenerImpl, serviceDataStoreOperations); + networkModelListenerImpl, serviceDataStoreOperations, catalogDataStoreOperations); serviceDataStoreOperations.createService(serviceCreateInput); ListenableFuture> result = servicehandlerImpl.serviceDelete(serviceDeleteInput); result.addListener(() -> endSignal.countDown(), executorService); @@ -224,7 +238,7 @@ public class ServicehandlerImplTest extends AbstractTest { void serviceFeasibilityCheckShouldBeFailedWithEmptyInput() throws ExecutionException, InterruptedException { ServicehandlerImpl servicehandlerImpl = new ServicehandlerImpl(pathComputationService, rendererServiceOperations, notificationPublishService, pceListenerImpl, rendererListenerImpl, - networkModelListenerImpl, serviceDataStoreOperations); + networkModelListenerImpl, serviceDataStoreOperations, catalogDataStoreOperations); ListenableFuture> result = servicehandlerImpl.serviceFeasibilityCheck(new ServiceFeasibilityCheckInputBuilder().build()); result.addListener(() -> endSignal.countDown(), executorService); @@ -241,7 +255,7 @@ public class ServicehandlerImplTest extends AbstractTest { when(pathComputationService.pathComputationRequest(any())).thenReturn(Futures.immediateFuture(any())); ServicehandlerImpl servicehandlerImpl = new ServicehandlerImpl(pathComputationService, rendererServiceOperations, notificationPublishService, pceListenerImpl, rendererListenerImpl, - networkModelListenerImpl, serviceDataStoreOperations); + networkModelListenerImpl, serviceDataStoreOperations, catalogDataStoreOperations); ListenableFuture> result = servicehandlerImpl.serviceFeasibilityCheck(ServiceDataUtils.buildServiceFeasibilityCheckInput()); result.addListener(() -> endSignal.countDown(), executorService); @@ -256,7 +270,7 @@ public class ServicehandlerImplTest extends AbstractTest { void serviceReconfigureShouldBeFailedWithEmptyInput() throws ExecutionException, InterruptedException { ServicehandlerImpl servicehandlerImpl = new ServicehandlerImpl(pathComputationService, rendererServiceOperations, notificationPublishService, pceListenerImpl, rendererListenerImpl, - networkModelListenerImpl, serviceDataStoreOperations); + networkModelListenerImpl, serviceDataStoreOperations, catalogDataStoreOperations); ListenableFuture> result = servicehandlerImpl.serviceReconfigure(new ServiceReconfigureInputBuilder().setServiceName("").build()); result.addListener(() -> endSignal.countDown(), executorService); @@ -270,7 +284,7 @@ public class ServicehandlerImplTest extends AbstractTest { //action -> service reconfigure ServicehandlerImpl servicehandlerImpl = new ServicehandlerImpl(pathComputationService, rendererServiceOperations, notificationPublishService, pceListenerImpl, rendererListenerImpl, - networkModelListenerImpl, serviceDataStoreOperations); + networkModelListenerImpl, serviceDataStoreOperations, catalogDataStoreOperations); ListenableFuture> result = servicehandlerImpl.serviceReconfigure( serviceReconfigureInput); @@ -286,7 +300,7 @@ public class ServicehandlerImplTest extends AbstractTest { //create service to reconfigure ServicehandlerImpl servicehandlerImpl = new ServicehandlerImpl(pathComputationService, rendererServiceOperations, notificationPublishService, pceListenerImpl, rendererListenerImpl, - networkModelListenerImpl, serviceDataStoreOperations); + networkModelListenerImpl, serviceDataStoreOperations, catalogDataStoreOperations); serviceDataStoreOperations.createService(serviceCreateInput); //service reconfigure test action @@ -302,7 +316,7 @@ public class ServicehandlerImplTest extends AbstractTest { void serviceReRestorationShouldBeFailedWithEmptyInput() throws ExecutionException, InterruptedException { ServicehandlerImpl servicehandlerImpl = new ServicehandlerImpl(pathComputationService, rendererServiceOperations, notificationPublishService, pceListenerImpl, rendererListenerImpl, - networkModelListenerImpl, serviceDataStoreOperations); + networkModelListenerImpl, serviceDataStoreOperations, catalogDataStoreOperations); ListenableFuture> result = servicehandlerImpl .serviceRestoration(new ServiceRestorationInputBuilder().setServiceName("").build()); result.addListener(() -> endSignal.countDown(), executorService); @@ -316,7 +330,7 @@ public class ServicehandlerImplTest extends AbstractTest { //action -> service restore ServicehandlerImpl servicehandlerImpl = new ServicehandlerImpl(pathComputationService, rendererServiceOperations, notificationPublishService, pceListenerImpl, rendererListenerImpl, - networkModelListenerImpl, serviceDataStoreOperations); + networkModelListenerImpl, serviceDataStoreOperations, catalogDataStoreOperations); ListenableFuture> result = servicehandlerImpl.serviceRestoration( serviceRestorationInput); @@ -332,7 +346,7 @@ public class ServicehandlerImplTest extends AbstractTest { //create service to restore ServicehandlerImpl servicehandlerImpl = new ServicehandlerImpl(pathComputationService, rendererServiceOperations, notificationPublishService, pceListenerImpl, rendererListenerImpl, - networkModelListenerImpl, serviceDataStoreOperations); + networkModelListenerImpl, serviceDataStoreOperations, catalogDataStoreOperations); serviceDataStoreOperations.createService(serviceCreateInput); //service Restoration test action @@ -348,7 +362,7 @@ public class ServicehandlerImplTest extends AbstractTest { void serviceRerouteShouldBeFailedWithEmptyInput() throws ExecutionException, InterruptedException { ServicehandlerImpl servicehandlerImpl = new ServicehandlerImpl(pathComputationService, rendererServiceOperations, notificationPublishService, pceListenerImpl, rendererListenerImpl, - networkModelListenerImpl, serviceDataStoreOperations); + networkModelListenerImpl, serviceDataStoreOperations, catalogDataStoreOperations); ListenableFuture> result = servicehandlerImpl.serviceReroute(new ServiceRerouteInputBuilder().setServiceName("").build()); result.addListener(() -> endSignal.countDown(), executorService); @@ -365,7 +379,7 @@ public class ServicehandlerImplTest extends AbstractTest { //action -> service reconfigure ServicehandlerImpl servicehandlerImpl = new ServicehandlerImpl(pathComputationService, rendererServiceOperations, notificationPublishService, pceListenerImpl, rendererListenerImpl, - networkModelListenerImpl, serviceDataStoreOperations); + networkModelListenerImpl, serviceDataStoreOperations, catalogDataStoreOperations); ListenableFuture> result = servicehandlerImpl .serviceReroute(serviceRerouteInput); @@ -439,7 +453,7 @@ public class ServicehandlerImplTest extends AbstractTest { serviceDataStoreOperations.createService(serviceCreateInput); ListenableFuture> result = new ServicehandlerImpl(pathComputationService, rendererServiceOperations, notificationPublishService, pceListenerImpl, - rendererListenerImpl, networkModelListenerImpl, serviceDataStoreOperations) + rendererListenerImpl, networkModelListenerImpl, serviceDataStoreOperations, catalogDataStoreOperations) .serviceReroute(serviceRerouteInput); result.addListener(() -> endSignal.countDown(), executorService); @@ -454,7 +468,7 @@ public class ServicehandlerImplTest extends AbstractTest { void tempServiceDeleteShouldBeFailedWithEmptyInput() throws ExecutionException, InterruptedException { ServicehandlerImpl servicehandlerImpl = new ServicehandlerImpl(pathComputationService, rendererServiceOperations, notificationPublishService, pceListenerImpl, rendererListenerImpl, - networkModelListenerImpl, serviceDataStoreOperations); + networkModelListenerImpl, serviceDataStoreOperations, catalogDataStoreOperations); ListenableFuture> result = servicehandlerImpl.tempServiceDelete(new TempServiceDeleteInputBuilder().setCommonId("").build()); result.addListener(() -> endSignal.countDown(), executorService); @@ -474,7 +488,7 @@ public class ServicehandlerImplTest extends AbstractTest { void tempServiceDeleteShouldBeFailedWithNonExistService() throws ExecutionException, InterruptedException { ServicehandlerImpl servicehandlerImpl = new ServicehandlerImpl(pathComputationService, rendererServiceOperations, notificationPublishService, pceListenerImpl, rendererListenerImpl, - networkModelListenerImpl, serviceDataStoreOperations); + networkModelListenerImpl, serviceDataStoreOperations, catalogDataStoreOperations); ListenableFuture> result = servicehandlerImpl.tempServiceDelete( ServiceDataUtils.buildTempServiceDeleteInput()); result.addListener(() -> endSignal.countDown(), executorService); @@ -492,7 +506,7 @@ public class ServicehandlerImplTest extends AbstractTest { //create temp service to delete in the temp delete action ServicehandlerImpl servicehandlerImpl = new ServicehandlerImpl(pathComputationService, rendererServiceOperations, notificationPublishService, pceListenerImpl, rendererListenerImpl, - networkModelListenerImpl, serviceDataStoreOperations); + networkModelListenerImpl, serviceDataStoreOperations, catalogDataStoreOperations); TempServiceCreateInput createInput = ServiceDataUtils.buildTempServiceCreateInput(); serviceDataStoreOperations.createTempService(createInput); @@ -510,7 +524,7 @@ public class ServicehandlerImplTest extends AbstractTest { void tempServiceCreateShouldBeFailedWithEmptyInput() throws ExecutionException, InterruptedException { ServicehandlerImpl servicehandlerImpl = new ServicehandlerImpl(pathComputationService, rendererServiceOperations, notificationPublishService, pceListenerImpl, rendererListenerImpl, - networkModelListenerImpl, serviceDataStoreOperations); + networkModelListenerImpl, serviceDataStoreOperations, catalogDataStoreOperations); ListenableFuture> result = servicehandlerImpl.tempServiceCreate(new TempServiceCreateInputBuilder().build()); result.addListener(() -> endSignal.countDown(), executorService); @@ -528,7 +542,7 @@ public class ServicehandlerImplTest extends AbstractTest { ServicehandlerImpl servicehandlerImpl = new ServicehandlerImpl(pathComputationService, rendererServiceOperations, notificationPublishService, pceListenerImpl, rendererListenerImpl, - networkModelListenerImpl, serviceDataStoreOperations); + networkModelListenerImpl, serviceDataStoreOperations, catalogDataStoreOperations); ListenableFuture> result = servicehandlerImpl.tempServiceCreate( ServiceDataUtils.buildTempServiceCreateInput()); @@ -539,4 +553,62 @@ public class ServicehandlerImplTest extends AbstractTest { ResponseCodes.RESPONSE_OK, result.get().getResult().getConfigurationResponseCommon().getResponseCode()); } + + @Test + public void addOpenroadmOperationalModesToCatalogShouldBeFailedWithEmptyInput() throws ExecutionException, + InterruptedException { + ServicehandlerImpl servicehandlerImpl = new ServicehandlerImpl(pathComputationService, + rendererServiceOperations, notificationPublishService, pceListenerImpl, rendererListenerImpl, + networkModelListenerImpl, serviceDataStoreOperations, catalogDataStoreOperations); + ListenableFuture> result = servicehandlerImpl + .addOpenroadmOperationalModesToCatalog(new AddOpenroadmOperationalModesToCatalogInputBuilder().build()); + RpcResult rpcResult = result.get(); + Assert.assertEquals( + ResponseCodes.RESPONSE_FAILED, rpcResult.getResult().getConfigurationResponseCommon() + .getResponseCode()); + } + + @Test + public void addSpecificOperationalModesToCatalogShouldBeFailedWithEmptyInput() throws ExecutionException, + InterruptedException { + ServicehandlerImpl servicehandlerImpl = new ServicehandlerImpl(pathComputationService, + rendererServiceOperations, notificationPublishService, pceListenerImpl, rendererListenerImpl, + networkModelListenerImpl, serviceDataStoreOperations, catalogDataStoreOperations); + ListenableFuture> result = servicehandlerImpl + .addSpecificOperationalModesToCatalog(new AddSpecificOperationalModesToCatalogInputBuilder().build()); + RpcResult rpcResult = result.get(); + Assert.assertEquals( + ResponseCodes.RESPONSE_FAILED, rpcResult.getResult().getConfigurationResponseCommon() + .getResponseCode()); + } + + @Test + public void addOpenroadmOperationalModesToCatalogShouldBeSuccessfulWhenAddORToCatalog() throws ExecutionException, + InterruptedException { + AddOpenroadmOperationalModesToCatalogInput input = CatalogDataUtils.buildAddORToCatalogInput(); + + ServicehandlerImpl servicehandlerImpl = new ServicehandlerImpl(pathComputationService, + rendererServiceOperations, notificationPublishService, pceListenerImpl, rendererListenerImpl, + networkModelListenerImpl, serviceDataStoreOperations, catalogDataStoreOperations); + ListenableFuture> result = servicehandlerImpl + .addOpenroadmOperationalModesToCatalog(input); + RpcResult rpcResult = result.get(); + Assert.assertEquals( + ResponseCodes.RESPONSE_OK, rpcResult.getResult().getConfigurationResponseCommon().getResponseCode()); + } + + @Test + public void addSpecificOperationalModesToCatalogShouldBeSuccessfulWhenAddSpecificToCatalog() throws + ExecutionException, InterruptedException { + AddSpecificOperationalModesToCatalogInput input = CatalogDataUtils.buildAddSpecificToCatalogInput(); + + ServicehandlerImpl servicehandlerImpl = new ServicehandlerImpl(pathComputationService, + rendererServiceOperations, notificationPublishService, pceListenerImpl, rendererListenerImpl, + networkModelListenerImpl, serviceDataStoreOperations, catalogDataStoreOperations); + ListenableFuture> result = servicehandlerImpl + .addSpecificOperationalModesToCatalog(input); + RpcResult rpcResult = result.get(); + Assert.assertEquals( + ResponseCodes.RESPONSE_OK, rpcResult.getResult().getConfigurationResponseCommon().getResponseCode()); + } } \ No newline at end of file diff --git a/tapi/src/test/java/org/opendaylight/transportpce/tapi/connectivity/TapiConnectivityImplTest.java b/tapi/src/test/java/org/opendaylight/transportpce/tapi/connectivity/TapiConnectivityImplTest.java index deab1ea8b..d65f99d96 100644 --- a/tapi/src/test/java/org/opendaylight/transportpce/tapi/connectivity/TapiConnectivityImplTest.java +++ b/tapi/src/test/java/org/opendaylight/transportpce/tapi/connectivity/TapiConnectivityImplTest.java @@ -31,6 +31,7 @@ import org.opendaylight.transportpce.common.network.NetworkTransactionImpl; import org.opendaylight.transportpce.common.network.NetworkTransactionService; import org.opendaylight.transportpce.pce.service.PathComputationService; import org.opendaylight.transportpce.renderer.provisiondevice.RendererServiceOperations; +import org.opendaylight.transportpce.servicehandler.catalog.CatalogDataStoreOperations; import org.opendaylight.transportpce.servicehandler.impl.ServicehandlerImpl; import org.opendaylight.transportpce.servicehandler.listeners.NetworkListener; import org.opendaylight.transportpce.servicehandler.listeners.PceListener; @@ -83,6 +84,8 @@ public class TapiConnectivityImplTest extends AbstractTest { private RendererListener rendererListenerImpl; @Mock private NetworkListener networkModelListenerImpl; + @Mock + public CatalogDataStoreOperations catalogDataStoreOperations; private static final Logger LOG = LoggerFactory.getLogger(TapiConnectivityImplTest.class); private static ServiceDataStoreOperations serviceDataStoreOperations; @@ -128,7 +131,7 @@ public class TapiConnectivityImplTest extends AbstractTest { void createConnServiceShouldBeFailedWithEmptyInput() throws ExecutionException, InterruptedException { OrgOpenroadmServiceService serviceHandler = new ServicehandlerImpl(pathComputationService, rendererServiceOperations, notificationPublishService, pceListenerImpl, rendererListenerImpl, - networkModelListenerImpl, serviceDataStoreOperations); + networkModelListenerImpl, serviceDataStoreOperations, catalogDataStoreOperations); TapiConnectivityImpl tapiConnectivity = new TapiConnectivityImpl(serviceHandler, tapiContext, connectivityUtils, tapipceListenerImpl, tapirendererListenerImpl); @@ -153,7 +156,7 @@ public class TapiConnectivityImplTest extends AbstractTest { throws ExecutionException, InterruptedException { OrgOpenroadmServiceService serviceHandler = new ServicehandlerImpl(pathComputationService, rendererServiceOperations, notificationPublishService, pceListenerImpl, rendererListenerImpl, - networkModelListenerImpl, serviceDataStoreOperations); + networkModelListenerImpl, serviceDataStoreOperations, catalogDataStoreOperations); CreateConnectivityServiceInput input = TapiConnectivityDataUtils.buildConnServiceCreateInput(); when(pathComputationService.pathComputationRequest(any())).thenReturn(Futures.immediateFuture(any())); @@ -179,7 +182,7 @@ public class TapiConnectivityImplTest extends AbstractTest { void deleteConnServiceShouldBeFailedWithEmptyInput() throws ExecutionException, InterruptedException { OrgOpenroadmServiceService serviceHandler = new ServicehandlerImpl(pathComputationService, rendererServiceOperations, notificationPublishService, pceListenerImpl, rendererListenerImpl, - networkModelListenerImpl, serviceDataStoreOperations); + networkModelListenerImpl, serviceDataStoreOperations, catalogDataStoreOperations); TapiConnectivityImpl tapiConnectivity = new TapiConnectivityImpl(serviceHandler, tapiContext, connectivityUtils, tapipceListenerImpl, tapirendererListenerImpl); @@ -204,7 +207,7 @@ public class TapiConnectivityImplTest extends AbstractTest { DeleteConnectivityServiceInput input = TapiConnectivityDataUtils.buildConnServiceDeleteInput1(); OrgOpenroadmServiceService serviceHandler = new ServicehandlerImpl(pathComputationService, rendererServiceOperations, notificationPublishService, pceListenerImpl, rendererListenerImpl, - networkModelListenerImpl, serviceDataStoreOperations); + networkModelListenerImpl, serviceDataStoreOperations, catalogDataStoreOperations); TapiConnectivityImpl tapiConnectivity = new TapiConnectivityImpl(serviceHandler, tapiContext, connectivityUtils, tapipceListenerImpl, tapirendererListenerImpl); @@ -229,7 +232,7 @@ public class TapiConnectivityImplTest extends AbstractTest { OrgOpenroadmServiceService serviceHandler = new ServicehandlerImpl(pathComputationService, rendererServiceOperations, notificationPublishService, pceListenerImpl, rendererListenerImpl, - networkModelListenerImpl, serviceDataStoreOperations); + networkModelListenerImpl, serviceDataStoreOperations, catalogDataStoreOperations); TapiConnectivityImpl tapiConnectivity = new TapiConnectivityImpl(serviceHandler, tapiContext, connectivityUtils, tapipceListenerImpl, tapirendererListenerImpl); -- 2.36.6