Example #1
0
  private boolean runQuery(HttpServletResponse response, String sessionID) {
    boolean returnValue = false;

    log.debug("Calling ValidateSession query");

    VdcQueryReturnValue queryReturnValue =
        backend.runInternalQuery(
            VdcQueryType.ValidateSession, new VdcQueryParametersBase(sessionID));

    if (queryReturnValue != null) {
      returnValue = queryReturnValue.getSucceeded();

      if (returnValue) {
        DbUser user = queryReturnValue.getReturnValue();

        // We get the user name only in case the validation succeeded, and the user is an
        // administrator
        if (user.isAdmin()) {
          log.debug("Getting user name");
          printUPNToResponse(response, getUPN(user));
        } else {
          log.error("User '{}' is not authorized to perform operation", user.getLoginName());
          returnValue = false;
        }
      }
    } else {
      log.error("Got NULL from backend.RunQuery");
    }

    return returnValue;
  }
Example #2
0
  public void setCertificateInfo(VM model) {
    VdcQueryReturnValue result =
        runQuery(
            VdcQueryType.GetVdsCertificateSubjectByVmId,
            new IdQueryParameters(asGuid(model.getId())));

    if (result != null && result.getSucceeded() && result.getReturnValue() != null) {
      if (!model.isSetDisplay()) {
        model.setDisplay(new Display());
      }
      model.getDisplay().setCertificate(new Certificate());
      model.getDisplay().getCertificate().setSubject(result.getReturnValue().toString());
    }
  }
