Introducing RPCs for remote calls to VPP

Allowing other plugins to interact with VPP by
using VPP renderer.
RPCs allow creating bridge domains, interfaces
and assigning bridge domains to interfaces.

Change-Id: Iddcf4b127ebe5757405d6041746a9559365156ee
Signed-off-by: Tomas Cechvala <tcechval@cisco.com>

diff --git a/neutron-vpp-mapper/src/main/java/org/opendaylight/groupbasedpolicy/neutron/vpp/mapper/processors/NetworkAware.java b/neutron-vpp-mapper/src/main/java/org/opendaylight/groupbasedpolicy/neutron/vpp/mapper/processors/NetworkAware.java
index 265c8e90a04e470bece400ed4aeba6474c00cc60..577e36eaf96ce17c506d4022f5861d2155748cdb 100644 (file)
--- a/neutron-vpp-mapper/src/main/java/org/opendaylight/groupbasedpolicy/neutron/vpp/mapper/processors/NetworkAware.java
+++ b/neutron-vpp-mapper/src/main/java/org/opendaylight/groupbasedpolicy/neutron/vpp/mapper/processors/NetworkAware.java
@@ -23,8 +23,8 @@ import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_render
 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_renderer.rev160425.config.GbpBridgeDomain;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_renderer.rev160425.config.GbpBridgeDomainBuilder;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_renderer.rev160425.config.GbpBridgeDomainKey;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_renderer.rev160425.config.gbp.bridge.domain.PhysicalLocationRef;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_renderer.rev160425.config.gbp.bridge.domain.PhysicalLocationRefBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_renderer.rev160425.bridge.domain.base.attributes.PhysicalLocationRef;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_renderer.rev160425.bridge.domain.base.attributes.PhysicalLocationRefBuilder;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.l2.types.rev130827.VlanId;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.networks.rev150712.NetworkTypeFlat;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.networks.rev150712.NetworkTypeVlan;

diff --git a/neutron-vpp-mapper/src/main/java/org/opendaylight/groupbasedpolicy/neutron/vpp/mapper/processors/PortHandler.java b/neutron-vpp-mapper/src/main/java/org/opendaylight/groupbasedpolicy/neutron/vpp/mapper/processors/PortHandler.java
index 434da171c2dc0900e5027ff7125c2f4a917800b1..fb7fdfa262dba6aec5f70c40c280976ac5041719 100644 (file)
--- a/neutron-vpp-mapper/src/main/java/org/opendaylight/groupbasedpolicy/neutron/vpp/mapper/processors/PortHandler.java
+++ b/neutron-vpp-mapper/src/main/java/org/opendaylight/groupbasedpolicy/neutron/vpp/mapper/processors/PortHandler.java
@@ -32,11 +32,11 @@ import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_render
 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_renderer.rev160425.config.VppEndpoint;\r
 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_renderer.rev160425.config.VppEndpointBuilder;\r
 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_renderer.rev160425.config.VppEndpointKey;\r
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_renderer.rev160425.config.vpp.endpoint._interface.type.choice.LoopbackCase;\r
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_renderer.rev160425.config.vpp.endpoint._interface.type.choice.LoopbackCaseBuilder;\r
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_renderer.rev160425.config.vpp.endpoint._interface.type.choice.TapCase;\r
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_renderer.rev160425.config.vpp.endpoint._interface.type.choice.TapCaseBuilder;\r
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_renderer.rev160425.config.vpp.endpoint._interface.type.choice.VhostUserCaseBuilder;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_renderer.rev160425._interface.attributes._interface.type.choice.LoopbackCase;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_renderer.rev160425._interface.attributes._interface.type.choice.LoopbackCaseBuilder;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_renderer.rev160425._interface.attributes._interface.type.choice.TapCase;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_renderer.rev160425._interface.attributes._interface.type.choice.TapCaseBuilder;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_renderer.rev160425._interface.attributes._interface.type.choice.VhostUserCaseBuilder;\r
 import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.binding.rev150712.PortBindingExtension;\r
 import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.binding.rev150712.binding.attributes.VifDetails;\r
 import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.l3.rev150712.routers.attributes.Routers;\r

diff --git a/neutron-vpp-mapper/src/test/java/org/opendaylight/groupbasedpolicy/neutron/vpp/mapper/processors/NetworkAwareTest.java b/neutron-vpp-mapper/src/test/java/org/opendaylight/groupbasedpolicy/neutron/vpp/mapper/processors/NetworkAwareTest.java
index 2a1e84bae8c90b6e8cc18f189b5597bb778f4f13..5b45f216213fc0af07a65df1a536e257f7b74b3b 100644 (file)
--- a/neutron-vpp-mapper/src/test/java/org/opendaylight/groupbasedpolicy/neutron/vpp/mapper/processors/NetworkAwareTest.java
+++ b/neutron-vpp-mapper/src/test/java/org/opendaylight/groupbasedpolicy/neutron/vpp/mapper/processors/NetworkAwareTest.java
@@ -29,7 +29,7 @@ import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.
 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_renderer.rev160425.FlatNetwork;\r
 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_renderer.rev160425.VlanNetwork;\r
 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_renderer.rev160425.config.GbpBridgeDomain;\r
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_renderer.rev160425.config.gbp.bridge.domain.PhysicalLocationRef;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_renderer.rev160425.bridge.domain.base.attributes.PhysicalLocationRef;\r
 import org.opendaylight.yang.gen.v1.urn.opendaylight.l2.types.rev130827.VlanId;\r
 import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.networks.rev150712.NetworkTypeFlat;\r
 import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.networks.rev150712.NetworkTypeVlan;\r

diff --git a/neutron-vpp-mapper/src/test/java/org/opendaylight/groupbasedpolicy/neutron/vpp/mapper/processors/PortHandlerTest.java b/neutron-vpp-mapper/src/test/java/org/opendaylight/groupbasedpolicy/neutron/vpp/mapper/processors/PortHandlerTest.java
index fd9d3cf8db0fa42bd488870a0376396fc1e80825..7e2eadf2cefd01b1cb9d75f69650f9383cc9e91f 100644 (file)
--- a/neutron-vpp-mapper/src/test/java/org/opendaylight/groupbasedpolicy/neutron/vpp/mapper/processors/PortHandlerTest.java
+++ b/neutron-vpp-mapper/src/test/java/org/opendaylight/groupbasedpolicy/neutron/vpp/mapper/processors/PortHandlerTest.java
@@ -36,7 +36,7 @@ import org.opendaylight.groupbasedpolicy.neutron.vpp.mapper.SocketInfo;
 import org.opendaylight.groupbasedpolicy.util.DataStoreHelper;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.neutron.gbp.mapper.rev150513.mappings.gbp.by.neutron.mappings.base.endpoints.by.ports.BaseEndpointByPort;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_renderer.rev160425.config.VppEndpoint;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_renderer.rev160425.config.vpp.endpoint._interface.type.choice.VhostUserCase;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_renderer.rev160425._interface.attributes._interface.type.choice.VhostUserCase;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.ports.rev150712.ports.attributes.Ports;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.ports.rev150712.ports.attributes.ports.Port;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.rev150712.Neutron;

diff --git a/renderers/vpp/src/main/java/org/opendaylight/controller/config/yang/config/vpp_provider/impl/GbpVppProviderInstance.java b/renderers/vpp/src/main/java/org/opendaylight/controller/config/yang/config/vpp_provider/impl/GbpVppProviderInstance.java
index 566b5e9e36295ceaaff4ba925bb45066946471a1..1e548e1b2b70677d31cae60449f4a06ba02f0a2f 100644 (file)
--- a/renderers/vpp/src/main/java/org/opendaylight/controller/config/yang/config/vpp_provider/impl/GbpVppProviderInstance.java
+++ b/renderers/vpp/src/main/java/org/opendaylight/controller/config/yang/config/vpp_provider/impl/GbpVppProviderInstance.java
@@ -8,20 +8,33 @@
 
 package org.opendaylight.controller.config.yang.config.vpp_provider.impl;
 
+import java.util.concurrent.Future;
+
 import com.google.common.base.Preconditions;
 import com.google.common.util.concurrent.Futures;
 import com.google.common.util.concurrent.ListenableFuture;
+
 import org.opendaylight.controller.config.yang.config.groupbasedpolicy.GroupbasedpolicyInstance;
 import org.opendaylight.controller.md.sal.binding.api.DataBroker;
 import org.opendaylight.controller.sal.binding.api.BindingAwareBroker;
