itm/itm-impl/src/main/java/org/opendaylight/vpnservice/itm/rpc/ItmManagerRpcService.java

   1 /*
   2  * Copyright (c) 2015 Ericsson India Global Services Pvt Ltd. and others.  All rights reserved.
   3  *
   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
   7  */
   8 package org.opendaylight.vpnservice.itm.rpc;
   9
  10 import java.math.BigInteger;
  11 import java.util.List;
  12 import java.util.concurrent.Future;
  13
  14 import org.slf4j.Logger;
  15 import org.slf4j.LoggerFactory;
  16 import org.opendaylight.controller.md.sal.binding.api.DataBroker;
  17 import org.opendaylight.vpnservice.itm.confighelpers.ItmExternalTunnelAddWorker;
  18 import org.opendaylight.vpnservice.itm.impl.ItmUtils;
  19 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.IpAddress;
  20 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.itm.op.rev150701.ExternalTunnelList;
  21 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.itm.op.rev150701.TunnelList;
  22 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.itm.op.rev150701.dpn.endpoints.DPNTEPsInfo;
  23 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.itm.op.rev150701.external.tunnel.list.ExternalTunnel;
  24 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.itm.op.rev150701.external.tunnel.list.ExternalTunnelKey;
  25 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.itm.op.rev150701.tunnel.list.Tunnel;
  26 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.itm.op.rev150701.tunnel.list.TunnelKey;
  27 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.itm.rpcs.rev151217.AddExternalTunnelEndpointInput;
  28 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.itm.rpcs.rev151217.BuildExternalTunnelFromDpnsInput;
  29 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.itm.rpcs.rev151217.GetExternalTunnelInterfaceNameInput;
  30 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.itm.rpcs.rev151217.GetExternalTunnelInterfaceNameOutput;
  31 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.itm.rpcs.rev151217.GetExternalTunnelInterfaceNameOutputBuilder;
  32 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.itm.rpcs.rev151217.GetTunnelInterfaceNameInput;
  33 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.itm.rpcs.rev151217.GetTunnelInterfaceNameOutput;
  34 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.itm.rpcs.rev151217.GetTunnelInterfaceNameOutputBuilder;
  35 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.itm.rpcs.rev151217.ItmRpcService;
  36 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.itm.rpcs.rev151217.RemoveExternalTunnelEndpointInput;
  37 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.itm.rpcs.rev151217.RemoveExternalTunnelFromDpnsInput;
  38 import org.opendaylight.yangtools.yang.common.RpcResult;
  39 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
  40
  41 import com.google.common.util.concurrent.FutureCallback;
  42 import com.google.common.util.concurrent.Futures;
  43 import com.google.common.util.concurrent.ListenableFuture;
  44 import com.google.common.util.concurrent.SettableFuture;
  45
  46 import org.opendaylight.yangtools.yang.common.RpcError;
  47 import org.opendaylight.yangtools.yang.common.RpcResultBuilder;
  48
  49 import com.google.common.base.Optional;
  50
  51 import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
  52
  53 public class ItmManagerRpcService implements ItmRpcService {
  54
  55    private static final Logger LOG = LoggerFactory.getLogger(ItmManagerRpcService.class);
  56         DataBroker dataBroker;
  57         public ItmManagerRpcService(DataBroker dataBroker) {
  58         this.dataBroker = dataBroker;
  59     }
  60
  61      @Override
  62      public Future<RpcResult<GetTunnelInterfaceNameOutput>> getTunnelInterfaceName(GetTunnelInterfaceNameInput input) {
  63          RpcResultBuilder<GetTunnelInterfaceNameOutput> resultBld = null;
  64          BigInteger sourceDpn = input.getSourceDpid() ;
  65          BigInteger destinationDpn = input.getDestinationDpid() ;
  66          InstanceIdentifier<Tunnel> path = InstanceIdentifier.create(
  67                  TunnelList.class)
  68                      .child(Tunnel.class, new TunnelKey(destinationDpn, sourceDpn));
  69
  70          Optional<Tunnel> tnl = ItmUtils.read(LogicalDatastoreType.CONFIGURATION, path, dataBroker);
  71
  72          if( tnl != null && tnl.isPresent())
  73          {
  74               Tunnel tunnel = tnl.get();
  75               GetTunnelInterfaceNameOutputBuilder output = new GetTunnelInterfaceNameOutputBuilder() ;
  76               output.setInterfaceName(tunnel.getTunnelInterfaceName()) ;
  77               resultBld = RpcResultBuilder.success();
  78               resultBld.withResult(output.build()) ;
  79          }else {
  80              resultBld = RpcResultBuilder.failed();
  81          }
  82
  83          return Futures.immediateFuture(resultBld.build());
  84      }
  85
  86
  87     @Override
  88     public Future<RpcResult<Void>> removeExternalTunnelEndpoint(
  89             RemoveExternalTunnelEndpointInput input) {
  90         // TODO Auto-generated method stub
  91         return null;
  92     }
  93
  94     @Override
  95     public Future<RpcResult<Void>> removeExternalTunnelFromDpns(
  96             RemoveExternalTunnelFromDpnsInput input) {
  97         //Ignore the Futures for now
  98         final SettableFuture<RpcResult<Void>> result = SettableFuture.create();
  99 //        ItmExternalTunnelDeleteWorker.buildTunnelsFromDpnToExternalEndPoint(dataBroker, input.getDpnId(), null, input.getDestinationIp());
 100         result.set(RpcResultBuilder.<Void>success().build());
 101         return result;
 102     }
 103
 104     @Override
 105     public Future<RpcResult<Void>> buildExternalTunnelFromDpns(
 106             BuildExternalTunnelFromDpnsInput input) {
 107         //Ignore the Futures for now
 108         final SettableFuture<RpcResult<Void>> result = SettableFuture.create();
 109         List<ListenableFuture<Void>> extTunnelResultList = ItmExternalTunnelAddWorker.buildTunnelsFromDpnToExternalEndPoint(dataBroker, input.getDpnId(), input.getDestinationIp(), input.getTunnelType());
 110         for (ListenableFuture<Void> extTunnelResult : extTunnelResultList) {
 111             Futures.addCallback(extTunnelResult, new FutureCallback<Void>(){
 112
 113                 @Override
 114                 public void onSuccess(Void aVoid) {
 115                     result.set(RpcResultBuilder.<Void>success().build());
 116                 }
 117
 118                 @Override
 119                 public void onFailure(Throwable error) {
 120                     String msg = String.format("Unable to create ext tunnel");
 121                     LOG.error("create ext tunnel failed. {}. {}", msg, error);
 122                     result.set(RpcResultBuilder.<Void>failed().withError(RpcError.ErrorType.APPLICATION, msg, error).build());
 123                 }
 124             });
 125         }
 126         result.set(RpcResultBuilder.<Void>success().build());
 127         return result;
 128     }
 129
 130     @Override
 131     public Future<RpcResult<Void>> addExternalTunnelEndpoint(
 132             AddExternalTunnelEndpointInput input) {
 133         // TODO Auto-generated method stub
 134
 135         //Ignore the Futures for now
 136         final SettableFuture<RpcResult<Void>> result = SettableFuture.create();
 137     //    ItmExternalTunnelAddWorker.buildTunnelsToExternalEndPoint(dataBroker, null, input.getDestinationIp()) ;
 138         result.set(RpcResultBuilder.<Void>success().build());
 139         return result;
 140     }
 141
 142     @Override
 143     public Future<RpcResult<GetExternalTunnelInterfaceNameOutput>> getExternalTunnelInterfaceName(
 144             GetExternalTunnelInterfaceNameInput input) {
 145         final SettableFuture<RpcResult<GetExternalTunnelInterfaceNameOutput>> result = SettableFuture.create() ;
 146         RpcResultBuilder<GetExternalTunnelInterfaceNameOutput> resultBld;
 147         BigInteger sourceDpn = input.getSourceDpid() ;
 148         IpAddress destinationIp = input.getDestinationIp() ;
 149         InstanceIdentifier<ExternalTunnel> path = InstanceIdentifier.create(
 150                 ExternalTunnelList.class)
 151                     .child(ExternalTunnel.class, new ExternalTunnelKey(destinationIp, sourceDpn));
 152
 153         Optional<ExternalTunnel> ext = ItmUtils.read(LogicalDatastoreType.CONFIGURATION, path, dataBroker);
 154
 155         if( ext != null && ext.isPresent())
 156         {
 157              ExternalTunnel exTunnel = ext.get();
 158              GetExternalTunnelInterfaceNameOutputBuilder output = new GetExternalTunnelInterfaceNameOutputBuilder() ;
 159              output.setInterfaceName(exTunnel.getTunnelInterfaceName()) ;
 160              resultBld = RpcResultBuilder.success();
 161              resultBld.withResult(output.build()) ;
 162         }else {
 163             resultBld = RpcResultBuilder.failed();
 164         }
 165
 166         return Futures.immediateFuture(resultBld.build());
 167
 168     }
 169 }