public ArrayList<FloatingIP> listFloatingIp() throws RegionException, NeutronException {

    Optional<? extends FloatingIPApi> floatingIPApiExtension =
        neutronApi.getFloatingIPApi(getRegionOne());

    if (floatingIPApiExtension.isPresent()) {
      FloatingIPApi floatingIPApi = floatingIPApiExtension.get();
      return Lists.newArrayList(floatingIPApi.list().concat());
    } else {
      throw new NeutronException("FloatingIp is not present");
    }
  }
  public FloatingIP createFloatingIP() throws RegionException, NeutronException {
    Optional<? extends FloatingIPApi> floatingIPApiExtension =
        neutronApi.getFloatingIPApi(getRegionOne());

    if (floatingIPApiExtension.isPresent()) {
      FloatingIPApi floatingIPApi = floatingIPApiExtension.get();

      return floatingIPApi.create(
          CreateFloatingIP.createBuilder(
                  getNetworkIdByName(OpenstackConfiguration.EXTERNAL_NETWORK))
              .build());
    } else {
      throw new NeutronException("FloatingIp is not present");
    }
  }
 /**
  * Get all unassigned Floating IPs. To get all unassigned Floating IPs from a floating network use
  * {@link #getUnassignedFloatingIPsByNetworkUuid(String)}
  *
  * @return list of all the unassigned {@link FloatingIP} from all floating networks allocated to
  *     this tenant
  */
 private ArrayList<FloatingIP> getUnassignedFloatingIPs() {
   ArrayList<FloatingIP> availableFloatingIPs =
       Lists.newArrayList(
           Iterables.filter(
               floatingIPApi.list().concat().toList(),
               new Predicate<FloatingIP>() {
                 @Override
                 public boolean apply(FloatingIP arg0) {
                   return arg0.getPortId() == null;
                 }
               }));
   return availableFloatingIPs;
 }
  /**
   * Create a new Floating IP from the given floating network and assign it to the given port
   *
   * @param port the port to which a Floating IP to be assigned
   * @param floatingNetworkUuid the network uuid of the floating network from which the Floating IP
   *     should be created
   * @return the newly created/assigned {@link FloatingIP}
   */
  private FloatingIP createAndAssignFloatingIP(Port port, String floatingNetworkUuid) {

    assertNotNull(port, "Cannot create floating IP. Invalid port. Port cannot be null");
    assertNotNullAndNotEmpty(
        floatingNetworkUuid,
        "Cannot create floating IP. Invalid floating network uuid. "
            + "Floating network uuid cannot be null");

    if (log.isDebugEnabled()) {
      String msg =
          String.format(
              "Trying to create a floating IP from network %s to assign to the port %s",
              floatingNetworkUuid, port.getId());
      log.debug(msg);
    }

    FloatingIP.CreateFloatingIP createFip;
    try {
      createFip = FloatingIP.createBuilder(floatingNetworkUuid).portId(port.getId()).build();
    } catch (Exception e) {
      String msg =
          String.format(
              "Error while getting floating IP builder for the external network %s and port %s",
              floatingNetworkUuid, port.toString());
      log.error(msg, e);
      throw new CloudControllerException(msg, e);
    }

    FloatingIP floatingIP = null;
    try {
      floatingIP = floatingIPApi.create(createFip);
    } catch (Exception e) {
      String msg =
          String.format(
              "Error while creating floating IP for the port %s, from floating network %s",
              port.toString(), floatingNetworkUuid);
      log.error(msg, e);
      throw new CloudControllerException(msg, e);
    }

    String msg =
        String.format("Unable to create a floating IP from network %s", floatingNetworkUuid);
    assertNotNull(floatingIP, msg);

    return floatingIP;
  }
  /**
   * Assign the given Floating IP to the given port.
   *
   * @param floatingIP the Floating IP to be assigned
   * @param portTobeAssigned the port to which the given Floating IP to be assigned
   * @return the updated {@link FloatingIP}
   */
  private FloatingIP updateFloatingIP(FloatingIP floatingIP, Port portTobeAssigned) {

    assertNotNull(floatingIP, "Cannot update floating IP. Given floating IP is null");
    String portNotNullMsg =
        String.format(
            "Cannot update floating IP %s. Given port is null", floatingIP.getFloatingIpAddress());
    assertNotNull(portTobeAssigned, portNotNullMsg);

    FloatingIP updatedFloatingIP = null;
    if (log.isDebugEnabled()) {
      String msg =
          String.format(
              "Trying to assign existing floating IP %s to the port %s",
              floatingIP.getFloatingIpAddress(), portTobeAssigned.getId());
      log.debug(msg);
    }

    try {
      updatedFloatingIP =
          floatingIPApi.update(
              floatingIP.getId(),
              FloatingIP.UpdateFloatingIP.updateBuilder()
                  .portId(portTobeAssigned.getId())
                  .fixedIpAddress(portTobeAssigned.getFixedIps().iterator().next().getIpAddress())
                  .build());
    } catch (Exception e) {
      String msg =
          String.format(
              "Error while trying to assign existing floating IP %s to the port %s",
              floatingIP.toString(), portTobeAssigned.toString());
      log.error(msg, e);
      throw new CloudControllerException(msg, e);
    }

    String updatedFloatingIPNullMessage =
        String.format(
            "Unable to assign existing floating IP %s " + "to the port %s",
            floatingIP.toString(), portTobeAssigned.toString());
    assertNotNull(updatedFloatingIP, updatedFloatingIPNullMessage);

    if (log.isDebugEnabled()) {
      String msg = String.format("Successfully updated the floating IP %s", floatingIP.toString());
      log.debug(msg);
    }
    return updatedFloatingIP;
  }
 /**
  * Get all unassigned Floating IPs from the given floating network. To get all unassigned Floating
  * IPs from all floating networks use {@link #getUnassignedFloatingIPs()}
  *
  * @param networkUuid the network uuid of the floating network
  * @return list of all unassigned {@link FloatingIP} from the given floating network
  */
 private ArrayList<FloatingIP> getUnassignedFloatingIPsByNetworkUuid(final String networkUuid) {
   if (networkUuid == null || networkUuid.isEmpty()) {
     return null;
   }
   ArrayList<FloatingIP> availableFloatingIPs =
       Lists.newArrayList(
           Iterables.filter(
               floatingIPApi.list().concat().toList(),
               new Predicate<FloatingIP>() {
                 @Override
                 public boolean apply(FloatingIP arg0) {
                   return arg0.getPortId() == null
                       && arg0.getFloatingNetworkId() != null
                       && arg0.getFloatingNetworkId().equals(networkUuid);
                 }
               }));
   return availableFloatingIPs;
 }
  /**
   * Get the {@link FloatingIP} by its Floating IP Address
   *
   * @param floatingIPAddress the Floating IP Address (a.k.a public IP address)
   * @return the {@link FloatingIP} if found, null otherwise
   */
  private FloatingIP getFloatingIPByIPAddress(final String floatingIPAddress) {
    if (!isValidIP(floatingIPAddress)) {
      return null;
    }

    Iterable<FloatingIP> floatingIP =
        Iterables.filter(
            floatingIPApi.list().concat().toList(),
            new Predicate<FloatingIP>() {
              @Override
              public boolean apply(FloatingIP input) {
                return input.getFloatingIpAddress() != null
                    && input.getFloatingIpAddress().equals(floatingIPAddress);
              }
            });
    if (floatingIP.iterator().hasNext()) {
      return floatingIP.iterator().next();
    }
    return null;
  }
  @Override
  public void releaseAddress(String ip) {

    String iPNotValidMsg = String.format("Unable to release the IP. The given IP is not valid", ip);
    assertValidIP(ip, iPNotValidMsg);

    if (null == neutronApi || null == portApi || null == floatingIPApi) {
      buildNeutronApi();
    }

    if (log.isDebugEnabled()) {
      String msg = String.format("Trying delete the floating IP %s", ip);
      log.debug(msg);
    }

    FloatingIP floatingIP = getFloatingIPByIPAddress(ip);
    if (null == floatingIP) {
      if (log.isDebugEnabled()) {
        String msg =
            String.format(
                "Floating IP %s is not found. "
                    + "It might be already deleted, if instance is already terminated",
                ip);
        log.debug(msg);
      }
      return;
    }

    boolean deleted = floatingIPApi.delete(floatingIP.getId());
    if (deleted) {
      if (log.isDebugEnabled()) {
        String msg = String.format("Successfully deleted the floating IP %s", ip);
        log.debug(msg);
      }
    } else {
      String msg = String.format("Couldn't release the floating IP %s", ip);
      log.error(msg);
      throw new CloudControllerException(msg);
    }
  }