+import org.opendaylight.groupbasedpolicy.renderer.vpp.adapter.VppRpcServiceImpl;
 import org.opendaylight.mdsal.singleton.common.api.ClusterSingletonService;
 import org.opendaylight.mdsal.singleton.common.api.ClusterSingletonServiceProvider;
 import org.opendaylight.mdsal.singleton.common.api.ClusterSingletonServiceRegistration;
 import org.opendaylight.mdsal.singleton.common.api.ServiceGroupIdentifier;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_adapter.rev161201.AddInterfaceToBridgeDomainInput;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_adapter.rev161201.CreateInterfaceOnNodeInput;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_adapter.rev161201.CreateVirtualBridgeDomainOnNodesInput;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_adapter.rev161201.DelInterfaceFromBridgeDomainInput;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_adapter.rev161201.DeleteInterfaceInput;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_adapter.rev161201.DeleteVirtualBridgeDomainOnNodesInput;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_adapter.rev161201.ExpandVirtualBridgeDomainOnNodesInput;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_adapter.rev161201.VppAdapterService;
+import org.opendaylight.yangtools.yang.common.RpcResult;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
-public class GbpVppProviderInstance implements ClusterSingletonService, AutoCloseable {
+public class GbpVppProviderInstance implements ClusterSingletonService, VppAdapterService, AutoCloseable {
 
     private static final Logger LOG = LoggerFactory.getLogger(GbpVppProviderInstance.class);
 
@@ -81,4 +94,39 @@ public class GbpVppProviderInstance implements ClusterSingletonService, AutoClos
     public ServiceGroupIdentifier getIdentifier() {
         return IDENTIFIER;
     }
+
+    @Override
+    public Future<RpcResult<Void>> deleteVirtualBridgeDomainOnNodes(DeleteVirtualBridgeDomainOnNodesInput input) {
+        return renderer.getVppRpcServiceImpl().deleteVirtualBridgeDomain(input);
+    }
+
+    @Override
+    public Future<RpcResult<Void>> createVirtualBridgeDomainOnNodes(CreateVirtualBridgeDomainOnNodesInput input) {
+        return renderer.getVppRpcServiceImpl().createVirtualBridgeDomain(input);
+    }
+
+    @Override
+    public Future<RpcResult<Void>> createInterfaceOnNode(CreateInterfaceOnNodeInput input) {
+        return renderer.getVppRpcServiceImpl().createInterfaceOnNode(input);
+    }
+
+    @Override
+    public Future<RpcResult<Void>> deleteInterface(DeleteInterfaceInput input) {
+        return renderer.getVppRpcServiceImpl().deleteInterfaceOnNode(input);
+    }
+
+    @Override
+    public Future<RpcResult<Void>> addInterfaceToBridgeDomain(AddInterfaceToBridgeDomainInput input) {
+        return renderer.getVppRpcServiceImpl().addInterfaceToBridgeDomain(input);
+    }
+
+    @Override
+    public Future<RpcResult<Void>> delInterfaceFromBridgeDomain(DelInterfaceFromBridgeDomainInput input) {
+        return renderer.getVppRpcServiceImpl().delInterfaceFromBridgeDomain(input);
+    }
+
+    @Override
+    public Future<RpcResult<Void>> expandVirtualBridgeDomainOnNodes(ExpandVirtualBridgeDomainOnNodesInput input) {
+        return renderer.getVppRpcServiceImpl().expandVirtualBridgeDomainOnNode(input);
+    }
 }

diff --git a/renderers/vpp/src/main/java/org/opendaylight/controller/config/yang/config/vpp_provider/impl/VppRenderer.java b/renderers/vpp/src/main/java/org/opendaylight/controller/config/yang/config/vpp_provider/impl/VppRenderer.java
index 72b896f7ca743c970cbf5d66954aebf7049162f7..3e7a9b5bb182af9d100142ff12811ccc57994bf1 100644 (file)
--- a/renderers/vpp/src/main/java/org/opendaylight/controller/config/yang/config/vpp_provider/impl/VppRenderer.java
+++ b/renderers/vpp/src/main/java/org/opendaylight/controller/config/yang/config/vpp_provider/impl/VppRenderer.java
@@ -19,6 +19,8 @@ import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
 import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
 import org.opendaylight.controller.sal.binding.api.BindingAwareBroker;
 import org.opendaylight.controller.sal.binding.api.BindingAwareProvider;
+import org.opendaylight.groupbasedpolicy.renderer.vpp.api.BridgeDomainManager;
+import org.opendaylight.groupbasedpolicy.renderer.vpp.adapter.VppRpcServiceImpl;
 import org.opendaylight.groupbasedpolicy.renderer.vpp.iface.InterfaceManager;
 import org.opendaylight.groupbasedpolicy.renderer.vpp.listener.RendererPolicyListener;
 import org.opendaylight.groupbasedpolicy.renderer.vpp.listener.VppEndpointListener;
@@ -81,6 +83,7 @@ public class VppRenderer implements AutoCloseable, BindingAwareProvider {
     private VppNodeListener vppNodeListener;
     private VppEndpointListener vppEndpointListener;
     private RendererPolicyListener rendererPolicyListener;
+    private VppRpcServiceImpl vppRpcServiceImpl;
 
     public VppRenderer(DataBroker dataBroker, BindingAwareBroker bindingAwareBroker) {
         this.dataBroker = Preconditions.checkNotNull(dataBroker);
@@ -118,14 +121,15 @@ public class VppRenderer implements AutoCloseable, BindingAwareProvider {
                 context.getSubscriber(), context.getSubscriberMethod(), exception));
         interfaceManager = new InterfaceManager(mountDataProvider, dataBroker, NETCONF_WORKER);
         dtoEventBus.register(interfaceManager);
-        ForwardingManager fwManager = new ForwardingManager(interfaceManager, new BridgeDomainManagerImpl(dataBroker), dataBroker);
+        BridgeDomainManager bdManager = new BridgeDomainManagerImpl(dataBroker);
+        ForwardingManager fwManager = new ForwardingManager(interfaceManager, bdManager, dataBroker);
         vppRendererPolicyManager = new VppRendererPolicyManager(fwManager, dataBroker);
         dtoEventBus.register(vppRendererPolicyManager);
 
         vppNodeListener = new VppNodeListener(dataBroker, vppNodeManager, dtoEventBus);
         vppEndpointListener = new VppEndpointListener(dataBroker, dtoEventBus);
         rendererPolicyListener = new RendererPolicyListener(dataBroker, dtoEventBus);
-
+        vppRpcServiceImpl = new VppRpcServiceImpl(dataBroker, mountDataProvider, bdManager, interfaceManager);
         registerToRendererManager();
     }
 
@@ -175,4 +179,8 @@ public class VppRenderer implements AutoCloseable, BindingAwareProvider {
             }
         });
     }
+
+    VppRpcServiceImpl getVppRpcServiceImpl() {
+        return vppRpcServiceImpl;
+    }
 }