Example #3
0
  private boolean isRepoImageExists(
      String repoImagePath, Guid storageDomainId, ImageFileType imageFileType) {
    VdcQueryReturnValue ret =
        getBackend()
            .runInternalQuery(
                VdcQueryType.GetImagesList,
                new GetImagesListParameters(storageDomainId, imageFileType));

    if (ret != null && ret.getReturnValue() != null && ret.getSucceeded()) {
      for (RepoImage isoFileMetaData : ret.<List<RepoImage>>getReturnValue()) {
        if (repoImagePath.equals(isoFileMetaData.getRepoImageId())) {
          return true;
        }
      }
    }
    return false;
  }
  /**
   * Get devices (LUNs) that are visible by the host.
   *
   * @return the list of LUNs.
   */
  protected List<LUNs> getDeviceList() {
    List<LUNs> luns = new ArrayList<>();
    VdcQueryReturnValue returnValue =
        executeGetDeviceList(
            new GetDeviceListQueryParameters(
                getParameters().getVdsId(), getParameters().getStorageType(), false, null));

    if (returnValue.getSucceeded()) {
      luns.addAll(returnValue.<List<LUNs>>getReturnValue());
    } else {
      throw new RuntimeException(
          String.format(
              "GetDeviceList execution failed. Exception message: %1$s",
              returnValue.getExceptionString()));
    }

    return luns;
  }
  // TODO: REVISIT when backend expose CertificateSubject in vds
  public Host addCertificateInfo(Host host) {
    VdcQueryReturnValue result =
        runQuery(
            VdcQueryType.GetVdsCertificateSubjectByVdsId,
            new GetVdsByVdsIdParameters(asGuid(host.getId())));

    if (result != null && result.getSucceeded() && result.getReturnValue() != null) {
      String subject = result.getReturnValue().toString();
      if (subject != null) {
        host.setCertificate(new Certificate());
        host.getCertificate().setSubject(subject);
        host.getCertificate().setOrganization(subject.split(",")[0].replace("O=", ""));
      }
    } else {
      LOG.error("Could not fetch certificate info for host " + host.getId());
    }
    return host;
  }
  public void SetDefaultNames(VDS host, RefObject<String> message) {
    message.argvalue = null;
    setCommonName(StringFormat.format("%1$s-Local", host.getvds_name().replace('.', '-')));
    storage_pool candidate = null;

    // selecet all possible DCs
    VdcQueryReturnValue returnValue =
        Frontend.RunQuery(
            VdcQueryType.Search,
            new SearchParameters(
                StringFormat.format("DataCenter: name=%1$s", getCommonName() + "*"),
                SearchType.StoragePool));

    java.util.ArrayList<storage_pool> dataCenterList = new java.util.ArrayList<storage_pool>();
    java.util.ArrayList<VDSGroup> clusterList = null;
    if (returnValue != null && returnValue.getSucceeded() && returnValue.getReturnValue() != null) {
      dataCenterList =
          Linq.<storage_pool>Cast(
              (java.util.ArrayList<IVdcQueryable>) returnValue.getReturnValue());
    }
    // check if current settings suitable for local setup (in case just SD creation failed -
    // re-using the same setup)
    boolean useCurrentSettings = false;
    if (host.getstorage_pool_id() != null) {
      storage_pool tempCandidate = DataProvider.GetDataCenterById(host.getstorage_pool_id());
      if (IsLocalDataCenterEmpty(tempCandidate)) {
        candidate = tempCandidate;
        useCurrentSettings = true;
      } else {
        if (tempCandidate != null && tempCandidate.getstorage_pool_type() == StorageType.LOCALFS) {
          message.argvalue =
              "Note: Local Storage is already configured for this Host. The Host belongs to "
                  + host.getstorage_pool_name()
                  + " with local Storage Domain. If OK is clicked - this Host will be moved to a new Data Center, and a new Local Storage Domain will be created. Hit Cancel to abort the operation.";
        }
      }
    }
    // check if there is other DC suitable for re-use
    if (candidate == null) {
      for (storage_pool dataCenter : dataCenterList) {
        // need to check if the new DC is without host.
        if (IsLocalDataCenterEmpty(dataCenter)
            && DataProvider.GetLocalStorageHost(dataCenter.getname()) == null) {
          candidate = dataCenter;
          break;
        }
      }
    }
    java.util.ArrayList<String> listNames = new java.util.ArrayList<String>();
    // in case we found a suitable candidte for re-use:
    if (candidate != null) {
      getDataCenter().setDataCenterId(candidate.getId());
      getDataCenter().getName().setEntity(candidate.getname());
      getDataCenter().getDescription().setEntity(candidate.getdescription());
      Version compVersion = candidate.getcompatibility_version();
      getDataCenter().getVersion().setSelectedItem(compVersion);
      getCluster().getVersion().setSelectedItem(compVersion);
      setDontCreateDataCenter(true);
      // if we use current settings there is no need to create cluster.
      if (useCurrentSettings) {
        getCluster().setClusterId(host.getvds_group_id().getValue());
        getCluster().getName().setEntity(host.getvds_group_name());
        VDSGroup cluster = DataProvider.GetClusterById(host.getvds_group_id().getValue());
        if (cluster != null) {
          getCluster().getDescription().setEntity(cluster.getdescription());
          ServerCpu tempVar = new ServerCpu();
          tempVar.setCpuName(cluster.getcpu_name());
          getCluster().getCPU().setSelectedItem(tempVar);
        }
        setDontCreateCluster(true);
        setDontChangeHostCluster(true);
      }
      // use differnt cluster
      else {
        // check the DC cluster list (for re-use)
        clusterList = DataProvider.GetClusterList(candidate.getId());
        // no clusters avilable - pick up new name.
        if (clusterList.isEmpty()) {
          java.util.ArrayList<VDSGroup> listClusters = DataProvider.GetClusterList();
          listNames = new java.util.ArrayList<String>();
          for (VDSGroup cluster : listClusters) {
            listNames.add(cluster.getname());
          }
          getCluster().getName().setEntity(AvailableName(listNames));
        } else {
          // use the DC cluster.
          getCluster().setClusterId(clusterList.get(0).getId());
          getCluster().getName().setEntity(clusterList.get(0).getname());
          getCluster().getDescription().setEntity(clusterList.get(0).getdescription());
          VDSGroup cluster = DataProvider.GetClusterById(getCluster().getClusterId().getValue());
          if (cluster != null) {
            ServerCpu tempVar2 = new ServerCpu();
            tempVar2.setCpuName(cluster.getcpu_name());
            getCluster().getCPU().setSelectedItem(tempVar2);
          }
          setDontCreateCluster(true);
          if (host.getvds_group_id().getValue().equals(getCluster().getClusterId())) {
            setDontChangeHostCluster(true);
          }
        }
      }
    } else {
      // didn't found DC to re-use, so we select new names:
      listNames = new java.util.ArrayList<String>();
      for (storage_pool storagePool : dataCenterList) {
        listNames.add(storagePool.getname());
      }
      getDataCenter().getName().setEntity(AvailableName(listNames));

      // Choose a Data Center version corresponding to the host.
      if (!StringHelper.isNullOrEmpty(host.getsupported_cluster_levels())) {
        // the supported_cluster_levels are sorted.
        String[] array = host.getsupported_cluster_levels().split("[,]", -1);
        Version maxCombindVersion = null;

        for (int i = 0; i < array.length; i++) {
          Version vdsVersion = new Version(array[i]);
          for (Version version :
              (java.util.List<Version>) getDataCenter().getVersion().getItems()) {
            if (version.equals(vdsVersion) && version.compareTo(maxCombindVersion) > 0) {
              maxCombindVersion = version;
            }
          }
        }
        if (maxCombindVersion != null) {
          getDataCenter().getVersion().setSelectedItem(maxCombindVersion);
          getCluster().getVersion().setSelectedItem(maxCombindVersion);
        }
      }

      listNames = new java.util.ArrayList<String>();
      if (clusterList == null) {
        clusterList = DataProvider.GetClusterList();
      }

      for (VDSGroup cluster : clusterList) {
        listNames.add(cluster.getname());
      }
      getCluster().getName().setEntity(AvailableName(listNames));
    }

    // Choose default CPU name to match host.
    if (host.getCpuName() != null && getCluster().getCPU().getSelectedItem() != null) {
      getCluster()
          .getCPU()
          .setSelectedItem(
              Linq.FirstOrDefault(
                  (java.util.List<ServerCpu>) getCluster().getCPU().getItems(),
                  new Linq.ServerCpuPredicate(host.getCpuName().getCpuName())));
    }
    // always choose a avialable storage name.
    java.util.ArrayList<storage_domains> listStorageDomains = DataProvider.GetStorageDomainList();
    listNames = new java.util.ArrayList<String>();
    for (storage_domains storageDomain : listStorageDomains) {
      listNames.add(storageDomain.getstorage_name());
    }
    getFormattedStorageName().setEntity(AvailableName(listNames));
  }