How to use

com.yahoo.config.provision.HostSpec

constructor

@Override
public List<HostSpec> prepare(ClusterSpec cluster, Capacity capacity, int groups, ProvisionLogger logger) { // TODO: This should fail if capacity requested is more than 1
  List<HostSpec> hosts = new ArrayList<>();
  hosts.add(new HostSpec(host.hostname(), host.aliases(), ClusterMembership.from(cluster, counter++)));
  return hosts;
}

private HostSpec host2HostSpec(Host host) {
  return new HostSpec(host.hostname(), host.aliases());
}

Set<HostSpec> getHostSpecs() {
  return getHosts().stream()
      .map(host -> new HostSpec(host.getHostname(), Collections.emptyList(),
                   host.getFlavor(), host.primaryClusterMembership(), host.version()))
      .collect(Collectors.toCollection(LinkedHashSet::new));
}

@Override
public HostSpec allocateHost(String alias) {
  if (legacyMapping.containsKey(alias)) return legacyMapping.get(alias);
  List<Host> defaultHosts = freeNodes.get("default");
  if (defaultHosts.isEmpty()) throw new IllegalArgumentException("No more hosts of default flavor available");
  Host newHost = freeNodes.removeValue("default", 0);
  HostSpec hostSpec = new HostSpec(newHost.hostname(), newHost.aliases(), newHost.flavor(), Optional.empty(), newHost.version());
  legacyMapping.put(alias, hostSpec);
  return hostSpec;
}

private List<HostSpec> asSortedHosts(List<Node> nodes) {
  nodes.sort(Comparator.comparingInt(node -> node.allocation().get().membership().index()));
  List<HostSpec> hosts = new ArrayList<>(nodes.size());
  for (Node node : nodes) {
    log.log(LogLevel.DEBUG, () -> "Prepared node " + node.hostname() + " - " + node.flavor());
    hosts.add(new HostSpec(node.hostname(),
                node.allocation().orElseThrow(IllegalStateException::new).membership(),
                node.flavor(),
                node.status().vespaVersion()));
  }
  return hosts;
}

private HostSpec retire(HostSpec host) {
  return new HostSpec(host.hostname(),
            host.aliases(),
            host.flavor(),
            Optional.of(host.membership().get().retire()),
            host.version());
}

static HostSpec hostFromSlime(Inspector object, Optional<NodeFlavors> nodeFlavors) {
  Optional<ClusterMembership> membership =
      object.field(hostSpecMembership).valid() ? Optional.of(membershipFromSlime(object)) : Optional.empty();
  Optional<Flavor> flavor =
      object.field(hostSpecFlavor).valid() ? flavorFromSlime(object, nodeFlavors) : Optional.empty();
  Optional<com.yahoo.component.Version> version =
      optionalString(object.field(hostSpecCurrentVespaVersion)).map(com.yahoo.component.Version::new);
  return new HostSpec(object.field(hostSpecHostName).asString(), Collections.emptyList(), flavor, membership, version);
}

private List<HostSpec> allocateHostGroup(ClusterSpec clusterGroup, String flavor, int nodesInGroup, int startIndex, boolean canFail) {
  List<HostSpec> allocation = allocations.getOrDefault(clusterGroup, new ArrayList<>());
  allocations.put(clusterGroup, allocation);
  int nextIndex = nextIndexInCluster.getOrDefault(new Pair<>(clusterGroup.type(), clusterGroup.id()), startIndex);
  while (allocation.size() < nodesInGroup) {
    if (freeNodes.get(flavor).isEmpty()) {
      if (canFail)
        throw new IllegalArgumentException("Insufficient capacity of flavor '" + flavor + "'");
      else
        break;
    }
    Host newHost = freeNodes.removeValue(flavor, 0);
    ClusterMembership membership = ClusterMembership.from(clusterGroup, nextIndex++);
    allocation.add(new HostSpec(newHost.hostname(), newHost.aliases(), newHost.flavor(), Optional.of(membership), newHost.version()));
  }
  nextIndexInCluster.put(new Pair<>(clusterGroup.type(), clusterGroup.id()), nextIndex);
  while (allocation.size() > nodesInGroup)
    allocation.remove(0);
  return allocation;
}

@Override
public HostSpec allocateHost(String alias) {
  // Some special rules to allow no admin elements as well as jdisc element without nodes.
  if (alias.equals(IMPLICIT_ADMIN_HOSTALIAS)) {
    if (hosts.asCollection().size() > 1) {
      throw new IllegalArgumentException("More than 1 host specified (" + hosts.asCollection().size() + ") and <admin> not specified");
    } else {
      return host2HostSpec(getFirstHost());
    }
  } else if (alias.equals(Container.SINGLENODE_CONTAINER_SERVICESPEC)) {
    return host2HostSpec(getFirstHost());
  }
  for (Host host : hosts.asCollection()) {
    if (host.aliases().contains(alias)) {
      return new HostSpec(host.hostname(), host.aliases());
    }
  }
  throw new IllegalArgumentException("Unable to find host for alias '" + alias + "'");
}

public SingleNodeProvisioner() {
  host = new Host(HostName.getLocalhost());
  this.hostSpec = new HostSpec(host.hostname(), host.aliases());
}