diff --git a/renderers/vpp/src/main/java/org/opendaylight/groupbasedpolicy/renderer/vpp/external/VppRpcServiceImpl.java b/renderers/vpp/src/main/java/org/opendaylight/groupbasedpolicy/renderer/vpp/external/VppRpcServiceImpl.java
new file mode 100644 (file)
index 0000000..6544816
--- /dev/null
+++ b/renderers/vpp/src/main/java/org/opendaylight/groupbasedpolicy/renderer/vpp/external/VppRpcServiceImpl.java
@@ -0,0 +1,315 @@
+/*\r
+ * Copyright (c) 2016 Cisco Systems, Inc. and others. All rights reserved.\r
+ *\r
+ * This program and the accompanying materials are made available under the\r
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,\r
+ * and is available at http://www.eclipse.org/legal/epl-v10.html\r
+ */\r
+\r
+package org.opendaylight.groupbasedpolicy.renderer.vpp.adapter;\r
+\r
+import java.util.ArrayList;\r
+import java.util.List;\r
+import java.util.concurrent.Future;\r
+import java.util.stream.Collectors;\r
+\r
+import javax.annotation.Nonnull;\r
+\r
+import org.opendaylight.controller.md.sal.binding.api.DataBroker;\r
+import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;\r
+import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;\r
+import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;\r
+import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;\r
+import org.opendaylight.groupbasedpolicy.renderer.vpp.api.BridgeDomainManager;\r
+import org.opendaylight.groupbasedpolicy.renderer.vpp.commands.ConfigCommand;\r
+import org.opendaylight.groupbasedpolicy.renderer.vpp.commands.TapPortCommand;\r
+import org.opendaylight.groupbasedpolicy.renderer.vpp.commands.VhostUserCommand;\r
+import org.opendaylight.groupbasedpolicy.renderer.vpp.commands.VhostUserCommand.VhostUserCommandBuilder;\r
+import org.opendaylight.groupbasedpolicy.renderer.vpp.iface.InterfaceManager;\r
+import org.opendaylight.groupbasedpolicy.renderer.vpp.util.General.Operations;\r
+import org.opendaylight.groupbasedpolicy.renderer.vpp.util.MountedDataBrokerProvider;\r
+import org.opendaylight.groupbasedpolicy.renderer.vpp.util.VppIidFactory;\r
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.Interface;\r
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.InterfaceKey;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_adapter.rev161201.AddInterfaceToBridgeDomainInput;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_adapter.rev161201.CreateInterfaceOnNodeInput;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_adapter.rev161201.CreateVirtualBridgeDomainOnNodesInput;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_adapter.rev161201.DelInterfaceFromBridgeDomainInput;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_adapter.rev161201.DeleteInterfaceInput;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_adapter.rev161201.DeleteVirtualBridgeDomainOnNodesInput;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_adapter.rev161201.ExpandVirtualBridgeDomainOnNodesInput;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_adapter.rev161201.bridge.domain.attributes.tunnel.type.Vlan;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_adapter.rev161201.bridge.domain.attributes.tunnel.type.Vxlan;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_renderer.rev160425._interface.attributes.InterfaceTypeChoice;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_renderer.rev160425._interface.attributes._interface.type.choice.TapCase;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_renderer.rev160425._interface.attributes._interface.type.choice.VhostUserCase;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.l2.types.rev130827.VlanId;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev161214.VhostUserRole;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev161214.VxlanVni;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vbridge.topology.rev160129.TopologyTypesVbridgeAugment;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vbridge.topology.rev160129.TopologyVbridgeAugment;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vbridge.tunnel.vlan.rev160429.TunnelTypeVlan;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vbridge.tunnel.vlan.rev160429.network.topology.topology.tunnel.parameters.VlanNetworkParameters;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vbridge.tunnel.vxlan.rev160429.TunnelTypeVxlan;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vbridge.tunnel.vxlan.rev160429.network.topology.topology.tunnel.parameters.VxlanTunnelParameters;\r
+import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.NodeId;\r
+import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.TopologyId;\r
+import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.Topology;\r
+import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.TopologyKey;\r
+import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.TopologyTypes;\r
+import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;\r
+import org.opendaylight.yangtools.yang.common.RpcError.ErrorType;\r
+import org.opendaylight.yangtools.yang.common.RpcResult;\r
+import org.opendaylight.yangtools.yang.common.RpcResultBuilder;\r
+import org.slf4j.Logger;\r
+import org.slf4j.LoggerFactory;\r
+\r
+import com.google.common.base.Optional;\r
+import com.google.common.util.concurrent.AsyncFunction;\r
+import com.google.common.util.concurrent.CheckedFuture;\r
+import com.google.common.util.concurrent.Futures;\r
+import com.google.common.util.concurrent.ListenableFuture;\r
+\r
+public class VppRpcServiceImpl {\r
+\r
+    private static final Logger LOG = LoggerFactory.getLogger(VppRpcServiceImpl.class);\r
+\r
+    private final DataBroker dataBroker;\r
+    private final BridgeDomainManager bridgeDomainManager;\r
+    private final InterfaceManager interfaceManager;\r
+    private final MountedDataBrokerProvider mountDataProvider;\r
+\r
+    public VppRpcServiceImpl(@Nonnull DataBroker dataBroker, @Nonnull MountedDataBrokerProvider mountDataProvider,\r
+            BridgeDomainManager bridgeDomainManager, InterfaceManager interfaceManager) {\r
+        this.dataBroker = dataBroker;\r
+        this.bridgeDomainManager = bridgeDomainManager;\r
+        this.interfaceManager = interfaceManager;\r
+        this.mountDataProvider = mountDataProvider;\r
+    }\r
+\r
+    public Future<RpcResult<Void>> createVirtualBridgeDomain(CreateVirtualBridgeDomainOnNodesInput input) {\r
+        if (input.getTunnelType() == null) {\r
+            return Futures.immediateFuture(RpcResultBuilder.<Void>failed()\r
+                .withError(ErrorType.RPC,\r
+                        "Failed to create bridge domain" + input.getId() + "." + "Tunnel type not specified")\r
+                .build());\r
+        }\r
+        List<ListenableFuture<Void>> futures = new ArrayList<>();\r
+        List<NodeId> nodeIds = input.getPhysicalLocationRef()\r
+            .stream()\r
+            .map(locationRef -> locationRef.getNodeId())\r
+            .collect(Collectors.toList());\r
+        if (input.getTunnelType() instanceof Vxlan) {\r
+            Vxlan tunnelType = (Vxlan) input.getTunnelType();\r
+            VxlanVni vxlanVni = new VxlanVni(tunnelType.getVni().getValue());\r
+            nodeIds.forEach(nodeId -> {\r
+                futures.add(bridgeDomainManager.createVxlanBridgeDomainOnVppNode(input.getId(), vxlanVni, nodeId));\r
+            });\r
+        } else if (input.getTunnelType() instanceof Vlan) {\r
+            Vlan vlan = (Vlan) input.getTunnelType();\r
+            VlanId vlanId = new VlanId(vlan.getVlanId().getValue());\r
+            nodeIds.forEach(nodeId -> {\r
+                futures.add(bridgeDomainManager.createVlanBridgeDomainOnVppNode(input.getId(), vlanId, nodeId));\r
+            });\r
+        }\r
+        return Futures.transform(Futures.allAsList(futures), voidsToRpcResult());\r
+    }\r
+\r
+    public Future<RpcResult<Void>> deleteVirtualBridgeDomain(DeleteVirtualBridgeDomainOnNodesInput input) {\r
+        List<ListenableFuture<Void>> futures = new ArrayList<>();\r
+        input.getBridgeDomainNode().forEach(nodeId -> {\r
+            futures.add(bridgeDomainManager.removeBridgeDomainFromVppNode(input.getBridgeDomainId(), nodeId));\r
+        });\r
+        return Futures.transform(Futures.allAsList(futures), voidsToRpcResult());\r
+    }\r
+\r
+    public ListenableFuture<RpcResult<Void>> expandVirtualBridgeDomainOnNode(ExpandVirtualBridgeDomainOnNodesInput input) {\r
+        List<ListenableFuture<Void>> futures = new ArrayList<>();\r
+        ReadOnlyTransaction rTx = dataBroker.newReadOnlyTransaction();\r
+        InstanceIdentifier<Topology> topologyIid = VppIidFactory.getTopologyIid(new TopologyKey(new TopologyId(\r
+                input.getBridgeDomainId())));\r
+        return Futures.transform(rTx.read(LogicalDatastoreType.OPERATIONAL, topologyIid),\r
+                new AsyncFunction<Optional<Topology>, RpcResult<Void>>() {\r
+\r
+                    @Override\r
+                    public ListenableFuture<RpcResult<Void>> apply(Optional<Topology> optTopology) throws Exception {\r
+                        if (!optTopology.isPresent()) {\r
+\r
+                            return Futures.immediateFuture(RpcResultBuilder.<Void>failed()\r
+                                .withError(\r
+                                        ErrorType.RPC,\r
+                                        "Failed to expand bridge domain. Bridge domain " + input.getBridgeDomainId()\r
+                                                + " does not exist.")\r
+                                .build());\r
+                        }\r
+                        TopologyTypes topologyTypes = optTopology.get().getTopologyTypes();\r
+                        if (topologyTypes == null\r
+                                || topologyTypes.getAugmentation(TopologyTypesVbridgeAugment.class) == null\r
+                                || optTopology.get().getAugmentation(TopologyVbridgeAugment.class) == null) {\r
+                            return Futures.immediateFuture(RpcResultBuilder.<Void>failed()\r
+                                .withError(\r
+                                        ErrorType.RPC,\r
+                                        "Failed to expand bridge domain. Topology " + input.getBridgeDomainId()\r
+                                                + " is not bridge domain type.")\r
+                                .build());\r
+                        }\r
+                        TopologyVbridgeAugment vBridge = optTopology.get()\r
+                            .getAugmentation(TopologyVbridgeAugment.class);\r
+                        if (vBridge.getTunnelParameters() instanceof TunnelTypeVxlan) {\r
+                            VxlanTunnelParameters vxlanTunnelParams = (VxlanTunnelParameters) vBridge.getTunnelParameters();\r
+                            VxlanVni vni = vxlanTunnelParams.getVni();\r
+                            input.getBridgeDomainNode().forEach(\r
+                                    nodeId -> {\r
+                                        futures.add(bridgeDomainManager.createVxlanBridgeDomainOnVppNode(\r
+                                                input.getBridgeDomainId(), vni, nodeId));\r
+                                    });\r
+                        } else if (vBridge.getTunnelParameters() instanceof TunnelTypeVlan) {\r
+                            VlanNetworkParameters vlanTunnelParams = (VlanNetworkParameters) vBridge.getTunnelParameters();\r
+                            VlanId vlanId = vlanTunnelParams.getVlanId();\r
+                            input.getBridgeDomainNode().forEach(\r
+                                    nodeId -> {\r
+                                        futures.add(bridgeDomainManager.createVlanBridgeDomainOnVppNode(\r
+                                                input.getBridgeDomainId(), vlanId, nodeId));\r
+                                    });\r
+                        }\r
+                        return Futures.transform(Futures.allAsList(futures), voidsToRpcResult());\r
+                    }\r
+                });\r
+    }\r
+\r
+    public ListenableFuture<RpcResult<Void>> createInterfaceOnNode(CreateInterfaceOnNodeInput input) {\r
+        InterfaceTypeChoice interfaceType = input.getInterfaceTypeChoice();\r
+        ConfigCommand ifaceCommand = null;\r
+        if (interfaceType instanceof VhostUserCase) {\r
+            VhostUserCommandBuilder vhostBuilder = VhostUserCommand.builder();\r
+            vhostBuilder.setName(input.getVppInterfaceName());\r
+            VhostUserCase vhostCase = (VhostUserCase) input.getInterfaceTypeChoice();\r
+            vhostBuilder.setSocket(vhostCase.getSocket());\r
+            vhostBuilder.setRole(VhostUserRole.Client);\r
+            vhostBuilder.setDescription(input.getDescription());\r
+            vhostBuilder.setOperation(Operations.PUT);\r
+            ifaceCommand = vhostBuilder.build();\r
+        }\r
+        if (interfaceType instanceof TapCase) {\r
+            TapPortCommand.TapPortCommandBuilder tapBuilder = TapPortCommand.builder();\r
+            TapCase tapIface = (TapCase) input.getInterfaceTypeChoice();\r
+            tapBuilder.setTapName(tapIface.getName());\r
+            tapBuilder.setPhysAddress(tapIface.getPhysicalAddress());\r
+            tapBuilder.setInterfaceName(input.getVppInterfaceName());\r
+            tapBuilder.setDescription(input.getDescription());\r
+            tapBuilder.setOperation(Operations.PUT);\r
+            ifaceCommand = tapBuilder.build();\r
+        }\r
+        Optional<DataBroker> optDataBroker = mountDataProvider.getDataBrokerForMountPoint(input.getVppNodePath());\r
+        if (!optDataBroker.isPresent()) {\r
+            return Futures.immediateFuture(RpcResultBuilder.<Void>failed()\r
+                .withError(ErrorType.RPC, "Cannot find data broker for mount point " + input.getVppNodePath())\r
+                .build());\r
+        }\r
+        return Futures.transform(interfaceManager.createInterfaceOnVpp(ifaceCommand, optDataBroker.get()),\r
+                voidToRpcResult());\r
+    }\r
+\r
+    public ListenableFuture<RpcResult<Void>> deleteInterfaceOnNode(DeleteInterfaceInput input) {\r
+        return Futures.transform(readInterface(input.getVppNodePath(), input.getVppInterfaceName()),\r
+                new AsyncFunction<Optional<Interface>, RpcResult<Void>>() {\r
+\r
+                    @Override\r
+                    public ListenableFuture<RpcResult<Void>> apply(Optional<Interface> optIface) throws Exception {\r
+                        InterfaceKey iKey = new InterfaceKey(input.getVppInterfaceName());\r
+                        if (!optIface.isPresent()) {\r
+                            return Futures.immediateFuture(RpcResultBuilder.<Void>failed()\r
+                                .withError(\r
+                                        ErrorType.RPC,\r
+                                        "Cannot delete interface " + iKey + " on node " + input.getVppNodePath()\r
+                                                + ". Not found or already deleted.")\r
+                                .build());\r
+                        }\r
+                        Optional<DataBroker> dataBroker = mountDataProvider.getDataBrokerForMountPoint(input.getVppNodePath());\r
+                        WriteTransaction wTx = dataBroker.get().newWriteOnlyTransaction();\r
+                        wTx.delete(LogicalDatastoreType.CONFIGURATION, VppIidFactory.getInterfaceIID(iKey));\r
+                        return Futures.transform(wTx.submit(), voidToRpcResult());\r
+                    }\r
+                });\r
+    }\r
+\r
+    public ListenableFuture<RpcResult<Void>> addInterfaceToBridgeDomain(AddInterfaceToBridgeDomainInput input) {\r
+        return Futures.transform(readInterface(input.getVppNodePath(), input.getVppInterfaceName()),\r
+                new AsyncFunction<Optional<Interface>, RpcResult<Void>>() {\r
+\r
+                    @Override\r
+                    public ListenableFuture<RpcResult<Void>> apply(Optional<Interface> optIface) throws Exception {\r
+                        InterfaceKey iKey = new InterfaceKey(input.getVppInterfaceName());\r
+                        if (!optIface.isPresent()) {\r
+                            return Futures.immediateFuture(RpcResultBuilder.<Void>failed()\r
+                                .withError(\r
+                                        ErrorType.RPC,\r
+                                        "Cannot add interface " + iKey + " to bridge domain on node "\r
+                                                + input.getVppNodePath() + ". Not found or deleted.")\r
+                                .build());\r
+                        }\r
+                        Optional<DataBroker> dataBroker = mountDataProvider.getDataBrokerForMountPoint(input.getVppNodePath());\r
+                        return Futures.transform(interfaceManager.configureInterface(dataBroker.get(), iKey,\r
+                                input.getBridgeDomainId(), null), voidToRpcResult());\r
+                    }\r
+                });\r
+    }\r
+\r
+    public ListenableFuture<RpcResult<Void>> delInterfaceFromBridgeDomain(DelInterfaceFromBridgeDomainInput input) {\r
+        return Futures.transform(readInterface(input.getVppNodePath(), input.getVppInterfaceName()),\r
+                new AsyncFunction<Optional<Interface>, RpcResult<Void>>() {\r
+\r
+                    @Override\r
+                    public ListenableFuture<RpcResult<Void>> apply(Optional<Interface> optIface) throws Exception {\r
+                        if (!optIface.isPresent()) {\r
+                            return Futures.immediateFuture(RpcResultBuilder.<Void>failed()\r
+                                .withError(\r
+                                        ErrorType.RPC,\r
+                                        "Cannot remove interface " + input.getVppInterfaceName()\r
+                                                + " from bridge domain on node " + input.getVppNodePath()\r
+                                                + ". Not found or deleted.")\r
+                                .build());\r
+                        }\r
+                        Optional<DataBroker> dataBroker = mountDataProvider.getDataBrokerForMountPoint(input.getVppNodePath());\r
+                        return Futures.transform(interfaceManager.removeInterfaceFromBridgeDomain(dataBroker.get(),\r
+                                optIface.get().getKey()), voidToRpcResult());\r
+                    }\r
+                });\r
+    }\r
+\r
+    private CheckedFuture<Optional<Interface>, ReadFailedException> readInterface(InstanceIdentifier<?> nodeIid,\r
+            String interfaceName) {\r
+        Optional<DataBroker> optDataBroker = mountDataProvider.getDataBrokerForMountPoint(nodeIid);\r
+        if (!optDataBroker.isPresent()) {\r
+            LOG.error("Cannot find data broker for node {}", nodeIid);\r
+            return Futures.immediateCheckedFuture(Optional.absent());\r
+        }\r
+        ReadOnlyTransaction rwTx = optDataBroker.get().newReadOnlyTransaction();\r
+        InterfaceKey iKey = new InterfaceKey(interfaceName);\r
+        InstanceIdentifier<Interface> interfaceIID = VppIidFactory.getInterfaceIID(iKey);\r
+        CheckedFuture<Optional<Interface>, ReadFailedException> readInterface = rwTx.read(\r
+                LogicalDatastoreType.CONFIGURATION, interfaceIID);\r
+        rwTx.close();\r
+        return readInterface;\r
+    }\r
+\r
+    private AsyncFunction<Void, RpcResult<Void>> voidToRpcResult() {\r
+        return new AsyncFunction<Void, RpcResult<Void>>() {\r
+\r
+            @Override\r
+            public ListenableFuture<RpcResult<Void>> apply(Void input) throws Exception {\r
+                return Futures.immediateFuture(RpcResultBuilder.<Void>success().build());\r
+            }\r
+        };\r
+    }\r
+\r
+    private AsyncFunction<List<Void>, RpcResult<Void>> voidsToRpcResult() {\r
+        return new AsyncFunction<List<Void>, RpcResult<Void>>() {\r
+\r
+            @Override\r
+            public ListenableFuture<RpcResult<Void>> apply(List<Void> input) throws Exception {\r
+                return Futures.immediateFuture(RpcResultBuilder.<Void>success().build());\r
+            }\r
+        };\r
+    }\r
+}\r

