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