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

   1 package org.opendaylight.plugin2oc.neutron;
   2
   3 import java.util.List;
   4 import java.io.IOException;
   5 import java.net.HttpURLConnection;
   6 import java.util.UUID;
   7
   8 import net.juniper.contrail.api.ApiConnector;
   9 import net.juniper.contrail.api.ApiPropertyBase;
  10 import net.juniper.contrail.api.ObjectReference;
  11 import net.juniper.contrail.api.types.InstanceIp;
  12 import net.juniper.contrail.api.types.LoadbalancerMember;
  13 import net.juniper.contrail.api.types.LoadbalancerMemberType;
  14 import net.juniper.contrail.api.types.LoadbalancerPool;
  15 import net.juniper.contrail.api.types.Project;
  16 import net.juniper.contrail.api.types.VirtualMachineInterface;
  17
  18 import org.opendaylight.controller.networkconfig.neutron.INeutronLoadBalancerPoolMemberAware;
  19 import org.opendaylight.controller.networkconfig.neutron.NeutronLoadBalancerPoolMember;
  20 import org.slf4j.Logger;
  21 import org.slf4j.LoggerFactory;
  22
  23 /**
  24  * Handle requests for Neutron LoadbalancerPoolMember.
  25  */
  26
  27 public class LoadBalancerPoolMemberHandler implements INeutronLoadBalancerPoolMemberAware {
  28     /**
  29      * Logger instance.
  30      */
  31     static final Logger LOGGER = LoggerFactory.getLogger(LoadBalancerPoolMemberHandler.class);
  32     static ApiConnector apiConnector;
  33
  34     /**
  35      * Invoked when a member creation is requested to check if the specified
  36      * member can be created and then creates the member
  37      *
  38      * @param loadBalancerPoolMember
  39      *            An instance of proposed new NeutronLoadBalancerPoolMember object.
  40      *
  41      * @return A HTTP status code to the creation request.
  42      */
  43     @Override
  44     public int canCreateNeutronLoadBalancerPoolMember(NeutronLoadBalancerPoolMember loadBalancerPoolMember) {
  45         if (loadBalancerPoolMember == null) {
  46             LOGGER.error("LoadBalancerPool Member object can't be null..");
  47             return HttpURLConnection.HTTP_BAD_REQUEST;
  48         }
  49         apiConnector = Activator.apiConnector;
  50         if (loadBalancerPoolMember.getPoolMemberTenantID() == null
  51                 || loadBalancerPoolMember.getPoolMemberSubnetID() == null) {
  52             LOGGER.error("LoadBalancerPool Member TenanID/SubnetID can not be null");
  53             return HttpURLConnection.HTTP_BAD_REQUEST;
  54         }
  55         try {
  56             String loadBalancerPoolID = loadBalancerPoolMember.getPoolID();
  57             String loadBalancerPoolMemberUUID = loadBalancerPoolMember.getPoolMemberID();
  58             String projectUUID = loadBalancerPoolMember.getPoolMemberTenantID();
  59             try {
  60                 if (!(loadBalancerPoolMemberUUID.contains("-"))) {
  61                     loadBalancerPoolMemberUUID = Utils.uuidFormater(loadBalancerPoolMemberUUID);
  62                 }
  63                 if (!(projectUUID.contains("-"))) {
  64                     projectUUID = Utils.uuidFormater(projectUUID);
  65                 }
  66                 boolean isValidLoadBalancerPoolMemberUUID = Utils.isValidHexNumber(loadBalancerPoolMemberUUID);
  67                 boolean isValidprojectUUID = Utils.isValidHexNumber(projectUUID);
  68                 if (!isValidLoadBalancerPoolMemberUUID || !isValidprojectUUID) {
  69                     LOGGER.info("Badly formed Hexadecimal UUID...");
  70                     return HttpURLConnection.HTTP_BAD_REQUEST;
  71                 }
  72                 projectUUID = UUID.fromString(projectUUID).toString();
  73                 loadBalancerPoolMemberUUID = UUID.fromString(loadBalancerPoolMemberUUID).toString();
  74                 if (!(loadBalancerPoolID.contains("-"))) {
  75                     loadBalancerPoolID = Utils.uuidFormater(loadBalancerPoolID);
  76                 }
  77                 loadBalancerPoolID = UUID.fromString(loadBalancerPoolID).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             if (project.getVirtualMachineInterfaces() != null) {
  98                 List<ObjectReference<ApiPropertyBase>> vmiList = project.getVirtualMachineInterfaces();
  99                 for (ObjectReference<ApiPropertyBase> ref : vmiList) {
 100                     String vmiUUID = ref.getUuid();
 101                     VirtualMachineInterface vmi = (VirtualMachineInterface) apiConnector.findById(
 102                             VirtualMachineInterface.class, vmiUUID);
 103                     List<ObjectReference<ApiPropertyBase>> iip = vmi.getInstanceIpBackRefs();
 104                     for (ObjectReference<ApiPropertyBase> iipRef : iip) {
 105                         String iipUUID = iipRef.getUuid();
 106                         InstanceIp instanceIP = (InstanceIp) apiConnector.findById(InstanceIp.class, iipUUID);
 107                         if (!(loadBalancerPoolMember.getPoolMemberAddress().equals(instanceIP.getAddress()))) {
 108                             LOGGER.warn("LoadbalancerPool Member address does not exists...");
 109                             return HttpURLConnection.HTTP_FORBIDDEN;
 110                         }
 111                     }
 112                 }
 113             } else {
 114                 LOGGER.warn("No Servers available to create a member...");
 115                 return HttpURLConnection.HTTP_FORBIDDEN;
 116             }
 117             LoadbalancerMember virtualLoadbalancerPoolMemberById = (LoadbalancerMember) apiConnector.findById(
 118                     LoadbalancerMember.class, loadBalancerPoolMemberUUID);
 119             if (virtualLoadbalancerPoolMemberById != null) {
 120                 LOGGER.warn("LoadbalancerPool Member already exists with UUID" + loadBalancerPoolMemberUUID);
 121                 return HttpURLConnection.HTTP_FORBIDDEN;
 122             }
 123             LoadbalancerPool virtualLoadbalancerPool = (LoadbalancerPool) apiConnector.findById(LoadbalancerPool.class,
 124                     loadBalancerPoolID);
 125             if (virtualLoadbalancerPool == null) {
 126                 LOGGER.warn("LoadbalancerPool does not exist" + loadBalancerPoolID);
 127                 return HttpURLConnection.HTTP_FORBIDDEN;
 128             }
 129             if (!(loadBalancerPoolMember.getPoolMemberTenantID().equals(virtualLoadbalancerPool.getParentUuid()))) {
 130                 LOGGER.warn("Member with UUID: " + loadBalancerPoolID + "and Pool with UUID: " + loadBalancerPoolID
 131                         + " does not belong to same tenant");
 132                 return HttpURLConnection.HTTP_FORBIDDEN;
 133             }
 134             return HttpURLConnection.HTTP_OK;
 135         } catch (IOException ie) {
 136             LOGGER.error("IOException :   " + ie);
 137             return HttpURLConnection.HTTP_INTERNAL_ERROR;
 138         } catch (Exception e) {
 139             LOGGER.error("Exception :   " + e);
 140             return HttpURLConnection.HTTP_INTERNAL_ERROR;
 141         }
 142
 143     }
 144
 145     /**
 146      * Invoked to take action after a member has been created.
 147      *
 148      * @param loadBalancerPoolMember
 149      *            An instance of new NeutronLoadBalancerPoolMember object.
 150      */
 151     @Override
 152     public void neutronLoadBalancerPoolMemberCreated(NeutronLoadBalancerPoolMember loadBalancerPoolMember) {
 153         try {
 154             createLoadBalancerMember(loadBalancerPoolMember);
 155         } catch (IOException ex) {
 156             LOGGER.warn("Exception  :    " + ex);
 157         }
 158         LoadbalancerMember loadbalancerMember = null;
 159         try {
 160             String loadBalancerPoolMemberUUID = loadBalancerPoolMember.getPoolMemberID();
 161             if (!(loadBalancerPoolMemberUUID.contains("-"))) {
 162                 loadBalancerPoolMemberUUID = Utils.uuidFormater(loadBalancerPoolMemberUUID);
 163             }
 164             loadBalancerPoolMemberUUID = UUID.fromString(loadBalancerPoolMemberUUID).toString();
 165             loadbalancerMember = (LoadbalancerMember) apiConnector.findById(LoadbalancerMember.class,
 166                     loadBalancerPoolMemberUUID);
 167             if (loadbalancerMember != null) {
 168                 LOGGER.info("LoadbalancerPool Member creation verified for Member with UUID--"
 169                         + loadBalancerPoolMemberUUID);
 170             }
 171         } catch (Exception e) {
 172             LOGGER.error("Exception :     " + e);
 173         }
 174
 175     }
 176
 177     /**
 178      * Invoked to create the specified Neutron Member.
 179      *
 180      * @param loadBalancerPoolMember
 181      *            An instance of new NeutronLoadBalancerPoolMember object.
 182      */
 183     private void createLoadBalancerMember(NeutronLoadBalancerPoolMember loadBalancerPoolMember) throws IOException {
 184         LoadbalancerMember virtualLoadBalancerMember = new LoadbalancerMember();
 185         virtualLoadBalancerMember = mapLoadBalancerMemberProperties(loadBalancerPoolMember, virtualLoadBalancerMember);
 186         boolean loadBalancerMemberCreated;
 187         try {
 188             loadBalancerMemberCreated = apiConnector.create(virtualLoadBalancerMember);
 189             LOGGER.debug("loadBalancerPool member:   " + loadBalancerMemberCreated);
 190             if (!loadBalancerMemberCreated) {
 191                 LOGGER.info("loadBalancerPool member creation failed..");
 192             }
 193         } catch (Exception Ex) {
 194             LOGGER.error("Exception : " + Ex);
 195         }
 196         LOGGER.info("Member having UUID " + loadBalancerPoolMember.getPoolMemberID() + " sucessfully created");
 197     }
 198
 199     @Override
 200     public int canUpdateNeutronLoadBalancerPoolMember(NeutronLoadBalancerPoolMember delta,
 201             NeutronLoadBalancerPoolMember original) {
 202         // TODO Auto-generated method stub
 203         return 0;
 204     }
 205
 206     @Override
 207     public void neutronLoadBalancerPoolMemberUpdated(NeutronLoadBalancerPoolMember loadBalancerPoolMember) {
 208         // TODO Auto-generated method stub
 209
 210     }
 211
 212     /**
 213      * Invoked when a member deletion is requested to indicate if the specified
 214      * member can be deleted.
 215      *
 216      * @param loadBalancerPoolMember
 217      *            An instance of the NeutronLoadBalancerPoolMember object to be deleted.
 218      * @return A HTTP status code to the deletion request.
 219      */
 220     @Override
 221     public int canDeleteNeutronLoadBalancerPoolMember(NeutronLoadBalancerPoolMember loadBalancerPoolMember) {
 222         apiConnector = Activator.apiConnector;
 223         LoadbalancerMember virtualLoadBalancerMember = null;
 224         String loadBalancerMemberUUID = loadBalancerPoolMember.getPoolMemberID();
 225         try {
 226             if (!(loadBalancerMemberUUID.contains("-"))) {
 227                 loadBalancerMemberUUID = Utils.uuidFormater(loadBalancerMemberUUID);
 228             }
 229             loadBalancerMemberUUID = UUID.fromString(loadBalancerMemberUUID).toString();
 230         } catch (Exception ex) {
 231             LOGGER.error("UUID input incorrect", ex);
 232             return HttpURLConnection.HTTP_BAD_REQUEST;
 233         }
 234         try {
 235             virtualLoadBalancerMember = (LoadbalancerMember) apiConnector.findById(LoadbalancerMember.class,
 236                     loadBalancerMemberUUID);
 237             if (virtualLoadBalancerMember == null) {
 238                 LOGGER.info("No LoadbalancerPoolMember exists with ID :  " + loadBalancerMemberUUID);
 239                 return HttpURLConnection.HTTP_BAD_REQUEST;
 240             }
 241             return HttpURLConnection.HTTP_OK;
 242         } catch (Exception e) {
 243             LOGGER.error("Exception : " + e);
 244             return HttpURLConnection.HTTP_INTERNAL_ERROR;
 245         }
 246     }
 247
 248     /**
 249      * Invoked to take action after a member has been deleted.
 250      *
 251      * @param loadBalancerPoolMember
 252      *            An instance of deleted NeutronLoadBalancerPoolMember object.
 253      */
 254     @Override
 255     public void neutronLoadBalancerPoolMemberDeleted(NeutronLoadBalancerPoolMember loadBalancerPoolMember) {
 256         LoadbalancerMember virtualLoadBalancerMember = null;
 257         try {
 258             String loadBalancerMemberUUID = loadBalancerPoolMember.getPoolMemberID();
 259             if (!(loadBalancerMemberUUID.contains("-"))) {
 260                 loadBalancerMemberUUID = Utils.uuidFormater(loadBalancerMemberUUID);
 261             }
 262             loadBalancerMemberUUID = UUID.fromString(loadBalancerMemberUUID).toString();
 263             virtualLoadBalancerMember = (LoadbalancerMember) apiConnector.findById(LoadbalancerMember.class,
 264                     loadBalancerMemberUUID);
 265             apiConnector.delete(virtualLoadBalancerMember);
 266             if (virtualLoadBalancerMember == null) {
 267                 LOGGER.info("LoadbalancerPoolMember deletion verified....");
 268             } else {
 269                 LOGGER.info("LoadbalancerPoolMember with ID :  " + loadBalancerMemberUUID + "deletion failed");
 270             }
 271         } catch (Exception ex) {
 272             LOGGER.error("Exception :   " + ex);
 273         }
 274     }
 275
 276     /**
 277      * Invoked to map the NeutronLoadBalancerPoolMember object properties to the loadBalancerPoolMember
 278      * object.
 279      *
 280      * @param loadBalancerPoolMember
 281      *            An instance of new NeutronLoadBalancerPoolMember object.
 282      * @param virtualLoadBalancerMember
 283      *            An instance of new LoadbalancerMember object.
 284      * @return {@link LoadbalancerMember}
 285      */
 286     private LoadbalancerMember mapLoadBalancerMemberProperties(NeutronLoadBalancerPoolMember loadBalancerPoolMember,
 287             LoadbalancerMember virtualLoadBalancerMember) {
 288         String loadBalancerMemberUUID = loadBalancerPoolMember.getPoolMemberID();
 289         try {
 290             if (!(loadBalancerMemberUUID.contains("-"))) {
 291                 loadBalancerMemberUUID = Utils.uuidFormater(loadBalancerMemberUUID);
 292             }
 293             loadBalancerMemberUUID = UUID.fromString(loadBalancerMemberUUID).toString();
 294             LoadbalancerPool lbp = (LoadbalancerPool) apiConnector.findById(LoadbalancerPool.class,
 295                     loadBalancerPoolMember.getPoolID());
 296             virtualLoadBalancerMember.setParent(lbp);
 297         } catch (Exception ex) {
 298             LOGGER.error("UUID input incorrect", ex);
 299         }
 300         LoadbalancerMemberType lbmType = new LoadbalancerMemberType();
 301         lbmType.setAddress(loadBalancerPoolMember.getPoolMemberAddress());
 302         lbmType.setProtocolPort(loadBalancerPoolMember.getPoolMemberProtoPort());
 303         if (loadBalancerPoolMember.getPoolMemberStatus() != null) {
 304             lbmType.setStatus(loadBalancerPoolMember.getPoolMemberStatus());
 305         }
 306         if (loadBalancerPoolMember.getPoolMemberWeight() != null) {
 307             lbmType.setWeight(loadBalancerPoolMember.getPoolMemberWeight());
 308         }
 309         if (loadBalancerPoolMember.getPoolMemberAdminStateIsUp() != null) {
 310             lbmType.setAdminState(loadBalancerPoolMember.getPoolMemberAdminStateIsUp());
 311         } else {
 312             lbmType.setAdminState(true);
 313         }
 314         virtualLoadBalancerMember.setProperties(lbmType);
 315         virtualLoadBalancerMember.setUuid(loadBalancerMemberUUID);
 316         virtualLoadBalancerMember.setName(loadBalancerMemberUUID);
 317         virtualLoadBalancerMember.setDisplayName(loadBalancerMemberUUID);
 318         return virtualLoadBalancerMember;
 319     }
 320
 321 }