diff --git a/renderers/vpp/src/main/java/org/opendaylight/groupbasedpolicy/renderer/vpp/iface/InterfaceManager.java b/renderers/vpp/src/main/java/org/opendaylight/groupbasedpolicy/renderer/vpp/iface/InterfaceManager.java
index d3222249886752288cd9a304c44a1dd4d3d99bf9..256216441cdca4d692cc05b511168a8ec76f1f6e 100644 (file)
--- a/renderers/vpp/src/main/java/org/opendaylight/groupbasedpolicy/renderer/vpp/iface/InterfaceManager.java
+++ b/renderers/vpp/src/main/java/org/opendaylight/groupbasedpolicy/renderer/vpp/iface/InterfaceManager.java
@@ -8,18 +8,12 @@
 
 package org.opendaylight.groupbasedpolicy.renderer.vpp.iface;
 
-import javax.annotation.Nonnull;
-import javax.annotation.Nullable;
 import java.util.concurrent.ExecutionException;
 import java.util.concurrent.ExecutorService;
-import com.google.common.base.Optional;
-import com.google.common.base.Preconditions;
-import com.google.common.base.Strings;
-import com.google.common.eventbus.Subscribe;
-import com.google.common.util.concurrent.AsyncFunction;
-import com.google.common.util.concurrent.CheckedFuture;
-import com.google.common.util.concurrent.Futures;
-import com.google.common.util.concurrent.ListenableFuture;
+
+import javax.annotation.Nonnull;
+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;
@@ -33,17 +27,19 @@ import org.opendaylight.groupbasedpolicy.renderer.vpp.event.NodeOperEvent;
 import org.opendaylight.groupbasedpolicy.renderer.vpp.event.VppEndpointConfEvent;
 import org.opendaylight.groupbasedpolicy.renderer.vpp.util.General.Operations;
 import org.opendaylight.groupbasedpolicy.renderer.vpp.util.MountedDataBrokerProvider;
