private HostName getLoadBalancerName(HostName loadbalancerName, List<ConfigServerSpec> configServerSpecs) { // Set lbaddress, or use first hostname if not specified. // TODO: Remove this method and use the loadbalancerName directly return Optional.ofNullable(loadbalancerName) .orElseGet( () -> HostName.from(configServerSpecs.stream() .findFirst() .map(ConfigServerSpec::getHostName) .orElse("unknown") // Currently unable to test this, hence the unknown )); }
/** * Create a {@link HostName} with a given name. * * @param name Name * @return instance of {@link HostName}. */ public static HostName from(String name) { return new HostName(name); }
public static byte[] toJson(LoadBalancer loadBalancer) { Slime slime = new Slime(); Cursor root = slime.setObject(); root.setString(idField, loadBalancer.id().serializedForm()); root.setString(hostnameField, loadBalancer.hostname().toString()); loadBalancer.dnsZone().ifPresent(dnsZone -> root.setString(dnsZoneField, dnsZone.id())); Cursor portArray = root.setArray(portsField); loadBalancer.ports().forEach(portArray::addLong); Cursor networkArray = root.setArray(networksField); loadBalancer.networks().forEach(networkArray::addString); Cursor realArray = root.setArray(realsField); loadBalancer.reals().forEach(real -> { Cursor realObject = realArray.addObject(); realObject.setString(hostnameField, real.hostname().value()); realObject.setString(ipAddressField, real.ipAddress()); realObject.setLong(portField, real.port()); }); Cursor rotationArray = root.setArray(rotationsField); loadBalancer.rotations().forEach(rotation -> { Cursor rotationObject = rotationArray.addObject(); rotationObject.setString(nameField, rotation.value()); }); root.setBool(inactiveField, loadBalancer.inactive()); try { return SlimeUtils.toJsonBytes(slime); } catch (IOException e) { throw new UncheckedIOException(e); } }
@Override public int compareTo(Real that) { return hostname.compareTo(that.hostname()); }
/** Returns whether this flag is enabled for given hostname */ public boolean isEnabled(HostName hostname) { return enabled || hostnames.contains(hostname.value()); }
private LoadBalancer create(ApplicationId application, ClusterSpec.Id cluster, List<Node> nodes) { Map<HostName, Set<String>> hostnameToIpAdresses = nodes.stream() .collect(Collectors.toMap(node -> HostName.from(node.hostname()), this::reachableIpAddresses)); List<Real> reals = new ArrayList<>(); hostnameToIpAdresses.forEach((hostname, ipAddresses) -> { ipAddresses.forEach(ipAddress -> reals.add(new Real(hostname, ipAddress))); }); return service.create(application, cluster, reals); }
/** Returns a copy of this with enabled set for hostname */ public Flag withEnabled(HostName hostname, boolean enabled) { Set<String> hostnames = new LinkedHashSet<>(this.hostnames); if (enabled) { hostnames.add(hostname.value()); } else { hostnames.remove(hostname.value()); } return new Flag(id, this.enabled, hostnames, applications); }
public Maintainer(NodeRepository nodeRepository, Duration interval, JobControl jobControl) { this.nodeRepository = nodeRepository; this.interval = interval; this.jobControl = jobControl; HostName hostname = HostName.from(com.yahoo.net.HostName.getLocalhost()); long delay = staggeredDelay(nodeRepository.database().cluster(), hostname, nodeRepository.clock().instant(), interval); service = new ScheduledThreadPoolExecutor(1); service.scheduleAtFixedRate(this, delay, interval.toMillis(), TimeUnit.MILLISECONDS); jobControl.started(name()); }
@Override public void getConfig(IdentityConfig.Builder builder) { builder.domain(domain.value()); builder.service(service.value()); // Current interpretation of loadbalancer address is: hostname. // Config should be renamed or send the uri builder.loadBalancerAddress(loadBalancerName.value()); builder.ztsUrl(ztsUrl != null ? ztsUrl.toString() : ""); builder.athenzDnsSuffix(athenzDnsSuffix != null ? athenzDnsSuffix : ""); builder.nodeIdentityName("vespa.vespa.tenant"); // TODO Move to Oath configmodel amender builder.configserverIdentityName(getConfigserverIdentityName()); }
@Override public LoadBalancer create(ApplicationId application, ClusterSpec.Id cluster, Set<Real> reals) { LoadBalancer loadBalancer = new LoadBalancer( new LoadBalancerId(application, cluster), HostName.from("lb-" + application.toShortString() + "-" + cluster.value()), Optional.of(new DnsZone("zone-id-1")), Collections.singleton(4443), ImmutableSet.of("10.2.3.0/24", "10.4.5.0/24"), reals, false); loadBalancers.put(loadBalancer.id(), loadBalancer); return loadBalancer; }
lbObject.setString("instance", lb.id().application().instance().value()); lbObject.setString("cluster", lb.id().cluster().value()); lbObject.setString("hostname", lb.hostname().value()); lb.dnsZone().ifPresent(dnsZone -> lbObject.setString("dnsZone", dnsZone.id())); lb.reals().forEach(real -> { Cursor realObject = realArray.addObject(); realObject.setString("hostname", real.hostname().value()); realObject.setString("ipAddress", real.ipAddress()); realObject.setLong("port", real.port());
private HttpResponse setFlag(String flag, boolean enabled, String dimension, String value) { FlagId flagId = FlagId.fromSerializedForm(flag); switch (dimension) { case "application": nodeRepository.flags().setEnabled(flagId, ApplicationId.fromSerializedForm(value), enabled); break; case "node": nodeRepository.flags().setEnabled(flagId, HostName.from(value), enabled); break; case "": nodeRepository.flags().setEnabled(flagId, enabled); break; default: throw new IllegalArgumentException("Unknown flag dimension '" + dimension + "'"); } return new MessageResponse((enabled ? "Enabled" : "Disabled") + " feature " + flagId + (!value.isEmpty() ? " for " + dimension + " '" + value + "'" : "")); }
public static LoadBalancer fromJson(byte[] data) { Cursor object = SlimeUtils.jsonToSlime(data).get(); Set<Real> reals = new LinkedHashSet<>(); object.field(realsField).traverse((ArrayTraverser) (i, realObject) -> { reals.add(new Real(HostName.from(realObject.field(hostnameField).asString()), realObject.field(ipAddressField).asString(), (int) realObject.field(portField).asLong())); }); Set<Integer> ports = new LinkedHashSet<>(); object.field(portsField).traverse((ArrayTraverser) (i, port) -> ports.add((int) port.asLong())); Set<String> networks = new LinkedHashSet<>(); object.field(networksField).traverse((ArrayTraverser) (i, network) -> networks.add(network.asString())); Set<RotationName> rotations = new LinkedHashSet<>(); object.field(rotationsField).traverse((ArrayTraverser) (i, rotation) -> { rotations.add(RotationName.from(rotation.field(nameField).asString())); }); return new LoadBalancer(LoadBalancerId.fromSerializedForm(object.field(idField).asString()), HostName.from(object.field(hostnameField).asString()), optionalField(object.field(dnsZoneField), DnsZone::new), ports, networks, reals, rotations, object.field(inactiveField).asBool()); }