import org.opendaylight.transportpce.pce.impl.PceProvider;
import org.opendaylight.transportpce.pce.service.PathComputationService;
import org.opendaylight.transportpce.pce.service.PathComputationServiceImpl;
-import org.opendaylight.transportpce.renderer.RendererProvider;
import org.opendaylight.transportpce.renderer.openroadminterface.OpenRoadmInterfaceFactory;
// Adding OTN interface
import org.opendaylight.transportpce.renderer.provisiondevice.DeviceRendererService;
private final PceProvider pceProvider;
// network model beans
private final NetworkModelProvider networkModelProvider;
- // renderer beans
- private final RendererProvider rendererProvider;
// service-handler beans
private final ServicehandlerProvider servicehandlerProvider;
// T-api
mappingUtils, portMapping);
OtnDeviceRendererService otnDeviceRendererService = new OtnDeviceRendererServiceImpl(
crossConnect, openRoadmInterfaces, deviceTransactionManager, mappingUtils, portMapping);
- rendererProvider = initRenderer(
- lightyServices, olmPowerServiceRpc, deviceRendererService, otnDeviceRendererService, portMapping);
+ initRenderer(lightyServices, olmPowerServiceRpc, deviceRendererService, otnDeviceRendererService, portMapping);
LOG.info("Creating service-handler beans ...");
RendererServiceOperations rendererServiceOperations = new RendererServiceOperationsImpl(
LOG.info("Shutting down service-handler provider ...");
}
servicehandlerProvider.close();
- LOG.info("Shutting down renderer provider ...");
- rendererProvider.close();
LOG.info("Shutting down network-model provider ...");
networkModelProvider.close();
LOG.info("Shutting down PCE provider ...");
tapiNetworkModelListenerImpl, tapiNetworkModelService);
}
- private RendererProvider initRenderer(
+ private void initRenderer(
LightyServices lightyServices, TransportpceOlmService olmPowerServiceRpc,
DeviceRendererService deviceRendererService, OtnDeviceRendererService otnDeviceRendererService,
PortMapping portMapping) {
- return new RendererProvider(
- lightyServices.getRpcProviderService(), deviceRendererService,
- otnDeviceRendererService,
- new DeviceRendererRPCImpl(deviceRendererService, otnDeviceRendererService),
+ rpcRegistrations.add(
+ new DeviceRendererRPCImpl(
+ lightyServices.getRpcProviderService(),
+ deviceRendererService,
+ otnDeviceRendererService)
+ .getRegisteredRpc());
+ rpcRegistrations.add(
new TransportPCEServicePathRPCImpl(
- new RendererServiceOperationsImpl(
- deviceRendererService, otnDeviceRendererService, olmPowerServiceRpc,
- lightyServices.getBindingDataBroker(), lightyServices.getBindingNotificationPublishService(),
- portMapping)));
+ new RendererServiceOperationsImpl(
+ deviceRendererService,
+ otnDeviceRendererService,
+ olmPowerServiceRpc,
+ lightyServices.getBindingDataBroker(),
+ lightyServices.getBindingNotificationPublishService(),
+ portMapping),
+ lightyServices.getRpcProviderService())
+ .getRegisteredRpc());
}
private OpenRoadmInterfaceFactory initOpenRoadmFactory(
+++ /dev/null
-/*
- * Copyright © 2017 AT&T 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.renderer;
-
-import org.opendaylight.mdsal.binding.api.RpcProviderService;
-import org.opendaylight.transportpce.renderer.provisiondevice.DeviceRendererService;
-import org.opendaylight.transportpce.renderer.provisiondevice.OtnDeviceRendererService;
-import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.device.renderer.rev211004.TransportpceDeviceRendererService;
-import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.renderer.rev210915.TransportpceRendererService;
-import org.opendaylight.yangtools.concepts.ObjectRegistration;
-import org.osgi.service.component.annotations.Activate;
-import org.osgi.service.component.annotations.Component;
-import org.osgi.service.component.annotations.Deactivate;
-import org.osgi.service.component.annotations.Reference;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-@Component
-public class RendererProvider {
-
- private static final Logger LOG = LoggerFactory.getLogger(RendererProvider.class);
- private final RpcProviderService rpcProviderService;
- private ObjectRegistration<TransportpceDeviceRendererService> deviceRendererRegistration;
- private ObjectRegistration<TransportpceRendererService> tpceServiceRegistry;
-
- @Activate
- public RendererProvider(@Reference RpcProviderService rpcProviderService,
- @Reference DeviceRendererService deviceRenderer,
- @Reference OtnDeviceRendererService otnDeviceRendererService,
- @Reference TransportpceDeviceRendererService deviceRendererRPCImpl,
- @Reference TransportpceRendererService transportPCEServicePathRPCImpl) {
- this.rpcProviderService = rpcProviderService;
- LOG.info("RendererProvider Session Initiated");
- this.deviceRendererRegistration = this.rpcProviderService
- .registerRpcImplementation(TransportpceDeviceRendererService.class, deviceRendererRPCImpl);
- this.tpceServiceRegistry = this.rpcProviderService
- .registerRpcImplementation(TransportpceRendererService.class, transportPCEServicePathRPCImpl);
- }
-
- /**
- * Method called when the blueprint container is destroyed.
- */
- @Deactivate
- public void close() {
- LOG.info("RendererProvider Closed");
- if (this.deviceRendererRegistration != null) {
- this.deviceRendererRegistration.close();
- }
- if (this.tpceServiceRegistry != null) {
- this.tpceServiceRegistry.close();
- }
- }
-}
\ No newline at end of file
package org.opendaylight.transportpce.renderer.rpcs;
+import com.google.common.collect.ImmutableClassToInstanceMap;
import com.google.common.util.concurrent.ListenableFuture;
+import org.opendaylight.mdsal.binding.api.RpcProviderService;
import org.opendaylight.transportpce.common.openroadminterfaces.OpenRoadmInterfaceException;
import org.opendaylight.transportpce.common.service.ServiceTypes;
import org.opendaylight.transportpce.renderer.provisiondevice.DeviceRendererService;
import org.opendaylight.transportpce.renderer.provisiondevice.OtnDeviceRendererService;
+import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.device.renderer.rev211004.CreateOtsOms;
import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.device.renderer.rev211004.CreateOtsOmsInput;
import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.device.renderer.rev211004.CreateOtsOmsOutput;
+import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.device.renderer.rev211004.OtnServicePath;
import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.device.renderer.rev211004.OtnServicePathInput;
import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.device.renderer.rev211004.OtnServicePathOutput;
import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.device.renderer.rev211004.OtnServicePathOutputBuilder;
+import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.device.renderer.rev211004.RendererRollback;
import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.device.renderer.rev211004.RendererRollbackInput;
import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.device.renderer.rev211004.RendererRollbackOutput;
+import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.device.renderer.rev211004.ServicePath;
import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.device.renderer.rev211004.ServicePathInput;
import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.device.renderer.rev211004.ServicePathOutput;
import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.device.renderer.rev211004.ServicePathOutputBuilder;
import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.device.renderer.rev211004.TransportpceDeviceRendererService;
+import org.opendaylight.yangtools.concepts.Registration;
+import org.opendaylight.yangtools.yang.binding.Rpc;
import org.opendaylight.yangtools.yang.common.RpcResult;
import org.opendaylight.yangtools.yang.common.RpcResultBuilder;
import org.osgi.service.component.annotations.Activate;
import org.osgi.service.component.annotations.Component;
+import org.osgi.service.component.annotations.Deactivate;
import org.osgi.service.component.annotations.Reference;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
private static final Logger LOG = LoggerFactory.getLogger(DeviceRendererRPCImpl.class);
private DeviceRendererService deviceRenderer;
private OtnDeviceRendererService otnDeviceRendererService;
+ private Registration reg;
@Activate
- public DeviceRendererRPCImpl(@Reference DeviceRendererService deviceRenderer,
+ public DeviceRendererRPCImpl(@Reference RpcProviderService rpcProviderService,
+ @Reference DeviceRendererService deviceRenderer,
@Reference OtnDeviceRendererService otnDeviceRendererService) {
this.deviceRenderer = deviceRenderer;
this.otnDeviceRendererService = otnDeviceRendererService;
+ this.reg = rpcProviderService.registerRpcImplementations(ImmutableClassToInstanceMap.<Rpc<?, ?>>builder()
+ .put(ServicePath.class, this::servicePath)
+ .put(OtnServicePath.class, this::otnServicePath)
+ .put(RendererRollback.class, this::rendererRollback)
+ .put(CreateOtsOms.class, this::createOtsOms)
+ .build());
LOG.debug("DeviceRendererRPCImpl instantiated");
}
+ @Deactivate
+ public void close() {
+ this.reg.close();
+ LOG.info("DeviceRendererRPCImpl Closed");
+ }
+
/**
* This method is the implementation of the 'service-path' RESTCONF service,
* which is one of the external APIs into the renderer application. The
* @return Result of the request
*/
@Override
- public ListenableFuture<RpcResult<ServicePathOutput>> servicePath(ServicePathInput input) {
+ public final ListenableFuture<RpcResult<ServicePathOutput>> servicePath(ServicePathInput input) {
if (input.getOperation() != null) {
if (input.getOperation().getIntValue() == 1) {
LOG.info("Create operation request received");
}
@Override
- public ListenableFuture<RpcResult<OtnServicePathOutput>> otnServicePath(OtnServicePathInput input) {
+ public final ListenableFuture<RpcResult<OtnServicePathOutput>> otnServicePath(OtnServicePathInput input) {
if (input.getOperation() != null && input.getServiceFormat() != null && input.getServiceRate() != null) {
String serviceType = ServiceTypes.getOtnServiceType(input.getServiceFormat(), input.getServiceRate());
if (input.getOperation().getIntValue() == 1) {
* @return Success flag and nodes which failed to rollback
*/
@Override
- public ListenableFuture<RpcResult<RendererRollbackOutput>> rendererRollback(RendererRollbackInput input) {
+ public final ListenableFuture<RpcResult<RendererRollbackOutput>> rendererRollback(RendererRollbackInput input) {
return RpcResultBuilder.success(this.deviceRenderer.rendererRollback(input)).buildFuture();
}
@Override
- public ListenableFuture<RpcResult<CreateOtsOmsOutput>> createOtsOms(CreateOtsOmsInput input) {
+ public final ListenableFuture<RpcResult<CreateOtsOmsOutput>> createOtsOms(CreateOtsOmsInput input) {
LOG.info("Request received to create oms and ots interfaces on {}: {}", input.getNodeId(), input
.getLogicalConnectionPoint());
try {
}
return null;
}
+
+ public Registration getRegisteredRpc() {
+ return reg;
+ }
}
*/
package org.opendaylight.transportpce.renderer.rpcs;
+import com.google.common.collect.ImmutableClassToInstanceMap;
import com.google.common.util.concurrent.ListenableFuture;
import java.util.concurrent.ExecutionException;
+import org.opendaylight.mdsal.binding.api.RpcProviderService;
import org.opendaylight.transportpce.renderer.ModelMappingUtils;
import org.opendaylight.transportpce.renderer.provisiondevice.RendererServiceOperations;
+import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.renderer.rev210915.ServiceDelete;
import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.renderer.rev210915.ServiceDeleteInput;
import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.renderer.rev210915.ServiceDeleteOutput;
+import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.renderer.rev210915.ServiceImplementationRequest;
import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.renderer.rev210915.ServiceImplementationRequestInput;
import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.renderer.rev210915.ServiceImplementationRequestOutput;
import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.renderer.rev210915.TransportpceRendererService;
+import org.opendaylight.yangtools.concepts.Registration;
+import org.opendaylight.yangtools.yang.binding.Rpc;
import org.opendaylight.yangtools.yang.common.RpcResult;
import org.osgi.service.component.annotations.Activate;
import org.osgi.service.component.annotations.Component;
+import org.osgi.service.component.annotations.Deactivate;
import org.osgi.service.component.annotations.Reference;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
private static final Logger LOG = LoggerFactory.getLogger(TransportPCEServicePathRPCImpl.class);
private final RendererServiceOperations rendererServiceOperations;
+ private Registration reg;
@Activate
- public TransportPCEServicePathRPCImpl(@Reference RendererServiceOperations rendererServiceOperations) {
+ public TransportPCEServicePathRPCImpl(@Reference RendererServiceOperations rendererServiceOperations,
+ @Reference RpcProviderService rpcProviderService) {
this.rendererServiceOperations = rendererServiceOperations;
+ this.reg = rpcProviderService.registerRpcImplementations(ImmutableClassToInstanceMap.<Rpc<?, ?>>builder()
+ .put(ServiceImplementationRequest.class, this::serviceImplementationRequest)
+ .put(ServiceDelete.class, this::serviceDelete)
+ .build());
LOG.debug("TransportPCEServicePathRPCImpl instantiated");
}
+ @Deactivate
+ public void close() {
+ this.reg.close();
+ LOG.info("TransportPCEServicePathRPCImpl Closed");
+ }
+
@Override
- public ListenableFuture<RpcResult<ServiceDeleteOutput>> serviceDelete(ServiceDeleteInput input) {
+ public final ListenableFuture<RpcResult<ServiceDeleteOutput>> serviceDelete(ServiceDeleteInput input) {
String serviceName = input.getServiceName();
LOG.info("Calling RPC service delete request {}", serviceName);
ServiceDeleteOutput output = null;
}
@Override
- public ListenableFuture<RpcResult<ServiceImplementationRequestOutput>> serviceImplementationRequest(
+ public final ListenableFuture<RpcResult<ServiceImplementationRequestOutput>> serviceImplementationRequest(
ServiceImplementationRequestInput input) {
String serviceName = input.getServiceName();
LOG.info("Calling RPC service impl request {}", serviceName);
}
return ModelMappingUtils.createServiceImplementationRpcResponse(output);
}
+
+ public Registration getRegisteredRpc() {
+ return reg;
+ }
}
+++ /dev/null
-/*
- * Copyright © 2019 Orange, 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.renderer;
-
-import static org.mockito.ArgumentMatchers.any;
-import static org.mockito.Mockito.times;
-import static org.mockito.Mockito.verify;
-
-import org.junit.jupiter.api.Test;
-import org.junit.jupiter.api.extension.ExtendWith;
-import org.mockito.Mock;
-import org.mockito.junit.jupiter.MockitoExtension;
-import org.opendaylight.mdsal.binding.api.RpcProviderService;
-import org.opendaylight.transportpce.renderer.provisiondevice.DeviceRendererService;
-import org.opendaylight.transportpce.renderer.provisiondevice.OtnDeviceRendererService;
-import org.opendaylight.transportpce.renderer.rpcs.DeviceRendererRPCImpl;
-import org.opendaylight.transportpce.renderer.rpcs.TransportPCEServicePathRPCImpl;
-import org.opendaylight.transportpce.test.AbstractTest;
-
-@ExtendWith(MockitoExtension.class)
-public class RendererProviderTest extends AbstractTest {
-
- @Mock
- RpcProviderService rpcProviderService;
- @Mock
- DeviceRendererService deviceRenderer;
- @Mock
- OtnDeviceRendererService otnDeviceRendererService;
- @Mock
- DeviceRendererRPCImpl deviceRendererRPCImpl;
- @Mock
- TransportPCEServicePathRPCImpl transportPCEServicePathRPCImpl;
-
- @Test
- void testInitMethodRegistersRendererToRpcService() {
- new RendererProvider(rpcProviderService, deviceRenderer, otnDeviceRendererService, deviceRendererRPCImpl,
- transportPCEServicePathRPCImpl);
-
- verify(rpcProviderService, times(1))
- .registerRpcImplementation(any(), any(TransportPCEServicePathRPCImpl.class));
- verify(rpcProviderService, times(1))
- .registerRpcImplementation(any(), any(DeviceRendererRPCImpl.class));
- }
-}
package org.opendaylight.transportpce.renderer.rpcs;
import static org.junit.jupiter.api.Assertions.assertNull;
+import static org.mockito.ArgumentMatchers.any;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.spy;
import static org.mockito.Mockito.times;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
+import org.opendaylight.mdsal.binding.api.RpcProviderService;
import org.opendaylight.transportpce.common.openroadminterfaces.OpenRoadmInterfaceException;
import org.opendaylight.transportpce.renderer.provisiondevice.DeviceRendererService;
import org.opendaylight.transportpce.renderer.provisiondevice.OtnDeviceRendererService;
public class DeviceRendererRPCImplTest extends AbstractTest {
+ private final RpcProviderService rpcProviderService = mock(RpcProviderService.class);
private final DeviceRendererService deviceRenderer = mock(DeviceRendererService.class);
private final OtnDeviceRendererService otnDeviceRenderer = mock(OtnDeviceRendererService.class);
private final ServicePathInput servicePathInput = spy(ServicePathInput.class);
@BeforeEach
void setup() {
- deviceRendererRPC = new DeviceRendererRPCImpl(deviceRenderer, otnDeviceRenderer);
+ deviceRendererRPC = new DeviceRendererRPCImpl(rpcProviderService, deviceRenderer, otnDeviceRenderer);
+ }
+
+ @Test
+ void testRpcRegistration() {
+ verify(rpcProviderService, times(1)).registerRpcImplementations(any());
}
@Test