@Override
 public String toString() {
   return String.format(
       "%s, force=%s, checkConnectivity=%s, conectivityTimeout=%s,\n\tnetworks=%s,\n\tbonds=%s,\n\tinterfaces=%s,\n\tremovedNetworks=%s,\n\tremovedBonds=%s",
       super.toString(),
       isForce(),
       isCheckConnectivity(),
       getConectivityTimeout(),
       Entities.collectionToString(getNetworks(), "\t\t"),
       Entities.collectionToString(getBonds(), "\t\t"),
       Entities.collectionToString(getInterfaces(), "\t\t"),
       getRemovedNetworks(),
       getRemovedBonds());
 }
Esempio n. 2
0
  private Set<String> getClusterNetworksNames() {
    if (cachedClusterNetworksNames == null) {
      cachedClusterNetworksNames = Entities.objectNames(getClusterNetworks());
    }

    return cachedClusterNetworksNames;
  }
Esempio n. 3
0
  private Set<String> getInterfaceNetworkNames() {
    if (cachedInterfaceNetworkNames == null) {
      cachedInterfaceNetworkNames = Entities.vmInterfacesByNetworkName(vm.getInterfaces()).keySet();
    }

    return cachedInterfaceNetworkNames;
  }
  /**
   * Filter out LUNs that are already a part of storage domains exist in the system.
   *
   * @param luns the LUNs list
   * @return the filtered LUNs list
   */
  protected List<LUNs> filterLUNsThatBelongToExistingStorageDomains(List<LUNs> luns) {
    List<StorageDomain> existingStorageDomains = getStorageDomainDao().getAll();
    final List<Guid> existingStorageDomainIDs = Entities.getIds(existingStorageDomains);

    return luns.stream()
        .filter(lun -> !existingStorageDomainIDs.contains(lun.getStorageDomainId()))
        .collect(Collectors.toList());
  }
