Java VirtualDeploymentUnit.getVimInstanceName方法代码示例

import org.openbaton.catalogue.mano.descriptor.VirtualDeploymentUnit; //导入方法依赖的package包/类
private Set<String> getRuntimeDeploymentInfo(DeployNSRBody body, VirtualDeploymentUnit vdu)
    throws MissingParameterException {
  Set<String> instanceNames;

  if (body == null
      || body.getVduVimInstances() == null
      || body.getVduVimInstances().get(vdu.getName()) == null
      || body.getVduVimInstances().get(vdu.getName()).isEmpty()) {
    if (vdu.getVimInstanceName() == null) {
      throw new MissingParameterException(
          "No VimInstance specified for vdu with name: " + vdu.getName());
    }
    instanceNames = vdu.getVimInstanceName();
  } else {
    instanceNames = body.getVduVimInstances().get(vdu.getName());
  }
  return instanceNames;
}
 

import org.openbaton.catalogue.mano.descriptor.VirtualDeploymentUnit; //导入方法依赖的package包/类
public void fetchVimInstances(VirtualNetworkFunctionDescriptor vnfd, String projectId)
    throws NotFoundException {
  Iterable<BaseVimInstance> vimInstances = vimRepository.findByProjectId(projectId);
  if (!vimInstances.iterator().hasNext()) {
    throw new NotFoundException("No VimInstances in the Database");
  }
  for (VirtualDeploymentUnit vdu : vnfd.getVdu()) {
    if (vdu.getVimInstanceName() != null) {
      for (String name : vdu.getVimInstanceName()) {
        String vimName;
        if (name.contains(":")) {
          vimName = name.split(":")[0];
        } else {
          vimName = name;
        }
        log.debug("vim instance name=" + vimName);
        boolean fetched = false;
        for (BaseVimInstance vimInstance : vimInstances) {
          if ((vimInstance.getName() != null && vimInstance.getName().equals(vimName))) {
            log.info("Found vimInstance: " + vimInstance.getName());
            fetched = true;
            break;
          }
        }
        if (!fetched) {
          throw new NotFoundException(
              "Not found VimInstance with name " + vimName + " in the catalogue");
        }
      }
    } else {
      log.info(
          "No vimInstances are defined in the vdu "
              + vdu.getName()
              + ". Remember to define during the NSR onboarding.");
    }
  }
}
 

import org.openbaton.catalogue.mano.descriptor.VirtualDeploymentUnit; //导入方法依赖的package包/类
private void checkIntegrity(
    VirtualNetworkFunctionDescriptor virtualNetworkFunctionDescriptor,
    Set<VirtualLinkDescriptor> virtualLinkDescriptors)
    throws NetworkServiceIntegrityException {

  if (virtualNetworkFunctionDescriptor.getName() == null
      || virtualNetworkFunctionDescriptor.getName().isEmpty()) {
    throw new NetworkServiceIntegrityException("The VNFD has to have a name.");
  }

  if (virtualNetworkFunctionDescriptor.getType() == null
      || virtualNetworkFunctionDescriptor.getType().isEmpty()) {
    throw new NetworkServiceIntegrityException(
        "The VNFD " + virtualNetworkFunctionDescriptor.getName() + " misses a VNFD type.");
  }

  if (virtualNetworkFunctionDescriptor.getEndpoint() == null
      || virtualNetworkFunctionDescriptor.getEndpoint().isEmpty()) {
    throw new NetworkServiceIntegrityException(
        "No endpoint found in VNFD " + virtualNetworkFunctionDescriptor.getName());
  }
  if (virtualNetworkFunctionDescriptor.getVdu() == null
      || virtualNetworkFunctionDescriptor.getVdu().size() == 0) {
    throw new NetworkServiceIntegrityException(
        "No VDU defined in VNFD " + virtualNetworkFunctionDescriptor.getName());
  }

  checkIntegrityVDU(virtualNetworkFunctionDescriptor);

  checkIntegrityVirtualLinks(virtualNetworkFunctionDescriptor, virtualLinkDescriptors);

  checkIntegrityLifecycleEvents(virtualNetworkFunctionDescriptor);

  checkIntegrityVNFPackage(virtualNetworkFunctionDescriptor);

  if (virtualNetworkFunctionDescriptor.getVdu() != null) {
    for (VirtualDeploymentUnit virtualDeploymentUnit :
        virtualNetworkFunctionDescriptor.getVdu()) {
      if (inAllVims.equals("in-all-vims")) {
        if (virtualDeploymentUnit.getVimInstanceName() != null
            && !virtualDeploymentUnit.getVimInstanceName().isEmpty()) {
          for (String vimName : virtualDeploymentUnit.getVimInstanceName()) {
            BaseVimInstance vimInstance =
                checkIntegrityVimInstance(
                    virtualNetworkFunctionDescriptor, virtualDeploymentUnit, vimName);

            checkIntegrityScaleInOut(virtualNetworkFunctionDescriptor, virtualDeploymentUnit);

            checkFlavourIntegrity(virtualNetworkFunctionDescriptor, vimInstance);

            checkIntegrityImages(
                virtualNetworkFunctionDescriptor, virtualDeploymentUnit, vimInstance);
          }
        } else {
          log.warn(
              "Impossible to complete Integrity check because of missing VimInstances definition");
        }
      } else {
        log.error("" + inAllVims + " not yet implemented!");
        throw new UnsupportedOperationException("" + inAllVims + " not yet implemented!");
      }
    }
  } else {
    virtualNetworkFunctionDescriptor.setVdu(new HashSet<>());
  }
}
 