+import org.opendaylight.groupbasedpolicy.renderer.vpp.util.VppIidFactory;
 import org.opendaylight.groupbasedpolicy.util.DataStoreHelper;
 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.Interface;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.InterfaceKey;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.has.absolute.location.absolute.location.LocationType;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.has.absolute.location.absolute.location.location.type.ExternalLocationCase;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.has.absolute.location.absolute.location.location.type.ExternalLocationCaseBuilder;
 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.vpp_renderer.rev160425._interface.attributes.InterfaceTypeChoice;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_renderer.rev160425._interface.attributes._interface.type.choice.LoopbackCase;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_renderer.rev160425._interface.attributes._interface.type.choice.TapCase;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_renderer.rev160425._interface.attributes._interface.type.choice.VhostUserCase;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_renderer.rev160425.config.VppEndpoint;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_renderer.rev160425.config.vpp.endpoint.InterfaceTypeChoice;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_renderer.rev160425.config.vpp.endpoint._interface.type.choice.LoopbackCase;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_renderer.rev160425.config.vpp.endpoint._interface.type.choice.TapCase;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_renderer.rev160425.config.vpp.endpoint._interface.type.choice.VhostUserCase;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev161214.VhostUserRole;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev161214.VppInterfaceAugmentation;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev161214.interfaces._interface.L2;
@@ -56,6 +52,15 @@ import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
+import com.google.common.base.Optional;
+import com.google.common.base.Preconditions;
+import com.google.common.base.Strings;
+import com.google.common.eventbus.Subscribe;
+import com.google.common.util.concurrent.AsyncFunction;
+import com.google.common.util.concurrent.CheckedFuture;
+import com.google.common.util.concurrent.Futures;
+import com.google.common.util.concurrent.ListenableFuture;
+
 public class InterfaceManager implements AutoCloseable {
 
     private static final Logger LOG = LoggerFactory.getLogger(InterfaceManager.class);
@@ -115,23 +120,24 @@ public class InterfaceManager implements AutoCloseable {
             return Futures.immediateFuture(null);
         }
         DataBroker vppDataBroker = potentialVppDataProvider.get();
-        return createInterfaceOnVpp(ifaceWithoutBdCommand, vppDataBroker, vppEndpoint, vppNodeIid);
+        return Futures.transform(createInterfaceOnVpp(ifaceWithoutBdCommand, vppDataBroker),
+                new AsyncFunction<Void, Void>() {
+
+                    @Override
+                    public ListenableFuture<Void> apply(@Nonnull Void input) {
+                        LOG.debug("Create interface on VPP command was successful. VPP: {} Command: {}", vppNodeIid,
+                                ifaceWithoutBdCommand);
+                        return vppEndpointLocationProvider.createLocationForVppEndpoint(vppEndpoint);
+                    }
+                }, netconfWorker);
     }
 