Esempio n. 5
0
  /**
   * Actually process the VM device update in DB.
   *
   * @param vm
   */
  private void processVmDevices(Map vm) {
    if (vm == null || vm.get(VdsProperties.vm_guid) == null) {
      log.error("Received NULL VM or VM id when processing VM devices, abort.");
      return;
    }

    Guid vmId = new Guid((String) vm.get(VdsProperties.vm_guid));
    Set<Guid> processedDevices = new HashSet<Guid>();
    List<VmDevice> devices = getDbFacade().getVmDeviceDao().getVmDeviceByVmId(vmId);
    Map<VmDeviceId, VmDevice> deviceMap = Entities.businessEntitiesById(devices);

    for (Object o : (Object[]) vm.get(VdsProperties.Devices)) {
      Map device = (Map<String, Object>) o;
      if (device.get(VdsProperties.Address) == null) {
        logDeviceInformation(vmId, device);
        continue;
      }

      Guid deviceId = getDeviceId(device);
      VmDevice vmDevice = deviceMap.get(new VmDeviceId(deviceId, vmId));
      String logicalName = null;
      if (deviceId != null
          && FeatureSupported.reportedDisksLogicalNames(
              getVdsManager().getGroupCompatibilityVersion())
          && VmDeviceType.DISK.getName().equals(device.get(VdsProperties.Device))) {
        try {
          logicalName =
              getDeviceLogicalName((Map<?, ?>) vm.get(VdsProperties.GuestDiskMapping), deviceId);
        } catch (Exception e) {
          log.error(
              "error while getting device name when processing, vm '{}', device info '{}' with exception, skipping '{}'",
              vmId,
              device,
              e.getMessage());
          log.error("Exception", e);
        }
      }

      if (deviceId == null || vmDevice == null) {
        deviceId = addNewVmDevice(vmId, device, logicalName);
      } else {
        vmDevice.setIsPlugged(Boolean.TRUE);
        vmDevice.setAddress(((Map<String, String>) device.get(VdsProperties.Address)).toString());
        vmDevice.setAlias(StringUtils.defaultString((String) device.get(VdsProperties.Alias)));
        vmDevice.setLogicalName(logicalName);
        addVmDeviceToList(vmDevice);
      }

      processedDevices.add(deviceId);
    }

    handleRemovedDevices(vmId, processedDevices, devices);
  }
  private void auditNetworkCompliance(
      VDS host, List<VdsNetworkInterface> dbIfaces, List<Network> clusterNetworks) {
    if (host.getStatus() == VDSStatus.Maintenance) {
      return;
    }

    final Map<String, Network> clusterNetworksByName = Entities.entitiesByName(clusterNetworks);
    final Collection<Network> dbHostNetworks =
        findNetworksOnInterfaces(dbIfaces, clusterNetworksByName);
    logChangedDisplayNetwork(host, dbHostNetworks, dbIfaces);
    logUnsynchronizedNetworks(host, clusterNetworksByName);
  }
  /**
   * Create StorageDomain objects according to the specified VG-IDs list.
   *
   * @param vgIDs the VG-IDs list
   * @return storage domains list
   */
  @SuppressWarnings("unchecked")
  protected List<StorageDomain> getStorageDomainsByVolumeGroupIds(List<String> vgIDs) {
    List<StorageDomain> storageDomains = new ArrayList<>();

    // Get existing PhysicalVolumes.
    List<String> existingLunIds = Entities.getIds(getLunDao().getAll());

    for (String vgID : vgIDs) {
      VDSReturnValue returnValue;
      try {
        returnValue =
            executeGetVGInfo(new GetVGInfoVDSCommandParameters(getParameters().getVdsId(), vgID));
      } catch (RuntimeException e) {
        log.error("Could not get info for VG ID: '{}': {}", vgID, e.getMessage());
        log.debug("Exception", e);
        continue;
      }

      ArrayList<LUNs> luns = (ArrayList<LUNs>) returnValue.getReturnValue();
      List<String> lunIdsOnStorage = Entities.getIds(luns);
      if (CollectionUtils.containsAny(lunIdsOnStorage, existingLunIds)) {
        log.info("There are existing luns in the system which are part of VG id '{}'", vgID);
        continue;
      }

      // Get storage domain ID by a representative LUN
      LUNs lun = luns.get(0);
      Guid storageDomainId = lun.getStorageDomainId();

      // Get storage domain using GetStorageDomainInfo
      StorageDomain storageDomain = getStorageDomainById(storageDomainId);
      if (storageDomain != null) {
        storageDomains.add(storageDomain);
      }
    }
    return storageDomains;
  }
  private String getVmNetworksImplementedAsBridgeless(VDS host, List<Network> clusterNetworks) {
    Map<String, VdsNetworkInterface> interfacesByNetworkName =
        Entities.hostInterfacesByNetworkName(host.getInterfaces());
    List<String> networkNames = new ArrayList<>();

    for (Network net : clusterNetworks) {
      if (net.isVmNetwork()
          && interfacesByNetworkName.containsKey(net.getName())
          && !interfacesByNetworkName.get(net.getName()).isBridged()) {
        networkNames.add(net.getName());
      }
    }

    return StringUtils.join(networkNames, ",");
  }
 @Override
 public PersistentHostSetupNetworksParameters buildParameters(
     Guid vdsId,
     List<Network> labeledNetworksToBeAdded,
     List<Network> labeledNetworksToBeRemoved,
     Map<String, VdsNetworkInterface> nicsByLabel) {
   final PersistentHostSetupNetworksParameters addSetupNetworksParameters =
       addNetworksByLabelParametersBuilder.buildParameters(
           vdsId, labeledNetworksToBeAdded, nicsByLabel);
   final PersistentHostSetupNetworksParameters removeSetupNetworksParameters =
       removeNetworksByLabelParametersBuilder.buildParameters(vdsId, labeledNetworksToBeRemoved);
   final PersistentHostSetupNetworksParameters combinedParams =
       combine(addSetupNetworksParameters, removeSetupNetworksParameters);
   final Collection<Network> affectedNetworks =
       concat(labeledNetworksToBeAdded, labeledNetworksToBeRemoved);
   combinedParams.setNetworkNames(StringUtils.join(Entities.objectNames(affectedNetworks), ", "));
   return combinedParams;
 }
  @Override
  protected void executeQueryCommand() {
    List<VmTemplate> vmTemplateList =
        getDbFacade().getVmTemplateDao().getAllForNetwork(getParameters().getId());
    List<VmNetworkInterface> vmNetworkInterfaceList =
        getDbFacade()
            .getVmNetworkInterfaceDao()
            .getAllForTemplatesByNetwork(getParameters().getId());

    final Map<Guid, VmTemplate> vmTemplatesById = Entities.businessEntitiesById(vmTemplateList);

    List<PairQueryable<VmNetworkInterface, VmTemplate>> vmInterfaceVmPairs =
        new ArrayList<PairQueryable<VmNetworkInterface, VmTemplate>>();
    for (VmNetworkInterface vmNetworkInterface : vmNetworkInterfaceList) {
      vmInterfaceVmPairs.add(
          new PairQueryable<VmNetworkInterface, VmTemplate>(
              vmNetworkInterface, vmTemplatesById.get(vmNetworkInterface.getVmTemplateId())));
    }

    getQueryReturnValue().setReturnValue(vmInterfaceVmPairs);
  }
  @Override
  protected void executeCommand() {
    String address = getParameters().getAddress();
    String subnet =
        StringUtils.isEmpty(getParameters().getSubnet())
            ? getParameters().getNetwork().getSubnet()
            : getParameters().getSubnet();
    String gateway =
        StringUtils.isEmpty(getParameters().getGateway()) ? "" : getParameters().getGateway();
    ArrayList<String> interfaceNames = new ArrayList<>();

    Map<String, VdsNetworkInterface> interfaceByName = Entities.entitiesByName(interfaces);
    for (VdsNetworkInterface i : getParameters().getInterfaces()) {
      VdsNetworkInterface existingIface = interfaceByName.get(i.getName());
      if (Boolean.TRUE.equals(existingIface.getBonded())
          || NetworkUtils.isBondVlan(interfaces, existingIface)) {
        getParameters().setBondName(NetworkUtils.stripVlan(existingIface));
        for (VdsNetworkInterface ix : interfaces) {
          if (NetworkUtils.interfaceBasedOn(existingIface, ix.getBondName())) {
            interfaceNames.add(NetworkUtils.stripVlan(ix));
          }
        }
      } else {
        interfaceNames.add(NetworkUtils.stripVlan(existingIface));
      }
    }

    // updating a vlan over bond if the bond was not provided the bond device should preserve the
    // bonding options
    String bondingOptions = null;
    if (getParameters().getBondingOptions() == null
        && getParameters().getBondName() != null
        && !Entities.entitiesByName(getParameters().getInterfaces())
            .containsKey(getParameters().getBondName())) {
      VdsNetworkInterface bond =
          Entities.entitiesByName(interfaces).get(getParameters().getBondName());
      bondingOptions = bond == null ? null : bond.getBondOptions();
    } else {
      bondingOptions = getParameters().getBondingOptions();
    }

    NetworkVdsmVDSCommandParameters parameters =
        new NetworkVdsmVDSCommandParameters(
            getParameters().getVdsId(),
            getParameters().getNetwork().getName(),
            getParameters().getNetwork().getVlanId(),
            getParameters().getBondName(),
            interfaceNames.toArray(new String[] {}),
            address,
            subnet,
            gateway,
            getParameters().getNetwork().getStp(),
            bondingOptions,
            getParameters().getBootProtocol());
    parameters.setVmNetwork(getParameters().getNetwork().isVmNetwork());
    parameters.setOldNetworkName(getParameters().getOldNetworkName());
    parameters.setConnectionTimeout(
        Config.<Integer>getValue(ConfigValues.NetworkConnectivityCheckTimeoutInSeconds));
    parameters.setCheckConnectivity(getParameters().getCheckConnectivity());

    IPAddress[] adresses = Dns.getHostAddresses(NetworkUtils.OS_REFERENCE_TO_MACHINE_NAME);
    if (adresses != null && adresses.length > 0) {
      parameters.setHostAddr(adresses[0].toString());
    }

    if (getParameters().getCheckConnectivity()) {
      ThreadPoolUtil.execute(new EditNetworkThread(parameters));
      pollVds(getVds());
    } else {
      editNetworkThreadCompat(parameters);
    }

    if (retVal != null && editNetworkDone) {
      // update vds network data
      retVal =
          runVdsCommand(
              VDSCommandType.CollectVdsNetworkData,
              new CollectHostNetworkDataVdsCommandParameters(getVds()));

      if (retVal.getSucceeded()) {
        Guid groupId = getVdsDao().get(getParameters().getVdsId()).getVdsGroupId();
        NetworkClusterHelper.setStatus(groupId, getParameters().getNetwork());
        setSucceeded(true);
      }
    }
  }