From 3c010d302c4699d9abb8067636f72b399d967e17 Mon Sep 17 00:00:00 2001 From: Martin Sunal Date: Sun, 22 May 2016 02:06:02 +0200 Subject: [PATCH] Introduced DomainSpecificRegistry service - the service allows to register augmentors(entity which translates data from one augmentation to the other) for domain specific data - this service starts: - BaseEndpointService implementation - RendererManger Domain specific data can be augmented into: - address-endpoint-reg, containment-endpoint-reg from RPC register-endpoint (base-endpoint.yang) EndpointAugmentor has to be provided in order to propagate augmentations to all places - forwarding/forwarding-by-tenant/network-domain (forwarding.yang) NetworkDomainAugmentor has to be provided in order to propagate augmentations to all places Change-Id: Iaa9a0684651bb53279007de9472341d0e7fe4a4b Signed-off-by: Martin Sunal --- .../src/main/config/default-config.xml | 10 +- ...endererAugmentationRegistryImplModule.java | 44 -- ...AugmentationRegistryImplModuleFactory.java | 21 - .../DomainSpecificRegistryModule.java | 81 +++ .../DomainSpecificRegistryModuleFactory.java | 12 + .../GroupbasedpolicyModule.java | 4 - .../api/BaseEndpointRendererAugmentation.java | 45 -- ...eEndpointRendererAugmentationRegistry.java | 28 - .../api/DomainSpecificRegistry.java | 18 + .../api/EndpointAugmentor.java | 76 ++ .../api/EndpointAugmentorRegistry.java | 29 + .../api/EpRendererAugmentation.java | 1 + .../api/EpRendererAugmentationRegistry.java | 1 + .../api/NetworkDomainAugmentor.java | 36 + .../api/NetworkDomainAugmentorRegistry.java | 29 + .../BaseEndpointRpcRegistry.java | 658 ------------------ .../BaseEndpointServiceImpl.java | 328 +++++++++ .../EndpointAugmentorRegistryImpl.java | 43 ++ .../RegisterEndpointInputVerificator.java | 240 +++++++ .../NetworkDomainAugmentorRegistryImpl.java | 43 ++ .../RendererConfigurationBuilder.java | 95 ++- .../renderer/RendererManager.java | 12 +- .../groupbasedpolicy/util/EndpointUtils.java | 61 ++ .../groupbasedpolicy/util/IidFactory.java | 11 - .../src/main/yang/groupbasedpolicy-cfg.yang | 16 +- .../src/main/yang/model/base-endpoint.yang | 2 + .../src/main/yang/model/forwarding.yang | 44 +- .../src/main/yang/model/l2-l3-forwarding.yang | 56 +- .../src/main/yang/model/renderer.yang | 25 +- .../BaseEndpointRpcRegistryTest.java | 623 ----------------- .../BaseEndpointServiceImplTest.java | 439 ++++++++++++ .../EndpointAugmentorRegistryImplTest.java | 29 + .../RendererManagerDataBrokerTest.java | 29 +- .../renderer/RendererManagerTest.java | 8 +- 34 files changed, 1667 insertions(+), 1530 deletions(-) delete mode 100644 groupbasedpolicy/src/main/java/org/opendaylight/controller/config/yang/config/groupbasedpolicy/BaseEndpointRendererAugmentationRegistryImplModule.java delete mode 100644 groupbasedpolicy/src/main/java/org/opendaylight/controller/config/yang/config/groupbasedpolicy/BaseEndpointRendererAugmentationRegistryImplModuleFactory.java create mode 100644 groupbasedpolicy/src/main/java/org/opendaylight/controller/config/yang/config/groupbasedpolicy/DomainSpecificRegistryModule.java create mode 100644 groupbasedpolicy/src/main/java/org/opendaylight/controller/config/yang/config/groupbasedpolicy/DomainSpecificRegistryModuleFactory.java delete mode 100644 groupbasedpolicy/src/main/java/org/opendaylight/groupbasedpolicy/api/BaseEndpointRendererAugmentation.java delete mode 100644 groupbasedpolicy/src/main/java/org/opendaylight/groupbasedpolicy/api/BaseEndpointRendererAugmentationRegistry.java create mode 100644 groupbasedpolicy/src/main/java/org/opendaylight/groupbasedpolicy/api/DomainSpecificRegistry.java create mode 100644 groupbasedpolicy/src/main/java/org/opendaylight/groupbasedpolicy/api/EndpointAugmentor.java create mode 100644 groupbasedpolicy/src/main/java/org/opendaylight/groupbasedpolicy/api/EndpointAugmentorRegistry.java create mode 100644 groupbasedpolicy/src/main/java/org/opendaylight/groupbasedpolicy/api/NetworkDomainAugmentor.java create mode 100644 groupbasedpolicy/src/main/java/org/opendaylight/groupbasedpolicy/api/NetworkDomainAugmentorRegistry.java delete mode 100644 groupbasedpolicy/src/main/java/org/opendaylight/groupbasedpolicy/base_endpoint/BaseEndpointRpcRegistry.java create mode 100644 groupbasedpolicy/src/main/java/org/opendaylight/groupbasedpolicy/base_endpoint/BaseEndpointServiceImpl.java create mode 100644 groupbasedpolicy/src/main/java/org/opendaylight/groupbasedpolicy/base_endpoint/EndpointAugmentorRegistryImpl.java create mode 100644 groupbasedpolicy/src/main/java/org/opendaylight/groupbasedpolicy/base_endpoint/RegisterEndpointInputVerificator.java create mode 100644 groupbasedpolicy/src/main/java/org/opendaylight/groupbasedpolicy/forwarding/NetworkDomainAugmentorRegistryImpl.java create mode 100644 groupbasedpolicy/src/main/java/org/opendaylight/groupbasedpolicy/util/EndpointUtils.java delete mode 100644 groupbasedpolicy/src/test/java/org/opendaylight/groupbasedpolicy/base_endpoint/BaseEndpointRpcRegistryTest.java create mode 100644 groupbasedpolicy/src/test/java/org/opendaylight/groupbasedpolicy/base_endpoint/BaseEndpointServiceImplTest.java create mode 100644 groupbasedpolicy/src/test/java/org/opendaylight/groupbasedpolicy/base_endpoint/EndpointAugmentorRegistryImplTest.java diff --git a/groupbasedpolicy/src/main/config/default-config.xml b/groupbasedpolicy/src/main/config/default-config.xml index 0abe8d3a0..0390945d5 100755 --- a/groupbasedpolicy/src/main/config/default-config.xml +++ b/groupbasedpolicy/src/main/config/default-config.xml @@ -61,9 +61,9 @@ - groupbasedpolicy:base-endpoint-renderer-augmentation-registry-impl + groupbasedpolicy:domain-specific-registry-impl - base-endpoint-renderer-augmentation-registry + domain-specific-registry binding:binding-async-data-broker @@ -111,12 +111,12 @@ - groupbasedpolicy:base-endpoint-renderer-augmentation-registry + groupbasedpolicy:domain-specific-registry - base-endpoint-renderer-augmentation-registry - /modules/module[type='base-endpoint-renderer-augmentation-registry-impl'][name='base-endpoint-renderer-augmentation-registry'] + domain-specific-registry + /modules/module[type='domain-specific-registry-impl'][name='domain-specific-registry'] diff --git a/groupbasedpolicy/src/main/java/org/opendaylight/controller/config/yang/config/groupbasedpolicy/BaseEndpointRendererAugmentationRegistryImplModule.java b/groupbasedpolicy/src/main/java/org/opendaylight/controller/config/yang/config/groupbasedpolicy/BaseEndpointRendererAugmentationRegistryImplModule.java deleted file mode 100644 index 57c82a08f..000000000 --- a/groupbasedpolicy/src/main/java/org/opendaylight/controller/config/yang/config/groupbasedpolicy/BaseEndpointRendererAugmentationRegistryImplModule.java +++ /dev/null @@ -1,44 +0,0 @@ -/* - * Copyright (c) 2015 Cisco Systems, Inc. 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.controller.config.yang.config.groupbasedpolicy; - -import org.opendaylight.controller.md.sal.binding.api.DataBroker; -import org.opendaylight.controller.sal.binding.api.RpcProviderRegistry; -import org.opendaylight.groupbasedpolicy.base_endpoint.BaseEndpointRpcRegistry; -import org.slf4j.Logger; -import org.slf4j.LoggerFactory; - -public class BaseEndpointRendererAugmentationRegistryImplModule extends org.opendaylight.controller.config.yang.config.groupbasedpolicy.AbstractBaseEndpointRendererAugmentationRegistryImplModule { - - private static final Logger LOG = LoggerFactory.getLogger(BaseEndpointRendererAugmentationRegistryImplModule.class); - - public BaseEndpointRendererAugmentationRegistryImplModule(org.opendaylight.controller.config.api.ModuleIdentifier identifier, org.opendaylight.controller.config.api.DependencyResolver dependencyResolver) { - super(identifier, dependencyResolver); - } - - public BaseEndpointRendererAugmentationRegistryImplModule(org.opendaylight.controller.config.api.ModuleIdentifier identifier, org.opendaylight.controller.config.api.DependencyResolver dependencyResolver, org.opendaylight.controller.config.yang.config.groupbasedpolicy.BaseEndpointRendererAugmentationRegistryImplModule oldModule, java.lang.AutoCloseable oldInstance) { - super(identifier, dependencyResolver, oldModule, oldInstance); - } - - @Override - public void customValidation() { - // add custom validation form module attributes here. - } - - @Override - public java.lang.AutoCloseable createInstance() { - final DataBroker dataProvider = getDataBrokerDependency(); - final RpcProviderRegistry rpcRegistry = getRpcRegistryDependency(); - - BaseEndpointRpcRegistry baseEndpointRpcRegistry = new BaseEndpointRpcRegistry(dataProvider, rpcRegistry); - LOG.info("{} successfully started.", BaseEndpointRendererAugmentationRegistryImplModule.class.getCanonicalName()); - return baseEndpointRpcRegistry; - } - -} diff --git a/groupbasedpolicy/src/main/java/org/opendaylight/controller/config/yang/config/groupbasedpolicy/BaseEndpointRendererAugmentationRegistryImplModuleFactory.java b/groupbasedpolicy/src/main/java/org/opendaylight/controller/config/yang/config/groupbasedpolicy/BaseEndpointRendererAugmentationRegistryImplModuleFactory.java deleted file mode 100644 index 4ffe06f4f..000000000 --- a/groupbasedpolicy/src/main/java/org/opendaylight/controller/config/yang/config/groupbasedpolicy/BaseEndpointRendererAugmentationRegistryImplModuleFactory.java +++ /dev/null @@ -1,21 +0,0 @@ -/* - * Copyright (c) 2015 Cisco Systems, Inc. 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 - */ - -/* -* Generated file -* -* Generated from: yang module name: groupbasedpolicy-cfg yang module local name: base-endpoint-renderer-augmentation-registry-impl -* Generated by: org.opendaylight.controller.config.yangjmxgenerator.plugin.JMXGenerator -* Generated at: Mon May 09 16:19:05 CEST 2016 -* -* Do not modify this file unless it is present under src/main directory -*/ -package org.opendaylight.controller.config.yang.config.groupbasedpolicy; -public class BaseEndpointRendererAugmentationRegistryImplModuleFactory extends org.opendaylight.controller.config.yang.config.groupbasedpolicy.AbstractBaseEndpointRendererAugmentationRegistryImplModuleFactory { - -} diff --git a/groupbasedpolicy/src/main/java/org/opendaylight/controller/config/yang/config/groupbasedpolicy/DomainSpecificRegistryModule.java b/groupbasedpolicy/src/main/java/org/opendaylight/controller/config/yang/config/groupbasedpolicy/DomainSpecificRegistryModule.java new file mode 100644 index 000000000..b237883b1 --- /dev/null +++ b/groupbasedpolicy/src/main/java/org/opendaylight/controller/config/yang/config/groupbasedpolicy/DomainSpecificRegistryModule.java @@ -0,0 +1,81 @@ +/* + * Copyright (c) 2016 Cisco Systems, Inc. and others. All rights reserved. + * + * This program and the accompanying materials are made available under the + * terms of the Eclipse Public License v1.0 which accompanies this distribution, + * and is available at http://www.eclipse.org/legal/epl-v10.html + */ + +package org.opendaylight.controller.config.yang.config.groupbasedpolicy; + +import org.opendaylight.controller.md.sal.binding.api.DataBroker; +import org.opendaylight.controller.sal.binding.api.RpcProviderRegistry; +import org.opendaylight.groupbasedpolicy.api.DomainSpecificRegistry; +import org.opendaylight.groupbasedpolicy.api.EndpointAugmentorRegistry; +import org.opendaylight.groupbasedpolicy.api.NetworkDomainAugmentorRegistry; +import org.opendaylight.groupbasedpolicy.base_endpoint.BaseEndpointServiceImpl; +import org.opendaylight.groupbasedpolicy.base_endpoint.EndpointAugmentorRegistryImpl; +import org.opendaylight.groupbasedpolicy.forwarding.NetworkDomainAugmentorRegistryImpl; +import org.opendaylight.groupbasedpolicy.renderer.RendererManager; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +public class DomainSpecificRegistryModule extends org.opendaylight.controller.config.yang.config.groupbasedpolicy.AbstractDomainSpecificRegistryModule { + + private static final Logger LOG = LoggerFactory.getLogger(DomainSpecificRegistryModule.class); + + public DomainSpecificRegistryModule(org.opendaylight.controller.config.api.ModuleIdentifier identifier, org.opendaylight.controller.config.api.DependencyResolver dependencyResolver) { + super(identifier, dependencyResolver); + } + + public DomainSpecificRegistryModule(org.opendaylight.controller.config.api.ModuleIdentifier identifier, org.opendaylight.controller.config.api.DependencyResolver dependencyResolver, org.opendaylight.controller.config.yang.config.groupbasedpolicy.DomainSpecificRegistryModule oldModule, java.lang.AutoCloseable oldInstance) { + super(identifier, dependencyResolver, oldModule, oldInstance); + } + + @Override + public void customValidation() { + // add custom validation form module attributes here. + } + + @Override + public java.lang.AutoCloseable createInstance() { + final DataBroker dataProvider = getDataBrokerDependency(); + final RpcProviderRegistry rpcRegistry = getRpcRegistryDependency(); + Instance instance = new Instance(dataProvider, rpcRegistry); + LOG.info("{} successfully started.", DomainSpecificRegistryModule.class.getCanonicalName()); + return instance; + } + + private static class Instance implements DomainSpecificRegistry, AutoCloseable { + + private final EndpointAugmentorRegistryImpl endpointAugmentorRegistryImpl; + private final NetworkDomainAugmentorRegistryImpl netDomainAugmentorRegistryImpl; + private final BaseEndpointServiceImpl baseEndpointServiceImpl; + private final RendererManager rendererManager; + + Instance(DataBroker dataProvider, RpcProviderRegistry rpcRegistry) { + endpointAugmentorRegistryImpl = new EndpointAugmentorRegistryImpl(); + netDomainAugmentorRegistryImpl = new NetworkDomainAugmentorRegistryImpl(); + baseEndpointServiceImpl = new BaseEndpointServiceImpl(dataProvider, rpcRegistry, endpointAugmentorRegistryImpl); + rendererManager = new RendererManager(dataProvider, netDomainAugmentorRegistryImpl); + } + + @Override + public void close() throws Exception { + baseEndpointServiceImpl.close(); + rendererManager.close(); + } + + @Override + public EndpointAugmentorRegistry getEndpointAugmentorRegistry() { + return endpointAugmentorRegistryImpl; + } + + @Override + public NetworkDomainAugmentorRegistry getNetworkDomainAugmentorRegistry() { + return netDomainAugmentorRegistryImpl; + } + + } + +} diff --git a/groupbasedpolicy/src/main/java/org/opendaylight/controller/config/yang/config/groupbasedpolicy/DomainSpecificRegistryModuleFactory.java b/groupbasedpolicy/src/main/java/org/opendaylight/controller/config/yang/config/groupbasedpolicy/DomainSpecificRegistryModuleFactory.java new file mode 100644 index 000000000..f532db474 --- /dev/null +++ b/groupbasedpolicy/src/main/java/org/opendaylight/controller/config/yang/config/groupbasedpolicy/DomainSpecificRegistryModuleFactory.java @@ -0,0 +1,12 @@ +/* + * Copyright (c) 2016 Cisco Systems, Inc. and others. All rights reserved. + * + * This program and the accompanying materials are made available under the + * terms of the Eclipse Public License v1.0 which accompanies this distribution, + * and is available at http://www.eclipse.org/legal/epl-v10.html + */ + +package org.opendaylight.controller.config.yang.config.groupbasedpolicy; +public class DomainSpecificRegistryModuleFactory extends org.opendaylight.controller.config.yang.config.groupbasedpolicy.AbstractDomainSpecificRegistryModuleFactory { + +} diff --git a/groupbasedpolicy/src/main/java/org/opendaylight/controller/config/yang/config/groupbasedpolicy/GroupbasedpolicyModule.java b/groupbasedpolicy/src/main/java/org/opendaylight/controller/config/yang/config/groupbasedpolicy/GroupbasedpolicyModule.java index fcec2c0f5..5c82b0a0c 100644 --- a/groupbasedpolicy/src/main/java/org/opendaylight/controller/config/yang/config/groupbasedpolicy/GroupbasedpolicyModule.java +++ b/groupbasedpolicy/src/main/java/org/opendaylight/controller/config/yang/config/groupbasedpolicy/GroupbasedpolicyModule.java @@ -12,7 +12,6 @@ import org.opendaylight.controller.md.sal.binding.api.DataBroker; import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException; import org.opendaylight.groupbasedpolicy.api.PolicyValidatorRegistry; import org.opendaylight.groupbasedpolicy.location.resolver.LocationResolver; -import org.opendaylight.groupbasedpolicy.renderer.RendererManager; import org.opendaylight.groupbasedpolicy.resolver.ForwardingResolver; import org.opendaylight.groupbasedpolicy.sf.SubjectFeatureDefinitionProvider; import org.opendaylight.groupbasedpolicy.sf.SupportedActionDefinitionListener; @@ -64,7 +63,6 @@ public class GroupbasedpolicyModule extends org.opendaylight.controller.config.y private final SupportedClassifierDefinitionListener supportedClassifierDefinitionListener; private final SupportedActionDefinitionListener supportedActionDefinitionListener; private final LocationResolver locationResolver; - private final RendererManager rendererManager; private final ForwardingResolver forwardingResolver; Instance(DataBroker dataProvider, PolicyValidatorRegistry validatorRegistry) throws TransactionCommitFailedException { @@ -72,7 +70,6 @@ public class GroupbasedpolicyModule extends org.opendaylight.controller.config.y supportedClassifierDefinitionListener = new SupportedClassifierDefinitionListener(dataProvider, validatorRegistry); supportedActionDefinitionListener = new SupportedActionDefinitionListener(dataProvider); locationResolver = new LocationResolver(dataProvider); - rendererManager = new RendererManager(dataProvider); forwardingResolver = new ForwardingResolver(dataProvider); } @@ -82,7 +79,6 @@ public class GroupbasedpolicyModule extends org.opendaylight.controller.config.y supportedClassifierDefinitionListener.close(); supportedActionDefinitionListener.close(); locationResolver.close(); - rendererManager.close(); forwardingResolver.close(); } } diff --git a/groupbasedpolicy/src/main/java/org/opendaylight/groupbasedpolicy/api/BaseEndpointRendererAugmentation.java b/groupbasedpolicy/src/main/java/org/opendaylight/groupbasedpolicy/api/BaseEndpointRendererAugmentation.java deleted file mode 100644 index c9607c292..000000000 --- a/groupbasedpolicy/src/main/java/org/opendaylight/groupbasedpolicy/api/BaseEndpointRendererAugmentation.java +++ /dev/null @@ -1,45 +0,0 @@ -/* - * Copyright (c) 2016 Cisco Systems, Inc. and others. All rights reserved. - * - * This program and the accompanying materials are made available under the - * terms of the Eclipse Public License v1.0 which accompanies this distribution, - * and is available at http://www.eclipse.org/legal/epl-v10.html - */ - -package org.opendaylight.groupbasedpolicy.api; - -import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.endpoints.address.endpoints.AddressEndpoint; -import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.endpoints.containment.endpoints.ContainmentEndpoint; -import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.register.endpoint.input.AddressEndpointReg; -import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.register.endpoint.input.ContainmentEndpointReg; -import org.opendaylight.yangtools.yang.binding.Augmentation; - -import javax.annotation.Nullable; -import java.util.Map; - -public interface BaseEndpointRendererAugmentation { - - /** - * Creates pair of AddressEndpoint augmentation, specific for renderer and augmentation type - * (class - * name). - * - * @param input input data for AddressEndpoint creation - * @return pair of augmentation type and augmentation - */ - @Nullable - Map.Entry>, Augmentation> buildAddressEndpointAugmentation( - AddressEndpointReg input); - - /** - * Creates pair of AddressEndpoint augmentation, specific for renderer and augmentation type - * (class - * name). - * - * @param input input data for AddressEndpoint creation - * @return pair of augmentation type and augmentation - */ - @Nullable - Map.Entry>, Augmentation> buildContainmentEndpointAugmentation( - ContainmentEndpointReg input); -} diff --git a/groupbasedpolicy/src/main/java/org/opendaylight/groupbasedpolicy/api/BaseEndpointRendererAugmentationRegistry.java b/groupbasedpolicy/src/main/java/org/opendaylight/groupbasedpolicy/api/BaseEndpointRendererAugmentationRegistry.java deleted file mode 100644 index 18bc120d1..000000000 --- a/groupbasedpolicy/src/main/java/org/opendaylight/groupbasedpolicy/api/BaseEndpointRendererAugmentationRegistry.java +++ /dev/null @@ -1,28 +0,0 @@ -/* - * Copyright (c) 2016 Cisco Systems, Inc. and others. All rights reserved. - * - * This program and the accompanying materials are made available under the - * terms of the Eclipse Public License v1.0 which accompanies this distribution, - * and is available at http://www.eclipse.org/legal/epl-v10.html - */ - -package org.opendaylight.groupbasedpolicy.api; - -public interface BaseEndpointRendererAugmentationRegistry { - - /** - * Registers renderer's endpoints augmentation. - * - * @param baseEndpointRendererAugmentation cannot be {@code null} - * @throws NullPointerException - */ - void register(BaseEndpointRendererAugmentation baseEndpointRendererAugmentation); - - /** - * Unregisters renderer's endpoints augmentation. - * - * @param baseEndpointRendererAugmentation cannot be {@code null} - * @throws NullPointerException - */ - void unregister(BaseEndpointRendererAugmentation baseEndpointRendererAugmentation); -} diff --git a/groupbasedpolicy/src/main/java/org/opendaylight/groupbasedpolicy/api/DomainSpecificRegistry.java b/groupbasedpolicy/src/main/java/org/opendaylight/groupbasedpolicy/api/DomainSpecificRegistry.java new file mode 100644 index 000000000..a4af71f53 --- /dev/null +++ b/groupbasedpolicy/src/main/java/org/opendaylight/groupbasedpolicy/api/DomainSpecificRegistry.java @@ -0,0 +1,18 @@ +/* + * Copyright (c) 2016 Cisco Systems, Inc. and others. All rights reserved. + * + * This program and the accompanying materials are made available under the + * terms of the Eclipse Public License v1.0 which accompanies this distribution, + * and is available at http://www.eclipse.org/legal/epl-v10.html + */ + +package org.opendaylight.groupbasedpolicy.api; + +public interface DomainSpecificRegistry { + + EndpointAugmentorRegistry getEndpointAugmentorRegistry(); + + NetworkDomainAugmentorRegistry getNetworkDomainAugmentorRegistry(); + + // TODO add forwarding validator registry +} diff --git a/groupbasedpolicy/src/main/java/org/opendaylight/groupbasedpolicy/api/EndpointAugmentor.java b/groupbasedpolicy/src/main/java/org/opendaylight/groupbasedpolicy/api/EndpointAugmentor.java new file mode 100644 index 000000000..3a901cc82 --- /dev/null +++ b/groupbasedpolicy/src/main/java/org/opendaylight/groupbasedpolicy/api/EndpointAugmentor.java @@ -0,0 +1,76 @@ +/* + * Copyright (c) 2016 Cisco Systems, Inc. and others. All rights reserved. + * + * This program and the accompanying materials are made available under the + * terms of the Eclipse Public License v1.0 which accompanies this distribution, + * and is available at http://www.eclipse.org/legal/epl-v10.html + */ + +package org.opendaylight.groupbasedpolicy.api; + +import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.BaseEndpointService; +import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.endpoints.address.endpoints.AddressEndpoint; +import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.endpoints.containment.endpoints.ContainmentEndpoint; +import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.register.endpoint.input.AddressEndpointReg; +import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.register.endpoint.input.ContainmentEndpointReg; +import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.renderer.policy.configuration.endpoints.AddressEndpointWithLocation; +import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.renderer.policy.configuration.endpoints.ContainmentEndpointWithLocation; +import org.opendaylight.yangtools.yang.binding.Augmentation; + +import javax.annotation.Nullable; +import java.util.Map; + +/** + * Provides translation for endpoint augmentation + */ +public interface EndpointAugmentor { + + /** + * Creates pair of {@link AddressEndpoint} augmentation. Augmentation is domain specific. Result + * is used for translation from {@link AddressEndpointReg} to {@link AddressEndpoint} + * + * @param input {@link AddressEndpointReg} as part of RPC input + * {@link BaseEndpointService#registerEndpoint(org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.RegisterEndpointInput)} + * @return translated input to {@link AddressEndpoint} + */ + @Nullable + Map.Entry>, Augmentation> buildAddressEndpointAugmentation( + AddressEndpointReg input); + + /** + * Creates pair of {@link ContainmentEndpoint} augmentation. Augmentation is domain specific. + * Result is used for translation from {@link ContainmentEndpointReg} to + * {@link ContainmentEndpoint} + * + * @param input {@link ContainmentEndpointReg} as part of RPC input + * {@link BaseEndpointService#registerEndpoint(org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.RegisterEndpointInput)} + * @return translated input to {@link ContainmentEndpoint} + */ + @Nullable + Map.Entry>, Augmentation> buildContainmentEndpointAugmentation( + ContainmentEndpointReg input); + + /** + * Creates pair of {@link AddressEndpointWithLocation} augmentation. Augmentation is domain + * specific. Result is used for translation from {@link AddressEndpoint} to + * {@link AddressEndpointWithLocation} + * + * @param input {@link AddressEndpoint} + * @return translated input to {@link AddressEndpointWithLocation} + */ + @Nullable + Map.Entry>, Augmentation> buildAddressEndpointWithLocationAugmentation( + AddressEndpoint input); + + /** + * Creates pair of {@link ContainmentEndpointWithLocation} augmentation. Augmentation is domain + * specific. Result is used for translation from {@link ContainmentEndpoint} to + * {@link ContainmentEndpointWithLocation} + * + * @param input {@link ContainmentEndpoint} + * @return translated input to {@link ContainmentEndpointWithLocation} + */ + @Nullable + Map.Entry>, Augmentation> buildContainmentEndpointWithLocationAugmentation( + ContainmentEndpoint input); +} diff --git a/groupbasedpolicy/src/main/java/org/opendaylight/groupbasedpolicy/api/EndpointAugmentorRegistry.java b/groupbasedpolicy/src/main/java/org/opendaylight/groupbasedpolicy/api/EndpointAugmentorRegistry.java new file mode 100644 index 000000000..0cfadcebc --- /dev/null +++ b/groupbasedpolicy/src/main/java/org/opendaylight/groupbasedpolicy/api/EndpointAugmentorRegistry.java @@ -0,0 +1,29 @@ +/* + * Copyright (c) 2016 Cisco Systems, Inc. and others. All rights reserved. + * + * This program and the accompanying materials are made available under the + * terms of the Eclipse Public License v1.0 which accompanies this distribution, + * and is available at http://www.eclipse.org/legal/epl-v10.html + */ + +package org.opendaylight.groupbasedpolicy.api; + +public interface EndpointAugmentorRegistry { + + /** + * Registers domain specific endpoint augmentor + * + * @param endpointAugmentor cannot be {@code null} + * @throws NullPointerException if endpointAugmentor is {@code null} + */ + void register(EndpointAugmentor endpointAugmentor); + + /** + * Unregisters domain specific endpoint augmentor + * + * @param endpointAugmentor cannot be {@code null} + * @throws NullPointerException if endpointAugmentor is {@code null} + */ + void unregister(EndpointAugmentor endpointAugmentor); + +} diff --git a/groupbasedpolicy/src/main/java/org/opendaylight/groupbasedpolicy/api/EpRendererAugmentation.java b/groupbasedpolicy/src/main/java/org/opendaylight/groupbasedpolicy/api/EpRendererAugmentation.java index 9090b97b0..4bd64e202 100644 --- a/groupbasedpolicy/src/main/java/org/opendaylight/groupbasedpolicy/api/EpRendererAugmentation.java +++ b/groupbasedpolicy/src/main/java/org/opendaylight/groupbasedpolicy/api/EpRendererAugmentation.java @@ -18,6 +18,7 @@ import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.endpoint.r import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.endpoint.rev140421.endpoints.EndpointL3Prefix; import org.opendaylight.yangtools.yang.binding.Augmentation; +@Deprecated public interface EpRendererAugmentation { /** diff --git a/groupbasedpolicy/src/main/java/org/opendaylight/groupbasedpolicy/api/EpRendererAugmentationRegistry.java b/groupbasedpolicy/src/main/java/org/opendaylight/groupbasedpolicy/api/EpRendererAugmentationRegistry.java index be838a3f6..ca299810d 100644 --- a/groupbasedpolicy/src/main/java/org/opendaylight/groupbasedpolicy/api/EpRendererAugmentationRegistry.java +++ b/groupbasedpolicy/src/main/java/org/opendaylight/groupbasedpolicy/api/EpRendererAugmentationRegistry.java @@ -8,6 +8,7 @@ package org.opendaylight.groupbasedpolicy.api; +@Deprecated public interface EpRendererAugmentationRegistry { /** diff --git a/groupbasedpolicy/src/main/java/org/opendaylight/groupbasedpolicy/api/NetworkDomainAugmentor.java b/groupbasedpolicy/src/main/java/org/opendaylight/groupbasedpolicy/api/NetworkDomainAugmentor.java new file mode 100644 index 000000000..0c7931616 --- /dev/null +++ b/groupbasedpolicy/src/main/java/org/opendaylight/groupbasedpolicy/api/NetworkDomainAugmentor.java @@ -0,0 +1,36 @@ +/* + * Copyright (c) 2016 Cisco Systems, Inc. and others. All rights reserved. + * + * This program and the accompanying materials are made available under the + * terms of the Eclipse Public License v1.0 which accompanies this distribution, + * and is available at http://www.eclipse.org/legal/epl-v10.html + */ + +package org.opendaylight.groupbasedpolicy.api; + +import java.util.Map; + +import javax.annotation.Nullable; + +import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.forwarding.rev160427.forwarding.forwarding.by.tenant.NetworkDomain; +import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.renderer.policy.configuration.renderer.forwarding.renderer.forwarding.by.tenant.RendererNetworkDomain; +import org.opendaylight.yangtools.yang.binding.Augmentation; + +/** + * Provides translation for forwarding augmentation + */ +public interface NetworkDomainAugmentor { + + /** + * Creates pair of {@link RendererNetworkDomain} augmentation. Augmentation is domain + * specific. Result is used for translation from {@link NetworkDomain} to + * {@link RendererNetworkDomain} + * + * @param input {@link NetworkDomain} + * @return translated input to {@link RendererNetworkDomain} + */ + @Nullable + Map.Entry>, Augmentation> buildRendererNetworkDomainAugmentation( + NetworkDomain input); + +} diff --git a/groupbasedpolicy/src/main/java/org/opendaylight/groupbasedpolicy/api/NetworkDomainAugmentorRegistry.java b/groupbasedpolicy/src/main/java/org/opendaylight/groupbasedpolicy/api/NetworkDomainAugmentorRegistry.java new file mode 100644 index 000000000..e69ffaa6f --- /dev/null +++ b/groupbasedpolicy/src/main/java/org/opendaylight/groupbasedpolicy/api/NetworkDomainAugmentorRegistry.java @@ -0,0 +1,29 @@ +/* + * Copyright (c) 2016 Cisco Systems, Inc. and others. All rights reserved. + * + * This program and the accompanying materials are made available under the + * terms of the Eclipse Public License v1.0 which accompanies this distribution, + * and is available at http://www.eclipse.org/legal/epl-v10.html + */ + +package org.opendaylight.groupbasedpolicy.api; + +public interface NetworkDomainAugmentorRegistry { + + /** + * Registers domain specific network domain augmentor + * + * @param netDomainAugmentor cannot be {@code null} + * @throws NullPointerException if netDomainAugmentor is {@code null} + */ + void register(NetworkDomainAugmentor netDomainAugmentor); + + /** + * Unregisters domain specific network domain augmentor + * + * @param netDomainAugmentor cannot be {@code null} + * @throws NullPointerException if netDomainAugmentor is {@code null} + */ + void unregister(NetworkDomainAugmentor netDomainAugmentor); + +} diff --git a/groupbasedpolicy/src/main/java/org/opendaylight/groupbasedpolicy/base_endpoint/BaseEndpointRpcRegistry.java b/groupbasedpolicy/src/main/java/org/opendaylight/groupbasedpolicy/base_endpoint/BaseEndpointRpcRegistry.java deleted file mode 100644 index 899e29e8b..000000000 --- a/groupbasedpolicy/src/main/java/org/opendaylight/groupbasedpolicy/base_endpoint/BaseEndpointRpcRegistry.java +++ /dev/null @@ -1,658 +0,0 @@ -/* - * Copyright (c) 2016 Cisco Systems, Inc. and others. All rights reserved. - * - * This program and the accompanying materials are made available under the - * terms of the Eclipse Public License v1.0 which accompanies this distribution, - * and is available at http://www.eclipse.org/legal/epl-v10.html - */ - -package org.opendaylight.groupbasedpolicy.base_endpoint; - -import com.google.common.base.Function; -import com.google.common.base.Optional; -import com.google.common.base.Preconditions; -import com.google.common.util.concurrent.Futures; -import com.google.common.util.concurrent.ListenableFuture; -import org.opendaylight.controller.md.sal.binding.api.DataBroker; -import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction; -import org.opendaylight.controller.md.sal.binding.api.ReadTransaction; -import org.opendaylight.controller.md.sal.binding.api.WriteTransaction; -import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType; -import org.opendaylight.controller.sal.binding.api.BindingAwareBroker; -import org.opendaylight.controller.sal.binding.api.RpcProviderRegistry; -import org.opendaylight.groupbasedpolicy.api.BaseEndpointRendererAugmentation; -import org.opendaylight.groupbasedpolicy.api.BaseEndpointRendererAugmentationRegistry; -import org.opendaylight.groupbasedpolicy.util.DataStoreHelper; -import org.opendaylight.groupbasedpolicy.util.IidFactory; -import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.BaseEndpointService; -import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.RegisterEndpointInput; -import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.UnregisterEndpointInput; -import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.endpoints.address.endpoints.AddressEndpoint; -import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.endpoints.address.endpoints.AddressEndpointBuilder; -import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.endpoints.address.endpoints.AddressEndpointKey; -import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.endpoints.containment.endpoints.ContainmentEndpoint; -import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.endpoints.containment.endpoints.ContainmentEndpointBuilder; -import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.endpoints.containment.endpoints.ContainmentEndpointKey; -import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.has.child.endpoints.ChildEndpoint; -import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.has.child.endpoints.ChildEndpointBuilder; -import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.parent.child.endpoints.ParentEndpointChoice; -import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.parent.child.endpoints.parent.endpoint.choice.ParentContainmentEndpointCase; -import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.parent.child.endpoints.parent.endpoint.choice.ParentContainmentEndpointCaseBuilder; -import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.parent.child.endpoints.parent.endpoint.choice.ParentEndpointCase; -import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.parent.child.endpoints.parent.endpoint.choice.ParentEndpointCaseBuilder; -import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.parent.child.endpoints.parent.endpoint.choice.parent.containment.endpoint._case.ParentContainmentEndpoint; -import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.parent.child.endpoints.parent.endpoint.choice.parent.containment.endpoint._case.ParentContainmentEndpointBuilder; -import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.parent.child.endpoints.parent.endpoint.choice.parent.endpoint._case.ParentEndpoint; -import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.parent.child.endpoints.parent.endpoint.choice.parent.endpoint._case.ParentEndpointBuilder; -import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.register.endpoint.input.AddressEndpointReg; -import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.register.endpoint.input.AddressEndpointRegKey; -import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.register.endpoint.input.ContainmentEndpointReg; -import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.register.endpoint.input.ContainmentEndpointRegKey; -import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.unregister.endpoint.input.AddressEndpointUnreg; -import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.unregister.endpoint.input.ContainmentEndpointUnreg; -import org.opendaylight.yangtools.yang.binding.Augmentation; -import org.opendaylight.yangtools.yang.common.RpcError; -import org.opendaylight.yangtools.yang.common.RpcResult; -import org.opendaylight.yangtools.yang.common.RpcResultBuilder; -import org.slf4j.Logger; -import org.slf4j.LoggerFactory; - -import java.util.ArrayList; -import java.util.Collections; -import java.util.List; -import java.util.Map; -import java.util.concurrent.ConcurrentHashMap; -import java.util.concurrent.ConcurrentMap; -import java.util.concurrent.Future; - -import javax.annotation.Nullable; - -public class BaseEndpointRpcRegistry - implements BaseEndpointService, BaseEndpointRendererAugmentationRegistry, AutoCloseable { - - static final ConcurrentMap registeredRenderers = - new ConcurrentHashMap<>(); - private static final Logger LOG = LoggerFactory.getLogger(BaseEndpointRpcRegistry.class); - private final DataBroker dataProvider; - private final BindingAwareBroker.RpcRegistration rpcRegistration; - - private Function> futureTrans = new Function>() { - - @Override - public RpcResult apply(Void input) { - return RpcResultBuilder.success().build(); - } - }; - - public BaseEndpointRpcRegistry(DataBroker dataProvider, RpcProviderRegistry rpcRegistry) { - Preconditions.checkNotNull(dataProvider); - Preconditions.checkNotNull(rpcRegistry); - - this.dataProvider = dataProvider; - this.rpcRegistration = rpcRegistry.addRpcImplementation(BaseEndpointService.class, this); - } - - /** - * Registers renderer's endpoints augmentation. - * - * @param baseEndpointRendererAugmentation cannot be {@code null} - * @throws NullPointerException - */ - @Override - public void register(BaseEndpointRendererAugmentation baseEndpointRendererAugmentation) { - if (baseEndpointRendererAugmentation != null) { - registeredRenderers.putIfAbsent(baseEndpointRendererAugmentation.getClass().getName(), - baseEndpointRendererAugmentation); - LOG.info("Registered {}", baseEndpointRendererAugmentation.getClass().getName()); - } - } - - /** - * Unregisters renderer's endpoints augmentation. - * - * @param baseEndpointRendererAugmentation cannot be {@code null} - * @throws NullPointerException - */ - @Override - public void unregister(BaseEndpointRendererAugmentation baseEndpointRendererAugmentation) { - if (baseEndpointRendererAugmentation == null - || !registeredRenderers.containsKey(baseEndpointRendererAugmentation.getClass().getName())) { - return; - } - registeredRenderers.remove(baseEndpointRendererAugmentation.getClass().getName()); - LOG.info("Unregistered {}", baseEndpointRendererAugmentation.getClass().getName()); - } - - /** - * Register a new endpoint into the registry. If there is already an existing - * endpoint with the same keys, they will be overwritten with the new information. - * - * @param input Endpoint to register - */ - @Override - public Future> registerEndpoint(RegisterEndpointInput input) { - long timestamp = System.currentTimeMillis(); - - WriteTransaction t = dataProvider.newWriteOnlyTransaction(); - - List endpoints = input.getContainmentEndpointReg(); - ListenableFuture> failResult = verifyRegisterEndpointInput(input); - if (failResult == null) { - for (ContainmentEndpointReg ce : nullToEmpty(endpoints)) { - long stamp = (ce.getTimestamp() == null || ce.getTimestamp() == 0) ? timestamp : ce.getTimestamp(); - ContainmentEndpoint endpoint = buildContainmentEndpoint(ce).setTimestamp(stamp).build(); - t.put(LogicalDatastoreType.OPERATIONAL, IidFactory.containmentEndpointIid(endpoint.getKey()), endpoint, - true); - - updateContainmentEndpointRegChilds(t, endpoint); - } - - List addressEndpoints = input.getAddressEndpointReg(); - for (AddressEndpointReg ae : nullToEmpty(addressEndpoints)) { - long stamp = (ae.getTimestamp() == null || ae.getTimestamp() == 0) ? timestamp : ae.getTimestamp(); - AddressEndpoint endpoint = buildAddressEndpoint(ae).setTimestamp(stamp).build(); - t.put(LogicalDatastoreType.OPERATIONAL, IidFactory.addressEndpointIid(endpoint.getKey()), endpoint, - true); - - updateAddressEndpointRegChilds(t, endpoint); - - updateAddressEndpointRegParents(t, endpoint); - } - } else { - return failResult; - } - - ListenableFuture r = t.submit(); - return Futures.transform(r, futureTrans); - } - - private void updateContainmentEndpointRegChilds(WriteTransaction t, ContainmentEndpoint containmentEndpoint) { - ReadOnlyTransaction readTransaction = dataProvider.newReadOnlyTransaction(); - - for (ChildEndpoint child : nullToEmpty(containmentEndpoint.getChildEndpoint())) { - AddressEndpointKey key = new AddressEndpointKey(child.getAddress(), child.getAddressType(), - child.getContextId(), child.getContextType()); - Optional addressEndpointOptional = DataStoreHelper - .readFromDs(LogicalDatastoreType.OPERATIONAL, IidFactory.addressEndpointIid(key), readTransaction); - - if (addressEndpointOptional.isPresent()) { - ParentEndpointChoice parentEndpointChoice = addressEndpointOptional.get().getParentEndpointChoice(); - List parentContainmentEndpoints = - getParentContainmentEndpoints(parentEndpointChoice); - - ParentContainmentEndpoint parentContainmentEndpoint = - new ParentContainmentEndpointBuilder().setContextId(containmentEndpoint.getContextId()) - .setContextType(containmentEndpoint.getContextType()) - .build(); - - if (!nullToEmpty(parentContainmentEndpoints).contains(parentContainmentEndpoint)) { - parentContainmentEndpoints.add(parentContainmentEndpoint); - AddressEndpoint updatedAddressEndpoint = new AddressEndpointBuilder(addressEndpointOptional.get()) - .setParentEndpointChoice(new ParentContainmentEndpointCaseBuilder() - .setParentContainmentEndpoint(parentContainmentEndpoints).build()) - .build(); - - t.put(LogicalDatastoreType.OPERATIONAL, IidFactory.addressEndpointIid(key), updatedAddressEndpoint); - } - } - } - } - - private ListenableFuture> verifyRegisterEndpointInput(RegisterEndpointInput input) { - ListenableFuture> result; - List addressEndpointRegs = nullToEmpty(input.getAddressEndpointReg()); - List containmentEndpointRegs = nullToEmpty(input.getContainmentEndpointReg()); - - for (AddressEndpointReg addressEndpointReg : nullToEmpty(addressEndpointRegs)) { - result = verifyAddressEndpointChilds(addressEndpointRegs, addressEndpointReg); - if (result != null) { - return result; - } - - result = verifyAddressEndpointParents(addressEndpointRegs, addressEndpointReg); - if (result != null) { - return result; - } - } - - result = verifyContainmentEndpointChilds(addressEndpointRegs, containmentEndpointRegs); - if (result != null) { - return result; - } - - return null; - } - - private ListenableFuture> verifyContainmentEndpointChilds( - List addressEndpointRegs, List containmentEndpointRegs) { - for (ContainmentEndpointReg containmentEndpointReg : nullToEmpty(containmentEndpointRegs)) { - for (ChildEndpoint childEndpoint : nullToEmpty(containmentEndpointReg.getChildEndpoint())) { - AddressEndpointRegKey key = new AddressEndpointRegKey(childEndpoint.getAddress(), - childEndpoint.getAddressType(), childEndpoint.getContextId(), childEndpoint.getContextType()); - AddressEndpointReg addressEndpointRegChild = findAddressEndpointReg(key, addressEndpointRegs); - if (addressEndpointRegChild == null) { - // todo this can be optimized if we move this to - // updateContainmentEndpointRegChilds and verify child in one step with update. - Optional addressEndpointOptional = - DataStoreHelper.readFromDs(LogicalDatastoreType.OPERATIONAL, - IidFactory.addressEndpointIid(new AddressEndpointKey(key.getAddress(), - key.getAddressType(), key.getContextId(), key.getContextType())), - dataProvider.newReadOnlyTransaction()); - if (!addressEndpointOptional.isPresent()) { - LOG.debug("Child AddressEndpoint {} does not exist in RPC and DS.", childEndpoint); - return buildFailFeature( - String.format("Child AddressEndpoint %s does not exist in RPC and DS.", childEndpoint)); - } - } else { - - if (!containmentEndpointReg.getKey().equals(new ContainmentEndpointRegKey( - addressEndpointRegChild.getContextId(), addressEndpointRegChild.getContextType()))) { - LOG.debug( - "Child AddressEndpoint {} in ContainmentEndpoint->ChildEndpoints does not contain a valid ContainmentEndpointRegKey.", - addressEndpointRegChild); - return buildFailFeature(String - .format("AddressEndpoint in ContainmentEndpoint->ChildEndpoints does not contain a valid ContainmentEndpointRegKey." - + "\nChild element: %s", addressEndpointRegChild)); - } - } - } - } - return null; - } - - private ListenableFuture> verifyAddressEndpointParents(List addressEndpointRegs, - AddressEndpointReg addressEndpointReg) { - ParentEndpointChoice parentEndpointChoice = addressEndpointReg.getParentEndpointChoice(); - List parentEndpoints; - parentEndpoints = - (parentEndpointChoice instanceof ParentEndpointCase) ? ((ParentEndpointCase) parentEndpointChoice) - .getParentEndpoint() : null; - - for (ParentEndpoint parentEndpoint : nullToEmpty(parentEndpoints)) { - AddressEndpointRegKey key = new AddressEndpointRegKey(parentEndpoint.getAddress(), - parentEndpoint.getAddressType(), parentEndpoint.getContextId(), parentEndpoint.getContextType()); - AddressEndpointReg addressEndpointRegParent = findAddressEndpointReg(key, addressEndpointRegs); - - if (addressEndpointRegParent == null) { - // todo this can be optimized if we move this to updateAddressEndpointRegParents and - // verify child in one step with update. - Optional addressEndpointOptional = - DataStoreHelper.readFromDs(LogicalDatastoreType.OPERATIONAL, - IidFactory.addressEndpointIid(new AddressEndpointKey(key.getAddress(), - key.getAddressType(), key.getContextId(), key.getContextType())), - dataProvider.newReadOnlyTransaction()); - if (!addressEndpointOptional.isPresent()) { - LOG.debug("Parent AddressEndpoint {} does not exist in RPC and DS.", parentEndpoint); - return buildFailFeature( - String.format("Parent AddressEndpoint %s does not exist in RPC and DS.", parentEndpoint)); - } - } else { - - List childEndpoints = addressEndpointRegParent.getChildEndpoint(); - - if (!nullToEmpty(childEndpoints).contains(new ChildEndpointBuilder(addressEndpointReg).build())) { - LOG.debug("Parent AddressEndpoint {} does not contain a valid child AddressEndpoint.", - addressEndpointRegParent); - return buildFailFeature(String.format( - "Parent AddressEndpoint does not contain a valid child AddressEndpoint." - + "\nParent AddressEndpoint: %s" + "\nChild AddressEndpoint: %s", - addressEndpointRegParent, addressEndpointReg)); - } - } - } - return null; - } - - private ListenableFuture> verifyAddressEndpointChilds(List addressEndpointRegs, - AddressEndpointReg addressEndpointReg) { - for (ChildEndpoint childEndpoint : nullToEmpty(addressEndpointReg.getChildEndpoint())) { - AddressEndpointRegKey key = new AddressEndpointRegKey(childEndpoint.getAddress(), - childEndpoint.getAddressType(), childEndpoint.getContextId(), childEndpoint.getContextType()); - AddressEndpointReg addressEndpointRegChild = findAddressEndpointReg(key, addressEndpointRegs); - if (addressEndpointRegChild == null) { - // todo this can be optimized if we move this to updateAddressEndpointRegChilds and - // verify child in one step with update. - Optional addressEndpointOptional = - DataStoreHelper.readFromDs(LogicalDatastoreType.OPERATIONAL, - IidFactory.addressEndpointIid(new AddressEndpointKey(key.getAddress(), - key.getAddressType(), key.getContextId(), key.getContextType())), - dataProvider.newReadOnlyTransaction()); - if (!addressEndpointOptional.isPresent()) { - LOG.debug("Child AddressEndpoint {} does not exist in RPC and DS.", childEndpoint); - return buildFailFeature( - String.format("Child AddressEndpoint %s does not exist in RPC and DS.", childEndpoint)); - } - } else { - - ParentEndpointChoice parentEndpointChoice = addressEndpointRegChild.getParentEndpointChoice(); - - if (!(parentEndpointChoice instanceof ParentEndpointCase)) { - LOG.debug("Child AddressEndpoint {} does not contain list of parent elements.", childEndpoint); - return buildFailFeature(String.format( - "Child AddressEndpoint does not contain list of parent elements." + "\nChild element: %s", - childEndpoint)); - } - - List parentEndpoints = - nullToEmpty(((ParentEndpointCase) parentEndpointChoice).getParentEndpoint()); - if (!parentEndpoints.contains(new ParentEndpointBuilder(addressEndpointReg).build())) { - LOG.debug("Child AddressEndpoint {} does not contain a valid parent AddressEndpoint.", - addressEndpointRegChild); - return buildFailFeature(String.format( - "Child AddressEndpoint does not contain a valid parent AddressEndpoint." - + "\nChild element: %s" + "\nparent AddressEndpoint: %s", - addressEndpointRegChild, addressEndpointReg)); - } - } - } - return null; - } - - private AddressEndpointReg findAddressEndpointReg(AddressEndpointRegKey key, List addressEndpointRegs) { - for (AddressEndpointReg addressEndpointReg : addressEndpointRegs) { - if (addressEndpointReg.getKey().equals(key)) { - return addressEndpointReg; - } - } - return null; - } - - private void updateAddressEndpointRegParents(WriteTransaction t, AddressEndpoint endpoint) { - ParentEndpointCase parentEndpointCase = (ParentEndpointCase) endpoint.getParentEndpointChoice(); - List parentEndpoints; - ReadOnlyTransaction readTransaction = dataProvider.newReadOnlyTransaction(); - - parentEndpoints = getParentEndpoints(parentEndpointCase); - - for (ParentEndpoint parent : nullToEmpty(parentEndpoints)) { - Optional addressEndpointOptional = - DataStoreHelper.readFromDs(LogicalDatastoreType.OPERATIONAL, - IidFactory.addressEndpointIid(new AddressEndpointKey(parent.getAddress(), - parent.getAddressType(), parent.getContextId(), parent.getContextType())), - readTransaction); - - if (addressEndpointOptional.isPresent()) { - - List childEndpoints; - - childEndpoints = (addressEndpointOptional.get() == null || addressEndpointOptional.get() - .getChildEndpoint() == null) ? new ArrayList<>() : addressEndpointOptional.get().getChildEndpoint(); - - ChildEndpoint childEndpoint = new ChildEndpointBuilder(endpoint).build(); - if (!childEndpoints.contains(childEndpoint)) { - childEndpoints.add(childEndpoint); - AddressEndpoint parentAddressEndpoint = new AddressEndpointBuilder(addressEndpointOptional.get()) - .setChildEndpoint(childEndpoints).build(); - t.put(LogicalDatastoreType.OPERATIONAL, - IidFactory.addressEndpointIid(parentAddressEndpoint.getKey()), parentAddressEndpoint); - } - } - } - } - - private void updateAddressEndpointRegChilds(WriteTransaction t, AddressEndpoint endpoint) { - ReadTransaction readTransaction = dataProvider.newReadOnlyTransaction(); - - for (ChildEndpoint child : nullToEmpty(endpoint.getChildEndpoint())) { - Optional addressEndpointOptional = - DataStoreHelper.readFromDs(LogicalDatastoreType.OPERATIONAL, - IidFactory.addressEndpointIid(new AddressEndpointKey(child.getAddress(), - child.getAddressType(), child.getContextId(), child.getContextType())), - readTransaction); - - if (addressEndpointOptional.isPresent()) { - ParentEndpointCase parentEndpointCase = - (ParentEndpointCase) addressEndpointOptional.get().getParentEndpointChoice(); - List parentEndpoints; - - parentEndpoints = getParentEndpoints(parentEndpointCase); - - ParentEndpoint parentEndpoint = new ParentEndpointBuilder(endpoint).build(); - if (!parentEndpoints.contains(parentEndpoint)) { - parentEndpoints.add(parentEndpoint); - AddressEndpoint childAddressEndpoint = - new AddressEndpointBuilder(addressEndpointOptional.get()) - .setParentEndpointChoice( - new ParentEndpointCaseBuilder().setParentEndpoint(parentEndpoints).build()) - .build(); - t.put(LogicalDatastoreType.OPERATIONAL, - IidFactory.addressEndpointIid(childAddressEndpoint.getKey()), childAddressEndpoint); - } - } - } - } - - private ContainmentEndpointBuilder buildContainmentEndpoint(ContainmentEndpointReg input) { - - ContainmentEndpointBuilder eb = new ContainmentEndpointBuilder().setChildEndpoint(input.getChildEndpoint()) - .setCondition(input.getCondition()) - .setContextType(input.getContextType()) - .setContextId(input.getContextId()) - .setEndpointGroup(input.getEndpointGroup()) - .setKey(new ContainmentEndpointKey(input.getContextId(), input.getContextType())) - .setNetworkContainment(input.getNetworkContainment()) - .setTenant(input.getTenant()) - .setTimestamp(input.getTimestamp()) - .setChildEndpoint(input.getChildEndpoint()); - - for (Map.Entry entry : registeredRenderers.entrySet()) { - try { - Map.Entry>, Augmentation> augmentationEntry = - entry.getValue().buildContainmentEndpointAugmentation(input); - if (augmentationEntry != null) { - eb.addAugmentation(augmentationEntry.getKey(), augmentationEntry.getValue()); - } - } catch (Exception e) { - LOG.warn("AddressEndpoint Augmentation error while processing " + entry.getKey() + ". Reason: ", e); - } - } - return eb; - } - - private AddressEndpointBuilder buildAddressEndpoint(AddressEndpointReg ae) { - AddressEndpointBuilder builder = new AddressEndpointBuilder().setTenant(ae.getTenant()) - .setNetworkContainment(ae.getNetworkContainment()) - .setEndpointGroup(ae.getEndpointGroup()) - .setAddress(ae.getAddress()) - .setAddressType(ae.getAddressType()) - .setChildEndpoint(ae.getChildEndpoint()) - .setCondition(ae.getCondition()) - .setKey(new AddressEndpointKey(ae.getAddress(), ae.getAddressType(), ae.getContextId(), - ae.getContextType())) - .setParentEndpointChoice(ae.getParentEndpointChoice()) - .setTimestamp(ae.getTimestamp()) - .setContextId(ae.getContextId()) - .setContextType(ae.getContextType()) - .setTenant(ae.getTenant()); - - for (Map.Entry entry : registeredRenderers.entrySet()) { - try { - Map.Entry>, Augmentation> augmentationEntry = - entry.getValue().buildAddressEndpointAugmentation(ae); - if (augmentationEntry != null) { - builder.addAugmentation(augmentationEntry.getKey(), augmentationEntry.getValue()); - } - } catch (Exception e) { - LOG.warn("AddressEndpoint Augmentation error while processing " + entry.getKey() + ". Reason: ", e); - } - } - return builder; - } - - /** - * Unregister an endpoint or endpoints from the registry. - * - * @param input Endpoint/endpoints to unregister - */ - @Override - public Future> unregisterEndpoint(UnregisterEndpointInput input) { - WriteTransaction t = dataProvider.newWriteOnlyTransaction(); - - List addressEndpoints = input.getAddressEndpointUnreg(); - for (AddressEndpointUnreg ae : nullToEmpty(addressEndpoints)) { - AddressEndpointKey key = new AddressEndpointKey(ae.getAddress(), ae.getAddressType(), ae.getContextId(), - ae.getContextType()); - t.delete(LogicalDatastoreType.OPERATIONAL, IidFactory.addressEndpointIid(key)); - - updateAddressEndpointUnregChilds(t, ae); - - updateAddressEndpointUnregParents(t, ae); - } - - List endpoints = input.getContainmentEndpointUnreg(); - for (ContainmentEndpointUnreg ce : nullToEmpty(endpoints)) { - ContainmentEndpointKey key = new ContainmentEndpointKey(ce.getContextId(), ce.getContextType()); - t.delete(LogicalDatastoreType.OPERATIONAL, IidFactory.containmentEndpointIid(key)); - - updateContainmentEndpointUnregChilds(t, ce); - } - - ListenableFuture r = t.submit(); - return Futures.transform(r, futureTrans); - } - - private void updateAddressEndpointUnregParents(WriteTransaction t, AddressEndpointUnreg ae) { - ReadTransaction readTransaction = dataProvider.newReadOnlyTransaction(); - - Optional addressEndpointOptional = DataStoreHelper.readFromDs(LogicalDatastoreType.OPERATIONAL, - IidFactory.addressEndpointIid(new AddressEndpointKey(ae.getAddress(), ae.getAddressType(), - ae.getContextId(), ae.getContextType())), - readTransaction); - - if (addressEndpointOptional.isPresent()) { - ParentEndpointCase parentEndpointCase = - (ParentEndpointCase) addressEndpointOptional.get().getParentEndpointChoice(); - List parentEndpoints; - - parentEndpoints = getParentEndpoints(parentEndpointCase); - - for (ParentEndpoint parentEndpoint : parentEndpoints) { - Optional parentAddressEndpointOptional = - DataStoreHelper.readFromDs(LogicalDatastoreType.OPERATIONAL, - IidFactory.addressEndpointIid(new AddressEndpointKey(parentEndpoint.getAddress(), - parentEndpoint.getAddressType(), parentEndpoint.getContextId(), - parentEndpoint.getContextType())), - readTransaction); - - AddressEndpoint parent = - parentAddressEndpointOptional.isPresent() ? parentAddressEndpointOptional.get() : null; - - ChildEndpoint endpointToRemove = new ChildEndpointBuilder(addressEndpointOptional.get()).build(); - - if (parent != null && nullToEmpty(parent.getChildEndpoint()).contains(endpointToRemove)) { - parent.getChildEndpoint().remove(endpointToRemove); - t.put(LogicalDatastoreType.OPERATIONAL, IidFactory.addressEndpointIid(parent.getKey()), parent); - } - - } - } - } - - private void updateAddressEndpointUnregChilds(WriteTransaction t, AddressEndpointUnreg ae) { - ReadTransaction readTransaction = dataProvider.newReadOnlyTransaction(); - - Optional addressEndpointOptional = DataStoreHelper.readFromDs(LogicalDatastoreType.OPERATIONAL, - IidFactory.addressEndpointIid(new AddressEndpointKey(ae.getAddress(), ae.getAddressType(), - ae.getContextId(), ae.getContextType())), - readTransaction); - - if (addressEndpointOptional.isPresent()) { - AddressEndpoint endpoint = addressEndpointOptional.get(); - List childEndpoints = endpoint.getChildEndpoint(); - - for (ChildEndpoint childEndpoint : nullToEmpty(childEndpoints)) { - Optional childAddressEndpointOptional = - DataStoreHelper.readFromDs(LogicalDatastoreType.OPERATIONAL, - IidFactory.addressEndpointIid(new AddressEndpointKey(childEndpoint.getAddress(), - childEndpoint.getAddressType(), childEndpoint.getContextId(), - childEndpoint.getContextType())), - readTransaction); - - AddressEndpoint child = - childAddressEndpointOptional.isPresent() ? childAddressEndpointOptional.get() : null; - ParentEndpointCase parentEndpointCase = - (child != null) ? (ParentEndpointCase) child.getParentEndpointChoice() : null; - List parentEndpoints; - - parentEndpoints = getParentEndpoints(parentEndpointCase); - - ParentEndpoint endpointToRemove = new ParentEndpointBuilder(endpoint).build(); - - if (child != null && nullToEmpty(parentEndpoints).contains(endpointToRemove)) { - parentEndpoints.remove(endpointToRemove); - AddressEndpoint newChild = - new AddressEndpointBuilder(child) - .setParentEndpointChoice( - new ParentEndpointCaseBuilder().setParentEndpoint(parentEndpoints).build()) - .build(); - - t.put(LogicalDatastoreType.OPERATIONAL, IidFactory.addressEndpointIid(newChild.getKey()), newChild); - } - } - } - } - - private void updateContainmentEndpointUnregChilds(WriteTransaction t, - ContainmentEndpointUnreg containmentEndpointUnreg) { - ReadOnlyTransaction readTransaction = dataProvider.newReadOnlyTransaction(); - - ContainmentEndpointKey key = new ContainmentEndpointKey(containmentEndpointUnreg.getContextId(), - containmentEndpointUnreg.getContextType()); - Optional containmentEndpointOptional = DataStoreHelper - .readFromDs(LogicalDatastoreType.OPERATIONAL, IidFactory.containmentEndpointIid(key), readTransaction); - - if (!containmentEndpointOptional.isPresent()) { - return; - } - - for (ChildEndpoint child : nullToEmpty(containmentEndpointOptional.get().getChildEndpoint())) { - AddressEndpointKey aeKey = new AddressEndpointKey(child.getAddress(), child.getAddressType(), - child.getContextId(), child.getContextType()); - Optional addressEndpointOptional = DataStoreHelper - .readFromDs(LogicalDatastoreType.OPERATIONAL, IidFactory.addressEndpointIid(aeKey), readTransaction); - - if (addressEndpointOptional.isPresent()) { - ParentEndpointChoice parentEndpointChoice = addressEndpointOptional.get().getParentEndpointChoice(); - List parentContainmentEndpoints; - parentContainmentEndpoints = getParentContainmentEndpoints(parentEndpointChoice); - - ParentContainmentEndpoint parentContainmentEndpoint = - new ParentContainmentEndpointBuilder().setContextId(containmentEndpointUnreg.getContextId()) - .setContextType(containmentEndpointUnreg.getContextType()) - .build(); - if (nullToEmpty(parentContainmentEndpoints).contains(parentContainmentEndpoint)) { - t.delete(LogicalDatastoreType.OPERATIONAL, - IidFactory.parentContainmentEndpointIid(aeKey, parentContainmentEndpoint.getKey())); - } - } - } - } - - private List getParentContainmentEndpoints(ParentEndpointChoice parentEndpointChoice) { - return (parentEndpointChoice instanceof ParentContainmentEndpointCase) ? ((ParentContainmentEndpointCase) parentEndpointChoice) - .getParentContainmentEndpoint() : new ArrayList<>(); - } - - private List getParentEndpoints(ParentEndpointCase parentEndpointCase) { - return (parentEndpointCase == null - || parentEndpointCase.getParentEndpoint() == null) ? new ArrayList<>() : parentEndpointCase - .getParentEndpoint(); - } - - private ListenableFuture> buildFailFeature(String message) { - return Futures - .immediateFuture(RpcResultBuilder.failed().withError(RpcError.ErrorType.PROTOCOL, message).build()); - } - - @Override - public void close() throws Exception { - if (rpcRegistration != null) { - rpcRegistration.close(); - } - } - - private List nullToEmpty(@Nullable List list) { - return list == null ? Collections.emptyList() : list; - } - -} diff --git a/groupbasedpolicy/src/main/java/org/opendaylight/groupbasedpolicy/base_endpoint/BaseEndpointServiceImpl.java b/groupbasedpolicy/src/main/java/org/opendaylight/groupbasedpolicy/base_endpoint/BaseEndpointServiceImpl.java new file mode 100644 index 000000000..9609b6510 --- /dev/null +++ b/groupbasedpolicy/src/main/java/org/opendaylight/groupbasedpolicy/base_endpoint/BaseEndpointServiceImpl.java @@ -0,0 +1,328 @@ +/* + * Copyright (c) 2016 Cisco Systems, Inc. and others. All rights reserved. + * + * This program and the accompanying materials are made available under the + * terms of the Eclipse Public License v1.0 which accompanies this distribution, + * and is available at http://www.eclipse.org/legal/epl-v10.html + */ + +package org.opendaylight.groupbasedpolicy.base_endpoint; + +import java.util.Collections; +import java.util.List; +import java.util.Map; +import java.util.concurrent.Future; + +import javax.annotation.Nullable; + +import org.opendaylight.controller.md.sal.binding.api.DataBroker; +import org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction; +import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType; +import org.opendaylight.controller.sal.binding.api.BindingAwareBroker; +import org.opendaylight.controller.sal.binding.api.RpcProviderRegistry; +import org.opendaylight.groupbasedpolicy.api.EndpointAugmentor; +import org.opendaylight.groupbasedpolicy.util.DataStoreHelper; +import org.opendaylight.groupbasedpolicy.util.EndpointUtils; +import org.opendaylight.groupbasedpolicy.util.IidFactory; +import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.BaseEndpointService; +import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.RegisterEndpointInput; +import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.UnregisterEndpointInput; +import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.endpoints.address.endpoints.AddressEndpoint; +import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.endpoints.address.endpoints.AddressEndpointBuilder; +import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.endpoints.address.endpoints.AddressEndpointKey; +import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.endpoints.containment.endpoints.ContainmentEndpoint; +import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.endpoints.containment.endpoints.ContainmentEndpointBuilder; +import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.endpoints.containment.endpoints.ContainmentEndpointKey; +import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.has.child.endpoints.ChildEndpoint; +import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.has.child.endpoints.ChildEndpointBuilder; +import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.has.child.endpoints.ChildEndpointKey; +import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.parent.child.endpoints.ParentEndpointChoice; +import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.parent.child.endpoints.parent.endpoint.choice.parent.containment.endpoint._case.ParentContainmentEndpoint; +import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.parent.child.endpoints.parent.endpoint.choice.parent.containment.endpoint._case.ParentContainmentEndpointBuilder; +import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.parent.child.endpoints.parent.endpoint.choice.parent.containment.endpoint._case.ParentContainmentEndpointKey; +import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.parent.child.endpoints.parent.endpoint.choice.parent.endpoint._case.ParentEndpoint; +import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.parent.child.endpoints.parent.endpoint.choice.parent.endpoint._case.ParentEndpointBuilder; +import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.parent.child.endpoints.parent.endpoint.choice.parent.endpoint._case.ParentEndpointKey; +import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.register.endpoint.input.AddressEndpointReg; +import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.register.endpoint.input.ContainmentEndpointReg; +import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.unregister.endpoint.input.AddressEndpointUnreg; +import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.unregister.endpoint.input.ContainmentEndpointUnreg; +import org.opendaylight.yangtools.yang.binding.Augmentation; +import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; +import org.opendaylight.yangtools.yang.binding.KeyedInstanceIdentifier; +import org.opendaylight.yangtools.yang.common.RpcResult; +import org.opendaylight.yangtools.yang.common.RpcResultBuilder; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import com.google.common.base.Function; +import com.google.common.base.Optional; +import com.google.common.base.Preconditions; +import com.google.common.util.concurrent.Futures; +import com.google.common.util.concurrent.ListenableFuture; + +public class BaseEndpointServiceImpl implements BaseEndpointService, AutoCloseable { + + private static final Logger LOG = LoggerFactory.getLogger(BaseEndpointServiceImpl.class); + private final DataBroker dataProvider; + private final BindingAwareBroker.RpcRegistration rpcRegistration; + private final EndpointAugmentorRegistryImpl epAugRegistry; + + private static final Function> TO_SUCCESS_RPC_RESULT = new Function>() { + + @Override + public RpcResult apply(Void input) { + return RpcResultBuilder.success().build(); + } + }; + + public BaseEndpointServiceImpl(DataBroker dataProvider, RpcProviderRegistry rpcRegistry, + EndpointAugmentorRegistryImpl epAugRegistry) { + this.epAugRegistry = Preconditions.checkNotNull(epAugRegistry); + this.dataProvider = Preconditions.checkNotNull(dataProvider); + Preconditions.checkNotNull(rpcRegistry); + this.rpcRegistration = rpcRegistry.addRpcImplementation(BaseEndpointService.class, this); + } + + /** + * Register a new endpoint into the registry. If there is already an existing + * endpoint with the same keys, they will be overwritten with the new information. + * + * @param input Endpoint to register + */ + @Override + public Future> registerEndpoint(RegisterEndpointInput input) { + long timestamp = System.currentTimeMillis(); + + ReadWriteTransaction t = dataProvider.newReadWriteTransaction(); + + ListenableFuture> failResult = + RegisterEndpointInputVerificator.verifyRegisterEndpointInput(input, t); + if (failResult != null) { + t.cancel(); + return failResult; + } + + List endpoints = input.getContainmentEndpointReg(); + for (ContainmentEndpointReg ce : nullToEmpty(endpoints)) { + long stamp = (ce.getTimestamp() == null || ce.getTimestamp() == 0) ? timestamp : ce.getTimestamp(); + ContainmentEndpoint endpoint = buildContainmentEndpoint(ce).setTimestamp(stamp).build(); + t.put(LogicalDatastoreType.OPERATIONAL, IidFactory.containmentEndpointIid(endpoint.getKey()), endpoint, + true); + addContainmentEndpointToChilds(t, endpoint); + } + + List addressEndpoints = input.getAddressEndpointReg(); + for (AddressEndpointReg ae : nullToEmpty(addressEndpoints)) { + long stamp = (ae.getTimestamp() == null || ae.getTimestamp() == 0) ? timestamp : ae.getTimestamp(); + AddressEndpoint endpoint = buildAddressEndpoint(ae).setTimestamp(stamp).build(); + t.put(LogicalDatastoreType.OPERATIONAL, IidFactory.addressEndpointIid(endpoint.getKey()), endpoint, true); + addAddressEndpointToChilds(t, endpoint); + addAddressEndpointToParents(t, endpoint); + } + + return Futures.transform(t.submit(), TO_SUCCESS_RPC_RESULT); + } + + private void addContainmentEndpointToChilds(ReadWriteTransaction t, ContainmentEndpoint endpoint) { + ParentContainmentEndpoint epAsParent = new ParentContainmentEndpointBuilder(endpoint).build(); + for (ChildEndpoint child : nullToEmpty(endpoint.getChildEndpoint())) { + InstanceIdentifier childIid = + IidFactory.addressEndpointIid(EndpointUtils.createAddressEndointKey(child)); + Optional childAddrEpOptional = + DataStoreHelper.readFromDs(LogicalDatastoreType.OPERATIONAL, childIid, t); + if (childAddrEpOptional.isPresent()) { + KeyedInstanceIdentifier parentInChildIid = + childIid.child(ParentContainmentEndpoint.class, epAsParent.getKey()); + t.put(LogicalDatastoreType.OPERATIONAL, parentInChildIid, epAsParent, true); + } + } + } + + private void addAddressEndpointToChilds(ReadWriteTransaction t, AddressEndpoint endpoint) { + ParentEndpoint epAsParent = new ParentEndpointBuilder(endpoint).build(); + for (ChildEndpoint child : nullToEmpty(endpoint.getChildEndpoint())) { + InstanceIdentifier childIid = + IidFactory.addressEndpointIid(EndpointUtils.createAddressEndointKey(child)); + Optional childAddrEpOptional = + DataStoreHelper.readFromDs(LogicalDatastoreType.OPERATIONAL, childIid, t); + if (childAddrEpOptional.isPresent()) { + KeyedInstanceIdentifier parentInChildIid = + childIid.child(ParentEndpoint.class, epAsParent.getKey()); + t.put(LogicalDatastoreType.OPERATIONAL, parentInChildIid, epAsParent, true); + } + } + } + + private void addAddressEndpointToParents(ReadWriteTransaction t, AddressEndpoint endpoint) { + ChildEndpoint epAsChild = new ChildEndpointBuilder(endpoint).build(); + for (ParentEndpoint parent : EndpointUtils.getParentEndpoints(endpoint.getParentEndpointChoice())) { + InstanceIdentifier parentIid = + IidFactory.addressEndpointIid(EndpointUtils.createAddressEndpointKey(parent)); + Optional parentAddrEpOptional = + DataStoreHelper.readFromDs(LogicalDatastoreType.OPERATIONAL, parentIid, t); + if (parentAddrEpOptional.isPresent()) { + KeyedInstanceIdentifier childInParentIid = + parentIid.child(ChildEndpoint.class, epAsChild.getKey()); + t.put(LogicalDatastoreType.OPERATIONAL, childInParentIid, epAsChild, true); + } + } + for (ParentContainmentEndpoint parent : EndpointUtils.getParentContainmentEndpoints(endpoint.getParentEndpointChoice())) { + InstanceIdentifier parentIid = IidFactory + .containmentEndpointIid(new ContainmentEndpointKey(parent.getContextId(), parent.getContextType())); + Optional parentContEpOptional = + DataStoreHelper.readFromDs(LogicalDatastoreType.OPERATIONAL, parentIid, t); + if (parentContEpOptional.isPresent()) { + KeyedInstanceIdentifier childInParentIid = + parentIid.child(ChildEndpoint.class, epAsChild.getKey()); + t.put(LogicalDatastoreType.OPERATIONAL, childInParentIid, epAsChild, true); + } + } + } + + private ContainmentEndpointBuilder buildContainmentEndpoint(ContainmentEndpointReg input) { + + ContainmentEndpointBuilder eb = new ContainmentEndpointBuilder().setChildEndpoint(input.getChildEndpoint()) + .setCondition(input.getCondition()) + .setContextType(input.getContextType()) + .setContextId(input.getContextId()) + .setEndpointGroup(input.getEndpointGroup()) + .setKey(new ContainmentEndpointKey(input.getContextId(), input.getContextType())) + .setNetworkContainment(input.getNetworkContainment()) + .setTenant(input.getTenant()) + .setTimestamp(input.getTimestamp()) + .setChildEndpoint(input.getChildEndpoint()); + + for (EndpointAugmentor epAugmentor : epAugRegistry.getEndpointAugmentors()) { + try { + Map.Entry>, Augmentation> augmentationEntry = + epAugmentor.buildContainmentEndpointAugmentation(input); + if (augmentationEntry != null) { + eb.addAugmentation(augmentationEntry.getKey(), augmentationEntry.getValue()); + } + } catch (Exception e) { + LOG.warn("AddressEndpoint Augmentation error while {} was processing {}", + epAugmentor.getClass().getSimpleName(), input, e); + } + } + return eb; + } + + private AddressEndpointBuilder buildAddressEndpoint(AddressEndpointReg ae) { + AddressEndpointBuilder builder = new AddressEndpointBuilder().setTenant(ae.getTenant()) + .setNetworkContainment(ae.getNetworkContainment()) + .setEndpointGroup(ae.getEndpointGroup()) + .setAddress(ae.getAddress()) + .setAddressType(ae.getAddressType()) + .setChildEndpoint(ae.getChildEndpoint()) + .setCondition(ae.getCondition()) + .setKey(new AddressEndpointKey(ae.getAddress(), ae.getAddressType(), ae.getContextId(), + ae.getContextType())) + .setParentEndpointChoice(ae.getParentEndpointChoice()) + .setTimestamp(ae.getTimestamp()) + .setContextId(ae.getContextId()) + .setContextType(ae.getContextType()) + .setTenant(ae.getTenant()); + + for (EndpointAugmentor epAugmentor : epAugRegistry.getEndpointAugmentors()) { + try { + Map.Entry>, Augmentation> augmentationEntry = + epAugmentor.buildAddressEndpointAugmentation(ae); + if (augmentationEntry != null) { + builder.addAugmentation(augmentationEntry.getKey(), augmentationEntry.getValue()); + } + } catch (Exception e) { + LOG.warn("AddressEndpoint Augmentation error while {} was processing {}", + epAugmentor.getClass().getSimpleName(), ae, e); + } + } + return builder; + } + + /** + * Unregister an endpoint or endpoints from the registry. + * + * @param input Endpoint/endpoints to unregister + */ + @Override + public Future> unregisterEndpoint(UnregisterEndpointInput input) { + ReadWriteTransaction t = dataProvider.newReadWriteTransaction(); + + List addrEndpoints = input.getAddressEndpointUnreg(); + for (AddressEndpointUnreg aeUnreg : nullToEmpty(addrEndpoints)) { + AddressEndpointKey key = new AddressEndpointKey(aeUnreg.getAddress(), aeUnreg.getAddressType(), + aeUnreg.getContextId(), aeUnreg.getContextType()); + Optional aeOptional = DataStoreHelper.removeIfExists(LogicalDatastoreType.OPERATIONAL, + IidFactory.addressEndpointIid(key), t); + if (aeOptional.isPresent()) { + deleteAddressEndpointFromParents(t, aeOptional.get()); + deleteAddressEndpointFromChilds(t, aeOptional.get()); + } + } + + List contEndpoints = input.getContainmentEndpointUnreg(); + for (ContainmentEndpointUnreg ceUnreg : nullToEmpty(contEndpoints)) { + ContainmentEndpointKey key = new ContainmentEndpointKey(ceUnreg.getContextId(), ceUnreg.getContextType()); + Optional ceOptional = DataStoreHelper.removeIfExists(LogicalDatastoreType.OPERATIONAL, + IidFactory.containmentEndpointIid(key), t); + if (ceOptional.isPresent()) { + deleteContainmentEndpointFromChilds(t, ceOptional.get()); + } + } + + ListenableFuture r = t.submit(); + return Futures.transform(r, TO_SUCCESS_RPC_RESULT); + } + + private void deleteAddressEndpointFromParents(ReadWriteTransaction t, AddressEndpoint endpoint) { + ParentEndpointChoice parentEndpointChoice = endpoint.getParentEndpointChoice(); + for (ParentEndpoint parentEndpoint : EndpointUtils.getParentEndpoints(parentEndpointChoice)) { + KeyedInstanceIdentifier childEp = + IidFactory.addressEndpointIid(EndpointUtils.createAddressEndpointKey(parentEndpoint)).child(ChildEndpoint.class, + new ChildEndpointKey(endpoint.getAddress(), endpoint.getAddressType(), + endpoint.getContextId(), endpoint.getContextType())); + DataStoreHelper.removeIfExists(LogicalDatastoreType.OPERATIONAL, childEp, t); + } + for (ParentContainmentEndpoint parentContEndpoint : EndpointUtils.getParentContainmentEndpoints(parentEndpointChoice)) { + KeyedInstanceIdentifier childEp = IidFactory + .containmentEndpointIid(new ContainmentEndpointKey(parentContEndpoint.getContextId(), + parentContEndpoint.getContextType())) + .child(ChildEndpoint.class, new ChildEndpointKey(endpoint.getAddress(), endpoint.getAddressType(), + endpoint.getContextId(), endpoint.getContextType())); + DataStoreHelper.removeIfExists(LogicalDatastoreType.OPERATIONAL, childEp, t); + } + } + + private void deleteAddressEndpointFromChilds(ReadWriteTransaction t, AddressEndpoint endpoint) { + for (ChildEndpoint childEndpoint : nullToEmpty(endpoint.getChildEndpoint())) { + KeyedInstanceIdentifier parentEp = + IidFactory.addressEndpointIid(EndpointUtils.createAddressEndointKey(childEndpoint)).child(ParentEndpoint.class, + new ParentEndpointKey(endpoint.getAddress(), endpoint.getAddressType(), + endpoint.getContextId(), endpoint.getContextType())); + DataStoreHelper.removeIfExists(LogicalDatastoreType.OPERATIONAL, parentEp, t); + } + } + + private void deleteContainmentEndpointFromChilds(ReadWriteTransaction t, ContainmentEndpoint endpoint) { + for (ChildEndpoint child : nullToEmpty(endpoint.getChildEndpoint())) { + AddressEndpointKey aeKey = new AddressEndpointKey(child.getAddress(), child.getAddressType(), + child.getContextId(), child.getContextType()); + KeyedInstanceIdentifier parentEp = + IidFactory.addressEndpointIid(aeKey).child(ParentContainmentEndpoint.class, + new ParentContainmentEndpointKey(endpoint.getContextId(), endpoint.getContextType())); + DataStoreHelper.removeIfExists(LogicalDatastoreType.OPERATIONAL, parentEp, t); + } + } + + @Override + public void close() throws Exception { + if (rpcRegistration != null) { + rpcRegistration.close(); + } + } + + private List nullToEmpty(@Nullable List list) { + return list == null ? Collections.emptyList() : list; + } + +} diff --git a/groupbasedpolicy/src/main/java/org/opendaylight/groupbasedpolicy/base_endpoint/EndpointAugmentorRegistryImpl.java b/groupbasedpolicy/src/main/java/org/opendaylight/groupbasedpolicy/base_endpoint/EndpointAugmentorRegistryImpl.java new file mode 100644 index 000000000..cb4be65c1 --- /dev/null +++ b/groupbasedpolicy/src/main/java/org/opendaylight/groupbasedpolicy/base_endpoint/EndpointAugmentorRegistryImpl.java @@ -0,0 +1,43 @@ +/* + * Copyright (c) 2016 Cisco Systems, Inc. and others. All rights reserved. + * + * This program and the accompanying materials are made available under the + * terms of the Eclipse Public License v1.0 which accompanies this distribution, + * and is available at http://www.eclipse.org/legal/epl-v10.html + */ + +package org.opendaylight.groupbasedpolicy.base_endpoint; + +import java.util.Set; + +import org.opendaylight.groupbasedpolicy.api.EndpointAugmentor; +import org.opendaylight.groupbasedpolicy.api.EndpointAugmentorRegistry; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import com.google.common.collect.Sets; + +public class EndpointAugmentorRegistryImpl implements EndpointAugmentorRegistry { + + private final static Logger LOG = LoggerFactory.getLogger(EndpointAugmentorRegistryImpl.class); + private final Set epAugmentors = Sets.newConcurrentHashSet(); + + @Override + public void register(EndpointAugmentor endpointAugmentor) { + if (epAugmentors.add(endpointAugmentor)) { + LOG.info("Registered EndpointAugmentor - {}", endpointAugmentor.getClass().getSimpleName()); + } + } + + @Override + public void unregister(EndpointAugmentor endpointAugmentor) { + if (epAugmentors.remove(endpointAugmentor)) { + LOG.info("Unegistered EndpointAugmentor - {}", endpointAugmentor.getClass().getSimpleName()); + } + } + + public Set getEndpointAugmentors() { + return epAugmentors; + } + +} diff --git a/groupbasedpolicy/src/main/java/org/opendaylight/groupbasedpolicy/base_endpoint/RegisterEndpointInputVerificator.java b/groupbasedpolicy/src/main/java/org/opendaylight/groupbasedpolicy/base_endpoint/RegisterEndpointInputVerificator.java new file mode 100644 index 000000000..35415828c --- /dev/null +++ b/groupbasedpolicy/src/main/java/org/opendaylight/groupbasedpolicy/base_endpoint/RegisterEndpointInputVerificator.java @@ -0,0 +1,240 @@ +/* + * Copyright (c) 2016 Cisco Systems, Inc. and others. All rights reserved. + * + * This program and the accompanying materials are made available under the + * terms of the Eclipse Public License v1.0 which accompanies this distribution, + * and is available at http://www.eclipse.org/legal/epl-v10.html + */ + +package org.opendaylight.groupbasedpolicy.base_endpoint; + +import java.util.Collections; +import java.util.List; + +import javax.annotation.Nullable; + +import org.opendaylight.controller.md.sal.binding.api.ReadTransaction; +import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType; +import org.opendaylight.groupbasedpolicy.util.DataStoreHelper; +import org.opendaylight.groupbasedpolicy.util.EndpointUtils; +import org.opendaylight.groupbasedpolicy.util.IidFactory; +import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.RegisterEndpointInput; +import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.endpoints.address.endpoints.AddressEndpoint; +import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.endpoints.address.endpoints.AddressEndpointKey; +import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.endpoints.containment.endpoints.ContainmentEndpoint; +import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.endpoints.containment.endpoints.ContainmentEndpointKey; +import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.has.child.endpoints.ChildEndpoint; +import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.has.child.endpoints.ChildEndpointBuilder; +import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.parent.child.endpoints.ParentEndpointChoice; +import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.parent.child.endpoints.parent.endpoint.choice.parent.containment.endpoint._case.ParentContainmentEndpoint; +import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.parent.child.endpoints.parent.endpoint.choice.parent.containment.endpoint._case.ParentContainmentEndpointBuilder; +import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.parent.child.endpoints.parent.endpoint.choice.parent.endpoint._case.ParentEndpoint; +import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.parent.child.endpoints.parent.endpoint.choice.parent.endpoint._case.ParentEndpointBuilder; +import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.register.endpoint.input.AddressEndpointReg; +import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.register.endpoint.input.AddressEndpointRegKey; +import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.register.endpoint.input.ContainmentEndpointReg; +import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.register.endpoint.input.ContainmentEndpointRegKey; +import org.opendaylight.yangtools.yang.common.RpcError; +import org.opendaylight.yangtools.yang.common.RpcResult; +import org.opendaylight.yangtools.yang.common.RpcResultBuilder; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import com.google.common.base.Optional; +import com.google.common.util.concurrent.Futures; +import com.google.common.util.concurrent.ListenableFuture; + +public class RegisterEndpointInputVerificator { + + private static final Logger LOG = LoggerFactory.getLogger(RegisterEndpointInputVerificator.class); + + public static ListenableFuture> verifyRegisterEndpointInput(RegisterEndpointInput input, + ReadTransaction rTx) { + ListenableFuture> result; + List addressEndpointRegs = nullToEmpty(input.getAddressEndpointReg()); + List containmentEndpointRegs = nullToEmpty(input.getContainmentEndpointReg()); + + for (AddressEndpointReg addressEndpointReg : addressEndpointRegs) { + result = verifyAddressEndpointChilds(addressEndpointRegs, addressEndpointReg, rTx); + if (result != null) { + return result; + } + + result = verifyAddressEndpointParents(addressEndpointRegs, containmentEndpointRegs, addressEndpointReg, + rTx); + if (result != null) { + return result; + } + } + + result = verifyContainmentEndpointChilds(addressEndpointRegs, containmentEndpointRegs, rTx); + if (result != null) { + return result; + } + + return null; + } + + private static ListenableFuture> verifyAddressEndpointChilds( + List addressEndpointRegs, AddressEndpointReg addressEndpointReg, ReadTransaction rTx) { + for (ChildEndpoint childEndpoint : nullToEmpty(addressEndpointReg.getChildEndpoint())) { + AddressEndpointRegKey key = new AddressEndpointRegKey(childEndpoint.getAddress(), + childEndpoint.getAddressType(), childEndpoint.getContextId(), childEndpoint.getContextType()); + AddressEndpointReg addressEndpointRegChild = findAddressEndpointReg(key, addressEndpointRegs); + if (addressEndpointRegChild == null) { + Optional addressEndpointOptional = + DataStoreHelper.readFromDs(LogicalDatastoreType.OPERATIONAL, + IidFactory.addressEndpointIid(new AddressEndpointKey(key.getAddress(), + key.getAddressType(), key.getContextId(), key.getContextType())), + rTx); + if (!addressEndpointOptional.isPresent()) { + LOG.debug("Child AddressEndpoint {} does not exist in RPC and DS.", childEndpoint.getKey()); + return buildFailFeature(String.format("Child AddressEndpoint %s does not exist in RPC and DS.", + childEndpoint.getKey())); + } + } else { + ParentEndpointChoice parentEndpointChoice = addressEndpointRegChild.getParentEndpointChoice(); + List parentEndpoints = EndpointUtils.getParentEndpoints(parentEndpointChoice); + if (!parentEndpoints.contains(new ParentEndpointBuilder(addressEndpointReg).build())) { + LOG.debug("Child AddressEndpoint {} does not contain a parent AddressEndpoint {}.\nChild: {}", + addressEndpointRegChild.getKey(), addressEndpointReg.getKey(), addressEndpointRegChild); + return buildFailFeature(String.format( + "Child AddressEndpoint does not contain a parent AddressEndpoint." + + "\nChild AddressEndpoint: %s" + "\nParent AddressEndpoint: %s", + addressEndpointRegChild.getKey(), addressEndpointReg.getKey())); + } + } + } + return null; + } + + private static ListenableFuture> verifyAddressEndpointParents( + List addressEndpointRegs, List containmentEndpointRegs, + AddressEndpointReg addressEndpointReg, ReadTransaction rTx) { + ParentEndpointChoice parentEndpointChoice = addressEndpointReg.getParentEndpointChoice(); + for (ParentEndpoint parentEndpoint : EndpointUtils.getParentEndpoints(parentEndpointChoice)) { + AddressEndpointRegKey key = new AddressEndpointRegKey(parentEndpoint.getAddress(), + parentEndpoint.getAddressType(), parentEndpoint.getContextId(), parentEndpoint.getContextType()); + AddressEndpointReg addressEndpointRegParent = findAddressEndpointReg(key, addressEndpointRegs); + if (addressEndpointRegParent == null) { + Optional addressEndpointOptional = + DataStoreHelper.readFromDs(LogicalDatastoreType.OPERATIONAL, + IidFactory.addressEndpointIid(new AddressEndpointKey(key.getAddress(), + key.getAddressType(), key.getContextId(), key.getContextType())), + rTx); + if (!addressEndpointOptional.isPresent()) { + LOG.debug("Parent AddressEndpoint {} does not exist in RPC and DS.", parentEndpoint.getKey()); + return buildFailFeature(String.format("Parent AddressEndpoint %s does not exist in RPC and DS.", + parentEndpoint.getKey())); + } + } else { + List childEndpoints = addressEndpointRegParent.getChildEndpoint(); + if (!nullToEmpty(childEndpoints).contains(new ChildEndpointBuilder(addressEndpointReg).build())) { + LOG.debug("Parent AddressEndpoint {} does not contain a child AddressEndpoint {}.\nParent: {}", + addressEndpointRegParent.getKey(), addressEndpointReg.getKey(), addressEndpointRegParent); + return buildFailFeature(String.format( + "Parent AddressEndpoint does not contain a child AddressEndpoint." + + "\nParent AddressEndpoint: %s" + "\nChild AddressEndpoint: %s", + addressEndpointRegParent.getKey(), addressEndpointReg.getKey())); + } + } + } + for (ParentContainmentEndpoint parentEndpoint : EndpointUtils + .getParentContainmentEndpoints(parentEndpointChoice)) { + ContainmentEndpointRegKey key = + new ContainmentEndpointRegKey(parentEndpoint.getContextId(), parentEndpoint.getContextType()); + ContainmentEndpointReg containmentEndpointRegParent = + findContainmentEndpointReg(key, containmentEndpointRegs); + if (containmentEndpointRegParent == null) { + Optional containmentEndpointOptional = + DataStoreHelper.readFromDs(LogicalDatastoreType.OPERATIONAL, IidFactory.containmentEndpointIid( + new ContainmentEndpointKey(key.getContextId(), key.getContextType())), rTx); + if (!containmentEndpointOptional.isPresent()) { + LOG.debug("Parent ContainmentEndpoint {} does not exist in RPC and DS.", parentEndpoint.getKey()); + return buildFailFeature(String.format("Parent ContainmentEndpoint %s does not exist in RPC and DS.", + parentEndpoint.getKey())); + } + } else { + List childEndpoints = containmentEndpointRegParent.getChildEndpoint(); + if (!nullToEmpty(childEndpoints).contains(new ChildEndpointBuilder(addressEndpointReg).build())) { + LOG.debug("Parent ContainmentEndpoint {} does not contain a child AddressEndpoint {}.\nParent: {}", + containmentEndpointRegParent.getKey(), addressEndpointReg.getKey(), + containmentEndpointRegParent); + return buildFailFeature(String.format( + "Parent ContainmentEndpoint does not contain a child AddressEndpoint." + + "\nParent ContainmentEndpoint: %s" + "\nChild AddressEndpoint: %s", + containmentEndpointRegParent.getKey(), addressEndpointReg.getKey())); + } + } + } + return null; + } + + private static ListenableFuture> verifyContainmentEndpointChilds( + List addressEndpointRegs, List containmentEndpointRegs, + ReadTransaction rTx) { + for (ContainmentEndpointReg containmentEndpointReg : nullToEmpty(containmentEndpointRegs)) { + for (ChildEndpoint childEndpoint : nullToEmpty(containmentEndpointReg.getChildEndpoint())) { + AddressEndpointRegKey key = new AddressEndpointRegKey(childEndpoint.getAddress(), + childEndpoint.getAddressType(), childEndpoint.getContextId(), childEndpoint.getContextType()); + AddressEndpointReg addressEndpointRegChild = findAddressEndpointReg(key, addressEndpointRegs); + if (addressEndpointRegChild == null) { + Optional addressEndpointOptional = + DataStoreHelper.readFromDs(LogicalDatastoreType.OPERATIONAL, + IidFactory.addressEndpointIid(new AddressEndpointKey(key.getAddress(), + key.getAddressType(), key.getContextId(), key.getContextType())), + rTx); + if (!addressEndpointOptional.isPresent()) { + LOG.debug("Child AddressEndpoint {} does not exist in RPC and DS.", childEndpoint.getKey()); + return buildFailFeature(String.format("Child AddressEndpoint %s does not exist in RPC and DS.", + childEndpoint.getKey())); + } + } else { + List parentContainmentEndpoints = EndpointUtils + .getParentContainmentEndpoints(addressEndpointRegChild.getParentEndpointChoice()); + if (!parentContainmentEndpoints + .contains(new ParentContainmentEndpointBuilder(containmentEndpointReg).build())) { + LOG.debug( + "Child AddressEndpoint {} does not contain a parent ContainmentEndpoint {}.\nChild: {}", + addressEndpointRegChild.getKey(), containmentEndpointReg.getKey(), + addressEndpointRegChild); + return buildFailFeature(String.format( + "Child AddressEndpoint does not contain a parent ContainmentEndpoint." + + "\nChild AddressEndpoint: %s" + "\nParent ContainmentEndpoint: %s", + addressEndpointRegChild.getKey(), containmentEndpointReg.getKey())); + } + } + } + } + return null; + } + + private static AddressEndpointReg findAddressEndpointReg(AddressEndpointRegKey key, + List addressEndpointRegs) { + for (AddressEndpointReg addressEndpointReg : addressEndpointRegs) { + if (addressEndpointReg.getKey().equals(key)) { + return addressEndpointReg; + } + } + return null; + } + + private static ContainmentEndpointReg findContainmentEndpointReg(ContainmentEndpointRegKey key, + List addressEndpointRegs) { + for (ContainmentEndpointReg containmentEndpointReg : addressEndpointRegs) { + if (containmentEndpointReg.getKey().equals(key)) { + return containmentEndpointReg; + } + } + return null; + } + + private static ListenableFuture> buildFailFeature(String message) { + return Futures + .immediateFuture(RpcResultBuilder.failed().withError(RpcError.ErrorType.PROTOCOL, message).build()); + } + + private static List nullToEmpty(@Nullable List list) { + return list == null ? Collections.emptyList() : list; + } +} diff --git a/groupbasedpolicy/src/main/java/org/opendaylight/groupbasedpolicy/forwarding/NetworkDomainAugmentorRegistryImpl.java b/groupbasedpolicy/src/main/java/org/opendaylight/groupbasedpolicy/forwarding/NetworkDomainAugmentorRegistryImpl.java new file mode 100644 index 000000000..9c9cf04a4 --- /dev/null +++ b/groupbasedpolicy/src/main/java/org/opendaylight/groupbasedpolicy/forwarding/NetworkDomainAugmentorRegistryImpl.java @@ -0,0 +1,43 @@ +/* + * Copyright (c) 2016 Cisco Systems, Inc. and others. All rights reserved. + * + * This program and the accompanying materials are made available under the + * terms of the Eclipse Public License v1.0 which accompanies this distribution, + * and is available at http://www.eclipse.org/legal/epl-v10.html + */ + +package org.opendaylight.groupbasedpolicy.forwarding; + +import java.util.Set; + +import org.opendaylight.groupbasedpolicy.api.NetworkDomainAugmentor; +import org.opendaylight.groupbasedpolicy.api.NetworkDomainAugmentorRegistry; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import com.google.common.collect.Sets; + +public class NetworkDomainAugmentorRegistryImpl implements NetworkDomainAugmentorRegistry { + + private final static Logger LOG = LoggerFactory.getLogger(NetworkDomainAugmentorRegistryImpl.class); + private final Set augmentors = Sets.newConcurrentHashSet(); + + @Override + public void register(NetworkDomainAugmentor netDomainAugmentor) { + if (augmentors.add(netDomainAugmentor)) { + LOG.info("Registered NetworkDomainAugmentor - {}", netDomainAugmentor.getClass().getSimpleName()); + } + } + + @Override + public void unregister(NetworkDomainAugmentor netDomainAugmentor) { + if (augmentors.remove(netDomainAugmentor)) { + LOG.info("Unegistered NetworkDomainAugmentor - {}", netDomainAugmentor.getClass().getSimpleName()); + } + } + + public Set getEndpointAugmentors() { + return augmentors; + } + +} diff --git a/groupbasedpolicy/src/main/java/org/opendaylight/groupbasedpolicy/renderer/RendererConfigurationBuilder.java b/groupbasedpolicy/src/main/java/org/opendaylight/groupbasedpolicy/renderer/RendererConfigurationBuilder.java index c3bbf7f3d..f23160eeb 100644 --- a/groupbasedpolicy/src/main/java/org/opendaylight/groupbasedpolicy/renderer/RendererConfigurationBuilder.java +++ b/groupbasedpolicy/src/main/java/org/opendaylight/groupbasedpolicy/renderer/RendererConfigurationBuilder.java @@ -9,6 +9,7 @@ package org.opendaylight.groupbasedpolicy.renderer; import java.util.ArrayList; +import java.util.Collections; import java.util.HashMap; import java.util.HashSet; import java.util.List; @@ -17,7 +18,9 @@ import java.util.Map.Entry; import java.util.Set; import javax.annotation.Nonnull; +import javax.annotation.Nullable; +import org.opendaylight.groupbasedpolicy.api.NetworkDomainAugmentor; import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.endpoint.locations.AddressEndpointLocation; import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.endpoint.locations.ContainmentEndpointLocation; import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.endpoints.address.endpoints.AddressEndpoint; @@ -26,6 +29,8 @@ import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpo import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.endpoints.containment.endpoints.ContainmentEndpointKey; import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.forwarding.rev160427.Forwarding; import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.forwarding.rev160427.forwarding.ForwardingByTenant; +import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.forwarding.rev160427.forwarding.forwarding.by.tenant.ForwardingContext; +import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.forwarding.rev160427.forwarding.forwarding.by.tenant.NetworkDomain; import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.EndpointPolicyParticipation; import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.RendererName; import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.has.peer.endpoints.PeerEndpointKey; @@ -35,18 +40,16 @@ import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.r import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.has.rule.group.with.renderer.endpoint.participation.RuleGroupWithRendererEndpointParticipationBuilder; import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.renderer.policy.configuration.Endpoints; import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.renderer.policy.configuration.EndpointsBuilder; -import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.renderer.policy.configuration.ForwardingContexts; -import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.renderer.policy.configuration.ForwardingContextsBuilder; import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.renderer.policy.configuration.RendererEndpoints; import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.renderer.policy.configuration.RendererEndpointsBuilder; +import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.renderer.policy.configuration.RendererForwarding; +import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.renderer.policy.configuration.RendererForwardingBuilder; import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.renderer.policy.configuration.RuleGroups; import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.renderer.policy.configuration.RuleGroupsBuilder; import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.renderer.policy.configuration.endpoints.AddressEndpointWithLocation; import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.renderer.policy.configuration.endpoints.AddressEndpointWithLocationBuilder; import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.renderer.policy.configuration.endpoints.ContainmentEndpointWithLocation; import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.renderer.policy.configuration.endpoints.ContainmentEndpointWithLocationBuilder; -import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.renderer.policy.configuration.forwarding.contexts.ForwardingContextByTenant; -import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.renderer.policy.configuration.forwarding.contexts.ForwardingContextByTenantBuilder; import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.renderer.policy.configuration.renderer.endpoints.RendererEndpoint; import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.renderer.policy.configuration.renderer.endpoints.RendererEndpointBuilder; import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.renderer.policy.configuration.renderer.endpoints.RendererEndpointKey; @@ -59,14 +62,23 @@ import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.r import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.renderer.policy.configuration.renderer.endpoints.renderer.endpoint.PeerExternalEndpointWithPolicy; import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.renderer.policy.configuration.renderer.endpoints.renderer.endpoint.PeerExternalEndpointWithPolicyBuilder; import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.renderer.policy.configuration.renderer.endpoints.renderer.endpoint.PeerExternalEndpointWithPolicyKey; +import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.renderer.policy.configuration.renderer.forwarding.RendererForwardingByTenant; +import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.renderer.policy.configuration.renderer.forwarding.RendererForwardingByTenantBuilder; +import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.renderer.policy.configuration.renderer.forwarding.renderer.forwarding.by.tenant.RendererForwardingContext; +import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.renderer.policy.configuration.renderer.forwarding.renderer.forwarding.by.tenant.RendererForwardingContextBuilder; +import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.renderer.policy.configuration.renderer.forwarding.renderer.forwarding.by.tenant.RendererNetworkDomain; +import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.renderer.policy.configuration.renderer.forwarding.renderer.forwarding.by.tenant.RendererNetworkDomainBuilder; import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.renderer.policy.configuration.rule.groups.RuleGroup; import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.renderer.policy.configuration.rule.groups.RuleGroupBuilder; import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.resolved.policy.rev150828.resolved.policies.resolved.policy.policy.rule.group.with.endpoint.constraints.PolicyRuleGroup; import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.resolved.policy.rev150828.resolved.policies.resolved.policy.policy.rule.group.with.endpoint.constraints.PolicyRuleGroupKey; +import org.opendaylight.yangtools.yang.binding.Augmentation; import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; +import com.google.common.base.Function; import com.google.common.base.Optional; import com.google.common.base.Preconditions; +import com.google.common.collect.FluentIterable; import com.google.common.collect.HashBasedTable; import com.google.common.collect.ImmutableSet; import com.google.common.collect.ImmutableTable; @@ -365,21 +377,78 @@ public class RendererConfigurationBuilder { .build(); } - // TODO this copies entire Forwarding to ForwardingContexts - it could copy only forwarding used + // TODO this copies entire Forwarding to RendererForwarding - it could copy only forwarding used // in EPs (renderer EPs + peers) - public ForwardingContexts buildForwardingContexts(Forwarding forwarding) { - List forwardingContextByTenant = - resolveForwardingContextByTenant(forwarding.getForwardingByTenant()); - return new ForwardingContextsBuilder().setForwardingContextByTenant(forwardingContextByTenant).build(); + public RendererForwarding buildRendererForwarding(Forwarding forwarding, Set augmentors) { + List forwardingContextByTenant = + resolveForwardingContextByTenant(forwarding.getForwardingByTenant(), augmentors); + return new RendererForwardingBuilder().setRendererForwardingByTenant(forwardingContextByTenant).build(); } - private static List resolveForwardingContextByTenant( - List forwardingByTenant) { - List result = new ArrayList<>(); + private static List resolveForwardingContextByTenant( + List forwardingByTenant, Set augmentors) { + List result = new ArrayList<>(); for (ForwardingByTenant fwdByTenant : forwardingByTenant) { - result.add(new ForwardingContextByTenantBuilder(fwdByTenant).build()); + result.add(resolveRendererForwardingByTenant(fwdByTenant, augmentors)); } return result; } + private static RendererForwardingByTenant resolveRendererForwardingByTenant(ForwardingByTenant fwdByTenant, + Set augmentors) { + List rendererForwardingContexts = + resolveRendererForwardingContexts(fwdByTenant.getForwardingContext()); + List rendererNetworkDomains = + resolveRendererNetworkDomains(fwdByTenant.getNetworkDomain(), augmentors); + return new RendererForwardingByTenantBuilder().setTenantId(fwdByTenant.getTenantId()) + .setRendererForwardingContext(rendererForwardingContexts) + .setRendererNetworkDomain(rendererNetworkDomains) + .build(); + } + + private static List resolveRendererForwardingContexts( + @Nullable List fwdCtx) { + if (fwdCtx == null) { + return Collections.emptyList(); + } + return FluentIterable.from(fwdCtx).transform(new Function() { + + @Override + public RendererForwardingContext apply(ForwardingContext input) { + return new RendererForwardingContextBuilder().setContextId(input.getContextId()) + .setContextType(input.getContextType()) + .setName(input.getName()) + .setParent(input.getParent()) + .build(); + } + }).toList(); + } + + private static List resolveRendererNetworkDomains(@Nullable List netDomains, + Set augmentors) { + if (netDomains == null) { + return Collections.emptyList(); + } + return FluentIterable.from(netDomains).transform(new Function() { + + @Override + public RendererNetworkDomain apply(NetworkDomain input) { + RendererNetworkDomainBuilder rendererNetworkDomainBuilder = + new RendererNetworkDomainBuilder().setNetworkDomainId(input.getNetworkDomainId()) + .setNetworkDomainType(input.getNetworkDomainType()) + .setName(input.getName()) + .setParent(input.getParent()); + for (NetworkDomainAugmentor augmentor : augmentors) { + Entry>, Augmentation> networkDomainAugmentation = + augmentor.buildRendererNetworkDomainAugmentation(input); + if (networkDomainAugmentation != null) { + rendererNetworkDomainBuilder.addAugmentation(networkDomainAugmentation.getKey(), + networkDomainAugmentation.getValue()); + } + } + return rendererNetworkDomainBuilder.build(); + } + }).toList(); + } + } diff --git a/groupbasedpolicy/src/main/java/org/opendaylight/groupbasedpolicy/renderer/RendererManager.java b/groupbasedpolicy/src/main/java/org/opendaylight/groupbasedpolicy/renderer/RendererManager.java index becf45e45..16b68886c 100644 --- a/groupbasedpolicy/src/main/java/org/opendaylight/groupbasedpolicy/renderer/RendererManager.java +++ b/groupbasedpolicy/src/main/java/org/opendaylight/groupbasedpolicy/renderer/RendererManager.java @@ -26,6 +26,7 @@ import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType; import org.opendaylight.groupbasedpolicy.dto.ConsEpgKey; import org.opendaylight.groupbasedpolicy.dto.EpgKeyDto; import org.opendaylight.groupbasedpolicy.dto.ProvEpgKey; +import org.opendaylight.groupbasedpolicy.forwarding.NetworkDomainAugmentorRegistryImpl; import org.opendaylight.groupbasedpolicy.renderer.listener.EndpointLocationsListener; import org.opendaylight.groupbasedpolicy.renderer.listener.EndpointsListener; import org.opendaylight.groupbasedpolicy.renderer.listener.ForwardingListener; @@ -54,8 +55,8 @@ import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.r import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.renderer.policy.Configuration; import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.renderer.policy.ConfigurationBuilder; import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.renderer.policy.Status; -import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.renderer.policy.configuration.ForwardingContexts; import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.renderer.policy.configuration.RendererEndpoints; +import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.renderer.policy.configuration.RendererForwarding; import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.renderer.policy.configuration.RuleGroups; import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.renderer.policy.configuration.renderer.endpoints.RendererEndpointKey; import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.resolved.policy.rev150828.ResolvedPolicies; @@ -83,6 +84,7 @@ public class RendererManager implements AutoCloseable { private static long version = 0; private final DataBroker dataProvider; + private final NetworkDomainAugmentorRegistryImpl netDomainAugmentorRegistry; private final Set processingRenderers = new HashSet<>(); private Map, RendererName> rendererByNode = new HashMap<>(); private ResolvedPolicyInfo policyInfo; @@ -96,8 +98,9 @@ public class RendererManager implements AutoCloseable { private final ForwardingListener forwardingListener; private final RenderersListener renderersListener; - public RendererManager(DataBroker dataProvider) { + public RendererManager(DataBroker dataProvider, NetworkDomainAugmentorRegistryImpl netDomainAugmentorRegistry) { this.dataProvider = checkNotNull(dataProvider); + this.netDomainAugmentorRegistry = checkNotNull(netDomainAugmentorRegistry); endpointsListener = new EndpointsListener(this, dataProvider); endpointLocationsListener = new EndpointLocationsListener(this, dataProvider); resolvedPoliciesListener = new ResolvedPoliciesListener(this, dataProvider); @@ -264,8 +267,9 @@ public class RendererManager implements AutoCloseable { RuleGroups ruleGroups = rendererPolicyBuilder.buildRuluGroups(policyInfo); configBuilder.setRuleGroups(ruleGroups); - ForwardingContexts forwardingContexts = rendererPolicyBuilder.buildForwardingContexts(forwarding); - configBuilder.setForwardingContexts(forwardingContexts); + RendererForwarding rendererForwarding = rendererPolicyBuilder.buildRendererForwarding(forwarding, + netDomainAugmentorRegistry.getEndpointAugmentors()); + configBuilder.setRendererForwarding(rendererForwarding); return Optional.of(configBuilder.build()); } diff --git a/groupbasedpolicy/src/main/java/org/opendaylight/groupbasedpolicy/util/EndpointUtils.java b/groupbasedpolicy/src/main/java/org/opendaylight/groupbasedpolicy/util/EndpointUtils.java new file mode 100644 index 000000000..00432a622 --- /dev/null +++ b/groupbasedpolicy/src/main/java/org/opendaylight/groupbasedpolicy/util/EndpointUtils.java @@ -0,0 +1,61 @@ +/* + * Copyright (c) 2016 Cisco Systems, Inc. and others. All rights reserved. + * + * This program and the accompanying materials are made available under the + * terms of the Eclipse Public License v1.0 which accompanies this distribution, + * and is available at http://www.eclipse.org/legal/epl-v10.html + */ + +package org.opendaylight.groupbasedpolicy.util; + +import java.util.Collections; +import java.util.List; + +import javax.annotation.Nonnull; +import javax.annotation.Nullable; + +import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.endpoints.address.endpoints.AddressEndpointKey; +import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.has.child.endpoints.ChildEndpoint; +import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.parent.child.endpoints.ParentEndpointChoice; +import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.parent.child.endpoints.parent.endpoint.choice.ParentContainmentEndpointCase; +import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.parent.child.endpoints.parent.endpoint.choice.ParentEndpointCase; +import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.parent.child.endpoints.parent.endpoint.choice.parent.containment.endpoint._case.ParentContainmentEndpoint; +import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.parent.child.endpoints.parent.endpoint.choice.parent.endpoint._case.ParentEndpoint; + +public class EndpointUtils { + + public static AddressEndpointKey createAddressEndointKey(ChildEndpoint child) { + return new AddressEndpointKey(child.getAddress(), child.getAddressType(), child.getContextId(), + child.getContextType()); + } + + public static AddressEndpointKey createAddressEndpointKey(ParentEndpoint parent) { + return new AddressEndpointKey(parent.getAddress(), parent.getAddressType(), parent.getContextId(), + parent.getContextType()); + } + + public static @Nonnull List getParentContainmentEndpoints( + @Nullable ParentEndpointChoice parentEndpointChoice) { + if (parentEndpointChoice instanceof ParentContainmentEndpointCase) { + ParentContainmentEndpointCase parentCeCase = (ParentContainmentEndpointCase) parentEndpointChoice; + List parentContainmentEndpoints = parentCeCase.getParentContainmentEndpoint(); + if (parentContainmentEndpoints != null) { + return parentContainmentEndpoints; + } + } + return Collections.emptyList(); + } + + public static @Nonnull List getParentEndpoints( + @Nullable ParentEndpointChoice parentEndpointChoice) { + if (parentEndpointChoice instanceof ParentEndpointCase) { + ParentEndpointCase parentEpCase = (ParentEndpointCase) parentEndpointChoice; + List parentEndpoints = parentEpCase.getParentEndpoint(); + if (parentEndpoints != null) { + return parentEndpoints; + } + } + return Collections.emptyList(); + } + +} diff --git a/groupbasedpolicy/src/main/java/org/opendaylight/groupbasedpolicy/util/IidFactory.java b/groupbasedpolicy/src/main/java/org/opendaylight/groupbasedpolicy/util/IidFactory.java index 592f6cd66..f8bb98c2e 100644 --- a/groupbasedpolicy/src/main/java/org/opendaylight/groupbasedpolicy/util/IidFactory.java +++ b/groupbasedpolicy/src/main/java/org/opendaylight/groupbasedpolicy/util/IidFactory.java @@ -408,17 +408,6 @@ public class IidFactory { .build(); } - public static InstanceIdentifier parentContainmentEndpointIid( - AddressEndpointKey addressEndpointKey, ParentContainmentEndpointKey parentContainmentEndpointKey) { - return InstanceIdentifier - .builder( - org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.Endpoints.class) - .child(AddressEndpoints.class) - .child(AddressEndpoint.class, addressEndpointKey) - .child(ParentContainmentEndpoint.class, parentContainmentEndpointKey) - .build(); - } - public static InstanceIdentifier addressEndpointLocationIid(AddressEndpointLocationKey addrEndpointLocationKey) { return InstanceIdentifier.builder(EndpointLocations.class) .child(AddressEndpointLocation.class, addrEndpointLocationKey) diff --git a/groupbasedpolicy/src/main/yang/groupbasedpolicy-cfg.yang b/groupbasedpolicy/src/main/yang/groupbasedpolicy-cfg.yang index 5af40ce00..7cbce21e5 100644 --- a/groupbasedpolicy/src/main/yang/groupbasedpolicy-cfg.yang +++ b/groupbasedpolicy/src/main/yang/groupbasedpolicy-cfg.yang @@ -31,12 +31,12 @@ module groupbasedpolicy-cfg { config:java-class "org.opendaylight.groupbasedpolicy.api.EpRendererAugmentationRegistry"; } - identity base-endpoint-renderer-augmentation-registry { + identity domain-specific-registry { description - "base-endpoint-renderer-augmentation-registry service definition"; + "domain-specific-registry service definition"; base "config:service-type"; - config:java-class "org.opendaylight.groupbasedpolicy.api.BaseEndpointRendererAugmentationRegistry"; + config:java-class "org.opendaylight.groupbasedpolicy.api.DomainSpecificRegistry"; } identity policy-validator-registry { @@ -69,11 +69,11 @@ module groupbasedpolicy-cfg { config:java-name-prefix EpRendererAugmentationRegistryImpl; } - identity base-endpoint-renderer-augmentation-registry-impl { + identity domain-specific-registry-impl { base "config:module-type"; - config:provided-service base-endpoint-renderer-augmentation-registry; - config:java-name-prefix BaseEndpointRendererAugmentationRegistryImpl; + config:provided-service domain-specific-registry; + config:java-name-prefix DomainSpecificRegistry; } identity statistics-manager-impl { @@ -156,8 +156,8 @@ module groupbasedpolicy-cfg { } } } - case base-endpoint-renderer-augmentation-registry-impl { - when "/config:modules/config:module/config:type = 'base-endpoint-renderer-augmentation-registry-impl'"; + case domain-specific-registry-impl { + when "/config:modules/config:module/config:type = 'domain-specific-registry-impl'"; //wires in the data-broker service container data-broker { diff --git a/groupbasedpolicy/src/main/yang/model/base-endpoint.yang b/groupbasedpolicy/src/main/yang/model/base-endpoint.yang index 2d4d388d3..b92657d99 100644 --- a/groupbasedpolicy/src/main/yang/model/base-endpoint.yang +++ b/groupbasedpolicy/src/main/yang/model/base-endpoint.yang @@ -206,6 +206,8 @@ module base-endpoint { } container endpoint-locations { + config false; + list address-endpoint-location { key "context-type context-id address-type address"; uses address-endpoint-key; diff --git a/groupbasedpolicy/src/main/yang/model/forwarding.yang b/groupbasedpolicy/src/main/yang/model/forwarding.yang index 2fcca5d1c..5945a0bb5 100644 --- a/groupbasedpolicy/src/main/yang/model/forwarding.yang +++ b/groupbasedpolicy/src/main/yang/model/forwarding.yang @@ -90,33 +90,29 @@ module forwarding { } } - grouping forwarding-with-tenant-fields { - leaf tenant-id { - type gbp-common:tenant-id; - description - "The tenant with which forwarding-context is associated"; - } - - list forwarding-context { - key "context-type context-id"; - uses context-key; - - uses forwarding-fields; - } - - list network-domain { - key "network-domain-type network-domain-id"; - uses network-domain-key; - - uses forwarding-fields; - description "Network domain can be augmented with further information."; - } - } - container forwarding { list forwarding-by-tenant { key tenant-id; - uses forwarding-with-tenant-fields; + leaf tenant-id { + type gbp-common:tenant-id; + description + "The tenant with which forwarding-context is associated"; + } + + list forwarding-context { + key "context-type context-id"; + uses context-key; + + uses forwarding-fields; + } + + list network-domain { + key "network-domain-type network-domain-id"; + uses network-domain-key; + + uses forwarding-fields; + description "Network domain can be augmented with further information."; + } } } diff --git a/groupbasedpolicy/src/main/yang/model/l2-l3-forwarding.yang b/groupbasedpolicy/src/main/yang/model/l2-l3-forwarding.yang index 8be4874cf..ce977ee45 100644 --- a/groupbasedpolicy/src/main/yang/model/l2-l3-forwarding.yang +++ b/groupbasedpolicy/src/main/yang/model/l2-l3-forwarding.yang @@ -13,6 +13,7 @@ module l2-l3-forwarding { prefix "l2-l3-forwarding"; import forwarding { prefix forwarding; revision-date 2016-04-27; } + import renderer { prefix renderer; revision-date 2015-11-03; } import ietf-inet-types { prefix inet; revision-date 2010-09-24; } import yang-ext {prefix ext; revision-date 2013-07-09;} @@ -49,29 +50,32 @@ module l2-l3-forwarding { base forwarding:address-type; } - grouping subnet-fields { - leaf ip-prefix { - description "The IP prefix that defines the subnet"; - type inet:ip-prefix; - } - leaf virtual-router-ip { - description - "IP address to use for a virtual gateway router - for the subnet, if desired."; - type inet:ip-address; - } - list gateways { - description - "External gateways for subnets we serve, - includes prefixes for static routing"; - key "gateway"; - leaf gateway { + grouping has-subnet { + container subnet { + when "../forwarding:network-domain-type = 'l2-l3-forwarding:subnet'"; + leaf ip-prefix { + description "The IP prefix that defines the subnet"; + type inet:ip-prefix; + } + leaf virtual-router-ip { + description + "IP address to use for a virtual gateway router + for the subnet, if desired."; type inet:ip-address; } - list prefixes { - key "prefix"; - leaf prefix { - type inet:ip-prefix; + list gateways { + description + "External gateways for subnets we serve, + includes prefixes for static routing"; + key "gateway"; + leaf gateway { + type inet:ip-address; + } + list prefixes { + key "prefix"; + leaf prefix { + type inet:ip-prefix; + } } } } @@ -79,12 +83,12 @@ module l2-l3-forwarding { augment "/forwarding:forwarding/forwarding:forwarding-by-tenant/forwarding:network-domain" { ext:augment-identifier "subnet-augment-forwarding"; - container subnet { - when "../forwarding:network-domain-type = 'l2-l3-forwarding:subnet'"; - uses subnet-fields; - } + uses has-subnet; } - // TODO add augment to renderer.yang + augment "/renderer:renderers/renderer:renderer/renderer:renderer-policy/renderer:configuration/renderer:renderer-forwarding/renderer:renderer-forwarding-by-tenant/renderer:renderer-network-domain" { + ext:augment-identifier "subnet-augment-renderer"; + uses has-subnet; + } } diff --git a/groupbasedpolicy/src/main/yang/model/renderer.yang b/groupbasedpolicy/src/main/yang/model/renderer.yang index 8d052d433..444a1c5e5 100755 --- a/groupbasedpolicy/src/main/yang/model/renderer.yang +++ b/groupbasedpolicy/src/main/yang/model/renderer.yang @@ -240,11 +240,30 @@ module renderer { } } - container forwarding-contexts { - list forwarding-context-by-tenant { + container renderer-forwarding { + list renderer-forwarding-by-tenant { min-elements 1; key tenant-id; - uses forwarding:forwarding-with-tenant-fields; + leaf tenant-id { + type gbp-common:tenant-id; + description + "The tenant with which forwarding is associated"; + } + + list renderer-forwarding-context { + key "context-type context-id"; + uses forwarding:context-key; + + uses forwarding:forwarding-fields; + } + + list renderer-network-domain { + key "network-domain-type network-domain-id"; + uses forwarding:network-domain-key; + + uses forwarding:forwarding-fields; + description "Renderer network domain can be augmented with further information."; + } } } } diff --git a/groupbasedpolicy/src/test/java/org/opendaylight/groupbasedpolicy/base_endpoint/BaseEndpointRpcRegistryTest.java b/groupbasedpolicy/src/test/java/org/opendaylight/groupbasedpolicy/base_endpoint/BaseEndpointRpcRegistryTest.java deleted file mode 100644 index b83bcc541..000000000 --- a/groupbasedpolicy/src/test/java/org/opendaylight/groupbasedpolicy/base_endpoint/BaseEndpointRpcRegistryTest.java +++ /dev/null @@ -1,623 +0,0 @@ -/* - * Copyright (c) 2016 Cisco Systems, Inc. and others. All rights reserved. - * - * This program and the accompanying materials are made available under the - * terms of the Eclipse Public License v1.0 which accompanies this distribution, - * and is available at http://www.eclipse.org/legal/epl-v10.html - */ - -package org.opendaylight.groupbasedpolicy.base_endpoint; - -import static org.mockito.Mockito.mock; - -import com.google.common.base.Optional; -import com.google.common.collect.ImmutableList; -import org.junit.Assert; -import org.junit.Before; -import org.junit.Test; -import org.opendaylight.controller.md.sal.binding.api.DataBroker; -import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction; -import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType; -import org.opendaylight.controller.sal.binding.api.RpcProviderRegistry; -import org.opendaylight.groupbasedpolicy.api.BaseEndpointRendererAugmentation; -import org.opendaylight.groupbasedpolicy.test.CustomDataBrokerTest; -import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.common.endpoint.fields.NetworkContainmentBuilder; -import org.opendaylight.groupbasedpolicy.util.DataStoreHelper; -import org.opendaylight.groupbasedpolicy.util.IidFactory; -import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.Endpoints; -import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.RegisterEndpointInput; -import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.RegisterEndpointInputBuilder; -import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.UnregisterEndpointInput; -import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.UnregisterEndpointInputBuilder; -import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.common.endpoint.fields.network.containment.containment.NetworkDomainContainment; -import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.common.endpoint.fields.network.containment.containment.NetworkDomainContainmentBuilder; -import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.endpoints.AddressEndpoints; -import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.endpoints.ContainmentEndpoints; -import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.endpoints.address.endpoints.AddressEndpoint; -import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.endpoints.address.endpoints.AddressEndpointBuilder; -import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.endpoints.address.endpoints.AddressEndpointKey; -import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.endpoints.containment.endpoints.ContainmentEndpoint; -import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.endpoints.containment.endpoints.ContainmentEndpointBuilder; -import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.endpoints.containment.endpoints.ContainmentEndpointKey; -import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.has.child.endpoints.ChildEndpoint; -import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.has.child.endpoints.ChildEndpointBuilder; -import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.parent.child.endpoints.ParentEndpointChoice; -import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.parent.child.endpoints.parent.endpoint.choice.ParentContainmentEndpointCase; -import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.parent.child.endpoints.parent.endpoint.choice.ParentEndpointCase; -import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.parent.child.endpoints.parent.endpoint.choice.ParentEndpointCaseBuilder; -import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.parent.child.endpoints.parent.endpoint.choice.parent.endpoint._case.ParentEndpoint; -import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.parent.child.endpoints.parent.endpoint.choice.parent.endpoint._case.ParentEndpointBuilder; -import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.register.endpoint.input.AddressEndpointRegBuilder; -import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.register.endpoint.input.ContainmentEndpointReg; -import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.register.endpoint.input.ContainmentEndpointRegBuilder; -import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.unregister.endpoint.input.AddressEndpointUnregBuilder; -import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.unregister.endpoint.input.ContainmentEndpointUnreg; -import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.unregister.endpoint.input.ContainmentEndpointUnregBuilder; -import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.ContextId; -import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.NetworkDomainId; -import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.TenantId; -import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.forwarding.l2_l3.rev160427.IpPrefixType; -import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.forwarding.l2_l3.rev160427.L2FloodDomain; -import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.forwarding.l2_l3.rev160427.L3Context; -import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.forwarding.l2_l3.rev160427.MacAddressType; -import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.forwarding.l2_l3.rev160427.Subnet; -import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; -import org.opendaylight.yangtools.yang.common.RpcResult; - -import java.util.ArrayList; -import java.util.Collection; -import java.util.Collections; -import java.util.List; -import java.util.concurrent.Future; - -import javax.annotation.Nonnull; - -public class BaseEndpointRpcRegistryTest extends CustomDataBrokerTest { - - private static final String MAC_ADDRESS = "01:23:45:67:89:AB"; - private static final String IP_ADDRESS = "192.168.100.1/24"; - private static final String TENANT = "admin"; - private static final String DOMAIN = "test.domain"; - private static final String CONTEXT_ID = "testContext"; - private static final long timestamp = 1234567890L; - - private enum AddressEndpointRegistration { - CHILD, PARENT, BOTH, NONE - } - private enum AddressEndpointType { - L2, L3, BOTH, NONE - } - - private DataBroker dataProvider; - private BaseEndpointRendererAugmentation baseEndpointRendererAugmentation; - private BaseEndpointRpcRegistry baseEndpointRpcRegistry; - private AddressEndpoint basel2Ep; - private AddressEndpoint basel3Ep; - private ContainmentEndpoint baseContainmentEp; - private ParentEndpoint basel3Parent; - private ChildEndpoint basel2Child; - - @Nonnull - @Override - public Collection> getClassesFromModules() { - return ImmutableList.of(Endpoints.class, AddressEndpoints.class, ContainmentEndpoints.class, - MacAddressType.class, IpPrefixType.class); - } - - @Before - public void init() { - dataProvider = getDataBroker(); - baseEndpointRendererAugmentation = mock(BaseEndpointRendererAugmentation.class); - RpcProviderRegistry rpcRegistry = mock(RpcProviderRegistry.class); - - baseEndpointRpcRegistry = new BaseEndpointRpcRegistry(dataProvider, rpcRegistry); - - NetworkDomainContainment - networkDomainContainment = - new NetworkDomainContainmentBuilder().setNetworkDomainId(new NetworkDomainId(DOMAIN)).setNetworkDomainType( - Subnet.class).build(); - - basel3Parent = new ParentEndpointBuilder().setAddress(IP_ADDRESS) - .setAddressType(IpPrefixType.class) - .setContextId(new ContextId(CONTEXT_ID)) - .setContextType(L3Context.class) - .build(); - - basel2Child = new ChildEndpointBuilder().setAddress(MAC_ADDRESS) - .setAddressType(MacAddressType.class) - .setContextId(new ContextId(CONTEXT_ID)) - .setContextType(L2FloodDomain.class) - .build(); - - basel2Ep = new AddressEndpointBuilder().setTimestamp(timestamp) - .setContextId(new ContextId(CONTEXT_ID)) - .setContextType(L2FloodDomain.class) - .setTenant(new TenantId(TENANT)) - .setAddress(MAC_ADDRESS) - .setAddressType(MacAddressType.class) - .setNetworkContainment(new NetworkContainmentBuilder().setContainment(networkDomainContainment).build()) - .setTimestamp(timestamp) - .setParentEndpointChoice( - new ParentEndpointCaseBuilder().setParentEndpoint(Collections.singletonList(basel3Parent)).build()) - .build(); - - basel3Ep = new AddressEndpointBuilder().setTimestamp(timestamp) - .setContextId(new ContextId(CONTEXT_ID)) - .setContextType(L3Context.class) - .setTenant(new TenantId(TENANT)) - .setAddress(IP_ADDRESS) - .setAddressType(IpPrefixType.class) - .setNetworkContainment(new NetworkContainmentBuilder().setContainment(networkDomainContainment).build()) - .setTimestamp(timestamp) - .setChildEndpoint(Collections.singletonList(basel2Child)) - .build(); - - baseContainmentEp = new ContainmentEndpointBuilder().setTimestamp(timestamp) - .setContextId(new ContextId(CONTEXT_ID)) - .setContextType(L2FloodDomain.class) - .setTenant(new TenantId(TENANT)) - .setNetworkContainment(new NetworkContainmentBuilder().setContainment(networkDomainContainment).build()) - .setChildEndpoint(Collections.singletonList(basel2Child)) - .build(); - } - - @Test - public void testConstructor() throws Exception { - RpcProviderRegistry rpcRegistry = mock(RpcProviderRegistry.class); - BaseEndpointRpcRegistry registry = new BaseEndpointRpcRegistry(dataProvider, rpcRegistry); - registry.close(); - } - - @Test - public void testRegister() throws Exception { - baseEndpointRpcRegistry.register(baseEndpointRendererAugmentation); - Assert.assertEquals(1, BaseEndpointRpcRegistry.registeredRenderers.size()); - - baseEndpointRpcRegistry.unregister(baseEndpointRendererAugmentation); - Assert.assertEquals(0, BaseEndpointRpcRegistry.registeredRenderers.size()); - } - - @Test - public void testRegisterEndpoint() throws Exception { - RegisterEndpointInput input = - createRegisterEndpointInputVariablesForTest(AddressEndpointRegistration.BOTH, AddressEndpointType.BOTH, true); - - baseEndpointRpcRegistry.registerEndpoint(input); - - ReadOnlyTransaction transaction = dataProvider.newReadOnlyTransaction(); - - AddressEndpointKey key = new AddressEndpointKey(MAC_ADDRESS, MacAddressType.class, new ContextId(CONTEXT_ID), - L2FloodDomain.class); - Optional addressEndpointL2 = DataStoreHelper.readFromDs(LogicalDatastoreType.OPERATIONAL, - IidFactory.addressEndpointIid(key), transaction); - - Assert.assertTrue(addressEndpointL2.isPresent()); - - if (addressEndpointL2.isPresent()) { - Assert.assertEquals(basel2Ep, addressEndpointL2.get()); - } - - key = new AddressEndpointKey(IP_ADDRESS, IpPrefixType.class, new ContextId(CONTEXT_ID), L3Context.class); - - Optional addressEndpointL3 = DataStoreHelper.readFromDs(LogicalDatastoreType.OPERATIONAL, - IidFactory.addressEndpointIid(key), transaction); - - Assert.assertTrue(addressEndpointL3.isPresent()); - - if (addressEndpointL3.isPresent()) { - Assert.assertEquals(basel3Ep, addressEndpointL3.get()); - } - - ContainmentEndpointKey containmentEndpointKey = - new ContainmentEndpointKey(new ContextId(CONTEXT_ID), L2FloodDomain.class); - - Optional ContainmentEndpoint = DataStoreHelper.readFromDs(LogicalDatastoreType.OPERATIONAL, - IidFactory.containmentEndpointIid(containmentEndpointKey), transaction); - - Assert.assertTrue(ContainmentEndpoint.isPresent()); - - if (ContainmentEndpoint.isPresent()) { - Assert.assertEquals(baseContainmentEp, ContainmentEndpoint.get()); - } - } - - @Test - public void testRegisterEndpointWithParentUpdate() throws Exception { - setupBasicDataStore(); - RegisterEndpointInput input = - createRegisterEndpointInputVariablesForTest(AddressEndpointRegistration.BOTH, AddressEndpointType.L2, true); - - baseEndpointRpcRegistry.registerEndpoint(input); - - AddressEndpointKey key = new AddressEndpointKey(MAC_ADDRESS, MacAddressType.class, new ContextId(CONTEXT_ID), - L2FloodDomain.class); - Optional addressEndpointL2 = DataStoreHelper.readFromDs(LogicalDatastoreType.OPERATIONAL, - IidFactory.addressEndpointIid(key), dataProvider.newReadOnlyTransaction()); - - Assert.assertTrue(addressEndpointL2.isPresent()); - - if (addressEndpointL2.isPresent()) { - ParentEndpointCase parentEndpointCase = - (ParentEndpointCase) addressEndpointL2.get().getParentEndpointChoice(); - List parentEndpoints = parentEndpointCase.getParentEndpoint(); - Assert.assertEquals(parentEndpoints.size(), 1); - } - - key = new AddressEndpointKey(IP_ADDRESS, IpPrefixType.class, new ContextId(CONTEXT_ID), L3Context.class); - - Optional addressEndpointL3 = DataStoreHelper.readFromDs(LogicalDatastoreType.OPERATIONAL, - IidFactory.addressEndpointIid(key), dataProvider.newReadOnlyTransaction()); - - Assert.assertTrue(addressEndpointL3.isPresent()); - - if (addressEndpointL3.isPresent()) { - Assert.assertEquals(addressEndpointL3.get().getChildEndpoint().size(), 1); - } - } - - @Test - public void testRegisterEndpointWithParentUpdateFail() throws Exception { - RegisterEndpointInput input = createRegisterEndpointInputVariablesForTest(AddressEndpointRegistration.BOTH, - AddressEndpointType.L2, true); - - Future> rpcResultFuture = baseEndpointRpcRegistry.registerEndpoint(input); - - Assert.assertFalse(rpcResultFuture.get().isSuccessful()); - Assert.assertNotNull(rpcResultFuture.get().getErrors()); - Assert.assertEquals(rpcResultFuture.get().getErrors().size(), 1); - } - - @Test - public void testRegisterEndpointWithChildUpdate() throws Exception { - setupBasicDataStore(); - RegisterEndpointInput input = - createRegisterEndpointInputVariablesForTest(AddressEndpointRegistration.BOTH, AddressEndpointType.L3, true); - - baseEndpointRpcRegistry.registerEndpoint(input); - - AddressEndpointKey key = new AddressEndpointKey(MAC_ADDRESS, MacAddressType.class, new ContextId(CONTEXT_ID), - L2FloodDomain.class); - Optional addressEndpointL2 = DataStoreHelper.readFromDs(LogicalDatastoreType.OPERATIONAL, - IidFactory.addressEndpointIid(key), dataProvider.newReadOnlyTransaction()); - - Assert.assertTrue(addressEndpointL2.isPresent()); - - if (addressEndpointL2.isPresent()) { - ParentEndpointCase parentEndpointCase = - (ParentEndpointCase) addressEndpointL2.get().getParentEndpointChoice(); - List parentEndpoints = parentEndpointCase.getParentEndpoint(); - Assert.assertEquals(parentEndpoints.size(), 1); - } - - key = new AddressEndpointKey(IP_ADDRESS, IpPrefixType.class, new ContextId(CONTEXT_ID), L3Context.class); - - Optional addressEndpointL3 = DataStoreHelper.readFromDs(LogicalDatastoreType.OPERATIONAL, - IidFactory.addressEndpointIid(key), dataProvider.newReadOnlyTransaction()); - - Assert.assertTrue(addressEndpointL3.isPresent()); - - if (addressEndpointL3.isPresent()) { - Assert.assertEquals(addressEndpointL3.get().getChildEndpoint().size(), 1); - } - } - - @Test - public void testRegisterEndpointWithChildUpdateFail() throws Exception { - RegisterEndpointInput input = createRegisterEndpointInputVariablesForTest(AddressEndpointRegistration.BOTH, - AddressEndpointType.L3, true); - - Future> rpcResultFuture = baseEndpointRpcRegistry.registerEndpoint(input); - - Assert.assertFalse(rpcResultFuture.get().isSuccessful()); - Assert.assertNotNull(rpcResultFuture.get().getErrors()); - Assert.assertEquals(rpcResultFuture.get().getErrors().size(), 1); - } - - private void setupBasicDataStore() throws Exception { - InstanceIdentifier id = InstanceIdentifier.builder(Endpoints.class).build(); - dataProvider.newWriteOnlyTransaction().delete(LogicalDatastoreType.OPERATIONAL, id); - - RegisterEndpointInput input = - createRegisterEndpointInputVariablesForTest(AddressEndpointRegistration.NONE, AddressEndpointType.BOTH, true); - - baseEndpointRpcRegistry.registerEndpoint(input); - - AddressEndpointKey key = new AddressEndpointKey(MAC_ADDRESS, MacAddressType.class, new ContextId(CONTEXT_ID), - L2FloodDomain.class); - Optional addressEndpointL2 = DataStoreHelper.readFromDs(LogicalDatastoreType.OPERATIONAL, - IidFactory.addressEndpointIid(key), dataProvider.newReadOnlyTransaction()); - - Assert.assertTrue(addressEndpointL2.isPresent()); - - if (addressEndpointL2.isPresent()) { - ParentEndpointCase parentEndpointCase = - (ParentEndpointCase) addressEndpointL2.get().getParentEndpointChoice(); - Assert.assertEquals(parentEndpointCase.getParentEndpoint().size(), 0); - } - - key = new AddressEndpointKey(IP_ADDRESS, IpPrefixType.class, new ContextId(CONTEXT_ID), L3Context.class); - - Optional addressEndpointL3 = DataStoreHelper.readFromDs(LogicalDatastoreType.OPERATIONAL, - IidFactory.addressEndpointIid(key), dataProvider.newReadOnlyTransaction()); - - Assert.assertTrue(addressEndpointL3.isPresent()); - - if (addressEndpointL3.isPresent()) { - Assert.assertEquals(addressEndpointL3.get().getChildEndpoint().size(), 0); - } - } - - @Test - public void testRegisterEndpointParentFail() throws Exception { - Future> rpcResultFuture = - baseEndpointRpcRegistry.registerEndpoint(createRegisterEndpointInputVariablesForTest( - AddressEndpointRegistration.PARENT, AddressEndpointType.BOTH, true)); - - RpcResult rpcResult = rpcResultFuture.get(); - - Assert.assertFalse(rpcResult.isSuccessful()); - Assert.assertNull(rpcResult.getResult()); - Assert.assertEquals(rpcResult.getErrors().size(), 1); - - } - - @Test - public void testRegisterEndpointChildFail() throws Exception { - Future> rpcResultFuture = - baseEndpointRpcRegistry.registerEndpoint(createRegisterEndpointInputVariablesForTest( - AddressEndpointRegistration.CHILD, AddressEndpointType.BOTH, true)); - - RpcResult rpcResult = rpcResultFuture.get(); - - Assert.assertFalse(rpcResult.isSuccessful()); - Assert.assertNull(rpcResult.getResult()); - Assert.assertEquals(rpcResult.getErrors().size(), 1); - } - - @Test - public void testUnregisterEndpointWithParent() throws Exception { - RegisterEndpointInput input = - createRegisterEndpointInputVariablesForTest(AddressEndpointRegistration.BOTH, AddressEndpointType.BOTH, true); - - baseEndpointRpcRegistry.registerEndpoint(input); - - AddressEndpointKey key = new AddressEndpointKey(MAC_ADDRESS, MacAddressType.class, new ContextId(CONTEXT_ID), - L2FloodDomain.class); - ContainmentEndpointKey cKey = new ContainmentEndpointKey(new ContextId(CONTEXT_ID), L2FloodDomain.class); - - Optional addressEndpointL2 = DataStoreHelper.readFromDs(LogicalDatastoreType.OPERATIONAL, - IidFactory.addressEndpointIid(key), dataProvider.newReadOnlyTransaction()); - - Assert.assertTrue(addressEndpointL2.isPresent()); - - if (addressEndpointL2.isPresent()) { - Assert.assertEquals(basel2Ep, addressEndpointL2.get()); - } - - Optional ContainmentEndpoint = DataStoreHelper.readFromDs(LogicalDatastoreType.OPERATIONAL, - IidFactory.containmentEndpointIid(cKey), dataProvider.newReadOnlyTransaction()); - - Assert.assertTrue(ContainmentEndpoint.isPresent()); - - if (ContainmentEndpoint.isPresent()) { - Assert.assertEquals(baseContainmentEp, ContainmentEndpoint.get()); - } - - baseEndpointRpcRegistry.unregisterEndpoint(unregisterEndpointInputParent()); - Optional endpointOptional = DataStoreHelper.readFromDs(LogicalDatastoreType.OPERATIONAL, - IidFactory.addressEndpointIid(key), dataProvider.newReadOnlyTransaction()); - - Assert.assertFalse(endpointOptional.isPresent()); - - Optional containmentEndpointOptional = - DataStoreHelper.readFromDs(LogicalDatastoreType.OPERATIONAL, IidFactory.containmentEndpointIid(cKey), - dataProvider.newReadOnlyTransaction()); - - Assert.assertFalse(containmentEndpointOptional.isPresent()); - } - - @Test - public void testUnregisterEndpointWithChild() throws Exception { - RegisterEndpointInput input = - createRegisterEndpointInputVariablesForTest(AddressEndpointRegistration.BOTH, AddressEndpointType.BOTH, true); - - baseEndpointRpcRegistry.registerEndpoint(input); - - AddressEndpointKey key = - new AddressEndpointKey(IP_ADDRESS, IpPrefixType.class, new ContextId(CONTEXT_ID), L3Context.class); - - Optional addressEndpointL3 = DataStoreHelper.readFromDs(LogicalDatastoreType.OPERATIONAL, - IidFactory.addressEndpointIid(key), dataProvider.newReadOnlyTransaction()); - - Assert.assertTrue(addressEndpointL3.isPresent()); - - if (addressEndpointL3.isPresent()) { - Assert.assertEquals(basel3Ep, addressEndpointL3.get()); - } - - baseEndpointRpcRegistry.unregisterEndpoint(unregisterEndpointInputChild()); - Optional endpointOptional = DataStoreHelper.readFromDs(LogicalDatastoreType.OPERATIONAL, - IidFactory.addressEndpointIid(key), dataProvider.newReadOnlyTransaction()); - - Assert.assertFalse(endpointOptional.isPresent()); - - } - - @Test - public void testRegisterContainmentEndpointWithChildFail() throws Exception { - Future> rpcResultFuture = - baseEndpointRpcRegistry.registerEndpoint(createRegisterEndpointInputVariablesForTest( - AddressEndpointRegistration.NONE, AddressEndpointType.NONE, true)); - - RpcResult rpcResult = rpcResultFuture.get(); - - Assert.assertFalse(rpcResult.isSuccessful()); - Assert.assertNull(rpcResult.getResult()); - Assert.assertEquals(rpcResult.getErrors().size(), 1); - } - - @Test - public void testUnregisterContainmentEndpointWithChild() throws Exception { - InstanceIdentifier id = InstanceIdentifier.builder(Endpoints.class).build(); - dataProvider.newWriteOnlyTransaction().delete(LogicalDatastoreType.OPERATIONAL, id); - - RegisterEndpointInput input = - createRegisterEndpointInputVariablesForTest(AddressEndpointRegistration.NONE, AddressEndpointType.L2, false); - - baseEndpointRpcRegistry.registerEndpoint(input); - - AddressEndpointKey key = new AddressEndpointKey(MAC_ADDRESS, MacAddressType.class, new ContextId(CONTEXT_ID), - L2FloodDomain.class); - - Optional addressEndpointL2 = DataStoreHelper.readFromDs(LogicalDatastoreType.OPERATIONAL, - IidFactory.addressEndpointIid(key), dataProvider.newReadOnlyTransaction()); - - Assert.assertTrue(addressEndpointL2.isPresent()); - if (addressEndpointL2.isPresent()){ - ParentEndpointChoice parentEndpointChoice = addressEndpointL2.get().getParentEndpointChoice(); - if(parentEndpointChoice instanceof ParentContainmentEndpointCase){ - ParentContainmentEndpointCase - parentEndpointCase = (ParentContainmentEndpointCase) parentEndpointChoice; - Assert.assertNull(parentEndpointCase.getParentContainmentEndpoint()); - } - } - - ContainmentEndpointReg containmentEndpointReg = new ContainmentEndpointRegBuilder().setTimestamp(baseContainmentEp.getTimestamp()) - .setContextId(baseContainmentEp.getContextId()) - .setContextType(baseContainmentEp.getContextType()) - .setTenant(baseContainmentEp.getTenant()) - .setNetworkContainment(baseContainmentEp.getNetworkContainment()) - .setChildEndpoint(Collections.singletonList(basel2Child)) - .build(); - - baseEndpointRpcRegistry.registerEndpoint(new RegisterEndpointInputBuilder().setContainmentEndpointReg(Collections.singletonList(containmentEndpointReg)).build()); - - addressEndpointL2 = DataStoreHelper.readFromDs(LogicalDatastoreType.OPERATIONAL, - IidFactory.addressEndpointIid(key), dataProvider.newReadOnlyTransaction()); - - Assert.assertTrue(addressEndpointL2.isPresent()); - if (addressEndpointL2.isPresent()) { - ParentEndpointChoice parentEndpointChoice = addressEndpointL2.get().getParentEndpointChoice(); - if(parentEndpointChoice instanceof ParentContainmentEndpointCase){ - ParentContainmentEndpointCase - parentEndpointCase = (ParentContainmentEndpointCase) parentEndpointChoice; - Assert.assertNotNull(parentEndpointCase.getParentContainmentEndpoint()); - Assert.assertEquals(parentEndpointCase.getParentContainmentEndpoint().size(),1); - } - } - - ContainmentEndpointUnreg containmentEndpointUnreg = new ContainmentEndpointUnregBuilder() - .setContextId(baseContainmentEp.getContextId()) - .setContextType(baseContainmentEp.getContextType()) - .build(); - - baseEndpointRpcRegistry.unregisterEndpoint(new UnregisterEndpointInputBuilder().setContainmentEndpointUnreg(Collections.singletonList(containmentEndpointUnreg)).build()); - - addressEndpointL2 = DataStoreHelper.readFromDs(LogicalDatastoreType.OPERATIONAL, - IidFactory.addressEndpointIid(key), dataProvider.newReadOnlyTransaction()); - - Assert.assertTrue(addressEndpointL2.isPresent()); - if (addressEndpointL2.isPresent()) { - ParentEndpointChoice parentEndpointChoice = addressEndpointL2.get().getParentEndpointChoice(); - if(parentEndpointChoice instanceof ParentContainmentEndpointCase){ - ParentContainmentEndpointCase - parentEndpointCase = (ParentContainmentEndpointCase) parentEndpointChoice; - Assert.assertNotNull(parentEndpointCase.getParentContainmentEndpoint()); - Assert.assertEquals(parentEndpointCase.getParentContainmentEndpoint().size(),0); - } - } - - } - - private UnregisterEndpointInput unregisterEndpointInputParent() { - UnregisterEndpointInputBuilder builder = new UnregisterEndpointInputBuilder(); - - builder.setAddressEndpointUnreg(new ArrayList<>()); - builder.setContainmentEndpointUnreg(new ArrayList<>()); - - builder.getAddressEndpointUnreg().add(new AddressEndpointUnregBuilder().setContextId(new ContextId(CONTEXT_ID)) - .setContextType(L2FloodDomain.class) - .setAddress(MAC_ADDRESS) - .setAddressType(MacAddressType.class) - .build()); - - builder.getContainmentEndpointUnreg().add(new ContainmentEndpointUnregBuilder() - .setContextId(new ContextId(CONTEXT_ID)).setContextType(L2FloodDomain.class).build()); - - return builder.build(); - } - - private UnregisterEndpointInput unregisterEndpointInputChild() { - UnregisterEndpointInputBuilder builder = new UnregisterEndpointInputBuilder(); - - builder.setAddressEndpointUnreg(new ArrayList<>()); - builder.setContainmentEndpointUnreg(new ArrayList<>()); - - builder.getAddressEndpointUnreg().add(new AddressEndpointUnregBuilder().setContextId(new ContextId(CONTEXT_ID)) - .setContextType(L3Context.class) - .setAddress(IP_ADDRESS) - .setAddressType(IpPrefixType.class) - .build()); - - return builder.build(); - } - - private RegisterEndpointInput createRegisterEndpointInputVariablesForTest(AddressEndpointRegistration registration, - AddressEndpointType type, boolean containmentEpPresent) throws Exception { - RegisterEndpointInputBuilder registerEndpointInputBuilder = new RegisterEndpointInputBuilder(); - long timestamp = System.currentTimeMillis(); - - List parentEndpoints = new ArrayList<>(); - if (registration == AddressEndpointRegistration.BOTH || registration == AddressEndpointRegistration.PARENT) { - parentEndpoints.add(basel3Parent); - } - - List childEndpoints = new ArrayList<>(); - if (registration == AddressEndpointRegistration.BOTH || registration == AddressEndpointRegistration.CHILD) { - childEndpoints.add(basel2Child); - } - - registerEndpointInputBuilder.setAddressEndpointReg(new ArrayList<>()); - registerEndpointInputBuilder.setContainmentEndpointReg(new ArrayList<>()); - - if (type == AddressEndpointType.BOTH || type == AddressEndpointType.L2) { - registerEndpointInputBuilder.getAddressEndpointReg() - .add(new AddressEndpointRegBuilder().setTimestamp(timestamp) - .setContextId(basel2Ep.getContextId()) - .setContextType(basel2Ep.getContextType()) - .setTenant(basel2Ep.getTenant()) - .setAddress(basel2Ep.getAddress()) - .setAddressType(basel2Ep.getAddressType()) - .setNetworkContainment(basel2Ep.getNetworkContainment()) - .setTimestamp(basel2Ep.getTimestamp()) - .setParentEndpointChoice(new ParentEndpointCaseBuilder().setParentEndpoint(parentEndpoints).build()) - .build()); - } - - if (type == AddressEndpointType.BOTH || type == AddressEndpointType.L3) { - registerEndpointInputBuilder.getAddressEndpointReg() - .add(new AddressEndpointRegBuilder().setContextId(basel3Ep.getContextId()) - .setContextType(basel3Ep.getContextType()) - .setTenant(basel3Ep.getTenant()) - .setAddress(basel3Ep.getAddress()) - .setAddressType(basel3Ep.getAddressType()) - .setNetworkContainment(basel3Ep.getNetworkContainment()) - .setTimestamp(basel3Ep.getTimestamp()) - .setChildEndpoint(childEndpoints) - .build()); - } - - if(containmentEpPresent) { - registerEndpointInputBuilder.getContainmentEndpointReg() - .add(new ContainmentEndpointRegBuilder().setTimestamp(baseContainmentEp.getTimestamp()) - .setContextId(baseContainmentEp.getContextId()) - .setContextType(baseContainmentEp.getContextType()) - .setTenant(baseContainmentEp.getTenant()) - .setNetworkContainment(baseContainmentEp.getNetworkContainment()) - .setChildEndpoint(Collections.singletonList(basel2Child)) - .build()); - } - - return registerEndpointInputBuilder.build(); - } -} diff --git a/groupbasedpolicy/src/test/java/org/opendaylight/groupbasedpolicy/base_endpoint/BaseEndpointServiceImplTest.java b/groupbasedpolicy/src/test/java/org/opendaylight/groupbasedpolicy/base_endpoint/BaseEndpointServiceImplTest.java new file mode 100644 index 000000000..9e0abe80e --- /dev/null +++ b/groupbasedpolicy/src/test/java/org/opendaylight/groupbasedpolicy/base_endpoint/BaseEndpointServiceImplTest.java @@ -0,0 +1,439 @@ +/* + * Copyright (c) 2016 Cisco Systems, Inc. and others. All rights reserved. + * + * This program and the accompanying materials are made available under the + * terms of the Eclipse Public License v1.0 which accompanies this distribution, + * and is available at http://www.eclipse.org/legal/epl-v10.html + */ + +package org.opendaylight.groupbasedpolicy.base_endpoint; + +import static org.mockito.Mockito.mock; + +import java.util.ArrayList; +import java.util.Arrays; +import java.util.Collection; +import java.util.List; + +import org.junit.Assert; +import org.junit.Before; +import org.junit.Test; +import org.opendaylight.controller.md.sal.binding.api.DataBroker; +import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction; +import org.opendaylight.controller.md.sal.binding.api.WriteTransaction; +import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType; +import org.opendaylight.controller.sal.binding.api.RpcProviderRegistry; +import org.opendaylight.groupbasedpolicy.test.CustomDataBrokerTest; +import org.opendaylight.groupbasedpolicy.util.DataStoreHelper; +import org.opendaylight.groupbasedpolicy.util.EndpointUtils; +import org.opendaylight.groupbasedpolicy.util.IidFactory; +import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.Endpoints; +import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.RegisterEndpointInputBuilder; +import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.UnregisterEndpointInputBuilder; +import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.common.endpoint.fields.NetworkContainmentBuilder; +import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.common.endpoint.fields.network.containment.containment.NetworkDomainContainment; +import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.common.endpoint.fields.network.containment.containment.NetworkDomainContainmentBuilder; +import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.endpoints.AddressEndpoints; +import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.endpoints.ContainmentEndpoints; +import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.endpoints.address.endpoints.AddressEndpoint; +import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.endpoints.address.endpoints.AddressEndpointBuilder; +import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.endpoints.containment.endpoints.ContainmentEndpoint; +import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.endpoints.containment.endpoints.ContainmentEndpointBuilder; +import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.has.child.endpoints.ChildEndpoint; +import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.has.child.endpoints.ChildEndpointBuilder; +import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.parent.child.endpoints.parent.endpoint.choice.ParentContainmentEndpointCaseBuilder; +import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.parent.child.endpoints.parent.endpoint.choice.ParentEndpointCaseBuilder; +import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.parent.child.endpoints.parent.endpoint.choice.parent.containment.endpoint._case.ParentContainmentEndpoint; +import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.parent.child.endpoints.parent.endpoint.choice.parent.containment.endpoint._case.ParentContainmentEndpointBuilder; +import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.parent.child.endpoints.parent.endpoint.choice.parent.endpoint._case.ParentEndpoint; +import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.parent.child.endpoints.parent.endpoint.choice.parent.endpoint._case.ParentEndpointBuilder; +import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.register.endpoint.input.AddressEndpointReg; +import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.register.endpoint.input.AddressEndpointRegBuilder; +import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.register.endpoint.input.ContainmentEndpointReg; +import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.register.endpoint.input.ContainmentEndpointRegBuilder; +import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.unregister.endpoint.input.AddressEndpointUnreg; +import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.unregister.endpoint.input.AddressEndpointUnregBuilder; +import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.unregister.endpoint.input.ContainmentEndpointUnreg; +import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.unregister.endpoint.input.ContainmentEndpointUnregBuilder; +import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.ContextId; +import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.NetworkDomainId; +import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.TenantId; +import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.forwarding.l2_l3.rev160427.IpPrefixType; +import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.forwarding.l2_l3.rev160427.L2FloodDomain; +import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.forwarding.l2_l3.rev160427.L3Context; +import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.forwarding.l2_l3.rev160427.MacAddressType; +import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.forwarding.l2_l3.rev160427.Subnet; +import org.opendaylight.yangtools.yang.common.RpcResult; + +import com.google.common.base.Optional; +import com.google.common.collect.ImmutableList; + +public class BaseEndpointServiceImplTest extends CustomDataBrokerTest { + + private static final String MAC_ADDRESS = "01:23:45:67:89:AB"; + private static final String IP_ADDRESS = "192.168.100.1/24"; + private static final String TENANT = "admin"; + private static final String DOMAIN = "test.domain"; + private static final String CONTEXT_ID = "testContext"; + private static final long timestamp = 1234567890L; + private static final NetworkDomainContainment networkDomainContainment = new NetworkDomainContainmentBuilder() + .setNetworkDomainId(new NetworkDomainId(DOMAIN)).setNetworkDomainType(Subnet.class).build(); + private static final ParentEndpoint BASE_L3_PARENT = new ParentEndpointBuilder().setAddress(IP_ADDRESS) + .setAddressType(IpPrefixType.class) + .setContextId(new ContextId(CONTEXT_ID)) + .setContextType(L3Context.class) + .build(); + private static final ChildEndpoint BASE_L2_CHILD = new ChildEndpointBuilder().setAddress(MAC_ADDRESS) + .setAddressType(MacAddressType.class) + .setContextId(new ContextId(CONTEXT_ID)) + .setContextType(L2FloodDomain.class) + .build(); + private static final ParentContainmentEndpoint BASE_CONT_PARENT = new ParentContainmentEndpointBuilder() + .setContextId(new ContextId(CONTEXT_ID)).setContextType(L2FloodDomain.class).build(); + + private DataBroker dataProvider; + private BaseEndpointServiceImpl baseEndpointRpcRegistry; + + @Override + public Collection> getClassesFromModules() { + return ImmutableList.of(Endpoints.class, AddressEndpoints.class, ContainmentEndpoints.class, + MacAddressType.class, IpPrefixType.class); + } + + @Before + public void init() { + dataProvider = getDataBroker(); + RpcProviderRegistry rpcRegistry = mock(RpcProviderRegistry.class); + + baseEndpointRpcRegistry = + new BaseEndpointServiceImpl(dataProvider, rpcRegistry, new EndpointAugmentorRegistryImpl()); + } + + @Test + public void testConstructor() throws Exception { + RpcProviderRegistry rpcRegistry = mock(RpcProviderRegistry.class); + BaseEndpointServiceImpl registry = + new BaseEndpointServiceImpl(dataProvider, rpcRegistry, new EndpointAugmentorRegistryImpl()); + registry.close(); + } + + @Test + public void testRegisterEndpoint() throws Exception { + AddressEndpoint l2EpWithL3Parent = + createBaseL2EpBuilder() + .setParentEndpointChoice( + new ParentEndpointCaseBuilder().setParentEndpoint(Arrays.asList(BASE_L3_PARENT)).build()) + .build(); + AddressEndpoint l3EpWithL2Child = + createBaseL3EpBuilder().setChildEndpoint(Arrays.asList(BASE_L2_CHILD)).build(); + ContainmentEndpoint contEp = createBaseContEpBuilder().build(); + RegisterEndpointInputBuilder inputBuilder = new RegisterEndpointInputBuilder(); + setAddrEpsToBuilder(inputBuilder, l2EpWithL3Parent, l3EpWithL2Child); + setContEpsToBuilder(inputBuilder, contEp); + + RpcResult rpcResult = baseEndpointRpcRegistry.registerEndpoint(inputBuilder.build()).get(); + Assert.assertTrue(rpcResult.isSuccessful()); + + ReadOnlyTransaction rTx = dataProvider.newReadOnlyTransaction(); + Optional addressEndpointL2 = DataStoreHelper.readFromDs(LogicalDatastoreType.OPERATIONAL, + IidFactory.addressEndpointIid(l2EpWithL3Parent.getKey()), rTx); + Assert.assertTrue(addressEndpointL2.isPresent()); + Assert.assertEquals(l2EpWithL3Parent, addressEndpointL2.get()); + + Optional addressEndpointL3 = DataStoreHelper.readFromDs(LogicalDatastoreType.OPERATIONAL, + IidFactory.addressEndpointIid(l3EpWithL2Child.getKey()), rTx); + Assert.assertTrue(addressEndpointL3.isPresent()); + Assert.assertEquals(l3EpWithL2Child, addressEndpointL3.get()); + + Optional ContainmentEndpoint = DataStoreHelper.readFromDs(LogicalDatastoreType.OPERATIONAL, + IidFactory.containmentEndpointIid(contEp.getKey()), rTx); + Assert.assertTrue(ContainmentEndpoint.isPresent()); + Assert.assertEquals(contEp, ContainmentEndpoint.get()); + } + + @Test + public void testRegisterEndpoint_withParentUpdate() throws Exception { + WriteTransaction wTx = getDataBroker().newWriteOnlyTransaction(); + AddressEndpoint baseL3Ep = createBaseL3EpBuilder().build(); + wTx.put(LogicalDatastoreType.OPERATIONAL, IidFactory.addressEndpointIid(baseL3Ep.getKey()), baseL3Ep); + wTx.submit().get(); + AddressEndpoint l2EpWithL3Parent = + createBaseL2EpBuilder() + .setParentEndpointChoice( + new ParentEndpointCaseBuilder().setParentEndpoint(Arrays.asList(BASE_L3_PARENT)).build()) + .build(); + RegisterEndpointInputBuilder inputBuilder = new RegisterEndpointInputBuilder(); + setAddrEpsToBuilder(inputBuilder, l2EpWithL3Parent); + + RpcResult rpcResult = baseEndpointRpcRegistry.registerEndpoint(inputBuilder.build()).get(); + Assert.assertTrue(rpcResult.isSuccessful()); + + ReadOnlyTransaction rTx = dataProvider.newReadOnlyTransaction(); + Optional addressEndpointL2 = DataStoreHelper.readFromDs(LogicalDatastoreType.OPERATIONAL, + IidFactory.addressEndpointIid(l2EpWithL3Parent.getKey()), rTx); + Assert.assertTrue(addressEndpointL2.isPresent()); + List parentEndpoints = + EndpointUtils.getParentEndpoints(addressEndpointL2.get().getParentEndpointChoice()); + Assert.assertEquals(1, parentEndpoints.size()); + + Optional addressEndpointL3 = DataStoreHelper.readFromDs(LogicalDatastoreType.OPERATIONAL, + IidFactory.addressEndpointIid(baseL3Ep.getKey()), rTx); + Assert.assertTrue(addressEndpointL3.isPresent()); + Assert.assertEquals(1, addressEndpointL3.get().getChildEndpoint().size()); + } + + @Test + public void testRegisterEndpoint_withChildUpdate() throws Exception { + WriteTransaction wTx = getDataBroker().newWriteOnlyTransaction(); + AddressEndpoint baseL2Ep = createBaseL2EpBuilder().build(); + wTx.put(LogicalDatastoreType.OPERATIONAL, IidFactory.addressEndpointIid(baseL2Ep.getKey()), baseL2Ep); + wTx.submit().get(); + AddressEndpoint l3EpWithL2Child = + createBaseL3EpBuilder().setChildEndpoint(Arrays.asList(BASE_L2_CHILD)).build(); + RegisterEndpointInputBuilder inputBuilder = new RegisterEndpointInputBuilder(); + setAddrEpsToBuilder(inputBuilder, l3EpWithL2Child); + + RpcResult rpcResult = baseEndpointRpcRegistry.registerEndpoint(inputBuilder.build()).get(); + Assert.assertTrue(rpcResult.isSuccessful()); + + ReadOnlyTransaction rTx = dataProvider.newReadOnlyTransaction(); + Optional addressEndpointL2 = DataStoreHelper.readFromDs(LogicalDatastoreType.OPERATIONAL, + IidFactory.addressEndpointIid(baseL2Ep.getKey()), rTx); + Assert.assertTrue(addressEndpointL2.isPresent()); + List parentEndpoints = + EndpointUtils.getParentEndpoints(addressEndpointL2.get().getParentEndpointChoice()); + Assert.assertEquals(1, parentEndpoints.size()); + + Optional addressEndpointL3 = DataStoreHelper.readFromDs(LogicalDatastoreType.OPERATIONAL, + IidFactory.addressEndpointIid(l3EpWithL2Child.getKey()), rTx); + Assert.assertTrue(addressEndpointL3.isPresent()); + Assert.assertEquals(1, addressEndpointL3.get().getChildEndpoint().size()); + } + + @Test + public void testRegisterEndpoint_rpcInput_missing_child() throws Exception { + AddressEndpoint l2EpWithL3Parent = + createBaseL2EpBuilder() + .setParentEndpointChoice( + new ParentEndpointCaseBuilder().setParentEndpoint(Arrays.asList(BASE_L3_PARENT)).build()) + .build(); + AddressEndpoint l3EpWithL2Child = createBaseL3EpBuilder().setChildEndpoint(Arrays.asList()).build(); + ContainmentEndpoint contEp = createBaseContEpBuilder().build(); + RegisterEndpointInputBuilder inputBuilder = new RegisterEndpointInputBuilder(); + setAddrEpsToBuilder(inputBuilder, l2EpWithL3Parent, l3EpWithL2Child); + setContEpsToBuilder(inputBuilder, contEp); + + RpcResult rpcResult = baseEndpointRpcRegistry.registerEndpoint(inputBuilder.build()).get(); + Assert.assertFalse(rpcResult.isSuccessful()); + Assert.assertNotNull(rpcResult.getErrors()); + Assert.assertEquals(1, rpcResult.getErrors().size()); + } + + @Test + public void testRegisterEndpoint_rpcInput_missingParent() throws Exception { + AddressEndpoint l2EpWithL3Parent = createBaseL2EpBuilder().build(); + AddressEndpoint l3EpWithL2Child = + createBaseL3EpBuilder().setChildEndpoint(Arrays.asList(BASE_L2_CHILD)).build(); + ContainmentEndpoint contEp = createBaseContEpBuilder().build(); + RegisterEndpointInputBuilder inputBuilder = new RegisterEndpointInputBuilder(); + setAddrEpsToBuilder(inputBuilder, l2EpWithL3Parent, l3EpWithL2Child); + setContEpsToBuilder(inputBuilder, contEp); + + RpcResult rpcResult = baseEndpointRpcRegistry.registerEndpoint(inputBuilder.build()).get(); + Assert.assertFalse(rpcResult.isSuccessful()); + Assert.assertNotNull(rpcResult.getErrors()); + Assert.assertEquals(1, rpcResult.getErrors().size()); + } + + @Test + public void testUnregisterEndpoint_withParent() throws Exception { + WriteTransaction wTx = getDataBroker().newWriteOnlyTransaction(); + AddressEndpoint l2EpWithL3EpParent = + createBaseL2EpBuilder() + .setParentEndpointChoice( + new ParentEndpointCaseBuilder().setParentEndpoint(Arrays.asList(BASE_L3_PARENT)).build()) + .build(); + wTx.put(LogicalDatastoreType.OPERATIONAL, IidFactory.addressEndpointIid(l2EpWithL3EpParent.getKey()), + l2EpWithL3EpParent); + AddressEndpoint l3EpWithL2EpChild = + createBaseL3EpBuilder().setChildEndpoint(Arrays.asList(BASE_L2_CHILD)).build(); + wTx.put(LogicalDatastoreType.OPERATIONAL, IidFactory.addressEndpointIid(l3EpWithL2EpChild.getKey()), + l3EpWithL2EpChild); + wTx.submit().get(); + + UnregisterEndpointInputBuilder inputBuilder = new UnregisterEndpointInputBuilder(); + setAddrEpsToBuilder(inputBuilder, l2EpWithL3EpParent); + RpcResult rpcResult = baseEndpointRpcRegistry.unregisterEndpoint(inputBuilder.build()).get(); + Assert.assertTrue(rpcResult.isSuccessful()); + + ReadOnlyTransaction rTx = dataProvider.newReadOnlyTransaction(); + Optional l2EpWithL3EpParentFromDsOptional = DataStoreHelper.readFromDs( + LogicalDatastoreType.OPERATIONAL, IidFactory.addressEndpointIid(l2EpWithL3EpParent.getKey()), rTx); + Assert.assertFalse(l2EpWithL3EpParentFromDsOptional.isPresent()); + + Optional l3EpWithL2EpChildFromDsOptional = DataStoreHelper.readFromDs( + LogicalDatastoreType.OPERATIONAL, IidFactory.addressEndpointIid(l3EpWithL2EpChild.getKey()), rTx); + Assert.assertTrue(l3EpWithL2EpChildFromDsOptional.isPresent()); + Assert.assertEquals(0, l3EpWithL2EpChildFromDsOptional.get().getChildEndpoint().size()); + } + + @Test + public void testUnregisterEndpoint_withChild() throws Exception { + WriteTransaction wTx = getDataBroker().newWriteOnlyTransaction(); + AddressEndpoint l2EpWithL3EpParent = + createBaseL2EpBuilder() + .setParentEndpointChoice( + new ParentEndpointCaseBuilder().setParentEndpoint(Arrays.asList(BASE_L3_PARENT)).build()) + .build(); + wTx.put(LogicalDatastoreType.OPERATIONAL, IidFactory.addressEndpointIid(l2EpWithL3EpParent.getKey()), + l2EpWithL3EpParent); + AddressEndpoint l3EpWithL2EpChild = + createBaseL3EpBuilder().setChildEndpoint(Arrays.asList(BASE_L2_CHILD)).build(); + wTx.put(LogicalDatastoreType.OPERATIONAL, IidFactory.addressEndpointIid(l3EpWithL2EpChild.getKey()), + l3EpWithL2EpChild); + wTx.submit().get(); + + UnregisterEndpointInputBuilder inputBuilder = new UnregisterEndpointInputBuilder(); + setAddrEpsToBuilder(inputBuilder, l3EpWithL2EpChild); + RpcResult rpcResult = baseEndpointRpcRegistry.unregisterEndpoint(inputBuilder.build()).get(); + Assert.assertTrue(rpcResult.isSuccessful()); + + ReadOnlyTransaction rTx = dataProvider.newReadOnlyTransaction(); + Optional l3EpWithL2EpChildFromDsOptional = DataStoreHelper.readFromDs( + LogicalDatastoreType.OPERATIONAL, IidFactory.addressEndpointIid(l3EpWithL2EpChild.getKey()), rTx); + Assert.assertFalse(l3EpWithL2EpChildFromDsOptional.isPresent()); + + Optional l2EpWithL3EpParentFromDsOptional = DataStoreHelper.readFromDs( + LogicalDatastoreType.OPERATIONAL, IidFactory.addressEndpointIid(l2EpWithL3EpParent.getKey()), rTx); + Assert.assertTrue(l2EpWithL3EpParentFromDsOptional.isPresent()); + Assert.assertEquals(0, EndpointUtils + .getParentEndpoints(l2EpWithL3EpParentFromDsOptional.get().getParentEndpointChoice()).size()); + } + + @Test + public void testRegisterEndpoint_containmentEndpointWithChildFail() throws Exception { + ContainmentEndpoint contEpWithChild = + createBaseContEpBuilder().setChildEndpoint(Arrays.asList(BASE_L2_CHILD)).build(); + RegisterEndpointInputBuilder inputBuilder = new RegisterEndpointInputBuilder(); + setContEpsToBuilder(inputBuilder, contEpWithChild); + RpcResult rpcResult = baseEndpointRpcRegistry.registerEndpoint(inputBuilder.build()).get(); + Assert.assertFalse(rpcResult.isSuccessful()); + Assert.assertNull(rpcResult.getResult()); + Assert.assertEquals(1, rpcResult.getErrors().size()); + } + + @Test + public void testUnregisterEndpoint_containmentEndpointWithChild() throws Exception { + WriteTransaction wTx = getDataBroker().newWriteOnlyTransaction(); + ContainmentEndpoint contEpWithL2EpChild = + createBaseContEpBuilder().setChildEndpoint(Arrays.asList(BASE_L2_CHILD)).build(); + wTx.put(LogicalDatastoreType.OPERATIONAL, IidFactory.containmentEndpointIid(contEpWithL2EpChild.getKey()), + contEpWithL2EpChild); + AddressEndpoint l2EpWithContEpParent = + createBaseL2EpBuilder().setParentEndpointChoice(new ParentContainmentEndpointCaseBuilder() + .setParentContainmentEndpoint(Arrays.asList(BASE_CONT_PARENT)).build()).build(); + wTx.put(LogicalDatastoreType.OPERATIONAL, IidFactory.addressEndpointIid(l2EpWithContEpParent.getKey()), + l2EpWithContEpParent); + wTx.submit().get(); + + UnregisterEndpointInputBuilder inputBuilder = new UnregisterEndpointInputBuilder(); + setContEpsToBuilder(inputBuilder, contEpWithL2EpChild); + RpcResult rpcResult = baseEndpointRpcRegistry.unregisterEndpoint(inputBuilder.build()).get(); + Assert.assertTrue(rpcResult.isSuccessful()); + + ReadOnlyTransaction rTx = dataProvider.newReadOnlyTransaction(); + Optional contEpWithL2EpChildFromDsOptional = DataStoreHelper.readFromDs( + LogicalDatastoreType.OPERATIONAL, IidFactory.containmentEndpointIid(contEpWithL2EpChild.getKey()), rTx); + Assert.assertFalse(contEpWithL2EpChildFromDsOptional.isPresent()); + + Optional l2EpWithContEpParentFromDsOptional = DataStoreHelper.readFromDs( + LogicalDatastoreType.OPERATIONAL, IidFactory.addressEndpointIid(l2EpWithContEpParent.getKey()), rTx); + Assert.assertTrue(l2EpWithContEpParentFromDsOptional.isPresent()); + Assert.assertEquals(0, EndpointUtils + .getParentEndpoints(l2EpWithContEpParentFromDsOptional.get().getParentEndpointChoice()).size()); + } + + private void setAddrEpsToBuilder(RegisterEndpointInputBuilder builder, AddressEndpoint... addrEndpoints) { + List addrEpRegs = new ArrayList<>(); + for (AddressEndpoint addrEp : addrEndpoints) { + addrEpRegs.add(new AddressEndpointRegBuilder().setTimestamp(timestamp) + .setContextId(addrEp.getContextId()) + .setContextType(addrEp.getContextType()) + .setTenant(addrEp.getTenant()) + .setAddress(addrEp.getAddress()) + .setAddressType(addrEp.getAddressType()) + .setNetworkContainment(addrEp.getNetworkContainment()) + .setTimestamp(addrEp.getTimestamp()) + .setParentEndpointChoice(addrEp.getParentEndpointChoice()) + .setChildEndpoint(addrEp.getChildEndpoint()) + .build()); + } + builder.setAddressEndpointReg(addrEpRegs); + } + + private void setContEpsToBuilder(RegisterEndpointInputBuilder builder, ContainmentEndpoint... contEndpoints) { + List contEpRegs = new ArrayList<>(); + for (ContainmentEndpoint contEp : contEndpoints) { + contEpRegs.add(new ContainmentEndpointRegBuilder().setTimestamp(contEp.getTimestamp()) + .setContextId(contEp.getContextId()) + .setContextType(contEp.getContextType()) + .setTenant(contEp.getTenant()) + .setNetworkContainment(contEp.getNetworkContainment()) + .setChildEndpoint(contEp.getChildEndpoint()) + .build()); + } + builder.setContainmentEndpointReg(contEpRegs); + } + + private void setAddrEpsToBuilder(UnregisterEndpointInputBuilder builder, AddressEndpoint... addrEndpoints) { + List addrEpUnregs = new ArrayList<>(); + for (AddressEndpoint addrEp : addrEndpoints) { + addrEpUnregs.add(new AddressEndpointUnregBuilder().setContextId(addrEp.getContextId()) + .setContextType(addrEp.getContextType()) + .setAddress(addrEp.getAddress()) + .setAddressType(addrEp.getAddressType()) + .build()); + } + builder.setAddressEndpointUnreg(addrEpUnregs); + } + + private void setContEpsToBuilder(UnregisterEndpointInputBuilder builder, ContainmentEndpoint... contEndpoints) { + List contEpUnregs = new ArrayList<>(); + for (ContainmentEndpoint contEp : contEndpoints) { + contEpUnregs.add(new ContainmentEndpointUnregBuilder().setContextId(contEp.getContextId()) + .setContextType(contEp.getContextType()) + .build()); + } + builder.setContainmentEndpointUnreg(contEpUnregs); + } + + private AddressEndpointBuilder createBaseL2EpBuilder() { + return new AddressEndpointBuilder().setTimestamp(timestamp) + .setContextId(new ContextId(CONTEXT_ID)) + .setContextType(L2FloodDomain.class) + .setTenant(new TenantId(TENANT)) + .setAddress(MAC_ADDRESS) + .setAddressType(MacAddressType.class) + .setNetworkContainment(new NetworkContainmentBuilder().setContainment(networkDomainContainment).build()) + .setTimestamp(timestamp); + } + + private AddressEndpointBuilder createBaseL3EpBuilder() { + return new AddressEndpointBuilder().setTimestamp(timestamp) + .setContextId(new ContextId(CONTEXT_ID)) + .setContextType(L3Context.class) + .setTenant(new TenantId(TENANT)) + .setAddress(IP_ADDRESS) + .setAddressType(IpPrefixType.class) + .setNetworkContainment(new NetworkContainmentBuilder().setContainment(networkDomainContainment).build()) + .setTimestamp(timestamp); + } + + private ContainmentEndpointBuilder createBaseContEpBuilder() { + return new ContainmentEndpointBuilder().setTimestamp(timestamp) + .setContextId(new ContextId(CONTEXT_ID)) + .setContextType(L2FloodDomain.class) + .setTenant(new TenantId(TENANT)) + .setNetworkContainment(new NetworkContainmentBuilder().setContainment(networkDomainContainment).build()); + } +} diff --git a/groupbasedpolicy/src/test/java/org/opendaylight/groupbasedpolicy/base_endpoint/EndpointAugmentorRegistryImplTest.java b/groupbasedpolicy/src/test/java/org/opendaylight/groupbasedpolicy/base_endpoint/EndpointAugmentorRegistryImplTest.java new file mode 100644 index 000000000..7ad1070eb --- /dev/null +++ b/groupbasedpolicy/src/test/java/org/opendaylight/groupbasedpolicy/base_endpoint/EndpointAugmentorRegistryImplTest.java @@ -0,0 +1,29 @@ +package org.opendaylight.groupbasedpolicy.base_endpoint; + +import static org.mockito.Mockito.mock; + +import org.junit.Assert; +import org.junit.Before; +import org.junit.Test; +import org.opendaylight.groupbasedpolicy.api.EndpointAugmentor; + +public class EndpointAugmentorRegistryImplTest { + + private EndpointAugmentorRegistryImpl epAugmentorRegistry; + private EndpointAugmentor epAugmentor; + + @Before + public void init() { + epAugmentorRegistry = new EndpointAugmentorRegistryImpl(); + epAugmentor = mock(EndpointAugmentor.class); + } + + @Test + public void testRegisterUnregister() throws Exception { + epAugmentorRegistry.register(epAugmentor); + Assert.assertEquals(1, epAugmentorRegistry.getEndpointAugmentors().size()); + + epAugmentorRegistry.unregister(epAugmentor); + Assert.assertEquals(0, epAugmentorRegistry.getEndpointAugmentors().size()); + } +} diff --git a/groupbasedpolicy/src/test/java/org/opendaylight/groupbasedpolicy/renderer/RendererManagerDataBrokerTest.java b/groupbasedpolicy/src/test/java/org/opendaylight/groupbasedpolicy/renderer/RendererManagerDataBrokerTest.java index 1fde0ca02..1c6c9b14e 100644 --- a/groupbasedpolicy/src/test/java/org/opendaylight/groupbasedpolicy/renderer/RendererManagerDataBrokerTest.java +++ b/groupbasedpolicy/src/test/java/org/opendaylight/groupbasedpolicy/renderer/RendererManagerDataBrokerTest.java @@ -9,6 +9,7 @@ package org.opendaylight.groupbasedpolicy.renderer; import java.util.Arrays; +import java.util.Collections; import org.junit.Assert; import org.junit.Before; @@ -22,6 +23,7 @@ import org.opendaylight.controller.md.sal.binding.api.DataBroker; import org.opendaylight.controller.md.sal.binding.api.WriteTransaction; import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType; import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException; +import org.opendaylight.groupbasedpolicy.forwarding.NetworkDomainAugmentorRegistryImpl; import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.EndpointLocations; import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.EndpointLocationsBuilder; import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.EndpointsBuilder; @@ -43,7 +45,7 @@ import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.SubjectName; import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.forwarding.rev160427.ForwardingBuilder; import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.forwarding.rev160427.forwarding.ForwardingByTenantBuilder; -import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.forwarding.rev160427.forwarding.with.tenant.fields.ForwardingContextBuilder; +import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.forwarding.rev160427.forwarding.forwarding.by.tenant.ForwardingContextBuilder; import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.Tenants; import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.RendererName; import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.Renderers; @@ -56,8 +58,8 @@ import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.r import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.renderer.nodes.RendererNodeBuilder; import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.renderer.policy.Configuration; import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.renderer.policy.configuration.Endpoints; -import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.renderer.policy.configuration.ForwardingContexts; import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.renderer.policy.configuration.RendererEndpoints; +import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.renderer.policy.configuration.RendererForwarding; import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.renderer.policy.configuration.RuleGroups; import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.resolved.policy.rev150828.ResolvedPolicies; import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.resolved.policy.rev150828.ResolvedPoliciesBuilder; @@ -92,6 +94,8 @@ public class RendererManagerDataBrokerTest { @Mock private DataBroker dataProvider; @Mock + private NetworkDomainAugmentorRegistryImpl netDomainAugmentorRegistry; + @Mock private WriteTransaction wTx; @Mock private CheckedFuture submitFuture; @@ -102,7 +106,8 @@ public class RendererManagerDataBrokerTest { public void init() { Mockito.when(dataProvider.newWriteOnlyTransaction()).thenReturn(wTx); Mockito.when(wTx.submit()).thenReturn(submitFuture); - rendererManager = new RendererManager(dataProvider); + Mockito.when(netDomainAugmentorRegistry.getEndpointAugmentors()).thenReturn(Collections.emptySet()); + rendererManager = new RendererManager(dataProvider, netDomainAugmentorRegistry); RendererManager.resetVersion(); } @@ -173,9 +178,9 @@ public class RendererManagerDataBrokerTest { Assert.assertNotNull(rendererEndpoints); Assert.assertEquals(2, rendererEndpoints.getRendererEndpoint().size()); - ForwardingContexts forwardingContexts = configuration.getForwardingContexts(); - Assert.assertNotNull(forwardingContexts); - Assert.assertEquals(1, forwardingContexts.getForwardingContextByTenant().size()); + RendererForwarding rendererForwarding = configuration.getRendererForwarding(); + Assert.assertNotNull(rendererForwarding); + Assert.assertEquals(1, rendererForwarding.getRendererForwardingByTenant().size()); Endpoints endpoints = configuration.getEndpoints(); Assert.assertNotNull(endpoints); @@ -274,9 +279,9 @@ public class RendererManagerDataBrokerTest { Assert.assertNotNull(rendererEndpoints); Assert.assertEquals(1, rendererEndpoints.getRendererEndpoint().size()); - ForwardingContexts forwardingContexts = configuration.getForwardingContexts(); - Assert.assertNotNull(forwardingContexts); - Assert.assertEquals(1, forwardingContexts.getForwardingContextByTenant().size()); + RendererForwarding rendererForwarding = configuration.getRendererForwarding(); + Assert.assertNotNull(rendererForwarding); + Assert.assertEquals(1, rendererForwarding.getRendererForwardingByTenant().size()); Endpoints endpoints = configuration.getEndpoints(); Assert.assertNotNull(endpoints); @@ -357,9 +362,9 @@ public class RendererManagerDataBrokerTest { Assert.assertNotNull(rendererEndpoints); Assert.assertEquals(1, rendererEndpoints.getRendererEndpoint().size()); - ForwardingContexts forwardingContexts = configuration.getForwardingContexts(); - Assert.assertNotNull(forwardingContexts); - Assert.assertEquals(1, forwardingContexts.getForwardingContextByTenant().size()); + RendererForwarding rendererForwarding = configuration.getRendererForwarding(); + Assert.assertNotNull(rendererForwarding); + Assert.assertEquals(1, rendererForwarding.getRendererForwardingByTenant().size()); Endpoints endpoints = configuration.getEndpoints(); Assert.assertNotNull(endpoints); diff --git a/groupbasedpolicy/src/test/java/org/opendaylight/groupbasedpolicy/renderer/RendererManagerTest.java b/groupbasedpolicy/src/test/java/org/opendaylight/groupbasedpolicy/renderer/RendererManagerTest.java index 6c792d8f2..0aa8a2574 100644 --- a/groupbasedpolicy/src/test/java/org/opendaylight/groupbasedpolicy/renderer/RendererManagerTest.java +++ b/groupbasedpolicy/src/test/java/org/opendaylight/groupbasedpolicy/renderer/RendererManagerTest.java @@ -12,14 +12,17 @@ import static org.junit.Assert.assertEquals; import static org.junit.Assert.assertFalse; import static org.junit.Assert.assertTrue; +import java.util.Collections; import java.util.Set; import org.junit.Before; import org.junit.Test; import org.junit.runner.RunWith; import org.mockito.Mock; +import org.mockito.Mockito; import org.mockito.runners.MockitoJUnitRunner; import org.opendaylight.controller.md.sal.binding.api.DataBroker; +import org.opendaylight.groupbasedpolicy.forwarding.NetworkDomainAugmentorRegistryImpl; import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.EndpointLocations; import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.EndpointLocationsBuilder; import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.Endpoints; @@ -70,12 +73,15 @@ public class RendererManagerTest { @Mock private DataBroker dataProvider; + @Mock + private NetworkDomainAugmentorRegistryImpl netDomainAugmentorRegistry; private RendererManager rendererManager; @Before public void init() { - rendererManager = new RendererManager(dataProvider); + Mockito.when(netDomainAugmentorRegistry.getEndpointAugmentors()).thenReturn(Collections.emptySet()); + rendererManager = new RendererManager(dataProvider, netDomainAugmentorRegistry); } /** -- 2.36.6