-    private ListenableFuture<Void> createInterfaceOnVpp(ConfigCommand createIfaceWithoutBdCommand, DataBroker vppDataBroker,
-                                                        VppEndpoint vppEndpoint, InstanceIdentifier<?> vppNodeIid) {
+    public ListenableFuture<Void> createInterfaceOnVpp(ConfigCommand createIfaceWithoutBdCommand,
+            DataBroker vppDataBroker) {
         final ReadWriteTransaction rwTx = vppDataBroker.newReadWriteTransaction();
         createIfaceWithoutBdCommand.execute(rwTx);
         LOG.trace("Creating Interface on VPP: {}", createIfaceWithoutBdCommand);
-        return Futures.transform(rwTx.submit(), new AsyncFunction<Void, Void>() {
-
-            @Override
-            public ListenableFuture<Void> apply(@Nonnull Void input) {
-                LOG.debug("Create interface on VPP command was successful. VPP: {} Command: {}", vppNodeIid,
-                        createIfaceWithoutBdCommand);
-                return vppEndpointLocationProvider.createLocationForVppEndpoint(vppEndpoint);
-            }
-        }, netconfWorker);
+        return rwTx.submit();
     }
 
     private ListenableFuture<Void> vppEndpointUpdated(@Nonnull final VppEndpoint oldVppEndpoint,
@@ -174,24 +180,23 @@ public class InterfaceManager implements AutoCloseable {
             return Futures.immediateFuture(null);
         }
         DataBroker vppDataBroker = potentialVppDataProvider.get();
-        return deleteIfaceOnVpp(ifaceWithoutBdCommand, vppDataBroker, vppEndpoint, vppNodeIid);
+        return Futures.transform(deleteIfaceOnVpp(ifaceWithoutBdCommand, vppDataBroker),
+                new AsyncFunction<Void, Void>() {
+
+                    @Override
+                    public ListenableFuture<Void> apply(Void input) {
+                        LOG.debug("Delete interface on VPP command was successful: VPP: {} Command: {}", vppNodeIid,
+                                ifaceWithoutBdCommand);
+                        return vppEndpointLocationProvider.deleteLocationForVppEndpoint(vppEndpoint);
+                    }
+                }, netconfWorker);
     }
 
-    private ListenableFuture<Void> deleteIfaceOnVpp(ConfigCommand deleteIfaceWithoutBdCommand,
-            DataBroker vppDataBroker, VppEndpoint vppEndpoint, InstanceIdentifier<?> vppNodeIid) {
+    public ListenableFuture<Void> deleteIfaceOnVpp(ConfigCommand deleteIfaceWithoutBdCommand, DataBroker vppDataBroker) {
         ReadWriteTransaction rwTx = vppDataBroker.newReadWriteTransaction();
         deleteIfaceWithoutBdCommand.execute(rwTx);
         LOG.trace("Deleting Interface on VPP: {}", deleteIfaceWithoutBdCommand);
-
-        return Futures.transform(rwTx.submit(), new AsyncFunction<Void, Void>() {
-
-            @Override
-            public ListenableFuture<Void> apply(Void input) {
-                LOG.debug("Delete interface on VPP command was successful: VPP: {} Command: {}", vppNodeIid,
-                        deleteIfaceWithoutBdCommand);
-                return vppEndpointLocationProvider.deleteLocationForVppEndpoint(vppEndpoint);
-            }
-        }, netconfWorker);
+        return rwTx.submit();
     }
 
     @Subscribe
@@ -216,7 +221,7 @@ public class InterfaceManager implements AutoCloseable {
         }
     }
 
-    private static Optional<ConfigCommand> createInterfaceWithoutBdCommand(@Nonnull VppEndpoint vppEp,
+    public static Optional<ConfigCommand> createInterfaceWithoutBdCommand(@Nonnull VppEndpoint vppEp,
             @Nonnull Operations operations) {
         if (!hasNodeAndInterface(vppEp)) {
             LOG.debug("Interface command is not created for {}", vppEp);
@@ -318,7 +323,6 @@ public class InterfaceManager implements AutoCloseable {
                     new Exception("Cannot resolve interface instance-identifier for interface path" + interfacePath));
         }
         InstanceIdentifier<Interface> interfaceIid = optInterfaceIid.get();
-
         Optional<DataBroker> potentialVppDataProvider = mountDataProvider.getDataBrokerForMountPoint(vppNodeIid);
         if (!potentialVppDataProvider.isPresent()) {
             return Futures.immediateFailedFuture(new Exception("Cannot get data broker for mount point " + vppNodeIid));
@@ -335,7 +339,6 @@ public class InterfaceManager implements AutoCloseable {
                     return Futures.immediateFailedFuture(new Exception("Interface "
                             + interfaceIid.firstKeyOf(Interface.class) + " does not exist on node " + vppNodeIid));
                 }
-
                 String existingBridgeDomain = resolveBridgeDomain(optIface.get());
                 if (bridgeDomainName.equals(existingBridgeDomain)) {
                     LOG.debug("Bridge domain {} already exists on interface {}", bridgeDomainName, interfacePath);
@@ -349,18 +352,9 @@ public class InterfaceManager implements AutoCloseable {
                     }
                     return Futures.immediateFuture(null);
                 }
-                InstanceIdentifier<L2> l2Iid =
-                        interfaceIid.builder().augmentation(VppInterfaceAugmentation.class).child(L2.class).build();
-                final ReadWriteTransaction rwTxRead = mountpoint.newReadWriteTransaction();
-                Optional<L2> optL2 = DataStoreHelper.readFromDs(LogicalDatastoreType.CONFIGURATION, l2Iid, rwTxRead);
-                L2Builder l2Builder = (optL2.isPresent()) ? new L2Builder(optL2.get()) : new L2Builder();
-                L2 l2 = l2Builder.setInterconnection(new BridgeBasedBuilder()
-                    .setBridgeDomain(bridgeDomainName)
-                    .setBridgedVirtualInterface(enableBvi)
-                    .build()).build();
-                final ReadWriteTransaction rwTxPut = prepareTransactionAndPutData(mountpoint, l2, l2Iid);
-                LOG.debug("Adding bridge domain {} to interface {}", bridgeDomainName, interfacePath);
-                return Futures.transform(rwTxPut.submit(), new AsyncFunction<Void, Void>() {
+              return Futures.transform(
+                        configureInterface(mountpoint, optIface.get().getKey(), bridgeDomainName, enableBvi),
+                        new AsyncFunction<Void, Void>() {
 
                     @Override
                     public ListenableFuture<Void> apply(@Nonnull Void input) {
@@ -376,6 +370,39 @@ public class InterfaceManager implements AutoCloseable {
         }, netconfWorker);
     }
 
+    public ListenableFuture<Void> configureInterface(DataBroker mountPoint, InterfaceKey ifaceKey, @Nullable String bridgeDomainName, @Nullable Boolean enableBvi) {
+        L2Builder l2Builder = readL2ForInterface(mountPoint, ifaceKey);
+        L2 l2 = l2Builder.setInterconnection(new BridgeBasedBuilder()
+            .setBridgeDomain(bridgeDomainName)
+            .setBridgedVirtualInterface(enableBvi)
+            .build()).build();
+        final ReadWriteTransaction rwTxPut = prepareTransactionAndPutData(mountPoint, l2, VppIidFactory.getL2ForInterfaceIid(ifaceKey));
+        LOG.debug("Adding bridge domain {} to interface {}", bridgeDomainName, VppIidFactory.getInterfaceIID(ifaceKey));
+        return rwTxPut.submit();
+    }
+
+    public ListenableFuture<Void> removeInterfaceFromBridgeDomain(DataBroker mountPoint, InterfaceKey ifaceKey) {
+        L2Builder l2Builder = readL2ForInterface(mountPoint, ifaceKey);
+        if (l2Builder.getInterconnection() == null || !(l2Builder.getInterconnection() instanceof BridgeBased)) {
+            LOG.warn("Interface already not in bridge domain {} ", ifaceKey);
+            return Futures.immediateFuture(null);
+        }
+        BridgeBased bridgeBased = new BridgeBasedBuilder((BridgeBased) l2Builder.getInterconnection()).setBridgeDomain(
+                null).build();
+        L2 l2 = l2Builder.setInterconnection(bridgeBased).build();
+        final ReadWriteTransaction rwTxPut = prepareTransactionAndPutData(mountPoint, l2,
+                VppIidFactory.getL2ForInterfaceIid(ifaceKey));
+        LOG.debug("Removing bridge domain from interface {}", VppIidFactory.getInterfaceIID(ifaceKey));
+        return rwTxPut.submit();
+    }
+
+    private L2Builder readL2ForInterface(DataBroker mountpoint, InterfaceKey ifaceKey) {
+        InstanceIdentifier<L2> l2Iid = VppIidFactory.getL2ForInterfaceIid(ifaceKey);
+        final ReadWriteTransaction rwTxRead = mountpoint.newReadWriteTransaction();
+        Optional<L2> optL2 = DataStoreHelper.readFromDs(LogicalDatastoreType.CONFIGURATION, l2Iid, rwTxRead);
+        return  (optL2.isPresent()) ? new L2Builder(optL2.get()) : new L2Builder();
+    }
+
     /**
      * Removes bridge domain (if exist) from an interface (if exist).<br>
      * {@link VppEndpointLocationProvider#VPP_ENDPOINT_LOCATION_PROVIDER} will update endpoint

diff --git a/renderers/vpp/src/main/java/org/opendaylight/groupbasedpolicy/renderer/vpp/policy/BridgeDomainManagerImpl.java b/renderers/vpp/src/main/java/org/opendaylight/groupbasedpolicy/renderer/vpp/policy/BridgeDomainManagerImpl.java
index c1546d56e3dd70839de9b83f96714f256c980071..6b695324bce129f634a4df094b9a7fc90f3344bd 100644 (file)
--- a/renderers/vpp/src/main/java/org/opendaylight/groupbasedpolicy/renderer/vpp/policy/BridgeDomainManagerImpl.java
+++ b/renderers/vpp/src/main/java/org/opendaylight/groupbasedpolicy/renderer/vpp/policy/BridgeDomainManagerImpl.java
@@ -8,20 +8,14 @@
 
 package org.opendaylight.groupbasedpolicy.renderer.vpp.policy;
 
-import javax.annotation.Nonnull;
-import javax.annotation.Nullable;
 import java.util.Collection;
 import java.util.Collections;
 import java.util.concurrent.ExecutionException;
 import java.util.concurrent.TimeoutException;
-import com.google.common.base.Optional;
-import com.google.common.base.Preconditions;
-import com.google.common.util.concurrent.AsyncFunction;
-import com.google.common.util.concurrent.CheckedFuture;
-import com.google.common.util.concurrent.FutureCallback;
-import com.google.common.util.concurrent.Futures;
-import com.google.common.util.concurrent.ListenableFuture;
-import com.google.common.util.concurrent.SettableFuture;
+
+import javax.annotation.Nonnull;
+import javax.annotation.Nullable;
+
 import org.opendaylight.controller.md.sal.binding.api.ClusteredDataTreeChangeListener;
 import org.opendaylight.controller.md.sal.binding.api.DataBroker;
 import org.opendaylight.controller.md.sal.binding.api.DataObjectModification;
@@ -35,9 +29,9 @@ import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
 import org.opendaylight.groupbasedpolicy.renderer.vpp.api.BridgeDomainManager;
 import org.opendaylight.groupbasedpolicy.renderer.vpp.util.VppIidFactory;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_renderer.rev160425.Config;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_renderer.rev160425.bridge.domain.base.attributes.PhysicalLocationRef;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_renderer.rev160425.config.GbpBridgeDomain;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_renderer.rev160425.config.GbpBridgeDomainKey;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_renderer.rev160425.config.gbp.bridge.domain.PhysicalLocationRef;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.l2.types.rev130827.VlanId;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev161214.VxlanVni;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev161214.vpp.state.bridge.domains.BridgeDomain;
@@ -75,6 +69,15 @@ import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
+import com.google.common.base.Optional;
+import com.google.common.base.Preconditions;
+import com.google.common.util.concurrent.AsyncFunction;
+import com.google.common.util.concurrent.CheckedFuture;
+import com.google.common.util.concurrent.FutureCallback;
+import com.google.common.util.concurrent.Futures;
+import com.google.common.util.concurrent.ListenableFuture;
+import com.google.common.util.concurrent.SettableFuture;
+
 public class BridgeDomainManagerImpl implements BridgeDomainManager {
 
     private static final Logger LOG = LoggerFactory.getLogger(BridgeDomainManagerImpl.class);

diff --git a/renderers/vpp/src/main/java/org/opendaylight/groupbasedpolicy/renderer/vpp/policy/ForwardingManager.java b/renderers/vpp/src/main/java/org/opendaylight/groupbasedpolicy/renderer/vpp/policy/ForwardingManager.java
index 5823d5bc4ef4b6aa8e74fdcce04517590cbd11c3..9e5e70c9b8f83593e11efc5ca0f9aecdc5db01a5 100644 (file)
--- a/renderers/vpp/src/main/java/org/opendaylight/groupbasedpolicy/renderer/vpp/policy/ForwardingManager.java
+++ b/renderers/vpp/src/main/java/org/opendaylight/groupbasedpolicy/renderer/vpp/policy/ForwardingManager.java
@@ -47,8 +47,8 @@ import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_render
 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_renderer.rev160425.config.GbpBridgeDomainKey;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_renderer.rev160425.config.VppEndpoint;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_renderer.rev160425.config.VppEndpointKey;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_renderer.rev160425.config.vpp.endpoint.InterfaceTypeChoice;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_renderer.rev160425.config.vpp.endpoint._interface.type.choice.LoopbackCase;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_renderer.rev160425._interface.attributes.InterfaceTypeChoice;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_renderer.rev160425._interface.attributes._interface.type.choice.LoopbackCase;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.l2.types.rev130827.VlanId;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev161214.VxlanVni;
 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.NodeId;

diff --git a/renderers/vpp/src/main/java/org/opendaylight/groupbasedpolicy/renderer/vpp/util/VppIidFactory.java b/renderers/vpp/src/main/java/org/opendaylight/groupbasedpolicy/renderer/vpp/util/VppIidFactory.java
index 366d3c5c9057451d815b9d1e368fc5a7eb3800db..e22dd8207ef8f6cf4c2a5ee768895d910733b194 100644 (file)
--- a/renderers/vpp/src/main/java/org/opendaylight/groupbasedpolicy/renderer/vpp/util/VppIidFactory.java
+++ b/renderers/vpp/src/main/java/org/opendaylight/groupbasedpolicy/renderer/vpp/util/VppIidFactory.java
@@ -18,7 +18,9 @@ import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.r
 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.RendererNodes;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.renderer.nodes.RendererNode;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.renderer.nodes.RendererNodeKey;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev161214.VppInterfaceAugmentation;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev161214.VppState;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev161214.interfaces._interface.L2;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev161214.vpp.state.BridgeDomains;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev161214.vpp.state.bridge.domains.BridgeDomain;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev161214.vpp.state.bridge.domains.BridgeDomainKey;
@@ -35,6 +37,13 @@ public class VppIidFactory {
         return InstanceIdentifier.create(Interfaces.class).child(Interface.class, interfaceKey);
     }
 
+    public static InstanceIdentifier<L2> getL2ForInterfaceIid(InterfaceKey interfaceKey) {
+        return getInterfaceIID(interfaceKey).builder()
+            .augmentation(VppInterfaceAugmentation.class)
+            .child(L2.class)
+            .build();
+    }
+
     public static InstanceIdentifier<Renderer> getRendererIID(RendererKey rendererKey) {
         return InstanceIdentifier.create(Renderers.class).child(Renderer.class, rendererKey);
     }

diff --git a/renderers/vpp/src/main/resources/org/opendaylight/blueprint/vpp-renderer.xml b/renderers/vpp/src/main/resources/org/opendaylight/blueprint/vpp-renderer.xml
index ba47a38e5c62605f8953bb398ad52951a893c7eb..62a8dbfbd4fd1eec8f7ffb9e6b3343da7ef6814c 100644 (file)
--- a/renderers/vpp/src/main/resources/org/opendaylight/blueprint/vpp-renderer.xml
+++ b/renderers/vpp/src/main/resources/org/opendaylight/blueprint/vpp-renderer.xml
@@ -13,4 +13,7 @@
         <argument ref="broker"/>
         <argument ref="clusterSingletonService" />
     </bean>
+
+    <odl:rpc-implementation ref="vppRenderer"/>
+
 </blueprint>
\ No newline at end of file

diff --git a/renderers/vpp/src/main/yang/vpp-adapter.yang b/renderers/vpp/src/main/yang/vpp-adapter.yang
new file mode 100644 (file)
index 0000000..9d8d169
--- /dev/null
+++ b/renderers/vpp/src/main/yang/vpp-adapter.yang
@@ -0,0 +1,112 @@
+/*
+ * 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
+ */
+
+module vpp-adapter {
+    yang-version 1;
+
+    namespace "urn:opendaylight:groupbasedpolicy:vpp_adapter";
+    prefix "vpp-adapter";
+
+    import vpp-renderer { prefix "vpp-renderer"; }
+    import network-topology { prefix nt; revision-date 2013-10-21; }
+    import opendaylight-l2-types { prefix l2-types; revision-date "2013-08-27"; }
+    import ietf-yang-types { prefix yang-types; revision-date "2013-07-15"; }
+    import ietf-inet-types { prefix "inet-types"; }
+
+    description
+        "This module allows external plugins to use VPP renderer by calling defined RPCs.";
+
+    revision "2016-12-01" {
+        description
+            "Initial revision.";
+    }
+
+    typedef vxlan-vni-type {
+        type uint32 {
+            range "1 .. 16777214";
+        }
+    }
+
+    grouping bridge-domain-attributes {
+        uses vpp-renderer:bridge-domain-base-attributes;
+        leaf unknown-unicast-flood {
+            type boolean;
+            default "False";
+        }
+        choice tunnel-type {
+            case vxlan {
+                leaf vni {
+                    type vxlan-vni-type;
+                }
+            }
+            case vlan {
+                leaf vlan-id {
+                    type l2-types:vlan-id;
+                }
+            }
+        }
+    }
+
+    grouping bridge-domain-nodes {
+        uses bridge-domain-id;
+            leaf-list bridge-domain-node {
+                min-elements 1;
+                type nt:node-id;
+            }
+    }
+
+    grouping bridge-domain-id {
+        leaf bridge-domain-id {
+            mandatory true;
+            type string;
+        }
+    }
+
+    rpc create-virtual-bridge-domain-on-nodes {
+       input {
+            uses bridge-domain-attributes;
+       }
+    }
+
+    rpc expand-virtual-bridge-domain-on-nodes {
+       input {
+            uses bridge-domain-nodes;
+       }
+    }
+
+    rpc delete-virtual-bridge-domain-on-nodes {
+       input {
+            uses bridge-domain-nodes;
+       }
+    }
+
+    rpc create-interface-on-node {
+        input {
+            uses vpp-renderer:interface-attributes;
+        }
+    }
+
+    rpc delete-interface {
+        input {
+            uses vpp-renderer:interface-location;
+        }
+    }
+
+    rpc add-interface-to-bridge-domain {
+        input {
+            uses vpp-renderer:interface-location;
+            uses bridge-domain-id;
+        }
+    }
+
+    rpc del-interface-from-bridge-domain {
+        input {
+            uses vpp-renderer:interface-location;
+        }
+    }
+}

diff --git a/renderers/vpp/src/main/yang/vpp-renderer.yang b/renderers/vpp/src/main/yang/vpp-renderer.yang
index 25b3f835ef91c3d1b507f44416ae78643fb1a32d..116adc755be8173a1199dc438ac81e9a7187f28c 100644 (file)
--- a/renderers/vpp/src/main/yang/vpp-renderer.yang
+++ b/renderers/vpp/src/main/yang/vpp-renderer.yang
@@ -47,79 +47,106 @@ module vpp-renderer {
         }
     }
 
-    container config {
-        list vpp-endpoint {
-            description "Renderer creates/removes interface on VPP node based on given parameters.";
-
-            key "context-type context-id address-type address";
-            uses base-ep:address-endpoint-key;
-
-            leaf vpp-node-path {
-                description "Path to a node representing mount-point to VPP instance.";
-                mandatory true;
-                type instance-identifier;
-            }
-            leaf vpp-interface-name {
-                description "Name of interface for the endpoint on VPP";
-                mandatory true;
-                type string;
+    grouping bridge-domain-base-attributes {
+        leaf id {
+            description "Same as in VBD.";
+            type string;
+        }
+        leaf description {
+           type string;
+        }
+        list physical-location-ref {
+            description
+                "Refers to physical interfaces on vpp nodes through which external
+                 nodes belonging to the same bridge-domain can be reached.";
+            key "node-id";
+            leaf node-id {
+                description "Refers to a VPP node.";
+                type nt:node-id;
             }
-            leaf description {
-                description "Additional description of the vpp-endpoint";
+            leaf-list interface {
+                description "Physical interface on the VPP node.";
                 type string;
             }
-            choice interface-type-choice {
-                case vhost-user-case {
-                    leaf socket {
-                        description "Identifier of a vhost user";
-                        type string {
-                            length 1..255;
-                        }
+        }
+    }
+
+    grouping interface-attributes {
+        uses vpp-renderer:interface-location;
+        leaf description {
+            description "Additional description of the vpp-endpoint";
+            type string;
+        }
+        choice interface-type-choice {
+            mandatory true;
+            case vhost-user-case {
+                leaf socket {
+                    description "Identifier of a vhost user";
+                    type string {
+                        length 1..255;
                     }
                 }
-                case tap-case {
-                    leaf name {
-                        description "Identifier of a tap port";
-                        mandatory true;
-                        type string {
-                            length 1..255;
-                        }
-                    }
-                    leaf physical-address {
-                        description "MAC address of a tap port";
-                        type yang-types:phys-address;
+            }
+            case tap-case {
+                leaf name {
+                    description "Identifier of a tap port";
+                    mandatory true;
+                    type string {
+                        length 1..255;
                     }
                 }
-                case loopback-case {
-                    leaf phys-address {
-                        description "MAC address of a loopback interface";
-                        type yang-types:phys-address;
-                    }
-                    leaf ip-address {
-                        description "Ip address of a loopback interface";
-                        type inet-types:ip-address;
-                    }
-                    leaf ip-prefix {
-                        description "Ip address prefix of a loopback interface";
-                        type inet-types:ip-prefix;
-                    }
-                    leaf bvi {
-                        description "Enable/disable BVI for loopback interface";
-                        type boolean;
-                    }
+                leaf physical-address {
+                    description "MAC address of a tap port";
+                    type yang-types:phys-address;
+                }
+            }
+            case loopback-case {
+                leaf phys-address {
+                    description "MAC address of a loopback interface";
+                    type yang-types:phys-address;
+                }
+                leaf ip-address {
+                    description "Ip address of a loopback interface";
+                    type inet-types:ip-address;
+                }
+                leaf ip-prefix {
+                    description "Ip address prefix of a loopback interface";
+                    type inet-types:ip-prefix;
+                }
+                leaf bvi {
+                    description "Enable/disable BVI for loopback interface";
+                    type boolean;
                 }
             }
         }
+    }
+
+    grouping interface-location {
+        leaf vpp-node-path {
+            description "Path to a node representing mount-point to VPP instance.";
+            mandatory true;
+            type instance-identifier;
+        }
+        leaf vpp-interface-name {
+            description "Name of interface for the endpoint on VPP";
+            mandatory true;
+            type string;
+        }
+    }
+
+    container config {
+        list vpp-endpoint {
+            description "Renderer creates/removes interface on VPP node based on given parameters.";
+
+            key "context-type context-id address-type address";
+            uses base-ep:address-endpoint-key;
+
+            uses interface-attributes;
+        }
 
         list gbp-bridge-domain {
             key "id";
-            leaf id {
-                description "Same as in VBD.";
-                type string;
-            }
-            leaf description {
-               type string;
-            }
+            uses bridge-domain-base-attributes;
             leaf type {
                 mandatory true;
                 type network-type;
@@ -128,20 +155,6 @@ module vpp-renderer {
                 when "type = 'vlan-network'";
                 type l2-types:vlan-id;
             }
-            list physical-location-ref {
-                description
-                    "Refers to physical interfaces on vpp nodes through which external
-                     nodes belonging to the same bridge-domain can be reached.";
-                key "node-id";
-                leaf node-id {
-                    description "Refers to a VPP node.";
-                    type nt:node-id;
-                }
-                leaf-list interface {
-                    description "Physical interface on the VPP node.";
-                    type string;
-                }
-            }
         }
     }
 }

diff --git a/renderers/vpp/src/test/java/org/opendaylight/groupbasedpolicy/renderer/vpp/iface/InterfaceManagerTest.java b/renderers/vpp/src/test/java/org/opendaylight/groupbasedpolicy/renderer/vpp/iface/InterfaceManagerTest.java
index b3839f02d539cf2420961f1840f0006471649864..f9f6b77ebe1ee2ca3e4a7ab5776526799503bc8a 100644 (file)
--- a/renderers/vpp/src/test/java/org/opendaylight/groupbasedpolicy/renderer/vpp/iface/InterfaceManagerTest.java
+++ b/renderers/vpp/src/test/java/org/opendaylight/groupbasedpolicy/renderer/vpp/iface/InterfaceManagerTest.java
@@ -36,7 +36,7 @@ import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_render
 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_renderer.rev160425.config.VppEndpoint;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_renderer.rev160425.config.VppEndpointBuilder;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_renderer.rev160425.config.VppEndpointKey;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_renderer.rev160425.config.vpp.endpoint._interface.type.choice.VhostUserCaseBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_renderer.rev160425._interface.attributes._interface.type.choice.VhostUserCaseBuilder;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev161214.VhostUser;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev161214.VhostUserRole;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev161214.VppInterfaceAugmentation;

diff --git a/renderers/vpp/src/test/java/org/opendaylight/groupbasedpolicy/renderer/vpp/policy/VppRendererPolicyManagerTest.java b/renderers/vpp/src/test/java/org/opendaylight/groupbasedpolicy/renderer/vpp/policy/VppRendererPolicyManagerTest.java
index 50e8790483701b5d7a9226babee187098bc73b1f..5f76ae15de1562530433891c01ef4f3d6f11ea79 100644 (file)
--- a/renderers/vpp/src/test/java/org/opendaylight/groupbasedpolicy/renderer/vpp/policy/VppRendererPolicyManagerTest.java
+++ b/renderers/vpp/src/test/java/org/opendaylight/groupbasedpolicy/renderer/vpp/policy/VppRendererPolicyManagerTest.java
@@ -50,8 +50,8 @@ import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_render
 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_renderer.rev160425.config.VppEndpoint;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_renderer.rev160425.config.VppEndpointBuilder;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_renderer.rev160425.config.VppEndpointKey;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_renderer.rev160425.config.gbp.bridge.domain.PhysicalLocationRef;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_renderer.rev160425.config.vpp.endpoint._interface.type.choice.VhostUserCaseBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_renderer.rev160425.bridge.domain.base.attributes.PhysicalLocationRef;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_renderer.rev160425._interface.attributes._interface.type.choice.VhostUserCaseBuilder;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev161214.VppInterfaceAugmentation;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev161214.VxlanVni;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev161214.interfaces._interface.L2;