import org.openbaton.catalogue.mano.descriptor.VirtualDeploymentUnit; //导入方法依赖的package包/类
@Override
public Map<String, BaseVimInstance> grantLifecycleOperation(
    VirtualNetworkFunctionRecord virtualNetworkFunctionRecord)
    throws VimException, PluginException {
  Map<String, BaseVimInstance> result = new HashMap<>();

  //HashMap holds how many VNFCInstances are needed to deploy on a specific VimInstance
  HashMap<BaseVimInstance, Integer> countVDUsOnVimInstances = new HashMap<>();

  //Find how many VNFCInstances are needed to deploy on a specific VimInstance
  log.info("Granting Lifecycle Operation for vnfr: " + virtualNetworkFunctionRecord.getName());
  for (VirtualDeploymentUnit vdu : virtualNetworkFunctionRecord.getVdu()) {
    for (String vimName : vdu.getVimInstanceName()) {

      BaseVimInstance vimInstance =
          vimInstanceRepository.findByProjectIdAndName(vdu.getProjectId(), vimName);

      if (countVDUsOnVimInstances.containsKey(vimInstance)) {
        countVDUsOnVimInstances.put(
            vimInstance,
            countVDUsOnVimInstances.get(vimInstance)
                + vdu.getVnfc().size()
                - vdu.getVnfc_instance().size());
      } else {
        log.debug(
            "VimInstance: "
                + vdu.getVimInstanceName()
                + "\n VNFC: "
                + vdu.getVnfc()
                + "\nVNFCINST: "
                + vdu.getVnfc_instance());
        countVDUsOnVimInstances.put(
            vimInstance, vdu.getVnfc().size() - vdu.getVnfc_instance().size());
      }
    }
  }

  //Check if enough resources are available for the deployment
  log.debug("Checking if enough resources are available on the defined VimInstance.");
  for (VirtualDeploymentUnit virtualDeploymentUnit : virtualNetworkFunctionRecord.getVdu()) {
    BaseVimInstance vimInstanceChosen =
        pickVimInstance(
            virtualDeploymentUnit.getVimInstanceName(),
            countVDUsOnVimInstances,
            virtualNetworkFunctionRecord);
    if (vimInstanceChosen != null) {
      log.info(
          "Enough resources are available for deploying VDU in vimInstance: "
              + vimInstanceChosen.getName());
      result.put(virtualDeploymentUnit.getId(), vimInstanceChosen);
    }
  }

  return result;
}