neutron/src/main/java/org/opendaylight/plugin2oc/neutron/LoadBalancerHandler.java

   1 package org.opendaylight.plugin2oc.neutron;
   2
   3 import java.io.IOException;
   4 import java.net.HttpURLConnection;
   5 import java.util.List;
   6 import java.util.UUID;
   7
   8 import net.juniper.contrail.api.ApiConnector;
   9 import net.juniper.contrail.api.ObjectReference;
  10 import net.juniper.contrail.api.types.InstanceIp;
  11 import net.juniper.contrail.api.types.Project;
  12 import net.juniper.contrail.api.types.VirtualMachineInterface;
  13 import net.juniper.contrail.api.types.VirtualNetwork;
  14 import net.juniper.contrail.api.types.VnSubnetsType;
  15
  16 import org.opendaylight.controller.networkconfig.neutron.INeutronLoadBalancerAware;
  17 import org.opendaylight.controller.networkconfig.neutron.INeutronSubnetCRUD;
  18 import org.opendaylight.controller.networkconfig.neutron.NeutronCRUDInterfaces;
  19 import org.opendaylight.controller.networkconfig.neutron.NeutronLoadBalancer;
  20 import org.opendaylight.controller.networkconfig.neutron.NeutronSubnet;
  21 import org.slf4j.Logger;
  22 import org.slf4j.LoggerFactory;
  23
  24 /**
  25  * Handle requests for Neutron LoadBalancer.
  26  */
  27 public class LoadBalancerHandler implements INeutronLoadBalancerAware {
  28     /**
  29      * Logger instance.
  30      */
  31     static final Logger LOGGER = LoggerFactory.getLogger(LoadBalancerHandler.class);
  32     static ApiConnector apiConnector;
  33
  34     /**
  35      * Invoked when a LoadBalancer creation is requested to check if the specified
  36      * LoadBalancer can be created and then creates the LoadBalancer
  37      *
  38      * @param loadBalancer
  39      *            An instance of proposed new Neutron LoadBalancer object.
  40      *
  41      * @return A HTTP status code to the creation request.
  42      */
  43     @Override
  44     public int canCreateNeutronLoadBalancer(NeutronLoadBalancer loadBalancer) {
  45         if (loadBalancer == null) {
  46             LOGGER.error("LoadBalancer object can't be null..");
  47             return HttpURLConnection.HTTP_BAD_REQUEST;
  48         }
  49         apiConnector = Activator.apiConnector;
  50         if (loadBalancer.getLoadBalancerTenantID() == null || loadBalancer.getLoadBalancerVipSubnetID() == null) {
  51             LOGGER.error("LoadBalancer TenanID/SubnetID can not be null");
  52             return HttpURLConnection.HTTP_BAD_REQUEST;
  53         }
  54         try {
  55             String loadBalancerID = loadBalancer.getLoadBalancerID();
  56             String loadBalancerVipSubnetID = loadBalancer.getLoadBalancerVipSubnetID();
  57             String projectUUID = loadBalancer.getLoadBalancerTenantID();
  58             try {
  59                 if (!(loadBalancerID.contains("-"))) {
  60                     loadBalancerID = Utils.uuidFormater(loadBalancerID);
  61                 }
  62                 if (!(projectUUID.contains("-"))) {
  63                     projectUUID = Utils.uuidFormater(projectUUID);
  64                 }
  65                 if (!(loadBalancerVipSubnetID.contains("-"))) {
  66                     loadBalancerVipSubnetID = Utils.uuidFormater(loadBalancerVipSubnetID);
  67                 }
  68                 boolean isValidLoadBalancerID = Utils.isValidHexNumber(loadBalancerID);
  69                 boolean isValidprojectUUID = Utils.isValidHexNumber(projectUUID);
  70                 boolean isValidVipSubnetID = Utils.isValidHexNumber(loadBalancerVipSubnetID);
  71                 if (!isValidLoadBalancerID || !isValidprojectUUID || !isValidVipSubnetID) {
  72                     LOGGER.info("Badly formed Hexadecimal UUID...");
  73                     return HttpURLConnection.HTTP_BAD_REQUEST;
  74                 }
  75                 projectUUID = UUID.fromString(projectUUID).toString();
  76                 loadBalancerID = UUID.fromString(loadBalancerID).toString();
  77                 loadBalancerVipSubnetID = UUID.fromString(loadBalancerVipSubnetID).toString();
  78             } catch (Exception ex) {
  79                 LOGGER.error("UUID input incorrect", ex);
  80                 return HttpURLConnection.HTTP_BAD_REQUEST;
  81             }
  82             Project project = (Project) apiConnector.findById(Project.class, projectUUID);
  83             if (project == null) {
  84                 try {
  85                     Thread.currentThread();
  86                     Thread.sleep(3000);
  87                 } catch (InterruptedException e) {
  88                     LOGGER.error("InterruptedException :    ", e);
  89                     return HttpURLConnection.HTTP_BAD_REQUEST;
  90                 }
  91                 project = (Project) apiConnector.findById(Project.class, projectUUID);
  92                 if (project == null) {
  93                     LOGGER.error("Could not find projectUUID...");
  94                     return HttpURLConnection.HTTP_NOT_FOUND;
  95                 }
  96             }
  97             /* TODO: support for LoadBalancer is not provided in OpenContrail */
  98             // LoadBalancer loadBalancer = (LoadBalancer)
  99             // apiConnector.findById(LoadBalancer.class, loadBalancerID);
 100             // if (loadBalancer != null) {
 101             // LOGGER.warn("Loadbalancer already exists with UUID" +
 102             // loadBalancerID);
 103             // return HttpURLConnection.HTTP_FORBIDDEN;
 104             // }
 105
 106             /* to check if provided subnet ID already exists in contrail */
 107
 108             INeutronSubnetCRUD subnetInterface = NeutronCRUDInterfaces.getINeutronSubnetCRUD(this);
 109             if (subnetInterface == null) {
 110                 LOGGER.error("The subnet does not exists in ODL itself..");
 111                 return HttpURLConnection.HTTP_FORBIDDEN;
 112             }
 113             NeutronSubnet subnet = subnetInterface.getSubnet(loadBalancerVipSubnetID);
 114             if (subnet == null) {
 115                 LOGGER.error("Subnet does not exists...");
 116                 return HttpURLConnection.HTTP_FORBIDDEN;
 117             }
 118             String networkUUID = subnet.getNetworkUUID();
 119             VirtualNetwork virtualnetwork = (VirtualNetwork) apiConnector.findById(VirtualNetwork.class, networkUUID);
 120             if (virtualnetwork == null) {
 121                 LOGGER.error("No network exists for the specified subnet...");
 122                 return HttpURLConnection.HTTP_FORBIDDEN;
 123             } else {
 124                 try {
 125                     boolean ifSubnetExist = subnetExists(virtualnetwork.getNetworkIpam(), subnet);
 126                     if (!ifSubnetExist) {
 127                         LOGGER.error("The subnet does not exists..");
 128                         return HttpURLConnection.HTTP_FORBIDDEN;
 129                     }
 130                 } catch (Exception e) {
 131                     LOGGER.error("Exception:  " + e);
 132                     return HttpURLConnection.HTTP_INTERNAL_ERROR;
 133                 }
 134             }
 135             return HttpURLConnection.HTTP_OK;
 136         } catch (IOException ie) {
 137             LOGGER.error("IOException :   " + ie);
 138             System.out.println("exception 1");
 139             return HttpURLConnection.HTTP_INTERNAL_ERROR;
 140         } catch (Exception e) {
 141             LOGGER.error("Exception :   " + e);
 142             System.out.println("exception 2");
 143             return HttpURLConnection.HTTP_INTERNAL_ERROR;
 144         }
 145
 146     }
 147
 148     /**
 149      * Invoked to take action after a loadBalancer has been created.
 150      *
 151      * @param loadBalancer
 152      *            An instance of new Neutron loadBalancer object.
 153      */
 154     @Override
 155     public void neutronLoadBalancerCreated(NeutronLoadBalancer loadBalancer) {
 156         try {
 157             createLoadBalancer(loadBalancer);
 158         } catch (IOException ex) {
 159             LOGGER.warn("Exception  :    " + ex);
 160         }
 161 //        LoadBalancer loadBalancer = null;
 162         try {
 163             String loadBalanceUUID = loadBalancer.getLoadBalancerID();
 164             if (!(loadBalanceUUID.contains("-"))) {
 165                 loadBalanceUUID = Utils.uuidFormater(loadBalanceUUID);
 166             }
 167             loadBalanceUUID = UUID.fromString(loadBalanceUUID).toString();
 168             /* TODO: support for LoadBalancer is not provided in OpenContrail */
 169             // loadBalancer = (LoadBalancer)
 170             // apiConnector.findById(LoadBalancer.class, loadBalancerID);
 171             // if (loadBalancer != null) {
 172             // LOGGER.warn("Loadbalancer creation verified...." +
 173             // loadBalancerID);
 174             // return HttpURLConnection.HTTP_FORBIDDEN;
 175             // }
 176         } catch (Exception e) {
 177             LOGGER.error("Exception :     " + e);
 178         }
 179     }
 180
 181     /**
 182      * Invoked to create the specified Neutron LoadBalancer.
 183      *
 184      * @param loadBalancer
 185      *            An instance of new Neutron LoadBalancer object.
 186      */
 187     private void createLoadBalancer(NeutronLoadBalancer loadBalancer) throws IOException {
 188 //        LoadBalancer virtualLoadBalancer = new LoadBalancer();
 189 //        virtualLoadBalancer = mapLoadBalancerProperties(loadBalancer, virtualLoadBalancer);
 190         Project project = (Project) apiConnector.findById(Project.class, loadBalancer.getLoadBalancerTenantID());
 191         INeutronSubnetCRUD subnetInterface = NeutronCRUDInterfaces.getINeutronSubnetCRUD(this);
 192         NeutronSubnet subnet = subnetInterface.getSubnet(loadBalancer.getLoadBalancerVipSubnetID());
 193         String networkUUID = subnet.getNetworkUUID();
 194         VirtualNetwork virtualnetwork = (VirtualNetwork) apiConnector.findById(VirtualNetwork.class, networkUUID);
 195         VirtualMachineInterface vmi = new VirtualMachineInterface();
 196         vmi.setName(UUID.randomUUID().toString());
 197         vmi.setUuid(UUID.randomUUID().toString());
 198         vmi.setParent(project);
 199         vmi.setVirtualNetwork(virtualnetwork);
 200         boolean virtualMachineInterfaceCreated = apiConnector.create(vmi);
 201         if (!virtualMachineInterfaceCreated) {
 202             LOGGER.warn("actual virtualMachineInterface creation failed..");
 203         }
 204 //        /* setting vmi in LoadBalancer in OpenContrail */
 205 //        virtualLoadBalancer.setVirtualMachineInterface(vmi);
 206          String ips = loadBalancer.getLoadBalancerVipAddress();
 207          InstanceIp instanceIp = new InstanceIp();
 208          String instaneIpUuid = UUID.randomUUID().toString();
 209          instanceIp.setAddress(ips);
 210          instanceIp.setName(instaneIpUuid);
 211          instanceIp.setUuid(instaneIpUuid);
 212          instanceIp.setParent(vmi);
 213          instanceIp.setVirtualMachineInterface(vmi);
 214          instanceIp.setVirtualNetwork(virtualnetwork);
 215          boolean instanceIpCreated = apiConnector.create(instanceIp);
 216          if (!instanceIpCreated) {
 217          LOGGER.warn("instanceIp addition failed..");
 218          }
 219          LOGGER.info("Instance IP " + instanceIp.getAddress() +
 220          " added sucessfully...");
 221 //        boolean loadBalancerCreated;
 222         try {
 223 //            loadBalancerCreated = apiConnector.create(virtualLoadBalancer);
 224 //            LOGGER.debug("loadBalancer:   " + loadBalancerCreated);
 225 //            if (!loadBalancerCreated) {
 226 //                LOGGER.info("loadBalancer creation failed..");
 227 //            }
 228         } catch (Exception Ex) {
 229             LOGGER.error("Exception : " + Ex);
 230         }
 231     }
 232
 233     @Override
 234     public int canUpdateNeutronLoadBalancer(NeutronLoadBalancer delta, NeutronLoadBalancer original) {
 235         // TODO Auto-generated method stub
 236         return 0;
 237     }
 238
 239     @Override
 240     public void neutronLoadBalancerUpdated(NeutronLoadBalancer loadBalancer) {
 241         // TODO Auto-generated method stub
 242
 243     }
 244
 245     @Override
 246     public int canDeleteNeutronLoadBalancer(NeutronLoadBalancer loadBalancer) {
 247         // TODO Auto-generated method stub
 248         return 0;
 249     }
 250
 251     @Override
 252     public void neutronLoadBalancerDeleted(NeutronLoadBalancer loadBalancer) {
 253         // TODO Auto-generated method stub
 254
 255     }
 256     /**
 257      * Invoked to map the NeutronLoadBalancer object properties to the LoadBalancer
 258      * object.
 259      *
 260      * @param loadBalancer
 261      *            An instance of new NeutronLoadBalancer object.
 262      * @param virtualLoadBalancer
 263      *            An instance of new LoadBalancer object.
 264      * @return {@link LoadBalancer}
 265      */
 266 //    private LoadBalancer mapLoadBalancerProperties(NeutronLoadBalancer loadBalancer, LoadBalancer virtualLoadBalancer) {
 267 //        String loadBalancerID = loadBalancer.getLoadBalancerID();
 268 //        String loadBalancerName = loadBalancer.getLoadBalancerName();
 269 //        String projectUUID = loadBalancer.getLoadBalancerTenantID();
 270 //        try {
 271 //            if (!(loadBalancerID.contains("-"))) {
 272 //                loadBalancerID = Utils.uuidFormater(loadBalancerID);
 273 //            }
 274 //            loadBalancerID = UUID.fromString(loadBalancerID).toString();
 275 //            if (!(projectUUID.contains("-"))) {
 276 //                projectUUID = Utils.uuidFormater(projectUUID);
 277 //            }
 278 //            projectUUID = UUID.fromString(projectUUID).toString();
 279 //            Project project = (Project) apiConnector.findById(Project.class, projectUUID);
 280 //            virtualLoadBalancer.setParent(project);
 281 //        } catch (Exception ex) {
 282 //            LOGGER.error("UUID input incorrect", ex);
 283 //        }
 284 //        LoadBalancerType loadBalancerType = new LoadBalancerType();
 285 //        loadBalancerType.setAddress(loadBalancer.getLoadBalancerVipAddress());
 286 //        loadBalancerType.setAdminState(true);
 287 //        loadBalancerType.setSubnetId(loadBalancer.getLoadBalancerVipSubnetID());
 288 //        virtualLoadBalancer.setDisplayName(loadBalancerName);
 289 //        virtualLoadBalancer.setUuid(loadBalancerID);
 290 //        return virtualLoadBalancer;
 291 //    }
 292
 293     /**
 294      * Invoked to check if subnet exists from the Neutron Subnet object.
 295      *
 296      * @param ipamRefs
 297      *            An list of new ObjectReference<VnSubnetsType> objects.
 298      *
 299      * @param subnet
 300      *            An instance of new Neutron Subnet object.
 301      *
 302      * @return boolean
 303      */
 304     private boolean subnetExists(List<ObjectReference<VnSubnetsType>> ipamRefs, NeutronSubnet subnet) {
 305         if (ipamRefs != null) {
 306             for (ObjectReference<VnSubnetsType> ref : ipamRefs) {
 307                 VnSubnetsType vnSubnetsType = ref.getAttr();
 308                 if (vnSubnetsType != null) {
 309                     List<VnSubnetsType.IpamSubnetType> subnets = vnSubnetsType.getIpamSubnets();
 310                     if (subnets != null) {
 311                         for (VnSubnetsType.IpamSubnetType subnetValue : subnets) {
 312                             String[] ipPrefix = getIpPrefix(subnet);
 313                             Boolean doesSubnetExist = subnetValue.getSubnet().getIpPrefix().matches(ipPrefix[0]);
 314                             if (doesSubnetExist) {
 315                                 return doesSubnetExist;
 316                             }
 317                         }
 318                     }
 319                 }
 320             }
 321         }
 322         return false;
 323     }
 324
 325     /**
 326      * Invoked to get the IP Prefix from the Neutron Subnet object.
 327      *
 328      * @param subnet
 329      *            An instance of new Neutron Subnet object.
 330      *
 331      * @return IP Prefix
 332      * @throws Exception
 333      */
 334     String[] getIpPrefix(NeutronSubnet subnet) {
 335         String[] ipPrefix = null;
 336         String cidr = subnet.getCidr();
 337         if (cidr.contains("/")) {
 338             ipPrefix = cidr.split("/");
 339         } else {
 340             throw new IllegalArgumentException("String " + cidr + " not in correct format..");
 341         }
 342         return ipPrefix;
 343     }
 344 }