mappingservice/implementation/src/main/java/org/opendaylight/lispflowmapping/implementation/LfmMappingDatabaseRpc.java

   1 /*
   2  * Copyright (c) 2015 Cisco Systems, Inc.  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.lispflowmapping.implementation;
   9
  10 import java.util.concurrent.Future;
  11
  12 import org.opendaylight.controller.md.sal.binding.api.DataBroker;
  13 import org.opendaylight.lispflowmapping.implementation.mdsal.DataStoreBackEnd;
  14 import org.opendaylight.lispflowmapping.implementation.util.RPCInputConvertorUtil;
  15 import org.opendaylight.lispflowmapping.lisp.util.MapServerMapResolverUtil;
  16 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.MapReply;
  17 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.MapRequest;
  18 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mapping.database.rev150314.AddKeyInput;
  19 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mapping.database.rev150314.AddMappingInput;
  20 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mapping.database.rev150314.GetKeyInput;
  21 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mapping.database.rev150314.GetKeyOutput;
  22 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mapping.database.rev150314.GetKeyOutputBuilder;
  23 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mapping.database.rev150314.GetMappingInput;
  24 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mapping.database.rev150314.GetMappingOutput;
  25 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mapping.database.rev150314.GetMappingOutputBuilder;
  26 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mapping.database.rev150314.LfmMappingDatabaseService;
  27 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mapping.database.rev150314.RemoveKeyInput;
  28 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mapping.database.rev150314.RemoveMappingInput;
  29 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mapping.database.rev150314.UpdateKeyInput;
  30 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mapping.database.rev150314.UpdateMappingInput;
  31 import org.opendaylight.yangtools.yang.common.RpcError;
  32 import org.opendaylight.yangtools.yang.common.RpcResult;
  33 import org.opendaylight.yangtools.yang.common.RpcResultBuilder;
  34 import org.slf4j.Logger;
  35 import org.slf4j.LoggerFactory;
  36
  37 import com.google.common.base.Preconditions;
  38 import com.google.common.util.concurrent.Futures;
  39
  40 /**
  41  * Implementation of the RPCs defined in lfm-mapping-database.yang
  42  *
  43  * @author Lorand Jakab
  44  * @author Florin Coras
  45  *
  46  */
  47 public class LfmMappingDatabaseRpc implements LfmMappingDatabaseService {
  48     protected static final Logger LOG = LoggerFactory.getLogger(LfmMappingDatabaseRpc.class);
  49     private static final String NOT_FOUND_TAG = "data-missing";
  50     private static final String DATA_EXISTS_TAG = "data-exists";
  51
  52     private LispMappingService lispMappingService;
  53     private DataBroker dataBroker;
  54     private DataStoreBackEnd dsbe;
  55
  56     public LfmMappingDatabaseRpc(DataBroker dataBroker) {
  57         this.lispMappingService = LispMappingService.getLispMappingService();
  58         this.dataBroker = dataBroker;
  59         this.dsbe = new DataStoreBackEnd(this.dataBroker);
  60         LOG.debug("LfmMappingDatabaseProviderRpc created!");
  61     }
  62
  63     @Override
  64     public Future<RpcResult<Void>> addKey(AddKeyInput input) {
  65         Preconditions.checkNotNull(input, "add-key RPC input must be not null!");
  66         LOG.trace("RPC received to add the following key: " + input.toString());
  67
  68         RpcResultBuilder<Void> rpcResultBuilder;
  69
  70         String key = lispMappingService.getAuthenticationKey(input.getLispAddressContainer(),
  71                 input.getMaskLength());
  72
  73         if (key != null) {
  74             String message = "Key already exists! Please use update-key if you want to change it.";
  75             rpcResultBuilder = RpcResultBuilder.<Void>failed()
  76                     .withError(RpcError.ErrorType.PROTOCOL, DATA_EXISTS_TAG, message);
  77             return Futures.immediateFuture(rpcResultBuilder.build());
  78         }
  79
  80         dsbe.addAuthenticationKey(RPCInputConvertorUtil.toAuthenticationKey(input));
  81         rpcResultBuilder = RpcResultBuilder.success();
  82
  83         return Futures.immediateFuture(rpcResultBuilder.build());
  84     }
  85
  86     @Override
  87     public Future<RpcResult<Void>> addMapping(AddMappingInput input) {
  88         Preconditions.checkNotNull(input, "add-mapping RPC input must be not null!");
  89         LOG.trace("RPC received to add the following mapping: " + input.toString());
  90
  91         dsbe.addMapping(RPCInputConvertorUtil.toMapping(input));
  92
  93         RpcResultBuilder<Void> rpcResultBuilder;
  94
  95         rpcResultBuilder = RpcResultBuilder.success();
  96
  97         return Futures.immediateFuture(rpcResultBuilder.build());
  98     }
  99
 100     @Override
 101     public Future<RpcResult<GetKeyOutput>> getKey(GetKeyInput input) {
 102         Preconditions.checkNotNull(input, "get-key RPC input must be not null!");
 103         LOG.trace("RPC received to get the following key: " + input.toString());
 104
 105         RpcResultBuilder<GetKeyOutput> rpcResultBuilder;
 106
 107         String key = lispMappingService.getAuthenticationKey(input.getLispAddressContainer(), input.getMaskLength());
 108
 109         if (key == null) {
 110             String message = "Key was not found in the mapping database";
 111             rpcResultBuilder = RpcResultBuilder.<GetKeyOutput>failed()
 112                     .withError(RpcError.ErrorType.APPLICATION, NOT_FOUND_TAG, message);
 113         } else {
 114             rpcResultBuilder = RpcResultBuilder.success(new GetKeyOutputBuilder().setAuthkey(key));
 115         }
 116
 117         return Futures.immediateFuture(rpcResultBuilder.build());
 118     }
 119
 120     @Override
 121     public Future<RpcResult<GetMappingOutput>> getMapping(GetMappingInput input) {
 122         Preconditions.checkNotNull(input, "get-mapping RPC input must be not null!");
 123         LOG.trace("RPC received to get the following mapping: " + input.toString());
 124
 125         RpcResultBuilder<GetMappingOutput> rpcResultBuilder;
 126
 127         MapRequest request = MapServerMapResolverUtil.getMapRequest(input.getLispAddressContainer(),
 128                 input.getMaskLength());
 129         MapReply reply = lispMappingService.handleMapRequest(request, false);
 130
 131         if (reply == null) {
 132             String message = "No mapping was found in the mapping database";
 133             rpcResultBuilder = RpcResultBuilder.<GetMappingOutput>failed()
 134                     .withError(RpcError.ErrorType.APPLICATION, NOT_FOUND_TAG, message);
 135         } else {
 136             rpcResultBuilder = RpcResultBuilder.success(new GetMappingOutputBuilder()
 137             .setEidToLocatorRecord(reply.getEidToLocatorRecord()));
 138         }
 139
 140         return Futures.immediateFuture(rpcResultBuilder.build());
 141     }
 142
 143     @Override
 144     public Future<RpcResult<Void>> removeKey(RemoveKeyInput input) {
 145         Preconditions.checkNotNull(input, "remove-key RPC input must be not null!");
 146         LOG.trace("RPC received to remove the following key: " + input.toString());
 147
 148         RpcResultBuilder<Void> rpcResultBuilder;
 149
 150         dsbe.removeAuthenticationKey(RPCInputConvertorUtil.toAuthenticationKey(input));
 151
 152         rpcResultBuilder = RpcResultBuilder.success();
 153
 154         return Futures.immediateFuture(rpcResultBuilder.build());
 155     }
 156
 157     @Override
 158     public Future<RpcResult<Void>> removeMapping(RemoveMappingInput input) {
 159         Preconditions.checkNotNull(input, "remove-mapping RPC input must be not null!");
 160         LOG.trace("RPC received to remove the following mapping: " + input.toString());
 161
 162         RpcResultBuilder<Void> rpcResultBuilder;
 163
 164         dsbe.removeMapping(RPCInputConvertorUtil.toMapping(input));
 165
 166         rpcResultBuilder = RpcResultBuilder.success();
 167
 168         return Futures.immediateFuture(rpcResultBuilder.build());
 169     }
 170
 171     @Override
 172     public Future<RpcResult<Void>> updateKey(UpdateKeyInput input) {
 173         Preconditions.checkNotNull(input, "update-key RPC input must be not null!");
 174         LOG.trace("RPC received to update the following key: " + input.toString());
 175
 176         RpcResultBuilder<Void> rpcResultBuilder;
 177
 178         String key = lispMappingService.getAuthenticationKey(input.getEid().getLispAddressContainer(),
 179                 input.getEid().getMaskLength());
 180
 181         if (key == null) {
 182             String message = "Key doesn't exist! Please use add-key if you want to create a new authentication key.";
 183             rpcResultBuilder = RpcResultBuilder.<Void>failed()
 184                     .withError(RpcError.ErrorType.PROTOCOL, NOT_FOUND_TAG, message);
 185             return Futures.immediateFuture(rpcResultBuilder.build());
 186         }
 187
 188         dsbe.updateAuthenticationKey(RPCInputConvertorUtil.toAuthenticationKey(input));
 189         rpcResultBuilder = RpcResultBuilder.success();
 190
 191         return Futures.immediateFuture(rpcResultBuilder.build());
 192     }
 193
 194     @Override
 195     public Future<RpcResult<Void>> updateMapping(UpdateMappingInput input) {
 196         LOG.trace("RPC received to update the following mapping: " + input.toString());
 197         Preconditions.checkNotNull(input, "update-mapping RPC input must be not null!");
 198
 199         RpcResultBuilder<Void> rpcResultBuilder;
 200
 201         dsbe.updateMapping(RPCInputConvertorUtil.toMapping(input));
 202
 203         rpcResultBuilder = RpcResultBuilder.success();
 204
 205         return Futures.immediateFuture(rpcResultBuilder.build());
 206     }
 207
 208     public void setLispMappingService(LispMappingService lispMappingService) {
 209         this.lispMappingService = lispMappingService;
 210     }
 211 }