index int64 0 0 | repo_id stringlengths 26 205 | file_path stringlengths 51 246 | content stringlengths 8 433k | __index_level_0__ int64 0 10k |
|---|---|---|---|---|
0 | Create_ds/titus-control-plane/titus-common-client/src/main/java/com/netflix/titus/client/clustermembership | Create_ds/titus-control-plane/titus-common-client/src/main/java/com/netflix/titus/client/clustermembership/grpc/GrpcClusterMembershipNameResolverFactory.java | /*
* Copyright 2019 Netflix, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.netflix.titus.client.clustermembership.grpc;
import java.io.Closeable;
import java.net.URI;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;
import java.util.function.Function;
import javax.annotation.Nullable;
import com.google.common.base.Preconditions;
import com.netflix.titus.api.clustermembership.model.ClusterMember;
import com.netflix.titus.api.clustermembership.model.ClusterMemberAddress;
import com.netflix.titus.client.clustermembership.resolver.ClusterMemberResolver;
import com.netflix.titus.common.runtime.TitusRuntime;
import com.netflix.titus.common.util.ExceptionExt;
import com.netflix.titus.common.util.IOExt;
import io.grpc.Attributes;
import io.grpc.NameResolver;
public class GrpcClusterMembershipNameResolverFactory extends NameResolver.Factory implements Closeable {
private static final String SCHEME = "leader";
private final GrpcClusterMembershipNameResolverConfiguration configuration;
private final Function<URI, ClusterMemberResolver> clusterMemberResolverProvider;
private final Function<ClusterMember, ClusterMemberAddress> addressSelector;
private final TitusRuntime titusRuntime;
private volatile boolean closed;
private final ConcurrentMap<URI, Allocation> allocatedResolvers = new ConcurrentHashMap<>();
public GrpcClusterMembershipNameResolverFactory(GrpcClusterMembershipNameResolverConfiguration configuration,
Function<URI, ClusterMemberResolver> clusterMemberResolverProvider,
Function<ClusterMember, ClusterMemberAddress> addressSelector,
TitusRuntime titusRuntime) {
this.configuration = configuration;
this.clusterMemberResolverProvider = clusterMemberResolverProvider;
this.addressSelector = addressSelector;
this.titusRuntime = titusRuntime;
}
@Override
public void close() {
closed = true;
allocatedResolvers.values().forEach(Allocation::close);
allocatedResolvers.clear();
}
@Nullable
@Override
public NameResolver newNameResolver(URI targetUri, NameResolver.Args args) {
Preconditions.checkState(!closed, "Name resolver already closed");
return allocatedResolvers.computeIfAbsent(targetUri, uri -> {
ClusterMemberResolver resolver = clusterMemberResolverProvider.apply(targetUri);
return new Allocation(
resolver,
new GrpcClusterMembershipLeaderNameResolver(configuration, resolver, addressSelector, titusRuntime)
);
}).getGrpcClusterMembershipLeaderNameResolver();
}
@Override
public String getDefaultScheme() {
return SCHEME;
}
private static class Allocation implements Closeable {
private final ClusterMemberResolver clusterMemberResolver;
private final GrpcClusterMembershipLeaderNameResolver grpcClusterMembershipLeaderNameResolver;
private Allocation(ClusterMemberResolver clusterMemberResolver,
GrpcClusterMembershipLeaderNameResolver grpcClusterMembershipLeaderNameResolver) {
this.clusterMemberResolver = clusterMemberResolver;
this.grpcClusterMembershipLeaderNameResolver = grpcClusterMembershipLeaderNameResolver;
}
private GrpcClusterMembershipLeaderNameResolver getGrpcClusterMembershipLeaderNameResolver() {
return grpcClusterMembershipLeaderNameResolver;
}
@Override
public void close() {
ExceptionExt.silent(grpcClusterMembershipLeaderNameResolver::shutdown);
IOExt.closeSilently(clusterMemberResolver);
}
}
}
| 9,800 |
0 | Create_ds/titus-control-plane/titus-common-client/src/main/java/com/netflix/titus/client/clustermembership | Create_ds/titus-control-plane/titus-common-client/src/main/java/com/netflix/titus/client/clustermembership/grpc/ClusterMembershipGrpcConverters.java | /*
* Copyright 2019 Netflix, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.netflix.titus.client.clustermembership.grpc;
import java.util.stream.Collectors;
import com.netflix.titus.api.clustermembership.model.ClusterMember;
import com.netflix.titus.api.clustermembership.model.ClusterMemberAddress;
import com.netflix.titus.common.util.CollectionsExt;
import com.netflix.titus.common.util.StringExt;
import com.netflix.titus.grpc.protogen.ClusterMember.LeadershipState;
import com.netflix.titus.grpc.protogen.ClusterMembershipRevision;
public class ClusterMembershipGrpcConverters {
/**
* TODO Add revision number to GRPC IDL
*/
private static final String REVISION_LABEL = "titus.clusterMembership.revision";
public static ClusterMembershipRevision toGrpcClusterMembershipRevision(com.netflix.titus.api.clustermembership.model.ClusterMembershipRevision<ClusterMember> memberRevision,
boolean leader) {
ClusterMember tagged = memberRevision.getCurrent().toBuilder()
.withLabels(CollectionsExt.copyAndAdd(memberRevision.getCurrent().getLabels(), REVISION_LABEL, "" + memberRevision.getRevision()))
.build();
return ClusterMembershipRevision.newBuilder()
.setCurrent(toGrpcClusterMember(tagged, leader))
.setCode(memberRevision.getCode())
.setMessage(memberRevision.getMessage())
.setTimestamp(memberRevision.getTimestamp())
.build();
}
public static com.netflix.titus.grpc.protogen.ClusterMember toGrpcClusterMember(ClusterMember clusterMember, boolean leader) {
LeadershipState leadershipState;
if (leader) {
leadershipState = LeadershipState.Leader;
} else if (clusterMember.isActive()) {
leadershipState = LeadershipState.NonLeader;
} else {
leadershipState = LeadershipState.Disabled;
}
return com.netflix.titus.grpc.protogen.ClusterMember.newBuilder()
.setMemberId(clusterMember.getMemberId())
.setEnabled(clusterMember.isEnabled())
.setRegistered(clusterMember.isRegistered())
.setLeadershipState(leadershipState)
.addAllAddresses(clusterMember.getClusterMemberAddresses().stream()
.map(ClusterMembershipGrpcConverters::toGrpcServiceAddress)
.collect(Collectors.toList())
)
.putAllLabels(clusterMember.getLabels())
.build();
}
public static com.netflix.titus.grpc.protogen.ClusterMemberAddress toGrpcServiceAddress(ClusterMemberAddress address) {
return com.netflix.titus.grpc.protogen.ClusterMemberAddress.newBuilder()
.setIpAddress(address.getIpAddress())
.setPortNumber(address.getPortNumber())
.setProtocol(address.getProtocol())
.setSecure(address.isSecure())
.setDescription(address.getDescription())
.build();
}
public static com.netflix.titus.api.clustermembership.model.ClusterMembershipRevision<ClusterMember> toCoreClusterMembershipRevision(ClusterMembershipRevision grpcRevision) {
String revisionValue = grpcRevision.getCurrent().getLabelsMap().get(REVISION_LABEL);
long revision = StringExt.parseLong(revisionValue).orElse(System.currentTimeMillis());
return com.netflix.titus.api.clustermembership.model.ClusterMembershipRevision.<ClusterMember>newBuilder()
.withCurrent(toCoreClusterMember(grpcRevision.getCurrent()))
.withCode(grpcRevision.getCode())
.withMessage(grpcRevision.getMessage())
.withRevision(revision)
.withTimestamp(grpcRevision.getTimestamp())
.build();
}
public static ClusterMember toCoreClusterMember(com.netflix.titus.grpc.protogen.ClusterMember grpcClusterMember) {
return ClusterMember.newBuilder()
.withMemberId(grpcClusterMember.getMemberId())
.withEnabled(grpcClusterMember.getEnabled())
.withRegistered(grpcClusterMember.getRegistered())
.withLabels(grpcClusterMember.getLabelsMap())
.withClusterMemberAddresses(grpcClusterMember.getAddressesList().stream()
.map(ClusterMembershipGrpcConverters::toCoreClusterMemberAddress)
.collect(Collectors.toList())
)
.build();
}
private static ClusterMemberAddress toCoreClusterMemberAddress(com.netflix.titus.grpc.protogen.ClusterMemberAddress grpcAddress) {
return ClusterMemberAddress.newBuilder()
.withIpAddress(grpcAddress.getIpAddress())
.withPortNumber(grpcAddress.getPortNumber())
.withProtocol(grpcAddress.getProtocol())
.withSecure(grpcAddress.getSecure())
.withDescription(grpcAddress.getDescription())
.build();
}
}
| 9,801 |
0 | Create_ds/titus-control-plane/titus-common-client/src/main/java/com/netflix/titus/client/clustermembership | Create_ds/titus-control-plane/titus-common-client/src/main/java/com/netflix/titus/client/clustermembership/grpc/ClusterMembershipClient.java | /*
* Copyright 2019 Netflix, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.netflix.titus.client.clustermembership.grpc;
import com.netflix.titus.grpc.protogen.ClusterMembershipEvent;
import com.netflix.titus.grpc.protogen.ClusterMembershipRevision;
import com.netflix.titus.grpc.protogen.ClusterMembershipRevisions;
import com.netflix.titus.grpc.protogen.DeleteMemberLabelsRequest;
import com.netflix.titus.grpc.protogen.EnableMemberRequest;
import com.netflix.titus.grpc.protogen.MemberId;
import com.netflix.titus.grpc.protogen.UpdateMemberLabelsRequest;
import reactor.core.publisher.Flux;
import reactor.core.publisher.Mono;
/**
* Reactor wrapper around the GRPC ClusterMembershipService documented at:
* https://github.com/Netflix/titus-api-definitions/blob/master/src/main/proto/netflix/titus/titus_cluster_membership_api.proto.
*/
public interface ClusterMembershipClient {
Mono<ClusterMembershipRevisions> getMembers();
Mono<ClusterMembershipRevision> getMember(MemberId request);
Mono<ClusterMembershipRevision> updateMemberLabels(UpdateMemberLabelsRequest request);
Mono<ClusterMembershipRevision> deleteMemberLabels(DeleteMemberLabelsRequest request);
Mono<ClusterMembershipRevision> enableMember(EnableMemberRequest request);
Mono<Void> stopBeingLeader();
Flux<ClusterMembershipEvent> events();
void shutdown();
}
| 9,802 |
0 | Create_ds/titus-control-plane/titus-common-client/src/main/java/com/netflix/titus/client/clustermembership | Create_ds/titus-control-plane/titus-common-client/src/main/java/com/netflix/titus/client/clustermembership/grpc/GrpcClusterMembershipNameResolverConfiguration.java | /*
* Copyright 2019 Netflix, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.netflix.titus.client.clustermembership.grpc;
import com.netflix.archaius.api.annotations.Configuration;
import com.netflix.archaius.api.annotations.DefaultValue;
@Configuration(prefix = "titus.clusterMembership.client.grpcNameResolver")
public interface GrpcClusterMembershipNameResolverConfiguration {
@DefaultValue("1000")
long getRetryIntervalMs();
}
| 9,803 |
0 | Create_ds/titus-control-plane/titus-common-client/src/main/java/com/netflix/titus/client/clustermembership | Create_ds/titus-control-plane/titus-common-client/src/main/java/com/netflix/titus/client/clustermembership/grpc/GrpcClusterMembershipLeaderNameResolver.java | /*
* Copyright 2019 Netflix, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.netflix.titus.client.clustermembership.grpc;
import java.net.InetSocketAddress;
import java.time.Duration;
import java.util.Collections;
import java.util.List;
import java.util.Optional;
import java.util.function.Function;
import com.netflix.spectator.api.Id;
import com.netflix.spectator.api.patterns.PolledMeter;
import com.netflix.titus.api.clustermembership.model.ClusterMember;
import com.netflix.titus.api.clustermembership.model.ClusterMemberAddress;
import com.netflix.titus.api.clustermembership.model.ClusterMembershipRevision;
import com.netflix.titus.api.clustermembership.model.ClusterMembershipSnapshot;
import com.netflix.titus.client.clustermembership.ClusterMembershipClientMetrics;
import com.netflix.titus.client.clustermembership.resolver.ClusterMemberResolver;
import com.netflix.titus.common.runtime.TitusRuntime;
import com.netflix.titus.common.util.Evaluators;
import com.netflix.titus.common.util.rx.ReactorExt;
import io.grpc.Attributes;
import io.grpc.EquivalentAddressGroup;
import io.grpc.NameResolver;
import io.grpc.Status;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import reactor.core.Disposable;
import reactor.core.publisher.Mono;
import reactor.core.publisher.SignalType;
import reactor.util.retry.Retry;
class GrpcClusterMembershipLeaderNameResolver extends NameResolver {
private static final Logger logger = LoggerFactory.getLogger(GrpcClusterMembershipLeaderNameResolver.class);
private static final String CLUSTER_MEMBERSHIP_AUTHORITY = "ClusterMembershipAuthority";
private static final String METRICS_ROOT = ClusterMembershipClientMetrics.CLUSTER_MEMBERSHIP_CLIENT_METRICS_ROOT + "grpcNameResolver";
private final GrpcClusterMembershipNameResolverConfiguration configuration;
private final ClusterMemberResolver resolver;
private final Function<ClusterMember, ClusterMemberAddress> addressSelector;
private volatile LeaderMetrics leaderMetrics;
private final TitusRuntime titusRuntime;
private volatile Listener listener;
private volatile Disposable eventStreamDisposable;
private volatile ClusterMembershipRevision<ClusterMember> lastLeader;
GrpcClusterMembershipLeaderNameResolver(GrpcClusterMembershipNameResolverConfiguration configuration,
ClusterMemberResolver resolver,
Function<ClusterMember, ClusterMemberAddress> addressSelector,
TitusRuntime titusRuntime) {
this.configuration = configuration;
this.resolver = resolver;
this.addressSelector = addressSelector;
this.titusRuntime = titusRuntime;
}
@Override
public String getServiceAuthority() {
return CLUSTER_MEMBERSHIP_AUTHORITY;
}
@Override
public void start(Listener listener) {
this.listener = listener;
Duration retryInterval = Duration.ofMillis(configuration.getRetryIntervalMs());
this.eventStreamDisposable = resolver.resolve()
.materialize()
.flatMap(signal -> {
if (signal.getType() == SignalType.ON_NEXT) {
return Mono.just(signal.get());
}
if (signal.getType() == SignalType.ON_COMPLETE) {
return Mono.error(new IllegalStateException("Unexpected end of stream"));
}
if (signal.getType() == SignalType.ON_ERROR) {
return Mono.error(signal.getThrowable());
}
return Mono.empty();
})
.retryWhen(Retry.backoff(Long.MAX_VALUE, retryInterval))
.subscribe(
this::refresh,
e -> logger.warn("Cluster membership event stream terminated with an error", e),
() -> logger.info("Cluster membership event stream terminated")
);
}
@Override
public void shutdown() {
ReactorExt.safeDispose(eventStreamDisposable);
this.listener = null;
}
private void refresh(ClusterMembershipSnapshot snapshot) {
try {
Optional<ClusterMembershipRevision<ClusterMember>> leaderOpt = snapshot.getLeaderRevision()
.flatMap(l -> Optional.ofNullable(snapshot.getMemberRevisions().get(l.getCurrent().getMemberId())));
if (leaderOpt.isPresent()) {
ClusterMembershipRevision<ClusterMember> memberRevision = leaderOpt.get();
ClusterMemberAddress address = addressSelector.apply(memberRevision.getCurrent());
if (lastLeader == null || !lastLeader.getCurrent().getMemberId().equals(memberRevision.getCurrent().getMemberId())) {
logger.info("New leader: {}", memberRevision);
Evaluators.acceptNotNull(leaderMetrics, LeaderMetrics::close);
lastLeader = memberRevision;
leaderMetrics = new LeaderMetrics(lastLeader, titusRuntime);
} else {
logger.debug("Refreshing: {}", lastLeader);
}
EquivalentAddressGroup server = new EquivalentAddressGroup(new InetSocketAddress(address.getIpAddress(), address.getPortNumber()));
List<EquivalentAddressGroup> servers = Collections.singletonList(server);
listener.onAddresses(servers, Attributes.EMPTY);
} else {
if (lastLeader != null) {
leaderMetrics.close();
lastLeader = null;
leaderMetrics = null;
logger.warn("No leader");
}
listener.onError(Status.UNAVAILABLE.withDescription("Unable to resolve leader server"));
}
} catch (Exception e) {
logger.error("Unable to create server with error: ", e);
listener.onError(Status.UNAVAILABLE.withCause(e));
}
}
private static class LeaderMetrics {
private final long electedTimestamp;
private final Id metricLeaderId;
private final TitusRuntime titusRuntime;
private LeaderMetrics(ClusterMembershipRevision<ClusterMember> lastLeader, TitusRuntime titusRuntime) {
this.electedTimestamp = titusRuntime.getClock().wallTime();
this.titusRuntime = titusRuntime;
this.metricLeaderId = titusRuntime.getRegistry().createId(METRICS_ROOT + "leaderElected",
"memberId", lastLeader.getCurrent().getMemberId()
);
PolledMeter.using(titusRuntime.getRegistry()).withId(metricLeaderId).monitorValue(this,
self -> self.titusRuntime.getClock().wallTime() - self.electedTimestamp
);
}
private void close() {
PolledMeter.remove(titusRuntime.getRegistry(), metricLeaderId);
}
}
}
| 9,804 |
0 | Create_ds/titus-control-plane/titus-common-client/src/main/java/com/netflix/titus/client/clustermembership | Create_ds/titus-control-plane/titus-common-client/src/main/java/com/netflix/titus/client/clustermembership/resolver/ClusterMemberVerifierResult.java | /*
* Copyright 2020 Netflix, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.netflix.titus.client.clustermembership.resolver;
import java.util.Objects;
public class ClusterMemberVerifierResult {
private static final ClusterMemberVerifierResult VALID = new ClusterMemberVerifierResult(true, "valid");
private final boolean valid;
private final String message;
public ClusterMemberVerifierResult(boolean valid, String message) {
this.valid = valid;
this.message = message;
}
public boolean isValid() {
return valid;
}
public String getMessage() {
return message;
}
@Override
public boolean equals(Object o) {
if (this == o) {
return true;
}
if (o == null || getClass() != o.getClass()) {
return false;
}
ClusterMemberVerifierResult result = (ClusterMemberVerifierResult) o;
return valid == result.valid &&
Objects.equals(message, result.message);
}
@Override
public int hashCode() {
return Objects.hash(valid, message);
}
@Override
public String toString() {
return "ClusterMemberVerifierResult{" +
"valid=" + valid +
", message='" + message + '\'' +
'}';
}
public static ClusterMemberVerifierResult valid() {
return VALID;
}
public static ClusterMemberVerifierResult invalid(String errorMessage) {
return new ClusterMemberVerifierResult(false, errorMessage);
}
}
| 9,805 |
0 | Create_ds/titus-control-plane/titus-common-client/src/main/java/com/netflix/titus/client/clustermembership | Create_ds/titus-control-plane/titus-common-client/src/main/java/com/netflix/titus/client/clustermembership/resolver/MultiNodeClusterMemberResolverMetrics.java | /*
* Copyright 2019 Netflix, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.netflix.titus.client.clustermembership.resolver;
import java.io.Closeable;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
import com.netflix.spectator.api.Id;
import com.netflix.spectator.api.Registry;
import com.netflix.spectator.api.patterns.PolledMeter;
import com.netflix.titus.api.clustermembership.model.ClusterMemberLeadership;
import com.netflix.titus.api.clustermembership.model.ClusterMembershipRevision;
import com.netflix.titus.api.clustermembership.model.ClusterMembershipSnapshot;
import com.netflix.titus.client.clustermembership.ClusterMembershipClientMetrics;
import com.netflix.titus.common.runtime.TitusRuntime;
import com.netflix.titus.common.util.CollectionsExt;
import com.netflix.titus.common.util.time.Clock;
/**
* Companion class to {@link MultiNodeClusterMemberResolver}.
*/
final class MultiNodeClusterMemberResolverMetrics {
private static final String ROOT = ClusterMembershipClientMetrics.CLUSTER_MEMBERSHIP_CLIENT_METRICS_ROOT + "multiNodeResolver.";
private final String serviceName;
private final Clock clock;
private final Registry registry;
private final Map<String, DirectConnection> directConnections = new HashMap<>();
private final Map<String, KnownMember> knownMembers = new HashMap<>();
private Leader leader;
MultiNodeClusterMemberResolverMetrics(String serviceName, TitusRuntime titusRuntime) {
this.serviceName = serviceName;
this.clock = titusRuntime.getClock();
this.registry = titusRuntime.getRegistry();
}
void updateConnectedMembers(Map<String, DirectClusterMemberResolver> memberResolversByIpAddress) {
memberResolversByIpAddress.forEach((memberIp, directResolver) -> {
if (!directConnections.containsKey(memberIp)) {
directConnections.put(memberIp, new DirectConnection(memberIp, directResolver));
}
});
Set<String> toRemove = CollectionsExt.copyAndRemove(directConnections.keySet(), memberResolversByIpAddress.keySet());
toRemove.forEach(memberIp -> directConnections.remove(memberIp).close());
}
void updateSnapshot(ClusterMembershipSnapshot snapshot) {
// Members
snapshot.getMemberRevisions().forEach((memberId, revision) -> {
if (!knownMembers.containsKey(memberId)) {
knownMembers.put(memberId, new KnownMember(memberId));
}
});
Set<String> toRemove = CollectionsExt.copyAndRemove(knownMembers.keySet(), snapshot.getMemberRevisions().keySet());
toRemove.forEach(memberIp -> knownMembers.remove(memberIp).close());
// Leader
ClusterMemberLeadership currentLeader = snapshot.getLeaderRevision().map(ClusterMembershipRevision::getCurrent).orElse(null);
if (currentLeader != null) {
if (leader == null) {
this.leader = new Leader(currentLeader);
} else {
if (!leader.getMemberId().equals(currentLeader.getMemberId())) {
leader.close();
this.leader = new Leader(currentLeader);
}
}
} else if (leader != null) {
leader.close();
leader = null;
}
}
private class DirectConnection implements Closeable {
private final DirectClusterMemberResolver directResolver;
private final long startTime;
private final Id connectionHealthId;
private final Id connectionTimeId;
private volatile boolean closed;
private DirectConnection(String ipAddress, DirectClusterMemberResolver directResolver) {
this.startTime = clock.wallTime();
this.directResolver = directResolver;
this.connectionHealthId = registry.createId(
ROOT + "directConnection.health",
"service", serviceName,
"memberIp", ipAddress
);
this.connectionTimeId = registry.createId(
ROOT + "directConnection.time",
"service", serviceName,
"memberIp", ipAddress
);
PolledMeter.using(registry).withId(connectionHealthId).monitorValue(this, self ->
closed ? 0 : (self.directResolver.isHealthy() ? 1 : 0)
);
PolledMeter.using(registry).withId(connectionTimeId).monitorValue(this, self ->
closed ? 0 : (clock.wallTime() - self.startTime)
);
}
@Override
public void close() {
closed = true;
PolledMeter.update(registry);
PolledMeter.remove(registry, connectionHealthId);
PolledMeter.remove(registry, connectionTimeId);
}
}
private class KnownMember implements Closeable {
private final long startTime;
private final Id memberTimeId;
private volatile boolean closed;
private KnownMember(String memberId) {
this.startTime = clock.wallTime();
this.memberTimeId = registry.createId(
ROOT + "knownMember.time",
"service", serviceName,
"memberId", memberId
);
PolledMeter.using(registry).withId(memberTimeId).monitorValue(this, self ->
closed ? 0 : (clock.wallTime() - self.startTime)
);
}
@Override
public void close() {
closed = true;
PolledMeter.update(registry);
PolledMeter.remove(registry, memberTimeId);
}
}
private class Leader implements Closeable {
private final long startTime;
private final Id leaderTimeId;
private final String memberId;
private volatile boolean closed;
private Leader(ClusterMemberLeadership leader) {
this.memberId = leader.getMemberId();
this.startTime = clock.wallTime();
this.leaderTimeId = registry.createId(
ROOT + "leader.time",
"service", serviceName,
"memberId", memberId
);
PolledMeter.using(registry).withId(leaderTimeId).monitorValue(this, self ->
closed ? 0 : (clock.wallTime() - self.startTime)
);
}
private String getMemberId() {
return memberId;
}
@Override
public void close() {
closed = true;
PolledMeter.update(registry);
PolledMeter.remove(registry, leaderTimeId);
}
}
}
| 9,806 |
0 | Create_ds/titus-control-plane/titus-common-client/src/main/java/com/netflix/titus/client/clustermembership | Create_ds/titus-control-plane/titus-common-client/src/main/java/com/netflix/titus/client/clustermembership/resolver/ClusterMembershipResolverConfiguration.java | /*
* Copyright 2019 Netflix, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.netflix.titus.client.clustermembership.resolver;
import com.netflix.archaius.api.annotations.Configuration;
import com.netflix.archaius.api.annotations.DefaultValue;
@Configuration(prefix = "titus.clusterMembership.client.resolver")
public interface ClusterMembershipResolverConfiguration {
/**
* Frequency at which GRPC stream connection is disconnected to prevent staleness.
*/
@DefaultValue("60000")
long getSingleMemberReconnectIntervalMs();
@DefaultValue("100")
long getSingleMemberInitialRetryIntervalMs();
@DefaultValue("1000")
long getSingleMemberMaxRetryIntervalMs();
@DefaultValue("30000")
long getHealthDisconnectThresholdMs();
/**
* Interval at which data from the underlying resolvers is collected and evaluated to produce a new cluster
* membership state.
*/
@DefaultValue("100")
long getMultiMemberRefreshIntervalMs();
}
| 9,807 |
0 | Create_ds/titus-control-plane/titus-common-client/src/main/java/com/netflix/titus/client/clustermembership | Create_ds/titus-control-plane/titus-common-client/src/main/java/com/netflix/titus/client/clustermembership/resolver/SingleClusterMemberResolver.java | /*
* Copyright 2019 Netflix, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.netflix.titus.client.clustermembership.resolver;
import java.time.Duration;
import java.util.Optional;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicReference;
import com.google.common.annotations.VisibleForTesting;
import com.netflix.titus.api.clustermembership.model.ClusterMember;
import com.netflix.titus.api.clustermembership.model.ClusterMemberAddress;
import com.netflix.titus.api.clustermembership.model.ClusterMemberLeadership;
import com.netflix.titus.api.clustermembership.model.ClusterMemberLeadershipState;
import com.netflix.titus.api.clustermembership.model.ClusterMembershipFunctions;
import com.netflix.titus.api.clustermembership.model.ClusterMembershipRevision;
import com.netflix.titus.api.clustermembership.model.ClusterMembershipSnapshot;
import com.netflix.titus.client.clustermembership.grpc.ClusterMembershipClient;
import com.netflix.titus.common.runtime.TitusRuntime;
import com.netflix.titus.common.util.CollectionsExt;
import com.netflix.titus.common.util.ExceptionExt;
import com.netflix.titus.common.util.closeable.CloseableReference;
import com.netflix.titus.common.util.rx.ReactorExt;
import com.netflix.titus.common.util.rx.ReactorRetriers;
import com.netflix.titus.common.util.rx.RetryHandlerBuilder;
import com.netflix.titus.common.util.time.Clock;
import com.netflix.titus.grpc.protogen.ClusterMember.LeadershipState;
import com.netflix.titus.grpc.protogen.ClusterMembershipEvent;
import com.netflix.titus.runtime.common.grpc.GrpcClientErrorUtils;
import io.grpc.Status;
import io.grpc.StatusRuntimeException;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import reactor.core.Disposable;
import reactor.core.publisher.Flux;
import reactor.core.publisher.FluxSink;
import reactor.core.publisher.Mono;
import reactor.core.publisher.ReplayProcessor;
import reactor.core.publisher.SignalType;
import reactor.core.scheduler.Schedulers;
import static com.netflix.titus.api.clustermembership.model.ClusterMembershipFunctions.hasIpAddress;
import static com.netflix.titus.client.clustermembership.grpc.ClusterMembershipGrpcConverters.toCoreClusterMember;
import static com.netflix.titus.client.clustermembership.grpc.ClusterMembershipGrpcConverters.toCoreClusterMembershipRevision;
/**
* Resolves cluster member addresses by calling a cluster membership service directly at a specified location.
*/
public class SingleClusterMemberResolver implements DirectClusterMemberResolver {
private static final Logger logger = LoggerFactory.getLogger(SingleClusterMemberResolver.class);
/**
* Not used, but must be set on the builder.
*/
private static final Duration GRPC_REQUEST_TIMEOUT = Duration.ofSeconds(1);
private final CloseableReference<ClusterMembershipClient> clientRef;
private final String name;
private final ClusterMembershipResolverConfiguration configuration;
private final ClusterMemberAddress address;
private final ClusterMemberVerifier clusterMemberVerifier;
private final Clock clock;
private final Disposable eventStreamDisposable;
private volatile String rejectedMemberError;
private volatile Optional<String> connectedToMemberId = Optional.empty();
private volatile ClusterMembershipSnapshot lastSnapshot = ClusterMembershipSnapshot.empty();
private final ReplayProcessor<ClusterMembershipSnapshot> eventProcessor = ReplayProcessor.create(1);
private final FluxSink<ClusterMembershipSnapshot> eventSink = eventProcessor.sink();
private final AtomicReference<Long> disconnectTimeRef;
public SingleClusterMemberResolver(ClusterMembershipResolverConfiguration configuration,
CloseableReference<ClusterMembershipClient> clientRef,
ClusterMemberAddress address,
ClusterMemberVerifier clusterMemberVerifier,
TitusRuntime titusRuntime) {
this.clientRef = clientRef;
this.name = "member@" + ClusterMembershipFunctions.toStringUri(address);
this.configuration = configuration;
this.address = address;
this.clusterMemberVerifier = clusterMemberVerifier;
this.clock = titusRuntime.getClock();
this.disconnectTimeRef = new AtomicReference<>(clock.wallTime());
this.eventStreamDisposable = clientRef.get().events()
.materialize()
.flatMap(signal -> {
if (signal.getType() == SignalType.ON_COMPLETE) {
logger.info("[{}] Unexpected end of stream. Converting to error to force retry...", name);
return Mono.error(new IllegalStateException(String.format("[%s] Unexpected end of stream", name)));
}
if (signal.getType() == SignalType.ON_ERROR) {
Throwable error = signal.getThrowable();
if (isConnectionDeadline(error)) {
logger.debug("[{}] Connection deadline", name, error);
} else {
logger.info("[{}] Connection terminated with an error: {}", name, GrpcClientErrorUtils.toDetailedMessage(error));
logger.debug("[{}] Stack trace", name, error);
}
disconnectTimeRef.compareAndSet(null, clock.wallTime());
return Mono.error(error);
}
if (signal.getType() == SignalType.ON_NEXT) {
ClusterMembershipEvent event = signal.get();
if (event.getEventCase() == ClusterMembershipEvent.EventCase.SNAPSHOT) {
this.rejectedMemberError = checkSnapshot(event.getSnapshot()).orElse(null);
if (rejectedMemberError != null) {
logger.error(rejectedMemberError);
return Mono.error(new IllegalStateException(rejectedMemberError));
}
}
return Mono.just(event);
}
return Mono.empty();
})
.retryWhen(ReactorRetriers.rectorPredicateRetryer(this::isConnectionDeadline))
.retryWhen(RetryHandlerBuilder.retryHandler()
.withUnlimitedRetries()
.withDelay(configuration.getSingleMemberInitialRetryIntervalMs(), configuration.getSingleMemberMaxRetryIntervalMs(), TimeUnit.MILLISECONDS)
.withReactorScheduler(Schedulers.parallel())
.buildRetryExponentialBackoff()
)
.doFinally(signal -> {
if (signal == SignalType.CANCEL) {
logger.info("[{}] Event stream canceled: address={}", name, address);
}
disconnectTimeRef.compareAndSet(null, clock.wallTime());
})
.subscribe(
next -> {
disconnectTimeRef.set(null);
processEvent(next);
},
e -> logger.warn("[{}] Event stream terminated with an error: address={}", name, address, e),
() -> logger.info("[{}] Event stream terminated: address={}", name, address)
);
}
private Optional<String> checkSnapshot(ClusterMembershipEvent.Snapshot snapshot) {
if (CollectionsExt.isNullOrEmpty(snapshot.getRevisionsList())) {
return Optional.of(String.format("[%s] Empty cluster membership list", name));
}
ClusterMember member = toCoreClusterMember(snapshot.getRevisionsList().get(0).getCurrent());
ClusterMemberVerifierResult result = clusterMemberVerifier.verify(member);
return result.isValid() ? Optional.empty() : Optional.of(result.getMessage());
}
@Override
public void shutdown() {
ReactorExt.safeDispose(eventStreamDisposable);
ExceptionExt.silent(eventSink::complete);
clientRef.close();
}
@Override
public ClusterMemberAddress getAddress() {
return address;
}
@Override
public String getPrintableName() {
return connectedToMemberId.orElse("<connecting>");
}
@Override
public boolean isHealthy() {
return disconnectTimeRef.get() == null || !clock.isPast(disconnectTimeRef.get() + configuration.getHealthDisconnectThresholdMs());
}
@Override
public ClusterMembershipSnapshot getSnapshot() {
return lastSnapshot;
}
@Override
public Flux<ClusterMembershipSnapshot> resolve() {
return eventProcessor;
}
@VisibleForTesting
String getRejectedMemberError() {
return rejectedMemberError;
}
private void processEvent(ClusterMembershipEvent next) {
ClusterMembershipSnapshot newSnapshot;
switch (next.getEventCase()) {
case SNAPSHOT:
newSnapshot = processSnapshotEvent(next.getSnapshot());
break;
case MEMBERUPDATED:
newSnapshot = processMemberUpdateEvent(next.getMemberUpdated());
break;
case MEMBERREMOVED:
newSnapshot = processMemberRemovedEvent(next.getMemberRemoved());
break;
default:
return;
}
this.lastSnapshot = newSnapshot;
if (!connectedToMemberId.isPresent()) {
newSnapshot.getMemberRevisions().values().stream()
.filter(m -> hasIpAddress(m.getCurrent(), address.getIpAddress()))
.findFirst()
.ifPresent(m -> this.connectedToMemberId = Optional.of(m.getCurrent().getMemberId()));
}
eventSink.next(lastSnapshot);
}
private ClusterMembershipSnapshot processSnapshotEvent(ClusterMembershipEvent.Snapshot snapshot) {
ClusterMembershipSnapshot.Builder builder = ClusterMembershipSnapshot.newBuilder();
snapshot.getRevisionsList().forEach(grpcRevision -> {
ClusterMembershipRevision<ClusterMember> coreRevision = toCoreClusterMembershipRevision(grpcRevision);
builder.withMemberRevisions(coreRevision);
boolean isLeader = grpcRevision.getCurrent().getLeadershipState() == LeadershipState.Leader;
if (isLeader) {
builder.withLeaderRevision(buildLeaderRevision(coreRevision));
}
});
return builder.build();
}
private ClusterMembershipSnapshot processMemberUpdateEvent(ClusterMembershipEvent.MemberUpdated memberUpdated) {
ClusterMembershipRevision<ClusterMember> memberRevision = toCoreClusterMembershipRevision(memberUpdated.getRevision());
ClusterMembershipSnapshot.Builder builder = lastSnapshot.toBuilder().withMemberRevisions(memberRevision);
String memberId = memberUpdated.getRevision().getCurrent().getMemberId();
boolean isLeader = memberUpdated.getRevision().getCurrent().getLeadershipState() == LeadershipState.Leader;
boolean previousLeader = lastSnapshot.getLeaderRevision().map(r -> r.getCurrent().getMemberId().equals(memberId)).orElse(false);
if (isLeader) {
if (!previousLeader) {
builder.withLeaderRevision(buildLeaderRevision(memberRevision));
}
} else if (previousLeader) {
builder.withLeaderRevision(null);
}
return builder.build();
}
private ClusterMembershipRevision<ClusterMemberLeadership> buildLeaderRevision(ClusterMembershipRevision<ClusterMember> memberRevision) {
return ClusterMembershipRevision.<ClusterMemberLeadership>newBuilder()
.withCurrent(ClusterMemberLeadership.newBuilder()
.withMemberId(memberRevision.getCurrent().getMemberId())
.withLeadershipState(ClusterMemberLeadershipState.Leader)
.build()
)
.withRevision(memberRevision.getRevision())
.withTimestamp(memberRevision.getTimestamp())
.build();
}
private ClusterMembershipSnapshot processMemberRemovedEvent(ClusterMembershipEvent.MemberRemoved memberRemoved) {
ClusterMembershipRevision<ClusterMember> memberRevision = toCoreClusterMembershipRevision(memberRemoved.getRevision());
ClusterMembershipSnapshot.Builder builder = lastSnapshot.toBuilder().withoutMemberRevisions(memberRevision);
String memberId = memberRemoved.getRevision().getCurrent().getMemberId();
boolean previousLeader = lastSnapshot.getLeaderRevision().map(r -> r.getCurrent().getMemberId().equals(memberId)).orElse(false);
if (previousLeader) {
builder.withLeaderRevision(null);
}
return builder.build();
}
private boolean isConnectionDeadline(Throwable error) {
if (error == null) {
return false;
}
if (!(error instanceof StatusRuntimeException)) {
return false;
}
StatusRuntimeException statusException = (StatusRuntimeException) error;
return statusException.getStatus().getCode() == Status.Code.DEADLINE_EXCEEDED;
}
}
| 9,808 |
0 | Create_ds/titus-control-plane/titus-common-client/src/main/java/com/netflix/titus/client/clustermembership | Create_ds/titus-control-plane/titus-common-client/src/main/java/com/netflix/titus/client/clustermembership/resolver/DirectClusterMemberResolver.java | /*
* Copyright 2019 Netflix, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.netflix.titus.client.clustermembership.resolver;
import com.netflix.titus.api.clustermembership.model.ClusterMemberAddress;
/**
* Supplementary interface to simplify the testing process.
*/
public interface DirectClusterMemberResolver extends ClusterMemberResolver {
ClusterMemberAddress getAddress();
String getPrintableName();
boolean isHealthy();
void shutdown();
}
| 9,809 |
0 | Create_ds/titus-control-plane/titus-common-client/src/main/java/com/netflix/titus/client/clustermembership | Create_ds/titus-control-plane/titus-common-client/src/main/java/com/netflix/titus/client/clustermembership/resolver/NameClusterMemberVerifier.java | /*
* Copyright 2022 Netflix, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.netflix.titus.client.clustermembership.resolver;
import java.util.function.Function;
import com.netflix.titus.api.clustermembership.model.ClusterMember;
import com.netflix.titus.common.util.StringExt;
public class NameClusterMemberVerifier implements ClusterMemberVerifier {
private final String expectedStackName;
private final Function<ClusterMember, String> clusterNameResolve;
public NameClusterMemberVerifier(String expectedStackName,
Function<ClusterMember, String> clusterNameResolve) {
this.expectedStackName = StringExt.safeTrim(expectedStackName);
this.clusterNameResolve = clusterNameResolve;
}
@Override
public ClusterMemberVerifierResult verify(ClusterMember clusterMember) {
if (expectedStackName.isEmpty()) {
return ClusterMemberVerifierResult.valid();
}
String stackName = clusterNameResolve.apply(clusterMember);
// Allow the null value for backward compatibility (old members data do not include their stack names).
if (stackName == null || stackName.equals(expectedStackName)) {
return ClusterMemberVerifierResult.valid();
}
return ClusterMemberVerifierResult.invalid(
String.format("Invalid member stack: expected=%s, actual=%s", expectedStackName, stackName)
);
}
public static ClusterMemberVerifier fromLabel(String expectedStackName, String labelName) {
return new NameClusterMemberVerifier(
expectedStackName,
clusterMember -> clusterMember.getLabels().get(labelName)
);
}
}
| 9,810 |
0 | Create_ds/titus-control-plane/titus-common-client/src/main/java/com/netflix/titus/client/clustermembership | Create_ds/titus-control-plane/titus-common-client/src/main/java/com/netflix/titus/client/clustermembership/resolver/ClusterMemberVerifier.java | /*
* Copyright 2020 Netflix, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.netflix.titus.client.clustermembership.resolver;
import com.netflix.titus.api.clustermembership.model.ClusterMember;
/**
* {@link ClusterMemberVerifier} verifies that a discovered cluster member belongs to the desired membership group.
* This unlikely event may happen, if an IP address is reused by another stack of the same application before the
* the state is cleaned up by the client. The client when reconnecting would connect to a newly created instance of
* the same application but in a different stack.
*/
public interface ClusterMemberVerifier {
ClusterMemberVerifierResult verify(ClusterMember clusterMember);
}
| 9,811 |
0 | Create_ds/titus-control-plane/titus-common-client/src/main/java/com/netflix/titus/client/clustermembership | Create_ds/titus-control-plane/titus-common-client/src/main/java/com/netflix/titus/client/clustermembership/resolver/EmptyClusterMembershipResolver.java | /*
* Copyright 2019 Netflix, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.netflix.titus.client.clustermembership.resolver;
import com.netflix.titus.api.clustermembership.model.ClusterMembershipSnapshot;
import reactor.core.publisher.Flux;
public class EmptyClusterMembershipResolver implements ClusterMemberResolver {
private static final ClusterMemberResolver INSTANCE = new EmptyClusterMembershipResolver();
private EmptyClusterMembershipResolver() {
}
@Override
public ClusterMembershipSnapshot getSnapshot() {
return ClusterMembershipSnapshot.empty();
}
@Override
public Flux<ClusterMembershipSnapshot> resolve() {
return Flux.just(ClusterMembershipSnapshot.empty()).concatWith(Flux.never());
}
public static ClusterMemberResolver getInstance() {
return INSTANCE;
}
}
| 9,812 |
0 | Create_ds/titus-control-plane/titus-common-client/src/main/java/com/netflix/titus/client/clustermembership | Create_ds/titus-control-plane/titus-common-client/src/main/java/com/netflix/titus/client/clustermembership/resolver/ClusterMemberResolver.java | /*
* Copyright 2019 Netflix, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.netflix.titus.client.clustermembership.resolver;
import java.io.Closeable;
import com.netflix.titus.api.clustermembership.model.ClusterMembershipSnapshot;
import reactor.core.publisher.Flux;
/**
* Provider of all known cluster members.
*/
public interface ClusterMemberResolver extends Closeable {
ClusterMembershipSnapshot getSnapshot();
/**
* Emits known cluster members, followed by updates.
*/
Flux<ClusterMembershipSnapshot> resolve();
/**
* Release resources associated with this resolver if any.
*/
@Override
default void close() {
}
}
| 9,813 |
0 | Create_ds/titus-control-plane/titus-common-client/src/main/java/com/netflix/titus/client/clustermembership | Create_ds/titus-control-plane/titus-common-client/src/main/java/com/netflix/titus/client/clustermembership/resolver/MultiNodeClusterMemberResolver.java | /*
* Copyright 2019 Netflix, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.netflix.titus.client.clustermembership.resolver;
import java.time.Duration;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;
import java.util.concurrent.TimeUnit;
import java.util.function.Function;
import java.util.function.Supplier;
import java.util.stream.Collectors;
import com.google.common.base.Preconditions;
import com.google.common.base.Stopwatch;
import com.netflix.titus.api.clustermembership.model.ClusterMember;
import com.netflix.titus.api.clustermembership.model.ClusterMemberAddress;
import com.netflix.titus.api.clustermembership.model.ClusterMemberLeadership;
import com.netflix.titus.api.clustermembership.model.ClusterMembershipRevision;
import com.netflix.titus.api.clustermembership.model.ClusterMembershipSnapshot;
import com.netflix.titus.common.framework.scheduler.ScheduleReference;
import com.netflix.titus.common.framework.scheduler.model.ScheduleDescriptor;
import com.netflix.titus.common.runtime.TitusRuntime;
import com.netflix.titus.common.util.CollectionsExt;
import com.netflix.titus.common.util.retry.Retryers;
import com.netflix.titus.common.util.rx.ReactorExt;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import reactor.core.publisher.Flux;
import reactor.core.publisher.ReplayProcessor;
/**
* {@link MultiNodeClusterMemberResolver} reads cluster membership data directly from the cluster members, by invoking
* the cluster membership API. This implementation is agnostic to a specific consistent store used to orchestrate the
* data exchange and the leader election process. If this approach is suboptimal, {@link ClusterMemberResolver}
* should be integrated directly with the underlying store.
*
* <h1>Rules for adding a member</h1>
* A new member is added if any of the conditions below is met:
* <ul>
* <ul>It is a seed node</ul>
* <ul>It is reported by a healthy member(s)</ul>
* </ul>
* <h1>Rules for removing a member</h1>
* The following rules are applied to identify a known cluster member M that should be removed. All the conditions
* must hold true for the node to be removed:
* <ul>
* <li>It is not a seed node</li>
* <li>None of the healthy cluster members reports M as a member</li>
* <li>It is not possible to connect to M for a prolonged amount of time</li>
* </ul>
* <p>
* TODO Reactive data update from the underlying sources. Now it is updated periodically on the configured schedule only.
*/
public class MultiNodeClusterMemberResolver implements ClusterMemberResolver {
private static final Logger logger = LoggerFactory.getLogger(MultiNodeClusterMemberResolver.class);
private static final ScheduleDescriptor SCHEDULE_DESCRIPTOR = ScheduleDescriptor.newBuilder()
.withName(MultiNodeClusterMemberResolver.class.getSimpleName())
.withDescription("Cluster membership resolver aggregating data from all cluster members")
.withInitialDelay(Duration.ZERO)
.withInterval(Duration.ofSeconds(1))
.withTimeout(Duration.ofSeconds(5))
.withRetryerSupplier(Retryers::never)
.withOnErrorHandler((action, error) -> {
logger.warn("Cannot update cluster membership data: {}", error.getMessage());
logger.debug(error.getMessage(), error);
})
.build();
private final Supplier<Set<ClusterMemberAddress>> seedAddressesProvider;
private final Function<ClusterMemberAddress, DirectClusterMemberResolver> directResolverFactory;
private final Function<ClusterMember, ClusterMemberAddress> addressSelector;
private final MultiNodeClusterMemberResolverMetrics metrics;
private final ConcurrentMap<String, DirectClusterMemberResolver> memberResolversByIpAddress = new ConcurrentHashMap<>();
private final ScheduleReference scheduleReference;
private volatile ClusterMembershipSnapshot lastReportedSnapshot;
private final ReplayProcessor<ClusterMembershipSnapshot> snapshotEventProcessor = ReplayProcessor.create(1);
private final Flux<ClusterMembershipSnapshot> snapshotEventObservable = snapshotEventProcessor
.distinctUntilChanged()
.onBackpressureError()
.transformDeferred(ReactorExt.badSubscriberHandler(logger));
public MultiNodeClusterMemberResolver(String serviceName,
ClusterMembershipResolverConfiguration configuration,
Supplier<Set<ClusterMemberAddress>> seedAddressesProvider,
Function<ClusterMemberAddress, DirectClusterMemberResolver> directResolverFactory,
Function<ClusterMember, ClusterMemberAddress> addressSelector,
TitusRuntime titusRuntime) {
this.seedAddressesProvider = seedAddressesProvider;
this.directResolverFactory = directResolverFactory;
this.addressSelector = addressSelector;
this.metrics = new MultiNodeClusterMemberResolverMetrics(serviceName, titusRuntime);
this.scheduleReference = titusRuntime.getLocalScheduler().schedule(
SCHEDULE_DESCRIPTOR.toBuilder()
.withInterval(Duration.ofMillis(configuration.getMultiMemberRefreshIntervalMs()))
.build(),
context -> {
Stopwatch stopwatch = Stopwatch.createStarted();
refresh();
ClusterMembershipSnapshot newSnapshot = getSnapshot();
report(newSnapshot);
snapshotEventProcessor.onNext(newSnapshot);
logger.debug("Refreshed data in {}ms", stopwatch.elapsed(TimeUnit.MILLISECONDS));
},
false
);
}
@Override
public void close() {
scheduleReference.cancel();
}
/**
* Returns cluster membership snapshot computed from data provided by all connected and healthy members.
*/
@Override
public ClusterMembershipSnapshot getSnapshot() {
// Each cluster member should be reported by each resolver.
return buildSnapshot();
}
@Override
public Flux<ClusterMembershipSnapshot> resolve() {
return snapshotEventObservable;
}
private List<DirectClusterMemberResolver> findHealthyMembers() {
return memberResolversByIpAddress.values().stream().filter(DirectClusterMemberResolver::isHealthy).collect(Collectors.toList());
}
private List<ClusterMembershipSnapshot> findHealthySnapshots() {
return findHealthyMembers().stream().map(DirectClusterMemberResolver::getSnapshot).collect(Collectors.toList());
}
private ClusterMembershipSnapshot buildSnapshot() {
if (memberResolversByIpAddress.isEmpty()) {
return ClusterMembershipSnapshot.empty();
}
List<ClusterMembershipSnapshot> healthySnapshots = findHealthySnapshots();
ClusterMembershipSnapshot.Builder builder = ClusterMembershipSnapshot.newBuilder();
Map<String, List<ClusterMembershipRevision<ClusterMember>>> grouped = healthySnapshots.stream()
.flatMap(snapshot -> snapshot.getMemberRevisions().values().stream())
.collect(Collectors.groupingBy(m -> m.getCurrent().getMemberId()));
List<ClusterMembershipRevision<ClusterMember>> recentRevisions = grouped.values().stream()
.map(this::findBestMemberRevision)
.collect(Collectors.toList());
builder.withMemberRevisions(recentRevisions);
// Find leader
ClusterMembershipRevision<ClusterMemberLeadership> latestLeader = null;
for (ClusterMembershipSnapshot snapshot : healthySnapshots) {
ClusterMembershipRevision<ClusterMemberLeadership> snapshotLeader = snapshot.getLeaderRevision().orElse(null);
if (snapshotLeader != null) {
if (latestLeader != null) {
if(latestLeader.getCurrent().getMemberId().equals(snapshotLeader.getCurrent().getMemberId())) {
latestLeader = latestLeader.getRevision() < snapshotLeader.getRevision() ? snapshotLeader : latestLeader;
} else {
latestLeader = latestLeader.getTimestamp() < snapshotLeader.getTimestamp() ? snapshotLeader : latestLeader;
}
} else {
latestLeader = snapshotLeader;
}
}
}
if(latestLeader != null) {
builder.withLeaderRevision(latestLeader);
}
// Choose latest version of each
long minStaleness = healthySnapshots.stream()
.mapToLong(ClusterMembershipSnapshot::getStalenessMs)
.min()
.orElse(0);
builder.withStalenessMs(minStaleness);
return builder.build();
}
private ClusterMembershipRevision<ClusterMember> findBestMemberRevision(List<ClusterMembershipRevision<ClusterMember>> singleMemberVersions) {
Preconditions.checkArgument(singleMemberVersions.size() > 0);
Iterator<ClusterMembershipRevision<ClusterMember>> it = singleMemberVersions.iterator();
ClusterMembershipRevision<ClusterMember> best = it.next();
while (it.hasNext()) {
ClusterMembershipRevision<ClusterMember> next = it.next();
if (next.getRevision() > best.getRevision()) {
best = next;
}
}
return best;
}
private void refresh() {
// Always first add missing seed nodes.
addNewSeeds();
ClusterMembershipSnapshot resolvedSnapshot = buildSnapshot();
// If no members, we cannot make any progress, so exit.
if (resolvedSnapshot.getMemberRevisions().isEmpty()) {
Set<String> toRemove = memberResolversByIpAddress.keySet().stream().filter(ip -> !isSeedIp(ip)).collect(Collectors.toSet());
disconnectTerminatedMembers(toRemove);
logger.debug("Cannot connect to any cluster member. Known members: {}", toResolvedMembersString());
return;
}
// As IP address can be reused take always more recent record first.
Map<String, ClusterMembershipRevision<ClusterMember>> resolvedMembersByIp = new HashMap<>();
resolvedSnapshot.getMemberRevisions().forEach((memberId, revision) -> {
String ipAddress = addressSelector.apply(revision.getCurrent()).getIpAddress();
ClusterMembershipRevision<ClusterMember> previous = resolvedMembersByIp.get(ipAddress);
if (previous == null || previous.getTimestamp() < revision.getTimestamp()) {
resolvedMembersByIp.put(ipAddress, revision);
}
});
// Find terminated members.
Set<String> toRemove = memberResolversByIpAddress.keySet().stream()
.filter(ip -> !resolvedMembersByIp.containsKey(ip) && !isSeedIp(ip))
.collect(Collectors.toSet());
disconnectTerminatedMembers(toRemove);
// Find new members that we should connect to.
Set<String> toAdd = resolvedMembersByIp.keySet().stream()
.filter(ip -> !memberResolversByIpAddress.containsKey(ip))
.collect(Collectors.toSet());
connectNewMembers(resolvedMembersByIp, toAdd);
}
private void connectNewMembers(Map<String, ClusterMembershipRevision<ClusterMember>> resolvedMembersByIp, Set<String> toAdd) {
if (!toAdd.isEmpty()) {
logger.info("Connecting to the new cluster members: {}", toAdd);
toAdd.forEach(ip -> memberResolversByIpAddress.put(
ip,
directResolverFactory.apply(addressSelector.apply(resolvedMembersByIp.get(ip).getCurrent())))
);
}
}
private void disconnectTerminatedMembers(Set<String> toRemove) {
if (!toRemove.isEmpty()) {
// Closing connection usually will happen some time after the member was removed from the membership
// group, as the seed provider may still advertise it for some time. For example Eureka has up to 90sec
// propagation delay.
logger.info("Closing connection to the terminated cluster members: {}", toRemove);
toRemove.forEach(ip -> {
DirectClusterMemberResolver removed = memberResolversByIpAddress.remove(ip);
if (removed != null) {
removed.shutdown();
}
});
}
}
private void addNewSeeds() {
Set<ClusterMemberAddress> seeds = seedAddressesProvider.get();
Map<String, ClusterMemberAddress> seedsByIps = seeds.stream().collect(Collectors.toMap(ClusterMemberAddress::getIpAddress, m -> m));
Set<String> toAdd = CollectionsExt.copyAndRemove(seedsByIps.keySet(), memberResolversByIpAddress.keySet());
if (!toAdd.isEmpty()) {
logger.info("Discovered new seed nodes with IPs: {}", toAdd);
toAdd.forEach(ip -> memberResolversByIpAddress.put(ip, directResolverFactory.apply(seedsByIps.get(ip))));
}
}
private boolean isSeedIp(String ipAddress) {
Optional<ClusterMemberAddress> seedAddress = seedAddressesProvider.get().stream().filter(a -> a.getIpAddress().equals(ipAddress)).findFirst();
return seedAddress.isPresent();
}
private String toResolvedMembersString() {
return String.format("[%s]",
memberResolversByIpAddress.values().stream()
.map(m -> m.getPrintableName() + '@' + m.getAddress().getIpAddress())
.collect(Collectors.joining(", "))
);
}
private void report(ClusterMembershipSnapshot newSnapshot) {
if (lastReportedSnapshot == null) {
newSnapshot.getMemberRevisions().forEach((memberId, revision) -> {
logger.info("Discovered new cluster member: id={}, addresses={}", memberId, revision.getCurrent().getClusterMemberAddresses());
});
if (newSnapshot.getLeaderRevision().isPresent()) {
logger.info("Cluster leader is {}", newSnapshot.getLeaderRevision().get().getCurrent().getMemberId());
} else {
logger.info("No leader yet");
}
} else {
Map<String, ClusterMembershipRevision<ClusterMember>> previousRevisions = lastReportedSnapshot.getMemberRevisions();
newSnapshot.getMemberRevisions().forEach((memberId, revision) -> {
if (!previousRevisions.containsKey(memberId)) {
logger.info("Discovered new cluster member: id={}, addresses={}", memberId, revision.getCurrent().getClusterMemberAddresses());
}
});
lastReportedSnapshot.getMemberRevisions().forEach((memberId, previousRevision) -> {
if (!newSnapshot.getMemberRevisions().containsKey(memberId)) {
logger.info("Removed cluster member: {}", memberId);
}
});
if (lastReportedSnapshot.getLeaderRevision().isPresent()) {
ClusterMemberLeadership previousLeader = lastReportedSnapshot.getLeaderRevision().get().getCurrent();
if (newSnapshot.getLeaderRevision().isPresent()) {
ClusterMemberLeadership newLeader = newSnapshot.getLeaderRevision().get().getCurrent();
if (!newLeader.getMemberId().equals(previousLeader.getMemberId())) {
logger.info("Leader changed from {} to {}", previousLeader.getMemberId(), newLeader.getMemberId());
}
} else {
logger.info("{} is no longer leader, and no new leader is re-elected yet", previousLeader.getMemberId());
}
} else if (newSnapshot.getLeaderRevision().isPresent()) {
logger.info("Cluster leader is {}", newSnapshot.getLeaderRevision().get().getCurrent().getMemberId());
}
}
metrics.updateConnectedMembers(memberResolversByIpAddress);
metrics.updateSnapshot(newSnapshot);
this.lastReportedSnapshot = newSnapshot;
}
}
| 9,814 |
0 | Create_ds/titus-control-plane/titus-server-federation/src/test/java/com/netflix/titus/federation/endpoint | Create_ds/titus-control-plane/titus-server-federation/src/test/java/com/netflix/titus/federation/endpoint/rest/FederationSchedulerSpringResourceTest.java | /*
* Copyright 2020 Netflix, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.netflix.titus.federation.endpoint.rest;
import com.netflix.titus.federation.service.AggregatingSchedulerService;
import com.netflix.titus.grpc.protogen.SchedulingResultEvent;
import com.netflix.titus.testkit.junit.spring.SpringMockMvcUtil;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.autoconfigure.web.servlet.WebMvcTest;
import org.springframework.boot.test.mock.mockito.MockBean;
import org.springframework.http.converter.protobuf.ProtobufHttpMessageConverter;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringRunner;
import org.springframework.test.web.servlet.MockMvc;
import reactor.core.publisher.Mono;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.Mockito.when;
@RunWith(SpringRunner.class)
@WebMvcTest()
@ContextConfiguration(classes = {FederationSchedulerSpringResource.class, ProtobufHttpMessageConverter.class})
public class FederationSchedulerSpringResourceTest {
private static final SchedulingResultEvent EVENT = SchedulingResultEvent.newBuilder()
.setSuccess(SchedulingResultEvent.Success.newBuilder().setMessage("Success!").build())
.build();
@MockBean
protected AggregatingSchedulerService serviceMock;
@Autowired
private MockMvc mockMvc;
@Test
public void testFindLastSchedulingResult() throws Exception {
when(serviceMock.findLastSchedulingResult("taskAbc")).thenReturn(Mono.just(EVENT));
SchedulingResultEvent entity = SpringMockMvcUtil.doGet(mockMvc, "/api/v3/scheduler/results/taskAbc", SchedulingResultEvent.class);
assertThat(entity).isEqualTo(EVENT);
}
} | 9,815 |
0 | Create_ds/titus-control-plane/titus-server-federation/src/test/java/com/netflix/titus/federation/endpoint | Create_ds/titus-control-plane/titus-server-federation/src/test/java/com/netflix/titus/federation/endpoint/rest/FederationV2CapacityGroupResourceTest.java | /*
* Copyright 2019 Netflix, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.netflix.titus.federation.endpoint.rest;
import java.io.IOException;
import java.util.Collections;
import java.util.List;
import java.util.Map;
import javax.ws.rs.WebApplicationException;
import javax.ws.rs.core.HttpHeaders;
import javax.ws.rs.core.MediaType;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.google.common.collect.ImmutableMap;
import com.netflix.titus.api.endpoint.v2.rest.representation.ApplicationSlaRepresentation;
import com.netflix.titus.api.federation.model.Cell;
import com.netflix.titus.api.json.ObjectMappers;
import com.netflix.titus.api.model.ApplicationSLA;
import com.netflix.titus.common.util.ExceptionExt;
import com.netflix.titus.common.util.archaius2.Archaius2Ext;
import com.netflix.titus.federation.endpoint.EndpointConfiguration;
import com.netflix.titus.federation.service.CellWebClientConnector;
import com.netflix.titus.testkit.data.core.ApplicationSlaSample;
import okhttp3.mockwebserver.Dispatcher;
import okhttp3.mockwebserver.MockResponse;
import okhttp3.mockwebserver.MockWebServer;
import okhttp3.mockwebserver.RecordedRequest;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import org.mockito.Mockito;
import org.springframework.web.reactive.function.client.WebClient;
import static com.netflix.titus.federation.endpoint.rest.FederationV2CapacityGroupResource.API_PATH;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.Mockito.when;
public class FederationV2CapacityGroupResourceTest {
private static final ApplicationSLA CELL_1_CAPACITY_GROUP = ApplicationSlaSample.CriticalLarge.build();
private static final ApplicationSLA CELL_2_CAPACITY_GROUP = ApplicationSlaSample.CriticalSmall.build();
private static final Cell CELL_1 = new Cell("cell1", "hostname1:7001");
private static final Cell CELL_2 = new Cell("cell2", "hostname1:7001");
private MockWebServer cell1Server = new MockWebServer();
private MockWebServer cell2Server = new MockWebServer();
private final CellWebClientConnector webClientConnector = Mockito.mock(CellWebClientConnector.class);
private final FederationV2CapacityGroupResource resource = new FederationV2CapacityGroupResource(
Archaius2Ext.newConfiguration(EndpointConfiguration.class),
webClientConnector
);
@Before
public void setUp() throws Exception {
cell1Server.setDispatcher(newDispatcher(CELL_1_CAPACITY_GROUP));
cell2Server.setDispatcher(newDispatcher(CELL_2_CAPACITY_GROUP));
cell1Server.start();
cell2Server.start();
Map<Cell, WebClient> cellWebClients = ImmutableMap.of(
CELL_1, WebClient.builder().baseUrl(cell1Server.url("/").toString()).build(),
CELL_2, WebClient.builder().baseUrl(cell1Server.url("/").toString()).build()
);
when(webClientConnector.getWebClients()).thenReturn(cellWebClients);
}
@After
public void tearDown() {
ExceptionExt.silent(() -> cell1Server.shutdown());
ExceptionExt.silent(() -> cell2Server.shutdown());
}
@Test
public void testGetCapacityGroup() {
ApplicationSlaRepresentation result = resource.getApplicationSLA(CELL_1_CAPACITY_GROUP.getAppName(), false);
assertThat(result).isNotNull();
}
@Test
public void testGetCapacityGroupNotFound() {
try {
resource.getApplicationSLA("myFakeCapacityGroup", false);
} catch (WebApplicationException e) {
assertThat(e.getResponse().getStatus()).isEqualTo(404);
}
}
@Test
public void testGetCapacityGroupSystemError() throws IOException {
cell1Server.shutdown();
try {
resource.getApplicationSLA("myFakeCapacityGroup", false);
} catch (WebApplicationException e) {
assertThat(e.getResponse().getStatus()).isEqualTo(500);
}
}
@Test
public void testGetCapacityGroups() {
List<ApplicationSlaRepresentation> result = resource.getApplicationSLAs(false);
assertThat(result).isNotNull();
assertThat(result).hasSize(2);
}
@Test
public void testGetCapacityGroupsSystemError() throws IOException {
cell1Server.shutdown();
try {
resource.getApplicationSLAs(false);
} catch (WebApplicationException e) {
assertThat(e.getResponse().getStatus()).isEqualTo(500);
}
}
private Dispatcher newDispatcher(ApplicationSLA capacityGroup) {
return new Dispatcher() {
@Override
public MockResponse dispatch(RecordedRequest request) throws InterruptedException {
if (request.getPath().equals(API_PATH + "?extended=false")) {
return newMockGetResult(Collections.singletonList(capacityGroup));
}
if (request.getPath().equals(API_PATH + '/' + capacityGroup.getAppName() + "?extended=false")) {
return newMockGetResult(capacityGroup);
}
return new MockResponse().setResponseCode(404);
}
};
}
private <T> MockResponse newMockGetResult(T body) {
try {
return new MockResponse()
.setResponseCode(200)
.setHeader(HttpHeaders.CONTENT_TYPE, MediaType.APPLICATION_JSON)
.setBody(ObjectMappers.storeMapper().writeValueAsString(body));
} catch (JsonProcessingException e) {
throw new IllegalArgumentException(e);
}
}
} | 9,816 |
0 | Create_ds/titus-control-plane/titus-server-federation/src/test/java/com/netflix/titus/federation | Create_ds/titus-control-plane/titus-server-federation/src/test/java/com/netflix/titus/federation/service/CellInfoUtilTest.java | /*
* Copyright 2018 Netflix, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.netflix.titus.federation.service;
import java.util.Collections;
import java.util.List;
import java.util.Map;
import com.netflix.titus.api.federation.model.Cell;
import org.junit.Test;
import static org.assertj.core.api.Assertions.assertThat;
public class CellInfoUtilTest {
@Test
public void checkTwoCellSpecifications() {
String cellsSpec = "cell1=hostName1:7001;cell2=hostName2:7002";
List<Cell> cells = CellInfoUtil.extractCellsFromCellSpecification(cellsSpec);
assertThat(cells).isNotNull();
assertThat(cells.size()).isEqualTo(2);
assertThat(cells.get(0).getAddress()).isEqualTo("hostName1:7001");
assertThat(cells.get(1).getAddress()).isEqualTo("hostName2:7002");
}
@Test
public void checkSingleCellSpecifications() {
String cellsSpec = "cell1=hostName1:7001";
List<Cell> cells = CellInfoUtil.extractCellsFromCellSpecification(cellsSpec);
assertThat(cells).isNotNull();
assertThat(cells.size()).isEqualTo(1);
assertThat(cells.get(0).getAddress()).isEqualTo("hostName1:7001");
}
@Test
public void checkEmptyCellSpecifications() {
String cellsSpec = "";
List<Cell> cells = CellInfoUtil.extractCellsFromCellSpecification(cellsSpec);
assertThat(cells).isNotNull();
assertThat(cells.size()).isEqualTo(0);
}
@Test
public void duplicatedRoutingRulesAreIgnored() {
Cell cell = new Cell("cell1", "1");
String cellsSpec = "cell1=(app1.*);cell1=(app2.*)";
Map<Cell, String> routingRules = CellInfoUtil.extractCellRoutingFromCellSpecification(
Collections.singletonList(cell), cellsSpec
);
assertThat(routingRules).isNotNull();
assertThat(routingRules).hasSize(1);
// second value got ignored
assertThat(routingRules.get(cell)).isEqualTo("(app1.*)");
}
}
| 9,817 |
0 | Create_ds/titus-control-plane/titus-server-federation/src/test/java/com/netflix/titus/federation | Create_ds/titus-control-plane/titus-server-federation/src/test/java/com/netflix/titus/federation/service/CellWithFailingLoadBalancers.java | /*
* Copyright 2018 Netflix, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.netflix.titus.federation.service;
import com.google.protobuf.Empty;
import com.netflix.titus.grpc.protogen.AddLoadBalancerRequest;
import com.netflix.titus.grpc.protogen.GetAllLoadBalancersRequest;
import com.netflix.titus.grpc.protogen.GetAllLoadBalancersResult;
import com.netflix.titus.grpc.protogen.GetJobLoadBalancersResult;
import com.netflix.titus.grpc.protogen.JobId;
import com.netflix.titus.grpc.protogen.LoadBalancerServiceGrpc;
import com.netflix.titus.grpc.protogen.RemoveLoadBalancerRequest;
import io.grpc.Status;
import io.grpc.stub.StreamObserver;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
class CellWithFailingLoadBalancers extends LoadBalancerServiceGrpc.LoadBalancerServiceImplBase {
private static final Logger logger = LoggerFactory.getLogger(CellWithFailingLoadBalancers.class);
private Status errorStatus;
CellWithFailingLoadBalancers(Status errorStatus) {
this.errorStatus = errorStatus;
}
@Override
public void getJobLoadBalancers(JobId request, StreamObserver<GetJobLoadBalancersResult> responseObserver) {
responseObserver.onError(errorStatus.asRuntimeException());
}
@Override
public void getAllLoadBalancers(GetAllLoadBalancersRequest request, StreamObserver<GetAllLoadBalancersResult> responseObserver) {
responseObserver.onError(errorStatus.asRuntimeException());
}
@Override
public void addLoadBalancer(AddLoadBalancerRequest request, StreamObserver<Empty> responseObserver) {
responseObserver.onError(errorStatus.asRuntimeException());
}
@Override
public void removeLoadBalancer(RemoveLoadBalancerRequest request, StreamObserver<Empty> responseObserver) {
responseObserver.onError(errorStatus.asRuntimeException());
}
}
| 9,818 |
0 | Create_ds/titus-control-plane/titus-server-federation/src/test/java/com/netflix/titus/federation | Create_ds/titus-control-plane/titus-server-federation/src/test/java/com/netflix/titus/federation/service/AggregatingJobServiceGatewayTest.java | /*
* Copyright 2018 Netflix, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.netflix.titus.federation.service;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.Random;
import java.util.UUID;
import java.util.concurrent.TimeUnit;
import java.util.stream.Collectors;
import java.util.stream.Stream;
import com.google.common.collect.ImmutableMap;
import com.google.common.collect.Iterables;
import com.netflix.titus.api.federation.model.Cell;
import com.netflix.titus.api.jobmanager.service.JobManagerConstants;
import com.netflix.titus.api.model.Page;
import com.netflix.titus.api.service.TitusServiceException;
import com.netflix.titus.common.runtime.TitusRuntime;
import com.netflix.titus.common.runtime.TitusRuntimes;
import com.netflix.titus.common.util.CollectionsExt;
import com.netflix.titus.common.util.event.EventPropagationUtil;
import com.netflix.titus.common.util.time.Clocks;
import com.netflix.titus.common.util.time.TestClock;
import com.netflix.titus.common.util.tuple.Pair;
import com.netflix.titus.federation.service.router.ApplicationCellRouter;
import com.netflix.titus.federation.startup.GrpcConfiguration;
import com.netflix.titus.federation.startup.TitusFederationConfiguration;
import com.netflix.titus.grpc.protogen.Capacity;
import com.netflix.titus.grpc.protogen.Job;
import com.netflix.titus.grpc.protogen.JobCapacityUpdate;
import com.netflix.titus.grpc.protogen.JobChangeNotification;
import com.netflix.titus.grpc.protogen.JobChangeNotification.JobUpdate;
import com.netflix.titus.grpc.protogen.JobChangeNotification.SnapshotEnd;
import com.netflix.titus.grpc.protogen.JobChangeNotification.TaskUpdate;
import com.netflix.titus.grpc.protogen.JobDescriptor;
import com.netflix.titus.grpc.protogen.JobId;
import com.netflix.titus.grpc.protogen.JobManagementServiceGrpc;
import com.netflix.titus.grpc.protogen.JobManagementServiceGrpc.JobManagementServiceStub;
import com.netflix.titus.grpc.protogen.JobQuery;
import com.netflix.titus.grpc.protogen.JobQueryResult;
import com.netflix.titus.grpc.protogen.JobStatus;
import com.netflix.titus.grpc.protogen.ObserveJobsQuery;
import com.netflix.titus.grpc.protogen.Task;
import com.netflix.titus.grpc.protogen.TaskKillRequest;
import com.netflix.titus.grpc.protogen.TaskQuery;
import com.netflix.titus.grpc.protogen.TaskQueryResult;
import com.netflix.titus.runtime.endpoint.v3.grpc.GrpcJobManagementModelConverters;
import com.netflix.titus.runtime.jobmanager.JobManagerCursors;
import com.netflix.titus.testkit.grpc.TestStreamObserver;
import io.grpc.Status;
import io.grpc.StatusRuntimeException;
import io.grpc.testing.GrpcServerRule;
import org.junit.After;
import org.junit.Before;
import org.junit.Rule;
import org.junit.Test;
import org.junit.jupiter.api.BeforeEach;
import rx.observers.AssertableSubscriber;
import rx.subjects.PublishSubject;
import static com.netflix.titus.api.jobmanager.JobAttributes.JOB_ATTRIBUTES_CELL;
import static com.netflix.titus.api.jobmanager.JobAttributes.JOB_ATTRIBUTES_STACK;
import static com.netflix.titus.api.jobmanager.service.JobManagerConstants.UNDEFINED_CALL_METADATA;
import static com.netflix.titus.federation.service.ServiceTests.walkAllPages;
import static com.netflix.titus.runtime.endpoint.v3.grpc.GrpcJobQueryModelConverters.toGrpcPage;
import static io.grpc.Status.DEADLINE_EXCEEDED;
import static io.grpc.Status.INTERNAL;
import static io.grpc.Status.NOT_FOUND;
import static io.grpc.Status.UNAVAILABLE;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatCode;
import static org.mockito.Mockito.any;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
public class AggregatingJobServiceGatewayTest {
private static final JobStatus ACCEPTED_STATE = JobStatus.newBuilder().setState(JobStatus.JobState.Accepted).build();
private static final JobStatus KILL_INITIATED_STATE = JobStatus.newBuilder().setState(JobStatus.JobState.KillInitiated).build();
private static final JobStatus FINISHED_STATE = JobStatus.newBuilder().setState(JobStatus.JobState.Finished).build();
private static final int TASKS_IN_GENERATED_JOBS = 10;
private static final long GRPC_REQUEST_TIMEOUT_MS = 1_000L;
private static final long GRPC_PRIMARY_FALLBACK_TIMEOUT_MS = 100L;
private final TitusRuntime titusRuntime = TitusRuntimes.internal();
@Rule
public GrpcServerRule remoteFederationRule = new GrpcServerRule().directExecutor();
@Rule
public final GrpcServerRule cellOne = new GrpcServerRule().directExecutor();
private final PublishSubject<JobChangeNotification> cellOneUpdates = PublishSubject.create();
@Rule
public final GrpcServerRule cellTwo = new GrpcServerRule().directExecutor();
private final PublishSubject<JobChangeNotification> cellTwoUpdates = PublishSubject.create();
private final TitusFederationConfiguration titusFederationConfiguration = mock(TitusFederationConfiguration.class);
private String stackName;
private AggregatingJobServiceGateway service;
private List<Cell> cells;
private Map<Cell, GrpcServerRule> cellToServiceMap;
private TestClock clock;
private ServiceDataGenerator dataGenerator;
@Before
public void setUp() {
stackName = UUID.randomUUID().toString();
GrpcConfiguration grpcConfiguration = mock(GrpcConfiguration.class);
when(grpcConfiguration.getRequestTimeoutMs()).thenReturn(GRPC_REQUEST_TIMEOUT_MS);
when(grpcConfiguration.getPrimaryFallbackTimeoutMs()).thenReturn(GRPC_PRIMARY_FALLBACK_TIMEOUT_MS);
when(titusFederationConfiguration.getStack()).thenReturn(stackName);
when(titusFederationConfiguration.getCells()).thenReturn("one=1;two=2");
when(titusFederationConfiguration.getRoutingRules()).thenReturn("one=(app1.*|app2.*);two=(app3.*)");
CellInfoResolver cellInfoResolver = new DefaultCellInfoResolver(titusFederationConfiguration);
ApplicationCellRouter cellRouter = new ApplicationCellRouter(cellInfoResolver, titusFederationConfiguration);
cells = cellInfoResolver.resolve();
cellToServiceMap = ImmutableMap.of(
cells.get(0), cellOne,
cells.get(1), cellTwo
);
RemoteFederationConnector fedConnector = mock(RemoteFederationConnector.class);
when(fedConnector.getChannel()).thenReturn(remoteFederationRule.getChannel());
CellConnector cellConnector = mock(CellConnector.class);
when(cellConnector.getChannels()).thenReturn(cellToServiceMap.entrySet().stream()
.collect(Collectors.toMap(Map.Entry::getKey, cellPairEntry -> cellPairEntry.getValue().getChannel()))
);
when(cellConnector.getChannelForCell(any(Cell.class))).thenAnswer(invocation ->
Optional.ofNullable(cellToServiceMap.get(invocation.<Cell>getArgument(0)))
.map(GrpcServerRule::getChannel)
);
final AggregatingCellClient aggregatingCellClient = new AggregatingCellClient(cellConnector);
service = new AggregatingJobServiceGateway(
grpcConfiguration,
titusFederationConfiguration,
cellConnector,
cellRouter,
aggregatingCellClient,
new AggregatingJobManagementServiceHelper(aggregatingCellClient, grpcConfiguration),
titusRuntime
);
clock = Clocks.test();
dataGenerator = new ServiceDataGenerator(clock, TASKS_IN_GENERATED_JOBS);
}
@After
public void tearDown() {
cellOneUpdates.onCompleted();
cellTwoUpdates.onCompleted();
}
@BeforeEach
public void beforeEach() {
when(titusFederationConfiguration.isRemoteFederationEnabled()).thenReturn(false);
}
@Test
public void findJobsMergesAllCellsIntoSingleResult() {
Random random = new Random();
final List<Job> cellOneSnapshot = new ArrayList<>();
final List<Job> cellTwoSnapshot = new ArrayList<>();
for (int i = 0; i < 5; i++) {
cellOneSnapshot.addAll(
dataGenerator.newBatchJobs(random.nextInt(10), GrpcJobManagementModelConverters::toGrpcJob)
);
cellTwoSnapshot.addAll(
dataGenerator.newBatchJobs(random.nextInt(10), GrpcJobManagementModelConverters::toGrpcJob)
);
cellOneSnapshot.addAll(
dataGenerator.newServiceJobs(random.nextInt(10), GrpcJobManagementModelConverters::toGrpcJob)
);
cellTwoSnapshot.addAll(
dataGenerator.newServiceJobs(random.nextInt(10), GrpcJobManagementModelConverters::toGrpcJob)
);
clock.advanceTime(1, TimeUnit.MINUTES);
}
cellOne.getServiceRegistry().addService(new CellWithFixedJobsService(cellOneSnapshot, cellOneUpdates.serialize()));
cellTwo.getServiceRegistry().addService(new CellWithFixedJobsService(cellTwoSnapshot, cellTwoUpdates.serialize()));
JobQuery query = JobQuery.newBuilder()
.setPage(toGrpcPage(Page.unlimited()))
.build();
final AssertableSubscriber<JobQueryResult> testSubscriber = service.findJobs(query, UNDEFINED_CALL_METADATA).test();
testSubscriber.awaitTerminalEvent(1, TimeUnit.SECONDS);
testSubscriber.assertNoErrors().assertCompleted();
testSubscriber.assertValueCount(1);
final List<JobQueryResult> results = testSubscriber.getOnNextEvents();
assertThat(results).hasSize(1);
// expect stackName to have changed
List<Job> expected = Stream.concat(cellOneSnapshot.stream(), cellTwoSnapshot.stream())
.sorted(JobManagerCursors.jobCursorOrderComparator())
.map(this::withStackName)
.collect(Collectors.toList());
assertThat(results.get(0).getItemsList()).containsExactlyElementsOf(expected);
}
@Test
public void findJobsEmptyPage() {
Random random = new Random();
final List<Job> cellOneSnapshot = new ArrayList<>();
final List<Job> cellTwoSnapshot = new ArrayList<>();
for (int i = 0; i < 5; i++) {
Iterables.addAll(cellOneSnapshot, Iterables.concat(
dataGenerator.newBatchJobs(random.nextInt(10), GrpcJobManagementModelConverters::toGrpcJob),
dataGenerator.newServiceJobs(random.nextInt(10), GrpcJobManagementModelConverters::toGrpcJob)
));
Iterables.addAll(cellTwoSnapshot, Iterables.concat(
dataGenerator.newBatchJobs(random.nextInt(10), GrpcJobManagementModelConverters::toGrpcJob),
dataGenerator.newServiceJobs(random.nextInt(10), GrpcJobManagementModelConverters::toGrpcJob)
));
clock.advanceTime(1, TimeUnit.MINUTES);
}
cellOne.getServiceRegistry().addService(new CellWithFixedJobsService(cellOneSnapshot, cellOneUpdates.serialize()));
cellTwo.getServiceRegistry().addService(new CellWithFixedJobsService(cellTwoSnapshot, cellTwoUpdates.serialize()));
JobQuery query = JobQuery.newBuilder()
.setPage(toGrpcPage(Page.empty()))
.build();
final AssertableSubscriber<JobQueryResult> testSubscriber = service.findJobs(query, UNDEFINED_CALL_METADATA).test();
testSubscriber.awaitTerminalEvent(1, TimeUnit.SECONDS);
testSubscriber.assertNoErrors().assertCompleted();
testSubscriber.assertValueCount(1);
final List<JobQueryResult> results = testSubscriber.getOnNextEvents();
assertThat(results).hasSize(1);
assertThat(results.get(0).getItemsList()).isEmpty();
assertThat(results.get(0).getPagination().getHasMore()).isFalse();
}
@Test
public void findJobsWithCursorPagination() {
Pair<List<Job>, List<Job>> cellSnapshots = generateTestJobs();
List<Job> allJobs = walkAllFindJobsPages(10);
assertThat(allJobs).hasSize(cellSnapshots.getLeft().size() + cellSnapshots.getRight().size());
// expect stackName to have changed
List<Job> expected = Stream.concat(cellSnapshots.getLeft().stream(), cellSnapshots.getRight().stream())
.sorted(JobManagerCursors.jobCursorOrderComparator())
.map(this::withStackName)
.collect(Collectors.toList());
assertThat(allJobs).containsExactlyElementsOf(expected);
}
/**
* Ensure that all items are still walked, even when pageSizes is smaller than the number of Cells. In other words,
* make sure that the federation proxy is constantly alternating items to be returning from each Cell.
*/
@Test
public void findJobsWithSmallPageSizes() {
final List<Job> cellOneSnapshot = new ArrayList<>();
final List<Job> cellTwoSnapshot = new ArrayList<>();
for (int i = 0; i < 5; i++) {
clock.advanceTime(1, TimeUnit.SECONDS);
cellOneSnapshot.addAll(dataGenerator.newBatchJobs(5, GrpcJobManagementModelConverters::toGrpcJob));
clock.advanceTime(1, TimeUnit.SECONDS);
cellTwoSnapshot.addAll(dataGenerator.newServiceJobs(5, GrpcJobManagementModelConverters::toGrpcJob));
clock.advanceTime(1, TimeUnit.SECONDS);
cellTwoSnapshot.addAll(dataGenerator.newBatchJobs(5, GrpcJobManagementModelConverters::toGrpcJob));
clock.advanceTime(1, TimeUnit.SECONDS);
cellTwoSnapshot.addAll(dataGenerator.newServiceJobs(5, GrpcJobManagementModelConverters::toGrpcJob));
}
cellOne.getServiceRegistry().addService(new CellWithFixedJobsService(cellOneSnapshot, cellOneUpdates.serialize()));
cellTwo.getServiceRegistry().addService(new CellWithFixedJobsService(cellTwoSnapshot, cellTwoUpdates.serialize()));
List<Job> allJobs = walkAllFindJobsPages(1);
assertThat(allJobs).hasSize(cellOneSnapshot.size() + cellTwoSnapshot.size());
// expect stackName to have changed
List<Job> expected = CollectionsExt.merge(cellOneSnapshot, cellTwoSnapshot).stream()
.sorted(JobManagerCursors.jobCursorOrderComparator())
.map(this::withStackName)
.collect(Collectors.toList());
assertThat(allJobs).containsExactlyElementsOf(expected);
}
/**
* When one of the cells is empty, ensure that findJobs (including pagination) is working as if only one Cell
* existed.
*/
@Test
public void findJobsWithEmptyCell() {
final List<Job> cellTwoSnapshot = new ArrayList<>();
for (int i = 0; i < 5; i++) {
cellTwoSnapshot.addAll(dataGenerator.newBatchJobs(5, GrpcJobManagementModelConverters::toGrpcJob));
clock.advanceTime(1, TimeUnit.SECONDS);
cellTwoSnapshot.addAll(dataGenerator.newServiceJobs(5, GrpcJobManagementModelConverters::toGrpcJob));
clock.advanceTime(1, TimeUnit.MINUTES);
}
cellOne.getServiceRegistry().addService(new CellWithFixedJobsService(Collections.emptyList(), cellOneUpdates.serialize()));
cellTwo.getServiceRegistry().addService(new CellWithFixedJobsService(cellTwoSnapshot, cellTwoUpdates.serialize()));
List<Job> allJobs = walkAllFindJobsPages(5);
assertThat(allJobs).hasSize(cellTwoSnapshot.size());
// expect stackName to have changed
List<Job> expected = cellTwoSnapshot.stream()
.sorted(JobManagerCursors.jobCursorOrderComparator())
.map(this::withStackName)
.collect(Collectors.toList());
assertThat(allJobs).containsExactlyElementsOf(expected);
}
@Test
public void findJobsWithAllEmptyCells() {
cellOne.getServiceRegistry().addService(new CellWithFixedJobsService(Collections.emptyList(), cellOneUpdates.serialize()));
cellTwo.getServiceRegistry().addService(new CellWithFixedJobsService(Collections.emptyList(), cellTwoUpdates.serialize()));
List<Job> allJobs = walkAllFindJobsPages(5);
assertThat(allJobs).isEmpty();
}
@Test
public void findJobsWithFailingCell() {
List<Job> cellTwoSnapshot = new ArrayList<>();
for (int i = 0; i < 5; i++) {
cellTwoSnapshot.addAll(dataGenerator.newBatchJobs(5, GrpcJobManagementModelConverters::toGrpcJob));
cellTwoSnapshot.addAll(dataGenerator.newServiceJobs(5, GrpcJobManagementModelConverters::toGrpcJob));
clock.advanceTime(1, TimeUnit.MINUTES);
}
cellOne.getServiceRegistry().addService(new CellWithFailingJobManagementService());
cellTwo.getServiceRegistry().addService(new CellWithFixedJobsService(cellTwoSnapshot, cellTwoUpdates.serialize()));
JobQuery query = JobQuery.newBuilder()
.setPage(toGrpcPage(Page.unlimited()))
.build();
final AssertableSubscriber<JobQueryResult> testSubscriber = service.findJobs(query, UNDEFINED_CALL_METADATA).test();
testSubscriber.awaitTerminalEvent(1, TimeUnit.SECONDS);
testSubscriber.assertError(Status.INTERNAL.asRuntimeException().getClass());
testSubscriber.assertNoValues();
}
@Test
public void findJobsWithFieldFiltering() {
Pair<List<Job>, List<Job>> cellSnapshots = generateTestJobs();
List<Job> allJobs = walkAllPages(
10,
request -> service.findJobs(request, UNDEFINED_CALL_METADATA),
page -> JobQuery.newBuilder()
.setPage(page)
.addFields("jobDescriptor.owner")
.build(),
JobQueryResult::getPagination,
JobQueryResult::getItemsList
);
assertThat(allJobs).hasSize(cellSnapshots.getLeft().size() + cellSnapshots.getRight().size());
for (Job job : allJobs) {
assertThat(job.getId()).isNotEmpty();
assertThat(job.getJobDescriptor().getOwner().getTeamEmail()).isNotEmpty();
assertThat(job.getStatus().getReasonMessage()).isEmpty();
assertThat(job.getStatusHistoryList()).isEmpty();
}
}
@Test
public void findJob() {
Random random = new Random();
List<Job> cellOneSnapshot = new ArrayList<>(dataGenerator.newServiceJobs(10, GrpcJobManagementModelConverters::toGrpcJob));
cellOne.getServiceRegistry().addService(new CellWithFixedJobsService(cellOneSnapshot, cellOneUpdates.serialize()));
cellTwo.getServiceRegistry().addService(new CellWithFixedJobsService(Collections.emptyList(), cellTwoUpdates.serialize()));
Job expected = withStackName(cellOneSnapshot.get(random.nextInt(cellOneSnapshot.size())));
AssertableSubscriber<Job> testSubscriber = service.findJob(expected.getId(), UNDEFINED_CALL_METADATA).test();
testSubscriber.awaitTerminalEvent(1, TimeUnit.SECONDS);
testSubscriber.assertNoErrors();
testSubscriber.assertValueCount(1);
testSubscriber.assertValue(expected);
}
@Test
public void findJobWithFailingCell() {
Random random = new Random();
List<Job> cellOneSnapshot = new ArrayList<>(dataGenerator.newServiceJobs(10, GrpcJobManagementModelConverters::toGrpcJob));
cellOne.getServiceRegistry().addService(new CellWithFixedJobsService(cellOneSnapshot, cellOneUpdates.serialize()));
cellTwo.getServiceRegistry().addService(new CellWithFailingJobManagementService());
Job expected = withStackName(cellOneSnapshot.get(random.nextInt(cellOneSnapshot.size())));
AssertableSubscriber<Job> testSubscriber = service.findJob(expected.getId(), UNDEFINED_CALL_METADATA).test();
testSubscriber.awaitTerminalEvent(1, TimeUnit.SECONDS);
testSubscriber.assertNoErrors();
testSubscriber.assertValueCount(1);
testSubscriber.assertValue(expected);
}
@Test
public void findJobErrors() {
cellOne.getServiceRegistry().addService(new CellWithFailingJobManagementService(NOT_FOUND));
cellTwo.getServiceRegistry().addService(new CellWithFailingJobManagementService(UNAVAILABLE));
AssertableSubscriber<Job> testSubscriber = service.findJob("any", UNDEFINED_CALL_METADATA).test();
testSubscriber.awaitTerminalEvent(1, TimeUnit.SECONDS);
// transient errors have higher precedence than not found
testSubscriber.assertError(StatusRuntimeException.class);
assertThat(Status.fromThrowable(testSubscriber.getOnErrorEvents().get(0))).isEqualTo(UNAVAILABLE);
}
@Test
public void killJob() {
Random random = new Random();
List<Job> cellOneSnapshot = new ArrayList<>(dataGenerator.newServiceJobs(12, GrpcJobManagementModelConverters::toGrpcJob));
List<Job> cellTwoSnapshot = new ArrayList<>(dataGenerator.newBatchJobs(7, GrpcJobManagementModelConverters::toGrpcJob));
CellWithFixedJobsService cellOneService = new CellWithFixedJobsService(cellOneSnapshot, cellOneUpdates.serialize());
CellWithFixedJobsService cellTwoService = new CellWithFixedJobsService(cellTwoSnapshot, cellTwoUpdates.serialize());
cellOne.getServiceRegistry().addService(cellOneService);
cellTwo.getServiceRegistry().addService(cellTwoService);
Job killInCellOne = cellOneSnapshot.get(random.nextInt(cellOneSnapshot.size()));
Job killInCellTwo = cellTwoSnapshot.get(random.nextInt(cellTwoSnapshot.size()));
assertThat(cellOneService.currentJobs()).containsKey(killInCellOne.getId());
assertThat(cellTwoService.currentJobs()).containsKey(killInCellTwo.getId());
AssertableSubscriber<Void> testSubscriber = service.killJob(killInCellOne.getId(), UNDEFINED_CALL_METADATA).test();
testSubscriber.awaitTerminalEvent(1, TimeUnit.SECONDS);
testSubscriber.assertNoErrors();
testSubscriber.assertNoValues();
testSubscriber.assertCompleted();
assertThat(cellOneService.currentJobs()).doesNotContainKey(killInCellOne.getId());
assertThat(cellTwoService.currentJobs()).doesNotContainKey(killInCellOne.getId());
testSubscriber.unsubscribe();
testSubscriber = service.killJob(killInCellTwo.getId(), UNDEFINED_CALL_METADATA).test();
testSubscriber.awaitTerminalEvent(1, TimeUnit.SECONDS);
testSubscriber.assertNoErrors();
testSubscriber.assertNoValues();
testSubscriber.assertCompleted();
assertThat(cellOneService.currentJobs()).doesNotContainKey(killInCellTwo.getId());
assertThat(cellTwoService.currentJobs()).doesNotContainKey(killInCellTwo.getId());
testSubscriber.unsubscribe();
}
@Test
public void singleJobUpdates() {
Random random = new Random();
List<String> cellOneSnapshot = new ArrayList<>(dataGenerator.newServiceJobs(12)).stream()
.map(job -> job.getId())
.collect(Collectors.toList());
List<String> cellTwoSnapshot = new ArrayList<>(dataGenerator.newBatchJobs(7)).stream()
.map(job -> job.getId())
.collect(Collectors.toList());
CellWithJobIds cellOneService = new CellWithJobIds(cellOneSnapshot);
CellWithJobIds cellTwoService = new CellWithJobIds(cellTwoSnapshot);
cellOne.getServiceRegistry().addService(cellOneService);
cellTwo.getServiceRegistry().addService(cellTwoService);
String cellOneJobId = cellOneSnapshot.get(random.nextInt(cellOneSnapshot.size()));
String cellTwoJobId = cellTwoSnapshot.get(random.nextInt(cellTwoSnapshot.size()));
assertThat(cellOneService.containsCapacityUpdates(cellOneJobId)).isFalse();
assertThat(cellTwoService.containsCapacityUpdates(cellOneJobId)).isFalse();
JobCapacityUpdate cellOneUpdate = JobCapacityUpdate.newBuilder()
.setJobId(cellOneJobId)
.setCapacity(Capacity.newBuilder()
.setMax(1).setDesired(2).setMax(3)
.build())
.build();
AssertableSubscriber<Void> testSubscriber = service.updateJobCapacity(cellOneUpdate, UNDEFINED_CALL_METADATA).test();
testSubscriber.awaitTerminalEvent(1, TimeUnit.SECONDS);
testSubscriber.assertNoErrors();
testSubscriber.assertNoValues();
testSubscriber.assertCompleted();
assertThat(cellOneService.containsCapacityUpdates(cellOneJobId)).isTrue();
assertThat(cellTwoService.containsCapacityUpdates(cellOneJobId)).isFalse();
testSubscriber.unsubscribe();
JobCapacityUpdate cellTwoUpdate = JobCapacityUpdate.newBuilder()
.setJobId(cellTwoJobId)
.setCapacity(Capacity.newBuilder()
.setMax(2).setDesired(2).setMax(2)
.build())
.build();
testSubscriber = service.updateJobCapacity(cellTwoUpdate, UNDEFINED_CALL_METADATA).test();
testSubscriber.awaitTerminalEvent(1, TimeUnit.SECONDS);
testSubscriber.assertNoErrors();
testSubscriber.assertNoValues();
testSubscriber.assertCompleted();
assertThat(cellOneService.containsCapacityUpdates(cellTwoJobId)).isFalse();
assertThat(cellTwoService.containsCapacityUpdates(cellTwoJobId)).isTrue();
testSubscriber.unsubscribe();
}
@Test
public void killTask() {
Random random = new Random();
List<Task> cellOneSnapshot = new ArrayList<>(dataGenerator.newServiceJobWithTasks());
List<Task> cellTwoSnapshot = new ArrayList<>(dataGenerator.newBatchJobWithTasks());
CellWithFixedTasksService cellOneService = new CellWithFixedTasksService(cellOneSnapshot);
CellWithFixedTasksService cellTwoService = new CellWithFixedTasksService(cellTwoSnapshot);
cellOne.getServiceRegistry().addService(cellOneService);
cellTwo.getServiceRegistry().addService(cellTwoService);
Task killInCellOne = cellOneSnapshot.get(random.nextInt(cellOneSnapshot.size()));
Task killInCellTwo = cellTwoSnapshot.get(random.nextInt(cellTwoSnapshot.size()));
assertThat(cellOneService.currentTasks()).containsKey(killInCellOne.getId());
assertThat(cellTwoService.currentTasks()).containsKey(killInCellTwo.getId());
TaskKillRequest cellOneRequest = TaskKillRequest.newBuilder()
.setTaskId(killInCellOne.getId())
.setShrink(false)
.build();
AssertableSubscriber<Void> testSubscriber = service.killTask(cellOneRequest, UNDEFINED_CALL_METADATA).test();
testSubscriber.awaitTerminalEvent(1, TimeUnit.SECONDS);
testSubscriber.assertNoErrors();
testSubscriber.assertNoValues();
testSubscriber.assertCompleted();
assertThat(cellOneService.currentTasks()).doesNotContainKey(killInCellOne.getId());
assertThat(cellTwoService.currentTasks()).doesNotContainKey(killInCellOne.getId());
testSubscriber.unsubscribe();
TaskKillRequest cellTwoRequest = TaskKillRequest.newBuilder()
.setTaskId(killInCellTwo.getId())
.setShrink(false)
.build();
testSubscriber = service.killTask(cellTwoRequest, UNDEFINED_CALL_METADATA).test();
testSubscriber.awaitTerminalEvent(1, TimeUnit.SECONDS);
testSubscriber.assertNoErrors();
testSubscriber.assertNoValues();
testSubscriber.assertCompleted();
assertThat(cellOneService.currentTasks()).doesNotContainKey(killInCellTwo.getId());
assertThat(cellTwoService.currentTasks()).doesNotContainKey(killInCellTwo.getId());
testSubscriber.unsubscribe();
}
@Test
public void findTask() {
Random random = new Random();
List<Task> cellOneSnapshot = new ArrayList<>(dataGenerator.newServiceJobWithTasks());
cellOne.getServiceRegistry().addService(new CellWithFixedTasksService(cellOneSnapshot));
cellTwo.getServiceRegistry().addService(new CellWithFixedTasksService(Collections.emptyList()));
Task expected = withStackName(cellOneSnapshot.get(random.nextInt(cellOneSnapshot.size())));
AssertableSubscriber<Task> testSubscriber = service.findTask(expected.getId(), UNDEFINED_CALL_METADATA).test();
testSubscriber.awaitTerminalEvent(1, TimeUnit.SECONDS);
testSubscriber.assertNoErrors();
testSubscriber.assertValueCount(1);
testSubscriber.assertValue(expected);
}
@Test
public void findTaskWithFailingCell() {
Random random = new Random();
List<Task> cellOneSnapshot = new ArrayList<>(dataGenerator.newServiceJobWithTasks());
cellOne.getServiceRegistry().addService(new CellWithFixedTasksService(cellOneSnapshot));
cellTwo.getServiceRegistry().addService(new CellWithFailingJobManagementService(DEADLINE_EXCEEDED));
Task expected = withStackName(cellOneSnapshot.get(random.nextInt(cellOneSnapshot.size())));
AssertableSubscriber<Task> testSubscriber = service.findTask(expected.getId(), UNDEFINED_CALL_METADATA).test();
testSubscriber.awaitTerminalEvent(1, TimeUnit.SECONDS);
testSubscriber.assertNoErrors();
testSubscriber.assertValueCount(1);
testSubscriber.assertValue(expected);
}
@Test
public void findTaskErrors() {
cellOne.getServiceRegistry().addService(new CellWithFailingJobManagementService(INTERNAL));
cellTwo.getServiceRegistry().addService(new CellWithFailingJobManagementService(UNAVAILABLE));
AssertableSubscriber<Task> testSubscriber = service.findTask("any", UNDEFINED_CALL_METADATA).test();
testSubscriber.awaitTerminalEvent(1, TimeUnit.SECONDS);
// unexpected errors have higher precedence than transient
testSubscriber.assertError(StatusRuntimeException.class);
assertThat(Status.fromThrowable(testSubscriber.getOnErrorEvents().get(0))).isEqualTo(INTERNAL);
}
@Test
public void findTasksMergesAllCellsIntoSingleResult() {
Pair<List<Task>, List<Task>> cellSnapshots = generateTestJobsWithTasks();
List<Task> tasks = walkAllFindTasksPages(7);
assertThat(tasks).hasSize(cellSnapshots.getLeft().size() + cellSnapshots.getRight().size());
List<Task> expected = Stream.concat(cellSnapshots.getLeft().stream(), cellSnapshots.getRight().stream())
.sorted(JobManagerCursors.taskCursorOrderComparator())
.map(this::withStackName)
.collect(Collectors.toList());
assertThat(tasks).containsExactlyElementsOf(expected);
}
@Test
public void findTasksWithFieldFiltering() {
Pair<List<Task>, List<Task>> cellSnapshots = generateTestJobsWithTasks();
List<Task> allTasks = walkAllPages(
6,
request -> service.findTasks(request, UNDEFINED_CALL_METADATA),
page -> TaskQuery.newBuilder()
.setPage(page)
.addFields("jobId")
.build(),
TaskQueryResult::getPagination,
TaskQueryResult::getItemsList
);
assertThat(allTasks).hasSize(cellSnapshots.getLeft().size() + cellSnapshots.getRight().size());
for (Task task : allTasks) {
assertThat(task.getId()).isNotEmpty();
assertThat(task.getJobId()).isNotEmpty();
assertThat(task.getStatus().getReasonMessage()).isEmpty();
assertThat(task.getStatusHistoryList()).isEmpty();
}
}
@Test
public void observeJobsWaitsForAllMarkers() {
final List<Job> cellOneSnapshot = Arrays.asList(
Job.newBuilder().setId("cell-1-job-1").setStatus(ACCEPTED_STATE).build(),
Job.newBuilder().setId("cell-1-job-2").setStatus(ACCEPTED_STATE).build(),
Job.newBuilder().setId("cell-1-job-3").setStatus(ACCEPTED_STATE).build()
);
final List<Job> cellTwoSnapshot = Arrays.asList(
Job.newBuilder().setId("cell-2-job-1").setStatus(ACCEPTED_STATE).build(),
Job.newBuilder().setId("cell-2-job-2").setStatus(ACCEPTED_STATE).build(),
Job.newBuilder().setId("cell-2-job-3").setStatus(ACCEPTED_STATE).build()
);
cellOne.getServiceRegistry().addService(new CellWithFixedJobsService(cellOneSnapshot, cellOneUpdates.serialize()));
cellTwo.getServiceRegistry().addService(new CellWithFixedJobsService(cellTwoSnapshot, cellTwoUpdates.serialize()));
final AssertableSubscriber<JobChangeNotification> testSubscriber = service.observeJobs(ObserveJobsQuery.getDefaultInstance(), UNDEFINED_CALL_METADATA).test();
List<JobChangeNotification> expected = Stream.concat(
cellOneSnapshot.stream().map(this::toNotification).map(this::withStackName),
cellTwoSnapshot.stream().map(this::toNotification).map(this::withStackName)
).collect(Collectors.toList());
// single marker for all cells
final JobChangeNotification mergedMarker = JobChangeNotification.newBuilder().setSnapshotEnd(SnapshotEnd.newBuilder()).build();
expected.add(mergedMarker);
testSubscriber.awaitValueCount(7, 1, TimeUnit.SECONDS);
List<JobChangeNotification> onNextEvents = testSubscriber.getOnNextEvents().stream()
.map(this::removeEventPropagationData)
.collect(Collectors.toList());
assertThat(onNextEvents).last().isEqualTo(mergedMarker);
assertThat(onNextEvents).containsExactlyInAnyOrder(expected.toArray(new JobChangeNotification[expected.size()]));
// more updates are flowing
final JobChangeNotification cellOneUpdate = toNotification(Job.newBuilder().setId("cell-1-job-10").setStatus(ACCEPTED_STATE).build());
final JobChangeNotification cellTwoUpdate = toNotification(Job.newBuilder().setId("cell-2-job-10").setStatus(ACCEPTED_STATE).build());
cellOneUpdates.onNext(cellOneUpdate);
cellTwoUpdates.onNext(cellTwoUpdate);
testSubscriber.awaitValueCount(9, 1, TimeUnit.SECONDS);
onNextEvents = testSubscriber.getOnNextEvents().stream()
.map(this::removeEventPropagationData)
.collect(Collectors.toList());
assertThat(onNextEvents).last().isNotEqualTo(mergedMarker);
assertThat(onNextEvents).contains(withStackName(cellOneUpdate), withStackName(cellTwoUpdate));
}
private JobChangeNotification removeEventPropagationData(JobChangeNotification event) {
if (event.getNotificationCase() == JobChangeNotification.NotificationCase.JOBUPDATE) {
JobDescriptor.Builder jobDescriptorBuilder = event.getJobUpdate().getJob().getJobDescriptor().toBuilder();
jobDescriptorBuilder.removeAttributes(EventPropagationUtil.EVENT_ATTRIBUTE_PROPAGATION_STAGES);
return event.toBuilder()
.setJobUpdate(event.getJobUpdate().toBuilder()
.setJob(event.getJobUpdate().getJob().toBuilder()
.setJobDescriptor(jobDescriptorBuilder.build())
.build()
)
.build()
)
.build();
}
return event;
}
@Test
public void observeJobsStopsWhenAnyClientsTerminate() {
cellOne.getServiceRegistry().addService(new CellWithFixedJobsService(Collections.emptyList(), cellOneUpdates.serialize()));
cellTwo.getServiceRegistry().addService(new CellWithFixedJobsService(Collections.emptyList(), cellTwoUpdates.serialize()));
final AssertableSubscriber<JobChangeNotification> testSubscriber = service.observeJobs(ObserveJobsQuery.getDefaultInstance(), UNDEFINED_CALL_METADATA).test();
final JobChangeNotification cellOneUpdate = toNotification(Job.newBuilder().setId("cell-1-job-100").setStatus(ACCEPTED_STATE).build());
final JobChangeNotification cellTwoUpdate = toNotification(Job.newBuilder().setId("cell-2-job-200").setStatus(ACCEPTED_STATE).build());
cellOneUpdates.onNext(cellOneUpdate);
cellTwoUpdates.onNext(cellTwoUpdate);
testSubscriber.awaitValueCount(2, 1, TimeUnit.SECONDS);
assertThat(testSubscriber.getOnErrorEvents()).isEmpty();
assertThat(testSubscriber.isUnsubscribed()).isFalse();
assertThat(testSubscriber.getCompletions()).isEqualTo(0);
// a client finishes
cellTwoUpdates.onCompleted();
testSubscriber.awaitTerminalEvent(1, TimeUnit.SECONDS);
assertThat(testSubscriber.getOnErrorEvents()).isEmpty();
assertThat(testSubscriber.isUnsubscribed()).isTrue();
assertThat(testSubscriber.getCompletions()).isEqualTo(1);
}
@Test
public void observeJobsErrorsWhenAnyClientsError() {
cellOne.getServiceRegistry().addService(new CellWithFixedJobsService(Collections.emptyList(), cellOneUpdates.serialize()));
cellTwo.getServiceRegistry().addService(new CellWithFixedJobsService(Collections.emptyList(), cellTwoUpdates.serialize()));
final AssertableSubscriber<JobChangeNotification> testSubscriber = service.observeJobs(ObserveJobsQuery.getDefaultInstance(), UNDEFINED_CALL_METADATA).test();
final JobChangeNotification cellOneUpdate = toNotification(Job.newBuilder().setId("cell-1-job-100").setStatus(ACCEPTED_STATE).build());
final JobChangeNotification cellTwoUpdate = toNotification(Job.newBuilder().setId("cell-2-job-200").setStatus(ACCEPTED_STATE).build());
cellOneUpdates.onNext(cellOneUpdate);
cellTwoUpdates.onNext(cellTwoUpdate);
testSubscriber.awaitValueCount(2, 1, TimeUnit.SECONDS);
assertThat(testSubscriber.getOnErrorEvents()).isEmpty();
assertThat(testSubscriber.isUnsubscribed()).isFalse();
assertThat(testSubscriber.getCompletions()).isEqualTo(0);
// a client emits an error
cellTwoUpdates.onError(new RuntimeException("unexpected error"));
testSubscriber.awaitTerminalEvent(1, TimeUnit.SECONDS);
assertThat(testSubscriber.getOnErrorEvents()).hasSize(1);
assertThat(testSubscriber.isUnsubscribed()).isTrue();
assertThat(testSubscriber.getCompletions()).isEqualTo(0);
}
@Test
public void observeJob() {
String cellOneJobId = UUID.randomUUID().toString();
String cellTwoJobId = UUID.randomUUID().toString();
cellOne.getServiceRegistry().addService(new CellWithJobStream(cellOneJobId, cellOneUpdates.serialize()));
cellTwo.getServiceRegistry().addService(new CellWithJobStream(cellTwoJobId, cellTwoUpdates.serialize()));
AssertableSubscriber<JobChangeNotification> subscriber1 = service.observeJob(cellOneJobId, UNDEFINED_CALL_METADATA).test();
AssertableSubscriber<JobChangeNotification> subscriber2 = service.observeJob(cellTwoJobId, UNDEFINED_CALL_METADATA).test();
cellOneUpdates.onNext(toNotification(Job.newBuilder().setId(cellOneJobId).setStatus(ACCEPTED_STATE).build()));
cellOneUpdates.onNext(toNotification(Job.newBuilder().setId(cellOneJobId).setStatus(KILL_INITIATED_STATE).build()));
cellOneUpdates.onNext(toNotification(Job.newBuilder().setId(cellOneJobId).setStatus(FINISHED_STATE).build()));
cellOneUpdates.onNext(toNotification(Job.newBuilder().setId(cellOneJobId).setStatus(ACCEPTED_STATE).build()));
subscriber1.awaitValueCount(3, 5, TimeUnit.SECONDS);
subscriber1.assertNoErrors();
subscriber1.assertNotCompleted();
assertThat(subscriber1.isUnsubscribed()).isFalse();
subscriber2.assertNoErrors();
subscriber2.assertNoValues();
subscriber2.assertNotCompleted();
cellTwoUpdates.onNext(toNotification(Task.newBuilder()
.setId(cellTwoJobId + "-task1").setJobId(cellTwoJobId)
.build())
);
subscriber2.awaitValueCount(1, 1, TimeUnit.SECONDS);
subscriber2.assertNoErrors();
subscriber2.assertNotCompleted();
cellOneUpdates.onCompleted();
subscriber1.awaitTerminalEvent(1, TimeUnit.SECONDS);
assertThat(subscriber1.getOnErrorEvents()).isEmpty();
assertThat(subscriber1.isUnsubscribed()).isTrue();
assertThat(subscriber1.getCompletions()).isEqualTo(1);
}
@Test
public void observeJobDoesNotSetDeadlines() throws InterruptedException {
String cellOneJobId = UUID.randomUUID().toString();
String cellTwoJobId = UUID.randomUUID().toString();
cellOne.getServiceRegistry().addService(new CellWithJobStream(cellOneJobId, cellOneUpdates.serialize()));
cellTwo.getServiceRegistry().addService(new CellWithJobStream(cellTwoJobId, cellTwoUpdates.serialize()));
List<AssertableSubscriber<JobChangeNotification>> subscribers = new LinkedList<>();
subscribers.add(service.observeJob(cellOneJobId, UNDEFINED_CALL_METADATA).test());
subscribers.add(service.observeJob(cellTwoJobId, UNDEFINED_CALL_METADATA).test());
// TODO: make it easier to extract the Deadline for each cell call
Thread.sleep(2 * GRPC_REQUEST_TIMEOUT_MS);
for (AssertableSubscriber<JobChangeNotification> subscriber : subscribers) {
subscriber.assertNoErrors();
subscriber.assertNotCompleted();
assertThat(subscriber.isUnsubscribed()).isFalse();
}
}
@Test
public void observeJobsDoesNotSetDeadlines() throws InterruptedException {
cellOne.getServiceRegistry().addService(new CellWithFixedJobsService(Collections.emptyList(), cellOneUpdates.serialize()));
cellTwo.getServiceRegistry().addService(new CellWithFixedJobsService(Collections.emptyList(), cellTwoUpdates.serialize()));
AssertableSubscriber<JobChangeNotification> subscriber = service.observeJobs(ObserveJobsQuery.getDefaultInstance(), UNDEFINED_CALL_METADATA).test();
// TODO: make it easier to extract the Deadline for each cell call
Thread.sleep(2 * GRPC_REQUEST_TIMEOUT_MS);
subscriber.assertNoErrors();
subscriber.assertNotCompleted();
assertThat(subscriber.isUnsubscribed()).isFalse();
}
@Test
public void createJobRouteToCorrectStack() {
// Build service handlers for each cell
cellToServiceMap.forEach((cell, grpcServerRule) ->
grpcServerRule.getServiceRegistry().addService(new CellWithCachedJobsService(cell.getName()))
);
// Expected assignments based on routing rules in setUp()
Map<String, String> expectedAssignmentMap = ImmutableMap.of(
"app1", "one",
"app2", "one",
"app3", "two",
"app4", "one"
);
expectedAssignmentMap.forEach((appName, expectedCellName) -> {
// Create the job and let it get routed
JobDescriptor jobDescriptor = JobDescriptor.newBuilder()
.setApplicationName(appName)
.setCapacityGroup(appName + "CapGroup")
.build();
String jobId = service.createJob(jobDescriptor, JobManagerConstants.UNDEFINED_CALL_METADATA).toBlocking().first();
// Get a client to the test gRPC service for the cell that we expect got it
// TODO(Andrew L): This can use findJob() instead once AggregatingService implements it
Cell expectedCell = getCellWithName(expectedCellName)
.orElseThrow(() -> TitusServiceException.cellNotFound(expectedCellName));
JobManagementServiceStub expectedCellClient = JobManagementServiceGrpc.newStub(cellToServiceMap.get(expectedCell).getChannel());
// Check that the cell has it with the correct attribute
TestStreamObserver<Job> findJobResponse = new TestStreamObserver<>();
expectedCellClient.findJob(JobId.newBuilder().setId(jobId).build(), findJobResponse);
assertThatCode(() -> {
Job job = findJobResponse.takeNext(1, TimeUnit.SECONDS);
assertThat(job.getJobDescriptor().getAttributesOrThrow(JOB_ATTRIBUTES_CELL).equals(expectedCellName));
}).doesNotThrowAnyException();
});
}
@Test
public void createJobInjectsFederatedStackName() {
Cell firstCell = cells.get(0);
CellWithCachedJobsService cachedJobsService = new CellWithCachedJobsService(firstCell.getName());
cellToServiceMap.get(firstCell).getServiceRegistry().addService(cachedJobsService);
// Create the job and let it get routed
JobDescriptor jobDescriptor = JobDescriptor.newBuilder()
.setApplicationName("app1")
.setCapacityGroup("app1CapGroup")
.build();
String jobId = service.createJob(jobDescriptor, JobManagerConstants.UNDEFINED_CALL_METADATA).toBlocking().first();
Optional<JobDescriptor> createdJob = cachedJobsService.getCachedJob(jobId);
assertThat(createdJob).isPresent();
assertThat(createdJob.get().getAttributesMap()).containsEntry(JOB_ATTRIBUTES_STACK, stackName);
}
private List<Job> walkAllFindJobsPages(int pageWalkSize) {
return walkAllPages(
pageWalkSize,
request -> service.findJobs(request, UNDEFINED_CALL_METADATA),
page -> JobQuery.newBuilder().setPage(page).build(),
JobQueryResult::getPagination,
JobQueryResult::getItemsList
);
}
private List<Task> walkAllFindTasksPages(int pageWalkSize) {
return walkAllPages(
pageWalkSize,
request -> service.findTasks(request, UNDEFINED_CALL_METADATA),
page -> TaskQuery.newBuilder().setPage(page).build(),
TaskQueryResult::getPagination,
TaskQueryResult::getItemsList
);
}
private JobChangeNotification toNotification(Job job) {
return JobChangeNotification.newBuilder().setJobUpdate(JobUpdate.newBuilder().setJob(job)).build();
}
private JobChangeNotification toNotification(Task task) {
return JobChangeNotification.newBuilder().setTaskUpdate(TaskUpdate.newBuilder().setTask(task)).build();
}
private Job withStackName(Job job) {
JobDescriptor jobDescriptor = job.getJobDescriptor().toBuilder()
.putAttributes("titus.stack", stackName)
.build();
return job.toBuilder().setJobDescriptor(jobDescriptor).build();
}
private Task withStackName(Task task) {
return task.toBuilder()
.putTaskContext("titus.stack", stackName)
.build();
}
private JobChangeNotification withStackName(JobChangeNotification jobChangeNotification) {
switch (jobChangeNotification.getNotificationCase()) {
case JOBUPDATE:
JobUpdate jobUpdate = jobChangeNotification.getJobUpdate().toBuilder()
.setJob(withStackName(jobChangeNotification.getJobUpdate().getJob()))
.build();
return jobChangeNotification.toBuilder().setJobUpdate(jobUpdate).build();
default:
return jobChangeNotification;
}
}
private Optional<Cell> getCellWithName(String cellName) {
return cellToServiceMap.keySet().stream().filter(cell -> cell.getName().equals(cellName)).findFirst();
}
private Pair<List<Job>, List<Job>> generateTestJobs() {
final List<Job> cellOneSnapshot = new ArrayList<>();
final List<Job> cellTwoSnapshot = new ArrayList<>();
// generate 5 groups of size 20 (10 service, 10 batch) with different timestamps
for (int i = 0; i < 5; i++) {
for (int j = 0; j < 5; j++) {
clock.advanceTime(1, TimeUnit.SECONDS);
cellOneSnapshot.add(dataGenerator.newBatchJob(GrpcJobManagementModelConverters::toGrpcJob));
clock.advanceTime(1, TimeUnit.SECONDS);
cellTwoSnapshot.add(dataGenerator.newServiceJob(GrpcJobManagementModelConverters::toGrpcJob));
clock.advanceTime(1, TimeUnit.SECONDS);
cellOneSnapshot.add(dataGenerator.newServiceJob(GrpcJobManagementModelConverters::toGrpcJob));
clock.advanceTime(1, TimeUnit.SECONDS);
cellTwoSnapshot.add(dataGenerator.newBatchJob(GrpcJobManagementModelConverters::toGrpcJob));
}
clock.advanceTime(9, TimeUnit.SECONDS);
}
cellOne.getServiceRegistry().addService(new CellWithFixedJobsService(cellOneSnapshot, cellOneUpdates.serialize()));
cellTwo.getServiceRegistry().addService(new CellWithFixedJobsService(cellTwoSnapshot, cellTwoUpdates.serialize()));
return Pair.of(cellOneSnapshot, cellTwoSnapshot);
}
private Pair<List<Task>, List<Task>> generateTestJobsWithTasks() {
List<Task> cellOneSnapshot = new ArrayList<>();
List<Task> cellTwoSnapshot = new ArrayList<>();
// 10 jobs on each cell with TASKS_IN_GENERATED_JOBS tasks each
for (int i = 0; i < 5; i++) {
cellOneSnapshot.addAll(dataGenerator.newBatchJobWithTasks());
cellTwoSnapshot.addAll(dataGenerator.newBatchJobWithTasks());
cellOneSnapshot.addAll(dataGenerator.newServiceJobWithTasks());
cellTwoSnapshot.addAll(dataGenerator.newServiceJobWithTasks());
clock.advanceTime(1, TimeUnit.MINUTES);
}
cellOne.getServiceRegistry().addService(new CellWithFixedTasksService(cellOneSnapshot));
cellTwo.getServiceRegistry().addService(new CellWithFixedTasksService(cellTwoSnapshot));
return Pair.of(cellOneSnapshot, cellTwoSnapshot);
}
}
| 9,819 |
0 | Create_ds/titus-control-plane/titus-server-federation/src/test/java/com/netflix/titus/federation | Create_ds/titus-control-plane/titus-server-federation/src/test/java/com/netflix/titus/federation/service/RemoteFederationJobServices.java | package com.netflix.titus.federation.service;
import com.netflix.titus.grpc.protogen.JobManagementServiceGrpc;
import io.grpc.Status;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.util.UUID;
import java.util.concurrent.atomic.AtomicLong;
abstract class RemoteJobManagementService extends JobManagementServiceGrpc.JobManagementServiceImplBase {
volatile public AtomicLong createCount = new AtomicLong(0);
public UUID id = UUID.randomUUID();
}
class RemoteJobManagementServiceWithUnimplementedInterface extends RemoteJobManagementService {
private static final Logger logger = LoggerFactory.getLogger(RemoteJobManagementServiceWithUnimplementedInterface.class);
// All interface methods on super class return UNIMPLEMENTED status.
public void createJob(com.netflix.titus.grpc.protogen.JobDescriptor request,
io.grpc.stub.StreamObserver<com.netflix.titus.grpc.protogen.JobId> responseObserver) {
createCount.getAndIncrement();
logger.info("id: {} createJob called {} time(s)", id, createCount);
super.createJob(request, responseObserver);
}
}
class RemoteJobManagementServiceWithTimeoutMethods extends RemoteJobManagementService {
private static final Logger logger = LoggerFactory.getLogger(RemoteJobManagementServiceWithTimeoutMethods.class);
public void createJob(com.netflix.titus.grpc.protogen.JobDescriptor request,
io.grpc.stub.StreamObserver<com.netflix.titus.grpc.protogen.JobId> responseObserver) {
// Never respond to force timeout
createCount.getAndIncrement();
logger.info("id: {} createJob called {} time(s)", id, createCount);
}
}
| 9,820 |
0 | Create_ds/titus-control-plane/titus-server-federation/src/test/java/com/netflix/titus/federation | Create_ds/titus-control-plane/titus-server-federation/src/test/java/com/netflix/titus/federation/service/CellWithCachedJobsService.java | /*
* Copyright 2018 Netflix, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.netflix.titus.federation.service;
import java.util.HashMap;
import java.util.Map;
import java.util.Optional;
import java.util.UUID;
import com.netflix.titus.grpc.protogen.Job;
import com.netflix.titus.grpc.protogen.JobDescriptor;
import com.netflix.titus.grpc.protogen.JobId;
import com.netflix.titus.grpc.protogen.JobManagementServiceGrpc;
import com.netflix.titus.runtime.endpoint.common.grpc.GrpcUtil;
import io.grpc.stub.StreamObserver;
import rx.Observable;
import rx.Subscription;
import static com.netflix.titus.api.jobmanager.JobAttributes.JOB_ATTRIBUTES_CELL;
class CellWithCachedJobsService extends JobManagementServiceGrpc.JobManagementServiceImplBase {
private final String cellName;
private final Map<JobId, JobDescriptor> jobDescriptorMap = new HashMap<>();
CellWithCachedJobsService(String name) {
this.cellName = name;
}
Optional<JobDescriptor> getCachedJob(String jobId) {
return Optional.ofNullable(jobDescriptorMap.get(JobId.newBuilder().setId(jobId).build()));
}
@Override
public void createJob(JobDescriptor request, StreamObserver<JobId> responseObserver) {
JobId jobId = JobId.newBuilder().setId(UUID.randomUUID().toString()).build();
jobDescriptorMap.put(
jobId,
JobDescriptor.newBuilder(request)
.putAttributes(JOB_ATTRIBUTES_CELL, cellName)
.build());
Subscription subscription = Observable.just(jobId)
.subscribe(
responseObserver::onNext,
responseObserver::onError,
responseObserver::onCompleted
);
GrpcUtil.attachCancellingCallback(responseObserver, subscription);
}
@Override
public void findJob(JobId request, StreamObserver<Job> responseObserver) {
final Subscription subscription = Observable.just(Job.newBuilder().setJobDescriptor(jobDescriptorMap.get(request)).build())
.subscribe(
responseObserver::onNext,
responseObserver::onError,
responseObserver::onCompleted
);
GrpcUtil.attachCancellingCallback(responseObserver, subscription);
}
}
| 9,821 |
0 | Create_ds/titus-control-plane/titus-server-federation/src/test/java/com/netflix/titus/federation | Create_ds/titus-control-plane/titus-server-federation/src/test/java/com/netflix/titus/federation/service/CellWithPolicies.java | /*
* Copyright 2018 Netflix, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.netflix.titus.federation.service;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.UUID;
import java.util.stream.Collectors;
import com.google.protobuf.Empty;
import com.netflix.titus.grpc.protogen.AutoScalingServiceGrpc;
import com.netflix.titus.grpc.protogen.DeletePolicyRequest;
import com.netflix.titus.grpc.protogen.GetPolicyResult;
import com.netflix.titus.grpc.protogen.JobId;
import com.netflix.titus.grpc.protogen.PutPolicyRequest;
import com.netflix.titus.grpc.protogen.ScalingPolicyID;
import com.netflix.titus.grpc.protogen.ScalingPolicyResult;
import com.netflix.titus.grpc.protogen.UpdatePolicyRequest;
import io.grpc.stub.StreamObserver;
class CellWithPolicies extends AutoScalingServiceGrpc.AutoScalingServiceImplBase {
private final Map<String, ScalingPolicyResult> policyMap;
CellWithPolicies(List<ScalingPolicyResult> policyResults) {
policyMap = policyResults.stream().collect(Collectors.toMap(p -> p.getId().getId(), p -> p));
}
@Override
public void getAllScalingPolicies(Empty request, StreamObserver<GetPolicyResult> responseObserver) {
sendScalingPolicyResults(new ArrayList<>(policyMap.values()), responseObserver);
}
@Override
public void getJobScalingPolicies(JobId request, StreamObserver<GetPolicyResult> responseObserver) {
List<ScalingPolicyResult> scalingPolicyResults = policyMap.values().stream()
.filter(p -> p.getJobId().equals(request.getId()))
.collect(Collectors.toList());
sendScalingPolicyResults(scalingPolicyResults, responseObserver);
}
@Override
public void getScalingPolicy(ScalingPolicyID request, StreamObserver<GetPolicyResult> responseObserver) {
List<ScalingPolicyResult> result = policyMap.values().stream()
.filter(p -> p.getId().getId().equals(request.getId())).collect(Collectors.toList());
if (result.isEmpty()) {
// mirror the current behavior of titus-master on each Cell, this will generate an INTERNAL error
// TODO: respond with NOT_FOUND when gateway/master gets fixed
responseObserver.onCompleted();
return;
}
sendScalingPolicyResults(result, responseObserver);
}
@Override
public void setAutoScalingPolicy(PutPolicyRequest request, StreamObserver<ScalingPolicyID> responseObserver) {
ScalingPolicyID newPolicyId = ScalingPolicyID.newBuilder().setId(UUID.randomUUID().toString()).build();
ScalingPolicyResult newPolicyResult = ScalingPolicyResult.newBuilder().setId(newPolicyId).setJobId(request.getJobId()).build();
policyMap.put(newPolicyId.getId(), newPolicyResult);
responseObserver.onNext(newPolicyId);
responseObserver.onCompleted();
}
@Override
public void updateAutoScalingPolicy(UpdatePolicyRequest request, StreamObserver<Empty> responseObserver) {
if (policyMap.containsKey(request.getPolicyId().getId())) {
ScalingPolicyResult currentPolicy = policyMap.get(request.getPolicyId().getId());
ScalingPolicyResult updatePolicy = ScalingPolicyResult.newBuilder().setId(currentPolicy.getId()).setJobId(currentPolicy.getJobId())
.setScalingPolicy(request.getScalingPolicy()).build();
policyMap.put(currentPolicy.getId().getId(), updatePolicy);
responseObserver.onNext(Empty.getDefaultInstance());
responseObserver.onCompleted();
} else {
responseObserver.onError(new IllegalArgumentException(request.getPolicyId().getId() + " is Invalid"));
}
}
@Override
public void deleteAutoScalingPolicy(DeletePolicyRequest request, StreamObserver<Empty> responseObserver) {
if (policyMap.containsKey(request.getId().getId())) {
policyMap.remove(request.getId().getId());
responseObserver.onNext(Empty.getDefaultInstance());
responseObserver.onCompleted();
} else {
responseObserver.onError(new IllegalArgumentException(request.getId().getId() + " is Invalid"));
}
}
private void sendScalingPolicyResults(List<ScalingPolicyResult> results,
StreamObserver<GetPolicyResult> responseObserver) {
GetPolicyResult.Builder getPolicyResultBuilder = GetPolicyResult.newBuilder();
results.forEach(getPolicyResultBuilder::addItems);
responseObserver.onNext(getPolicyResultBuilder.build());
responseObserver.onCompleted();
}
}
| 9,822 |
0 | Create_ds/titus-control-plane/titus-server-federation/src/test/java/com/netflix/titus/federation | Create_ds/titus-control-plane/titus-server-federation/src/test/java/com/netflix/titus/federation/service/CellWithHealthStatus.java | /*
* Copyright 2018 Netflix, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.netflix.titus.federation.service;
import com.netflix.titus.grpc.protogen.HealthCheckRequest;
import com.netflix.titus.grpc.protogen.HealthCheckResponse;
import com.netflix.titus.grpc.protogen.HealthGrpc;
import io.grpc.stub.StreamObserver;
class CellWithHealthStatus extends HealthGrpc.HealthImplBase {
private final HealthCheckResponse response;
CellWithHealthStatus(HealthCheckResponse response) {
this.response = response;
}
@Override
public void check(HealthCheckRequest request, StreamObserver<HealthCheckResponse> responseObserver) {
responseObserver.onNext(response);
responseObserver.onCompleted();
}
}
| 9,823 |
0 | Create_ds/titus-control-plane/titus-server-federation/src/test/java/com/netflix/titus/federation | Create_ds/titus-control-plane/titus-server-federation/src/test/java/com/netflix/titus/federation/service/FallbackJobServiceGatewayTest.java | /*
* Copyright 2018 Netflix, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.netflix.titus.federation.service;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.UUID;
import java.util.stream.Collectors;
import com.google.common.collect.ImmutableMap;
import com.netflix.titus.api.federation.model.Cell;
import com.netflix.titus.api.jobmanager.service.JobManagerConstants;
import com.netflix.titus.common.runtime.TitusRuntime;
import com.netflix.titus.common.runtime.TitusRuntimes;
import com.netflix.titus.common.util.time.Clocks;
import com.netflix.titus.common.util.time.TestClock;
import com.netflix.titus.federation.service.router.ApplicationCellRouter;
import com.netflix.titus.federation.startup.GrpcConfiguration;
import com.netflix.titus.federation.startup.TitusFederationConfiguration;
import com.netflix.titus.grpc.protogen.JobDescriptor;
import io.grpc.Status;
import io.grpc.StatusRuntimeException;
import io.grpc.testing.GrpcServerRule;
import org.junit.Before;
import org.junit.Rule;
import org.junit.Test;
import org.junit.jupiter.api.BeforeEach;
import rx.Observable;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.Mockito.any;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
public class FallbackJobServiceGatewayTest {
private static final int TASKS_IN_GENERATED_JOBS = 10;
private static final long GRPC_REQUEST_TIMEOUT_MS = 1_000L;
private static final long GRPC_PRIMARY_FALLBACK_TIMEOUT_MS = 100L;
private static final TitusRuntime titusRuntime = TitusRuntimes.internal();
@Rule
public GrpcServerRule remoteFederationRule = new GrpcServerRule().directExecutor();
@Rule
public final GrpcServerRule cellOne = new GrpcServerRule().directExecutor();
@Rule
public final GrpcServerRule cellTwo = new GrpcServerRule().directExecutor();
private final TitusFederationConfiguration fedConfig = mock(TitusFederationConfiguration.class);
private String stackName;
private AggregatingJobServiceGateway aggregatingJobServiceGateway;
private RemoteJobServiceGateway remoteJobServiceGateway;
private FallbackJobServiceGateway fallbackJobServiceGateway;
private List<Cell> cells;
private Map<Cell, GrpcServerRule> cellToServiceMap;
private TestClock clock;
private ServiceDataGenerator dataGenerator;
@Before
public void setUp() {
stackName = UUID.randomUUID().toString();
GrpcConfiguration grpcConfiguration = mock(GrpcConfiguration.class);
when(grpcConfiguration.getRequestTimeoutMs()).thenReturn(GRPC_REQUEST_TIMEOUT_MS);
when(grpcConfiguration.getPrimaryFallbackTimeoutMs()).thenReturn(GRPC_PRIMARY_FALLBACK_TIMEOUT_MS);
when(fedConfig.getStack()).thenReturn(stackName);
when(fedConfig.getCells()).thenReturn("one=1;two=2");
when(fedConfig.getRoutingRules()).thenReturn("one=(app1.*|app2.*);two=(app3.*)");
CellInfoResolver cellInfoResolver = new DefaultCellInfoResolver(fedConfig);
ApplicationCellRouter cellRouter = new ApplicationCellRouter(cellInfoResolver, fedConfig);
cells = cellInfoResolver.resolve();
cellToServiceMap = ImmutableMap.of(
cells.get(0), cellOne,
cells.get(1), cellTwo
);
RemoteFederationConnector fedConnector = mock(RemoteFederationConnector.class);
when(fedConnector.getChannel()).thenReturn(remoteFederationRule.getChannel());
CellConnector cellConnector = mock(CellConnector.class);
when(cellConnector.getChannels()).thenReturn(cellToServiceMap.entrySet().stream()
.collect(Collectors.toMap(Map.Entry::getKey, cellPairEntry -> cellPairEntry.getValue().getChannel()))
);
when(cellConnector.getChannelForCell(any(Cell.class))).thenAnswer(invocation ->
Optional.ofNullable(cellToServiceMap.get(invocation.<Cell>getArgument(0)))
.map(GrpcServerRule::getChannel)
);
final AggregatingCellClient aggregatingCellClient = new AggregatingCellClient(cellConnector);
aggregatingJobServiceGateway = new AggregatingJobServiceGateway(
grpcConfiguration,
fedConfig,
cellConnector,
cellRouter,
aggregatingCellClient,
new AggregatingJobManagementServiceHelper(aggregatingCellClient, grpcConfiguration),
titusRuntime
);
remoteJobServiceGateway = new RemoteJobServiceGateway(fedConfig, fedConnector, cellRouter, grpcConfiguration);
fallbackJobServiceGateway = new FallbackJobServiceGateway(titusRuntime, fedConfig, remoteJobServiceGateway, aggregatingJobServiceGateway);
clock = Clocks.test();
dataGenerator = new ServiceDataGenerator(clock, TASKS_IN_GENERATED_JOBS);
}
@BeforeEach
public void beforeEach() {
when(fedConfig.isRemoteFederationEnabled()).thenReturn(false);
}
@Test
public void createJobWithFallbackOnUnimplemented() {
createJobWithFallbackFromRemoteJobManagementService(new RemoteJobManagementServiceWithUnimplementedInterface());
}
@Test
public void createJobWithoutFallbackOnTimeout() {
RemoteJobManagementService remoteJobManagementService = new RemoteJobManagementServiceWithTimeoutMethods();
CellWithCachedJobsService cachedJobsService = new CellWithCachedJobsService(cells.get(0).getName());
cellOne.getServiceRegistry().addService(cachedJobsService);
remoteFederationRule.getServiceRegistry().addService(remoteJobManagementService);
JobDescriptor jobDescriptor = JobDescriptor.newBuilder()
.setApplicationName("app1")
.build();
// Prove fallback is NOT happening
assertNoFallback(jobDescriptor, remoteJobManagementService, cachedJobsService);
// Prove fallback is NOT happening and the Timeout error is returned
when(fedConfig.isRemoteFederationEnabled()).thenReturn(true);
Observable<String> createObservable =
fallbackJobServiceGateway.createJob(jobDescriptor, JobManagerConstants.UNDEFINED_CALL_METADATA);
try {
createObservable.toBlocking().first();
// We shouldn't reach here as we expect to raise a DEADLINE_EXCEEDED exception
assertThat(false).isEqualTo(true);
} catch (StatusRuntimeException e) {
assertThat(remoteJobManagementService.createCount.get()).isEqualTo(1);
assertThat(Status.fromThrowable(e).getCode()).isEqualTo(Status.Code.DEADLINE_EXCEEDED);
}
}
private void createJobWithFallbackFromRemoteJobManagementService(RemoteJobManagementService remoteJobManagementService) {
CellWithCachedJobsService cachedJobsService = new CellWithCachedJobsService(cells.get(0).getName());
cellOne.getServiceRegistry().addService(cachedJobsService);
remoteFederationRule.getServiceRegistry().addService(remoteJobManagementService);
JobDescriptor jobDescriptor = JobDescriptor.newBuilder()
.setApplicationName("app1")
.build();
// Prove fallback is NOT happening
assertNoFallback(jobDescriptor, remoteJobManagementService, cachedJobsService);
// Prove fallback IS happening
when(fedConfig.isRemoteFederationEnabled()).thenReturn(true);
assertFallback(jobDescriptor, remoteJobManagementService, cachedJobsService);
}
private void assertNoFallback(
JobDescriptor jobDescriptor,
RemoteJobManagementService remoteJobManagementService,
CellWithCachedJobsService cachedJobsService) {
long initialCreateCount = remoteJobManagementService.createCount.get();
assertThat(initialCreateCount).isEqualTo(0);
Observable<String> createObservable =
fallbackJobServiceGateway.createJob(jobDescriptor, JobManagerConstants.UNDEFINED_CALL_METADATA);
String jobId = createObservable.toBlocking().first();
Optional<JobDescriptor> createdJob = cachedJobsService.getCachedJob(jobId);
assertThat(createdJob).isPresent();
assertThat(remoteJobManagementService.createCount.get()).isEqualTo(initialCreateCount);
}
private void assertFallback(
JobDescriptor jobDescriptor,
RemoteJobManagementService remoteJobManagementService,
CellWithCachedJobsService cachedJobsService) {
long initialCreateCount = remoteJobManagementService.createCount.get();
assertThat(initialCreateCount).isEqualTo(0);
Observable<String> createObservable =
fallbackJobServiceGateway.createJob(jobDescriptor, JobManagerConstants.UNDEFINED_CALL_METADATA);
String jobId = createObservable.toBlocking().first();
Optional<JobDescriptor> createdJob = cachedJobsService.getCachedJob(jobId);
assertThat(createdJob).isPresent();
assertThat(remoteJobManagementService.createCount.get()).isEqualTo(initialCreateCount + 1);
}
}
| 9,824 |
0 | Create_ds/titus-control-plane/titus-server-federation/src/test/java/com/netflix/titus/federation | Create_ds/titus-control-plane/titus-server-federation/src/test/java/com/netflix/titus/federation/service/CellWithFailingJobManagementService.java | /*
* Copyright 2018 Netflix, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.netflix.titus.federation.service;
import com.netflix.titus.grpc.protogen.Job;
import com.netflix.titus.grpc.protogen.JobId;
import com.netflix.titus.grpc.protogen.JobManagementServiceGrpc;
import com.netflix.titus.grpc.protogen.JobQuery;
import com.netflix.titus.grpc.protogen.JobQueryResult;
import com.netflix.titus.grpc.protogen.Task;
import com.netflix.titus.grpc.protogen.TaskId;
import com.netflix.titus.grpc.protogen.TaskQuery;
import com.netflix.titus.grpc.protogen.TaskQueryResult;
import io.grpc.Status;
import io.grpc.stub.StreamObserver;
import static io.grpc.Status.INTERNAL;
class CellWithFailingJobManagementService extends JobManagementServiceGrpc.JobManagementServiceImplBase {
private final Status errorStatus;
CellWithFailingJobManagementService() {
this(INTERNAL);
}
CellWithFailingJobManagementService(Status errorStatus) {
this.errorStatus = errorStatus;
}
@Override
public void findJob(JobId request, StreamObserver<Job> responseObserver) {
responseObserver.onError(errorStatus.asRuntimeException());
}
@Override
public void findJobs(JobQuery request, StreamObserver<JobQueryResult> responseObserver) {
responseObserver.onError(errorStatus.asRuntimeException());
}
@Override
public void findTask(TaskId request, StreamObserver<Task> responseObserver) {
responseObserver.onError(errorStatus.asRuntimeException());
}
@Override
public void findTasks(TaskQuery request, StreamObserver<TaskQueryResult> responseObserver) {
responseObserver.onError(errorStatus.asRuntimeException());
}
}
| 9,825 |
0 | Create_ds/titus-control-plane/titus-server-federation/src/test/java/com/netflix/titus/federation | Create_ds/titus-control-plane/titus-server-federation/src/test/java/com/netflix/titus/federation/service/DefaultCellInfoResolverTest.java | /*
* Copyright 2018 Netflix, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.netflix.titus.federation.service;
import com.netflix.titus.federation.startup.TitusFederationConfiguration;
import org.junit.Test;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
public class DefaultCellInfoResolverTest {
@Test
public void parsesCellsFromConfiguration() {
TitusFederationConfiguration config = mock(TitusFederationConfiguration.class);
when(config.getCells()).thenReturn("cell1=hostname1:1000;cell2=hostname2:1234;cell3=1.1.2.3:1");
DefaultCellInfoResolver cellInfoResolver = new DefaultCellInfoResolver(config);
assertThat(cellInfoResolver.resolve()).hasSize(3);
// first is the default
assertThat(cellInfoResolver.getDefault().getName()).isEqualTo("cell1");
}
} | 9,826 |
0 | Create_ds/titus-control-plane/titus-server-federation/src/test/java/com/netflix/titus/federation | Create_ds/titus-control-plane/titus-server-federation/src/test/java/com/netflix/titus/federation/service/ResponseAggregationTest.java | /*
* Copyright 2018 Netflix, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.netflix.titus.federation.service;
import java.util.Collections;
import java.util.List;
import java.util.stream.Collectors;
import com.netflix.titus.api.federation.model.Cell;
import com.netflix.titus.common.util.tuple.Either;
import com.netflix.titus.grpc.protogen.JobManagementServiceGrpc;
import com.netflix.titus.grpc.protogen.JobManagementServiceGrpc.JobManagementServiceStub;
import io.grpc.ManagedChannel;
import io.grpc.Status;
import org.junit.Test;
import rx.Observable;
import static com.netflix.titus.common.data.generator.DataGenerator.items;
import static com.netflix.titus.common.data.generator.DataGenerator.range;
import static com.netflix.titus.common.data.generator.DataGenerator.zip;
import static io.grpc.Status.INTERNAL;
import static io.grpc.Status.INVALID_ARGUMENT;
import static io.grpc.Status.NOT_FOUND;
import static io.grpc.Status.UNAVAILABLE;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.Mockito.mock;
public class ResponseAggregationTest {
@Test
public void singleValueReturnsFirstNonError() {
List<CellResponse<JobManagementServiceStub, Either<String, Throwable>>> responses = generate(
Either.ofValue("result1"),
Either.ofError(UNAVAILABLE.asRuntimeException()),
Either.ofError(NOT_FOUND.asRuntimeException())
);
CellResponse<JobManagementServiceStub, Either<String, Throwable>> merged = Observable.from(responses)
.reduce(ResponseMerger.singleValue((e1, e2) -> e1))
.toBlocking().single();
assertThat(merged).isSameAs(responses.get(0));
}
@Test(expected = IllegalArgumentException.class)
public void singleValueExpectsOnlyOneNonError() {
Observable<CellResponse<JobManagementServiceStub, Either<String, Throwable>>> responses = Observable.from(generate(
Either.ofValue("result1"),
Either.ofValue("result2"),
Either.ofError(NOT_FOUND.asRuntimeException()),
Either.ofError(UNAVAILABLE.asRuntimeException()),
Either.ofValue("result5")
));
responses.reduce(ResponseMerger.singleValue((e1, e2) -> e1))
.toBlocking().single();
}
@Test
public void commonErrorMergerBasedOnCategories() {
// one of each category
Either<String, Throwable> notFound = Either.ofError(NOT_FOUND.asRuntimeException());
Either<String, Throwable> transientError = Either.ofError(UNAVAILABLE.asRuntimeException());
Either<String, Throwable> entityExistedInACell = Either.ofError(INVALID_ARGUMENT.asRuntimeException());
Either<String, Throwable> unexpectedError = Either.ofError(INTERNAL.asRuntimeException());
List<CellResponse<JobManagementServiceStub, Either<String, Throwable>>> responses = generate(
notFound, transientError, entityExistedInACell, unexpectedError
);
CellResponse<JobManagementServiceStub, Either<String, Throwable>> unexpectedErrorResponse = responses.get(3);
Collections.shuffle(responses);
CellResponse<JobManagementServiceStub, Either<String, Throwable>> merged = Observable.from(responses)
.reduce(ErrorMerger.grpc(StatusCategoryComparator.defaultPriorities()))
.toBlocking().single();
// unexpected system errors have the highest precedence
assertThat(merged).isSameAs(unexpectedErrorResponse);
List<Status> sorted = responses.stream()
.map(r -> Status.fromThrowable(r.getResult().getError()))
.sorted(StatusCategoryComparator.defaultPriorities())
.collect(Collectors.toList());
// verify common order: unexpected > entity existed > transient > not found
assertThat(sorted).containsExactly(
INTERNAL,
INVALID_ARGUMENT,
UNAVAILABLE,
NOT_FOUND
);
}
@SafeVarargs
private static List<CellResponse<JobManagementServiceStub, Either<String, Throwable>>> generate(Either<String, Throwable>... values) {
JobManagementServiceStub client = JobManagementServiceGrpc.newStub(mock(ManagedChannel.class));
return zip(range(1), items(values)).map(pair -> {
String idx = pair.getLeft().toString();
Either<String, Throwable> result = pair.getRight();
return new CellResponse<>(new Cell("cell" + idx, idx), client, result);
}).toList();
}
}
| 9,827 |
0 | Create_ds/titus-control-plane/titus-server-federation/src/test/java/com/netflix/titus/federation | Create_ds/titus-control-plane/titus-server-federation/src/test/java/com/netflix/titus/federation/service/AggregatingHealthServiceTest.java | /*
* Copyright 2018 Netflix, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.netflix.titus.federation.service;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.Set;
import java.util.concurrent.TimeUnit;
import java.util.stream.Collectors;
import com.google.protobuf.util.Durations;
import com.netflix.titus.api.federation.model.Cell;
import com.netflix.titus.common.util.time.Clocks;
import com.netflix.titus.common.util.time.TestClock;
import com.netflix.titus.federation.startup.GrpcConfiguration;
import com.netflix.titus.grpc.protogen.HealthCheckRequest;
import com.netflix.titus.grpc.protogen.HealthCheckResponse;
import com.netflix.titus.grpc.protogen.HealthCheckResponse.Details;
import com.netflix.titus.grpc.protogen.HealthCheckResponse.ServerStatus;
import com.netflix.titus.grpc.protogen.HealthGrpc;
import com.netflix.titus.runtime.endpoint.metadata.AnonymousCallMetadataResolver;
import io.grpc.ManagedChannel;
import io.grpc.Status;
import io.grpc.stub.StreamObserver;
import io.grpc.testing.GrpcServerRule;
import org.junit.Before;
import org.junit.Rule;
import org.junit.Test;
import rx.observers.AssertableSubscriber;
import static com.netflix.titus.grpc.protogen.HealthCheckResponse.ServingStatus.NOT_SERVING;
import static com.netflix.titus.grpc.protogen.HealthCheckResponse.ServingStatus.SERVING;
import static io.grpc.Status.Code.DEADLINE_EXCEEDED;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.reset;
import static org.mockito.Mockito.when;
public class AggregatingHealthServiceTest {
private final TestClock clock = Clocks.test();
@Rule
public final GrpcServerRule cellOne = new GrpcServerRule().directExecutor();
@Rule
public final GrpcServerRule cellTwo = new GrpcServerRule().directExecutor();
AggregatingHealthService service;
private final CellConnector connector = mock(CellConnector.class);
@Before
public void setup() {
Map<Cell, ManagedChannel> cellMap = new HashMap<>();
cellMap.put(new Cell("one", "1"), cellOne.getChannel());
cellMap.put(new Cell("two", "2"), cellTwo.getChannel());
when(connector.getChannels()).thenReturn(cellMap);
when(connector.getChannelForCell(any())).then(invocation ->
Optional.ofNullable(cellMap.get(invocation.getArgument(0)))
);
GrpcConfiguration grpcConfiguration = mock(GrpcConfiguration.class);
when(grpcConfiguration.getRequestTimeoutMs()).thenReturn(1000L);
AnonymousCallMetadataResolver anonymousCallMetadataResolver = new AnonymousCallMetadataResolver();
AggregatingCellClient aggregatingCellClient = new AggregatingCellClient(connector);
service = new AggregatingHealthService(aggregatingCellClient, anonymousCallMetadataResolver, grpcConfiguration);
}
@Test
public void allCellsOK() {
cellOne.getServiceRegistry().addService(new CellWithHealthStatus(ok("one")));
cellTwo.getServiceRegistry().addService(new CellWithHealthStatus(ok("two")));
AssertableSubscriber<HealthCheckResponse> subscriber = service.check(HealthCheckRequest.newBuilder().build()).test();
subscriber.awaitTerminalEvent(10, TimeUnit.SECONDS);
subscriber.assertNoErrors();
subscriber.assertValueCount(1);
HealthCheckResponse response = subscriber.getOnNextEvents().get(0);
assertThat(response.getStatus()).isEqualTo(SERVING);
assertThat(response.getDetailsCount()).isEqualTo(2);
assertThat(response.getDetails(0).hasDetails()).isTrue();
assertThat(response.getDetails(1).hasDetails()).isTrue();
Set<String> cellsSeen = response.getDetailsList().stream()
.map(s -> s.getDetails().getCell())
.collect(Collectors.toSet());
assertThat(cellsSeen).contains("one", "two");
}
@Test
public void singleCell() {
reset(connector);
when(connector.getChannels()).thenReturn(Collections.singletonMap(
new Cell("one", "1"), cellOne.getChannel()
));
when(connector.getChannelForCell(any())).thenReturn(Optional.of(cellOne.getChannel()));
HealthCheckResponse one = HealthCheckResponse.newBuilder()
.setStatus(NOT_SERVING)
.addDetails(ServerStatus.newBuilder()
.setDetails(Details.newBuilder()
.setCell("one")
.setLeader(false)
.setActive(true)
.setUptime(Durations.fromMillis(clock.wallTime()))
.build())
.build())
.build();
cellOne.getServiceRegistry().addService(new CellWithHealthStatus(one));
AssertableSubscriber<HealthCheckResponse> subscriber = service.check(HealthCheckRequest.newBuilder().build()).test();
subscriber.awaitTerminalEvent(10, TimeUnit.SECONDS);
subscriber.assertNoErrors();
subscriber.assertValueCount(1);
HealthCheckResponse response = subscriber.getOnNextEvents().get(0);
assertThat(response.getStatus()).isEqualTo(NOT_SERVING);
assertThat(response.getDetailsCount()).isEqualTo(1);
assertThat(response.getDetails(0).hasDetails()).isTrue();
assertThat(response.getDetails(0).getDetails().getCell()).isEqualTo("one");
assertThat(response.getDetails(0).getDetails().getLeader()).isFalse();
}
@Test
public void oneCellFailing() {
cellOne.getServiceRegistry().addService(new CellWithHealthStatus(ok("one")));
cellTwo.getServiceRegistry().addService(new CellWithHealthStatus(failing("two")));
AssertableSubscriber<HealthCheckResponse> subscriber = service.check(HealthCheckRequest.newBuilder().build()).test();
subscriber.awaitTerminalEvent(10, TimeUnit.SECONDS);
subscriber.assertNoErrors();
subscriber.assertValueCount(1);
HealthCheckResponse response = subscriber.getOnNextEvents().get(0);
assertThat(response.getStatus()).isEqualTo(NOT_SERVING);
assertThat(response.getDetailsCount()).isEqualTo(2);
assertThat(response.getDetails(0).hasDetails()).isTrue();
assertThat(response.getDetails(1).hasDetails()).isTrue();
Set<String> cellsSeen = response.getDetailsList().stream()
.map(s -> s.getDetails().getCell())
.collect(Collectors.toSet());
assertThat(cellsSeen).contains("one", "two");
}
@Test
public void grpcErrors() {
cellOne.getServiceRegistry().addService(new CellWithHealthStatus(ok("one")));
cellTwo.getServiceRegistry().addService(new HealthGrpc.HealthImplBase() {
@Override
public void check(HealthCheckRequest request, StreamObserver<HealthCheckResponse> responseObserver) {
responseObserver.onError(Status.DEADLINE_EXCEEDED.asRuntimeException());
}
});
AssertableSubscriber<HealthCheckResponse> subscriber = service.check(HealthCheckRequest.newBuilder().build()).test();
subscriber.awaitTerminalEvent(10, TimeUnit.SECONDS);
subscriber.assertNoErrors();
subscriber.assertValueCount(1);
HealthCheckResponse response = subscriber.getOnNextEvents().get(0);
assertThat(response.getStatus()).isEqualTo(NOT_SERVING);
assertThat(response.getDetailsCount()).isEqualTo(2);
List<ServerStatus> errors = response.getDetailsList().stream()
.filter(ServerStatus::hasError)
.collect(Collectors.toList());
assertThat(errors).hasSize(1);
assertThat(errors.get(0).getError().getCell()).isEqualTo("two");
assertThat(errors.get(0).getError().getErrorCode()).isEqualTo(DEADLINE_EXCEEDED.toString());
}
@Test
public void allCellsFailing() {
cellOne.getServiceRegistry().addService(new CellWithHealthStatus(failing("one")));
cellTwo.getServiceRegistry().addService(new CellWithHealthStatus(failing("two")));
AssertableSubscriber<HealthCheckResponse> subscriber = service.check(HealthCheckRequest.newBuilder().build()).test();
subscriber.awaitTerminalEvent(10, TimeUnit.SECONDS);
subscriber.assertNoErrors();
subscriber.assertValueCount(1);
HealthCheckResponse response = subscriber.getOnNextEvents().get(0);
assertThat(response.getStatus()).isEqualTo(NOT_SERVING);
assertThat(response.getDetailsCount()).isEqualTo(2);
assertThat(response.getDetails(0).hasDetails()).isTrue();
assertThat(response.getDetails(1).hasDetails()).isTrue();
Set<String> cellsSeen = response.getDetailsList().stream()
.map(s -> s.getDetails().getCell())
.collect(Collectors.toSet());
assertThat(cellsSeen).contains("one", "two");
}
private HealthCheckResponse ok(String cellName) {
return HealthCheckResponse.newBuilder()
.setStatus(SERVING)
.addDetails(ServerStatus.newBuilder()
.setDetails(Details.newBuilder()
.setCell(cellName)
.setLeader(true)
.setActive(true)
.setUptime(Durations.fromMillis(clock.wallTime()))
.build())
.build())
.build();
}
private HealthCheckResponse failing(String cellName) {
return HealthCheckResponse.newBuilder()
.setStatus(NOT_SERVING)
.addDetails(ServerStatus.newBuilder()
.setDetails(Details.newBuilder()
.setCell(cellName)
.setLeader(true)
.setActive(false)
.setUptime(Durations.fromMillis(clock.wallTime()))
.build())
.build())
.build();
}
} | 9,828 |
0 | Create_ds/titus-control-plane/titus-server-federation/src/test/java/com/netflix/titus/federation | Create_ds/titus-control-plane/titus-server-federation/src/test/java/com/netflix/titus/federation/service/DefaultCellConnectorTest.java | /*
* Copyright 2018 Netflix, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.netflix.titus.federation.service;
import java.util.Map;
import java.util.Optional;
import com.netflix.titus.api.federation.model.Cell;
import com.netflix.titus.federation.startup.TitusFederationConfiguration;
import io.grpc.ManagedChannel;
import org.junit.Test;
import static org.assertj.core.api.Java6Assertions.assertThat;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
public class DefaultCellConnectorTest {
@Test
public void buildChannelsTest() {
TitusFederationConfiguration titusFederationConfiguration = mock(TitusFederationConfiguration.class);
when(titusFederationConfiguration.getCells()).thenReturn("cell1=hostName1:7001;cell2=hostName2:7002");
DefaultCellInfoResolver cellInfoResolver = new DefaultCellInfoResolver(titusFederationConfiguration);
DefaultCellConnector defaultCellConnector = new DefaultCellConnector(cellInfoResolver);
Map<Cell, ManagedChannel> channels = defaultCellConnector.getChannels();
assertThat(channels).isNotEmpty();
assertThat(channels.size()).isEqualTo(2);
Optional<ManagedChannel> hostOneChannel = defaultCellConnector.getChannelForCell(new Cell("cell1", "hostName1:7001"));
Optional<ManagedChannel> hostTwoChannel = defaultCellConnector.getChannelForCell(new Cell("cell2", "hostName2:7002"));
assertThat(hostOneChannel.isPresent()).isTrue();
assertThat(hostTwoChannel.isPresent()).isTrue();
Optional<ManagedChannel> hostThreeChannel = defaultCellConnector.getChannelForCell(new Cell("cell3", "hostName3:7002"));
assertThat(hostThreeChannel.isPresent()).isFalse();
}
}
| 9,829 |
0 | Create_ds/titus-control-plane/titus-server-federation/src/test/java/com/netflix/titus/federation | Create_ds/titus-control-plane/titus-server-federation/src/test/java/com/netflix/titus/federation/service/AggregatingAutoScalingServiceTest.java | /*
* Copyright 2018 Netflix, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.netflix.titus.federation.service;
import java.util.Collections;
import java.util.List;
import java.util.concurrent.TimeUnit;
import com.google.protobuf.DoubleValue;
import com.netflix.titus.grpc.protogen.DeletePolicyRequest;
import com.netflix.titus.grpc.protogen.GetPolicyResult;
import com.netflix.titus.grpc.protogen.JobId;
import com.netflix.titus.grpc.protogen.PutPolicyRequest;
import com.netflix.titus.grpc.protogen.ScalingPolicy;
import com.netflix.titus.grpc.protogen.ScalingPolicyID;
import com.netflix.titus.grpc.protogen.ScalingPolicyResult;
import com.netflix.titus.grpc.protogen.TargetTrackingPolicyDescriptor;
import com.netflix.titus.grpc.protogen.UpdatePolicyRequest;
import io.grpc.Status;
import io.grpc.StatusRuntimeException;
import org.junit.Test;
import rx.observers.AssertableSubscriber;
import static com.netflix.titus.testkit.junit.spring.SpringMockMvcUtil.JUNIT_REST_CALL_METADATA;
import static org.assertj.core.api.Java6Assertions.assertThat;
public class AggregatingAutoScalingServiceTest extends AggregatingAutoScalingTestBase {
@Test
public void getPoliciesFromTwoCells() {
ScalingPolicyID policy1 = ScalingPolicyID.newBuilder().setId(POLICY_1).build();
ScalingPolicyID policy2 = ScalingPolicyID.newBuilder().setId(POLICY_2).build();
ScalingPolicyResult policyOneResult = ScalingPolicyResult.newBuilder().setId(policy1).build();
ScalingPolicyResult policyTwoResult = ScalingPolicyResult.newBuilder().setId(policy2).build();
CellWithPolicies cellOneService = new CellWithPolicies(Collections.singletonList(policyOneResult));
CellWithPolicies cellTwoService = new CellWithPolicies(Collections.singletonList(policyTwoResult));
cellOne.getServiceRegistry().addService(cellOneService);
cellTwo.getServiceRegistry().addService(cellTwoService);
final AssertableSubscriber<GetPolicyResult> testSubscriber = service.getAllScalingPolicies(JUNIT_REST_CALL_METADATA).test();
testSubscriber.awaitValueCount(1, 1, TimeUnit.SECONDS);
List<GetPolicyResult> onNextEvents = testSubscriber.getOnNextEvents();
assertThat(onNextEvents).isNotNull();
assertThat(onNextEvents.size()).isEqualTo(1);
assertThat(onNextEvents.get(0).getItemsCount()).isEqualTo(2);
}
@Test
public void getPoliciesFromTwoCellsWithOneFailing() {
ScalingPolicyID policy1 = ScalingPolicyID.newBuilder().setId(POLICY_1).build();
ScalingPolicyResult policyOneResult = ScalingPolicyResult.newBuilder().setId(policy1).build();
CellWithPolicies cellOneService = new CellWithPolicies(Collections.singletonList(policyOneResult));
CellWithFailingAutoscalingService badCell = new CellWithFailingAutoscalingService();
cellOne.getServiceRegistry().addService(cellOneService);
cellTwo.getServiceRegistry().addService(badCell);
final AssertableSubscriber<GetPolicyResult> testSubscriber = service.getAllScalingPolicies(JUNIT_REST_CALL_METADATA).test();
testSubscriber.awaitTerminalEvent(1, TimeUnit.SECONDS);
testSubscriber.assertNoValues();
testSubscriber.assertError(StatusRuntimeException.class);
List<Throwable> onErrorEvents = testSubscriber.getOnErrorEvents();
assertThat(onErrorEvents.size()).isEqualTo(1);
}
@Test
public void getPoliciesForJobFromTwoCells() {
ScalingPolicyID policy1 = ScalingPolicyID.newBuilder().setId(POLICY_1).build();
ScalingPolicyID policy2 = ScalingPolicyID.newBuilder().setId(POLICY_2).build();
ScalingPolicyResult policyOneResult = ScalingPolicyResult.newBuilder().setId(policy1).setJobId(JOB_1).build();
ScalingPolicyResult policyTwoResult = ScalingPolicyResult.newBuilder().setId(policy2).setJobId(JOB_2).build();
CellWithPolicies cellOneService = new CellWithPolicies(Collections.singletonList(policyOneResult));
CellWithPolicies cellTwoService = new CellWithPolicies(Collections.singletonList(policyTwoResult));
cellOne.getServiceRegistry().addService(cellOneService);
cellTwo.getServiceRegistry().addService(cellTwoService);
AssertableSubscriber<GetPolicyResult> testSubscriber = service.getJobScalingPolicies(JobId.newBuilder().setId(JOB_2).build(), JUNIT_REST_CALL_METADATA).test();
testSubscriber.awaitValueCount(1, 1, TimeUnit.SECONDS);
List<GetPolicyResult> onNextEvents = testSubscriber.getOnNextEvents();
assertThat(onNextEvents).isNotNull();
assertThat(onNextEvents.size()).isEqualTo(1);
assertThat(onNextEvents.get(0).getItemsCount()).isEqualTo(1);
assertThat(onNextEvents.get(0).getItems(0).getJobId()).isEqualTo(JOB_2);
// Bad policy id, currently each Cell returns an empty result
testSubscriber = service.getJobScalingPolicies(JobId.newBuilder().setId("badID").build(), JUNIT_REST_CALL_METADATA).test();
testSubscriber.awaitTerminalEvent(1, TimeUnit.SECONDS);
testSubscriber.assertNoErrors();
onNextEvents = testSubscriber.getOnNextEvents();
assertThat(onNextEvents).isNotNull();
assertThat(onNextEvents.size()).isEqualTo(1);
assertThat(onNextEvents.get(0).getItemsCount()).isEqualTo(0);
}
@Test
public void createAndUpdatePolicyForJobIdFromTwoCells() {
ScalingPolicyID policy1 = ScalingPolicyID.newBuilder().setId(POLICY_1).build();
ScalingPolicyID policy2 = ScalingPolicyID.newBuilder().setId(POLICY_2).build();
ScalingPolicyResult policyOneResult = ScalingPolicyResult.newBuilder().setId(policy1).setJobId(JOB_1).build();
ScalingPolicyResult policyTwoResult = ScalingPolicyResult.newBuilder().setId(policy2).setJobId(JOB_2).build();
CellWithPolicies cellOneService = new CellWithPolicies(Collections.singletonList(policyOneResult));
CellWithPolicies cellTwoService = new CellWithPolicies(Collections.singletonList(policyTwoResult));
CellWithJobIds cellOneJobsService = new CellWithJobIds(Collections.singletonList(JOB_1));
CellWithJobIds cellTwoJobsService = new CellWithJobIds(Collections.singletonList(JOB_2));
cellOne.getServiceRegistry().addService(cellOneService);
cellOne.getServiceRegistry().addService(cellOneJobsService);
cellTwo.getServiceRegistry().addService(cellTwoService);
cellTwo.getServiceRegistry().addService(cellTwoJobsService);
AssertableSubscriber<ScalingPolicyID> testSubscriber = service.setAutoScalingPolicy(PutPolicyRequest.newBuilder().setJobId(JOB_2).build(), JUNIT_REST_CALL_METADATA).test();
testSubscriber.awaitValueCount(1, 1, TimeUnit.SECONDS);
testSubscriber.assertNoErrors();
List<ScalingPolicyID> onNextEvents = testSubscriber.getOnNextEvents();
assertThat(onNextEvents).isNotNull();
assertThat(onNextEvents.size()).isEqualTo(1);
assertThat(onNextEvents.get(0).getId()).isNotEmpty();
AssertableSubscriber<GetPolicyResult> testSubscriber2 = service.getJobScalingPolicies(JobId.newBuilder().setId(JOB_2).build(), JUNIT_REST_CALL_METADATA).test();
testSubscriber2.awaitValueCount(1, 1, TimeUnit.SECONDS);
List<GetPolicyResult> onNextEvents1 = testSubscriber2.getOnNextEvents();
assertThat(onNextEvents1).isNotNull();
assertThat(onNextEvents1.size()).isEqualTo(1);
assertThat(onNextEvents1.get(0).getItemsCount()).isEqualTo(2);
assertThat(onNextEvents1.get(0).getItems(0).getJobId()).isEqualTo(JOB_2);
assertThat(onNextEvents1.get(0).getItems(1).getJobId()).isEqualTo(JOB_2);
UpdatePolicyRequest updatePolicyRequest = UpdatePolicyRequest.newBuilder()
.setPolicyId(ScalingPolicyID.newBuilder().setId(POLICY_2))
.setScalingPolicy(ScalingPolicy.newBuilder()
.setTargetPolicyDescriptor(TargetTrackingPolicyDescriptor.newBuilder()
.setTargetValue(DoubleValue.newBuilder().setValue(100.0).build()).build()).build()).build();
AssertableSubscriber<Void> testSubscriber3 = service.updateAutoScalingPolicy(updatePolicyRequest, JUNIT_REST_CALL_METADATA).test();
testSubscriber3.assertNoErrors();
AssertableSubscriber<GetPolicyResult> testSubscriber4 = service.getScalingPolicy(ScalingPolicyID.newBuilder().setId(POLICY_2).build(), JUNIT_REST_CALL_METADATA).test();
testSubscriber2.awaitValueCount(1, 1, TimeUnit.SECONDS);
List<GetPolicyResult> onNextEvents2 = testSubscriber4.getOnNextEvents();
assertThat(onNextEvents2).isNotNull();
assertThat(onNextEvents2.size()).isEqualTo(1);
assertThat(onNextEvents2.get(0).getItemsCount()).isEqualTo(1);
assertThat(onNextEvents2.get(0).getItems(0).getJobId()).isEqualTo(JOB_2);
assertThat(onNextEvents2.get(0).getItems(0).getId().getId()).isEqualTo(POLICY_2);
ScalingPolicy scalingPolicy = onNextEvents2.get(0).getItems(0).getScalingPolicy();
double updatedValue = scalingPolicy.getTargetPolicyDescriptor().getTargetValue().getValue();
assertThat(updatedValue).isEqualTo(100);
}
@Test
public void createAndDeletePolicyForJobIdFromTwoCells() {
ScalingPolicyID policy1 = ScalingPolicyID.newBuilder().setId(POLICY_1).build();
ScalingPolicyID policy2 = ScalingPolicyID.newBuilder().setId(POLICY_2).build();
ScalingPolicyResult policyOneResult = ScalingPolicyResult.newBuilder().setId(policy1).setJobId(JOB_1).build();
ScalingPolicyResult policyTwoResult = ScalingPolicyResult.newBuilder().setId(policy2).setJobId(JOB_2).build();
CellWithPolicies cellOneService = new CellWithPolicies(Collections.singletonList(policyOneResult));
CellWithPolicies cellTwoService = new CellWithPolicies(Collections.singletonList(policyTwoResult));
CellWithJobIds cellOneJobsService = new CellWithJobIds(Collections.singletonList(JOB_1));
CellWithJobIds cellTwoJobsService = new CellWithJobIds(Collections.singletonList(JOB_2));
cellOne.getServiceRegistry().addService(cellOneService);
cellTwo.getServiceRegistry().addService(cellOneJobsService);
cellTwo.getServiceRegistry().addService(cellTwoService);
cellTwo.getServiceRegistry().addService(cellTwoJobsService);
AssertableSubscriber<ScalingPolicyID> testSubscriber = service.setAutoScalingPolicy(PutPolicyRequest.newBuilder().setJobId(JOB_2).build(), JUNIT_REST_CALL_METADATA).test();
testSubscriber.awaitValueCount(1, 1, TimeUnit.SECONDS);
assertThat(testSubscriber.getOnErrorEvents().isEmpty()).isTrue();
List<ScalingPolicyID> onNextEvents = testSubscriber.getOnNextEvents();
assertThat(onNextEvents).isNotNull();
assertThat(onNextEvents.size()).isEqualTo(1);
assertThat(onNextEvents.get(0).getId()).isNotEmpty();
String newPolicyId = onNextEvents.get(0).getId();
AssertableSubscriber<GetPolicyResult> testSubscriber2 = service.getJobScalingPolicies(JobId.newBuilder().setId(JOB_2).build(), JUNIT_REST_CALL_METADATA).test();
testSubscriber2.awaitValueCount(1, 1, TimeUnit.SECONDS);
List<GetPolicyResult> onNextEvents1 = testSubscriber2.getOnNextEvents();
assertThat(onNextEvents1).isNotNull();
assertThat(onNextEvents1.size()).isEqualTo(1);
assertThat(onNextEvents1.get(0).getItemsCount()).isEqualTo(2);
assertThat(onNextEvents1.get(0).getItems(0).getJobId()).isEqualTo(JOB_2);
assertThat(onNextEvents1.get(0).getItems(1).getJobId()).isEqualTo(JOB_2);
DeletePolicyRequest deletePolicyRequest = DeletePolicyRequest.newBuilder().setId(ScalingPolicyID.newBuilder().setId(newPolicyId).build()).build();
AssertableSubscriber<Void> testSubscriber3 = service.deleteAutoScalingPolicy(deletePolicyRequest, JUNIT_REST_CALL_METADATA).test();
testSubscriber3.assertNoErrors();
AssertableSubscriber<GetPolicyResult> testSubscriber4 = service.getJobScalingPolicies(JobId.newBuilder().setId(JOB_2).build(), JUNIT_REST_CALL_METADATA).test();
testSubscriber2.awaitValueCount(1, 1, TimeUnit.SECONDS);
List<GetPolicyResult> onNextEvents2 = testSubscriber4.getOnNextEvents();
assertThat(onNextEvents2).isNotNull();
assertThat(onNextEvents2.size()).isEqualTo(1);
assertThat(onNextEvents2.get(0).getItemsCount()).isEqualTo(1);
assertThat(onNextEvents2.get(0).getItems(0).getJobId()).isEqualTo(JOB_2);
assertThat(onNextEvents2.get(0).getItems(0).getId().getId()).isEqualTo(POLICY_2);
}
@Test
public void getPolicyByIdFromTwoCells() {
ScalingPolicyID policy1 = ScalingPolicyID.newBuilder().setId(POLICY_1).build();
ScalingPolicyID policy2 = ScalingPolicyID.newBuilder().setId(POLICY_2).build();
ScalingPolicyResult policyOneResult = ScalingPolicyResult.newBuilder().setId(policy1).build();
ScalingPolicyResult policyTwoResult = ScalingPolicyResult.newBuilder().setId(policy2).build();
CellWithPolicies cellOneService = new CellWithPolicies(Collections.singletonList(policyOneResult));
CellWithPolicies cellTwoService = new CellWithPolicies(Collections.singletonList(policyTwoResult));
cellOne.getServiceRegistry().addService(cellOneService);
cellTwo.getServiceRegistry().addService(cellTwoService);
AssertableSubscriber<GetPolicyResult> testSubscriber = service.getScalingPolicy(
ScalingPolicyID.newBuilder().setId(POLICY_2).build(), JUNIT_REST_CALL_METADATA).test();
testSubscriber.awaitValueCount(1, 1, TimeUnit.SECONDS);
List<GetPolicyResult> onNextEvents = testSubscriber.getOnNextEvents();
assertThat(onNextEvents).isNotNull();
assertThat(onNextEvents.size()).isEqualTo(1);
assertThat(onNextEvents.get(0).getItemsCount()).isEqualTo(1);
// Bad id. The current behavior is "INTERNAL: Completed without a response", but it will change to NOT_FOUND someday
testSubscriber = service.getScalingPolicy(ScalingPolicyID.newBuilder().setId("badID").build(), JUNIT_REST_CALL_METADATA).test();
testSubscriber.awaitTerminalEvent(1, TimeUnit.SECONDS);
testSubscriber.assertError(StatusRuntimeException.class);
testSubscriber.assertNoValues();
List<Throwable> onErrorEvents = testSubscriber.getOnErrorEvents();
assertThat(onErrorEvents).isNotNull();
assertThat(onErrorEvents).hasSize(1);
assertThat(Status.fromThrowable(onErrorEvents.get(0)).getCode()).isEqualTo(Status.CANCELLED.getCode());
}
}
| 9,830 |
0 | Create_ds/titus-control-plane/titus-server-federation/src/test/java/com/netflix/titus/federation | Create_ds/titus-control-plane/titus-server-federation/src/test/java/com/netflix/titus/federation/service/AggregatingAutoScalingTestBase.java | /*
* Copyright 2018 Netflix, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.netflix.titus.federation.service;
import java.util.HashMap;
import java.util.Map;
import java.util.Optional;
import com.netflix.titus.api.federation.model.Cell;
import com.netflix.titus.runtime.endpoint.metadata.AnonymousCallMetadataResolver;
import com.netflix.titus.federation.startup.GrpcConfiguration;
import io.grpc.ManagedChannel;
import io.grpc.testing.GrpcServerRule;
import org.junit.Before;
import org.junit.Rule;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
public class AggregatingAutoScalingTestBase {
static final String POLICY_1 = "policy1";
static final String POLICY_2 = "policy2";
static final String JOB_1 = "job1";
static final String JOB_2 = "job2";
@Rule
public final GrpcServerRule cellOne = new GrpcServerRule().directExecutor();
@Rule
public final GrpcServerRule cellTwo = new GrpcServerRule().directExecutor();
AggregatingAutoScalingService service;
@Before
public void setUp() {
CellConnector connector = mock(CellConnector.class);
Map<Cell, ManagedChannel> cellMap = new HashMap<>();
cellMap.put(new Cell("one", "1"), cellOne.getChannel());
cellMap.put(new Cell("two", "2"), cellTwo.getChannel());
when(connector.getChannels()).thenReturn(cellMap);
when(connector.getChannelForCell(any())).then(invocation ->
Optional.ofNullable(cellMap.get(invocation.getArgument(0)))
);
GrpcConfiguration grpcConfiguration = mock(GrpcConfiguration.class);
when(grpcConfiguration.getRequestTimeoutMs()).thenReturn(1000L);
final AggregatingCellClient aggregatingCellClient = new AggregatingCellClient(connector);
service = new AggregatingAutoScalingService(connector, grpcConfiguration,
new AggregatingJobManagementServiceHelper(aggregatingCellClient, grpcConfiguration),
aggregatingCellClient);
}
}
| 9,831 |
0 | Create_ds/titus-control-plane/titus-server-federation/src/test/java/com/netflix/titus/federation | Create_ds/titus-control-plane/titus-server-federation/src/test/java/com/netflix/titus/federation/service/CellWithFixedJobsService.java | /*
* Copyright 2018 Netflix, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.netflix.titus.federation.service;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.function.Function;
import java.util.stream.Collectors;
import com.google.protobuf.Empty;
import com.netflix.titus.api.model.Pagination;
import com.netflix.titus.api.model.PaginationUtil;
import com.netflix.titus.common.util.ProtobufExt;
import com.netflix.titus.common.util.tuple.Pair;
import com.netflix.titus.grpc.protogen.Job;
import com.netflix.titus.grpc.protogen.JobChangeNotification;
import com.netflix.titus.grpc.protogen.JobChangeNotification.SnapshotEnd;
import com.netflix.titus.grpc.protogen.JobId;
import com.netflix.titus.grpc.protogen.JobManagementServiceGrpc;
import com.netflix.titus.grpc.protogen.JobQuery;
import com.netflix.titus.grpc.protogen.JobQueryResult;
import com.netflix.titus.grpc.protogen.ObserveJobsQuery;
import com.netflix.titus.runtime.endpoint.common.grpc.GrpcUtil;
import com.netflix.titus.runtime.jobmanager.JobManagerCursors;
import io.grpc.stub.StreamObserver;
import rx.Observable;
import rx.Subscription;
import static com.netflix.titus.runtime.endpoint.v3.grpc.GrpcJobQueryModelConverters.toGrpcPagination;
import static com.netflix.titus.runtime.endpoint.v3.grpc.GrpcJobQueryModelConverters.toPage;
import static io.grpc.Status.NOT_FOUND;
class CellWithFixedJobsService extends JobManagementServiceGrpc.JobManagementServiceImplBase {
private final Map<String, Job> jobsIndex;
private final Observable<JobChangeNotification> updates;
CellWithFixedJobsService(List<Job> snapshot, Observable<JobChangeNotification> updates) {
this.jobsIndex = snapshot.stream().collect(Collectors.toMap(Job::getId, Function.identity()));
this.updates = updates;
}
private List<Job> getJobsList() {
return new ArrayList<>(jobsIndex.values());
}
@Override
public void findJob(JobId request, StreamObserver<Job> responseObserver) {
Job job = jobsIndex.get(request.getId());
if (job == null) {
responseObserver.onError(NOT_FOUND.asRuntimeException());
return;
}
responseObserver.onNext(job);
responseObserver.onCompleted();
}
@Override
public void findJobs(JobQuery request, StreamObserver<JobQueryResult> responseObserver) {
Pair<List<Job>, Pagination> page = PaginationUtil.takePageWithCursor(
toPage(request.getPage()),
getJobsList(),
JobManagerCursors.jobCursorOrderComparator(),
JobManagerCursors::jobIndexOf,
JobManagerCursors::newCursorFrom
);
Set<String> fieldsFilter = new HashSet<>(request.getFieldsList());
if (!fieldsFilter.isEmpty()) {
fieldsFilter.add("id");
page = page.mapLeft(jobs -> jobs.stream()
.map(job -> ProtobufExt.copy(job, fieldsFilter))
.collect(Collectors.toList()));
}
JobQueryResult result = JobQueryResult.newBuilder()
.addAllItems(page.getLeft())
.setPagination(toGrpcPagination(page.getRight()))
.build();
responseObserver.onNext(result);
responseObserver.onCompleted();
}
@Override
public void killJob(JobId request, StreamObserver<Empty> responseObserver) {
if (!jobsIndex.containsKey(request.getId())) {
responseObserver.onError(NOT_FOUND.asRuntimeException());
return;
}
jobsIndex.remove(request.getId());
responseObserver.onNext(Empty.getDefaultInstance());
responseObserver.onCompleted();
}
@Override
public void observeJobs(ObserveJobsQuery query, StreamObserver<JobChangeNotification> responseObserver) {
// TODO: query criteria (filters) are not implemented
for (Job job : jobsIndex.values()) {
JobChangeNotification.JobUpdate update = JobChangeNotification.JobUpdate.newBuilder().setJob(job).build();
JobChangeNotification notification = JobChangeNotification.newBuilder().setJobUpdate(update).build();
responseObserver.onNext(notification);
}
SnapshotEnd snapshotEnd = SnapshotEnd.newBuilder().build();
JobChangeNotification marker = JobChangeNotification.newBuilder().setSnapshotEnd(snapshotEnd).build();
responseObserver.onNext(marker);
final Subscription subscription = updates.subscribe(
responseObserver::onNext,
responseObserver::onError,
responseObserver::onCompleted
);
GrpcUtil.attachCancellingCallback(responseObserver, subscription);
}
Map<String, Job> currentJobs() {
return Collections.unmodifiableMap(jobsIndex);
}
}
| 9,832 |
0 | Create_ds/titus-control-plane/titus-server-federation/src/test/java/com/netflix/titus/federation | Create_ds/titus-control-plane/titus-server-federation/src/test/java/com/netflix/titus/federation/service/CellWithFixedTasksService.java | /*
* Copyright 2018 Netflix, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.netflix.titus.federation.service;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.function.Function;
import java.util.stream.Collectors;
import com.google.protobuf.Empty;
import com.netflix.titus.api.model.Pagination;
import com.netflix.titus.api.model.PaginationUtil;
import com.netflix.titus.common.util.ProtobufExt;
import com.netflix.titus.common.util.tuple.Pair;
import com.netflix.titus.grpc.protogen.JobManagementServiceGrpc;
import com.netflix.titus.grpc.protogen.Task;
import com.netflix.titus.grpc.protogen.TaskId;
import com.netflix.titus.grpc.protogen.TaskKillRequest;
import com.netflix.titus.grpc.protogen.TaskQuery;
import com.netflix.titus.grpc.protogen.TaskQueryResult;
import com.netflix.titus.runtime.jobmanager.JobManagerCursors;
import io.grpc.stub.StreamObserver;
import static com.netflix.titus.runtime.endpoint.v3.grpc.GrpcJobQueryModelConverters.toGrpcPagination;
import static com.netflix.titus.runtime.endpoint.v3.grpc.GrpcJobQueryModelConverters.toPage;
import static io.grpc.Status.NOT_FOUND;
class CellWithFixedTasksService extends JobManagementServiceGrpc.JobManagementServiceImplBase {
private final Map<String, Task> tasksIndex;
CellWithFixedTasksService(List<Task> snapshot) {
this.tasksIndex = snapshot.stream().collect(Collectors.toMap(Task::getId, Function.identity()));
}
private List<Task> getTasksList() {
return new ArrayList<>(tasksIndex.values());
}
@Override
public void findTask(TaskId request, StreamObserver<Task> responseObserver) {
Task task = tasksIndex.get(request.getId());
if (task == null) {
responseObserver.onError(NOT_FOUND.asRuntimeException());
return;
}
responseObserver.onNext(task);
responseObserver.onCompleted();
}
@Override
public void findTasks(TaskQuery request, StreamObserver<TaskQueryResult> responseObserver) {
Pair<List<Task>, Pagination> page = PaginationUtil.takePageWithCursor(
toPage(request.getPage()),
getTasksList(),
JobManagerCursors.taskCursorOrderComparator(),
JobManagerCursors::taskIndexOf,
JobManagerCursors::newTaskCursorFrom
);
Set<String> fieldsFilter = new HashSet<>(request.getFieldsList());
if (!fieldsFilter.isEmpty()) {
fieldsFilter.add("id");
page = page.mapLeft(tasks -> tasks.stream()
.map(task -> ProtobufExt.copy(task, fieldsFilter))
.collect(Collectors.toList()));
}
TaskQueryResult result = TaskQueryResult.newBuilder()
.addAllItems(page.getLeft())
.setPagination(toGrpcPagination(page.getRight()))
.build();
responseObserver.onNext(result);
responseObserver.onCompleted();
}
@Override
public void killTask(TaskKillRequest request, StreamObserver<Empty> responseObserver) {
if (!tasksIndex.containsKey(request.getTaskId())) {
responseObserver.onError(NOT_FOUND.asRuntimeException());
return;
}
tasksIndex.remove(request.getTaskId());
responseObserver.onNext(Empty.getDefaultInstance());
responseObserver.onCompleted();
}
Map<String, Task> currentTasks() {
return Collections.unmodifiableMap(tasksIndex);
}
}
| 9,833 |
0 | Create_ds/titus-control-plane/titus-server-federation/src/test/java/com/netflix/titus/federation | Create_ds/titus-control-plane/titus-server-federation/src/test/java/com/netflix/titus/federation/service/AutoScalingResourceTest.java | /*
* Copyright 2018 Netflix, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.netflix.titus.federation.service;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import javax.ws.rs.core.Response;
import com.google.protobuf.DoubleValue;
import com.netflix.titus.grpc.protogen.GetPolicyResult;
import com.netflix.titus.grpc.protogen.PutPolicyRequest;
import com.netflix.titus.grpc.protogen.ScalingPolicy;
import com.netflix.titus.grpc.protogen.ScalingPolicyID;
import com.netflix.titus.grpc.protogen.ScalingPolicyResult;
import com.netflix.titus.grpc.protogen.TargetTrackingPolicyDescriptor;
import com.netflix.titus.grpc.protogen.UpdatePolicyRequest;
import com.netflix.titus.runtime.endpoint.common.rest.RestException;
import com.netflix.titus.runtime.endpoint.metadata.AnonymousCallMetadataResolver;
import com.netflix.titus.runtime.endpoint.metadata.CallMetadataResolver;
import com.netflix.titus.runtime.endpoint.v3.rest.AutoScalingResource;
import io.grpc.Status;
import org.assertj.core.api.Assertions;
import org.junit.Test;
import static org.assertj.core.api.Java6Assertions.assertThat;
public class AutoScalingResourceTest extends AggregatingAutoScalingTestBase {
private final CallMetadataResolver callMetadataResolver = new AnonymousCallMetadataResolver();
@Test
public void getPoliciesFromTwoCells() {
ScalingPolicyID policy1 = ScalingPolicyID.newBuilder().setId(POLICY_1).build();
ScalingPolicyID policy2 = ScalingPolicyID.newBuilder().setId(POLICY_2).build();
List<ScalingPolicyID> policyIds = Arrays.asList(policy1, policy2);
ScalingPolicyResult policyOneResult = ScalingPolicyResult.newBuilder().setId(policy1).build();
ScalingPolicyResult policyTwoResult = ScalingPolicyResult.newBuilder().setId(policy2).build();
CellWithPolicies cellOneService = new CellWithPolicies(Collections.singletonList(policyOneResult));
CellWithPolicies cellTwoService = new CellWithPolicies(Collections.singletonList(policyTwoResult));
cellOne.getServiceRegistry().addService(cellOneService);
cellTwo.getServiceRegistry().addService(cellTwoService);
final AutoScalingResource autoScalingResource = new AutoScalingResource(service, callMetadataResolver);
final GetPolicyResult allScalingPolicies = autoScalingResource.getAllScalingPolicies();
assertThat(allScalingPolicies).isNotNull();
assertThat(allScalingPolicies.getItemsCount()).isEqualTo(2);
allScalingPolicies.getItemsList()
.forEach(scalingPolicyResult -> assertThat(policyIds.contains(scalingPolicyResult.getId())).isTrue());
}
@Test(expected = RestException.class)
public void getPoliciesFromTwoCellsWithOneFailing() {
ScalingPolicyID policy1 = ScalingPolicyID.newBuilder().setId(POLICY_1).build();
ScalingPolicyResult policyOneResult = ScalingPolicyResult.newBuilder().setId(policy1).build();
CellWithPolicies cellOneService = new CellWithPolicies(Collections.singletonList(policyOneResult));
CellWithFailingAutoscalingService badCell = new CellWithFailingAutoscalingService();
cellOne.getServiceRegistry().addService(cellOneService);
cellTwo.getServiceRegistry().addService(badCell);
final AutoScalingResource autoScalingResource = new AutoScalingResource(service, callMetadataResolver);
autoScalingResource.getAllScalingPolicies();
assertThat(false).isTrue();
}
@Test
public void getPoliciesForJobFromTwoCells() {
ScalingPolicyID policy1 = ScalingPolicyID.newBuilder().setId(POLICY_1).build();
ScalingPolicyID policy2 = ScalingPolicyID.newBuilder().setId(POLICY_2).build();
ScalingPolicyResult policyOneResult = ScalingPolicyResult.newBuilder().setId(policy1).setJobId(JOB_1).build();
ScalingPolicyResult policyTwoResult = ScalingPolicyResult.newBuilder().setId(policy2).setJobId(JOB_2).build();
CellWithPolicies cellOneService = new CellWithPolicies(Collections.singletonList(policyOneResult));
CellWithPolicies cellTwoService = new CellWithPolicies(Collections.singletonList(policyTwoResult));
cellOne.getServiceRegistry().addService(cellOneService);
cellTwo.getServiceRegistry().addService(cellTwoService);
final AutoScalingResource autoScalingResource = new AutoScalingResource(service, callMetadataResolver);
final GetPolicyResult scalingPolicyForJob = autoScalingResource.getScalingPolicyForJob(JOB_2);
assertThat(scalingPolicyForJob).isNotNull();
assertThat(scalingPolicyForJob.getItemsCount()).isEqualTo(1);
assertThat(scalingPolicyForJob.getItems(0).getJobId()).isEqualTo(JOB_2);
}
@Test
public void getPolicyByIdFromTwoCells() {
ScalingPolicyID policy1 = ScalingPolicyID.newBuilder().setId(POLICY_1).build();
ScalingPolicyID policy2 = ScalingPolicyID.newBuilder().setId(POLICY_2).build();
ScalingPolicyResult policyOneResult = ScalingPolicyResult.newBuilder().setId(policy1).build();
ScalingPolicyResult policyTwoResult = ScalingPolicyResult.newBuilder().setId(policy2).build();
CellWithPolicies cellOneService = new CellWithPolicies(Collections.singletonList(policyOneResult));
CellWithPolicies cellTwoService = new CellWithPolicies(Collections.singletonList(policyTwoResult));
cellOne.getServiceRegistry().addService(cellOneService);
cellTwo.getServiceRegistry().addService(cellTwoService);
final AutoScalingResource autoScalingResource = new AutoScalingResource(service, callMetadataResolver);
final GetPolicyResult scalingPolicy = autoScalingResource.getScalingPolicy(POLICY_2);
assertThat(scalingPolicy.getItemsCount()).isEqualTo(1);
assertThat(scalingPolicy.getItems(0).getId().getId()).isEqualTo(POLICY_2);
// bad id
Assertions.assertThatCode(() -> autoScalingResource.getScalingPolicy("badPolicyId"))
.hasCause(Status.CANCELLED.withDescription("server cancelled stream").asRuntimeException());
}
@Test
public void createAndUpdatePolicyForJobIdFromTwoCells() {
ScalingPolicyID policy1 = ScalingPolicyID.newBuilder().setId(POLICY_1).build();
ScalingPolicyID policy2 = ScalingPolicyID.newBuilder().setId(POLICY_2).build();
ScalingPolicyResult policyOneResult = ScalingPolicyResult.newBuilder().setId(policy1).setJobId(JOB_1).build();
ScalingPolicyResult policyTwoResult = ScalingPolicyResult.newBuilder().setId(policy2).setJobId(JOB_2).build();
CellWithPolicies cellOneService = new CellWithPolicies(Collections.singletonList(policyOneResult));
CellWithPolicies cellTwoService = new CellWithPolicies(Collections.singletonList(policyTwoResult));
CellWithJobIds cellOneJobsService = new CellWithJobIds(Collections.singletonList(JOB_1));
CellWithJobIds cellTwoJobsService = new CellWithJobIds(Collections.singletonList(JOB_2));
cellOne.getServiceRegistry().addService(cellOneService);
cellOne.getServiceRegistry().addService(cellOneJobsService);
cellTwo.getServiceRegistry().addService(cellTwoService);
cellTwo.getServiceRegistry().addService(cellTwoJobsService);
final AutoScalingResource autoScalingResource = new AutoScalingResource(service, callMetadataResolver);
final ScalingPolicyID scalingPolicyID = autoScalingResource.setScalingPolicy(PutPolicyRequest.newBuilder().setJobId(JOB_2).build());
assertThat(scalingPolicyID).isNotNull();
assertThat(scalingPolicyID.getId()).isNotEmpty();
final GetPolicyResult scalingPolicyForJob = autoScalingResource.getScalingPolicyForJob(JOB_2);
assertThat(scalingPolicyForJob).isNotNull();
assertThat(scalingPolicyForJob.getItemsCount()).isEqualTo(2);
assertThat(scalingPolicyForJob.getItems(0).getJobId()).isEqualTo(JOB_2);
assertThat(scalingPolicyForJob.getItems(1).getJobId()).isEqualTo(JOB_2);
UpdatePolicyRequest updatePolicyRequest = UpdatePolicyRequest.newBuilder()
.setPolicyId(ScalingPolicyID.newBuilder().setId(POLICY_2))
.setScalingPolicy(ScalingPolicy.newBuilder()
.setTargetPolicyDescriptor(TargetTrackingPolicyDescriptor.newBuilder()
.setTargetValue(DoubleValue.newBuilder().setValue(100.0).build()).build()).build()).build();
final Response updateScalingPolicyResponse = autoScalingResource.updateScalingPolicy(updatePolicyRequest);
assertThat(updateScalingPolicyResponse.getStatus()).isEqualTo(200);
final GetPolicyResult updatedScalingPolicy = autoScalingResource.getScalingPolicy(POLICY_2);
assertThat(updatedScalingPolicy.getItemsCount()).isEqualTo(1);
assertThat(updatedScalingPolicy.getItems(0).getJobId()).isEqualTo(JOB_2);
assertThat(updatedScalingPolicy.getItems(0).getId().getId()).isEqualTo(POLICY_2);
final DoubleValue targetValue = updatedScalingPolicy.getItems(0).getScalingPolicy().getTargetPolicyDescriptor().getTargetValue();
assertThat(targetValue.getValue()).isEqualTo(100.0);
}
@Test
public void createAndDeletePolicyForJobIdFromTwoCells() {
ScalingPolicyID policy1 = ScalingPolicyID.newBuilder().setId(POLICY_1).build();
ScalingPolicyID policy2 = ScalingPolicyID.newBuilder().setId(POLICY_2).build();
ScalingPolicyResult policyOneResult = ScalingPolicyResult.newBuilder().setId(policy1).setJobId(JOB_1).build();
ScalingPolicyResult policyTwoResult = ScalingPolicyResult.newBuilder().setId(policy2).setJobId(JOB_2).build();
CellWithPolicies cellOneService = new CellWithPolicies(Collections.singletonList(policyOneResult));
CellWithPolicies cellTwoService = new CellWithPolicies(Collections.singletonList(policyTwoResult));
CellWithJobIds cellOneJobsService = new CellWithJobIds(Collections.singletonList(JOB_1));
CellWithJobIds cellTwoJobsService = new CellWithJobIds(Collections.singletonList(JOB_2));
cellOne.getServiceRegistry().addService(cellOneService);
cellOne.getServiceRegistry().addService(cellOneJobsService);
cellTwo.getServiceRegistry().addService(cellTwoService);
cellTwo.getServiceRegistry().addService(cellTwoJobsService);
final AutoScalingResource autoScalingResource = new AutoScalingResource(service, callMetadataResolver);
final ScalingPolicyID scalingPolicyId = autoScalingResource.setScalingPolicy(PutPolicyRequest.newBuilder().setJobId(JOB_2).build());
assertThat(scalingPolicyId).isNotNull();
assertThat(scalingPolicyId.getId()).isNotEmpty();
final GetPolicyResult scalingPolicyForJob = autoScalingResource.getScalingPolicyForJob(JOB_2);
assertThat(scalingPolicyForJob).isNotNull();
assertThat(scalingPolicyForJob.getItemsCount()).isEqualTo(2);
assertThat(scalingPolicyForJob.getItems(0).getJobId()).isEqualTo(JOB_2);
assertThat(scalingPolicyForJob.getItems(1).getJobId()).isEqualTo(JOB_2);
final Response deleteResponse = autoScalingResource.removePolicy(scalingPolicyId.getId());
assertThat(deleteResponse.getStatus()).isEqualTo(200);
final GetPolicyResult scalingPolicyForJobResult = autoScalingResource.getScalingPolicyForJob(JOB_2);
assertThat(scalingPolicyForJobResult).isNotNull();
assertThat(scalingPolicyForJobResult.getItemsCount()).isEqualTo(1);
assertThat(scalingPolicyForJobResult.getItems(0).getJobId()).isEqualTo(JOB_2);
}
}
| 9,834 |
0 | Create_ds/titus-control-plane/titus-server-federation/src/test/java/com/netflix/titus/federation | Create_ds/titus-control-plane/titus-server-federation/src/test/java/com/netflix/titus/federation/service/CellWithJobStream.java | /*
* Copyright 2018 Netflix, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.netflix.titus.federation.service;
import com.netflix.titus.runtime.endpoint.common.grpc.GrpcUtil;
import com.netflix.titus.grpc.protogen.Job;
import com.netflix.titus.grpc.protogen.JobChangeNotification;
import com.netflix.titus.grpc.protogen.JobId;
import com.netflix.titus.grpc.protogen.JobManagementServiceGrpc;
import io.grpc.stub.StreamObserver;
import rx.Observable;
import rx.Subscription;
import static io.grpc.Status.NOT_FOUND;
class CellWithJobStream extends JobManagementServiceGrpc.JobManagementServiceImplBase {
private final String jobId;
private final Observable<JobChangeNotification> updates;
CellWithJobStream(String jobId, Observable<JobChangeNotification> updates) {
this.jobId = jobId;
this.updates = updates;
}
@Override
public void findJob(JobId request, StreamObserver<Job> responseObserver) {
if (!jobId.equals(request.getId())) {
responseObserver.onError(NOT_FOUND.asRuntimeException());
return;
}
responseObserver.onNext(Job.newBuilder().setId(jobId).build());
responseObserver.onCompleted();
}
@Override
public void observeJob(JobId request, StreamObserver<JobChangeNotification> responseObserver) {
if (!jobId.equals(request.getId())) {
responseObserver.onError(NOT_FOUND.asRuntimeException());
return;
}
final Subscription subscription = updates.subscribe(
responseObserver::onNext,
responseObserver::onError,
responseObserver::onCompleted
);
GrpcUtil.attachCancellingCallback(responseObserver, subscription);
}
}
| 9,835 |
0 | Create_ds/titus-control-plane/titus-server-federation/src/test/java/com/netflix/titus/federation | Create_ds/titus-control-plane/titus-server-federation/src/test/java/com/netflix/titus/federation/service/ServiceTests.java | /*
* Copyright 2018 Netflix, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.netflix.titus.federation.service;
import java.util.ArrayList;
import java.util.List;
import java.util.Optional;
import java.util.concurrent.TimeUnit;
import java.util.function.Function;
import rx.Observable;
import rx.observers.AssertableSubscriber;
import static org.assertj.core.api.Assertions.assertThat;
/**
* Common test utilities (functions).
*/
final class ServiceTests {
private ServiceTests() {
}
/**
* @param <Q> query type
* @param <R> result type
* @param <T> type of items in the result
*/
static <Q, R, T> List<T> walkAllPages(int pageWalkSize,
Function<Q, Observable<R>> pageFetcher,
Function<com.netflix.titus.grpc.protogen.Page, Q> queryFactory,
Function<R, com.netflix.titus.grpc.protogen.Pagination> paginationGetter,
Function<R, List<T>> itemsGetter) {
List<T> allItems = new ArrayList<>();
Optional<R> lastResult = Optional.empty();
int currentCursorPosition = -1;
int currentPageNumber = 0;
while (lastResult.map(r -> paginationGetter.apply(r).getHasMore()).orElse(true)) {
com.netflix.titus.grpc.protogen.Page.Builder builder = com.netflix.titus.grpc.protogen.Page.newBuilder().setPageSize(pageWalkSize);
if (lastResult.isPresent()) {
builder.setCursor(paginationGetter.apply(lastResult.get()).getCursor());
} else {
builder.setPageNumber(0);
}
Q query = queryFactory.apply(builder.build());
AssertableSubscriber<R> testSubscriber = pageFetcher.apply(query).test();
testSubscriber.awaitTerminalEvent(1, TimeUnit.SECONDS);
testSubscriber.assertNoErrors().assertCompleted();
testSubscriber.assertValueCount(1);
final List<R> results = testSubscriber.getOnNextEvents();
assertThat(results).hasSize(1);
R result = results.get(0);
List<T> items = itemsGetter.apply(result);
com.netflix.titus.grpc.protogen.Pagination pagination = paginationGetter.apply(result);
if (pagination.getHasMore()) {
assertThat(items).hasSize(pageWalkSize);
}
currentCursorPosition += items.size();
if (pagination.getTotalItems() > 0) {
assertThat(pagination.getCursorPosition()).isEqualTo(currentCursorPosition);
} else {
assertThat(pagination.getCursorPosition()).isEqualTo(0);
}
assertThat(pagination.getCurrentPage().getPageNumber()).isEqualTo(currentPageNumber++);
allItems.addAll(items);
lastResult = Optional.of(result);
testSubscriber.unsubscribe();
}
return allItems;
}
}
| 9,836 |
0 | Create_ds/titus-control-plane/titus-server-federation/src/test/java/com/netflix/titus/federation | Create_ds/titus-control-plane/titus-server-federation/src/test/java/com/netflix/titus/federation/service/AggregatingJobServiceGatewayWithSingleCellTest.java | /*
* Copyright 2018 Netflix, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.netflix.titus.federation.service;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.Random;
import java.util.UUID;
import java.util.concurrent.TimeUnit;
import java.util.stream.Collectors;
import com.google.common.collect.ImmutableMap;
import com.netflix.titus.api.federation.model.Cell;
import com.netflix.titus.api.model.Page;
import com.netflix.titus.common.runtime.TitusRuntime;
import com.netflix.titus.common.runtime.TitusRuntimes;
import com.netflix.titus.common.util.time.Clocks;
import com.netflix.titus.common.util.time.TestClock;
import com.netflix.titus.federation.service.router.ApplicationCellRouter;
import com.netflix.titus.federation.startup.GrpcConfiguration;
import com.netflix.titus.federation.startup.TitusFederationConfiguration;
import com.netflix.titus.grpc.protogen.Job;
import com.netflix.titus.grpc.protogen.JobDescriptor;
import com.netflix.titus.grpc.protogen.JobQuery;
import com.netflix.titus.grpc.protogen.JobQueryResult;
import com.netflix.titus.grpc.protogen.Task;
import com.netflix.titus.grpc.protogen.TaskQuery;
import com.netflix.titus.grpc.protogen.TaskQueryResult;
import com.netflix.titus.runtime.endpoint.metadata.AnonymousCallMetadataResolver;
import com.netflix.titus.runtime.endpoint.v3.grpc.GrpcJobManagementModelConverters;
import com.netflix.titus.runtime.jobmanager.JobManagerCursors;
import io.grpc.testing.GrpcServerRule;
import org.junit.Before;
import org.junit.Rule;
import org.junit.Test;
import rx.observers.AssertableSubscriber;
import rx.subjects.PublishSubject;
import static com.netflix.titus.api.jobmanager.service.JobManagerConstants.UNDEFINED_CALL_METADATA;
import static com.netflix.titus.runtime.endpoint.v3.grpc.GrpcJobQueryModelConverters.toGrpcPage;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.Mockito.any;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
public class AggregatingJobServiceGatewayWithSingleCellTest {
private static final int TASKS_IN_GENERATED_JOBS = 10;
private final TitusRuntime titusRuntime = TitusRuntimes.internal();
@Rule
public GrpcServerRule remoteFederationRule = new GrpcServerRule().directExecutor();
@Rule
public final GrpcServerRule cell = new GrpcServerRule().directExecutor();
private String stackName;
private AggregatingJobServiceGateway service;
private Map<Cell, GrpcServerRule> cellToServiceMap;
private TestClock clock;
private ServiceDataGenerator dataGenerator;
@Before
public void setUp() {
stackName = UUID.randomUUID().toString();
GrpcConfiguration grpcClientConfiguration = mock(GrpcConfiguration.class);
when(grpcClientConfiguration.getRequestTimeoutMs()).thenReturn(1000L);
TitusFederationConfiguration titusFederationConfiguration = mock(TitusFederationConfiguration.class);
when(titusFederationConfiguration.getStack()).thenReturn(stackName);
when(titusFederationConfiguration.getCells()).thenReturn("one=1");
when(titusFederationConfiguration.getRoutingRules()).thenReturn("one=(app1.*|app2.*);two=(app3.*)");
CellInfoResolver cellInfoResolver = new DefaultCellInfoResolver(titusFederationConfiguration);
ApplicationCellRouter cellRouter = new ApplicationCellRouter(cellInfoResolver, titusFederationConfiguration);
List<Cell> cells = cellInfoResolver.resolve();
cellToServiceMap = ImmutableMap.of(cells.get(0), cell);
RemoteFederationConnector fedConnector = mock(RemoteFederationConnector.class);
when(fedConnector.getChannel()).thenReturn(remoteFederationRule.getChannel());
CellConnector cellConnector = mock(CellConnector.class);
when(cellConnector.getChannels()).thenReturn(cellToServiceMap.entrySet().stream()
.collect(Collectors.toMap(Map.Entry::getKey, cellPairEntry -> cellPairEntry.getValue().getChannel()))
);
when(cellConnector.getChannelForCell(any(Cell.class))).thenAnswer(invocation ->
Optional.ofNullable(cellToServiceMap.get(invocation.<Cell>getArgument(0)))
.map(GrpcServerRule::getChannel)
);
final AggregatingCellClient aggregatingCellClient = new AggregatingCellClient(cellConnector);
final AnonymousCallMetadataResolver anonymousCallMetadataResolver = new AnonymousCallMetadataResolver();
service = new AggregatingJobServiceGateway(
grpcClientConfiguration,
titusFederationConfiguration,
cellConnector,
cellRouter,
aggregatingCellClient,
new AggregatingJobManagementServiceHelper(aggregatingCellClient, grpcClientConfiguration),
titusRuntime
);
clock = Clocks.test();
dataGenerator = new ServiceDataGenerator(clock, TASKS_IN_GENERATED_JOBS);
}
@Test
public void findJobsAddsStackName() {
Random random = new Random();
final List<Job> cellSnapshot = new ArrayList<>();
for (int i = 0; i < 5; i++) {
cellSnapshot.addAll(dataGenerator.newBatchJobs(random.nextInt(10), GrpcJobManagementModelConverters::toGrpcJob));
cellSnapshot.addAll(dataGenerator.newServiceJobs(random.nextInt(10), GrpcJobManagementModelConverters::toGrpcJob));
clock.advanceTime(1, TimeUnit.MINUTES);
}
cell.getServiceRegistry().addService(new CellWithFixedJobsService(cellSnapshot, PublishSubject.create()));
JobQuery query = JobQuery.newBuilder()
.setPage(toGrpcPage(Page.unlimited()))
.build();
final AssertableSubscriber<JobQueryResult> testSubscriber = service.findJobs(query, UNDEFINED_CALL_METADATA).test();
testSubscriber.awaitTerminalEvent(1, TimeUnit.SECONDS);
testSubscriber.assertNoErrors().assertCompleted();
testSubscriber.assertValueCount(1);
final List<JobQueryResult> results = testSubscriber.getOnNextEvents();
assertThat(results).hasSize(1);
// expect stackName to have changed
List<Job> expected = cellSnapshot.stream()
.sorted(JobManagerCursors.jobCursorOrderComparator())
.map(this::withStackName)
.collect(Collectors.toList());
assertThat(results.get(0).getItemsList()).containsExactlyElementsOf(expected);
}
@Test
public void findTasksMergesAllCellsIntoSingleResult() {
List<Task> cellSnapshot = new ArrayList<>();
// 10 jobs on each cell with TASKS_IN_GENERATED_JOBS tasks each
for (int i = 0; i < 5; i++) {
cellSnapshot.addAll(dataGenerator.newBatchJobWithTasks());
cellSnapshot.addAll(dataGenerator.newServiceJobWithTasks());
clock.advanceTime(1, TimeUnit.MINUTES);
}
cell.getServiceRegistry().addService(new CellWithFixedTasksService(cellSnapshot));
TaskQuery query = TaskQuery.newBuilder()
.setPage(toGrpcPage(Page.unlimited()))
.build();
final AssertableSubscriber<TaskQueryResult> testSubscriber = service.findTasks(query, UNDEFINED_CALL_METADATA).test();
testSubscriber.awaitTerminalEvent(1, TimeUnit.SECONDS);
testSubscriber.assertNoErrors().assertCompleted();
testSubscriber.assertValueCount(1);
final List<TaskQueryResult> results = testSubscriber.getOnNextEvents();
assertThat(results).hasSize(1);
// expect stackName to have changed
List<Task> expected = cellSnapshot.stream()
.sorted(JobManagerCursors.taskCursorOrderComparator())
.map(this::withStackName)
.collect(Collectors.toList());
assertThat(results.get(0).getItemsList()).containsExactlyElementsOf(expected);
}
private Job withStackName(Job job) {
JobDescriptor jobDescriptor = job.getJobDescriptor().toBuilder()
.putAttributes("titus.stack", stackName)
.build();
return job.toBuilder().setJobDescriptor(jobDescriptor).build();
}
private Task withStackName(Task task) {
return task.toBuilder()
.putTaskContext("titus.stack", stackName)
.build();
}
}
| 9,837 |
0 | Create_ds/titus-control-plane/titus-server-federation/src/test/java/com/netflix/titus/federation | Create_ds/titus-control-plane/titus-server-federation/src/test/java/com/netflix/titus/federation/service/CellWithLoadBalancers.java | /*
* Copyright 2018 Netflix, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.netflix.titus.federation.service;
import java.util.List;
import java.util.Set;
import java.util.stream.Collectors;
import com.google.protobuf.Empty;
import com.netflix.titus.api.loadbalancer.model.JobLoadBalancer;
import com.netflix.titus.api.model.PaginationUtil;
import com.netflix.titus.common.util.tuple.Pair;
import com.netflix.titus.grpc.protogen.AddLoadBalancerRequest;
import com.netflix.titus.grpc.protogen.GetAllLoadBalancersRequest;
import com.netflix.titus.grpc.protogen.GetAllLoadBalancersResult;
import com.netflix.titus.grpc.protogen.GetJobLoadBalancersResult;
import com.netflix.titus.grpc.protogen.JobId;
import com.netflix.titus.grpc.protogen.LoadBalancerId;
import com.netflix.titus.grpc.protogen.LoadBalancerServiceGrpc;
import com.netflix.titus.grpc.protogen.RemoveLoadBalancerRequest;
import com.netflix.titus.runtime.loadbalancer.LoadBalancerCursors;
import io.grpc.stub.StreamObserver;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import static com.netflix.titus.runtime.endpoint.v3.grpc.GrpcJobQueryModelConverters.toGrpcPagination;
import static com.netflix.titus.runtime.endpoint.v3.grpc.GrpcJobQueryModelConverters.toPage;
class CellWithLoadBalancers extends LoadBalancerServiceGrpc.LoadBalancerServiceImplBase {
private static final Logger logger = LoggerFactory.getLogger(CellWithLoadBalancers.class);
private List<JobLoadBalancer> jobLoadBalancerList;
CellWithLoadBalancers(List<JobLoadBalancer> jobLoadBalancerList) {
this.jobLoadBalancerList = jobLoadBalancerList;
}
@Override
public void getJobLoadBalancers(JobId request, StreamObserver<GetJobLoadBalancersResult> responseObserver) {
responseObserver.onNext(buildJobLoadBalancersResult(jobLoadBalancerList, request.getId()));
responseObserver.onCompleted();
}
@Override
public void getAllLoadBalancers(GetAllLoadBalancersRequest request, StreamObserver<GetAllLoadBalancersResult> responseObserver) {
Pair<List<JobLoadBalancer>, com.netflix.titus.api.model.Pagination> page = PaginationUtil.takePageWithCursor(
toPage(request.getPage()),
jobLoadBalancerList,
LoadBalancerCursors.loadBalancerComparator(),
LoadBalancerCursors::loadBalancerIndexOf,
LoadBalancerCursors::newCursorFrom
);
final List<JobLoadBalancer> jobLoadBalancersList = page.getLeft();
final Set<String> jobIds = jobLoadBalancersList.stream().map(jobLoadBalancer -> jobLoadBalancer.getJobId()).collect(Collectors.toSet());
final GetAllLoadBalancersResult.Builder allResultsBuilder = GetAllLoadBalancersResult.newBuilder();
final List<GetJobLoadBalancersResult> getJobLoadBalancersResults = jobIds.stream()
.map(jid -> buildJobLoadBalancersResult(jobLoadBalancersList, jid))
.collect(Collectors.toList());
allResultsBuilder.setPagination(toGrpcPagination(page.getRight())).addAllJobLoadBalancers(getJobLoadBalancersResults);
responseObserver.onNext(allResultsBuilder.build());
responseObserver.onCompleted();
}
@Override
public void addLoadBalancer(AddLoadBalancerRequest request, StreamObserver<Empty> responseObserver) {
jobLoadBalancerList.add(new JobLoadBalancer(request.getJobId(), request.getLoadBalancerId().getId()));
responseObserver.onNext(Empty.getDefaultInstance());
responseObserver.onCompleted();
}
@Override
public void removeLoadBalancer(RemoveLoadBalancerRequest request, StreamObserver<Empty> responseObserver) {
final String loadBalancerToDelete = request.getLoadBalancerId().getId();
jobLoadBalancerList = jobLoadBalancerList.stream()
.filter(jobLoadBalancer -> !jobLoadBalancer.getLoadBalancerId().equals(loadBalancerToDelete)).collect(Collectors.toList());
responseObserver.onNext(Empty.getDefaultInstance());
responseObserver.onCompleted();
}
private GetJobLoadBalancersResult buildJobLoadBalancersResult(List<JobLoadBalancer> lbList, String jobId) {
final List<LoadBalancerId> loadBalancerIdsForJob = lbList.stream().filter(jobLoadBalancer -> jobLoadBalancer.getJobId().equals(jobId))
.map(jobLoadBalancer -> LoadBalancerId.newBuilder().setId(jobLoadBalancer.getLoadBalancerId()).build())
.collect(Collectors.toList());
return GetJobLoadBalancersResult.newBuilder().setJobId(jobId).addAllLoadBalancers(loadBalancerIdsForJob).build();
}
}
| 9,838 |
0 | Create_ds/titus-control-plane/titus-server-federation/src/test/java/com/netflix/titus/federation | Create_ds/titus-control-plane/titus-server-federation/src/test/java/com/netflix/titus/federation/service/CellWithJobIds.java | /*
* Copyright 2018 Netflix, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.netflix.titus.federation.service;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import com.google.protobuf.Empty;
import com.netflix.titus.grpc.protogen.Job;
import com.netflix.titus.grpc.protogen.JobCapacityUpdate;
import com.netflix.titus.grpc.protogen.JobId;
import com.netflix.titus.grpc.protogen.JobManagementServiceGrpc;
import com.netflix.titus.grpc.protogen.JobProcessesUpdate;
import com.netflix.titus.grpc.protogen.JobStatusUpdate;
import io.grpc.stub.StreamObserver;
import static io.grpc.Status.NOT_FOUND;
class CellWithJobIds extends JobManagementServiceGrpc.JobManagementServiceImplBase {
private final List<String> jobIds;
private final Set<String> capacityUpdatesTracking = new HashSet<>();
private final Set<String> statusUpdatesTracking = new HashSet<>();
private final Set<String> processUpdatesTracking = new HashSet<>();
CellWithJobIds(List<String> jobIds) {
this.jobIds = jobIds;
}
@Override
public void findJob(JobId request, StreamObserver<Job> responseObserver) {
if (!jobIds.contains(request.getId())) {
responseObserver.onError(NOT_FOUND.asRuntimeException());
return;
}
responseObserver.onNext(Job.newBuilder().setId(request.getId()).build());
responseObserver.onCompleted();
}
@Override
public void updateJobCapacity(JobCapacityUpdate request, StreamObserver<Empty> responseObserver) {
if (!jobIds.contains(request.getJobId())) {
responseObserver.onError(NOT_FOUND.asRuntimeException());
return;
}
capacityUpdatesTracking.add(request.getJobId());
responseObserver.onNext(Empty.getDefaultInstance());
responseObserver.onCompleted();
}
@Override
public void updateJobStatus(JobStatusUpdate request, StreamObserver<Empty> responseObserver) {
if (!jobIds.contains(request.getId())) {
responseObserver.onError(NOT_FOUND.asRuntimeException());
return;
}
statusUpdatesTracking.add(request.getId());
responseObserver.onNext(Empty.getDefaultInstance());
responseObserver.onCompleted();
}
@Override
public void updateJobProcesses(JobProcessesUpdate request, StreamObserver<Empty> responseObserver) {
if (!jobIds.contains(request.getJobId())) {
responseObserver.onError(NOT_FOUND.asRuntimeException());
return;
}
processUpdatesTracking.add(request.getJobId());
responseObserver.onNext(Empty.getDefaultInstance());
responseObserver.onCompleted();
}
public boolean containsCapacityUpdates(String jobId) {
return capacityUpdatesTracking.contains(jobId);
}
public boolean containsStatusUpdates(String jobId) {
return statusUpdatesTracking.contains(jobId);
}
public boolean containsProcessUpdates(String jobId) {
return processUpdatesTracking.contains(jobId);
}
}
| 9,839 |
0 | Create_ds/titus-control-plane/titus-server-federation/src/test/java/com/netflix/titus/federation | Create_ds/titus-control-plane/titus-server-federation/src/test/java/com/netflix/titus/federation/service/AggregatingLoadBalancerServiceTest.java | /*
* Copyright 2018 Netflix, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.netflix.titus.federation.service;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.concurrent.TimeUnit;
import java.util.stream.Collectors;
import com.netflix.titus.api.federation.model.Cell;
import com.netflix.titus.api.loadbalancer.model.JobLoadBalancer;
import com.netflix.titus.federation.startup.GrpcConfiguration;
import com.netflix.titus.grpc.protogen.AddLoadBalancerRequest;
import com.netflix.titus.grpc.protogen.GetAllLoadBalancersRequest;
import com.netflix.titus.grpc.protogen.GetAllLoadBalancersResult;
import com.netflix.titus.grpc.protogen.GetJobLoadBalancersResult;
import com.netflix.titus.grpc.protogen.JobId;
import com.netflix.titus.grpc.protogen.LoadBalancerId;
import com.netflix.titus.grpc.protogen.Page;
import com.netflix.titus.grpc.protogen.RemoveLoadBalancerRequest;
import com.netflix.titus.runtime.endpoint.metadata.AnonymousCallMetadataResolver;
import io.grpc.ManagedChannel;
import io.grpc.Status;
import io.grpc.testing.GrpcServerRule;
import org.junit.Before;
import org.junit.Rule;
import org.junit.Test;
import rx.Observable;
import rx.observers.AssertableSubscriber;
import static com.netflix.titus.testkit.junit.spring.SpringMockMvcUtil.JUNIT_REST_CALL_METADATA;
import static java.util.Collections.singletonList;
import static org.assertj.core.api.Java6Assertions.assertThat;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
public class AggregatingLoadBalancerServiceTest {
private static final String JOB_1 = "job1";
private static final String JOB_2 = "job2";
private static final String LB_1 = "loadBalancer1";
private static final String LB_2 = "loadBalancer2";
private static final String LB_3 = "loadBalancer3";
@Rule
public final GrpcServerRule cellOne = new GrpcServerRule().directExecutor();
@Rule
public final GrpcServerRule cellTwo = new GrpcServerRule().directExecutor();
AggregatingLoadbalancerService service;
@Before
public void setup() {
CellConnector connector = mock(CellConnector.class);
Map<Cell, ManagedChannel> cellMap = new HashMap<>();
cellMap.put(new Cell("one", "1"), cellOne.getChannel());
cellMap.put(new Cell("two", "2"), cellTwo.getChannel());
when(connector.getChannels()).thenReturn(cellMap);
when(connector.getChannelForCell(any())).then(invocation ->
Optional.ofNullable(cellMap.get(invocation.getArgument(0)))
);
GrpcConfiguration grpcConfiguration = mock(GrpcConfiguration.class);
when(grpcConfiguration.getRequestTimeoutMs()).thenReturn(1000L);
final AnonymousCallMetadataResolver anonymousCallMetadataResolver = new AnonymousCallMetadataResolver();
final AggregatingCellClient aggregatingCellClient = new AggregatingCellClient(connector);
service = new AggregatingLoadbalancerService(connector, anonymousCallMetadataResolver, grpcConfiguration, aggregatingCellClient,
new AggregatingJobManagementServiceHelper(aggregatingCellClient, grpcConfiguration));
}
@Test
public void getLoadBalancersForJob() {
JobLoadBalancer jobLoadBalancer1 = new JobLoadBalancer(JOB_1, LB_1);
JobLoadBalancer jobLoadBalancer2 = new JobLoadBalancer(JOB_2, LB_2);
final CellWithLoadBalancers cellWithLoadBalancersOne = new CellWithLoadBalancers(singletonList(jobLoadBalancer1));
final CellWithLoadBalancers cellWithLoadBalancersTwo = new CellWithLoadBalancers(singletonList(jobLoadBalancer2));
cellOne.getServiceRegistry().addService(cellWithLoadBalancersOne);
cellTwo.getServiceRegistry().addService(cellWithLoadBalancersTwo);
final AssertableSubscriber<GetJobLoadBalancersResult> resultSubscriber = service.getLoadBalancers(JobId.newBuilder().setId(JOB_2).build(), JUNIT_REST_CALL_METADATA).test();
resultSubscriber.awaitValueCount(1, 1, TimeUnit.SECONDS);
resultSubscriber.assertNoErrors();
final List<GetJobLoadBalancersResult> onNextEvents = resultSubscriber.getOnNextEvents();
assertThat(onNextEvents.size()).isEqualTo(1);
assertThat(onNextEvents.get(0).getJobId()).isEqualTo(JOB_2);
assertThat(onNextEvents.get(0).getLoadBalancersCount()).isEqualTo(1);
assertThat(onNextEvents.get(0).getLoadBalancers(0).getId()).isEqualTo(LB_2);
}
@Test
public void addLoadBalancer() {
JobLoadBalancer jobLoadBalancer1 = new JobLoadBalancer(JOB_1, LB_1);
JobLoadBalancer jobLoadBalancer2 = new JobLoadBalancer(JOB_2, LB_2);
final CellWithLoadBalancers cellWithLoadBalancersOne = new CellWithLoadBalancers(singletonList(jobLoadBalancer1));
final CellWithLoadBalancers cellWithLoadBalancersTwo = new CellWithLoadBalancers(new ArrayList<>(singletonList(jobLoadBalancer2)));
final CellWithJobIds cellWithJobIdsOne = new CellWithJobIds(singletonList(JOB_1));
final CellWithJobIds cellWithJobIdsTwo = new CellWithJobIds(singletonList(JOB_2));
cellOne.getServiceRegistry().addService(cellWithLoadBalancersOne);
cellOne.getServiceRegistry().addService(cellWithJobIdsOne);
cellTwo.getServiceRegistry().addService(cellWithLoadBalancersTwo);
cellTwo.getServiceRegistry().addService(cellWithJobIdsTwo);
final AssertableSubscriber<Void> resultSubscriber = service.addLoadBalancer(
AddLoadBalancerRequest.newBuilder().setJobId(JOB_2).setLoadBalancerId(LoadBalancerId.newBuilder().setId(LB_3).build()).build(),
JUNIT_REST_CALL_METADATA
).test();
resultSubscriber.awaitTerminalEvent(1, TimeUnit.SECONDS);
resultSubscriber.assertNoErrors();
resultSubscriber.assertNoValues();
resultSubscriber.assertCompleted();
final AssertableSubscriber<GetJobLoadBalancersResult> jobResults = service.getLoadBalancers(
JobId.newBuilder().setId(JOB_2).build(),
JUNIT_REST_CALL_METADATA
).test();
jobResults.assertNoErrors();
final List<GetJobLoadBalancersResult> onNextEvents = jobResults.getOnNextEvents();
assertThat(onNextEvents.size()).isEqualTo(1);
final List<LoadBalancerId> loadBalancersList = onNextEvents.get(0).getLoadBalancersList();
assertThat(loadBalancersList.size()).isEqualTo(2);
final List<String> resultLoadBalancerIds = loadBalancersList.stream().map(LoadBalancerId::getId).collect(Collectors.toList());
assertThat(resultLoadBalancerIds).contains(LB_2, LB_3);
}
@Test
public void removeLoadBalancer() {
JobLoadBalancer jobLoadBalancer1 = new JobLoadBalancer(JOB_1, LB_1);
JobLoadBalancer jobLoadBalancer2 = new JobLoadBalancer(JOB_2, LB_2);
JobLoadBalancer jobLoadBalancer3 = new JobLoadBalancer(JOB_2, LB_3);
final CellWithLoadBalancers cellWithLoadBalancersOne = new CellWithLoadBalancers(singletonList(jobLoadBalancer1));
final CellWithLoadBalancers cellWithLoadBalancersTwo = new CellWithLoadBalancers(new ArrayList<>(Arrays.asList(jobLoadBalancer2, jobLoadBalancer3)));
final CellWithJobIds cellWithJobIdsOne = new CellWithJobIds(singletonList(JOB_1));
final CellWithJobIds cellWithJobIdsTwo = new CellWithJobIds(singletonList(JOB_2));
cellOne.getServiceRegistry().addService(cellWithLoadBalancersOne);
cellOne.getServiceRegistry().addService(cellWithJobIdsOne);
cellTwo.getServiceRegistry().addService(cellWithLoadBalancersTwo);
cellTwo.getServiceRegistry().addService(cellWithJobIdsTwo);
final AssertableSubscriber<Void> resultSubscriber = service.removeLoadBalancer(
RemoveLoadBalancerRequest.newBuilder().setJobId(JOB_2).setLoadBalancerId(LoadBalancerId.newBuilder().setId(LB_2).build()).build(),
JUNIT_REST_CALL_METADATA
).test();
resultSubscriber.awaitTerminalEvent(1, TimeUnit.SECONDS);
resultSubscriber.assertNoErrors();
resultSubscriber.assertNoValues();
resultSubscriber.assertCompleted();
final AssertableSubscriber<GetJobLoadBalancersResult> jobResults = service.getLoadBalancers(
JobId.newBuilder().setId(JOB_2).build(),
JUNIT_REST_CALL_METADATA
).test();
jobResults.awaitValueCount(1, 1, TimeUnit.SECONDS);
jobResults.assertNoErrors();
final List<GetJobLoadBalancersResult> onNextEvents = jobResults.getOnNextEvents();
assertThat(onNextEvents.size()).isEqualTo(1);
final List<LoadBalancerId> loadBalancersList = onNextEvents.get(0).getLoadBalancersList();
assertThat(loadBalancersList.size()).isEqualTo(1);
assertThat(loadBalancersList.get(0).getId()).isEqualTo(LB_3);
}
@Test
public void getAllLoadBalancersNoPagination() {
JobLoadBalancer jobLoadBalancer1 = new JobLoadBalancer(JOB_1, LB_1);
JobLoadBalancer jobLoadBalancer2 = new JobLoadBalancer(JOB_2, LB_2);
final CellWithLoadBalancers cellWithLoadBalancersOne = new CellWithLoadBalancers(singletonList(jobLoadBalancer1));
final CellWithLoadBalancers cellWithLoadBalancersTwo = new CellWithLoadBalancers(singletonList(jobLoadBalancer2));
cellOne.getServiceRegistry().addService(cellWithLoadBalancersOne);
cellTwo.getServiceRegistry().addService(cellWithLoadBalancersTwo);
final AssertableSubscriber<GetAllLoadBalancersResult> resultSubscriber = service.getAllLoadBalancers(
GetAllLoadBalancersRequest.newBuilder().setPage(Page.newBuilder().setPageNumber(0).setPageSize(10)).build(),
JUNIT_REST_CALL_METADATA
).test();
resultSubscriber.awaitValueCount(1, 1, TimeUnit.SECONDS);
resultSubscriber.assertNoErrors();
final List<GetAllLoadBalancersResult> onNextEvents = resultSubscriber.getOnNextEvents();
assertThat(onNextEvents).hasSize(1);
assertThat(onNextEvents.get(0).getJobLoadBalancersCount()).isEqualTo(2);
}
@Test
public void getAllLoadBalancersWithPagination() {
final List<JobLoadBalancer> jobLoadBalancersOne = Observable.range(1, 5)
.map(i -> new JobLoadBalancer(JOB_1, String.format("LB_1_%d", i.intValue())))
.toList().toBlocking().first();
final List<JobLoadBalancer> jobLoadBalancersTwo = Observable.range(1, 5)
.map(i -> new JobLoadBalancer(JOB_2, String.format("LB_2_%d", i.intValue())))
.toList().toBlocking().first();
final CellWithLoadBalancers cellWithLoadBalancersOne = new CellWithLoadBalancers(jobLoadBalancersOne);
final CellWithLoadBalancers cellWithLoadBalancersTwo = new CellWithLoadBalancers(jobLoadBalancersTwo);
cellOne.getServiceRegistry().addService(cellWithLoadBalancersOne);
cellTwo.getServiceRegistry().addService(cellWithLoadBalancersTwo);
final List<JobLoadBalancer> results = ServiceTests.walkAllPages(
2,
request -> service.getAllLoadBalancers(request, JUNIT_REST_CALL_METADATA),
page -> GetAllLoadBalancersRequest.newBuilder().setPage(page).build(),
GetAllLoadBalancersResult::getPagination,
this::buildJobLoadBalancerList
);
assertThat(results).hasSize(10);
}
@Test
public void getLoadBalancersWithOneFailingCell() {
JobLoadBalancer jobLoadBalancer1 = new JobLoadBalancer(JOB_1, LB_1);
JobLoadBalancer jobLoadBalancer2 = new JobLoadBalancer(JOB_1, LB_2);
final CellWithLoadBalancers cellWithLoadBalancersOne = new CellWithLoadBalancers(
Arrays.asList(jobLoadBalancer1, jobLoadBalancer2));
cellOne.getServiceRegistry().addService(cellWithLoadBalancersOne);
cellTwo.getServiceRegistry().addService(new CellWithFailingLoadBalancers(Status.INTERNAL));
final AssertableSubscriber<GetAllLoadBalancersResult> resultSubscriber = service.getAllLoadBalancers(
GetAllLoadBalancersRequest.newBuilder().setPage(Page.newBuilder().setPageSize(10)).build(),
JUNIT_REST_CALL_METADATA
).test();
resultSubscriber.awaitTerminalEvent(1, TimeUnit.SECONDS);
resultSubscriber.assertNoValues();
final List<Throwable> onErrorEvents = resultSubscriber.getOnErrorEvents();
assertThat(onErrorEvents).hasSize(1);
assertThat(Status.fromThrowable(onErrorEvents.get(0))).isEqualTo(Status.INTERNAL);
}
@Test
public void getLoadBalancersWithTwoFailingCell() {
cellOne.getServiceRegistry().addService(new CellWithFailingLoadBalancers(Status.UNAVAILABLE));
cellTwo.getServiceRegistry().addService(new CellWithFailingLoadBalancers(Status.INTERNAL));
final AssertableSubscriber<GetAllLoadBalancersResult> resultSubscriber = service.getAllLoadBalancers(
GetAllLoadBalancersRequest.newBuilder().setPage(Page.newBuilder().setPageSize(10)).build(),
JUNIT_REST_CALL_METADATA
).test();
resultSubscriber.awaitTerminalEvent(1, TimeUnit.SECONDS);
resultSubscriber.assertNoValues();
final List<Throwable> onErrorEvents = resultSubscriber.getOnErrorEvents();
assertThat(onErrorEvents).hasSize(1);
assertThat(Status.fromThrowable(onErrorEvents.get(0))).isEqualTo(Status.INTERNAL);
}
@Test
public void getJobLoadBalancersWithOneFailingCell() {
JobLoadBalancer jobLoadBalancer1 = new JobLoadBalancer(JOB_1, LB_1);
JobLoadBalancer jobLoadBalancer2 = new JobLoadBalancer(JOB_1, LB_2);
final CellWithLoadBalancers cellWithLoadBalancersOne = new CellWithLoadBalancers(
Arrays.asList(jobLoadBalancer1, jobLoadBalancer2));
cellOne.getServiceRegistry().addService(cellWithLoadBalancersOne);
cellTwo.getServiceRegistry().addService(new CellWithFailingLoadBalancers(Status.INTERNAL));
final AssertableSubscriber<GetJobLoadBalancersResult> resultSubscriber = service.getLoadBalancers(
JobId.newBuilder().setId(JOB_1).build(),
JUNIT_REST_CALL_METADATA
).test();
resultSubscriber.awaitValueCount(1, 1, TimeUnit.SECONDS);
resultSubscriber.assertNoErrors();
final List<GetJobLoadBalancersResult> onNextEvents = resultSubscriber.getOnNextEvents();
assertThat(onNextEvents).hasSize(1);
final List<LoadBalancerId> loadBalancersList = onNextEvents.get(0).getLoadBalancersList();
final List<String> resultLoadBalancers = loadBalancersList.stream().map(loadBalancerId -> loadBalancerId.getId()).collect(Collectors.toList());
assertThat(resultLoadBalancers).contains(LB_1, LB_2);
}
@Test
public void getJobLoadBalancersWithTwoFailingCell() {
cellOne.getServiceRegistry().addService(new CellWithFailingLoadBalancers(Status.NOT_FOUND));
cellTwo.getServiceRegistry().addService(new CellWithFailingLoadBalancers(Status.INTERNAL));
final AssertableSubscriber<GetJobLoadBalancersResult> resultSubscriber = service.getLoadBalancers(
JobId.newBuilder().setId(JOB_1).build(),
JUNIT_REST_CALL_METADATA
).test();
resultSubscriber.awaitTerminalEvent(1, TimeUnit.SECONDS);
resultSubscriber.assertNoValues();
final List<Throwable> onErrorEvents = resultSubscriber.getOnErrorEvents();
assertThat(onErrorEvents).hasSize(1);
assertThat(Status.fromThrowable(onErrorEvents.get(0))).isEqualTo(Status.INTERNAL);
}
@Test
public void getJobLoadBalancersInvalidJobId() {
cellOne.getServiceRegistry().addService(new CellWithFailingLoadBalancers(Status.NOT_FOUND));
cellTwo.getServiceRegistry().addService(new CellWithFailingLoadBalancers(Status.NOT_FOUND));
final AssertableSubscriber<GetJobLoadBalancersResult> resultSubscriber = service.getLoadBalancers(
JobId.newBuilder().setId(JOB_1).build(),
JUNIT_REST_CALL_METADATA
).test();
resultSubscriber.awaitTerminalEvent(1, TimeUnit.SECONDS);
resultSubscriber.assertNoValues();
final List<Throwable> onErrorEvents = resultSubscriber.getOnErrorEvents();
assertThat(onErrorEvents).hasSize(1);
assertThat(Status.fromThrowable(onErrorEvents.get(0))).isEqualTo(Status.NOT_FOUND);
}
@Test
public void getJobLoadBalancersNoAssociations() {
cellOne.getServiceRegistry().addService(new CellWithLoadBalancers(Collections.emptyList()));
cellTwo.getServiceRegistry().addService(new CellWithLoadBalancers(Collections.emptyList()));
final AssertableSubscriber<GetJobLoadBalancersResult> resultSubscriber = service.getLoadBalancers(
JobId.newBuilder().setId(JOB_1).build(),
JUNIT_REST_CALL_METADATA
).test();
resultSubscriber.awaitTerminalEvent(1, TimeUnit.SECONDS);
resultSubscriber.assertNoErrors().assertCompleted();
resultSubscriber.assertValueCount(1);
assertThat(resultSubscriber.getOnNextEvents().get(0).getLoadBalancersCount()).isZero();
}
private List<JobLoadBalancer> buildJobLoadBalancerList(GetAllLoadBalancersResult getAllLoadBalancersResult) {
return getAllLoadBalancersResult.getJobLoadBalancersList().stream()
.flatMap(jobLoadBalancersResult -> {
final String jobId = jobLoadBalancersResult.getJobId();
return jobLoadBalancersResult.getLoadBalancersList().stream()
.map(loadBalancerId -> new JobLoadBalancer(jobId, loadBalancerId.getId()));
}).collect(Collectors.toList());
}
}
| 9,840 |
0 | Create_ds/titus-control-plane/titus-server-federation/src/test/java/com/netflix/titus/federation | Create_ds/titus-control-plane/titus-server-federation/src/test/java/com/netflix/titus/federation/service/CellWithFailingAutoscalingService.java | /*
* Copyright 2018 Netflix, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.netflix.titus.federation.service;
import com.google.protobuf.Empty;
import com.netflix.titus.grpc.protogen.AutoScalingServiceGrpc;
import com.netflix.titus.grpc.protogen.GetPolicyResult;
import io.grpc.Status;
import io.grpc.stub.StreamObserver;
public class CellWithFailingAutoscalingService extends AutoScalingServiceGrpc.AutoScalingServiceImplBase {
@Override
public void getAllScalingPolicies(Empty request, StreamObserver<GetPolicyResult> responseObserver) {
responseObserver.onError(Status.UNAVAILABLE.asRuntimeException());
}
}
| 9,841 |
0 | Create_ds/titus-control-plane/titus-server-federation/src/test/java/com/netflix/titus/federation | Create_ds/titus-control-plane/titus-server-federation/src/test/java/com/netflix/titus/federation/service/ServiceDataGenerator.java | /*
* Copyright 2018 Netflix, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.netflix.titus.federation.service;
import java.util.ArrayList;
import java.util.List;
import java.util.function.Function;
import java.util.stream.Collectors;
import com.netflix.titus.api.jobmanager.model.job.Capacity;
import com.netflix.titus.api.jobmanager.model.job.Job;
import com.netflix.titus.api.jobmanager.model.job.JobFunctions;
import com.netflix.titus.api.jobmanager.model.job.ext.BatchJobExt;
import com.netflix.titus.api.jobmanager.model.job.ext.ServiceJobExt;
import com.netflix.titus.common.data.generator.DataGenerator;
import com.netflix.titus.common.util.time.Clock;
import com.netflix.titus.common.util.tuple.Pair;
import com.netflix.titus.grpc.protogen.Task;
import com.netflix.titus.runtime.endpoint.common.EmptyLogStorageInfo;
import com.netflix.titus.runtime.endpoint.v3.grpc.GrpcJobManagementModelConverters;
import com.netflix.titus.testkit.model.job.JobDescriptorGenerator;
import com.netflix.titus.testkit.model.job.JobGenerator;
class ServiceDataGenerator {
private DataGenerator<Job<BatchJobExt>> batchJobs;
private DataGenerator<Job<ServiceJobExt>> serviceJobs;
ServiceDataGenerator(Clock clock, int tasksInJob) {
batchJobs = JobGenerator.batchJobs(JobDescriptorGenerator.batchJobDescriptors().map(descriptor -> {
BatchJobExt extensions = descriptor.getExtensions().toBuilder()
.withSize(tasksInJob)
.build();
return descriptor.toBuilder().withExtensions(extensions).build();
}).getValue(), clock);
serviceJobs = JobGenerator.serviceJobs(JobDescriptorGenerator.serviceJobDescriptors().map(descriptor -> {
ServiceJobExt extensions = descriptor.getExtensions().toBuilder()
.withCapacity(new Capacity(tasksInJob, tasksInJob, tasksInJob))
.build();
return descriptor.toBuilder().withExtensions(extensions).build();
}).getValue(), clock);
}
<T> T newBatchJob(Function<Job<BatchJobExt>, T> mapper) {
return newBatchJobs(1, mapper).get(0);
}
Job<BatchJobExt> newBatchJob() {
return newBatchJobs(1).get(0);
}
<T> List<T> newBatchJobs(int count, Function<Job<BatchJobExt>, T> mapper) {
return newBatchJobs(count).stream().map(mapper).collect(Collectors.toList());
}
List<Job<BatchJobExt>> newBatchJobs(int count) {
Pair<DataGenerator<Job<BatchJobExt>>, List<Job<BatchJobExt>>> generated = batchJobs.getAndApply(count);
batchJobs = generated.getLeft();
return generated.getRight();
}
<T> T newServiceJob(Function<Job<ServiceJobExt>, T> mapper) {
return newServiceJobs(1, mapper).get(0);
}
<T> List<T> newServiceJobs(int count, Function<Job<ServiceJobExt>, T> mapper) {
return newServiceJobs(count).stream().map(mapper).collect(Collectors.toList());
}
Job<ServiceJobExt> newServiceJob() {
return newServiceJobs(1).get(0);
}
List<Job<ServiceJobExt>> newServiceJobs(int count) {
Pair<DataGenerator<Job<ServiceJobExt>>, List<Job<ServiceJobExt>>> generated = serviceJobs.getAndApply(count);
serviceJobs = generated.getLeft();
return generated.getRight();
}
List<Task> newBatchJobWithTasks() {
List<Task> generatedTasks = new ArrayList<>();
batchJobs = batchJobs.apply(job -> {
List<Task> tasks = JobGenerator.batchTasks(job)
.limit(JobFunctions.getJobDesiredSize(job))
.map(t -> GrpcJobManagementModelConverters.toGrpcTask(t, new EmptyLogStorageInfo<>()))
.toList();
generatedTasks.addAll(tasks);
}, 1);
return generatedTasks;
}
List<Task> newServiceJobWithTasks() {
List<Task> generatedTasks = new ArrayList<>();
serviceJobs = serviceJobs.apply(job -> {
List<Task> tasks = JobGenerator.serviceTasks(job)
.limit(JobFunctions.getJobDesiredSize(job))
.map(t -> GrpcJobManagementModelConverters.toGrpcTask(t, new EmptyLogStorageInfo<>()))
.toList();
generatedTasks.addAll(tasks);
}, 1);
return generatedTasks;
}
}
| 9,842 |
0 | Create_ds/titus-control-plane/titus-server-federation/src/test/java/com/netflix/titus/federation/service | Create_ds/titus-control-plane/titus-server-federation/src/test/java/com/netflix/titus/federation/service/router/RoutingRuleSelectorTest.java | /*
* Copyright 2020 Netflix, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.netflix.titus.federation.service.router;
import java.util.concurrent.atomic.AtomicReference;
import com.netflix.titus.api.federation.model.Cell;
import com.netflix.titus.federation.service.CellInfoResolver;
import org.junit.Before;
import org.junit.Test;
import static java.util.Arrays.asList;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
public class RoutingRuleSelectorTest {
private static final Cell CELL_1 = new Cell("cell1", "cell.1");
private static final Cell CELL_2 = new Cell("cell2", "cell.2");
private final CellInfoResolver cellInfoResolver = mock(CellInfoResolver.class);
@Before
public void setUp() {
when(cellInfoResolver.resolve()).thenReturn(asList(CELL_1, CELL_2));
}
@Test(expected = NullPointerException.class)
public void testFailFast() {
new RoutingRuleSelector(cellInfoResolver, () -> null);
}
@Test
public void testParser() {
RoutingRuleSelector selector = new RoutingRuleSelector(cellInfoResolver, () -> "cell1=(app1.*);cell2=(app2.*)");
assertThat(selector.select("app1", cell -> true)).contains(CELL_1);
assertThat(selector.select("app2", cell -> true)).contains(CELL_2);
}
@Test
public void testReload() {
AtomicReference<String> rules = new AtomicReference<>("cell1=(app1.*);cell2=(app2.*)");
RoutingRuleSelector selector = new RoutingRuleSelector(cellInfoResolver, rules::get);
assertThat(selector.select("app1", cell -> true)).contains(CELL_1);
rules.set("cell1=(app2.*);cell2=(app1.*)");
assertThat(selector.select("app1", cell -> true)).contains(CELL_2);
}
@Test
public void testReloadFailure() {
AtomicReference<String> rules = new AtomicReference<>("cell1=(app1.*);cell2=(app2.*)");
RoutingRuleSelector selector = new RoutingRuleSelector(cellInfoResolver, rules::get);
assertThat(selector.select("app1", cell -> true)).contains(CELL_1);
rules.set(null);
assertThat(selector.select("app1", cell -> true)).contains(CELL_1);
rules.set("cell1=(app2.*);cell2=(app1.*)");
assertThat(selector.select("app1", cell -> true)).contains(CELL_2);
}
} | 9,843 |
0 | Create_ds/titus-control-plane/titus-server-federation/src/test/java/com/netflix/titus/federation/service | Create_ds/titus-control-plane/titus-server-federation/src/test/java/com/netflix/titus/federation/service/router/SpecialInstanceTypeRouterTest.java | /*
* Copyright 2020 Netflix, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.netflix.titus.federation.service.router;
import com.netflix.titus.api.federation.model.Cell;
import com.netflix.titus.federation.service.CellInfoResolver;
import com.netflix.titus.federation.startup.TitusFederationConfiguration;
import com.netflix.titus.grpc.protogen.Container;
import com.netflix.titus.grpc.protogen.ContainerResources;
import com.netflix.titus.grpc.protogen.JobDescriptor;
import org.junit.Before;
import org.junit.Test;
import static java.util.Arrays.asList;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
public class SpecialInstanceTypeRouterTest {
private static final Cell CELL_1 = new Cell("cell1", "cell.1");
private static final Cell CELL_2 = new Cell("cell2", "cell.2");
private final CellInfoResolver cellInfoResolver = mock(CellInfoResolver.class);
private final TitusFederationConfiguration titusFederationConfiguration = mock(TitusFederationConfiguration.class);
private CellRouter router;
@Before
public void setUp() {
when(cellInfoResolver.resolve()).thenReturn(asList(CELL_1, CELL_2));
when(titusFederationConfiguration.getInstanceTypeRoutingRules()).thenReturn("cell2=(gpu.*)");
router = SpecialInstanceTypeRouter.getGpuInstanceTypeRouter(cellInfoResolver, titusFederationConfiguration);
}
@Test
public void testGpuCellIsSelectedForGpuJob() {
JobDescriptor gpuJobDescriptor = JobDescriptor.newBuilder()
.setContainer(Container.newBuilder()
.setResources(ContainerResources.newBuilder()
.setGpu(5)
)
)
.build();
assertThat(router.routeKey(gpuJobDescriptor)).contains(CELL_2);
}
@Test
public void testNoCellIsSelectedForNonGpuJob() {
assertThat(router.routeKey(JobDescriptor.getDefaultInstance())).isEmpty();
}
} | 9,844 |
0 | Create_ds/titus-control-plane/titus-server-federation/src/test/java/com/netflix/titus/federation/service | Create_ds/titus-control-plane/titus-server-federation/src/test/java/com/netflix/titus/federation/service/router/ApplicationCellRouterTest.java | /*
* Copyright 2020 Netflix, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.netflix.titus.federation.service.router;
import java.util.regex.PatternSyntaxException;
import com.netflix.titus.api.federation.model.Cell;
import com.netflix.titus.api.jobmanager.JobAttributes;
import com.netflix.titus.federation.service.CellInfoResolver;
import com.netflix.titus.federation.service.DefaultCellInfoResolver;
import com.netflix.titus.federation.startup.TitusFederationConfiguration;
import com.netflix.titus.grpc.protogen.JobDescriptor;
import org.junit.Test;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatThrownBy;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.reset;
import static org.mockito.Mockito.when;
public class ApplicationCellRouterTest {
private static final JobDescriptor APP_2 = JobDescriptor.newBuilder().setApplicationName("app2foobar").build();
private static final JobDescriptor APP_3 = JobDescriptor.newBuilder().setApplicationName("app3foobar").build();
private static final JobDescriptor APP_4 = JobDescriptor.newBuilder().setApplicationName("app4foobar").build();
private static final JobDescriptor OTHER = JobDescriptor.newBuilder().setApplicationName("other").build();
@Test
public void cellRoutingRulesFromConfig() {
TitusFederationConfiguration titusFederationConfiguration = mock(TitusFederationConfiguration.class);
when(titusFederationConfiguration.getCells()).thenReturn("cell1=hostName1:7001;cell2=hostName2:7002");
when(titusFederationConfiguration.getRoutingRules()).thenReturn("cell1=(app1.*|app2.*);cell2=(app3.*)");
CellInfoResolver cellInfoResolver = new DefaultCellInfoResolver(titusFederationConfiguration);
ApplicationCellRouter cellRouter = new ApplicationCellRouter(cellInfoResolver, titusFederationConfiguration);
assertThat(cellRouter.routeKey(APP_3).get().getName()).isEqualTo("cell2");
assertThat(cellRouter.routeKey(APP_2).get().getName()).isEqualTo("cell1");
// if not rules, by default go to the first configured in titus.federation.cells
assertThat(cellRouter.routeKey(OTHER).get().getName()).isEqualTo("cell1");
}
@Test
public void cellsWithNoRulesCanExist() {
TitusFederationConfiguration titusFederationConfiguration = mock(TitusFederationConfiguration.class);
when(titusFederationConfiguration.getCells()).thenReturn("cell1=hostName1:7001;cell2=hostName2:7002");
when(titusFederationConfiguration.getRoutingRules()).thenReturn("cell1=(app1.*|app2.*)");
CellInfoResolver cellInfoResolver = new DefaultCellInfoResolver(titusFederationConfiguration);
ApplicationCellRouter cellRouter = new ApplicationCellRouter(cellInfoResolver, titusFederationConfiguration);
Cell cell = cellRouter.routeKey(APP_2).get();
assertThat(cell.getName()).isEqualTo("cell1");
}
@Test
public void rulesWithNonConfiguredCellsAreIgnored() {
TitusFederationConfiguration titusFederationConfiguration = mock(TitusFederationConfiguration.class);
when(titusFederationConfiguration.getCells()).thenReturn("cell1=hostName1:7001;cell2=hostName2:7002");
when(titusFederationConfiguration.getRoutingRules()).thenReturn("cell1=(app1.*|app2.*);cell2=(app3.*);cell3=(app4.*)");
CellInfoResolver cellInfoResolver = new DefaultCellInfoResolver(titusFederationConfiguration);
ApplicationCellRouter cellRouter = new ApplicationCellRouter(cellInfoResolver, titusFederationConfiguration);
Cell cell = cellRouter.routeKey(APP_4).get();
assertThat(cell.getName()).isEqualTo("cell1"); // no rules default to first
}
@Test
public void invalidInitialRoutingPatternThrowsException() {
TitusFederationConfiguration titusFederationConfiguration = mock(TitusFederationConfiguration.class);
when(titusFederationConfiguration.getCells()).thenReturn("cell1=hostName1:7001;cell2=hostName2:7002");
when(titusFederationConfiguration.getRoutingRules()).thenReturn("cell1=(app1.*|app2.*);cell2=#)(");
CellInfoResolver cellInfoResolver = new DefaultCellInfoResolver(titusFederationConfiguration);
assertThatThrownBy(() -> new ApplicationCellRouter(cellInfoResolver, titusFederationConfiguration))
.isInstanceOf(PatternSyntaxException.class);
}
@Test
public void rulesCanBeChangedDynamically() {
TitusFederationConfiguration titusFederationConfiguration = mock(TitusFederationConfiguration.class);
when(titusFederationConfiguration.getCells()).thenReturn("cell1=hostName1:7001;cell2=hostName2:7002");
when(titusFederationConfiguration.getRoutingRules()).thenReturn("cell1=(app1.*|app2.*);cell2=(app3.*)");
CellInfoResolver cellInfoResolver = new DefaultCellInfoResolver(titusFederationConfiguration);
ApplicationCellRouter cellRouter = new ApplicationCellRouter(cellInfoResolver, titusFederationConfiguration);
assertThat(cellRouter.routeKey(APP_3).get().getName()).isEqualTo("cell2");
assertThat(cellRouter.routeKey(APP_2).get().getName()).isEqualTo("cell1");
// if not rules, by default go to the first configured in titus.federation.cells
assertThat(cellRouter.routeKey(OTHER).get().getName()).isEqualTo("cell1");
// flip rules
reset(titusFederationConfiguration);
when(titusFederationConfiguration.getCells()).thenReturn("cell1=hostName1:7001;cell2=hostName2:7002");
when(titusFederationConfiguration.getRoutingRules()).thenReturn("cell2=(app1.*|app2.*);cell1=(app3.*)");
assertThat(cellRouter.routeKey(APP_3).get().getName()).isEqualTo("cell1");
assertThat(cellRouter.routeKey(APP_2).get().getName()).isEqualTo("cell2");
// if not rules, by default go to the first configured in titus.federation.cells
assertThat(cellRouter.routeKey(OTHER).get().getName()).isEqualTo("cell1");
}
@Test
public void jobToCellAffinity() {
JobDescriptor withCellAffinity = APP_2.toBuilder()
.putAttributes(JobAttributes.JOB_PARAMETER_ATTRIBUTES_CELL_REQUEST, "cell2")
.build();
TitusFederationConfiguration titusFederationConfiguration = mock(TitusFederationConfiguration.class);
when(titusFederationConfiguration.getCells()).thenReturn("cell1=hostName1:7001;cell2=hostName2:7002");
when(titusFederationConfiguration.getRoutingRules()).thenReturn("cell1=(app1.*|app2.*);cell2=(app3.*)");
CellInfoResolver cellInfoResolver = new DefaultCellInfoResolver(titusFederationConfiguration);
ApplicationCellRouter cellRouter = new ApplicationCellRouter(cellInfoResolver, titusFederationConfiguration);
assertThat(cellRouter.routeKey(withCellAffinity).get().getName()).isEqualTo("cell2");
}
@Test
public void jobCellAntiAffinity() {
JobDescriptor withCellAntiAffinity = APP_2.toBuilder()
.putAttributes(JobAttributes.JOB_PARAMETER_ATTRIBUTES_CELL_AVOID, "cell4, cell1")
.build();
JobDescriptor allRejectedGoesToDefault = APP_2.toBuilder()
.putAttributes(JobAttributes.JOB_PARAMETER_ATTRIBUTES_CELL_AVOID, "cell1,cell2")
.build();
TitusFederationConfiguration titusFederationConfiguration = mock(TitusFederationConfiguration.class);
when(titusFederationConfiguration.getCells()).thenReturn("cell1=hostName1:7001;cell2=hostName2:7002");
when(titusFederationConfiguration.getRoutingRules()).thenReturn("cell1=(app1.*|app2.*);cell2=(app3.*)");
CellInfoResolver cellInfoResolver = new DefaultCellInfoResolver(titusFederationConfiguration);
ApplicationCellRouter cellRouter = new ApplicationCellRouter(cellInfoResolver, titusFederationConfiguration);
assertThat(cellRouter.routeKey(withCellAntiAffinity).get().getName()).isEqualTo("cell2");
assertThat(cellRouter.routeKey(allRejectedGoesToDefault)).isEmpty();
}
}
| 9,845 |
0 | Create_ds/titus-control-plane/titus-server-federation/src/test/java/com/netflix/titus/federation/service | Create_ds/titus-control-plane/titus-server-federation/src/test/java/com/netflix/titus/federation/service/router/ChainCellRouterTest.java | /*
* Copyright 2020 Netflix, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.netflix.titus.federation.service.router;
import java.util.Optional;
import com.netflix.titus.api.federation.model.Cell;
import com.netflix.titus.grpc.protogen.JobDescriptor;
import org.junit.Test;
import org.mockito.Mockito;
import static java.util.Arrays.asList;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.Mockito.when;
public class ChainCellRouterTest {
private static final Cell CELL_1 = new Cell("cell1", "cell.1");
private static final Cell CELL_2 = new Cell("cell2", "cell.2");
@Test
public void testChaining() {
CellRouter first = Mockito.mock(CellRouter.class);
CellRouter second = Mockito.mock(CellRouter.class);
ChainCellRouter chain = new ChainCellRouter(asList(first, second));
// Nothing matches
when(first.routeKey(any())).thenReturn(Optional.empty());
when(second.routeKey(any())).thenReturn(Optional.empty());
assertThat(chain.routeKey(JobDescriptor.getDefaultInstance())).isEmpty();
// First cell matches
when(first.routeKey(any())).thenReturn(Optional.of(CELL_1));
when(second.routeKey(any())).thenReturn(Optional.of(CELL_2));
assertThat(chain.routeKey(JobDescriptor.getDefaultInstance())).contains(CELL_1);
// Second cell matches
when(first.routeKey(any())).thenReturn(Optional.empty());
when(second.routeKey(any())).thenReturn(Optional.of(CELL_2));
assertThat(chain.routeKey(JobDescriptor.getDefaultInstance())).contains(CELL_2);
}
} | 9,846 |
0 | Create_ds/titus-control-plane/titus-server-federation/src/main/java/com/netflix/titus/federation | Create_ds/titus-control-plane/titus-server-federation/src/main/java/com/netflix/titus/federation/endpoint/FederationEndpointModule.java | /*
* Copyright 2018 Netflix, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.netflix.titus.federation.endpoint;
import javax.inject.Singleton;
import com.google.inject.AbstractModule;
import com.google.inject.Provides;
import com.netflix.archaius.ConfigProxyFactory;
import com.netflix.archaius.api.Config;
import com.netflix.titus.common.runtime.TitusRuntime;
import com.netflix.titus.common.util.CollectionsExt;
import com.netflix.titus.common.util.loadshedding.AdmissionController;
import com.netflix.titus.common.util.loadshedding.AdmissionControllers;
import com.netflix.titus.common.util.loadshedding.grpc.GrpcAdmissionControllerServerInterceptor;
import com.netflix.titus.federation.endpoint.grpc.FederationGrpcModule;
import com.netflix.titus.federation.endpoint.rest.JerseyModule;
import com.netflix.titus.runtime.endpoint.metadata.CallMetadataResolveModule;
import com.netflix.titus.runtime.endpoint.metadata.CallMetadataResolver;
public class FederationEndpointModule extends AbstractModule {
private static final String ADMISSION_CONTROLLER_CONFIGURATION_PREFIX = "titus.federation.admissionController.buckets";
private static final String UNIDENTIFIED = "unidentified";
@Override
protected void configure() {
install(new CallMetadataResolveModule());
install(new FederationGrpcModule());
install(new JerseyModule());
}
@Provides
@Singleton
public EndpointConfiguration getGrpcEndpointConfiguration(ConfigProxyFactory factory) {
return factory.newProxy(EndpointConfiguration.class);
}
@Provides
@Singleton
public GrpcAdmissionControllerServerInterceptor getGrpcAdmissionControllerServerInterceptor(Config config,
EndpointConfiguration configuration,
CallMetadataResolver callMetadataResolver,
TitusRuntime titusRuntime) {
AdmissionController mainController = AdmissionControllers.tokenBucketsFromArchaius(
config.getPrefixedView(ADMISSION_CONTROLLER_CONFIGURATION_PREFIX),
true,
titusRuntime
);
AdmissionController circuitBreaker = AdmissionControllers.circuitBreaker(
mainController,
configuration::isAdmissionControllerEnabled
);
AdmissionController spectator = AdmissionControllers.spectator(circuitBreaker, titusRuntime);
return new GrpcAdmissionControllerServerInterceptor(
spectator,
() -> callMetadataResolver.resolve().map(c -> {
if (CollectionsExt.isNullOrEmpty(c.getCallers())) {
return UNIDENTIFIED;
}
return c.getCallers().get(0).getId();
}).orElse(UNIDENTIFIED)
);
}
}
| 9,847 |
0 | Create_ds/titus-control-plane/titus-server-federation/src/main/java/com/netflix/titus/federation | Create_ds/titus-control-plane/titus-server-federation/src/main/java/com/netflix/titus/federation/endpoint/FederationEndpointComponent.java | /*
* Copyright 2020 Netflix, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.netflix.titus.federation.endpoint;
import com.netflix.titus.common.environment.MyEnvironment;
import com.netflix.titus.common.runtime.TitusRuntime;
import com.netflix.titus.common.util.CollectionsExt;
import com.netflix.titus.common.util.archaius2.Archaius2Ext;
import com.netflix.titus.common.util.archaius2.SpringConfig;
import com.netflix.titus.common.util.loadshedding.AdmissionController;
import com.netflix.titus.common.util.loadshedding.AdmissionControllers;
import com.netflix.titus.common.util.loadshedding.grpc.GrpcAdmissionControllerServerInterceptor;
import com.netflix.titus.federation.endpoint.grpc.FederationGrpcComponent;
import com.netflix.titus.federation.endpoint.rest.FederationRestComponent;
import com.netflix.titus.runtime.endpoint.metadata.CallMetadataResolver;
import com.netflix.titus.runtime.endpoint.metadata.CallMetadataResolverComponent;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Import;
import org.springframework.core.env.Environment;
import org.springframework.stereotype.Component;
@Component
@Import({
CallMetadataResolverComponent.class,
FederationGrpcComponent.class,
FederationRestComponent.class,
})
public class FederationEndpointComponent {
private static final String ADMISSION_CONTROLLER_CONFIGURATION_PREFIX = "titus.federation.admissionController.buckets";
private static final String UNIDENTIFIED = "unidentified";
@Bean
public EndpointConfiguration getGrpcEndpointConfiguration(MyEnvironment environment) {
return Archaius2Ext.newConfiguration(EndpointConfiguration.class, environment);
}
@Bean
public GrpcAdmissionControllerServerInterceptor getGrpcAdmissionControllerServerInterceptor(Environment environment,
EndpointConfiguration configuration,
CallMetadataResolver callMetadataResolver,
TitusRuntime titusRuntime) {
AdmissionController mainController = AdmissionControllers.tokenBucketsFromArchaius(
new SpringConfig(ADMISSION_CONTROLLER_CONFIGURATION_PREFIX, environment),
true,
titusRuntime
);
AdmissionController circuitBreaker = AdmissionControllers.circuitBreaker(
mainController,
configuration::isAdmissionControllerEnabled
);
AdmissionController spectator = AdmissionControllers.spectator(circuitBreaker, titusRuntime);
return new GrpcAdmissionControllerServerInterceptor(
spectator,
() -> callMetadataResolver.resolve().map(c -> {
if (CollectionsExt.isNullOrEmpty(c.getCallers())) {
return UNIDENTIFIED;
}
return c.getCallers().get(0).getId();
}).orElse(UNIDENTIFIED)
);
}
}
| 9,848 |
0 | Create_ds/titus-control-plane/titus-server-federation/src/main/java/com/netflix/titus/federation | Create_ds/titus-control-plane/titus-server-federation/src/main/java/com/netflix/titus/federation/endpoint/EndpointConfiguration.java | /*
* Copyright 2018 Netflix, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.netflix.titus.federation.endpoint;
import com.netflix.archaius.api.annotations.Configuration;
import com.netflix.archaius.api.annotations.DefaultValue;
@Configuration(prefix = "titus.federation.endpoint")
public interface EndpointConfiguration {
@DefaultValue("7104")
int getGrpcPort();
@DefaultValue("10000")
long getRestRequestTimeoutMs();
/**
* Graceful shutdown time for GRPC server. If zero, shutdown happens immediately, and all client connections are
* terminated abruptly.
*/
@DefaultValue("30000")
long getGrpcServerShutdownTimeoutMs();
@DefaultValue("true")
boolean isAdmissionControllerEnabled();
}
| 9,849 |
0 | Create_ds/titus-control-plane/titus-server-federation/src/main/java/com/netflix/titus/federation/endpoint | Create_ds/titus-control-plane/titus-server-federation/src/main/java/com/netflix/titus/federation/endpoint/grpc/FederationGrpcServerComponent.java | /*
* Copyright 2020 Netflix, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.netflix.titus.federation.endpoint.grpc;
import org.springframework.context.annotation.Import;
import org.springframework.stereotype.Component;
@Component
@Import(TitusFederationGrpcServer.class)
public class FederationGrpcServerComponent {
}
| 9,850 |
0 | Create_ds/titus-control-plane/titus-server-federation/src/main/java/com/netflix/titus/federation/endpoint | Create_ds/titus-control-plane/titus-server-federation/src/main/java/com/netflix/titus/federation/endpoint/grpc/TitusFederationGrpcServer.java | /*
* Copyright 2018 Netflix, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.netflix.titus.federation.endpoint.grpc;
import java.io.IOException;
import java.util.Arrays;
import java.util.List;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicBoolean;
import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;
import javax.inject.Inject;
import javax.inject.Singleton;
import com.netflix.titus.TitusAgentSecurityGroupServiceGrpc;
import com.netflix.titus.common.runtime.TitusRuntime;
import com.netflix.titus.common.util.ExecutorsExt;
import com.netflix.titus.common.util.grpc.reactor.GrpcToReactorServerFactory;
import com.netflix.titus.common.util.loadshedding.grpc.GrpcAdmissionControllerServerInterceptor;
import com.netflix.titus.federation.endpoint.EndpointConfiguration;
import com.netflix.titus.grpc.protogen.AutoScalingServiceGrpc;
import com.netflix.titus.grpc.protogen.AutoScalingServiceGrpc.AutoScalingServiceImplBase;
import com.netflix.titus.grpc.protogen.HealthGrpc;
import com.netflix.titus.grpc.protogen.HealthGrpc.HealthImplBase;
import com.netflix.titus.grpc.protogen.JobActivityHistoryServiceGrpc;
import com.netflix.titus.grpc.protogen.JobActivityHistoryServiceGrpc.JobActivityHistoryServiceImplBase;
import com.netflix.titus.grpc.protogen.JobManagementServiceGrpc;
import com.netflix.titus.grpc.protogen.JobManagementServiceGrpc.JobManagementServiceImplBase;
import com.netflix.titus.grpc.protogen.LoadBalancerServiceGrpc;
import com.netflix.titus.grpc.protogen.LoadBalancerServiceGrpc.LoadBalancerServiceImplBase;
import com.netflix.titus.grpc.protogen.SchedulerServiceGrpc;
import com.netflix.titus.grpc.protogen.SchedulerServiceGrpc.SchedulerServiceImplBase;
import com.netflix.titus.runtime.endpoint.common.grpc.interceptor.ErrorCatchingServerInterceptor;
import com.netflix.titus.runtime.endpoint.metadata.V3HeaderInterceptor;
import com.netflix.titus.TitusAgentSecurityGroupServiceGrpc.TitusAgentSecurityGroupServiceImplBase;
import io.grpc.Server;
import io.grpc.ServerBuilder;
import io.grpc.ServerInterceptor;
import io.grpc.ServerInterceptors;
import io.grpc.ServiceDescriptor;
import io.grpc.protobuf.services.ProtoReflectionService;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
@Singleton
public class TitusFederationGrpcServer {
private static final Logger LOG = LoggerFactory.getLogger(TitusFederationGrpcServer.class);
private final GrpcAdmissionControllerServerInterceptor admissionController;
private final HealthImplBase healthService;
private final SchedulerServiceImplBase schedulerService;
private final JobManagementServiceImplBase jobManagementService;
private AutoScalingServiceImplBase autoScalingService;
private LoadBalancerServiceImplBase loadBalancerService;
private JobActivityHistoryServiceImplBase jobActivityHistoryService;
private final GrpcToReactorServerFactory reactorServerFactory;
private final EndpointConfiguration config;
private final TitusRuntime runtime;
private TitusAgentSecurityGroupServiceImplBase securityGroupService;
private final ExecutorService grpcCallbackExecutor;
private final AtomicBoolean started = new AtomicBoolean();
private Server server;
private int port;
@Inject
public TitusFederationGrpcServer(
GrpcAdmissionControllerServerInterceptor admissionController,
HealthImplBase healthService,
SchedulerServiceImplBase schedulerService,
JobManagementServiceImplBase jobManagementService,
AutoScalingServiceImplBase autoScalingService,
LoadBalancerServiceImplBase loadBalancerService,
JobActivityHistoryServiceImplBase jobActivityHistoryService,
GrpcToReactorServerFactory reactorServerFactory,
EndpointConfiguration config,
TitusAgentSecurityGroupServiceImplBase sgService,
TitusRuntime runtime) {
this.admissionController = admissionController;
this.healthService = healthService;
this.schedulerService = schedulerService;
this.jobManagementService = jobManagementService;
this.autoScalingService = autoScalingService;
this.loadBalancerService = loadBalancerService;
this.jobActivityHistoryService = jobActivityHistoryService;
this.reactorServerFactory = reactorServerFactory;
this.config = config;
this.runtime = runtime;
this.securityGroupService = sgService;
this.grpcCallbackExecutor = ExecutorsExt.instrumentedCachedThreadPool(runtime.getRegistry(), "grpcCallbackExecutor");
}
public int getGrpcPort() {
return port;
}
@PostConstruct
public void start() {
if (started.getAndSet(true)) {
return;
}
this.port = config.getGrpcPort();
this.server = configure(ServerBuilder.forPort(port).executor(grpcCallbackExecutor))
.addService(ServerInterceptors.intercept(
healthService,
createInterceptors(HealthGrpc.getServiceDescriptor())
))
.addService(ServerInterceptors.intercept(
schedulerService,
createInterceptors(SchedulerServiceGrpc.getServiceDescriptor())
))
.addService(ServerInterceptors.intercept(
jobManagementService,
createInterceptors(JobManagementServiceGrpc.getServiceDescriptor())
))
.addService(ServerInterceptors.intercept(
autoScalingService,
createInterceptors(AutoScalingServiceGrpc.getServiceDescriptor())
))
.addService(ServerInterceptors.intercept(
loadBalancerService,
createInterceptors(LoadBalancerServiceGrpc.getServiceDescriptor())))
.addService(ServerInterceptors.intercept(
securityGroupService,
createInterceptors(TitusAgentSecurityGroupServiceGrpc.getServiceDescriptor())))
.addService(ServerInterceptors.intercept(
jobActivityHistoryService,
createInterceptors(JobActivityHistoryServiceGrpc.getServiceDescriptor())))
.addService(ProtoReflectionService.newInstance())
.build();
LOG.info("Starting gRPC server on port {}.", port);
try {
this.server.start();
this.port = server.getPort();
} catch (final IOException e) {
throw new RuntimeException(e);
}
LOG.info("Started gRPC server on port {}.", port);
}
@PreDestroy
public void shutdown() {
if (server.isShutdown()) {
return;
}
long timeoutMs = config.getGrpcServerShutdownTimeoutMs();
try {
if (timeoutMs <= 0) {
server.shutdownNow();
} else {
server.shutdown();
try {
server.awaitTermination(timeoutMs, TimeUnit.MILLISECONDS);
} catch (InterruptedException ignore) {
}
if (!server.isShutdown()) {
server.shutdownNow();
}
}
} finally {
grpcCallbackExecutor.shutdown();
if (timeoutMs > 0) {
try {
grpcCallbackExecutor.awaitTermination(timeoutMs, TimeUnit.MILLISECONDS);
} catch (InterruptedException ignore) {
}
}
}
}
/**
* Override to change default server configuration.
*/
protected ServerBuilder configure(ServerBuilder serverBuilder) {
return serverBuilder;
}
/**
* Override to add server side interceptors.
*/
protected List<ServerInterceptor> createInterceptors(ServiceDescriptor serviceDescriptor) {
return Arrays.asList(
admissionController,
new ErrorCatchingServerInterceptor(),
new V3HeaderInterceptor()
);
}
}
| 9,851 |
0 | Create_ds/titus-control-plane/titus-server-federation/src/main/java/com/netflix/titus/federation/endpoint | Create_ds/titus-control-plane/titus-server-federation/src/main/java/com/netflix/titus/federation/endpoint/grpc/FederationGrpcComponent.java | /*
* Copyright 2020 Netflix, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.netflix.titus.federation.endpoint.grpc;
import com.netflix.titus.runtime.endpoint.v3.grpc.DefaultAutoScalingServiceGrpc;
import com.netflix.titus.runtime.endpoint.v3.grpc.DefaultHealthServiceGrpc;
import com.netflix.titus.runtime.endpoint.v3.grpc.DefaultJobActivityHistoryServiceGrpc;
import com.netflix.titus.runtime.endpoint.v3.grpc.DefaultJobManagementServiceGrpc;
import com.netflix.titus.runtime.endpoint.v3.grpc.DefaultLoadBalancerServiceGrpc;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Import;
@Configuration
@Import({
DefaultHealthServiceGrpc.class,
AggregatingSchedulerServiceGrpc.class,
DefaultJobManagementServiceGrpc.class,
DefaultAutoScalingServiceGrpc.class,
DefaultLoadBalancerServiceGrpc.class,
DefaultJobActivityHistoryServiceGrpc.class,
DefaultTitusAgentSecurityGroupServiceGrpc.class,
})
public class FederationGrpcComponent {
}
| 9,852 |
0 | Create_ds/titus-control-plane/titus-server-federation/src/main/java/com/netflix/titus/federation/endpoint | Create_ds/titus-control-plane/titus-server-federation/src/main/java/com/netflix/titus/federation/endpoint/grpc/DefaultTitusAgentSecurityGroupServiceGrpc.java | package com.netflix.titus.federation.endpoint.grpc;
import javax.inject.Inject;
import javax.inject.Singleton;
import com.netflix.titus.runtime.endpoint.v3.grpc.DefaultJobActivityHistoryServiceGrpc;
import com.netflix.titus.runtime.service.TitusAgentSecurityGroupClient;
import io.reactivex.subscribers.DefaultSubscriber;
import org.reactivestreams.Processor;
import org.reactivestreams.Subscriber;
import org.reactivestreams.Subscription;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import com.netflix.titus.api.jobmanager.service.JobManagerConstants;
import com.netflix.titus.api.model.callmetadata.CallMetadata;
import com.netflix.titus.TitusAgentSecurityGroupServiceGrpc;
import com.netflix.titus.TitusVpcApi.ResetSecurityGroupResponse;
import com.netflix.titus.runtime.endpoint.metadata.CallMetadataResolver;
import reactor.core.CoreSubscriber;
import java.awt.event.ActionListener;
import java.util.function.Consumer;
@Singleton
public class DefaultTitusAgentSecurityGroupServiceGrpc extends TitusAgentSecurityGroupServiceGrpc.TitusAgentSecurityGroupServiceImplBase {
private static final Logger logger = LoggerFactory.getLogger(DefaultJobActivityHistoryServiceGrpc.class);
private final TitusAgentSecurityGroupClient titusAgentSecurityGroupServiceGateway;
private final CallMetadataResolver callMetadataResolver;
@Inject
public DefaultTitusAgentSecurityGroupServiceGrpc(TitusAgentSecurityGroupClient titusAgentSecurityGroupService, //client
CallMetadataResolver callMetadataResolver) {
this.titusAgentSecurityGroupServiceGateway = titusAgentSecurityGroupService;
this.callMetadataResolver = callMetadataResolver;
}
@Override
public void resetSecurityGroup(com.netflix.titus.TitusVpcApi.ResetSecurityGroupRequest request,
io.grpc.stub.StreamObserver<com.netflix.titus.TitusVpcApi.ResetSecurityGroupResponse> responseObserver) {
titusAgentSecurityGroupServiceGateway.resetSecurityGroup(request, resolveCallMetadata()).subscribe(
resetSecurityGroupResponse -> {
logger.debug(" Proxy server got response for " + request.getSecurityGroupID());
responseObserver.onNext(resetSecurityGroupResponse);
responseObserver.onCompleted();
}, throwable -> {
logger.debug(" Proxy server got error for " + request.getSecurityGroupID());
responseObserver.onError(throwable);
});
}
private CallMetadata resolveCallMetadata() {
return callMetadataResolver.resolve().orElse(JobManagerConstants.UNDEFINED_CALL_METADATA);
}
}
| 9,853 |
0 | Create_ds/titus-control-plane/titus-server-federation/src/main/java/com/netflix/titus/federation/endpoint | Create_ds/titus-control-plane/titus-server-federation/src/main/java/com/netflix/titus/federation/endpoint/grpc/FederationGrpcModule.java | /*
* Copyright 2018 Netflix, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.netflix.titus.federation.endpoint.grpc;
import com.google.inject.AbstractModule;
import com.netflix.titus.TitusAgentSecurityGroupServiceGrpc;
import com.netflix.titus.federation.service.DefaultTitusAgentSecurityGroupClient;
import com.netflix.titus.grpc.protogen.AutoScalingServiceGrpc;
import com.netflix.titus.grpc.protogen.HealthGrpc;
import com.netflix.titus.grpc.protogen.JobActivityHistoryServiceGrpc;
import com.netflix.titus.grpc.protogen.JobManagementServiceGrpc;
import com.netflix.titus.grpc.protogen.LoadBalancerServiceGrpc;
import com.netflix.titus.grpc.protogen.SchedulerServiceGrpc;
import com.netflix.titus.runtime.endpoint.v3.grpc.*;
import com.netflix.titus.runtime.service.TitusAgentSecurityGroupClient;
public class FederationGrpcModule extends AbstractModule {
@Override
protected void configure() {
bind(TitusFederationGrpcServer.class).asEagerSingleton();
bind(HealthGrpc.HealthImplBase.class).to(DefaultHealthServiceGrpc.class);
bind(SchedulerServiceGrpc.SchedulerServiceImplBase.class).to(AggregatingSchedulerServiceGrpc.class);
bind(JobManagementServiceGrpc.JobManagementServiceImplBase.class).to(DefaultJobManagementServiceGrpc.class);
bind(AutoScalingServiceGrpc.AutoScalingServiceImplBase.class).to(DefaultAutoScalingServiceGrpc.class);
bind(LoadBalancerServiceGrpc.LoadBalancerServiceImplBase.class).to(DefaultLoadBalancerServiceGrpc.class);
bind(JobActivityHistoryServiceGrpc.JobActivityHistoryServiceImplBase.class).to(DefaultJobActivityHistoryServiceGrpc.class);
bind(TitusAgentSecurityGroupServiceGrpc.TitusAgentSecurityGroupServiceImplBase.class).to(DefaultTitusAgentSecurityGroupServiceGrpc.class);
bind(TitusAgentSecurityGroupClient.class).to(DefaultTitusAgentSecurityGroupClient.class);
}
}
| 9,854 |
0 | Create_ds/titus-control-plane/titus-server-federation/src/main/java/com/netflix/titus/federation/endpoint | Create_ds/titus-control-plane/titus-server-federation/src/main/java/com/netflix/titus/federation/endpoint/grpc/AggregatingSchedulerServiceGrpc.java | /*
* Copyright 2019 Netflix, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.netflix.titus.federation.endpoint.grpc;
import javax.inject.Inject;
import javax.inject.Singleton;
import com.netflix.titus.federation.service.AggregatingSchedulerService;
import com.netflix.titus.grpc.protogen.SchedulerServiceGrpc;
import com.netflix.titus.grpc.protogen.SchedulingResultEvent;
import com.netflix.titus.grpc.protogen.SchedulingResultRequest;
import io.grpc.stub.StreamObserver;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import reactor.core.Disposable;
import static com.netflix.titus.runtime.endpoint.common.grpc.GrpcUtil.attachCancellingCallback;
import static com.netflix.titus.runtime.endpoint.common.grpc.GrpcUtil.safeOnError;
@Singleton
public class AggregatingSchedulerServiceGrpc extends SchedulerServiceGrpc.SchedulerServiceImplBase {
private static final Logger logger = LoggerFactory.getLogger(AggregatingSchedulerServiceGrpc.class);
private final AggregatingSchedulerService schedulerService;
@Inject
public AggregatingSchedulerServiceGrpc(AggregatingSchedulerService schedulerService) {
this.schedulerService = schedulerService;
}
@Override
public void getSchedulingResult(SchedulingResultRequest request, StreamObserver<SchedulingResultEvent> responseObserver) {
Disposable subscription = schedulerService.findLastSchedulingResult(request.getTaskId()).subscribe(
responseObserver::onNext,
e -> safeOnError(logger, e, responseObserver),
responseObserver::onCompleted
);
attachCancellingCallback(responseObserver, subscription);
}
}
| 9,855 |
0 | Create_ds/titus-control-plane/titus-server-federation/src/main/java/com/netflix/titus/federation/endpoint | Create_ds/titus-control-plane/titus-server-federation/src/main/java/com/netflix/titus/federation/endpoint/rest/FederationSchedulerSpringResource.java | /*
* Copyright 2020 Netflix, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.netflix.titus.federation.endpoint.rest;
import javax.inject.Inject;
import com.netflix.titus.federation.service.AggregatingSchedulerService;
import com.netflix.titus.grpc.protogen.SchedulingResultEvent;
import com.netflix.titus.runtime.endpoint.common.rest.Responses;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
@Api(tags = "Scheduler")
@RestController
@RequestMapping(path = "/api/v3/scheduler", produces = "application/json")
public class FederationSchedulerSpringResource {
private final AggregatingSchedulerService schedulerService;
@Inject
public FederationSchedulerSpringResource(AggregatingSchedulerService schedulerService) {
this.schedulerService = schedulerService;
}
@GetMapping(path = "/results/{id}")
@ApiOperation("Find scheduling result for a task")
public SchedulingResultEvent findLastSchedulingResult(@PathVariable("id") String taskId) {
return Responses.fromMono(schedulerService.findLastSchedulingResult(taskId));
}
}
| 9,856 |
0 | Create_ds/titus-control-plane/titus-server-federation/src/main/java/com/netflix/titus/federation/endpoint | Create_ds/titus-control-plane/titus-server-federation/src/main/java/com/netflix/titus/federation/endpoint/rest/FederationSchedulerResource.java | /*
* Copyright 2019 Netflix, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.netflix.titus.federation.endpoint.rest;
import javax.inject.Inject;
import javax.inject.Singleton;
import javax.ws.rs.Consumes;
import javax.ws.rs.GET;
import javax.ws.rs.Path;
import javax.ws.rs.PathParam;
import javax.ws.rs.Produces;
import javax.ws.rs.core.MediaType;
import com.netflix.titus.federation.service.AggregatingSchedulerService;
import com.netflix.titus.grpc.protogen.SchedulingResultEvent;
import com.netflix.titus.runtime.endpoint.common.rest.Responses;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
/**
* Supports subset of operations provided by {@link com.netflix.titus.grpc.protogen.SchedulerServiceGrpc}, applicable
* at the federation level.
*/
@Produces(MediaType.APPLICATION_JSON)
@Consumes(MediaType.APPLICATION_JSON)
@Api(tags = "Scheduler")
@Path("/v3/scheduler")
@Singleton
public class FederationSchedulerResource {
private final AggregatingSchedulerService schedulerService;
@Inject
public FederationSchedulerResource(AggregatingSchedulerService schedulerService) {
this.schedulerService = schedulerService;
}
@GET
@ApiOperation("Find scheduling result for a task")
@Path("/results/{id}")
public SchedulingResultEvent findLastSchedulingResult(@PathParam("id") String taskId) {
return Responses.fromMono(schedulerService.findLastSchedulingResult(taskId));
}
}
| 9,857 |
0 | Create_ds/titus-control-plane/titus-server-federation/src/main/java/com/netflix/titus/federation/endpoint | Create_ds/titus-control-plane/titus-server-federation/src/main/java/com/netflix/titus/federation/endpoint/rest/FederationRestComponent.java | /*
* Copyright 2020 Netflix, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.netflix.titus.federation.endpoint.rest;
import com.netflix.titus.runtime.endpoint.common.rest.TitusExceptionHandlers;
import com.netflix.titus.runtime.endpoint.v3.rest.AutoScalingSpringResource;
import com.netflix.titus.runtime.endpoint.v3.rest.HealthSpringResource;
import com.netflix.titus.runtime.endpoint.v3.rest.JobManagementSpringResource;
import com.netflix.titus.runtime.endpoint.v3.rest.LoadBalancerSpringResource;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Import;
@Configuration
@Import({
TitusExceptionHandlers.class,
HealthSpringResource.class,
FederationSchedulerSpringResource.class,
JobManagementSpringResource.class,
AutoScalingSpringResource.class,
LoadBalancerSpringResource.class,
FederationV2CapacityGroupSpringResource.class,
})
public class FederationRestComponent {
}
| 9,858 |
0 | Create_ds/titus-control-plane/titus-server-federation/src/main/java/com/netflix/titus/federation/endpoint | Create_ds/titus-control-plane/titus-server-federation/src/main/java/com/netflix/titus/federation/endpoint/rest/JerseyModule.java | /*
* Copyright 2018 Netflix, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.netflix.titus.federation.endpoint.rest;
import java.util.function.UnaryOperator;
import javax.inject.Named;
import javax.inject.Singleton;
import com.google.inject.Provides;
import com.netflix.archaius.ConfigProxyFactory;
import com.netflix.governator.guice.jersey.GovernatorServletContainer;
import com.netflix.governator.providers.Advises;
import com.netflix.titus.runtime.endpoint.common.rest.JsonMessageReaderWriter;
import com.netflix.titus.runtime.endpoint.common.rest.RestServerConfiguration;
import com.netflix.titus.runtime.endpoint.common.rest.TitusExceptionMapper;
import com.netflix.titus.runtime.endpoint.common.rest.filter.CallerContextFilter;
import com.netflix.titus.runtime.endpoint.common.rest.provider.InstrumentedResourceMethodDispatchAdapter;
import com.netflix.titus.runtime.endpoint.metadata.SimpleHttpCallMetadataResolver;
import com.netflix.titus.runtime.endpoint.v3.rest.AutoScalingResource;
import com.netflix.titus.runtime.endpoint.v3.rest.HealthResource;
import com.netflix.titus.runtime.endpoint.v3.rest.JobManagementResource;
import com.netflix.titus.runtime.endpoint.v3.rest.LoadBalancerResource;
import com.sun.jersey.api.core.DefaultResourceConfig;
import com.sun.jersey.guice.JerseyServletModule;
/**
* We use this module to wire up our endpoints.
*/
public final class JerseyModule extends JerseyServletModule {
@Override
protected void configureServlets() {
// Store HTTP servlet request data in thread local variable
filter("/api/v3/*").through(CallerContextFilter.class);
// Call metadata interceptor (see CallMetadataHeaders).
filter("/api/v3/*").through(SimpleHttpCallMetadataResolver.CallMetadataInterceptorFilter.class);
// Configure servlet to serve resources for all other api paths
serve("/api/*").with(GovernatorServletContainer.class);
}
@Provides
@Singleton
public RestServerConfiguration getRestServerConfiguration(ConfigProxyFactory factory) {
return factory.newProxy(RestServerConfiguration.class);
}
@Advises
@Singleton
@Named("governator")
UnaryOperator<DefaultResourceConfig> getConfig() {
return config -> {
// providers
config.getClasses().add(JsonMessageReaderWriter.class);
config.getClasses().add(TitusExceptionMapper.class);
config.getClasses().add(InstrumentedResourceMethodDispatchAdapter.class);
// resources
config.getClasses().add(HealthResource.class);
config.getClasses().add(FederationSchedulerResource.class);
config.getClasses().add(JobManagementResource.class);
config.getClasses().add(AutoScalingResource.class);
config.getClasses().add(LoadBalancerResource.class);
config.getClasses().add(FederationV2CapacityGroupResource.class);
return config;
};
}
@Override
public boolean equals(Object obj) {
return obj != null && getClass().equals(obj.getClass());
}
@Override
public int hashCode() {
return getClass().hashCode();
}
}
| 9,859 |
0 | Create_ds/titus-control-plane/titus-server-federation/src/main/java/com/netflix/titus/federation/endpoint | Create_ds/titus-control-plane/titus-server-federation/src/main/java/com/netflix/titus/federation/endpoint/rest/FederationV2CapacityGroupResource.java | /*
* Copyright 2019 Netflix, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.netflix.titus.federation.endpoint.rest;
import java.util.List;
import javax.inject.Inject;
import javax.inject.Singleton;
import javax.ws.rs.Consumes;
import javax.ws.rs.GET;
import javax.ws.rs.Path;
import javax.ws.rs.PathParam;
import javax.ws.rs.Produces;
import javax.ws.rs.QueryParam;
import javax.ws.rs.WebApplicationException;
import javax.ws.rs.core.MediaType;
import com.netflix.titus.api.endpoint.v2.rest.representation.ApplicationSlaRepresentation;
import com.netflix.titus.common.util.tuple.Either;
import com.netflix.titus.federation.endpoint.EndpointConfiguration;
import com.netflix.titus.federation.service.CellWebClientConnector;
import com.netflix.titus.federation.service.CellWebClientConnectorUtil;
import io.swagger.annotations.Api;
import org.springframework.core.ParameterizedTypeReference;
@Produces(MediaType.APPLICATION_JSON)
@Consumes(MediaType.APPLICATION_JSON)
@Api(tags = "CapacityManagement")
@Path(FederationV2CapacityGroupResource.BASE_PATH)
@Singleton
public class FederationV2CapacityGroupResource {
public static final String BASE_PATH = "/v2/management/applications";
public static final String API_PATH = "/api/v2/management/applications";
private static final ParameterizedTypeReference<ApplicationSlaRepresentation> APPLICATION_SLA_TP =
ParameterizedTypeReference.forType(ApplicationSlaRepresentation.class);
private static final ParameterizedTypeReference<List<ApplicationSlaRepresentation>> APPLICATION_SLA_LIST_TP =
new ParameterizedTypeReference<List<ApplicationSlaRepresentation>>() {
};
private final EndpointConfiguration configuration;
private final CellWebClientConnector cellWebClientConnector;
@Inject
public FederationV2CapacityGroupResource(EndpointConfiguration configuration,
CellWebClientConnector cellWebClientConnector) {
this.configuration = configuration;
this.cellWebClientConnector = cellWebClientConnector;
}
/**
* Returns all registered application SLAs.
*
* @return a collection of application SLAs or empty array if non present
*/
@GET
public List<ApplicationSlaRepresentation> getApplicationSLAs(@QueryParam("extended") boolean extended) {
Either<List<ApplicationSlaRepresentation>, WebApplicationException> result = CellWebClientConnectorUtil.doGetAndMerge(
cellWebClientConnector,
API_PATH + "?extended=" + extended,
APPLICATION_SLA_LIST_TP,
configuration.getRestRequestTimeoutMs()
);
if (result.hasError()) {
throw result.getError();
}
return result.getValue();
}
/**
* Returns application SLA data for a given application.
*
* @return HTTP 200, and application SLA in the response body or HTTP 404 if application SLA is not defined
* for the given application
*/
@GET
@Path("/{applicationName}")
public ApplicationSlaRepresentation getApplicationSLA(@PathParam("applicationName") String applicationName,
@QueryParam("extended") boolean extended) {
Either<ApplicationSlaRepresentation, WebApplicationException> result = CellWebClientConnectorUtil.doGetFromCell(
cellWebClientConnector,
API_PATH
+ '/' + applicationName + "?extended=" + extended,
APPLICATION_SLA_TP,
configuration.getRestRequestTimeoutMs()
);
if (result.hasError()) {
throw result.getError();
}
return result.getValue();
}
}
| 9,860 |
0 | Create_ds/titus-control-plane/titus-server-federation/src/main/java/com/netflix/titus/federation/endpoint | Create_ds/titus-control-plane/titus-server-federation/src/main/java/com/netflix/titus/federation/endpoint/rest/FederationV2CapacityGroupSpringResource.java | /*
* Copyright 2020 Netflix, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.netflix.titus.federation.endpoint.rest;
import java.util.List;
import javax.inject.Inject;
import javax.ws.rs.WebApplicationException;
import com.netflix.titus.api.endpoint.v2.rest.representation.ApplicationSlaRepresentation;
import com.netflix.titus.common.util.tuple.Either;
import com.netflix.titus.federation.endpoint.EndpointConfiguration;
import com.netflix.titus.federation.service.CellWebClientConnector;
import com.netflix.titus.federation.service.CellWebClientConnectorUtil;
import io.swagger.annotations.Api;
import org.springframework.core.ParameterizedTypeReference;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
@Api(tags = "CapacityManagement")
@RestController
@RequestMapping(path = "/api/v2/management/applications", produces = "application/json")
public class FederationV2CapacityGroupSpringResource {
public static final String API_PATH = "/api/v2/management/applications";
private static final ParameterizedTypeReference<ApplicationSlaRepresentation> APPLICATION_SLA_TP =
ParameterizedTypeReference.forType(ApplicationSlaRepresentation.class);
private static final ParameterizedTypeReference<List<ApplicationSlaRepresentation>> APPLICATION_SLA_LIST_TP =
new ParameterizedTypeReference<List<ApplicationSlaRepresentation>>() {
};
private final EndpointConfiguration configuration;
private final CellWebClientConnector cellWebClientConnector;
@Inject
public FederationV2CapacityGroupSpringResource(EndpointConfiguration configuration,
CellWebClientConnector cellWebClientConnector) {
this.configuration = configuration;
this.cellWebClientConnector = cellWebClientConnector;
}
/**
* Returns all registered application SLAs.
*
* @return a collection of application SLAs or empty array if non present
*/
@GetMapping
public List<ApplicationSlaRepresentation> getApplicationSLAs(@RequestParam(name = "extended", defaultValue = "false") boolean extended) {
Either<List<ApplicationSlaRepresentation>, WebApplicationException> result = CellWebClientConnectorUtil.doGetAndMerge(
cellWebClientConnector,
API_PATH + "?extended=" + extended,
APPLICATION_SLA_LIST_TP,
configuration.getRestRequestTimeoutMs()
);
return result.must();
}
/**
* Returns application SLA data for a given application.
*
* @return HTTP 200, and application SLA in the response body or HTTP 404 if application SLA is not defined
* for the given application
*/
@GetMapping(path = "/{applicationName}")
public ApplicationSlaRepresentation getApplicationSLA(@PathVariable("applicationName") String applicationName,
@RequestParam(name = "extended", defaultValue = "false") boolean extended) {
Either<ApplicationSlaRepresentation, WebApplicationException> result = CellWebClientConnectorUtil.doGetFromCell(
cellWebClientConnector,
API_PATH
+ '/' + applicationName + "?extended=" + extended,
APPLICATION_SLA_TP,
configuration.getRestRequestTimeoutMs()
);
return result.must();
}
}
| 9,861 |
0 | Create_ds/titus-control-plane/titus-server-federation/src/main/java/com/netflix/titus/federation | Create_ds/titus-control-plane/titus-server-federation/src/main/java/com/netflix/titus/federation/service/DefaultJobActivityHistoryService.java | package com.netflix.titus.federation.service;
import com.netflix.titus.api.model.callmetadata.CallMetadata;
import com.netflix.titus.federation.startup.GrpcConfiguration;
import com.netflix.titus.grpc.protogen.ActivityQueryResult;
import com.netflix.titus.grpc.protogen.JobActivityHistoryServiceGrpc.JobActivityHistoryServiceStub;
import com.netflix.titus.grpc.protogen.JobId;
import com.netflix.titus.runtime.service.JobActivityHistoryService;
import io.grpc.stub.StreamObserver;
import rx.Observable;
import javax.inject.Inject;
import javax.inject.Singleton;
import static com.netflix.titus.runtime.endpoint.common.grpc.GrpcUtil.createWrappedStub;
import static com.netflix.titus.runtime.endpoint.common.grpc.GrpcUtil.createRequestObservable;
import static com.netflix.titus.runtime.endpoint.common.grpc.GrpcUtil.createSimpleClientResponseObserver;
@Singleton
public class DefaultJobActivityHistoryService implements JobActivityHistoryService {
private final GrpcConfiguration grpcConfiguration;
private JobActivityHistoryServiceStub client;
@Inject
public DefaultJobActivityHistoryService(GrpcConfiguration grpcConfiguration,
JobActivityHistoryServiceStub client) {
this.grpcConfiguration = grpcConfiguration;
this.client = client;
}
public Observable<ActivityQueryResult> viewScalingActivities(JobId request, CallMetadata callMetadata) {
return createRequestObservable(emitter -> {
StreamObserver<ActivityQueryResult> streamObserver = createSimpleClientResponseObserver(emitter);
createWrappedStub(client, callMetadata, grpcConfiguration.getRequestTimeoutMs()).viewScalingActivities(request, streamObserver);
}, grpcConfiguration.getRequestTimeoutMs());
}
}
| 9,862 |
0 | Create_ds/titus-control-plane/titus-server-federation/src/main/java/com/netflix/titus/federation | Create_ds/titus-control-plane/titus-server-federation/src/main/java/com/netflix/titus/federation/service/FallbackJobServiceGateway.java | package com.netflix.titus.federation.service;
import com.netflix.spectator.api.Counter;
import com.netflix.spectator.api.Id;
import com.netflix.titus.api.model.callmetadata.CallMetadata;
import com.netflix.titus.common.runtime.TitusRuntime;
import com.netflix.titus.federation.startup.TitusFederationConfiguration;
import com.netflix.titus.grpc.protogen.Job;
import com.netflix.titus.grpc.protogen.JobAttributesDeleteRequest;
import com.netflix.titus.grpc.protogen.JobAttributesUpdate;
import com.netflix.titus.grpc.protogen.JobCapacityUpdate;
import com.netflix.titus.grpc.protogen.JobCapacityUpdateWithOptionalAttributes;
import com.netflix.titus.grpc.protogen.JobChangeNotification;
import com.netflix.titus.grpc.protogen.JobDescriptor;
import com.netflix.titus.grpc.protogen.JobDisruptionBudgetUpdate;
import com.netflix.titus.grpc.protogen.JobProcessesUpdate;
import com.netflix.titus.grpc.protogen.JobQuery;
import com.netflix.titus.grpc.protogen.JobQueryResult;
import com.netflix.titus.grpc.protogen.JobStatusUpdate;
import com.netflix.titus.grpc.protogen.ObserveJobsQuery;
import com.netflix.titus.grpc.protogen.Task;
import com.netflix.titus.grpc.protogen.TaskAttributesDeleteRequest;
import com.netflix.titus.grpc.protogen.TaskAttributesUpdate;
import com.netflix.titus.grpc.protogen.TaskKillRequest;
import com.netflix.titus.grpc.protogen.TaskMoveRequest;
import com.netflix.titus.grpc.protogen.TaskQuery;
import com.netflix.titus.grpc.protogen.TaskQueryResult;
import com.netflix.titus.runtime.jobmanager.gateway.JobServiceGateway;
import io.grpc.Status;
import io.grpc.StatusRuntimeException;
import reactor.core.publisher.Mono;
import rx.Completable;
import rx.Observable;
import javax.inject.Inject;
import java.util.Arrays;
import java.util.List;
public class FallbackJobServiceGateway implements JobServiceGateway {
public static final String METRIC_ROOT = "titus.fallbackJobServiceGateway.";
private static final String METRIC_FALLBACK_ROOT= METRIC_ROOT + "fallbackCount.";
private final TitusFederationConfiguration federationConfiguration;
private final JobServiceGateway primary;
private final JobServiceGateway secondary;
private final TitusRuntime titusRuntime;
private final List<Status.Code> fallbackCodes = Arrays.asList(Status.Code.UNIMPLEMENTED);
@Inject
public FallbackJobServiceGateway(
TitusRuntime titusRuntime,
TitusFederationConfiguration federationConfiguration,
RemoteJobServiceGateway primary,
AggregatingJobServiceGateway secondary) {
this.titusRuntime = titusRuntime;
this.federationConfiguration = federationConfiguration;
this.primary = primary;
this.secondary = secondary;
}
@Override
public Observable<String> createJob(JobDescriptor jobDescriptor, CallMetadata callMetadata) {
final String methodName = "createJob";
Observable<String> primaryObservable = primary.createJob(jobDescriptor, callMetadata);
Observable<String> secondaryObservable = secondary.createJob(jobDescriptor, callMetadata);
return getFallbackObservable(methodName, primaryObservable, secondaryObservable);
}
@Override
public Completable updateJobCapacity(JobCapacityUpdate jobCapacityUpdate, CallMetadata callMetadata) {
final String methodName = "updateJobCapacity";
Completable primaryCompletable = primary.updateJobCapacity(jobCapacityUpdate, callMetadata);
Completable secondaryCompletable = secondary.updateJobCapacity(jobCapacityUpdate, callMetadata);
return getFallbackCompletable(methodName, primaryCompletable, secondaryCompletable);
}
@Override
public Completable updateJobCapacityWithOptionalAttributes(JobCapacityUpdateWithOptionalAttributes jobCapacityUpdateWithOptionalAttributes, CallMetadata callMetadata) {
final String methodName = "updateJobCapacityWithOptionalAttributes";
Completable primaryCompletable = primary.updateJobCapacityWithOptionalAttributes(
jobCapacityUpdateWithOptionalAttributes,
callMetadata);
Completable secondaryCompletable = secondary.updateJobCapacityWithOptionalAttributes(
jobCapacityUpdateWithOptionalAttributes,
callMetadata);
return getFallbackCompletable(methodName, primaryCompletable, secondaryCompletable);
}
@Override
public Completable updateJobProcesses(JobProcessesUpdate jobProcessesUpdate, CallMetadata callMetadata) {
final String methodName = "updateJobProcesses";
Completable primaryCompletable = primary.updateJobProcesses(jobProcessesUpdate, callMetadata);
Completable secondaryCompletable = secondary.updateJobProcesses(jobProcessesUpdate, callMetadata);
return getFallbackCompletable(methodName, primaryCompletable, secondaryCompletable);
}
@Override
public Completable updateJobStatus(JobStatusUpdate statusUpdate, CallMetadata callMetadata) {
final String methodName = "updateJobStatus";
Completable primaryCompletable = primary.updateJobStatus(statusUpdate, callMetadata);
Completable secondaryCompletable = secondary.updateJobStatus(statusUpdate, callMetadata);
return getFallbackCompletable(methodName, primaryCompletable, secondaryCompletable);
}
@Override
public Mono<Void> updateJobDisruptionBudget(JobDisruptionBudgetUpdate request, CallMetadata callMetadata) {
final String methodName = "updateJobDisruptionBudget";
Mono<Void> primaryMono = primary.updateJobDisruptionBudget(request, callMetadata);
Mono<Void> secondaryMono = secondary.updateJobDisruptionBudget(request, callMetadata);
return getFallbackMono(methodName, primaryMono, secondaryMono);
}
@Override
public Mono<Void> updateJobAttributes(JobAttributesUpdate request, CallMetadata callMetadata) {
final String methodName = "updateJobAttributes";
Mono<Void> primaryMono = primary.updateJobAttributes(request, callMetadata);
Mono<Void> secondaryMono = secondary.updateJobAttributes(request, callMetadata);
return getFallbackMono(methodName, primaryMono, secondaryMono);
}
@Override
public Mono<Void> deleteJobAttributes(JobAttributesDeleteRequest request, CallMetadata callMetadata) {
final String methodName = "deleteJobAttributes";
Mono<Void> primaryMono = primary.deleteJobAttributes(request, callMetadata);
Mono<Void> secondaryMono = secondary.deleteJobAttributes(request, callMetadata);
return getFallbackMono(methodName, primaryMono, secondaryMono);
}
@Override
public Observable<Job> findJob(String jobId, CallMetadata callMetadata) {
final String methodName = "findJob";
Observable<Job> primaryObservable = primary.findJob(jobId, callMetadata);
Observable<Job> secondaryObservable = secondary.findJob(jobId, callMetadata);
return getFallbackObservable(methodName, primaryObservable, secondaryObservable);
}
@Override
public Observable<JobQueryResult> findJobs(JobQuery jobQuery, CallMetadata callMetadata) {
final String methodName = "findJobs";
Observable<JobQueryResult> primaryObservable = primary.findJobs(jobQuery, callMetadata);
Observable<JobQueryResult> secondaryObservable = secondary.findJobs(jobQuery, callMetadata);
return getFallbackObservable(methodName, primaryObservable, secondaryObservable);
}
@Override
public Observable<JobChangeNotification> observeJob(String jobId, CallMetadata callMetadata) {
// Fallback is not applicable to streaming APIs.
if (federationConfiguration.isRemoteFederationEnabled()) {
return primary.observeJob(jobId, callMetadata);
}
return secondary.observeJob(jobId, callMetadata);
}
@Override
public Observable<JobChangeNotification> observeJobs(ObserveJobsQuery query, CallMetadata callMetadata) {
// Fallback is not applicable to streaming APIs.
if (federationConfiguration.isRemoteFederationEnabled()) {
return primary.observeJobs(query, callMetadata);
}
return secondary.observeJobs(query, callMetadata);
}
@Override
public Completable killJob(String jobId, CallMetadata callMetadata) {
final String methodName = "killJob";
Completable primaryCompletable = primary.killJob(jobId, callMetadata);
Completable secondaryCompletable = secondary.killJob(jobId, callMetadata);
return getFallbackCompletable(methodName, primaryCompletable, secondaryCompletable);
}
@Override
public Observable<Task> findTask(String taskId, CallMetadata callMetadata) {
final String methodName = "findTask";
Observable<Task> primaryObservable = primary.findTask(taskId, callMetadata);
Observable<Task> secondaryObservable = secondary.findTask(taskId, callMetadata);
return getFallbackObservable(methodName, primaryObservable, secondaryObservable);
}
@Override
public Observable<TaskQueryResult> findTasks(TaskQuery taskQuery, CallMetadata callMetadata) {
final String methodName = "findTasks";
Observable<TaskQueryResult> primaryObservable = primary.findTasks(taskQuery, callMetadata);
Observable<TaskQueryResult> secondaryObservable = secondary.findTasks(taskQuery, callMetadata);
return getFallbackObservable(methodName, primaryObservable, secondaryObservable);
}
@Override
public Completable killTask(TaskKillRequest taskKillRequest, CallMetadata callMetadata) {
final String methodName = "killTask";
Completable primaryCompletable = primary.killTask(taskKillRequest, callMetadata);
Completable secondaryCompletable = secondary.killTask(taskKillRequest, callMetadata);
return getFallbackCompletable(methodName, primaryCompletable, secondaryCompletable);
}
@Override
public Completable updateTaskAttributes(TaskAttributesUpdate request, CallMetadata callMetadata) {
final String methodName = "updateTaskAttributes";
Completable primaryCompletable = primary.updateTaskAttributes(request, callMetadata);
Completable secondaryCompletable = secondary.updateTaskAttributes(request, callMetadata);
return getFallbackCompletable(methodName, primaryCompletable, secondaryCompletable);
}
@Override
public Completable deleteTaskAttributes(TaskAttributesDeleteRequest request, CallMetadata callMetadata) {
final String methodName = "deleteTaskAttributes";
Completable primaryCompletable = primary.deleteTaskAttributes(request, callMetadata);
Completable secondaryCompletable = secondary.deleteTaskAttributes(request, callMetadata);
return getFallbackCompletable(methodName, primaryCompletable, secondaryCompletable);
}
@Override
public Completable moveTask(TaskMoveRequest taskMoveRequest, CallMetadata callMetadata) {
final String methodName = "moveTask";
Completable primaryCompletable = primary.moveTask(taskMoveRequest, callMetadata);
Completable secondaryCompletable = secondary.moveTask(taskMoveRequest, callMetadata);
return getFallbackCompletable(methodName, primaryCompletable, secondaryCompletable);
}
private <T> Observable<T> getFallbackObservable(String methodName, Observable<T> primary, Observable<T> secondary) {
if (federationConfiguration.isRemoteFederationEnabled()) {
return primary.onErrorResumeNext( (t) -> {
incrementFallbackCounter(methodName, t);
if (shouldFallback(t)) {
return secondary;
} else {
return Observable.error(t);
}
});
} else {
return secondary;
}
}
private <T> Mono<T> getFallbackMono(String methodName, Mono<T> primary, Mono<T> secondary) {
if (federationConfiguration.isRemoteFederationEnabled()) {
return primary.onErrorResume(t -> {
incrementFallbackCounter(methodName, t);
if (shouldFallback(t)) {
return secondary;
} else {
return Mono.error(t);
}
});
} else {
return secondary;
}
}
private Completable getFallbackCompletable(String methodName, Completable primary, Completable secondary) {
return getFallbackObservable(methodName, primary.toObservable(), secondary.toObservable()).toCompletable();
}
private boolean shouldFallback(Throwable t) {
return t instanceof StatusRuntimeException && fallbackCodes.contains(Status.fromThrowable(t).getCode());
}
private void incrementFallbackCounter(String methodName, Throwable t) {
Id metricId = this.getMetricId(METRIC_FALLBACK_ROOT + methodName, t);
this.titusRuntime.getRegistry().counter(metricId).increment();
}
private Id getMetricId(String metricName, Throwable t) {
Status.Code code = Status.fromThrowable(t).getCode();
String reason = code == Status.Code.UNKNOWN ? t.getClass().getSimpleName() : code.toString();
return this.titusRuntime.getRegistry().createId(
metricName,
"reason", reason);
}
}
| 9,863 |
0 | Create_ds/titus-control-plane/titus-server-federation/src/main/java/com/netflix/titus/federation | Create_ds/titus-control-plane/titus-server-federation/src/main/java/com/netflix/titus/federation/service/CellConnectorUtil.java | /*
* Copyright 2018 Netflix, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.netflix.titus.federation.service;
import java.util.Map;
import java.util.Optional;
import java.util.function.BiConsumer;
import java.util.function.Function;
import java.util.stream.Collectors;
import com.netflix.titus.api.federation.model.Cell;
import com.netflix.titus.api.service.TitusServiceException;
import com.netflix.titus.runtime.endpoint.common.grpc.GrpcUtil;
import io.grpc.ManagedChannel;
import io.grpc.stub.AbstractStub;
import io.grpc.stub.StreamObserver;
import rx.Observable;
final class CellConnectorUtil {
private CellConnectorUtil() {
}
static <T extends AbstractStub> Map<Cell, T> stubs(CellConnector connector, Function<ManagedChannel, T> stubFactory) {
return connector.getChannels()
.entrySet().stream()
.collect(Collectors.toMap(
Map.Entry::getKey,
entry -> stubFactory.apply(entry.getValue())
));
}
static <T extends AbstractStub> Optional<T> toStub(Cell cell, CellConnector connector, Function<ManagedChannel, T> stubFactory) {
Optional<ManagedChannel> optionalChannel = connector.getChannelForCell(cell);
return optionalChannel.map(stubFactory);
}
static <STUB extends AbstractStub<STUB>, RespT> Observable<RespT> callToCell(
Cell cell,
CellConnector connector,
Function<ManagedChannel, STUB> stubFactory,
BiConsumer<STUB, StreamObserver<RespT>> fnCall) {
Optional<ManagedChannel> channel = connector.getChannelForCell(cell);
if (!channel.isPresent()) {
return Observable.error(TitusServiceException.invalidArgument("Invalid Cell " + cell));
}
STUB targetClient = stubFactory.apply(channel.get());
return GrpcUtil.createRequestObservable(emitter -> {
StreamObserver<RespT> streamObserver = GrpcUtil.createSimpleClientResponseObserver(emitter);
fnCall.accept(targetClient, streamObserver);
});
}
}
| 9,864 |
0 | Create_ds/titus-control-plane/titus-server-federation/src/main/java/com/netflix/titus/federation | Create_ds/titus-control-plane/titus-server-federation/src/main/java/com/netflix/titus/federation/service/CellConnector.java | /*
* Copyright 2018 Netflix, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.netflix.titus.federation.service;
import java.util.Map;
import java.util.Optional;
import com.netflix.titus.api.federation.model.Cell;
import io.grpc.ManagedChannel;
public interface CellConnector {
Map<Cell, ManagedChannel> getChannels();
Optional<ManagedChannel> getChannelForCell(Cell cell);
}
| 9,865 |
0 | Create_ds/titus-control-plane/titus-server-federation/src/main/java/com/netflix/titus/federation | Create_ds/titus-control-plane/titus-server-federation/src/main/java/com/netflix/titus/federation/service/AggregatingLoadbalancerService.java | /*
* Copyright 2018 Netflix, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.netflix.titus.federation.service;
import java.util.List;
import java.util.function.BiConsumer;
import java.util.stream.Collectors;
import javax.inject.Inject;
import javax.inject.Singleton;
import com.google.protobuf.Empty;
import com.netflix.titus.api.federation.model.Cell;
import com.netflix.titus.api.loadbalancer.model.JobLoadBalancer;
import com.netflix.titus.api.model.callmetadata.CallMetadata;
import com.netflix.titus.api.service.TitusServiceException;
import com.netflix.titus.common.util.StringExt;
import com.netflix.titus.common.util.tuple.Pair;
import com.netflix.titus.federation.startup.GrpcConfiguration;
import com.netflix.titus.grpc.protogen.AddLoadBalancerRequest;
import com.netflix.titus.grpc.protogen.GetAllLoadBalancersRequest;
import com.netflix.titus.grpc.protogen.GetAllLoadBalancersResult;
import com.netflix.titus.grpc.protogen.GetJobLoadBalancersResult;
import com.netflix.titus.grpc.protogen.JobId;
import com.netflix.titus.grpc.protogen.LoadBalancerServiceGrpc;
import com.netflix.titus.grpc.protogen.LoadBalancerServiceGrpc.LoadBalancerServiceStub;
import com.netflix.titus.grpc.protogen.Pagination;
import com.netflix.titus.grpc.protogen.RemoveLoadBalancerRequest;
import com.netflix.titus.runtime.endpoint.metadata.CallMetadataResolver;
import com.netflix.titus.runtime.loadbalancer.GrpcModelConverters;
import com.netflix.titus.runtime.loadbalancer.LoadBalancerCursors;
import com.netflix.titus.runtime.service.LoadBalancerService;
import io.grpc.stub.AbstractStub;
import io.grpc.stub.StreamObserver;
import rx.Completable;
import rx.Observable;
import static com.netflix.titus.federation.service.CellConnectorUtil.callToCell;
import static com.netflix.titus.federation.service.PageAggregationUtil.combinePagination;
import static com.netflix.titus.federation.service.PageAggregationUtil.takeCombinedPage;
import static com.netflix.titus.runtime.endpoint.common.grpc.GrpcUtil.createWrappedStub;
import static com.netflix.titus.runtime.endpoint.v3.grpc.GrpcJobQueryModelConverters.emptyGrpcPagination;
import static com.netflix.titus.runtime.endpoint.v3.grpc.GrpcJobQueryModelConverters.toPagination;
@Singleton
public class AggregatingLoadbalancerService implements LoadBalancerService {
private final AggregatingCellClient aggregatingClient;
private final AggregatingJobManagementServiceHelper jobManagementServiceHelper;
private final CellConnector connector;
private final GrpcConfiguration grpcConfiguration;
@Inject
public AggregatingLoadbalancerService(CellConnector connector,
CallMetadataResolver callMetadataResolver,
GrpcConfiguration grpcConfiguration,
AggregatingCellClient aggregatingClient,
AggregatingJobManagementServiceHelper jobManagementServiceHelper) {
this.connector = connector;
this.grpcConfiguration = grpcConfiguration;
this.aggregatingClient = aggregatingClient;
this.jobManagementServiceHelper = jobManagementServiceHelper;
}
@Override
public Observable<GetAllLoadBalancersResult> getAllLoadBalancers(GetAllLoadBalancersRequest request, CallMetadata callMetadata) {
if (request.getPage().getPageSize() <= 0) {
return Observable.just(GetAllLoadBalancersResult.newBuilder()
.setPagination(emptyGrpcPagination(request.getPage()))
.build());
}
if (StringExt.isNotEmpty(request.getPage().getCursor()) || request.getPage().getPageNumber() == 0) {
return findLoadBalancersWithCursorPagination(request, callMetadata);
}
return Observable.error(TitusServiceException.invalidArgument("pageNumbers are not supported, please use cursors"));
}
@Override
public Observable<GetJobLoadBalancersResult> getLoadBalancers(JobId jobId, CallMetadata callMetadata) {
ClientCall<GetJobLoadBalancersResult> getLoadBalancersForJob =
(client, responseObserver) -> wrap(client, callMetadata).getJobLoadBalancers(jobId, responseObserver);
return aggregatingClient.callExpectingErrors(LoadBalancerServiceGrpc::newStub, getLoadBalancersForJob)
.filter(response -> response.getResult().hasError() || response.getResult().getValue().getLoadBalancersCount() > 0)
.reduce(ResponseMerger.emptyResponseMarker(), ResponseMerger.singleValue())
.filter(ResponseMerger::isNotEmptyResponseMarker)
.flatMap(response -> response.getResult().map(Observable::just).onErrorGet(Observable::error))
.switchIfEmpty(Observable.just(GetJobLoadBalancersResult.newBuilder().setJobId(jobId.getId()).build()));
}
@Override
public Completable addLoadBalancer(AddLoadBalancerRequest request, CallMetadata callMetadata) {
JobId jobId = JobId.newBuilder().setId(request.getJobId()).build();
final Observable<Empty> responseObservable = jobManagementServiceHelper.findJobInAllCells(jobId.getId(), callMetadata)
.flatMap(response -> singleCellCall(response.getCell(),
(client, responseObserver) -> client.addLoadBalancer(request, responseObserver),
callMetadata));
return responseObservable.toCompletable();
}
@Override
public Completable removeLoadBalancer(RemoveLoadBalancerRequest removeLoadBalancerRequest, CallMetadata callMetadata) {
JobId jobId = JobId.newBuilder().setId(removeLoadBalancerRequest.getJobId()).build();
final Observable<Empty> responseObservable = jobManagementServiceHelper.findJobInAllCells(jobId.getId(), callMetadata)
.flatMap(response -> singleCellCall(response.getCell(),
(client, responseObserver) -> client.removeLoadBalancer(removeLoadBalancerRequest, responseObserver),
callMetadata));
return responseObservable.toCompletable();
}
private <STUB extends AbstractStub<STUB>> STUB wrap(STUB stub, CallMetadata callMetadata) {
return createWrappedStub(stub, callMetadata, grpcConfiguration.getRequestTimeoutMs());
}
private <T> Observable<T> singleCellCall(Cell cell, ClientCall<T> clientCall, CallMetadata callMetadata) {
return callToCell(cell, connector, LoadBalancerServiceGrpc::newStub,
(client, streamObserver) -> clientCall.accept(wrap(client, callMetadata), streamObserver));
}
private interface ClientCall<T> extends BiConsumer<LoadBalancerServiceStub, StreamObserver<T>> {
// generics sanity
}
private ClientCall<GetAllLoadBalancersResult> getAllLoadBalancersInCell(GetAllLoadBalancersRequest request, CallMetadata callMetadata) {
return (client, streamObserver) -> wrap(client, callMetadata).getAllLoadBalancers(request, streamObserver);
}
private Observable<GetAllLoadBalancersResult> findLoadBalancersWithCursorPagination(GetAllLoadBalancersRequest request, CallMetadata callMetadata) {
return aggregatingClient.call(LoadBalancerServiceGrpc::newStub, getAllLoadBalancersInCell(request, callMetadata))
.map(CellResponse::getResult)
.reduce(this::combineGetAllJobLoadBalancersResult)
.map(combinedResults -> {
Pair<List<JobLoadBalancer>, Pagination> combinedPage = takeCombinedPage(
request.getPage(),
toListOfJobLoadBalancer(combinedResults),
combinedResults.getPagination(),
LoadBalancerCursors.loadBalancerComparator(),
LoadBalancerCursors::newCursorFrom);
return GrpcModelConverters.toGetAllLoadBalancersResult(combinedPage.getLeft(), toPagination(combinedPage.getRight()));
});
}
private GetAllLoadBalancersResult combineGetAllJobLoadBalancersResult(GetAllLoadBalancersResult one,
GetAllLoadBalancersResult other) {
Pagination pagination = combinePagination(one.getPagination(), other.getPagination());
return GetAllLoadBalancersResult.newBuilder()
.setPagination(pagination)
.addAllJobLoadBalancers(one.getJobLoadBalancersList())
.addAllJobLoadBalancers(other.getJobLoadBalancersList())
.build();
}
private List<JobLoadBalancer> toListOfJobLoadBalancer(GetAllLoadBalancersResult result) {
return result.getJobLoadBalancersList().stream()
.flatMap(jobLoadBalancersResult -> {
final String jobId = jobLoadBalancersResult.getJobId();
return jobLoadBalancersResult.getLoadBalancersList().stream()
.map(loadBalancerId -> new JobLoadBalancer(jobId, loadBalancerId.getId()));
})
.collect(Collectors.toList());
}
}
| 9,866 |
0 | Create_ds/titus-control-plane/titus-server-federation/src/main/java/com/netflix/titus/federation | Create_ds/titus-control-plane/titus-server-federation/src/main/java/com/netflix/titus/federation/service/ResponseMerger.java | /*
* Copyright 2018 Netflix, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.netflix.titus.federation.service;
import com.google.common.base.Preconditions;
import com.netflix.titus.common.util.tuple.Either;
import io.grpc.stub.AbstractStub;
import rx.functions.Func2;
interface ResponseMerger<STUB extends AbstractStub<STUB>, T> extends Func2<
CellResponse<STUB, T>,
CellResponse<STUB, T>,
CellResponse<STUB, T>> {
// generics sanity
/**
* Merge results by returning the first non-error value encountered. Otherwise merge all error results with a
* fallback merger.
*
* @param errorMerger fallback merger for errors
*/
static <STUB extends AbstractStub<STUB>, T>
ResponseMerger<STUB, Either<T, Throwable>> singleValue(ErrorMerger<STUB, T> errorMerger) {
return (one, other) -> {
if (isEmptyResponseMarker(one)) {
return other;
}
if (isEmptyResponseMarker(other)) {
return one;
}
boolean bothHaveValues = one.getResult().hasValue() && other.getResult().hasValue();
Preconditions.checkArgument(!bothHaveValues, "expecting a single non-error response");
if (one.getResult().hasValue()) {
return one;
}
if (other.getResult().hasValue()) {
return other;
}
return errorMerger.call(one, other);
};
}
final CellResponse<?, ?> EMPTY_RESPONSE_MARKER = new CellResponse<>(null, null, null);
/**
* Marker to be used with {@link rx.Observable#reduce(Object, Func2)} and {@link rx.Observable#reduce(Func2)} on
* empty Observables. By design, <tt>reduce</tt> emits an error for empty Observables. This marker can be used as
* the initial seed, and will be passed through in case the <tt>Observable</tt> is empty, and can be filtered out
* later with {@link ResponseMerger#isNotEmptyResponseMarker(CellResponse)}. Merger functions _must_ ignore the
* empty marker with {@link ResponseMerger#isEmptyResponseMarker(CellResponse)}.
* <p>
* See https://github.com/ReactiveX/RxJava/pull/474
*/
@SuppressWarnings("unchecked")
static <STUB extends AbstractStub<STUB>, T> CellResponse<STUB, T> emptyResponseMarker() {
return (CellResponse<STUB, T>) EMPTY_RESPONSE_MARKER;
}
static <STUB extends AbstractStub<STUB>, T> boolean isEmptyResponseMarker(CellResponse<STUB, T> response) {
return response == EMPTY_RESPONSE_MARKER;
}
static <STUB extends AbstractStub<STUB>, T> boolean isNotEmptyResponseMarker(CellResponse<STUB, T> response) {
return response != EMPTY_RESPONSE_MARKER;
}
static <STUB extends AbstractStub<STUB>, T> ResponseMerger<STUB, Either<T, Throwable>> singleValue() {
return singleValue(ErrorMerger.<STUB, T>grpcWithDefaultPriorities());
}
}
| 9,867 |
0 | Create_ds/titus-control-plane/titus-server-federation/src/main/java/com/netflix/titus/federation | Create_ds/titus-control-plane/titus-server-federation/src/main/java/com/netflix/titus/federation/service/AggregatingJobServiceGateway.java | /*
* Copyright 2018 Netflix, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.netflix.titus.federation.service;
import java.util.Collections;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.Set;
import java.util.concurrent.CountDownLatch;
import java.util.function.BiConsumer;
import java.util.stream.Collectors;
import javax.inject.Inject;
import javax.inject.Singleton;
import com.google.protobuf.Empty;
import com.netflix.titus.api.federation.model.Cell;
import com.netflix.titus.api.model.callmetadata.CallMetadata;
import com.netflix.titus.api.service.TitusServiceException;
import com.netflix.titus.common.runtime.TitusRuntime;
import com.netflix.titus.common.util.CollectionsExt;
import com.netflix.titus.common.util.ProtobufExt;
import com.netflix.titus.common.util.StringExt;
import com.netflix.titus.common.util.concurrency.CallbackCountDownLatch;
import com.netflix.titus.common.util.rx.EmitterWithMultipleSubscriptions;
import com.netflix.titus.common.util.rx.ReactorExt;
import com.netflix.titus.common.util.tuple.Pair;
import com.netflix.titus.federation.service.router.CellRouter;
import com.netflix.titus.federation.startup.GrpcConfiguration;
import com.netflix.titus.federation.startup.TitusFederationConfiguration;
import com.netflix.titus.grpc.protogen.Job;
import com.netflix.titus.grpc.protogen.JobAttributesDeleteRequest;
import com.netflix.titus.grpc.protogen.JobAttributesUpdate;
import com.netflix.titus.grpc.protogen.JobCapacityUpdate;
import com.netflix.titus.grpc.protogen.JobCapacityUpdateWithOptionalAttributes;
import com.netflix.titus.grpc.protogen.JobChangeNotification;
import com.netflix.titus.grpc.protogen.JobChangeNotification.JobUpdate;
import com.netflix.titus.grpc.protogen.JobChangeNotification.TaskUpdate;
import com.netflix.titus.grpc.protogen.JobDescriptor;
import com.netflix.titus.grpc.protogen.JobDisruptionBudgetUpdate;
import com.netflix.titus.grpc.protogen.JobId;
import com.netflix.titus.grpc.protogen.JobManagementServiceGrpc;
import com.netflix.titus.grpc.protogen.JobManagementServiceGrpc.JobManagementServiceStub;
import com.netflix.titus.grpc.protogen.JobProcessesUpdate;
import com.netflix.titus.grpc.protogen.JobQuery;
import com.netflix.titus.grpc.protogen.JobQueryResult;
import com.netflix.titus.grpc.protogen.JobStatusUpdate;
import com.netflix.titus.grpc.protogen.ObserveJobsQuery;
import com.netflix.titus.grpc.protogen.Pagination;
import com.netflix.titus.grpc.protogen.Task;
import com.netflix.titus.grpc.protogen.TaskAttributesDeleteRequest;
import com.netflix.titus.grpc.protogen.TaskAttributesUpdate;
import com.netflix.titus.grpc.protogen.TaskId;
import com.netflix.titus.grpc.protogen.TaskKillRequest;
import com.netflix.titus.grpc.protogen.TaskMoveRequest;
import com.netflix.titus.grpc.protogen.TaskQuery;
import com.netflix.titus.grpc.protogen.TaskQueryResult;
import com.netflix.titus.runtime.connector.jobmanager.JobEventPropagationUtil;
import com.netflix.titus.runtime.endpoint.common.grpc.GrpcUtil;
import com.netflix.titus.runtime.jobmanager.JobManagerCursors;
import com.netflix.titus.runtime.jobmanager.gateway.JobServiceGateway;
import io.grpc.stub.StreamObserver;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import reactor.core.publisher.Mono;
import rx.Completable;
import rx.Emitter;
import rx.Observable;
import static com.netflix.titus.api.jobmanager.JobAttributes.JOB_ATTRIBUTES_FEDERATED_JOB_ID;
import static com.netflix.titus.api.jobmanager.JobAttributes.JOB_ATTRIBUTES_STACK;
import static com.netflix.titus.api.jobmanager.JobAttributes.JOB_ATTRIBUTE_ROUTING_CELL;
import static com.netflix.titus.api.jobmanager.TaskAttributes.TASK_ATTRIBUTES_STACK;
import static com.netflix.titus.federation.service.CellConnectorUtil.callToCell;
import static com.netflix.titus.federation.service.PageAggregationUtil.combinePagination;
import static com.netflix.titus.federation.service.PageAggregationUtil.takeCombinedPage;
import static com.netflix.titus.runtime.connector.jobmanager.JobEventPropagationUtil.CHECKPOINT_FED_CLIENT;
import static com.netflix.titus.runtime.endpoint.common.grpc.GrpcUtil.createRequestObservable;
import static com.netflix.titus.runtime.endpoint.common.grpc.GrpcUtil.createWrappedStub;
import static com.netflix.titus.runtime.endpoint.v3.grpc.GrpcJobQueryModelConverters.emptyGrpcPagination;
@Singleton
public class AggregatingJobServiceGateway implements JobServiceGateway {
private static final Logger logger = LoggerFactory.getLogger(AggregatingJobServiceGateway.class);
// some fields are required from each cell, so pagination cursors can be generated
private static final Set<String> JOB_FEDERATION_MINIMUM_FIELD_SET = CollectionsExt.asSet("id", "status", "statusHistory");
private static final Set<String> TASK_FEDERATION_MINIMUM_FIELD_SET = CollectionsExt.asSet("id", "status", "statusHistory");
private final GrpcConfiguration grpcConfiguration;
private final TitusFederationConfiguration federationConfiguration;
private final CellConnector cellConnector;
private final AggregatingCellClient aggregatingClient;
private final AggregatingJobManagementServiceHelper jobManagementServiceHelper;
private final TitusRuntime titusRuntime;
private final CellRouter router;
@Inject
public AggregatingJobServiceGateway(GrpcConfiguration grpcConfiguration,
TitusFederationConfiguration federationConfiguration,
CellConnector cellConnector,
CellRouter router,
AggregatingCellClient aggregatingClient,
AggregatingJobManagementServiceHelper jobManagementServiceHelper,
TitusRuntime titusRuntime) {
this.grpcConfiguration = grpcConfiguration;
this.federationConfiguration = federationConfiguration;
this.cellConnector = cellConnector;
this.router = router;
this.aggregatingClient = aggregatingClient;
this.jobManagementServiceHelper = jobManagementServiceHelper;
this.titusRuntime = titusRuntime;
}
@Override
public Observable<String> createJob(JobDescriptor jobDescriptor, CallMetadata callMetadata) {
Cell cell = router.routeKey(jobDescriptor).orElse(null);
if (cell == null) {
// This should never happen in a correctly setup system.
return Observable.error(new IllegalStateException("Internal system error. Routing rule not found"));
}
logger.debug("Routing JobDescriptor {} to Cell {}", jobDescriptor, cell);
Optional<JobManagementServiceStub> optionalClient = CellConnectorUtil.toStub(cell, cellConnector, JobManagementServiceGrpc::newStub);
if (!optionalClient.isPresent()) {
return Observable.error(TitusServiceException.cellNotFound(cell.getName()));
}
JobManagementServiceStub client = optionalClient.get();
JobDescriptor.Builder jobDescriptorBuilder = addStackName(jobDescriptor.toBuilder());
jobDescriptorBuilder = removeFederationAttributes(jobDescriptorBuilder);
jobDescriptorBuilder = addRoutingCell(jobDescriptorBuilder, cell);
JobDescriptor jd = jobDescriptorBuilder.build();
return createRequestObservable(emitter -> {
StreamObserver<JobId> streamObserver = GrpcUtil.createClientResponseObserver(
emitter,
jobId -> emitter.onNext(jobId.getId()),
emitter::onError,
emitter::onCompleted
);
wrap(client, callMetadata).createJob(jd, streamObserver);
}, grpcConfiguration.getRequestTimeoutMs());
}
@Override
public Completable updateJobCapacity(JobCapacityUpdate request, CallMetadata callMetadata) {
Observable<Empty> result = jobManagementServiceHelper.findJobInAllCells(request.getJobId(), callMetadata)
.flatMap(response -> singleCellCall(response.getCell(),
(client, streamObserver) -> client.updateJobCapacity(request, streamObserver),
callMetadata)
);
return result.toCompletable();
}
@Override
public Completable updateJobCapacityWithOptionalAttributes(JobCapacityUpdateWithOptionalAttributes request, CallMetadata callMetadata) {
Observable<Empty> result = jobManagementServiceHelper.findJobInAllCells(request.getJobId(), callMetadata)
.flatMap(response -> singleCellCall(response.getCell(),
(client, streamObserver) -> client.updateJobCapacityWithOptionalAttributes(request, streamObserver),
callMetadata)
);
return result.toCompletable();
}
@Override
public Completable updateJobProcesses(JobProcessesUpdate request, CallMetadata callMetadata) {
Observable<Empty> result = jobManagementServiceHelper.findJobInAllCells(request.getJobId(), callMetadata)
.flatMap(response -> singleCellCall(response.getCell(),
(client, streamObserver) -> client.updateJobProcesses(request, streamObserver),
callMetadata)
);
return result.toCompletable();
}
@Override
public Completable updateJobStatus(JobStatusUpdate request, CallMetadata callMetadata) {
Observable<Empty> result = jobManagementServiceHelper.findJobInAllCells(request.getId(), callMetadata)
.flatMap(response -> singleCellCall(response.getCell(),
(client, streamObserver) -> client.updateJobStatus(request, streamObserver),
callMetadata)
);
return result.toCompletable();
}
@Override
public Mono<Void> updateJobDisruptionBudget(JobDisruptionBudgetUpdate request, CallMetadata callMetadata) {
Mono<Empty> result = jobManagementServiceHelper.findJobInAllCellsReact(request.getJobId(), callMetadata)
.flatMap(response -> singleCellCallReact(response.getCell(),
(client, streamObserver) -> client.updateJobDisruptionBudget(request, streamObserver),
callMetadata)
);
return result.ignoreElement().cast(Void.class);
}
@Override
public Mono<Void> updateJobAttributes(JobAttributesUpdate request, CallMetadata callMetadata) {
Mono<Empty> result = jobManagementServiceHelper.findJobInAllCellsReact(request.getJobId(), callMetadata)
.flatMap(response -> singleCellCallReact(response.getCell(),
(client, streamObserver) -> client.updateJobAttributes(request, streamObserver),
callMetadata)
);
return result.ignoreElement().cast(Void.class);
}
@Override
public Mono<Void> deleteJobAttributes(JobAttributesDeleteRequest request, CallMetadata callMetadata) {
Mono<Empty> result = jobManagementServiceHelper.findJobInAllCellsReact(request.getJobId(), callMetadata)
.flatMap(response -> singleCellCallReact(response.getCell(),
(client, streamObserver) -> client.deleteJobAttributes(request, streamObserver),
callMetadata)
);
return result.ignoreElement().cast(Void.class);
}
@Override
public Observable<Job> findJob(String jobId, CallMetadata callMetadata) {
return jobManagementServiceHelper.findJobInAllCells(jobId, callMetadata)
.map(CellResponse::getResult)
.map(this::addStackName);
}
@Override
public Observable<JobQueryResult> findJobs(JobQuery request, CallMetadata callMetadata) {
if (request.getPage().getPageSize() <= 0) {
return Observable.just(JobQueryResult.newBuilder()
.setPagination(emptyGrpcPagination(request.getPage()))
.build());
}
Set<String> fieldsFilter = Collections.emptySet();
if (request.getFieldsCount() > 0) {
fieldsFilter = new HashSet<>(request.getFieldsList());
fieldsFilter.addAll(JOB_MINIMUM_FIELD_SET);
request = request.toBuilder()
.addAllFields(fieldsFilter)
.addAllFields(JOB_FEDERATION_MINIMUM_FIELD_SET)
.build();
}
if (StringExt.isNotEmpty(request.getPage().getCursor()) || request.getPage().getPageNumber() == 0) {
return findJobsWithCursorPagination(request, fieldsFilter, callMetadata);
}
// TODO: page number pagination
return Observable.error(TitusServiceException.invalidArgument("pageNumbers are not supported, please use cursors"));
}
private Observable<JobQueryResult> findJobsWithCursorPagination(JobQuery request, Set<String> fields, CallMetadata callMetadata) {
return aggregatingClient.call(JobManagementServiceGrpc::newStub, findJobsInCell(request, callMetadata))
.map(CellResponse::getResult)
.map(this::addStackName)
.reduce(this::combineJobResults)
.map(combinedResults -> {
Pair<List<Job>, Pagination> combinedPage = takeCombinedPage(
request.getPage(),
combinedResults.getItemsList(),
combinedResults.getPagination(),
JobManagerCursors.jobCursorOrderComparator(),
JobManagerCursors::newCursorFrom
);
if (!CollectionsExt.isNullOrEmpty(fields)) {
combinedPage = combinedPage.mapLeft(jobs -> jobs.stream()
.map(job -> ProtobufExt.copy(job, fields))
.collect(Collectors.toList())
);
}
return JobQueryResult.newBuilder()
.addAllItems(combinedPage.getLeft())
.setPagination(combinedPage.getRight())
.build();
});
}
private ClientCall<JobQueryResult> findJobsInCell(JobQuery request, CallMetadata callMetadata) {
return (client, streamObserver) -> wrap(client, callMetadata).findJobs(request, streamObserver);
}
private JobQueryResult combineJobResults(JobQueryResult one, JobQueryResult other) {
Pagination pagination = combinePagination(one.getPagination(), other.getPagination());
return JobQueryResult.newBuilder()
.setPagination(pagination)
.addAllItems(one.getItemsList())
.addAllItems(other.getItemsList())
.build();
}
@Override
public Observable<JobChangeNotification> observeJob(String jobId, CallMetadata callMetadata) {
JobId request = JobId.newBuilder().setId(jobId).build();
return jobManagementServiceHelper.findJobInAllCells(jobId, callMetadata)
.flatMap(response -> singleCellCallWithNoDeadline(response.getCell(),
(client, streamObserver) -> client.observeJob(request, streamObserver),
callMetadata)
);
}
@Override
public Observable<JobChangeNotification> observeJobs(ObserveJobsQuery query, CallMetadata callMetadata) {
final Observable<JobChangeNotification> observable = createRequestObservable(delegate -> {
Emitter<JobChangeNotification> emitter = new EmitterWithMultipleSubscriptions<>(delegate);
Map<Cell, JobManagementServiceStub> clients = CellConnectorUtil.stubs(cellConnector, JobManagementServiceGrpc::newStub);
final CountDownLatch markersEmitted = new CallbackCountDownLatch(clients.size(),
() -> emitter.onNext(buildJobSnapshotEndMarker())
);
clients.forEach((cell, client) -> {
StreamObserver<JobChangeNotification> streamObserver = new FilterOutFirstMarker(emitter, markersEmitted);
wrapWithNoDeadline(client, callMetadata).observeJobs(query, streamObserver);
});
});
return observable.map(this::addStackName);
}
@Override
public Completable killJob(String jobId, CallMetadata callMetadata) {
JobId id = JobId.newBuilder().setId(jobId).build();
Observable<Empty> result = jobManagementServiceHelper.findJobInAllCells(jobId, callMetadata)
.flatMap(response -> singleCellCall(response.getCell(),
(client, streamObserver) -> client.killJob(id, streamObserver),
callMetadata)
);
return result.toCompletable();
}
@Override
public Observable<Task> findTask(String taskId, CallMetadata callMetadata) {
return findTaskInAllCells(taskId, callMetadata).map(CellResponse::getResult).map(this::addStackName);
}
private Observable<CellResponse<JobManagementServiceStub, Task>> findTaskInAllCells(String taskId, CallMetadata callMetadata) {
return aggregatingClient.callExpectingErrors(JobManagementServiceGrpc::newStub, findTaskInCell(taskId, callMetadata))
.reduce(ResponseMerger.singleValue())
.flatMap(response -> response.getResult()
.map(v -> Observable.just(CellResponse.ofValue(response)))
.onErrorGet(Observable::error)
);
}
private ClientCall<Task> findTaskInCell(String taskId, CallMetadata callMetadata) {
TaskId id = TaskId.newBuilder().setId(taskId).build();
return (client, streamObserver) -> wrap(client, callMetadata).findTask(id, streamObserver);
}
@Override
public Observable<TaskQueryResult> findTasks(TaskQuery request, CallMetadata callMetadata) {
if (request.getPage().getPageSize() <= 0) {
return Observable.just(TaskQueryResult.newBuilder()
.setPagination(emptyGrpcPagination(request.getPage()))
.build());
}
Set<String> fieldsFilter = Collections.emptySet();
if (request.getFieldsCount() > 0) {
fieldsFilter = new HashSet<>(request.getFieldsList());
fieldsFilter.addAll(TASK_MINIMUM_FIELD_SET);
request = request.toBuilder()
.addAllFields(fieldsFilter)
.addAllFields(TASK_FEDERATION_MINIMUM_FIELD_SET)
.build();
}
if (StringExt.isNotEmpty(request.getPage().getCursor()) || request.getPage().getPageNumber() == 0) {
return findTasksWithCursorPagination(request, fieldsFilter, callMetadata);
}
// TODO: page number pagination
return Observable.error(TitusServiceException.invalidArgument("pageNumbers are not supported, please use cursors"));
}
private Observable<TaskQueryResult> findTasksWithCursorPagination(TaskQuery request, Set<String> fields, CallMetadata callMetadata) {
return aggregatingClient.call(JobManagementServiceGrpc::newStub, findTasksInCell(request, callMetadata))
.map(CellResponse::getResult)
.map(this::addStackName)
.reduce(this::combineTaskResults)
.map(combinedResults -> {
Pair<List<Task>, Pagination> combinedPage = takeCombinedPage(
request.getPage(),
combinedResults.getItemsList(),
combinedResults.getPagination(),
JobManagerCursors.taskCursorOrderComparator(),
JobManagerCursors::newTaskCursorFrom
);
if (!CollectionsExt.isNullOrEmpty(fields)) {
combinedPage = combinedPage.mapLeft(tasks -> tasks.stream()
.map(task -> ProtobufExt.copy(task, fields))
.collect(Collectors.toList())
);
}
return TaskQueryResult.newBuilder()
.addAllItems(combinedPage.getLeft())
.setPagination(combinedPage.getRight())
.build();
});
}
private ClientCall<TaskQueryResult> findTasksInCell(TaskQuery request, CallMetadata callMetadata) {
return (client, streamObserver) -> wrap(client, callMetadata).findTasks(request, streamObserver);
}
private TaskQueryResult combineTaskResults(TaskQueryResult one, TaskQueryResult other) {
Pagination pagination = combinePagination(one.getPagination(), other.getPagination());
return TaskQueryResult.newBuilder()
.setPagination(pagination)
.addAllItems(one.getItemsList())
.addAllItems(other.getItemsList())
.build();
}
@Override
public Completable killTask(TaskKillRequest request, CallMetadata callMetadata) {
Observable<Empty> result = findTaskInAllCells(request.getTaskId(), callMetadata)
.flatMap(response -> singleCellCall(response.getCell(),
(client, streamObserver) -> client.killTask(request, streamObserver),
callMetadata)
);
return result.toCompletable();
}
@Override
public Completable updateTaskAttributes(TaskAttributesUpdate attributesUpdate, CallMetadata callMetadata) {
Observable<Empty> result = findTaskInAllCells(attributesUpdate.getTaskId(), callMetadata)
.flatMap(response -> singleCellCall(response.getCell(),
(client, streamObserver) -> client.updateTaskAttributes(attributesUpdate, streamObserver),
callMetadata));
return result.toCompletable();
}
@Override
public Completable deleteTaskAttributes(TaskAttributesDeleteRequest deleteRequest, CallMetadata callMetadata) {
Observable<Empty> result = findTaskInAllCells(deleteRequest.getTaskId(), callMetadata)
.flatMap(response -> singleCellCall(response.getCell(),
(client, streamObserver) -> client.deleteTaskAttributes(deleteRequest, streamObserver),
callMetadata));
return result.toCompletable();
}
@Override
public Completable moveTask(TaskMoveRequest taskMoveRequest, CallMetadata callMetadata) {
Observable<Empty> result = findTaskInAllCells(taskMoveRequest.getTaskId(), callMetadata)
.flatMap(response -> singleCellCall(response.getCell(),
(client, streamObserver) -> client.moveTask(taskMoveRequest, streamObserver),
callMetadata));
return result.toCompletable();
}
private JobDescriptor.Builder addRoutingCell(JobDescriptor.Builder jobDescriptorBuilder, Cell cell) {
return jobDescriptorBuilder
.putAttributes(JOB_ATTRIBUTE_ROUTING_CELL, cell.getName());
}
private JobDescriptor.Builder removeFederationAttributes(JobDescriptor.Builder jobDescriptorBuilder) {
return jobDescriptorBuilder
.removeAttributes(JOB_ATTRIBUTES_FEDERATED_JOB_ID);
}
private JobQueryResult addStackName(JobQueryResult result) {
List<Job> withStackName = result.getItemsList().stream().map(this::addStackName).collect(Collectors.toList());
return result.toBuilder().clearItems().addAllItems(withStackName).build();
}
private TaskQueryResult addStackName(TaskQueryResult result) {
List<Task> withStackName = result.getItemsList().stream().map(this::addStackName).collect(Collectors.toList());
return result.toBuilder().clearItems().addAllItems(withStackName).build();
}
private JobDescriptor.Builder addStackName(JobDescriptor.Builder jobDescriptorBuilder) {
return jobDescriptorBuilder.putAttributes(JOB_ATTRIBUTES_STACK, federationConfiguration.getStack());
}
private JobDescriptor addStackName(JobDescriptor jobDescriptor) {
return addStackName(jobDescriptor.toBuilder()).build();
}
private Job addStackName(Job job) {
JobDescriptor jobDescriptor = addStackName(job.getJobDescriptor());
return job.toBuilder().setJobDescriptor(jobDescriptor).build();
}
private Task addStackName(Task task) {
return task.toBuilder()
.putTaskContext(TASK_ATTRIBUTES_STACK, federationConfiguration.getStack())
.build();
}
private JobChangeNotification addStackName(JobChangeNotification notification) {
switch (notification.getNotificationCase()) {
case JOBUPDATE:
Job job = addStackName(notification.getJobUpdate().getJob());
job = JobEventPropagationUtil.recordChannelLatency(CHECKPOINT_FED_CLIENT, job, notification.getTimestamp(), titusRuntime.getClock());
JobUpdate jobUpdate = notification.getJobUpdate().toBuilder().setJob(job).build();
return notification.toBuilder().setJobUpdate(jobUpdate).build();
case TASKUPDATE:
Task task = addStackName(notification.getTaskUpdate().getTask());
task = JobEventPropagationUtil.recordChannelLatency(CHECKPOINT_FED_CLIENT, task, notification.getTimestamp(), titusRuntime.getClock());
TaskUpdate taskUpdate = notification.getTaskUpdate().toBuilder().setTask(task).build();
return notification.toBuilder().setTaskUpdate(taskUpdate).build();
default:
return notification;
}
}
private static JobChangeNotification buildJobSnapshotEndMarker() {
final JobChangeNotification.SnapshotEnd marker = JobChangeNotification.SnapshotEnd.newBuilder().build();
return JobChangeNotification.newBuilder().setSnapshotEnd(marker).build();
}
private JobManagementServiceStub wrap(JobManagementServiceStub client, CallMetadata callMetadata) {
return createWrappedStub(client, callMetadata, grpcConfiguration.getRequestTimeoutMs());
}
private JobManagementServiceStub wrapWithNoDeadline(JobManagementServiceStub client, CallMetadata callMetadata) {
return createWrappedStub(client, callMetadata);
}
private <T> Observable<T> singleCellCall(Cell cell, ClientCall<T> clientCall, CallMetadata callMetadata) {
return callToCell(cell, cellConnector, JobManagementServiceGrpc::newStub,
(client, streamObserver) -> clientCall.accept(wrap(client, callMetadata), streamObserver));
}
private <T> Mono<T> singleCellCallReact(Cell cell, ClientCall<T> clientCall, CallMetadata callMetadata) {
return ReactorExt.toMono(singleCellCall(cell, clientCall, callMetadata).toSingle());
}
private <T> Observable<T> singleCellCallWithNoDeadline(Cell cell, ClientCall<T> clientCall, CallMetadata callMetadata) {
return callToCell(cell, cellConnector, JobManagementServiceGrpc::newStub,
(client, streamObserver) -> clientCall.accept(wrapWithNoDeadline(client, callMetadata), streamObserver));
}
private interface ClientCall<T> extends BiConsumer<JobManagementServiceStub, StreamObserver<T>> {
// generics sanity
}
}
| 9,868 |
0 | Create_ds/titus-control-plane/titus-server-federation/src/main/java/com/netflix/titus/federation | Create_ds/titus-control-plane/titus-server-federation/src/main/java/com/netflix/titus/federation/service/PageAggregationUtil.java | /*
* Copyright 2018 Netflix, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.netflix.titus.federation.service;
import java.util.Comparator;
import java.util.List;
import java.util.function.Function;
import java.util.stream.Collectors;
import com.netflix.titus.common.util.tuple.Pair;
import com.netflix.titus.grpc.protogen.Page;
import com.netflix.titus.grpc.protogen.Pagination;
final class PageAggregationUtil {
private PageAggregationUtil() {
}
static <T> Pair<List<T>, Pagination> takeCombinedPage(Page requested,
List<T> combinedItems,
Pagination combinedPagination,
Comparator<T> cursorComparator,
Function<T, String> cursorFactory) {
List<T> sorted = combinedItems.stream()
.sorted(cursorComparator)
.collect(Collectors.toList());
int lastItemOffset = Math.min(sorted.size(), requested.getPageSize());
List<T> pageItems = sorted.subList(0, lastItemOffset);
String cursor = sorted.isEmpty() ? "" : cursorFactory.apply(pageItems.get(pageItems.size() - 1));
// first item position relative to totalItems from all Cells
int firstItemPosition = Math.max(0, combinedPagination.getCursorPosition() - (sorted.size() - 1));
int pageNumber = firstItemPosition / requested.getPageSize();
Pagination finalPagination = Pagination.newBuilder(combinedPagination)
.setCurrentPage(Page.newBuilder(requested).setPageNumber(pageNumber))
.setCursor(cursor)
.setCursorPosition(firstItemPosition + lastItemOffset - 1)
.setHasMore(combinedPagination.getHasMore() || lastItemOffset < sorted.size())
.build();
return Pair.of(pageItems, finalPagination);
}
static Pagination combinePagination(Pagination one, Pagination other) {
int cursorPosition = one.getCursorPosition() + other.getCursorPosition();
if (one.getTotalItems() > 0 && other.getTotalItems() > 0) {
// the cursorPosition on each cell always points to (totalItemsReturned - 1), when merging two cells
// with items, we need to compensate two deductions on the total number of items, so the final (merged)
// cursorPosition is still (totalItemsBeingReturned - 1).
// Note that when either one of the cells is empty, the cursorPosition from the empty cell will be 0 and
// there is nothing to compensate since there are no items in that cell.
cursorPosition++;
}
return Pagination.newBuilder()
// combined currentPage.pageNumber and cursor will be computed later
.setHasMore(one.getHasMore() || other.getHasMore())
.setTotalPages(one.getTotalPages() + other.getTotalPages())
.setTotalItems(one.getTotalItems() + other.getTotalItems())
.setCursorPosition(cursorPosition)
.build();
}
}
| 9,869 |
0 | Create_ds/titus-control-plane/titus-server-federation/src/main/java/com/netflix/titus/federation | Create_ds/titus-control-plane/titus-server-federation/src/main/java/com/netflix/titus/federation/service/WebClientFactory.java | /*
* Copyright 2019 Netflix, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.netflix.titus.federation.service;
import java.util.function.Function;
import com.netflix.titus.api.federation.model.Cell;
import org.springframework.web.reactive.function.client.WebClient;
public interface WebClientFactory extends Function<Cell, WebClient> {
}
| 9,870 |
0 | Create_ds/titus-control-plane/titus-server-federation/src/main/java/com/netflix/titus/federation | Create_ds/titus-control-plane/titus-server-federation/src/main/java/com/netflix/titus/federation/service/DefaultRemoteFederationInfoResolver.java | package com.netflix.titus.federation.service;
import com.netflix.titus.api.federation.model.RemoteFederation;
import com.netflix.titus.federation.startup.TitusFederationConfiguration;
import javax.inject.Inject;
public class DefaultRemoteFederationInfoResolver implements RemoteFederationInfoResolver {
private final TitusFederationConfiguration configuration;
@Inject
public DefaultRemoteFederationInfoResolver(TitusFederationConfiguration configuration) {
this.configuration = configuration;
}
@Override
public RemoteFederation resolve() {
return new RemoteFederation(configuration.getRemoteFederation());
}
}
| 9,871 |
0 | Create_ds/titus-control-plane/titus-server-federation/src/main/java/com/netflix/titus/federation | Create_ds/titus-control-plane/titus-server-federation/src/main/java/com/netflix/titus/federation/service/StatusCategoryComparator.java | /*
* Copyright 2018 Netflix, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.netflix.titus.federation.service;
import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import io.grpc.Status;
import static io.grpc.Status.Code.ABORTED;
import static io.grpc.Status.Code.ALREADY_EXISTS;
import static io.grpc.Status.Code.CANCELLED;
import static io.grpc.Status.Code.DATA_LOSS;
import static io.grpc.Status.Code.DEADLINE_EXCEEDED;
import static io.grpc.Status.Code.FAILED_PRECONDITION;
import static io.grpc.Status.Code.INTERNAL;
import static io.grpc.Status.Code.INVALID_ARGUMENT;
import static io.grpc.Status.Code.NOT_FOUND;
import static io.grpc.Status.Code.OUT_OF_RANGE;
import static io.grpc.Status.Code.PERMISSION_DENIED;
import static io.grpc.Status.Code.RESOURCE_EXHAUSTED;
import static io.grpc.Status.Code.UNAUTHENTICATED;
import static io.grpc.Status.Code.UNAVAILABLE;
import static io.grpc.Status.Code.UNIMPLEMENTED;
import static io.grpc.Status.Code.UNKNOWN;
/**
* Group gRPC {@link Status} codes in categories (buckets) with different precedence. More important errors take place
* of less important errors.
* <p>
* Errors not explicitly provided are considered less important than the ones explicitly provided.
*/
class StatusCategoryComparator implements Comparator<Status> {
private final Map<Status.Code, Integer> priorities = new HashMap<>();
@SafeVarargs
StatusCategoryComparator(List<Status.Code>... statusCategories) {
for (int i = 0; i < statusCategories.length; i++) {
List<Status.Code> codes = statusCategories[i];
for (Status.Code code : codes) {
if (priorities.putIfAbsent(code, i) != null) {
throw new IllegalArgumentException(code + " has been already specified with a different priority");
}
}
}
}
@Override
public int compare(Status one, Status other) {
if (!priorities.containsKey(one.getCode())) {
return 1;
}
if (!priorities.containsKey(other.getCode())) {
return -1;
}
return priorities.get(one.getCode()).compareTo(priorities.get(other.getCode()));
}
private static final StatusCategoryComparator DEFAULT = new StatusCategoryComparator(
// unexpected system errors first
Arrays.asList(UNKNOWN, PERMISSION_DENIED, UNIMPLEMENTED, INTERNAL, DATA_LOSS, UNAUTHENTICATED),
// then errors where the entity existed somewhere
Arrays.asList(FAILED_PRECONDITION, INVALID_ARGUMENT, ALREADY_EXISTS, OUT_OF_RANGE),
// then transient errors
Arrays.asList(UNAVAILABLE, CANCELLED, DEADLINE_EXCEEDED, RESOURCE_EXHAUSTED, ABORTED),
// NOT_FOUND for sure only if it came from everywhere
Collections.singletonList(NOT_FOUND)
);
/**
* A default categorization with priorities that should be good enough for most point query cases. The precedence
* order is:
* <p>
* 1. Unexpected system errors.
* 2. Errors where we can deduce the entity existed in a Cell (e.g.: validation errors).
* 3. Transient errors.
* 4. <tt>NOT_FOUND</tt> (we can only be sure if all errors are a <tt>NOT_FOUND</tt>)
*/
static StatusCategoryComparator defaultPriorities() {
return DEFAULT;
}
}
| 9,872 |
0 | Create_ds/titus-control-plane/titus-server-federation/src/main/java/com/netflix/titus/federation | Create_ds/titus-control-plane/titus-server-federation/src/main/java/com/netflix/titus/federation/service/ServiceComponent.java | /*
* Copyright 2020 Netflix, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.netflix.titus.federation.service;
import com.netflix.titus.common.runtime.TitusRuntime;
import com.netflix.titus.federation.startup.TitusFederationConfiguration;
import com.netflix.titus.runtime.jobmanager.gateway.JobServiceGateway;
import com.netflix.titus.runtime.service.TitusAgentSecurityGroupClient;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Import;
import org.springframework.context.annotation.Primary;
@Configuration
@Import({
AggregatingCellClient.class,
AggregatingHealthService.class,
AggregatingJobManagementServiceHelper.class,
AggregatingJobServiceGateway.class,
AggregatingAutoScalingService.class,
AggregatingLoadbalancerService.class,
DefaultAggregatingSchedulerService.class,
DefaultJobActivityHistoryService.class,
RemoteJobServiceGateway.class,
DefaultTitusAgentSecurityGroupClient.class,
DefaultVpcServiceConnector.class,
})
public class ServiceComponent {
@Bean
@Primary
public JobServiceGateway getFallbackJobServiceGateway(
TitusRuntime titusRuntime,
TitusFederationConfiguration federationConfiguration,
RemoteJobServiceGateway primary,
AggregatingJobServiceGateway secondary) {
return new FallbackJobServiceGateway(titusRuntime, federationConfiguration, primary, secondary);
}
}
| 9,873 |
0 | Create_ds/titus-control-plane/titus-server-federation/src/main/java/com/netflix/titus/federation | Create_ds/titus-control-plane/titus-server-federation/src/main/java/com/netflix/titus/federation/service/CellInfoResolver.java | /*
* Copyright 2018 Netflix, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.netflix.titus.federation.service;
import java.util.List;
import com.netflix.titus.api.federation.model.Cell;
public interface CellInfoResolver {
/**
* @return all registered cells
*/
List<Cell> resolve();
/**
* @return cell to be used when no existing routing rules match
*/
Cell getDefault();
}
| 9,874 |
0 | Create_ds/titus-control-plane/titus-server-federation/src/main/java/com/netflix/titus/federation | Create_ds/titus-control-plane/titus-server-federation/src/main/java/com/netflix/titus/federation/service/CellResponse.java | /*
* Copyright 2018 Netflix, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.netflix.titus.federation.service;
import com.netflix.titus.api.federation.model.Cell;
import com.netflix.titus.common.util.tuple.Either;
import io.grpc.stub.AbstractStub;
class CellResponse<STUB extends AbstractStub<STUB>, T> {
private final Cell cell;
private final STUB client;
private final T result;
CellResponse(Cell cell, STUB client, T result) {
this.cell = cell;
this.client = client;
this.result = result;
}
public Cell getCell() {
return cell;
}
public STUB getClient() {
return client;
}
public T getResult() {
return result;
}
@Override
public String toString() {
return "CellResponse{" +
"cell=" + cell +
", client=" + client +
", result=" + result +
'}';
}
public static <STUB extends AbstractStub<STUB>, T>
CellResponse<STUB, T> ofValue(CellResponse<STUB, Either<T, Throwable>> response) {
return new CellResponse<>(response.getCell(), response.getClient(), response.getResult().getValue());
}
}
| 9,875 |
0 | Create_ds/titus-control-plane/titus-server-federation/src/main/java/com/netflix/titus/federation | Create_ds/titus-control-plane/titus-server-federation/src/main/java/com/netflix/titus/federation/service/AggregatingAutoScalingService.java | /*
* Copyright 2018 Netflix, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.netflix.titus.federation.service;
import java.util.function.BiConsumer;
import javax.inject.Inject;
import javax.inject.Singleton;
import com.google.protobuf.Empty;
import com.netflix.titus.api.federation.model.Cell;
import com.netflix.titus.api.model.callmetadata.CallMetadata;
import com.netflix.titus.federation.startup.GrpcConfiguration;
import com.netflix.titus.grpc.protogen.AutoScalingServiceGrpc;
import com.netflix.titus.grpc.protogen.DeletePolicyRequest;
import com.netflix.titus.grpc.protogen.GetPolicyResult;
import com.netflix.titus.grpc.protogen.JobId;
import com.netflix.titus.grpc.protogen.PutPolicyRequest;
import com.netflix.titus.grpc.protogen.ScalingPolicyID;
import com.netflix.titus.grpc.protogen.UpdatePolicyRequest;
import com.netflix.titus.runtime.service.AutoScalingService;
import io.grpc.stub.AbstractStub;
import io.grpc.stub.StreamObserver;
import rx.Completable;
import rx.Observable;
import static com.netflix.titus.federation.service.CellConnectorUtil.callToCell;
import static com.netflix.titus.grpc.protogen.AutoScalingServiceGrpc.AutoScalingServiceStub;
import static com.netflix.titus.runtime.endpoint.common.grpc.GrpcUtil.createWrappedStub;
@Singleton
public class AggregatingAutoScalingService implements AutoScalingService {
private final CellConnector connector;
private final AggregatingCellClient aggregatingClient;
private final GrpcConfiguration grpcConfiguration;
private final AggregatingJobManagementServiceHelper jobManagementServiceHelper;
@Inject
public AggregatingAutoScalingService(CellConnector connector,
GrpcConfiguration configuration,
AggregatingJobManagementServiceHelper jobManagementServiceHelper,
AggregatingCellClient aggregatingClient) {
this.connector = connector;
grpcConfiguration = configuration;
this.jobManagementServiceHelper = jobManagementServiceHelper;
this.aggregatingClient = aggregatingClient;
}
@Override
public Observable<GetPolicyResult> getJobScalingPolicies(JobId jobId, CallMetadata callMetadata) {
return aggregatingClient.callExpectingErrors(AutoScalingServiceGrpc::newStub, getJobScalingPoliciesInCell(jobId, callMetadata))
.filter(response -> response.getResult().hasError() || response.getResult().getValue().getItemsCount() > 0)
.reduce(ResponseMerger.emptyResponseMarker(), ResponseMerger.singleValue())
.filter(ResponseMerger::isNotEmptyResponseMarker)
.flatMap(response -> response.getResult()
.map(Observable::just)
.onErrorGet(Observable::error)
)
.switchIfEmpty(Observable.just(GetPolicyResult.newBuilder().build()));
}
private ClientCall<GetPolicyResult> getJobScalingPoliciesInCell(JobId jobId, CallMetadata callMetadata) {
return (client, responseObserver) -> wrap(client, callMetadata).getJobScalingPolicies(jobId, responseObserver);
}
@Override
public Observable<ScalingPolicyID> setAutoScalingPolicy(PutPolicyRequest request, CallMetadata callMetadata) {
JobId jobId = JobId.newBuilder().setId(request.getJobId()).build();
return jobManagementServiceHelper.findJobInAllCells(jobId.getId(), callMetadata)
.flatMap(response -> singleCellCall(response.getCell(),
(client, responseObserver) -> client.setAutoScalingPolicy(request, responseObserver),
callMetadata)
);
}
@Override
public Observable<GetPolicyResult> getScalingPolicy(ScalingPolicyID request, CallMetadata callMetadata) {
// each Cell returns an Status.INTERNAL error today when the id is not found
// TODO: make the error condition more explicit and return NOT_ERROR
return getScalingPolicyInAllCells(request, callMetadata).map(CellResponse::getResult);
}
/**
* @return can be an empty Observable. Callers must handle it appropriately, usually with
* {@link Observable#switchIfEmpty(Observable)}.
*/
private Observable<CellResponse<AutoScalingServiceStub, GetPolicyResult>> getScalingPolicyInAllCells(ScalingPolicyID request,
CallMetadata callMetadata) {
return aggregatingClient.callExpectingErrors(AutoScalingServiceGrpc::newStub, getScalingPolicyInCell(request, callMetadata))
.filter(response -> response.getResult().hasError() || response.getResult().getValue().getItemsCount() > 0)
// Observable#reduce does not support empty Observables, so we inject a marker and take it out after
// merging results. The marker will be passed through only when the Observable is empty
.reduce(ResponseMerger.emptyResponseMarker(), ResponseMerger.singleValue())
.filter(ResponseMerger::isNotEmptyResponseMarker)
.flatMap(response -> response.getResult()
.map(v -> Observable.just(CellResponse.ofValue(response)))
.onErrorGet(Observable::error)
);
}
private ClientCall<GetPolicyResult> getScalingPolicyInCell(ScalingPolicyID request, CallMetadata callMetadata) {
return (client, responseObserver) -> wrap(client, callMetadata).getScalingPolicy(request, responseObserver);
}
@Override
public Observable<GetPolicyResult> getAllScalingPolicies(CallMetadata callMetadata) {
return aggregatingClient.call(AutoScalingServiceGrpc::newStub, getAllScalingPoliciesInCell(callMetadata))
.map(CellResponse::getResult)
.reduce((acc, next) -> GetPolicyResult.newBuilder()
.addAllItems(acc.getItemsList())
.addAllItems(next.getItemsList())
.build()
);
}
private ClientCall<GetPolicyResult> getAllScalingPoliciesInCell(CallMetadata callMetadata) {
return (client, responseObserver) ->
wrap(client, callMetadata).getAllScalingPolicies(Empty.getDefaultInstance(), responseObserver);
}
@Override
public Completable deleteAutoScalingPolicy(DeletePolicyRequest request, CallMetadata callMetadata) {
ScalingPolicyID policyId = request.getId();
Observable<Empty> observable = getScalingPolicyInAllCells(policyId, callMetadata)
.flatMap(response -> singleCellCall(response.getCell(),
(client, responseObserver) -> client.deleteAutoScalingPolicy(request, responseObserver),
callMetadata)
);
return observable.toCompletable();
}
@Override
public Completable updateAutoScalingPolicy(UpdatePolicyRequest request, CallMetadata callMetadata) {
ScalingPolicyID policyId = request.getPolicyId();
Observable<Empty> observable = getScalingPolicyInAllCells(policyId, callMetadata)
.flatMap(response -> singleCellCall(response.getCell(),
(client, responseObserver) -> client.updateAutoScalingPolicy(request, responseObserver),
callMetadata)
);
return observable.toCompletable();
}
private <T> Observable<T> singleCellCall(Cell cell, ClientCall<T> clientCall, CallMetadata callMetadata) {
return callToCell(cell, connector, AutoScalingServiceGrpc::newStub,
(client, streamObserver) -> clientCall.accept(wrap(client, callMetadata), streamObserver));
}
private <STUB extends AbstractStub<STUB>> STUB wrap(STUB stub, CallMetadata callMetadata) {
return createWrappedStub(stub, callMetadata, grpcConfiguration.getRequestTimeoutMs());
}
private interface ClientCall<T> extends BiConsumer<AutoScalingServiceStub, StreamObserver<T>> {
// generics sanity
}
}
| 9,876 |
0 | Create_ds/titus-control-plane/titus-server-federation/src/main/java/com/netflix/titus/federation | Create_ds/titus-control-plane/titus-server-federation/src/main/java/com/netflix/titus/federation/service/DefaultAggregatingSchedulerService.java | /*
* Copyright 2019 Netflix, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.netflix.titus.federation.service;
import java.util.function.BiConsumer;
import javax.inject.Inject;
import javax.inject.Singleton;
import com.netflix.titus.common.util.rx.ReactorExt;
import com.netflix.titus.federation.startup.GrpcConfiguration;
import com.netflix.titus.grpc.protogen.SchedulerServiceGrpc;
import com.netflix.titus.grpc.protogen.SchedulingResultEvent;
import com.netflix.titus.grpc.protogen.SchedulingResultRequest;
import com.netflix.titus.runtime.endpoint.common.grpc.GrpcUtil;
import com.netflix.titus.runtime.endpoint.metadata.CallMetadataResolver;
import io.grpc.stub.StreamObserver;
import reactor.core.publisher.Mono;
import rx.Observable;
import static com.netflix.titus.runtime.endpoint.common.grpc.GrpcUtil.createWrappedStub;
@Singleton
public class DefaultAggregatingSchedulerService implements AggregatingSchedulerService {
private final GrpcConfiguration grpcConfiguration;
private final AggregatingCellClient aggregatingClient;
private final CallMetadataResolver callMetadataResolver;
@Inject
public DefaultAggregatingSchedulerService(GrpcConfiguration grpcConfiguration,
AggregatingCellClient aggregatingClient,
CallMetadataResolver callMetadataResolver) {
this.grpcConfiguration = grpcConfiguration;
this.aggregatingClient = aggregatingClient;
this.callMetadataResolver = callMetadataResolver;
}
@Override
public Mono<SchedulingResultEvent> findLastSchedulingResult(String taskId) {
return findSchedulingResultInAllCells(taskId).map(CellResponse::getResult);
}
private Mono<CellResponse<SchedulerServiceGrpc.SchedulerServiceStub, SchedulingResultEvent>> findSchedulingResultInAllCells(String taskId) {
Observable<CellResponse<SchedulerServiceGrpc.SchedulerServiceStub, SchedulingResultEvent>> action = aggregatingClient.callExpectingErrors(SchedulerServiceGrpc::newStub, findSchedulingResultInCell(taskId))
.reduce(ResponseMerger.singleValue())
.flatMap(response -> response.getResult()
.map(v -> Observable.just(CellResponse.ofValue(response)))
.onErrorGet(Observable::error)
);
return ReactorExt.toFlux(action).last();
}
private ClientCall<SchedulingResultEvent> findSchedulingResultInCell(String taskId) {
SchedulingResultRequest request = SchedulingResultRequest.newBuilder().setTaskId(taskId).build();
return (client, streamObserver) -> wrap(client).getSchedulingResult(request, streamObserver);
}
private SchedulerServiceGrpc.SchedulerServiceStub wrap(SchedulerServiceGrpc.SchedulerServiceStub client) {
return GrpcUtil.createWrappedStubWithResolver(client, callMetadataResolver, grpcConfiguration.getRequestTimeoutMs());
}
private interface ClientCall<T> extends BiConsumer<SchedulerServiceGrpc.SchedulerServiceStub, StreamObserver<T>> {
// generics sanity
}
}
| 9,877 |
0 | Create_ds/titus-control-plane/titus-server-federation/src/main/java/com/netflix/titus/federation | Create_ds/titus-control-plane/titus-server-federation/src/main/java/com/netflix/titus/federation/service/DefaultCellWebClientConnector.java | /*
* Copyright 2019 Netflix, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.netflix.titus.federation.service;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Optional;
import java.util.Set;
import javax.inject.Inject;
import javax.inject.Singleton;
import com.netflix.titus.api.federation.model.Cell;
import org.springframework.web.reactive.function.client.WebClient;
@Singleton
public class DefaultCellWebClientConnector implements CellWebClientConnector {
private final Map<Cell, WebClient> webClientsByCell;
@Inject
public DefaultCellWebClientConnector(CellInfoResolver cellInfoResolver,
WebClientFactory cellWebClientFactory) {
this.webClientsByCell = buildWebClients(cellInfoResolver, cellWebClientFactory);
}
@Override
public Map<Cell, WebClient> getWebClients() {
return webClientsByCell;
}
@Override
public Optional<WebClient> getWebClientForCell(Cell cell) {
return Optional.ofNullable(webClientsByCell.get(cell));
}
private Map<Cell, WebClient> buildWebClients(CellInfoResolver cellInfoResolver,
WebClientFactory cellWebClientFactory) {
Set<Cell> resolvedCells = new HashSet<>(cellInfoResolver.resolve());
Map<Cell, WebClient> webClientMap = new HashMap<>();
resolvedCells.forEach(cell -> webClientMap.put(cell, cellWebClientFactory.apply(cell)));
return Collections.unmodifiableMap(webClientMap);
}
}
| 9,878 |
0 | Create_ds/titus-control-plane/titus-server-federation/src/main/java/com/netflix/titus/federation | Create_ds/titus-control-plane/titus-server-federation/src/main/java/com/netflix/titus/federation/service/SimpleWebClientFactory.java | /*
* Copyright 2019 Netflix, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.netflix.titus.federation.service;
import com.netflix.titus.api.federation.model.Cell;
import org.springframework.web.reactive.function.client.WebClient;
public class SimpleWebClientFactory implements WebClientFactory {
private static final WebClientFactory INSTANCE = new SimpleWebClientFactory();
private SimpleWebClientFactory() {
}
@Override
public WebClient apply(Cell cell) {
return WebClient.builder().baseUrl("http://" + cell.getAddress()).build();
}
public static WebClientFactory getInstance() {
return INSTANCE;
}
}
| 9,879 |
0 | Create_ds/titus-control-plane/titus-server-federation/src/main/java/com/netflix/titus/federation | Create_ds/titus-control-plane/titus-server-federation/src/main/java/com/netflix/titus/federation/service/CellWebClientConnectorUtil.java | /*
* Copyright 2019 Netflix, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.netflix.titus.federation.service;
import java.time.Duration;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.stream.Collectors;
import javax.ws.rs.WebApplicationException;
import javax.ws.rs.core.Response;
import com.netflix.titus.common.util.CollectionsExt;
import com.netflix.titus.common.util.tuple.Either;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.core.ParameterizedTypeReference;
import org.springframework.http.HttpStatus;
import org.springframework.web.reactive.function.client.WebClientResponseException;
import reactor.core.publisher.Flux;
import reactor.core.publisher.Mono;
public class CellWebClientConnectorUtil {
private static final Logger logger = LoggerFactory.getLogger(CellWebClientConnectorUtil.class);
/**
* Run GET operation on all cells and merge the result.
*/
public static <T> Either<List<T>, WebApplicationException> doGetAndMerge(CellWebClientConnector cellWebClientConnector,
String path,
ParameterizedTypeReference<List<T>> type,
long timeoutMs) {
Either<List<List<T>>, Throwable> partials;
try {
partials = Flux
.merge(
cellWebClientConnector.getWebClients().values().stream()
.map(c ->
c.get().uri(path)
.retrieve()
.bodyToMono(type)
)
.collect(Collectors.toList())
)
.collectList()
.<Either<List<List<T>>, Throwable>>map(Either::ofValue)
.onErrorResume(e -> Mono.just(Either.ofError(e)))
.block(Duration.ofMillis(timeoutMs));
} catch (Exception e) {
logger.error("Unexpected error: path={}, type={}", path, type, e);
return Either.ofError(new WebApplicationException(e, Response.Status.INTERNAL_SERVER_ERROR));
}
if (partials == null) {
logger.error("No result from any cell: path={}, type={}", path, type);
return Either.ofError(new WebApplicationException(Response.Status.INTERNAL_SERVER_ERROR));
}
if (partials.hasError()) {
return Either.ofError(new WebApplicationException(partials.getError(), Response.Status.INTERNAL_SERVER_ERROR));
}
if (CollectionsExt.isNullOrEmpty(partials.getValue())) {
return Either.ofValue(Collections.emptyList());
}
List<T> result = new ArrayList<>();
partials.getValue().forEach(result::addAll);
return Either.ofValue(result);
}
/**
* Run GET operation on all cells, but only one is expected to return a result.
*/
public static <T> Either<T, WebApplicationException> doGetFromCell(CellWebClientConnector cellWebClientConnector,
String path,
ParameterizedTypeReference<T> type,
long timeoutMs) {
List<Either<T, Throwable>> partials;
try {
partials = Flux.merge(
cellWebClientConnector.getWebClients().values().stream()
.map(cell ->
cell.get().uri(path)
.retrieve()
.bodyToMono(type)
.map(Either::<T, Throwable>ofValue)
.onErrorResume(e -> Mono.just(Either.ofError(e)))
)
.collect(Collectors.toList())
).collectList().block(Duration.ofMillis(timeoutMs));
} catch (Exception e) {
logger.error("Unexpected error: path={}, type={}", path, type, e);
return Either.ofError(new WebApplicationException(e, Response.Status.INTERNAL_SERVER_ERROR));
}
if (CollectionsExt.isNullOrEmpty(partials)) {
logger.error("No result from any cell: path={}, type={}", path, type);
throw new WebApplicationException(Response.Status.NOT_FOUND);
}
Throwable systemError = null;
for (Either<T, Throwable> partial : partials) {
if (partial.hasValue()) {
return Either.ofValue(partial.getValue());
}
if (partial.getError() instanceof WebClientResponseException) {
WebClientResponseException wcError = (WebClientResponseException) partial.getError();
if (!wcError.getStatusCode().equals(HttpStatus.NOT_FOUND)) {
systemError = partial.getError();
}
} else {
systemError = partial.getError();
}
}
// If there is a system error, report it. Otherwise all cells returned NOT_FOUND, and we can send it back to
// the client.
return Either.ofError(systemError != null
? new WebApplicationException(systemError)
: new WebApplicationException(Response.Status.NOT_FOUND)
);
}
}
| 9,880 |
0 | Create_ds/titus-control-plane/titus-server-federation/src/main/java/com/netflix/titus/federation | Create_ds/titus-control-plane/titus-server-federation/src/main/java/com/netflix/titus/federation/service/CellInfoUtil.java | /*
* Copyright 2018 Netflix, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.netflix.titus.federation.service;
import java.util.Arrays;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;
import com.netflix.titus.api.federation.model.Cell;
import com.netflix.titus.common.util.CollectionsExt;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public class CellInfoUtil {
private static final Logger logger = LoggerFactory.getLogger(CellInfoUtil.class);
private static final String CELL_HOST_DELIM = ";";
private static final String CELL_HOST_RULE_DELIM = "=";
private static final String CELL_ROUTE_DELIM = ";";
private static final String CELL_ROUTE_RULE_DELIM = "=";
/**
* Extracts cells from a cell specification that takes the following form
* <tt>cell1=hostName1:7001;cell2=hostName2:7002</tt>
*
* <tt>cellSpecification</tt> must contain one entry for each cell. Only the first configuration for each cell name
* is kept.
*
* @return {@link Cell cells} indexed by their name
*/
public static List<Cell> extractCellsFromCellSpecification(String cellsSpecification) {
return Arrays.stream(cellsSpecification.split(CELL_HOST_DELIM))
.filter(cellSpec -> cellSpec.contains(CELL_HOST_RULE_DELIM))
.map(cellSpec -> cellSpec.split(CELL_HOST_RULE_DELIM))
.map(parts -> new Cell(parts[0], parts[1]))
.collect(Collectors.toList());
}
/**
* Extract cell routing configurations that take the following form <tt>cell1=someRuleString;cell2=someOtherRuleString</tt>.
* <p>
* Iteration on the returned {@link Map} will respect the order entries appear in the <tt>cellRoutingSpecification</tt>
* argument.
*/
public static Map<Cell, String> extractCellRoutingFromCellSpecification(List<Cell> cells, String cellRoutingSpecification) {
Map<String, Cell> cellsByName = CollectionsExt.indexBy(cells, Cell::getName);
return Arrays.stream(cellRoutingSpecification.split(CELL_ROUTE_DELIM))
.filter(cellRoutingSpec -> cellRoutingSpec.contains(CELL_ROUTE_RULE_DELIM))
.map(CellRoutingSpec::new)
.filter(spec -> isCellConfigured(cellsByName, spec))
.collect(Collectors.toMap(
spec -> cellsByName.get(spec.getCellName()),
CellRoutingSpec::getRoutingRule,
CellInfoUtil::mergeKeepingFirst,
LinkedHashMap::new
));
}
private static boolean isCellConfigured(Map<String, Cell> cellsByName, CellRoutingSpec spec) {
boolean isCellConfigured = cellsByName.containsKey(spec.getCellName());
if (!isCellConfigured) {
logger.error("Found a rule {} for cell {} that is not configured, ignoring it", spec.getRoutingRule(),
spec.getCellName());
}
return isCellConfigured;
}
private static <V> V mergeKeepingFirst(V v1, V v2) {
logger.warn("Duplicate values found, the second will be ignored: {} and {}", v1, v2);
return v1;
}
private static final class CellRoutingSpec {
private final String cellName;
private final String routingRule;
private CellRoutingSpec(String cellRoutingSpec) {
String[] parts = cellRoutingSpec.split(CELL_ROUTE_RULE_DELIM);
this.cellName = parts[0];
this.routingRule = parts[1];
}
private CellRoutingSpec(String cellName, String routingRule) {
this.cellName = cellName;
this.routingRule = routingRule;
}
private String getCellName() {
return cellName;
}
private String getRoutingRule() {
return routingRule;
}
}
}
| 9,881 |
0 | Create_ds/titus-control-plane/titus-server-federation/src/main/java/com/netflix/titus/federation | Create_ds/titus-control-plane/titus-server-federation/src/main/java/com/netflix/titus/federation/service/VpcServiceConnector.java | package com.netflix.titus.federation.service;
import io.grpc.ManagedChannel;
public interface VpcServiceConnector {
ManagedChannel getChannel();
}
| 9,882 |
0 | Create_ds/titus-control-plane/titus-server-federation/src/main/java/com/netflix/titus/federation | Create_ds/titus-control-plane/titus-server-federation/src/main/java/com/netflix/titus/federation/service/AggregatingSchedulerService.java | /*
* Copyright 2019 Netflix, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.netflix.titus.federation.service;
import com.netflix.titus.grpc.protogen.SchedulingResultEvent;
import reactor.core.publisher.Mono;
/**
* Supports subset of operations provided by {@link com.netflix.titus.grpc.protogen.SchedulerServiceGrpc}, applicable
* at the federation level.
*/
public interface AggregatingSchedulerService {
/**
* Returns the last known scheduling result for a task.
*
* @return {@link Mono#empty()} if the task is not found or the scheduling result otherwise
*/
Mono<SchedulingResultEvent> findLastSchedulingResult(String taskId);
}
| 9,883 |
0 | Create_ds/titus-control-plane/titus-server-federation/src/main/java/com/netflix/titus/federation | Create_ds/titus-control-plane/titus-server-federation/src/main/java/com/netflix/titus/federation/service/DefaultRemoteFederationConnector.java | package com.netflix.titus.federation.service;
import java.util.concurrent.TimeUnit;
import javax.annotation.PreDestroy;
import javax.inject.Inject;
import io.grpc.ManagedChannel;
import io.grpc.netty.shaded.io.grpc.netty.NettyChannelBuilder;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public class DefaultRemoteFederationConnector implements RemoteFederationConnector {
private static final Logger logger = LoggerFactory.getLogger(DefaultRemoteFederationConnector.class);
private static final long SHUTDOWN_TIMEOUT_MS = 5_000;
private final ManagedChannel channel;
@Inject
public DefaultRemoteFederationConnector(RemoteFederationInfoResolver remoteFederationInfoResolver) {
channel = NettyChannelBuilder.forTarget(remoteFederationInfoResolver.resolve().getAddress())
.usePlaintext()
.defaultLoadBalancingPolicy("round_robin")
.build();
}
@Override
public ManagedChannel getChannel() {
return channel;
}
@PreDestroy
public void shutdown() {
logger.info("shutting down gRPC channels");
try {
channel.awaitTermination(SHUTDOWN_TIMEOUT_MS, TimeUnit.MILLISECONDS);
} catch (InterruptedException e) {
if (!channel.isTerminated()) {
channel.shutdownNow();
}
}
}
}
| 9,884 |
0 | Create_ds/titus-control-plane/titus-server-federation/src/main/java/com/netflix/titus/federation | Create_ds/titus-control-plane/titus-server-federation/src/main/java/com/netflix/titus/federation/service/FilterOutFirstMarker.java | /*
* Copyright 2018 Netflix, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.netflix.titus.federation.service;
import java.util.concurrent.CountDownLatch;
import com.google.protobuf.Empty;
import com.netflix.titus.runtime.endpoint.common.grpc.GrpcUtil;
import com.netflix.titus.grpc.protogen.JobChangeNotification;
import com.netflix.titus.grpc.protogen.JobChangeNotification.NotificationCase;
import io.grpc.stub.ClientCallStreamObserver;
import io.grpc.stub.ClientResponseObserver;
import rx.Emitter;
/**
* Filter out the first <tt>marker</tt> from a source stream, decrementing a {@link CountDownLatch} when it is received.
*/
class FilterOutFirstMarker implements ClientResponseObserver<Empty, JobChangeNotification> {
private final Emitter<JobChangeNotification> emitter;
private final CountDownLatch latch;
private volatile boolean markerReceived = false;
FilterOutFirstMarker(Emitter<JobChangeNotification> destination, CountDownLatch markersReceived) {
this.emitter = destination;
this.latch = markersReceived;
}
@Override
public void beforeStart(ClientCallStreamObserver<Empty> requestStream) {
GrpcUtil.attachCancellingCallback(emitter, requestStream);
}
@Override
public void onNext(JobChangeNotification value) {
if (!markerReceived && value.getNotificationCase() == NotificationCase.SNAPSHOTEND) {
markerReceived = true;
latch.countDown();
return;
}
emitter.onNext(value);
}
@Override
public void onError(Throwable t) {
emitter.onError(t);
}
@Override
public void onCompleted() {
emitter.onCompleted();
}
}
| 9,885 |
0 | Create_ds/titus-control-plane/titus-server-federation/src/main/java/com/netflix/titus/federation | Create_ds/titus-control-plane/titus-server-federation/src/main/java/com/netflix/titus/federation/service/NoopJobActivityHistoryService.java | package com.netflix.titus.federation.service;
import com.netflix.titus.api.model.callmetadata.CallMetadata;
import com.netflix.titus.grpc.protogen.ActivityQueryResult;
import com.netflix.titus.grpc.protogen.JobId;
import com.netflix.titus.runtime.service.JobActivityHistoryService;
import rx.Observable;
import javax.inject.Inject;
import javax.inject.Singleton;
@Singleton
public class NoopJobActivityHistoryService implements JobActivityHistoryService {
@Inject
public NoopJobActivityHistoryService() {
}
@Override
public Observable<ActivityQueryResult> viewScalingActivities(JobId jobId, CallMetadata callMetadata) {
return null;
}
} | 9,886 |
0 | Create_ds/titus-control-plane/titus-server-federation/src/main/java/com/netflix/titus/federation | Create_ds/titus-control-plane/titus-server-federation/src/main/java/com/netflix/titus/federation/service/AggregatingHealthService.java | /*
* Copyright 2018 Netflix, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.netflix.titus.federation.service;
import java.util.function.BiConsumer;
import javax.inject.Inject;
import javax.inject.Singleton;
import com.netflix.titus.federation.startup.GrpcConfiguration;
import com.netflix.titus.grpc.protogen.HealthCheckRequest;
import com.netflix.titus.grpc.protogen.HealthCheckResponse;
import com.netflix.titus.grpc.protogen.HealthCheckResponse.ServingStatus;
import com.netflix.titus.grpc.protogen.HealthCheckResponse.Unknown;
import com.netflix.titus.grpc.protogen.HealthGrpc;
import com.netflix.titus.runtime.endpoint.common.grpc.GrpcUtil;
import com.netflix.titus.runtime.endpoint.metadata.CallMetadataResolver;
import com.netflix.titus.runtime.service.HealthService;
import io.grpc.Status;
import io.grpc.stub.AbstractStub;
import io.grpc.stub.StreamObserver;
import rx.Observable;
import static com.netflix.titus.grpc.protogen.HealthCheckResponse.ServingStatus.NOT_SERVING;
import static com.netflix.titus.grpc.protogen.HealthCheckResponse.ServingStatus.SERVING;
import static com.netflix.titus.grpc.protogen.HealthCheckResponse.ServingStatus.UNKNOWN;
import static com.netflix.titus.runtime.endpoint.common.grpc.GrpcUtil.createWrappedStub;
@Singleton
public class AggregatingHealthService implements HealthService {
private final AggregatingCellClient client;
private final CallMetadataResolver callMetadataResolver;
private final GrpcConfiguration grpcConfiguration;
@Inject
public AggregatingHealthService(AggregatingCellClient client, CallMetadataResolver callMetadataResolver, GrpcConfiguration grpcConfiguration) {
this.client = client;
this.callMetadataResolver = callMetadataResolver;
this.grpcConfiguration = grpcConfiguration;
}
private ClientCall<HealthCheckResponse> check() {
return (client, responseObserver) -> wrap(client).check(HealthCheckRequest.newBuilder().build(), responseObserver);
}
@Override
public Observable<HealthCheckResponse> check(HealthCheckRequest request) {
return client.callExpectingErrors(HealthGrpc::newStub, check())
.map(resp -> resp.getResult().onErrorGet(e -> newErrorResponse(resp.getCell().getName(), e)))
.reduce((one, other) -> HealthCheckResponse.newBuilder()
.setStatus(merge(one.getStatus(), other.getStatus()))
.addAllDetails(one.getDetailsList())
.addAllDetails(other.getDetailsList())
.build())
.defaultIfEmpty(HealthCheckResponse.newBuilder()
.setStatus(UNKNOWN)
.build());
}
private static ServingStatus merge(ServingStatus oneStatus, ServingStatus otherStatus) {
if (oneStatus.equals(SERVING)) {
return otherStatus;
}
return oneStatus;
}
private static HealthCheckResponse newErrorResponse(String cellName, Throwable e) {
return HealthCheckResponse.newBuilder()
.setStatus(NOT_SERVING)
.addDetails(HealthCheckResponse.ServerStatus.newBuilder()
.setError(Unknown.newBuilder()
.setCell(cellName)
.setErrorCode(statusCodeFromThrowable(e))
.setMessage(e.getMessage())
.build())
.build())
.build();
}
private static String statusCodeFromThrowable(Throwable e) {
Status status = Status.fromThrowable(e);
if (status.getCode().equals(Status.Code.UNKNOWN)) {
return e.getClass().getSimpleName();
}
return status.getCode().toString();
}
private <STUB extends AbstractStub<STUB>> STUB wrap(STUB stub) {
return GrpcUtil.createWrappedStubWithResolver(stub, callMetadataResolver, grpcConfiguration.getRequestTimeoutMs());
}
private interface ClientCall<T> extends BiConsumer<HealthGrpc.HealthStub, StreamObserver<T>> {
// generics sanity
}
}
| 9,887 |
0 | Create_ds/titus-control-plane/titus-server-federation/src/main/java/com/netflix/titus/federation | Create_ds/titus-control-plane/titus-server-federation/src/main/java/com/netflix/titus/federation/service/RemoteJobServiceGateway.java | package com.netflix.titus.federation.service;
import com.google.protobuf.Empty;
import com.netflix.titus.api.federation.model.Cell;
import com.netflix.titus.api.model.callmetadata.CallMetadata;
import com.netflix.titus.common.util.CollectionsExt;
import com.netflix.titus.common.util.rx.ReactorExt;
import com.netflix.titus.federation.service.router.CellRouter;
import com.netflix.titus.federation.startup.GrpcConfiguration;
import com.netflix.titus.federation.startup.TitusFederationConfiguration;
import com.netflix.titus.grpc.protogen.Job;
import com.netflix.titus.grpc.protogen.JobAttributesDeleteRequest;
import com.netflix.titus.grpc.protogen.JobAttributesUpdate;
import com.netflix.titus.grpc.protogen.JobCapacityUpdate;
import com.netflix.titus.grpc.protogen.JobCapacityUpdateWithOptionalAttributes;
import com.netflix.titus.grpc.protogen.JobChangeNotification;
import com.netflix.titus.grpc.protogen.JobDescriptor;
import com.netflix.titus.grpc.protogen.JobDisruptionBudgetUpdate;
import com.netflix.titus.grpc.protogen.JobId;
import com.netflix.titus.grpc.protogen.JobManagementServiceGrpc;
import com.netflix.titus.grpc.protogen.JobManagementServiceGrpc.JobManagementServiceStub;
import com.netflix.titus.grpc.protogen.JobProcessesUpdate;
import com.netflix.titus.grpc.protogen.JobQuery;
import com.netflix.titus.grpc.protogen.JobQueryResult;
import com.netflix.titus.grpc.protogen.JobStatusUpdate;
import com.netflix.titus.grpc.protogen.ObserveJobsQuery;
import com.netflix.titus.grpc.protogen.Task;
import com.netflix.titus.grpc.protogen.TaskAttributesDeleteRequest;
import com.netflix.titus.grpc.protogen.TaskAttributesUpdate;
import com.netflix.titus.grpc.protogen.TaskId;
import com.netflix.titus.grpc.protogen.TaskKillRequest;
import com.netflix.titus.grpc.protogen.TaskMoveRequest;
import com.netflix.titus.grpc.protogen.TaskQuery;
import com.netflix.titus.grpc.protogen.TaskQueryResult;
import com.netflix.titus.runtime.endpoint.common.grpc.GrpcUtil;
import com.netflix.titus.runtime.jobmanager.gateway.JobServiceGateway;
import io.grpc.stub.AbstractStub;
import io.grpc.stub.StreamObserver;
import reactor.core.publisher.Mono;
import rx.Completable;
import rx.Observable;
import javax.inject.Inject;
import javax.inject.Singleton;
import java.util.UUID;
import java.util.function.BiConsumer;
import static com.netflix.titus.api.jobmanager.JobAttributes.*;
import static com.netflix.titus.runtime.endpoint.common.grpc.GrpcUtil.createRequestObservable;
import static com.netflix.titus.runtime.endpoint.common.grpc.GrpcUtil.createWrappedStub;
@Singleton
public class RemoteJobServiceGateway implements JobServiceGateway {
private final JobManagementServiceStub remoteClient;
private final GrpcConfiguration grpcConfiguration;
private final TitusFederationConfiguration federationConfiguration;
private final CellRouter cellRouter;
private static final Cell unknownCell = new Cell("UNKNOWN", "UNKNOWN");
@Inject
public RemoteJobServiceGateway(
TitusFederationConfiguration federationConfiguration,
RemoteFederationConnector fedConnector,
CellRouter cellRouter,
GrpcConfiguration grpcConfiguration) {
this.federationConfiguration = federationConfiguration;
this.remoteClient = JobManagementServiceGrpc.newStub(fedConnector.getChannel());
this.cellRouter = cellRouter;
this.grpcConfiguration = grpcConfiguration;
}
@Override
public Observable<String> createJob(JobDescriptor jobDescriptor, CallMetadata callMetadata) {
// We want to know where the job would have been routed so remote federation can compare it to its own routing
// decision.
Cell cell = cellRouter.routeKey(jobDescriptor).orElse(unknownCell);
String federatedJobId = UUID.randomUUID().toString();
JobDescriptor jd = addAttributes(
jobDescriptor.toBuilder(),
federatedJobId,
cell.getName()).build();
return createRequestObservable(emitter -> {
StreamObserver<JobId> streamObserver = GrpcUtil.createClientResponseObserver(
emitter,
jobId -> emitter.onNext(jobId.getId()),
emitter::onError,
emitter::onCompleted
);
wrap(remoteClient, callMetadata, grpcConfiguration.getRequestTimeoutMs()).createJob(jd, streamObserver);
}, grpcConfiguration.getRequestTimeoutMs());
}
@Override
public Completable updateJobCapacity(JobCapacityUpdate jobCapacityUpdate, CallMetadata callMetadata) {
return remoteCall(
(JobManagementServiceStub client, StreamObserver<Empty> streamObserver) ->
client.updateJobCapacity(jobCapacityUpdate, streamObserver), callMetadata)
.toCompletable();
}
@Override
public Completable updateJobCapacityWithOptionalAttributes(JobCapacityUpdateWithOptionalAttributes jobCapacityUpdateWithOptionalAttributes, CallMetadata callMetadata) {
return remoteCall(
(JobManagementServiceStub client, StreamObserver<Empty> streamObserver) ->
client.updateJobCapacityWithOptionalAttributes(jobCapacityUpdateWithOptionalAttributes, streamObserver), callMetadata)
.toCompletable();
}
@Override
public Completable updateJobProcesses(JobProcessesUpdate jobProcessesUpdate, CallMetadata callMetadata) {
return remoteCall(
(JobManagementServiceStub client, StreamObserver<Empty> streamObserver) ->
client.updateJobProcesses(jobProcessesUpdate, streamObserver), callMetadata)
.toCompletable();
}
@Override
public Completable updateJobStatus(JobStatusUpdate statusUpdate, CallMetadata callMetadata) {
return remoteCall(
(JobManagementServiceStub client, StreamObserver<Empty> streamObserver) ->
client.updateJobStatus(statusUpdate, streamObserver), callMetadata)
.toCompletable();
}
@Override
public Mono<Void> updateJobDisruptionBudget(JobDisruptionBudgetUpdate request, CallMetadata callMetadata) {
return remoteCallReact(
(JobManagementServiceStub client, StreamObserver<Empty> streamObserver) ->
client.updateJobDisruptionBudget(request, streamObserver), callMetadata)
.ignoreElement().cast(Void.class);
}
@Override
public Mono<Void> updateJobAttributes(JobAttributesUpdate request, CallMetadata callMetadata) {
return remoteCallReact(
(JobManagementServiceStub client, StreamObserver<Empty> streamObserver) ->
client.updateJobAttributes(request, streamObserver), callMetadata)
.ignoreElement().cast(Void.class);
}
@Override
public Mono<Void> deleteJobAttributes(JobAttributesDeleteRequest request, CallMetadata callMetadata) {
return remoteCallReact(
(JobManagementServiceStub client, StreamObserver<Empty> streamObserver) ->
client.deleteJobAttributes(request, streamObserver), callMetadata)
.ignoreElement().cast(Void.class);
}
@Override
public Observable<Job> findJob(String jobId, CallMetadata callMetadata) {
return remoteCall(
(JobManagementServiceStub client, StreamObserver<Job> streamObserver) ->
client.findJob(JobId.newBuilder().setId(jobId).build(), streamObserver), callMetadata);
}
@Override
public Observable<JobQueryResult> findJobs(JobQuery jobQuery, CallMetadata callMetadata) {
return remoteCall(
(JobManagementServiceStub client, StreamObserver<JobQueryResult> streamObserver) ->
client.findJobs(jobQuery, streamObserver), callMetadata);
}
@Override
public Observable<JobChangeNotification> observeJob(String jobId, CallMetadata callMetadata) {
return remoteCallWithNoDeadline(
(JobManagementServiceStub client, StreamObserver<JobChangeNotification> streamObserver) ->
client.observeJob(JobId.newBuilder().setId(jobId).build(), streamObserver), callMetadata);
}
@Override
public Observable<JobChangeNotification> observeJobs(ObserveJobsQuery query, CallMetadata callMetadata) {
return remoteCallWithNoDeadline(
(JobManagementServiceStub client, StreamObserver<JobChangeNotification> streamObserver) ->
client.observeJobs(query, streamObserver), callMetadata);
}
@Override
public Completable killJob(String jobId, CallMetadata callMetadata) {
return remoteCall(
(JobManagementServiceStub client, StreamObserver<Empty> streamObserver) ->
client.killJob(JobId.newBuilder().setId(jobId).build(), streamObserver), callMetadata)
.toCompletable();
}
@Override
public Observable<Task> findTask(String taskId, CallMetadata callMetadata) {
return remoteCall(
(JobManagementServiceStub client, StreamObserver<Task> streamObserver) ->
client.findTask(TaskId.newBuilder().setId(taskId).build(), streamObserver), callMetadata);
}
@Override
public Observable<TaskQueryResult> findTasks(TaskQuery taskQuery, CallMetadata callMetadata) {
return remoteCall(
(JobManagementServiceStub client, StreamObserver<TaskQueryResult> streamObserver) ->
client.findTasks(taskQuery, streamObserver), callMetadata);
}
@Override
public Completable killTask(TaskKillRequest taskKillRequest, CallMetadata callMetadata) {
return remoteCall(
(JobManagementServiceStub client, StreamObserver<Empty> streamObserver) ->
client.killTask(taskKillRequest, streamObserver), callMetadata)
.toCompletable();
}
@Override
public Completable updateTaskAttributes(TaskAttributesUpdate request, CallMetadata callMetadata) {
return remoteCall(
(JobManagementServiceStub client, StreamObserver<Empty> streamObserver) ->
client.updateTaskAttributes(request, streamObserver), callMetadata)
.toCompletable();
}
@Override
public Completable deleteTaskAttributes(TaskAttributesDeleteRequest request, CallMetadata callMetadata) {
return remoteCall(
(JobManagementServiceStub client, StreamObserver<Empty> streamObserver) ->
client.deleteTaskAttributes(request, streamObserver), callMetadata)
.toCompletable();
}
@Override
public Completable moveTask(TaskMoveRequest taskMoveRequest, CallMetadata callMetadata) {
return remoteCall(
(JobManagementServiceStub client, StreamObserver<Empty> streamObserver) ->
client.moveTask(taskMoveRequest, streamObserver), callMetadata)
.toCompletable();
}
private JobManagementServiceStub wrap(JobManagementServiceStub client, CallMetadata callMetadata, long timeoutMs) {
return createWrappedStub(client, callMetadata, timeoutMs);
}
private JobManagementServiceStub wrapWithNoDeadline(JobManagementServiceStub client, CallMetadata callMetadata) {
return createWrappedStub(client, callMetadata);
}
private interface ClientCall<T> extends BiConsumer<JobManagementServiceStub, StreamObserver<T>> {
// generics sanity
}
private static <STUB extends AbstractStub<STUB>, RespT> Observable<RespT> callToRemote(
STUB client,
BiConsumer<STUB, StreamObserver<RespT>> fnCall) {
return GrpcUtil.createRequestObservable(emitter -> {
StreamObserver<RespT> streamObserver = GrpcUtil.createSimpleClientResponseObserver(emitter);
fnCall.accept(client, streamObserver);
});
}
private <T> Observable<T> remoteCall(ClientCall<T> clientCall, CallMetadata callMetadata) {
return callToRemote(
remoteClient,
(client, streamObserver) -> clientCall.accept(
wrap(remoteClient, callMetadata, this.grpcConfiguration.getRequestTimeoutMs()),
streamObserver));
}
private <T> Observable<T> remoteCallWithNoDeadline(ClientCall<T> clientCall, CallMetadata callMetadata) {
return callToRemote(
remoteClient,
(client, streamObserver) -> clientCall.accept(
wrapWithNoDeadline(remoteClient, callMetadata),
streamObserver));
}
private <T> Mono<T> remoteCallReact(ClientCall<T> clientCall, CallMetadata callMetadata) {
return ReactorExt.toMono(remoteCall(clientCall, callMetadata).toSingle());
}
private JobDescriptor.Builder addAttributes(JobDescriptor.Builder jobDescriptorBuilder, String federatedJobId, String routingCell) {
return jobDescriptorBuilder.putAllAttributes(CollectionsExt.<String, String>newHashMap()
.entry(JOB_ATTRIBUTES_STACK, federationConfiguration.getStack())
.entry(JOB_ATTRIBUTES_FEDERATED_JOB_ID, federatedJobId)
.entry(JOB_ATTRIBUTE_ROUTING_CELL, routingCell)
.toMap());
}
}
| 9,888 |
0 | Create_ds/titus-control-plane/titus-server-federation/src/main/java/com/netflix/titus/federation | Create_ds/titus-control-plane/titus-server-federation/src/main/java/com/netflix/titus/federation/service/RemoteFederationInfoResolver.java | package com.netflix.titus.federation.service;
import com.netflix.titus.api.federation.model.RemoteFederation;
public interface RemoteFederationInfoResolver {
RemoteFederation resolve();
}
| 9,889 |
0 | Create_ds/titus-control-plane/titus-server-federation/src/main/java/com/netflix/titus/federation | Create_ds/titus-control-plane/titus-server-federation/src/main/java/com/netflix/titus/federation/service/RemoteFederationConnector.java | package com.netflix.titus.federation.service;
import io.grpc.ManagedChannel;
public interface RemoteFederationConnector {
ManagedChannel getChannel();
}
| 9,890 |
0 | Create_ds/titus-control-plane/titus-server-federation/src/main/java/com/netflix/titus/federation | Create_ds/titus-control-plane/titus-server-federation/src/main/java/com/netflix/titus/federation/service/DefaultCellConnector.java | /*
* Copyright 2018 Netflix, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.netflix.titus.federation.service;
import java.util.Collections;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.concurrent.TimeUnit;
import java.util.stream.Collectors;
import javax.annotation.PreDestroy;
import javax.inject.Inject;
import javax.inject.Singleton;
import com.netflix.titus.api.federation.model.Cell;
import io.grpc.ManagedChannel;
import io.grpc.netty.shaded.io.grpc.netty.NettyChannelBuilder;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
@Singleton
public class DefaultCellConnector implements CellConnector {
private static Logger logger = LoggerFactory.getLogger(DefaultCellConnector.class);
private static final long SHUTDOWN_TIMEOUT_MS = 5_000;
private final Map<Cell, ManagedChannel> channels;
@Inject
public DefaultCellConnector(CellInfoResolver cellInfoResolver) {
List<Cell> cells = cellInfoResolver.resolve();
if (cells != null && !cells.isEmpty()) {
channels = cells.stream()
.collect(Collectors.toMap(
cell -> cell,
cell -> NettyChannelBuilder.forTarget(cell.getAddress())
.usePlaintext()
.defaultLoadBalancingPolicy("round_robin")
.build()
));
} else {
channels = Collections.emptyMap();
}
}
@Override
public Map<Cell, ManagedChannel> getChannels() {
return channels;
}
@Override
public Optional<ManagedChannel> getChannelForCell(Cell cell) {
return Optional.ofNullable(channels.get(cell));
}
@PreDestroy
public void shutdown() {
channels.values()
.forEach(channel -> {
logger.info("shutting down gRPC channels");
channel.shutdown();
try {
channel.awaitTermination(SHUTDOWN_TIMEOUT_MS, TimeUnit.MILLISECONDS);
} catch (InterruptedException e) {
if (!channel.isTerminated()) {
channel.shutdownNow();
}
}
});
}
}
| 9,891 |
0 | Create_ds/titus-control-plane/titus-server-federation/src/main/java/com/netflix/titus/federation | Create_ds/titus-control-plane/titus-server-federation/src/main/java/com/netflix/titus/federation/service/JobActivityServiceComponent.java | package com.netflix.titus.federation.service;
import com.google.inject.Provides;
import com.netflix.titus.common.runtime.TitusRuntime;
import com.netflix.titus.grpc.protogen.JobActivityHistoryServiceGrpc;
import com.netflix.titus.grpc.protogen.JobActivityHistoryServiceGrpc.JobActivityHistoryServiceStub;
import com.netflix.titus.runtime.connector.GrpcClientConfiguration;
import io.grpc.Channel;
import io.grpc.netty.shaded.io.grpc.netty.NettyChannelBuilder;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import javax.inject.Named;
import javax.inject.Singleton;
@Configuration
public class JobActivityServiceComponent {
public static final String JOB_ACTIVITY_HISTORY_CHANNEL = "JobActivityHistoryChannel";
@Bean
@Singleton
@Named(JOB_ACTIVITY_HISTORY_CHANNEL)
Channel jobActivityHistoryChannel(GrpcClientConfiguration configuration, TitusRuntime titusRuntime) {
return NettyChannelBuilder.forTarget(configuration.getHostname()).build();
}
@Bean
@Provides
@Singleton
JobActivityHistoryServiceStub jobActivityHistoryClient(final @Named(JOB_ACTIVITY_HISTORY_CHANNEL) Channel channel) {
return JobActivityHistoryServiceGrpc.newStub(channel);
}
}
| 9,892 |
0 | Create_ds/titus-control-plane/titus-server-federation/src/main/java/com/netflix/titus/federation | Create_ds/titus-control-plane/titus-server-federation/src/main/java/com/netflix/titus/federation/service/AggregatingCellClient.java | /*
* Copyright 2018 Netflix, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.netflix.titus.federation.service;
import java.util.List;
import java.util.Map;
import java.util.function.BiConsumer;
import java.util.function.Function;
import java.util.stream.Collectors;
import javax.inject.Inject;
import javax.inject.Singleton;
import com.netflix.titus.api.federation.model.Cell;
import com.netflix.titus.common.util.tuple.Either;
import io.grpc.ManagedChannel;
import io.grpc.stub.AbstractStub;
import io.grpc.stub.StreamObserver;
import rx.Observable;
import static com.netflix.titus.runtime.endpoint.common.grpc.GrpcUtil.createRequestObservable;
import static com.netflix.titus.runtime.endpoint.common.grpc.GrpcUtil.createSimpleClientResponseObserver;
import static com.netflix.titus.federation.service.CellConnectorUtil.stubs;
@Singleton
class AggregatingCellClient {
private final CellConnector connector;
@Inject
public AggregatingCellClient(CellConnector connector) {
this.connector = connector;
}
/**
* Call services on all Cells and collect results. Results from each {@link Cell} are emitted individually on the
* returned {@link Observable}. The first error encountered will be propagated (if any).
*/
<STUB extends AbstractStub<STUB>, RespT> Observable<CellResponse<STUB, RespT>> call(
Function<ManagedChannel, STUB> stubFactory,
BiConsumer<STUB, StreamObserver<RespT>> fnCall) {
Map<Cell, STUB> clients = stubs(connector, stubFactory);
List<Observable<CellResponse<STUB, RespT>>> results = clients.entrySet().stream().map(entry -> {
Cell cell = entry.getKey();
STUB client = entry.getValue();
Observable<RespT> request = createRequestObservable(emitter -> {
StreamObserver<RespT> streamObserver = createSimpleClientResponseObserver(emitter);
fnCall.accept(client, streamObserver);
});
return request.map(result -> new CellResponse<>(cell, client, result));
}).collect(Collectors.toList());
return Observable.merge(results);
}
/**
* Call services on all Cells and collect results, which can be {@link Either Either<RespT, Throwable>}. Results
* from each {@link Cell} are emitted individually on the returned {@link Observable}.
*/
<STUB extends AbstractStub<STUB>, RespT>
Observable<CellResponse<STUB, Either<RespT, Throwable>>> callExpectingErrors(
Function<ManagedChannel, STUB> stubFactory,
BiConsumer<STUB, StreamObserver<RespT>> fnCall) {
Map<Cell, STUB> clients = stubs(connector, stubFactory);
List<Observable<CellResponse<STUB, Either<RespT, Throwable>>>> results = clients.entrySet().stream().map(entry -> {
Cell cell = entry.getKey();
STUB client = entry.getValue();
Observable<RespT> request = callSingleCell(client, fnCall);
return request.map(result ->
new CellResponse<>(cell, client, Either.<RespT, Throwable>ofValue(result))
).onErrorResumeNext(error -> Observable.just(
new CellResponse<>(cell, client, Either.ofError(error)))
);
}).collect(Collectors.toList());
return Observable.merge(results);
}
private <STUB extends AbstractStub<STUB>, RespT>
Observable<RespT> callSingleCell(STUB client, BiConsumer<STUB, StreamObserver<RespT>> fnCall) {
return createRequestObservable(emitter -> {
StreamObserver<RespT> streamObserver = createSimpleClientResponseObserver(emitter);
fnCall.accept(client, streamObserver);
});
}
}
| 9,893 |
0 | Create_ds/titus-control-plane/titus-server-federation/src/main/java/com/netflix/titus/federation | Create_ds/titus-control-plane/titus-server-federation/src/main/java/com/netflix/titus/federation/service/DefaultTitusAgentSecurityGroupClient.java | package com.netflix.titus.federation.service;
import com.netflix.titus.TitusAgentSecurityGroupServiceGrpc;
import com.netflix.titus.TitusAgentSecurityGroupServiceGrpc.TitusAgentSecurityGroupServiceStub;
import com.netflix.titus.TitusVpcApi;
import com.netflix.titus.api.model.callmetadata.CallMetadata;
import com.netflix.titus.federation.startup.GrpcConfiguration;
import com.netflix.titus.runtime.endpoint.v3.grpc.DefaultJobActivityHistoryServiceGrpc;
import com.netflix.titus.runtime.service.TitusAgentSecurityGroupClient;
import com.netflix.titus.TitusVpcApi.ResetSecurityGroupResponse;
import org.bouncycastle.asn1.its.IValue;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import reactor.core.publisher.Mono;
import io.grpc.stub.StreamObserver;
import javax.inject.Inject;
import static com.netflix.titus.runtime.endpoint.common.grpc.GrpcUtil.createWrappedStub;
public class DefaultTitusAgentSecurityGroupClient implements TitusAgentSecurityGroupClient {
private static final Logger logger = LoggerFactory.getLogger(DefaultTitusAgentSecurityGroupClient.class);
private final TitusAgentSecurityGroupServiceStub clientToVpcService;
private final GrpcConfiguration grpcConfiguration;
@Inject
public DefaultTitusAgentSecurityGroupClient(VpcServiceConnector connector,
GrpcConfiguration grpcConfiguration) {
this.clientToVpcService = TitusAgentSecurityGroupServiceGrpc.newStub(connector.getChannel());
this.grpcConfiguration = grpcConfiguration;
}
@Override
public Mono<ResetSecurityGroupResponse> resetSecurityGroup(
TitusVpcApi.ResetSecurityGroupRequest request, CallMetadata callMetadata) {
return Mono.create(sink -> {
TitusAgentSecurityGroupServiceStub clientStub = wrap(clientToVpcService,
callMetadata,
grpcConfiguration.getRequestTimeoutMs());
clientStub.resetSecurityGroup(request, new StreamObserver<ResetSecurityGroupResponse>() {
private ResetSecurityGroupResponse val;
@Override
public void onNext(ResetSecurityGroupResponse value) {
val = value;
}
@Override
public void onError(Throwable t) {
sink.error(t);
}
@Override
public void onCompleted() {
sink.success(val);
}
});
});
}
private TitusAgentSecurityGroupServiceStub wrap(TitusAgentSecurityGroupServiceStub client,
CallMetadata callMetadata, long timeoutMs) {
return createWrappedStub(client, callMetadata, timeoutMs);
}
}
| 9,894 |
0 | Create_ds/titus-control-plane/titus-server-federation/src/main/java/com/netflix/titus/federation | Create_ds/titus-control-plane/titus-server-federation/src/main/java/com/netflix/titus/federation/service/CellWebClientConnector.java | /*
* Copyright 2019 Netflix, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.netflix.titus.federation.service;
import java.util.Map;
import java.util.Optional;
import com.netflix.titus.api.federation.model.Cell;
import org.springframework.web.reactive.function.client.WebClient;
public interface CellWebClientConnector {
Map<Cell, WebClient> getWebClients();
Optional<WebClient> getWebClientForCell(Cell cell);
}
| 9,895 |
0 | Create_ds/titus-control-plane/titus-server-federation/src/main/java/com/netflix/titus/federation | Create_ds/titus-control-plane/titus-server-federation/src/main/java/com/netflix/titus/federation/service/ServiceModule.java | /*
* Copyright 2018 Netflix, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.netflix.titus.federation.service;
import com.google.inject.AbstractModule;
import com.netflix.titus.runtime.jobmanager.gateway.JobServiceGateway;
import com.netflix.titus.runtime.service.AutoScalingService;
import com.netflix.titus.runtime.service.HealthService;
import com.netflix.titus.runtime.service.JobActivityHistoryService;
import com.netflix.titus.runtime.service.LoadBalancerService;
import com.netflix.titus.runtime.service.TitusAgentSecurityGroupClient;
public class ServiceModule extends AbstractModule {
@Override
protected void configure() {
bind(HealthService.class).to(AggregatingHealthService.class);
bind(AggregatingSchedulerService.class).to(DefaultAggregatingSchedulerService.class);
bind(JobServiceGateway.class).to(FallbackJobServiceGateway.class);
bind(AutoScalingService.class).to(AggregatingAutoScalingService.class);
bind(LoadBalancerService.class).to(AggregatingLoadbalancerService.class);
bind(JobActivityHistoryService.class).to(NoopJobActivityHistoryService.class);
}
}
| 9,896 |
0 | Create_ds/titus-control-plane/titus-server-federation/src/main/java/com/netflix/titus/federation | Create_ds/titus-control-plane/titus-server-federation/src/main/java/com/netflix/titus/federation/service/DefaultVpcServiceConnector.java | package com.netflix.titus.federation.service;
import com.netflix.titus.federation.startup.TitusFederationConfiguration;
import io.grpc.ManagedChannel;
import io.grpc.netty.shaded.io.grpc.netty.NettyChannelBuilder;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import javax.inject.Inject;
public class DefaultVpcServiceConnector implements VpcServiceConnector {
private static final Logger logger = LoggerFactory.getLogger(DefaultRemoteFederationConnector.class);
private static final long SHUTDOWN_TIMEOUT_MS = 5_000;
private final TitusFederationConfiguration configuration;
private final ManagedChannel channel;
@Inject
public DefaultVpcServiceConnector(TitusFederationConfiguration configuration) {
this.configuration = configuration;
String []hostPort = configuration.getVpcService().split(":");
channel = NettyChannelBuilder
.forAddress(hostPort[0], Integer.parseInt(hostPort[1]))
.usePlaintext()
.defaultLoadBalancingPolicy("round_robin")
.build();
}
@Override
public ManagedChannel getChannel() {
return channel;
}
}
| 9,897 |
0 | Create_ds/titus-control-plane/titus-server-federation/src/main/java/com/netflix/titus/federation | Create_ds/titus-control-plane/titus-server-federation/src/main/java/com/netflix/titus/federation/service/DefaultCellInfoResolver.java | /*
* Copyright 2018 Netflix, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.netflix.titus.federation.service;
import java.util.List;
import javax.inject.Inject;
import javax.inject.Singleton;
import com.netflix.titus.api.federation.model.Cell;
import com.netflix.titus.federation.startup.TitusFederationConfiguration;
@Singleton
public class DefaultCellInfoResolver implements CellInfoResolver {
private final TitusFederationConfiguration configuration;
@Inject
public DefaultCellInfoResolver(TitusFederationConfiguration configuration) {
this.configuration = configuration;
}
/**
* @throws IllegalStateException when no cells are configured
*/
@Override
public List<Cell> resolve() {
String configuredCells = configuration.getCells();
List<Cell> cells = CellInfoUtil.extractCellsFromCellSpecification(configuredCells);
if (cells.isEmpty()) {
throw new IllegalStateException("No valid cells are configured: " + configuredCells);
}
return cells;
}
@Override
public Cell getDefault() {
return resolve().get(0);
}
}
| 9,898 |
0 | Create_ds/titus-control-plane/titus-server-federation/src/main/java/com/netflix/titus/federation | Create_ds/titus-control-plane/titus-server-federation/src/main/java/com/netflix/titus/federation/service/ErrorMerger.java | /*
* Copyright 2018 Netflix, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.netflix.titus.federation.service;
import java.util.Comparator;
import com.google.common.base.Preconditions;
import com.netflix.titus.common.util.tuple.Either;
import io.grpc.Status;
import io.grpc.stub.AbstractStub;
import rx.functions.Func2;
import static com.netflix.titus.runtime.endpoint.common.grpc.GrpcUtil.isNotOK;
interface ErrorMerger<STUB extends AbstractStub<STUB>, T> extends Func2<
CellResponse<STUB, Either<T, Throwable>>,
CellResponse<STUB, Either<T, Throwable>>,
CellResponse<STUB, Either<T, Throwable>>> {
// generics sanity
/**
* Rank errors with a provided {@link Comparator} by gRPC error codes, and return the most important one. In case of
* a tie, the return is undefined and can be any of the most important errors.
*/
static <STUB extends AbstractStub<STUB>, T> ErrorMerger<STUB, T> grpc(Comparator<Status> rank) {
return (one, other) -> {
Status oneStatus = Status.fromThrowable(one.getResult().getError());
Status otherStatus = Status.fromThrowable(other.getResult().getError());
Preconditions.checkArgument(isNotOK(oneStatus), "status is not an error");
Preconditions.checkArgument(isNotOK(otherStatus), "status is not an error");
if (rank.compare(oneStatus, otherStatus) <= 0) {
return one;
}
return other;
};
}
static <STUB extends AbstractStub<STUB>, T> ErrorMerger<STUB, T> grpcWithDefaultPriorities() {
return grpc(StatusCategoryComparator.defaultPriorities());
}
}
| 9,899 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.