openstack/net-virt/src/main/java/org/opendaylight/netvirt/openstack/netvirt/translator/crud/impl/NeutronRouterInterface.java

   1 /*
   2  * Copyright (c) 2013, 2015 IBM Corporation 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
   9 package org.opendaylight.netvirt.openstack.netvirt.translator.crud.impl;
  10
  11 import java.util.ArrayList;
  12 import java.util.HashMap;
  13 import java.util.HashSet;
  14 import java.util.List;
  15 import java.util.Map;
  16 import java.util.Map.Entry;
  17 import java.util.Set;
  18
  19 import org.opendaylight.controller.sal.binding.api.BindingAwareBroker.ProviderContext;
  20 import org.opendaylight.netvirt.openstack.netvirt.translator.crud.INeutronRouterCRUD;
  21 import org.opendaylight.netvirt.openstack.netvirt.translator.NeutronRouter;
  22 import org.opendaylight.netvirt.openstack.netvirt.translator.NeutronRouter_NetworkReference;
  23 import org.opendaylight.netvirt.openstack.netvirt.translator.Neutron_IPs;
  24 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.IpAddress;
  25 import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.l3.rev150712.l3.attributes.Routes;
  26 import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.l3.rev150712.routers.attributes.Routers;
  27 import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.l3.rev150712.routers.attributes.routers.Router;
  28 import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.l3.rev150712.routers.attributes.routers.RouterBuilder;
  29 import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.l3.rev150712.routers.attributes.routers.router.ExternalGatewayInfo;
  30 import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.l3.rev150712.routers.attributes.routers.router.ExternalGatewayInfoBuilder;
  31 import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.l3.rev150712.routers.attributes.routers.router.external_gateway_info.ExternalFixedIps;
  32 import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.l3.rev150712.routers.attributes.routers.router.external_gateway_info.ExternalFixedIpsBuilder;
  33 import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.rev150712.Neutron;
  34 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
  35 import org.osgi.framework.BundleContext;
  36 import org.osgi.framework.ServiceRegistration;
  37 import org.slf4j.Logger;
  38 import org.slf4j.LoggerFactory;
  39
  40 public class NeutronRouterInterface extends  AbstractNeutronInterface<Router, NeutronRouter> implements INeutronRouterCRUD {
  41     private static final Logger LOGGER = LoggerFactory.getLogger(NeutronRouterInterface.class);
  42     // methods needed for creating caches
  43
  44
  45     NeutronRouterInterface(ProviderContext providerContext) {
  46         super(providerContext);
  47     }
  48
  49
  50     // IfNBRouterCRUD Interface methods
  51
  52     @Override
  53     public boolean routerExists(String uuid) {
  54         Router router = readMd(createInstanceIdentifier(toMd(uuid)));
  55         return router != null;
  56     }
  57
  58     @Override
  59     public NeutronRouter getRouter(String uuid) {
  60         Router router = readMd(createInstanceIdentifier(toMd(uuid)));
  61         if (router == null) {
  62             return null;
  63         }
  64         return fromMd(router);
  65     }
  66
  67     @Override
  68     public List<NeutronRouter> getAllRouters() {
  69         Set<NeutronRouter> allRouters = new HashSet<>();
  70         Routers routers = readMd(createInstanceIdentifier());
  71         if (routers != null) {
  72             for (Router router: routers.getRouter()) {
  73                 allRouters.add(fromMd(router));
  74             }
  75         }
  76         LOGGER.debug("Exiting getAllRouters, Found {} Routers", allRouters.size());
  77         List<NeutronRouter> ans = new ArrayList<>();
  78         ans.addAll(allRouters);
  79         return ans;
  80     }
  81
  82     @Override
  83     public boolean addRouter(NeutronRouter input) {
  84         if (routerExists(input.getID())) {
  85             return false;
  86         }
  87         addMd(input);
  88         return true;
  89     }
  90
  91     @Override
  92     public boolean removeRouter(String uuid) {
  93         if (!routerExists(uuid)) {
  94             return false;
  95         }
  96         return removeMd(toMd(uuid));
  97     }
  98
  99     @Override
 100     public boolean updateRouter(String uuid, NeutronRouter delta) {
 101         if (!routerExists(uuid)) {
 102             return false;
 103         }
 104         updateMd(delta);
 105         return true;
 106     }
 107
 108     @Override
 109     public boolean routerInUse(String routerUUID) {
 110         return !routerExists(routerUUID);
 111     }
 112
 113     @Override
 114     protected Router toMd(NeutronRouter router) {
 115
 116         RouterBuilder routerBuilder = new RouterBuilder();
 117
 118         if (router.getRouterUUID() != null) {
 119             routerBuilder.setUuid(toUuid(router.getRouterUUID()));
 120         }
 121         if (router.getName() != null) {
 122             routerBuilder.setName(router.getName());
 123         }
 124         if (router.getTenantID() != null && !router.getTenantID().isEmpty()) {
 125             routerBuilder.setTenantId(toUuid(router.getTenantID()));
 126         }
 127         if (router.getStatus() != null) {
 128             routerBuilder.setStatus(router.getStatus());
 129         }
 130         if (router.getGatewayPortId() != null && !router.getGatewayPortId().isEmpty()) {
 131             routerBuilder.setGatewayPortId(toUuid(router.getGatewayPortId()));
 132         }
 133         routerBuilder.setAdminStateUp(router.getAdminStateUp());
 134         routerBuilder.setDistributed(router.getDistributed());
 135         if (router.getRoutes() != null) {
 136             List<Routes> routes = new ArrayList<>();
 137             for (Routes route : router.getRoutes()) {
 138                 routes.add(route);
 139             }
 140             routerBuilder.setRoutes(routes);
 141         }
 142         if (router.getExternalGatewayInfo() != null) {
 143             ExternalGatewayInfo externalGatewayInfo = null;
 144             List<NeutronRouter_NetworkReference> neutronRouter_NetworkReferences = new ArrayList<>();
 145             neutronRouter_NetworkReferences.add(router.getExternalGatewayInfo());
 146             for (NeutronRouter_NetworkReference externalGatewayInfos : neutronRouter_NetworkReferences) {
 147                 ExternalGatewayInfoBuilder builder = new ExternalGatewayInfoBuilder();
 148                 builder.setEnableSnat(externalGatewayInfos.getEnableSNAT());
 149                 builder.setExternalNetworkId(toUuid(externalGatewayInfos.getNetworkID()));
 150                 if (externalGatewayInfos.getExternalFixedIPs() != null) {
 151                     List<ExternalFixedIps> externalFixedIps = new ArrayList<>();
 152                     for (Neutron_IPs eIP : externalGatewayInfos.getExternalFixedIPs()) {
 153                         ExternalFixedIpsBuilder eFixedIpBuilder = new ExternalFixedIpsBuilder();
 154                         eFixedIpBuilder.setIpAddress(new IpAddress(eIP.getIpAddress().toCharArray()));
 155                         eFixedIpBuilder.setSubnetId(toUuid(eIP.getSubnetUUID()));
 156                         externalFixedIps.add(eFixedIpBuilder.build());
 157                     }
 158                     builder.setExternalFixedIps(externalFixedIps);
 159                 }
 160                 externalGatewayInfo = builder.build();
 161             }
 162             routerBuilder.setExternalGatewayInfo(externalGatewayInfo);
 163         }
 164         if (router.getID() != null) {
 165             routerBuilder.setUuid(toUuid(router.getID()));
 166         } else {
 167             LOGGER.warn("Attempting to write neutron router without UUID");
 168         }
 169         return routerBuilder.build();
 170     }
 171
 172     @Override
 173     protected InstanceIdentifier<Router> createInstanceIdentifier(Router router) {
 174         return InstanceIdentifier.create(Neutron.class)
 175                  .child(Routers.class)
 176                  .child(Router.class, router.getKey());
 177     }
 178
 179     protected InstanceIdentifier<Routers> createInstanceIdentifier() {
 180         return InstanceIdentifier.create(Neutron.class).child(Routers.class);
 181     }
 182
 183     @Override
 184     protected Router toMd(String uuid) {
 185         RouterBuilder routerBuilder = new RouterBuilder();
 186         routerBuilder.setUuid(toUuid(uuid));
 187         return routerBuilder.build();
 188     }
 189
 190     public NeutronRouter fromMd(Router router) {
 191         NeutronRouter result = new NeutronRouter();
 192         result.setID(String.valueOf(router.getUuid().getValue()));
 193         result.setName(router.getName());
 194         result.setTenantID(String.valueOf(router.getTenantId().getValue()));
 195         result.setAdminStateUp(router.isAdminStateUp());
 196         result.setStatus(router.getStatus());
 197         result.setDistributed(router.isDistributed());
 198         if (router.getGatewayPortId() != null) {
 199             result.setGatewayPortId(String.valueOf(router.getGatewayPortId().getValue()));
 200         }
 201         if (router.getRoutes() != null) {
 202             List<Routes> routes = new ArrayList<>();
 203             for (Routes route : router.getRoutes()) {
 204                 routes.add(route);
 205             }
 206             result.setRoutes(routes);
 207         }
 208
 209         if (router.getExternalGatewayInfo() != null) {
 210             NeutronRouter_NetworkReference extGwInfo = new NeutronRouter_NetworkReference();
 211             extGwInfo.setNetworkID(String.valueOf(router.getExternalGatewayInfo().getExternalNetworkId().getValue()));
 212             extGwInfo.setEnableSNAT(router.getExternalGatewayInfo().isEnableSnat());
 213             if (router.getExternalGatewayInfo().getExternalFixedIps() != null) {
 214                 List<Neutron_IPs> fixedIPs = new ArrayList<>();
 215                 for (ExternalFixedIps mdFixedIP : router.getExternalGatewayInfo().getExternalFixedIps()) {
 216                      Neutron_IPs fixedIP = new Neutron_IPs();
 217                      fixedIP.setSubnetUUID(String.valueOf(mdFixedIP.getSubnetId().getValue()));
 218                      fixedIP.setIpAddress(String.valueOf(mdFixedIP.getIpAddress().getValue()));
 219                      fixedIPs.add(fixedIP);
 220                 }
 221                 extGwInfo.setExternalFixedIPs(fixedIPs);
 222             }
 223             result.setExternalGatewayInfo(extGwInfo);
 224         }
 225
 226         return result;
 227     }
 228
 229     public static void registerNewInterface(BundleContext context,
 230             ProviderContext providerContext,
 231             List<ServiceRegistration<?>> registrations) {
 232         NeutronRouterInterface neutronRouterInterface = new NeutronRouterInterface(providerContext);
 233         ServiceRegistration<INeutronRouterCRUD> neutronRouterInterfaceRegistration = context.registerService(INeutronRouterCRUD.class, neutronRouterInterface, null);
 234         if(neutronRouterInterfaceRegistration != null) {
 235                 registrations.add(neutronRouterInterfaceRegistration);
 236         }
 237         }
 238 }