2 * Copyright (c) 2015 Ericsson India Global Services Pvt Ltd. and others. All rights reserved.
4 * This program and the accompanying materials are made available under the
5 * terms of the Eclipse Public License v1.0 which accompanies this distribution,
6 * and is available at http://www.eclipse.org/legal/epl-v10.html
8 package org.opendaylight.vpnservice.nexthopmgr;
11 import com.google.common.base.Optional;
12 import java.util.concurrent.Future;
13 import com.google.common.util.concurrent.Futures;
14 import com.google.common.util.concurrent.FutureCallback;
15 import org.opendaylight.controller.md.sal.binding.api.DataBroker;
16 import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
17 import org.opendaylight.yangtools.yang.binding.DataObject;
18 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
19 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier.InstanceIdentifierBuilder;
20 import org.opendaylight.yangtools.yang.common.RpcResult;
22 import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
23 import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
24 import org.opendaylight.yang.gen.v1.urn.huawei.params.xml.ns.yang.l3vpn.rev140815.VpnInstances;
25 import org.opendaylight.yang.gen.v1.urn.huawei.params.xml.ns.yang.l3vpn.rev140815.vpn.instances.VpnInstance;
26 import org.opendaylight.yang.gen.v1.urn.huawei.params.xml.ns.yang.l3vpn.rev140815.vpn.instances.VpnInstanceKey;
27 import org.opendaylight.yang.gen.v1.urn.opendaylight.l3vpn.rev130911.VpnInstance1;
28 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.l3nexthop.rev150409.*;
29 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.l3nexthop.rev150409.l3nexthop.*;
30 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.l3nexthop.rev150409.l3nexthop.tunnelnexthops.*;
31 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.l3nexthop.rev150409.l3nexthop.vpnnexthops.*;
32 import org.slf4j.Logger;
33 import org.slf4j.LoggerFactory;
35 public class NexthopManager implements L3nexthopService, AutoCloseable {
36 private static final Logger LOG = LoggerFactory.getLogger(NexthopManager.class);
37 private final DataBroker broker;
39 private static final FutureCallback<Void> DEFAULT_CALLBACK =
40 new FutureCallback<Void>() {
41 public void onSuccess(Void result) {
42 LOG.info("Success in Datastore write operation");
44 public void onFailure(Throwable error) {
45 LOG.error("Error in Datastore write operation", error);
50 * Provides nexthop functions
51 * Creates group ID pool
53 * @param db - dataBroker reference
55 public NexthopManager(final DataBroker db) {
56 // create nexhhop ID pool
57 // getIdManager.createIdPool("nextHopGroupIdPool", 10000, 100000);
63 public void close() throws Exception {
64 LOG.info("NextHop Manager Closed");
68 public void createLocalNextHop(String ifName, String vpnName, String ipAddress)
70 String nhKey = new String("nexthop." + vpnName + ipAddress);
71 int groupId = 1;//getIdManager().getUniqueId("nextHopGroupIdPool", nhKey);
73 long vpnId = getVpnId(vpnName);
74 VpnNexthop nexthop = getVpnNexthop(vpnId, ipAddress);
75 if (nexthop == null) {
77 /* List<BucketInfo> listBucketInfo = new ArrayList<BucketInfo>();
78 List<ActionInfo> listActionInfo = interfacemgr.getEgressGroupActions(ifName);
79 BucketInfo bucket = new BucketInfo(listActionInfo);
81 listBucketInfo.add(bucket);
82 GroupEntity groupEntity = MDSALUtil.buildGroupEntity
83 (dpId, groupId, IPAddress, GroupTypes.GroupIndirect, listBucketInfo);
84 getMdsalApiManager().installGroup(groupEntity, objTransaction???);
88 addVpnNexthopToDS(vpnId, ipAddress, groupId);
94 private long getVpnId(String vpnName) {
95 InstanceIdentifierBuilder<VpnInstance> idBuilder = InstanceIdentifier.builder(VpnInstances.class)
96 .child(VpnInstance.class, new VpnInstanceKey(vpnName));
98 InstanceIdentifier<VpnInstance> id = idBuilder.build();
99 InstanceIdentifier<VpnInstance1> idx = id.augmentation(VpnInstance1.class);
100 Optional<VpnInstance1> vpn = read(LogicalDatastoreType.CONFIGURATION, idx);
102 if (vpn.isPresent()) return vpn.get().getVpnId();
106 private long getDpnId(String ifName) {
110 public void createRemoteNextHop(String ifName, String ipAddress)
112 String nhKey = new String("nexthop." + ifName + ipAddress);
113 int groupId = 1;//getIdManager().getUniqueId("nextHopGroupIdPool", nhKey);
115 long dpnId = getDpnId(ifName);
116 TunnelNexthop nexthop = getTunnelNexthop(dpnId, ipAddress);
117 if (nexthop == null) {
119 /* List<BucketInfo> listBucketInfo = new ArrayList<BucketInfo>();
120 List<ActionInfo> listActionInfo = interfacemgr.getEgressGroupActions(ifName);
121 BucketInfo bucket = new BucketInfo(listActionInfo);
123 listBucketInfo.add(bucket);
124 GroupEntity groupEntity = MDSALUtil.buildGroupEntity
125 (dpId, groupId, IPAddress, GroupTypes.GroupIndirect, listBucketInfo);
126 getMdsalApiManager().installGroup(groupEntity, objTransaction???);
130 addTunnelNexthopToDS(dpnId, ipAddress, groupId);
136 private void addVpnNexthopToDS(long vpnId, String ipPrefix, long egressPointer){
139 InstanceIdentifierBuilder<VpnNexthops> idBuilder = InstanceIdentifier.builder(L3nexthop.class)
140 .child(VpnNexthops.class, new VpnNexthopsKey(vpnId));
142 // check if vpn node is there or to be created
143 InstanceIdentifier<VpnNexthops> id = idBuilder.build();
144 Optional<VpnNexthops> nexthops = read(LogicalDatastoreType.CONFIGURATION, id);
145 if (!nexthops.isPresent()) {
147 VpnNexthops node = new VpnNexthopsBuilder().setKey(new VpnNexthopsKey(vpnId)).setVpnId(vpnId).build();
148 asyncWrite(LogicalDatastoreType.OPERATIONAL, id, node, DEFAULT_CALLBACK);
151 // Add nexthop to vpn node
152 VpnNexthop nh = new VpnNexthopBuilder().
153 setKey(new VpnNexthopKey(ipPrefix)).
154 setIpAddress(ipPrefix).
155 setEgressPointer(egressPointer).build();
157 InstanceIdentifier<VpnNexthop> id1 = idBuilder
158 .child(VpnNexthop.class, new VpnNexthopKey(ipPrefix)).build();
160 asyncWrite(LogicalDatastoreType.OPERATIONAL, id1, nh, DEFAULT_CALLBACK);
164 private void addTunnelNexthopToDS(long dpnId, String ipPrefix, long egressPointer){
165 InstanceIdentifierBuilder<TunnelNexthops> idBuilder = InstanceIdentifier.builder(L3nexthop.class)
166 .child(TunnelNexthops.class, new TunnelNexthopsKey(dpnId));
168 // check if dpn node is there or to be created
169 InstanceIdentifier<TunnelNexthops> id = idBuilder.build();
170 Optional<TunnelNexthops> nexthops = read(LogicalDatastoreType.CONFIGURATION, id);
171 if (!nexthops.isPresent()) {
173 TunnelNexthops node = new TunnelNexthopsBuilder().setKey(new TunnelNexthopsKey(dpnId)).setDpnId(dpnId).build();
174 asyncWrite(LogicalDatastoreType.OPERATIONAL, id, node, DEFAULT_CALLBACK);
177 // Add nexthop to dpn node
178 TunnelNexthop nh = new TunnelNexthopBuilder().
179 setKey(new TunnelNexthopKey(ipPrefix)).
180 setIpAddress(ipPrefix).
181 setEgressPointer(egressPointer).build();
183 InstanceIdentifier<TunnelNexthop> id1 = idBuilder
184 .child(TunnelNexthop.class, new TunnelNexthopKey(ipPrefix)).build();
186 asyncWrite(LogicalDatastoreType.OPERATIONAL, id1, nh, DEFAULT_CALLBACK);
190 private VpnNexthop getVpnNexthop(long vpnId, String ipAddress) {
192 InstanceIdentifierBuilder<VpnNexthop> idBuilder = InstanceIdentifier.builder(L3nexthop.class)
193 .child(VpnNexthops.class, new VpnNexthopsKey(vpnId))
194 .child(VpnNexthop.class, new VpnNexthopKey(ipAddress));
195 InstanceIdentifier<VpnNexthop> id = idBuilder.build();
196 Optional<VpnNexthop> nextHop = read(LogicalDatastoreType.CONFIGURATION, id);
198 if(nextHop.isPresent()) return nextHop.get();
202 private TunnelNexthop getTunnelNexthop(long dpnId, String ipAddress) {
203 InstanceIdentifierBuilder<TunnelNexthop> idBuilder = InstanceIdentifier.builder(L3nexthop.class)
204 .child(TunnelNexthops.class, new TunnelNexthopsKey(dpnId))
205 .child(TunnelNexthop.class, new TunnelNexthopKey(ipAddress));
206 InstanceIdentifier<TunnelNexthop> id = idBuilder.build();
207 Optional<TunnelNexthop> nextHop = read(LogicalDatastoreType.CONFIGURATION, id);
209 if(nextHop.isPresent()) return nextHop.get();
213 public long getNextHopPointer(long dpnId, long vpnId, String prefixIp, String nextHopIp) {
214 String endpointIp = "10.10.10.1";//interfaceManager.getLocalEndpointIp(dpnId);
215 if (nextHopIp.equals(endpointIp)) {
216 VpnNexthop vpnNextHop = getVpnNexthop(vpnId, prefixIp);
217 return vpnNextHop.getEgressPointer();
219 TunnelNexthop tunnelNextHop = getTunnelNexthop(dpnId, nextHopIp);
220 return tunnelNextHop.getEgressPointer();
224 public void removeRemoteNextHop(String ifname, String IpAddress)
226 String nhKey = new String("nexthop" + ifname + IpAddress);
227 int groupId = 1;//getIdManager().getUniqueId(L3Constants.L3NEXTHOP_GROUPID_POOL, nhKey);
229 /* if (getNextHop(groupId) != Null){
230 List<BucketInfo> listBucketInfo = new ArrayList<BucketInfo>();
231 List<ActionInfo> listActionInfo = null;//nextHop.getActions({output to port});
232 BucketInfo bucket = new BucketInfo(listActionInfo);
233 listBucketInfo.add(bucket);
234 //GroupEntity groupEntity = MDSALUtil.buildGroupEntity
235 (dpId, groupId, IPAddress, GroupTypes.GroupIndirect, listBucketInfo);
236 //getMdsalApiManager().removeGroup(groupEntity, objTransaction???);
239 removeNextHopFromDS(dpId, vpn, ipAddress);
245 private <T extends DataObject> Optional<T> read(LogicalDatastoreType datastoreType,
246 InstanceIdentifier<T> path) {
248 ReadOnlyTransaction tx = broker.newReadOnlyTransaction();
250 Optional<T> result = Optional.absent();
252 result = tx.read(datastoreType, path).get();
253 } catch (Exception e) {
254 throw new RuntimeException(e);
260 private <T extends DataObject> void asyncWrite(LogicalDatastoreType datastoreType,
261 InstanceIdentifier<T> path, T data, FutureCallback<Void> callback) {
262 WriteTransaction tx = broker.newWriteOnlyTransaction();
263 tx.put(datastoreType, path, data, true);
264 Futures.addCallback(tx.submit(), callback);
269 public Future<RpcResult<GetEgressPointerOutput>> getEgressPointer(
270 GetEgressPointerInput input) {
272 getNextHopPointer(input.getDpnId(), input.getVpnId(), input.getIpPrefix(), input.getNexthopIp());
274 GetEgressPointerOutputBuilder output = new GetEgressPointerOutputBuilder();
275 output.setEgressPointer(egressGroupId);
277 /*RpcResult<GetEgressPointerOutput> result = Rpcs.<GetEgressPointerOutput> getRpcResult(false, output.build());
278 return Futures.immediateFuture(result);*/