From: Vivek Srivastava Date: Wed, 1 Apr 2015 09:44:17 +0000 (+0000) Subject: Merge "Initial draft of vpn service" X-Git-Tag: release/lithium~84 X-Git-Url: https://git.opendaylight.org/gerrit/gitweb?a=commitdiff_plain;h=f9cf6c9c65b51d31c13791a87b7eb955f8935ac2;hp=0186b5f6c4e02ee15e16c7e53bb3ad7c69bc0f91;p=vpnservice.git Merge "Initial draft of vpn service" --- diff --git a/vpnmanager-impl/pom.xml b/vpnmanager-impl/pom.xml index 59cd96d7..d7762002 100644 --- a/vpnmanager-impl/pom.xml +++ b/vpnmanager-impl/pom.xml @@ -1,31 +1,41 @@ - - - - - - org.opendaylight.controller - config-parent - 0.3.0-SNAPSHOT - - - - 4.0.0 - org.opendaylight.vpnservice - vpnmanager-impl - 1.0-SNAPSHOT - bundle - - - ${project.groupId} - vpnmanager-api - ${project.version} - - - - + + + + + + org.opendaylight.controller + config-parent + 0.3.0-SNAPSHOT + + + + 4.0.0 + org.opendaylight.vpnservice + vpnmanager-impl + 1.0-SNAPSHOT + bundle + + + ${project.groupId} + vpnmanager-api + ${project.version} + + + + junit + junit + + + org.mockito + mockito-all + test + + + + diff --git a/vpnmanager-impl/src/main/java/org/opendaylight/vpnservice/AbstractDataChangeListener.java b/vpnmanager-impl/src/main/java/org/opendaylight/vpnservice/AbstractDataChangeListener.java new file mode 100644 index 00000000..38530a71 --- /dev/null +++ b/vpnmanager-impl/src/main/java/org/opendaylight/vpnservice/AbstractDataChangeListener.java @@ -0,0 +1,110 @@ +/* + * Copyright (c) 2015 Ericsson India Global Services Pvt Ltd. 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.vpnservice; + +import com.google.common.base.Optional; +import com.google.common.base.Preconditions; + +import org.opendaylight.controller.md.sal.binding.api.DataChangeListener; +import org.opendaylight.controller.md.sal.common.api.data.AsyncDataChangeEvent; +import org.opendaylight.yangtools.yang.binding.DataObject; +import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; + +import java.util.Collections; +import java.util.Map; +import java.util.Set; + +/** + * AbstractDataChangeListener implemented basic {@link DataChangeListener} processing for + * VPN related Data Objects. + */ +public abstract class AbstractDataChangeListener implements DataChangeListener { + + protected final Class clazz; + + public AbstractDataChangeListener(Class clazz) { + this.clazz = Preconditions.checkNotNull(clazz, "Class can not be null!"); + } + + @Override + public void onDataChanged(final AsyncDataChangeEvent, DataObject> changeEvent) { + Preconditions.checkNotNull(changeEvent,"Async ChangeEvent can not be null!"); + + /* All DataObjects for create */ + final Map, DataObject> createdData = changeEvent.getCreatedData() != null + ? changeEvent.getCreatedData() : Collections., DataObject> emptyMap(); + /* All DataObjects for remove */ + final Set> removeData = changeEvent.getRemovedPaths() != null + ? changeEvent.getRemovedPaths() : Collections.> emptySet(); + /* All DataObjects for updates */ + final Map, DataObject> updateData = changeEvent.getUpdatedData() != null + ? changeEvent.getUpdatedData() : Collections., DataObject> emptyMap(); + /* All Original DataObjects */ + final Map, DataObject> originalData = changeEvent.getOriginalData() != null + ? changeEvent.getOriginalData() : Collections., DataObject> emptyMap(); + + this.createData(createdData); + this.updateData(updateData, originalData); + this.removeData(removeData, originalData); + } + + @SuppressWarnings("unchecked") + private void createData(final Map, DataObject> createdData) { + final Set> keys = createdData.keySet() != null + ? createdData.keySet() : Collections.> emptySet(); + for (InstanceIdentifier key : keys) { + if (clazz.equals(key.getTargetType())) { + InstanceIdentifier createKeyIdent = key.firstIdentifierOf(clazz); + final Optional value = Optional.of(createdData.get(key)); + if (value.isPresent()) { + this.add(createKeyIdent, (T)value.get()); + } + } + } + } + + @SuppressWarnings("unchecked") + private void updateData(final Map, DataObject> updateData, + final Map, DataObject> originalData) { + + final Set> keys = updateData.keySet() != null + ? updateData.keySet() : Collections.> emptySet(); + for (InstanceIdentifier key : keys) { + if (clazz.equals(key.getTargetType())) { + InstanceIdentifier updateKeyIdent = key.firstIdentifierOf(clazz); + final Optional value = Optional.of(updateData.get(key)); + final Optional original = Optional.of(originalData.get(key)); + if (value.isPresent() && original.isPresent()) { + this.update(updateKeyIdent, (T)original.get(), (T)value.get()); + } + } + } + } + + @SuppressWarnings("unchecked") + private void removeData(final Set> removeData, + final Map, DataObject> originalData) { + + for (InstanceIdentifier key : removeData) { + if (clazz.equals(key.getTargetType())) { + final InstanceIdentifier ident = key.firstIdentifierOf(clazz); + final DataObject removeValue = originalData.get(key); + this.remove(ident, (T)removeValue); + } + } + } + + protected abstract void remove(InstanceIdentifier identifier, T del); + + protected abstract void update(InstanceIdentifier identifier, T original, T update); + + protected abstract void add(InstanceIdentifier identifier, T add); + +} + + diff --git a/vpnmanager-impl/src/main/java/org/opendaylight/vpnservice/VpnInterfaceManager.java b/vpnmanager-impl/src/main/java/org/opendaylight/vpnservice/VpnInterfaceManager.java new file mode 100644 index 00000000..ae286b66 --- /dev/null +++ b/vpnmanager-impl/src/main/java/org/opendaylight/vpnservice/VpnInterfaceManager.java @@ -0,0 +1,157 @@ +/* + * Copyright (c) 2015 Ericsson India Global Services Pvt Ltd. 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.vpnservice; + +import java.util.Collections; +import java.util.List; +import java.util.Map; +import java.util.Set; +import java.util.concurrent.Future; + +import org.opendaylight.controller.md.sal.binding.api.DataBroker; +import org.opendaylight.controller.md.sal.binding.api.DataChangeListener; +import org.opendaylight.yangtools.concepts.ListenerRegistration; +import org.opendaylight.yangtools.yang.binding.DataObject; +import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; +import org.opendaylight.yangtools.yang.binding.InstanceIdentifier.InstanceIdentifierBuilder; +import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction; +import org.opendaylight.controller.md.sal.common.api.data.AsyncDataChangeEvent; +import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType; +import org.opendaylight.controller.md.sal.common.api.data.AsyncDataBroker.DataChangeScope; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.Interfaces; +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.l3vpn.rev130911.NextHopList; +import org.opendaylight.yang.gen.v1.urn.opendaylight.l3vpn.rev130911.next.hop.list.*; +import org.opendaylight.yang.gen.v1.urn.huawei.params.xml.ns.yang.l3vpn.rev140815.VpnInterfaces; +import org.opendaylight.yang.gen.v1.urn.opendaylight.l3vpn.rev130911.VpnInterface1; +import org.opendaylight.yang.gen.v1.urn.huawei.params.xml.ns.yang.l3vpn.rev140815.vpn.interfaces.VpnInterface; +import org.opendaylight.yang.gen.v1.urn.huawei.params.xml.ns.yang.l3vpn.rev140815.vpn.interfaces.VpnInterfaceKey; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import com.google.common.base.Optional; +import com.google.common.collect.FluentIterable; + +public class VpnInterfaceManager extends AbstractDataChangeListener implements AutoCloseable{ + private static final Logger LOG = LoggerFactory.getLogger(VpnInterfaceManager.class); + private ListenerRegistration listenerRegistration; + private final DataBroker broker; + + public VpnInterfaceManager(final DataBroker db) { + super(VpnInterface.class); + broker = db; + registerListener(db); + } + + @Override + public void close() throws Exception { + if (listenerRegistration != null) { + try { + listenerRegistration.close(); + } catch (final Exception e) { + LOG.error("Error when cleaning up DataChangeListener.", e); + } + listenerRegistration = null; + } + LOG.info("VPN Interface Manager Closed"); + } + + private void registerListener(final DataBroker db) { + try { + listenerRegistration = db.registerDataChangeListener(LogicalDatastoreType.CONFIGURATION, + getWildCardPath(), VpnInterfaceManager.this, DataChangeScope.SUBTREE); + } catch (final Exception e) { + LOG.error("VPN Service DataChange listener registration fail!", e); + throw new IllegalStateException("VPN Service registration Listener failed.", e); + } + } + + @Override + protected void add(final InstanceIdentifier identifier, + final VpnInterface vpnInterface) { + LOG.info("key: " + identifier + ", value=" + vpnInterface ); + addInterface(identifier, vpnInterface); + } + + private void addInterface(final InstanceIdentifier identifier, + final VpnInterface vpnInterface) { + final VpnInterfaceKey key = identifier.firstKeyOf(VpnInterface.class, VpnInterfaceKey.class); + String interfaceName = key.getName(); + InstanceIdentifierBuilder idBuilder = + InstanceIdentifier.builder(Interfaces.class).child(Interface.class, new InterfaceKey(interfaceName)); + InstanceIdentifier id = idBuilder.build(); + Optional port = read(LogicalDatastoreType.CONFIGURATION, id); + if(port.isPresent()) { + Interface interf = port.get(); + bindServiceOnInterface(interf); + updateNextHops(identifier); + } + } + + private void updateNextHops(final InstanceIdentifier identifier) { + //Read NextHops + InstanceIdentifier path = identifier.augmentation(VpnInterface1.class); + Optional nextHopList = read(LogicalDatastoreType.CONFIGURATION, path); + + if(nextHopList.isPresent()) { + List nextHops = nextHopList.get().getL3NextHops(); + + if(!nextHops.isEmpty()) { + LOG.info("NextHops are "+ nextHops); + for(L3NextHops nextHop : nextHops) { + //TODO: Generate label for the prefix and store it in the next hop model + + //TODO: Update BGP + updatePrefixToBGP(nextHop); + } + } + } + } + + private void bindServiceOnInterface(Interface intf) { + //TODO: Create Ingress flow on the interface to bind the VPN service + } + + private void updatePrefixToBGP(L3NextHops nextHop) { + //TODO: Update the Prefix to BGP + } + + private Optional read(LogicalDatastoreType datastoreType, + InstanceIdentifier path) { + + ReadOnlyTransaction tx = broker.newReadOnlyTransaction(); + + Optional result = Optional.absent(); + try { + result = tx.read(datastoreType, path).get(); + } catch (Exception e) { + throw new RuntimeException(e); + } + + return result; + } + + private InstanceIdentifier getWildCardPath() { + return InstanceIdentifier.create(VpnInterfaces.class).child(VpnInterface.class); + } + + @Override + protected void remove( InstanceIdentifier identifier, VpnInterface del) { + // TODO Auto-generated method stub + + } + + @Override + protected void update(InstanceIdentifier identifier, + VpnInterface original, VpnInterface update) { + // TODO Auto-generated method stub + + } + +} diff --git a/vpnmanager-impl/src/main/java/org/opendaylight/vpnservice/VpnManager.java b/vpnmanager-impl/src/main/java/org/opendaylight/vpnservice/VpnManager.java new file mode 100644 index 00000000..7a957af4 --- /dev/null +++ b/vpnmanager-impl/src/main/java/org/opendaylight/vpnservice/VpnManager.java @@ -0,0 +1,87 @@ +/* + * Copyright (c) 2015 Ericsson India Global Services Pvt Ltd. 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.vpnservice; + +import java.util.Collections; +import java.util.Map; +import java.util.Set; + +import org.opendaylight.controller.md.sal.binding.api.DataBroker; +import org.opendaylight.controller.md.sal.binding.api.DataChangeListener; +import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType; +import org.opendaylight.controller.md.sal.common.api.data.AsyncDataBroker.DataChangeScope; +import org.opendaylight.yangtools.concepts.ListenerRegistration; +import org.opendaylight.yangtools.yang.binding.DataObject; +import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; +import org.opendaylight.yang.gen.v1.urn.huawei.params.xml.ns.yang.l3vpn.rev140815.vpn.instances.VpnInstance; +import org.opendaylight.yang.gen.v1.urn.huawei.params.xml.ns.yang.l3vpn.rev140815.VpnInstances; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import com.google.common.base.Optional; +import com.google.common.base.Preconditions; + +public class VpnManager extends AbstractDataChangeListener implements AutoCloseable{ + private static final Logger LOG = LoggerFactory.getLogger(VpnManager.class); + private ListenerRegistration listenerRegistration; + private final DataBroker broker; + + public VpnManager(final DataBroker db) { + super(VpnInstance.class); + broker = db; + registerListener(db); + } + + private void registerListener(final DataBroker db) { + try { + listenerRegistration = db.registerDataChangeListener(LogicalDatastoreType.CONFIGURATION, + getWildCardPath(), VpnManager.this, DataChangeScope.SUBTREE); + } catch (final Exception e) { + LOG.error("VPN Service DataChange listener registration fail!", e); + throw new IllegalStateException("VPN Service registration Listener failed.", e); + } + } + + @Override + protected void remove(InstanceIdentifier identifier, + VpnInstance del) { + // TODO Auto-generated method stub + } + + @Override + protected void update(InstanceIdentifier identifier, + VpnInstance original, VpnInstance update) { + // TODO Auto-generated method stub + } + + @Override + protected void add(InstanceIdentifier identifier, + VpnInstance value) { + LOG.info("key: " + identifier + ", value=" + value); + //TODO: Generate VPN ID for this instance, where to store in model ... ? + + //TODO: Add VRF to BGP + } + + private InstanceIdentifier getWildCardPath() { + return InstanceIdentifier.create(VpnInstances.class).child(VpnInstance.class); + } + + @Override + public void close() throws Exception { + if (listenerRegistration != null) { + try { + listenerRegistration.close(); + } catch (final Exception e) { + LOG.error("Error when cleaning up DataChangeListener.", e); + } + listenerRegistration = null; + } + LOG.info("VPN Manager Closed"); + } +} diff --git a/vpnmanager-impl/src/main/java/org/opendaylight/vpnservice/VpnserviceProvider.java b/vpnmanager-impl/src/main/java/org/opendaylight/vpnservice/VpnserviceProvider.java index ef4223ff..1ad8b593 100644 --- a/vpnmanager-impl/src/main/java/org/opendaylight/vpnservice/VpnserviceProvider.java +++ b/vpnmanager-impl/src/main/java/org/opendaylight/vpnservice/VpnserviceProvider.java @@ -1,29 +1,41 @@ -/* - * Copyright (c) 2015 Ericsson India Global Services Pvt Ltd. 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.vpnservice; - -import org.opendaylight.controller.sal.binding.api.BindingAwareBroker.ProviderContext; -import org.opendaylight.controller.sal.binding.api.BindingAwareProvider; -import org.slf4j.Logger; -import org.slf4j.LoggerFactory; - -public class VpnserviceProvider implements BindingAwareProvider, AutoCloseable { - - private static final Logger LOG = LoggerFactory.getLogger(VpnserviceProvider.class); - - @Override - public void onSessionInitiated(ProviderContext session) { - LOG.info("VpnserviceProvider Session Initiated"); - } - - @Override - public void close() throws Exception { - LOG.info("VpnserviceProvider Closed"); - } - -} +/* + * Copyright (c) 2015 Ericsson India Global Services Pvt Ltd. 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.vpnservice; + +import org.opendaylight.controller.md.sal.binding.api.DataBroker; +import org.opendaylight.controller.sal.binding.api.BindingAwareBroker.ProviderContext; +import org.opendaylight.controller.sal.binding.api.BindingAwareProvider; + +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +public class VpnserviceProvider implements BindingAwareProvider, + AutoCloseable { + + private static final Logger LOG = LoggerFactory.getLogger(VpnserviceProvider.class); + private VpnInterfaceManager vpnInterfaceManager; + private VpnManager vpnManager; + + @Override + public void onSessionInitiated(ProviderContext session) { + LOG.info("VpnserviceProvider Session Initiated"); + try { + final DataBroker dataBroker = session.getSALService(DataBroker.class); + vpnManager = new VpnManager(dataBroker); + vpnInterfaceManager = new VpnInterfaceManager(dataBroker); + } catch(Exception e) { + LOG.error("Error initializing services", e); + } + } + + @Override + public void close() throws Exception { + vpnManager.close(); + vpnInterfaceManager.close(); + } +} diff --git a/vpnmanager-impl/src/test/java/org/opendaylight/vpnservice/test/MockDataChangedEvent.java b/vpnmanager-impl/src/test/java/org/opendaylight/vpnservice/test/MockDataChangedEvent.java new file mode 100644 index 00000000..5e03dea3 --- /dev/null +++ b/vpnmanager-impl/src/test/java/org/opendaylight/vpnservice/test/MockDataChangedEvent.java @@ -0,0 +1,53 @@ +/* + * Copyright (c) 2015 Ericsson India Global Services Pvt Ltd. 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.vpnservice.test; + +import java.util.HashMap; +import java.util.HashSet; +import java.util.Map; +import java.util.Set; +import org.opendaylight.controller.md.sal.common.api.data.AsyncDataChangeEvent; +import org.opendaylight.yangtools.yang.binding.DataObject; +import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; + +class MockDataChangedEvent implements AsyncDataChangeEvent, DataObject> { + Map,DataObject> created = new HashMap<>(); + Map,DataObject> updated = new HashMap<>(); + Map,DataObject> original = new HashMap<>(); + Set> removed = new HashSet<>(); + + @Override + public Map, DataObject> getCreatedData() { + return created; + } + + @Override + public Map, DataObject> getUpdatedData() { + return updated; + } + + @Override + public Set> getRemovedPaths() { + return removed; + } + + @Override + public Map, DataObject> getOriginalData() { + return original; + } + + @Override + public DataObject getOriginalSubtree() { + throw new UnsupportedOperationException("Not implemented by mock"); + } + + @Override + public DataObject getUpdatedSubtree() { + throw new UnsupportedOperationException("Not implemented by mock"); + } +} diff --git a/vpnmanager-impl/src/test/java/org/opendaylight/vpnservice/test/VpnServiceTest.java b/vpnmanager-impl/src/test/java/org/opendaylight/vpnservice/test/VpnServiceTest.java new file mode 100644 index 00000000..a28c2987 --- /dev/null +++ b/vpnmanager-impl/src/test/java/org/opendaylight/vpnservice/test/VpnServiceTest.java @@ -0,0 +1,75 @@ +/* + * Copyright (c) 2015 Ericsson India Global Services Pvt Ltd. 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.vpnservice.test; + +import static org.junit.Assert.*; +import static org.mockito.Matchers.*; +import static org.mockito.Mockito.when; + +import org.junit.*; +import org.junit.runner.RunWith; +import org.mockito.Mock; +import org.mockito.runners.MockitoJUnitRunner; + +import org.opendaylight.vpnservice.VpnManager; +import org.opendaylight.controller.md.sal.binding.api.DataBroker; +import org.opendaylight.controller.md.sal.binding.api.DataChangeListener; +import org.opendaylight.controller.md.sal.common.api.data.AsyncDataBroker.DataChangeScope; +import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType; +import org.opendaylight.yangtools.concepts.ListenerRegistration; +import org.opendaylight.yangtools.yang.binding.DataObject; +import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.Interfaces; +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.yangtools.yang.binding.InstanceIdentifier.InstanceIdentifierBuilder; +import org.opendaylight.yang.gen.v1.urn.huawei.params.xml.ns.yang.l3vpn.rev140815.VpnInstances; +import org.opendaylight.yang.gen.v1.urn.huawei.params.xml.ns.yang.l3vpn.rev140815.vpn.instances.*; +import org.opendaylight.yang.gen.v1.urn.huawei.params.xml.ns.yang.l3vpn.rev140815.vpn.af.config.*; +import org.opendaylight.yang.gen.v1.urn.huawei.params.xml.ns.yang.l3vpn.rev140815.vpn.af.config.apply.label.apply.label.mode.*; +import org.opendaylight.yang.gen.v1.urn.huawei.params.xml.ns.yang.l3vpn.rev140815.vpn.af.config.apply.label.ApplyLabelMode; +import org.opendaylight.yang.gen.v1.urn.huawei.params.xml.ns.yang.l3vpn.rev140815.vpn.af.config.ApplyLabelBuilder; +import org.opendaylight.yang.gen.v1.urn.huawei.params.xml.ns.yang.l3vpn.rev140815.vpn.instances.vpn.instance.Ipv4FamilyBuilder; + +@RunWith(MockitoJUnitRunner.class) +public class VpnServiceTest { + @Mock DataBroker dataBroker; + @Mock ListenerRegistration dataChangeListenerRegistration; + MockDataChangedEvent event; + + @Before + public void setUp() throws Exception { + when(dataBroker.registerDataChangeListener( + any(LogicalDatastoreType.class), + any(InstanceIdentifier.class), + any(DataChangeListener.class), + any(DataChangeScope.class))) + .thenReturn(dataChangeListenerRegistration); + event = new MockDataChangedEvent(); + } + + @Test + public void test() { + VpnInstanceBuilder builder = new VpnInstanceBuilder().setKey(new VpnInstanceKey("Vpn1")). + setIpv4Family(new Ipv4FamilyBuilder().setRouteDistinguisher("100:1").setImportRoutePolicy("100:2"). + setExportRoutePolicy("100:1").setApplyLabel(new ApplyLabelBuilder().setApplyLabelMode( + new PerRouteBuilder().setApplyLabelPerRoute(true).build()).build()).build()); + VpnInstance instance = builder.build(); + VpnManager vpnManager = new VpnManager(dataBroker); + event.created.put(createVpnId("Vpn1"), instance); + vpnManager.onDataChanged(event); + } + + private InstanceIdentifier createVpnId(String name) { + InstanceIdentifierBuilder idBuilder = + InstanceIdentifier.builder(VpnInstances.class).child(VpnInstance.class, new VpnInstanceKey(name)); + InstanceIdentifier id = idBuilder.build(); + return id; + } + +}