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-testkit/src/main/java/com/netflix/titus/testkit/model | Create_ds/titus-control-plane/titus-testkit/src/main/java/com/netflix/titus/testkit/model/eviction/StubbedEvictionOperations.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.testkit.model.eviction;
import java.util.Optional;
import com.netflix.titus.api.eviction.model.EvictionQuota;
import com.netflix.titus.api.eviction.model.event.EvictionEvent;
import com.netflix.titus.api.eviction.service.EvictionException;
import com.netflix.titus.api.eviction.service.EvictionOperations;
import com.netflix.titus.api.model.callmetadata.CallMetadata;
import com.netflix.titus.api.jobmanager.model.job.Job;
import com.netflix.titus.api.jobmanager.model.job.Task;
import com.netflix.titus.api.jobmanager.service.JobManagerException;
import com.netflix.titus.api.jobmanager.service.V3JobOperations;
import com.netflix.titus.api.model.reference.Reference;
import com.netflix.titus.common.util.tuple.Pair;
import reactor.core.publisher.Flux;
import reactor.core.publisher.Mono;
class StubbedEvictionOperations implements EvictionOperations {
private final StubbedEvictionData stubbedEvictionData;
private final V3JobOperations jobOperations;
StubbedEvictionOperations(StubbedEvictionData stubbedEvictionData, V3JobOperations jobOperations) {
this.stubbedEvictionData = stubbedEvictionData;
this.jobOperations = jobOperations;
}
@Override
public Mono<Void> terminateTask(String taskId, String reason, String callerId) {
return deferMono(() -> {
Pair<Job<?>, Task> jobTaskPair = jobOperations.findTaskById(taskId).orElseThrow(() -> JobManagerException.taskNotFound(taskId));
Job<?> job = jobTaskPair.getLeft();
long quota = stubbedEvictionData.findEvictionQuota(Reference.job(job.getId())).map(EvictionQuota::getQuota).orElse(0L);
if (quota <= 0) {
throw EvictionException.noAvailableJobQuota(job, "No quota");
}
jobOperations.killTask(taskId, false, false, V3JobOperations.Trigger.Eviction, CallMetadata.newBuilder().withCallReason("Eviction").withCallerId("test").build()).block();
stubbedEvictionData.setJobQuota(job.getId(), quota - 1);
});
}
@Override
public EvictionQuota getEvictionQuota(Reference reference) {
return stubbedEvictionData.getEvictionQuota(reference);
}
@Override
public Optional<EvictionQuota> findEvictionQuota(Reference reference) {
return stubbedEvictionData.findEvictionQuota(reference);
}
@Override
public Flux<EvictionEvent> events(boolean includeSnapshot) {
return stubbedEvictionData.events(includeSnapshot);
}
private Mono<Void> deferMono(Runnable action) {
return Mono.defer(() -> {
action.run();
return Mono.empty();
});
}
}
| 1,100 |
0 | Create_ds/titus-control-plane/titus-testkit/src/main/java/com/netflix/titus/testkit/model | Create_ds/titus-control-plane/titus-testkit/src/main/java/com/netflix/titus/testkit/model/eviction/StubbedEvictionServiceClient.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.testkit.model.eviction;
import com.netflix.titus.api.eviction.model.EvictionQuota;
import com.netflix.titus.api.eviction.model.event.EvictionEvent;
import com.netflix.titus.api.eviction.service.EvictionOperations;
import com.netflix.titus.api.model.reference.Reference;
import com.netflix.titus.runtime.connector.eviction.EvictionServiceClient;
import reactor.core.publisher.Flux;
import reactor.core.publisher.Mono;
class StubbedEvictionServiceClient implements EvictionServiceClient {
private final EvictionOperations evictionOperations;
StubbedEvictionServiceClient(EvictionOperations evictionOperations) {
this.evictionOperations = evictionOperations;
}
@Override
public Mono<EvictionQuota> getEvictionQuota(Reference reference) {
return Mono.just(evictionOperations.findEvictionQuota(reference).orElseGet(() -> EvictionQuota.emptyQuota(reference)));
}
@Override
public Mono<Void> terminateTask(String taskId, String reason) {
return evictionOperations.terminateTask(taskId, reason, "<callerContext>");
}
@Override
public Flux<EvictionEvent> observeEvents(boolean includeSnapshot) {
return evictionOperations.events(includeSnapshot);
}
}
| 1,101 |
0 | Create_ds/titus-control-plane/titus-testkit/src/main/java/com/netflix/titus/testkit/model | Create_ds/titus-control-plane/titus-testkit/src/main/java/com/netflix/titus/testkit/model/eviction/DisruptionBudgetGenerator.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.testkit.model.eviction;
import java.util.Collections;
import java.util.List;
import com.netflix.titus.api.jobmanager.model.job.Job;
import com.netflix.titus.api.jobmanager.model.job.JobDescriptor;
import com.netflix.titus.api.jobmanager.model.job.JobDescriptor.JobDescriptorExt;
import com.netflix.titus.api.jobmanager.model.job.disruptionbudget.AvailabilityPercentageLimitDisruptionBudgetPolicy;
import com.netflix.titus.api.jobmanager.model.job.disruptionbudget.Day;
import com.netflix.titus.api.jobmanager.model.job.disruptionbudget.DisruptionBudget;
import com.netflix.titus.api.jobmanager.model.job.disruptionbudget.DisruptionBudgetPolicy;
import com.netflix.titus.api.jobmanager.model.job.disruptionbudget.DisruptionBudgetRate;
import com.netflix.titus.api.jobmanager.model.job.disruptionbudget.PercentagePerHourDisruptionBudgetRate;
import com.netflix.titus.api.jobmanager.model.job.disruptionbudget.RatePerIntervalDisruptionBudgetRate;
import com.netflix.titus.api.jobmanager.model.job.disruptionbudget.RatePercentagePerIntervalDisruptionBudgetRate;
import com.netflix.titus.api.jobmanager.model.job.disruptionbudget.RelocationLimitDisruptionBudgetPolicy;
import com.netflix.titus.api.jobmanager.model.job.disruptionbudget.SelfManagedDisruptionBudgetPolicy;
import com.netflix.titus.api.jobmanager.model.job.disruptionbudget.TimeWindow;
import com.netflix.titus.api.jobmanager.model.job.disruptionbudget.UnhealthyTasksLimitDisruptionBudgetPolicy;
import com.netflix.titus.api.jobmanager.model.job.disruptionbudget.UnlimitedDisruptionBudgetRate;
import com.netflix.titus.api.jobmanager.model.job.ext.BatchJobExt;
import com.netflix.titus.testkit.model.job.JobDescriptorGenerator;
import com.netflix.titus.testkit.model.job.JobGenerator;
public final class DisruptionBudgetGenerator {
public static AvailabilityPercentageLimitDisruptionBudgetPolicy percentageOfHealthyPolicy(double percentage) {
return AvailabilityPercentageLimitDisruptionBudgetPolicy.newBuilder()
.withPercentageOfHealthyContainers(percentage)
.build();
}
public static UnhealthyTasksLimitDisruptionBudgetPolicy numberOfHealthyPolicy(int limit) {
return UnhealthyTasksLimitDisruptionBudgetPolicy.newBuilder()
.withLimitOfUnhealthyContainers(limit)
.build();
}
public static RelocationLimitDisruptionBudgetPolicy perTaskRelocationLimitPolicy(int limit) {
return RelocationLimitDisruptionBudgetPolicy.newBuilder()
.withLimit(limit)
.build();
}
public static SelfManagedDisruptionBudgetPolicy selfManagedPolicy(long relocationTimeMs) {
return SelfManagedDisruptionBudgetPolicy.newBuilder()
.withRelocationTimeMs(relocationTimeMs)
.build();
}
public static PercentagePerHourDisruptionBudgetRate hourlyRatePercentage(int rate) {
return PercentagePerHourDisruptionBudgetRate.newBuilder()
.withMaxPercentageOfContainersRelocatedInHour(rate)
.build();
}
public static RatePerIntervalDisruptionBudgetRate ratePerInterval(long intervalMs, int rate) {
return RatePerIntervalDisruptionBudgetRate.newBuilder()
.withIntervalMs(intervalMs)
.withLimitPerInterval(rate)
.build();
}
public static RatePercentagePerIntervalDisruptionBudgetRate ratePercentagePerInterval(long intervalMs, double percentageRate) {
return RatePercentagePerIntervalDisruptionBudgetRate.newBuilder()
.withIntervalMs(intervalMs)
.withPercentageLimitPerInterval(percentageRate)
.build();
}
public static UnlimitedDisruptionBudgetRate unlimitedRate() {
return UnlimitedDisruptionBudgetRate.newBuilder().build();
}
public static TimeWindow officeHourTimeWindow() {
return TimeWindow.newBuilder()
.withDays(Day.weekdays())
.withwithHourlyTimeWindows(8, 17)
.withTimeZone("PST")
.build();
}
public static DisruptionBudget budget(DisruptionBudgetPolicy policy,
DisruptionBudgetRate rate,
List<TimeWindow> timeWindows) {
return DisruptionBudget.newBuilder()
.withDisruptionBudgetPolicy(policy)
.withDisruptionBudgetRate(rate)
.withContainerHealthProviders(Collections.emptyList())
.withTimeWindows(timeWindows)
.build();
}
public static DisruptionBudget budgetSelfManagedBasic() {
return budget(selfManagedPolicy(60_000), unlimitedRate(), Collections.emptyList());
}
public static JobDescriptor<BatchJobExt> newBatchJobDescriptor(int desired, DisruptionBudget budget) {
return JobDescriptorGenerator.batchJobDescriptor(desired).toBuilder()
.withDisruptionBudget(budget)
.build();
}
public static Job<BatchJobExt> newBatchJob(int desired, DisruptionBudget budget) {
return JobGenerator.batchJobs(newBatchJobDescriptor(desired, budget)).getValue();
}
public static <E extends JobDescriptorExt> JobDescriptor<E> exceptBudget(JobDescriptor<E> jobDescriptor, DisruptionBudget budget) {
return jobDescriptor.toBuilder().withDisruptionBudget(budget).build();
}
public static <E extends JobDescriptorExt> Job<E> exceptBudget(Job<E> job, DisruptionBudget budget) {
return job.toBuilder().withJobDescriptor(exceptBudget(job.getJobDescriptor(), budget)).build();
}
public static <E extends JobDescriptorExt> JobDescriptor<E> exceptPolicy(JobDescriptor<E> jobDescriptor, DisruptionBudgetPolicy policy) {
return exceptBudget(jobDescriptor, jobDescriptor.getDisruptionBudget().toBuilder().withDisruptionBudgetPolicy(policy).build());
}
public static <E extends JobDescriptorExt> Job<E> exceptPolicy(Job<E> job, DisruptionBudgetPolicy policy) {
return exceptBudget(job, job.getJobDescriptor().getDisruptionBudget().toBuilder().withDisruptionBudgetPolicy(policy).build());
}
public static <E extends JobDescriptorExt> JobDescriptor<E> exceptRate(JobDescriptor<E> jobDescriptor, DisruptionBudgetRate rate) {
return exceptBudget(jobDescriptor, jobDescriptor.getDisruptionBudget().toBuilder().withDisruptionBudgetRate(rate).build());
}
public static <E extends JobDescriptorExt> Job<E> exceptRate(Job<E> job, DisruptionBudgetRate rate) {
return exceptBudget(job, job.getJobDescriptor().getDisruptionBudget().toBuilder().withDisruptionBudgetRate(rate).build());
}
}
| 1,102 |
0 | Create_ds/titus-control-plane/titus-testkit/src/main/java/com/netflix/titus/testkit/model | Create_ds/titus-control-plane/titus-testkit/src/main/java/com/netflix/titus/testkit/model/eviction/EvictionComponentStub.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.testkit.model.eviction;
import com.netflix.titus.api.eviction.service.EvictionOperations;
import com.netflix.titus.common.runtime.TitusRuntime;
import com.netflix.titus.runtime.connector.eviction.EvictionServiceClient;
import com.netflix.titus.testkit.model.job.JobComponentStub;
public class EvictionComponentStub {
private final StubbedEvictionData stubbedEvictionData;
private final EvictionOperations evictionOperations;
private final StubbedEvictionServiceClient evictionServiceClient;
public EvictionComponentStub(JobComponentStub jobComponentStub, TitusRuntime titusRuntime) {
this.stubbedEvictionData = new StubbedEvictionData();
this.evictionOperations = new StubbedEvictionOperations(stubbedEvictionData, jobComponentStub.getJobOperations());
this.evictionServiceClient = new StubbedEvictionServiceClient(evictionOperations);
}
public EvictionOperations getEvictionOperations() {
return evictionOperations;
}
public void setSystemQuota(int quota) {
stubbedEvictionData.setSystemQuota(quota);
}
public void setJobQuota(String jobId, int quota) {
stubbedEvictionData.setJobQuota(jobId, quota);
}
public EvictionServiceClient getEvictionServiceClient() {
return evictionServiceClient;
}
}
| 1,103 |
0 | Create_ds/titus-control-plane/titus-testkit/src/main/java/com/netflix/titus/testkit/model | Create_ds/titus-control-plane/titus-testkit/src/main/java/com/netflix/titus/testkit/model/eviction/StubbedEvictionData.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.testkit.model.eviction;
import java.util.Optional;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;
import java.util.stream.Collectors;
import com.netflix.titus.api.eviction.model.EvictionQuota;
import com.netflix.titus.api.eviction.model.event.EvictionEvent;
import com.netflix.titus.api.eviction.service.EvictionException;
import com.netflix.titus.api.model.reference.Reference;
import reactor.core.publisher.EmitterProcessor;
import reactor.core.publisher.Flux;
class StubbedEvictionData {
private static final EvictionQuota SYSTEM_EVICTION_QUOTA = EvictionQuota.unlimited(Reference.system());
private EvictionQuota systemQuota = SYSTEM_EVICTION_QUOTA;
private final ConcurrentMap<String, EvictionQuota> jobQuota = new ConcurrentHashMap<>();
private final EmitterProcessor<EvictionEvent> eventProcessor = EmitterProcessor.create();
EvictionQuota getEvictionQuota(Reference reference) {
switch (reference.getLevel()) {
case System:
return systemQuota;
case Tier:
case CapacityGroup:
return SYSTEM_EVICTION_QUOTA;
case Job:
case Task:
return findJobQuota(reference.getName())
.map(quota -> quota.toBuilder().withReference(reference).build())
.orElseThrow(() -> EvictionException.noQuotaFound(reference));
}
throw new IllegalStateException("Unknown reference type: " + reference.getLevel());
}
Optional<EvictionQuota> findEvictionQuota(Reference reference) {
switch (reference.getLevel()) {
case System:
case Tier:
case CapacityGroup:
return Optional.of(getEvictionQuota(reference));
case Job:
case Task:
return findJobQuota(reference.getName()).map(quota -> quota.toBuilder().withReference(reference).build());
}
throw new IllegalStateException("Unknown reference type: " + reference.getLevel());
}
private Optional<EvictionQuota> findJobQuota(String jobId) {
return Optional.ofNullable(jobQuota.get(jobId));
}
void setSystemQuota(int quota) {
systemQuota = EvictionQuota.systemQuota(quota, "Stubbed");
eventProcessor.onNext(EvictionEvent.newQuotaEvent(systemQuota));
}
void setJobQuota(String jobId, long quota) {
jobQuota.put(jobId, EvictionQuota.jobQuota(jobId, quota, "Stubbed"));
eventProcessor.onNext(EvictionEvent.newQuotaEvent(EvictionQuota.jobQuota(jobId, quota, "Stubbed")));
}
Flux<EvictionEvent> events(boolean includeSnapshot) {
if (!includeSnapshot) {
return eventProcessor;
}
return Flux.concat(
Flux.just(EvictionEvent.newQuotaEvent(getEvictionQuota(Reference.system()))),
newJobEvictionEventSnapshot(),
Flux.just(EvictionEvent.newSnapshotEndEvent()),
eventProcessor
);
}
private Flux<EvictionEvent> newJobEvictionEventSnapshot() {
return Flux
.fromIterable(jobQuota.entrySet().stream()
.map(entry -> EvictionEvent.newQuotaEvent(entry.getValue()))
.collect(Collectors.toList())
)
.cast(EvictionEvent.class);
}
}
| 1,104 |
0 | Create_ds/titus-control-plane/titus-testkit/src/main/java/com/netflix/titus/testkit/data | Create_ds/titus-control-plane/titus-testkit/src/main/java/com/netflix/titus/testkit/data/core/ApplicationSlaGenerator.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.testkit.data.core;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import com.netflix.titus.api.model.ApplicationSLA;
public class ApplicationSlaGenerator {
private final Map<ApplicationSlaSample, Integer> sampleIndexes = new HashMap<>();
private final ApplicationSlaSample[] samples;
private int pos;
public ApplicationSlaGenerator(ApplicationSlaSample... samples) {
this.samples = samples;
for (ApplicationSlaSample sample : samples) {
sampleIndexes.put(sample, 0);
}
}
public ApplicationSLA next() {
ApplicationSlaSample sample = samples[pos % samples.length];
pos++;
int idx = sampleIndexes.get(sample);
sampleIndexes.put(sample, idx + 1);
ApplicationSLA.Builder builder = sample.builder().withAppName(sample.name() + '_' + idx);
return builder.build();
}
public List<ApplicationSLA> next(int count) {
List<ApplicationSLA> batch = new ArrayList<>(count);
for (int i = 0; i < count; i++) {
batch.add(next());
}
return batch;
}
}
| 1,105 |
0 | Create_ds/titus-control-plane/titus-testkit/src/main/java/com/netflix/titus/testkit/data | Create_ds/titus-control-plane/titus-testkit/src/main/java/com/netflix/titus/testkit/data/core/ResourceDimensionSample.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.testkit.data.core;
import com.netflix.titus.api.model.ResourceDimension;
import com.netflix.titus.api.model.ResourceDimension.Builder;
public enum ResourceDimensionSample {
Small() {
@Override
public Builder builder() {
return ResourceDimension.newBuilder()
.withCpus(1)
.withMemoryMB(1024)
.withDiskMB(100)
.withNetworkMbs(100);
}
},
SmallX2() {
@Override
public Builder builder() {
return ResourceDimension.newBuilder()
.withCpus(2)
.withMemoryMB(2048)
.withDiskMB(200)
.withNetworkMbs(200);
}
},
SmallWithGpuAndOpportunistic() {
@Override
public Builder builder() {
return Small.builder()
.withGpu(1)
.withOpportunisticCpus(1);
}
},
SmallWithGpuAndOpportunisticX2() {
@Override
public Builder builder() {
return SmallX2.builder()
.withGpu(2)
.withOpportunisticCpus(2);
}
};
public abstract Builder builder();
public ResourceDimension build() {
return builder().build();
}
}
| 1,106 |
0 | Create_ds/titus-control-plane/titus-testkit/src/main/java/com/netflix/titus/testkit/data | Create_ds/titus-control-plane/titus-testkit/src/main/java/com/netflix/titus/testkit/data/core/ApplicationSlaSample.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.testkit.data.core;
import java.util.ArrayList;
import java.util.List;
import com.google.common.math.DoubleMath;
import com.netflix.titus.api.model.ApplicationSLA;
import com.netflix.titus.api.model.ResourceDimension;
import com.netflix.titus.api.model.Tier;
import com.netflix.titus.common.aws.AwsInstanceDescriptor;
import com.netflix.titus.common.aws.AwsInstanceType;
import com.netflix.titus.master.model.ResourceDimensions;
import static com.netflix.titus.api.model.SchedulerConstants.SCHEDULER_NAME_KUBE_SCHEDULER;
import static com.netflix.titus.master.endpoint.v2.rest.ApplicationSlaManagementEndpoint.DEFAULT_APPLICATION;
/**
* TODO For test readability it would be better to express this with number of CPUs in names
*/
public enum ApplicationSlaSample {
DefaultFlex() {
@Override
public ApplicationSLA.Builder builder() {
return ApplicationSLA.newBuilder()
.withAppName(DEFAULT_APPLICATION)
.withTier(Tier.Flex)
.withResourceDimension(ResourceDimensionSample.SmallX2.build())
.withInstanceCount(100);
}
},
CriticalSmall() {
@Override
public ApplicationSLA.Builder builder() {
return ApplicationSLA.newBuilder()
.withAppName("criticalSmallApp")
.withTier(Tier.Critical)
.withResourceDimension(ResourceDimensionSample.Small.build())
.withInstanceCount(2);
}
},
CriticalLarge() {
@Override
public ApplicationSLA.Builder builder() {
return ApplicationSLA.newBuilder()
.withAppName("criticalLargeApp")
.withTier(Tier.Critical)
.withResourceDimension(ResourceDimensionSample.SmallX2.build())
.withInstanceCount(10);
}
},
FlexSmall() {
@Override
public ApplicationSLA.Builder builder() {
return ApplicationSLA.newBuilder(CriticalSmall.build())
.withAppName("flexSmallApp")
.withTier(Tier.Flex)
.withInstanceCount(2);
}
},
FlexLarge() {
@Override
public ApplicationSLA.Builder builder() {
return ApplicationSLA.newBuilder(CriticalLarge.build())
.withAppName("flexLargeApp")
.withTier(Tier.Flex)
.withInstanceCount(2);
}
},
FlexSmallKubeScheduler() {
@Override
public ApplicationSLA.Builder builder() {
return ApplicationSLA.newBuilder(CriticalSmall.build())
.withAppName("flexSmallKubeSchedulerApp")
.withTier(Tier.Flex)
.withSchedulerName(SCHEDULER_NAME_KUBE_SCHEDULER)
.withInstanceCount(2);
}
},
CriticalSmallKubeScheduler() {
@Override
public ApplicationSLA.Builder builder() {
return CriticalSmall.builder()
.withAppName("criticalSmallKubeSchedulerApp")
.withSchedulerName(SCHEDULER_NAME_KUBE_SCHEDULER)
.withResourcePool("reserved");
}
};
public abstract ApplicationSLA.Builder builder();
public ApplicationSLA build() {
return builder().build();
}
public static List<ApplicationSLA> asList(ApplicationSlaSample... samples) {
List<ApplicationSLA> sampleList = new ArrayList<>(samples.length);
for (ApplicationSlaSample s : samples) {
sampleList.add(s.build());
}
return sampleList;
}
public static ApplicationSLA fromAwsInstanceType(Tier tier, String appName, AwsInstanceType instanceType, double instanceCount) {
if (DoubleMath.isMathematicalInteger(instanceCount)) {
return ApplicationSLA.newBuilder()
.withTier(tier)
.withAppName(appName)
.withInstanceCount((int) instanceCount)
.withResourceDimension(ResourceDimensions.fromAwsInstanceType(instanceType))
.build();
}
// We have a fraction
AwsInstanceDescriptor descriptor = instanceType.getDescriptor();
return ApplicationSLA.newBuilder()
.withAppName(appName)
.withInstanceCount(1)
.withResourceDimension(ResourceDimension.newBuilder()
.withCpus(descriptor.getvCPUs() * instanceCount)
.withMemoryMB((int) (descriptor.getMemoryGB() * 1024 * instanceCount))
.withDiskMB((int) (descriptor.getStorageGB() * 1024 * instanceCount))
.withNetworkMbs((int) (descriptor.getNetworkMbs() * instanceCount))
.build()
)
.build();
}
}
| 1,107 |
0 | Create_ds/titus-control-plane/titus-testkit/src/main/java/com/netflix/titus/testkit | Create_ds/titus-control-plane/titus-testkit/src/main/java/com/netflix/titus/testkit/client/ReactorTitusMasterClient.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.testkit.client;
import java.io.IOException;
import java.util.Collections;
import java.util.List;
import javax.ws.rs.core.HttpHeaders;
import javax.ws.rs.core.MediaType;
import com.netflix.titus.api.endpoint.v2.rest.representation.ApplicationSlaRepresentation;
import com.netflix.titus.common.util.rx.ReactorExt;
import org.springframework.core.ParameterizedTypeReference;
import org.springframework.web.reactive.function.BodyInserters;
import org.springframework.web.reactive.function.client.WebClient;
import reactor.core.publisher.Mono;
import rx.Observable;
public class ReactorTitusMasterClient implements TitusMasterClient {
private static final ParameterizedTypeReference<List<ApplicationSlaRepresentation>> APPLICATION_SLA_LIST_TP =
new ParameterizedTypeReference<List<ApplicationSlaRepresentation>>() {
};
private final WebClient client;
public ReactorTitusMasterClient(String hostName, int port) {
this.client = WebClient.builder()
.baseUrl(String.format("http://%s:%s", hostName, port))
.defaultHeader(HttpHeaders.CONTENT_TYPE, MediaType.APPLICATION_JSON)
.build();
}
@Override
public Observable<String> addApplicationSLA(ApplicationSlaRepresentation applicationSLA) {
Mono<String> x = client.post()
.uri("/api/v2/management/applications")
.body(BodyInserters.fromObject(applicationSLA))
.exchange()
.flatMap(response -> response.toEntity(String.class))
.flatMap(response -> {
if (!response.getStatusCode().is2xxSuccessful()) {
return Mono.error(new IOException("Errored with HTTP status code " + response.getStatusCode()));
}
List<String> locationHeader = response.getHeaders().getOrDefault("Location", Collections.emptyList());
if (locationHeader.isEmpty()) {
return Mono.error(new IOException("Location header not found in response"));
}
return Mono.just(locationHeader.get(0));
});
return ReactorExt.toObservable(x);
}
@Override
public Observable<List<ApplicationSlaRepresentation>> findAllApplicationSLA() {
Mono<List<ApplicationSlaRepresentation>> x = client.get()
.uri("/api/v2/management/applications")
.retrieve()
.bodyToMono(APPLICATION_SLA_LIST_TP);
return ReactorExt.toObservable(x);
}
}
| 1,108 |
0 | Create_ds/titus-control-plane/titus-testkit/src/main/java/com/netflix/titus/testkit | Create_ds/titus-control-plane/titus-testkit/src/main/java/com/netflix/titus/testkit/client/V3ClientUtils.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.testkit.client;
import java.util.HashMap;
import java.util.Map;
import com.netflix.titus.api.model.callmetadata.CallMetadata;
import com.netflix.titus.api.jobmanager.model.job.Job;
import com.netflix.titus.api.jobmanager.model.job.Task;
import com.netflix.titus.api.jobmanager.model.job.event.JobManagerEvent;
import com.netflix.titus.api.jobmanager.model.job.event.JobUpdateEvent;
import com.netflix.titus.api.jobmanager.model.job.event.TaskUpdateEvent;
import com.netflix.titus.common.util.rx.ObservableExt;
import com.netflix.titus.common.util.tuple.Pair;
import com.netflix.titus.grpc.protogen.JobChangeNotification;
import com.netflix.titus.runtime.endpoint.v3.grpc.GrpcJobManagementModelConverters;
import rx.Observable;
public class V3ClientUtils {
private static final CallMetadata callMetadata = CallMetadata.newBuilder().withCallerId("StubbedJobData").build();
public static Observable<JobManagerEvent<?>> observeJobs(Observable<JobChangeNotification> grpcEvents) {
return grpcEvents.filter(V3ClientUtils::isJobOrTaskUpdate)
.compose(ObservableExt.mapWithState(new HashMap<>(), V3ClientUtils::toCoreEvent));
}
private static Pair<JobManagerEvent<?>, Map<String, Object>> toCoreEvent(JobChangeNotification event, Map<String, Object> state) {
if (event.getNotificationCase() == JobChangeNotification.NotificationCase.JOBUPDATE) {
Job<?> job = GrpcJobManagementModelConverters.toCoreJob(event.getJobUpdate().getJob());
Object previous = state.get(job.getId());
state.put(job.getId(), job);
if (previous == null) {
return Pair.of(JobUpdateEvent.newJob(job, callMetadata), state);
}
return Pair.of(JobUpdateEvent.jobChange(job, (Job<?>) previous, callMetadata), state);
}
// Task update
com.netflix.titus.grpc.protogen.Task grpcTask = event.getTaskUpdate().getTask();
Job<?> job = (Job<?>) state.get(grpcTask.getJobId());
Task task = GrpcJobManagementModelConverters.toCoreTask(job, grpcTask);
Object previous = state.get(task.getId());
state.put(task.getId(), task);
if (event.getTaskUpdate().getMovedFromAnotherJob()) {
return Pair.of(TaskUpdateEvent.newTaskFromAnotherJob(job, task, callMetadata), state);
} else if (previous == null) {
return Pair.of(TaskUpdateEvent.newTask(job, task, callMetadata), state);
}
return Pair.of(TaskUpdateEvent.taskChange(job, task, (Task) previous, callMetadata), state);
}
private static boolean isJobOrTaskUpdate(JobChangeNotification event) {
return event.getNotificationCase() == JobChangeNotification.NotificationCase.JOBUPDATE || event.getNotificationCase() == JobChangeNotification.NotificationCase.TASKUPDATE;
}
}
| 1,109 |
0 | Create_ds/titus-control-plane/titus-testkit/src/main/java/com/netflix/titus/testkit | Create_ds/titus-control-plane/titus-testkit/src/main/java/com/netflix/titus/testkit/client/TitusMasterClient.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.testkit.client;
import java.util.List;
import com.netflix.titus.api.endpoint.v2.rest.representation.ApplicationSlaRepresentation;
import com.netflix.titus.testkit.junit.master.TitusMasterResource;
import rx.Observable;
/**
* A simple implementation of Titus v2 REST API, which reuses server side REST API data model.
* It is provided solely for testing purposes. This implementation is provided as a default client by
* {@link TitusMasterResource}.
*/
public interface TitusMasterClient {
/*
* Capacity group management.
*/
Observable<String> addApplicationSLA(ApplicationSlaRepresentation applicationSLA);
Observable<List<ApplicationSlaRepresentation>> findAllApplicationSLA();
}
| 1,110 |
0 | Create_ds/titus-control-plane/titus-testkit/src/main/java/com/netflix/titus/testkit | Create_ds/titus-control-plane/titus-testkit/src/main/java/com/netflix/titus/testkit/rx/ExtTestSubscriber.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.testkit.rx;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.CopyOnWriteArrayList;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicReference;
import rx.Subscriber;
import rx.functions.Func1;
import static org.hamcrest.CoreMatchers.equalTo;
import static org.hamcrest.CoreMatchers.is;
import static org.junit.Assert.assertThat;
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;
/**
* RxJava {@link rx.observers.TestSubscriber}, is useful in most cases, specially when
* pared with {@link rx.schedulers.TestScheduler}. Sometimes however we want to examine asynchronous
* stream while it still produces items. This requires blocking not on the terminal event, but while
* waiting for onNext to happen.
* <p>
* Another difference of this class is a richer set of assertions.
*/
public class ExtTestSubscriber<T> extends Subscriber<T> {
private static final Object COMPLETED_MARKER = "CompletedMarker";
private static final Object ERROR_MARKER = "ErrorMarker";
private enum State {Open, OnCompleted, OnError}
private final AtomicReference<State> state = new AtomicReference<>(State.Open);
private final List<T> items = new CopyOnWriteArrayList<>();
private final BlockingQueue<T> available = new LinkedBlockingQueue<>();
private final AtomicReference<Throwable> onErrorResult = new AtomicReference<>();
private final List<Exception> contractErrors = new CopyOnWriteArrayList<>();
@Override
public void onCompleted() {
if (!state.compareAndSet(State.Open, State.OnCompleted)) {
contractErrors.add(new Exception("onComplete called on subscriber in state " + state));
}
available.add((T) COMPLETED_MARKER);
}
@Override
public void onError(Throwable e) {
if (!state.compareAndSet(State.Open, State.OnError)) {
contractErrors.add(new Exception("onError called on subscriber in state " + state));
}
onErrorResult.set(e);
available.add((T) ERROR_MARKER);
}
@Override
public void onNext(T t) {
if (state.get() != State.Open) {
contractErrors.add(new Exception("onNext called on subscriber in state " + state));
}
items.add(t);
available.add(t);
}
public void skipAvailable() {
while (takeNext() != null) {
}
}
public T takeNext() {
if (isError()) {
throw new IllegalStateException("OnError emitted", onErrorResult.get());
}
T value = available.poll();
return value == COMPLETED_MARKER ? null : value;
}
public List<T> takeNext(int n) throws IllegalStateException {
List<T> result = new ArrayList<>(n);
for (int i = 0; i < n; i++) {
T next = takeNext();
if (next == null) {
if (result.size() != n) {
throw new IllegalStateException("Did not receive the required number of items: " + n + ", only received: " + result.size());
}
break;
}
result.add(next);
}
return result;
}
public List<T> takeNext(int n, long timeout, TimeUnit timeUnit) throws InterruptedException, IllegalStateException {
List<T> result = new ArrayList<>(n);
for (int i = 0; i < n; i++) {
T next = takeNext(timeout, timeUnit);
if (next == null) {
if (result.size() != n) {
throw new IllegalStateException("Did not receive the required number of items: " + n + ", only received: " + result.size());
}
break;
}
result.add(next);
}
return result;
}
public T takeNext(long timeout, TimeUnit timeUnit) throws InterruptedException {
try {
return afterTakeNext(available.poll(timeout, timeUnit));
} catch (InterruptedException e) {
if (onErrorResult.get() != null) {
throw new RuntimeException(onErrorResult.get());
}
throw e;
}
}
public T takeNextOrWait() throws InterruptedException {
try {
return afterTakeNext(available.poll(24, TimeUnit.HOURS));
} catch (InterruptedException e) {
if (onErrorResult.get() != null) {
throw new RuntimeException(onErrorResult.get());
}
throw e;
}
}
private T afterTakeNext(T value) {
if (value == COMPLETED_MARKER) {
return null;
}
if (value == ERROR_MARKER) {
throw new RuntimeException(onErrorResult.get());
}
return value;
}
public List<T> getAllItems() {
return new ArrayList<>(items);
}
public T getLatestItem() {
if (items.isEmpty()) {
return null;
}
return items.get(items.size() - 1);
}
public boolean isError() {
return onErrorResult.get() != null;
}
public Throwable getError() {
return onErrorResult.get();
}
public List<T> getOnNextItems() {
return new ArrayList<>(items);
}
public List<T> takeNextOrWait(int n) throws InterruptedException {
List<T> result = new ArrayList<>(n);
for (int i = 0; i < n; i++) {
T next = takeNextOrWait();
if (next == null) {
break;
}
result.add(next);
}
return result;
}
public T takeNextOrFail() {
T next = available.poll();
if (next == null) {
if (state.get() == State.Open) {
fail("No more items currently available; observable stream is still open");
} else {
fail("No more items available; stream is terminated with state " + state);
}
}
return next;
}
public void assertOpen() {
if (state.get() == State.OnError) {
Throwable cause = onErrorResult.get();
throw cause instanceof RuntimeException ? (RuntimeException) cause : new RuntimeException(cause);
}
assertThat(state.get(), is(equalTo(State.Open)));
}
public void assertOnCompleted() {
assertThat(state.get(), is(equalTo(State.OnCompleted)));
}
public void assertOnCompleted(int timeout, TimeUnit timeUnit) throws Exception {
assertInState(State.OnCompleted, timeout, timeUnit);
}
public void assertOnError() {
assertThat(state.get(), is(equalTo(State.OnError)));
}
public void assertOnError(Throwable expected) {
assertThat(state.get(), is(equalTo(State.OnError)));
assertThat(onErrorResult.get(), is(equalTo(expected)));
}
public void assertOnError(int timeout, TimeUnit timeUnit) throws Exception {
assertInState(State.OnError, timeout, timeUnit);
}
public void assertOnError(Class<? extends Throwable> expected) {
assertThat(state.get(), is(equalTo(State.OnError)));
assertThat(onErrorResult.get().getClass(), is(equalTo(expected)));
}
public void assertOnError(Class<? extends Throwable> expected, int timeout, TimeUnit timeUnit) throws Exception {
assertInState(State.OnError, timeout, timeUnit);
assertThat(onErrorResult.get().getClass(), is(equalTo(expected)));
}
public void assertInState(State expectedState, int timeout, TimeUnit timeUnit) throws Exception {
long waitTimeInMs = timeUnit.toMillis(timeout);
long minWait = Math.max(waitTimeInMs, 10);
for (int i = 0; i < minWait; i += 10) {
if (state.get() == expectedState) {
assertTrue(true);
return;
}
Thread.sleep(10);
}
assertTrue(false);
}
public void assertContainsInAnyOrder(Collection<T> expected) {
assertContainsInAnyOrder(expected, new Func1<T, T>() {
@Override
public T call(T item) {
return item;
}
});
}
public <R> void assertContainsInAnyOrder(Collection<R> expected, Func1<T, R> mapFun) {
HashSet<R> left = new HashSet<>(expected);
while (!left.isEmpty()) {
R next = mapFun.call(takeNextOrFail());
if (!left.remove(next)) {
fail(formatAnyOrderFailure(next, expected.size(), left));
}
}
}
public void assertProducesInAnyOrder(Collection<T> expected) throws InterruptedException {
assertProducesInAnyOrder(expected, new Func1<T, T>() {
@Override
public T call(T item) {
return item;
}
}, 24, TimeUnit.HOURS);
}
public <R> void assertProducesInAnyOrder(Collection<R> expected,
Func1<T, R> mapFun) throws InterruptedException {
assertProducesInAnyOrder(expected, mapFun, 24, TimeUnit.HOURS);
}
public <R> void assertProducesInAnyOrder(Collection<R> expected,
Func1<T, R> mapFun,
long timeout,
TimeUnit timeUnit) throws InterruptedException {
HashSet<R> left = new HashSet<>(expected);
while (!left.isEmpty()) {
R next = mapFun.call(takeNext(timeout, timeUnit));
if (next != null && !left.remove(next)) {
fail(formatAnyOrderFailure(next, expected.size(), left));
}
}
}
private static <R> String formatAnyOrderFailure(R found, int total, Set<R> left) {
int consumed = total - left.size();
StringBuilder sb = new StringBuilder();
sb.append("Unexpected item found in the stream: ").append(found).append('\n');
sb.append(" consumed already ").append(consumed).append('\n');
sb.append(" left items on expected list:");
for (R item : left) {
sb.append('\n').append(item);
}
return sb.toString();
}
}
| 1,111 |
0 | Create_ds/titus-control-plane/titus-testkit/src/main/java/com/netflix/titus/testkit | Create_ds/titus-control-plane/titus-testkit/src/main/java/com/netflix/titus/testkit/embedded/EmbeddedTitusStackRunner.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.testkit.embedded;
import com.netflix.titus.testkit.embedded.cell.EmbeddedTitusCell;
import com.netflix.titus.testkit.embedded.cell.gateway.EmbeddedTitusGateway;
import com.netflix.titus.testkit.embedded.cell.master.EmbeddedTitusMaster;
import com.netflix.titus.testkit.embedded.federation.EmbeddedTitusFederation;
import com.netflix.titus.testkit.embedded.kube.EmbeddedKubeClusters;
import com.netflix.titus.testkit.util.cli.CommandLineBuilder;
import com.netflix.titus.testkit.util.cli.CommandLineFacade;
import org.apache.commons.cli.Option;
import org.apache.log4j.PropertyConfigurator;
public class EmbeddedTitusStackRunner {
static {
PropertyConfigurator.configure(EmbeddedTitusStackRunner.class.getClassLoader().getResource("embedded-log4j.properties"));
}
public static void main(String[] args) throws InterruptedException {
CommandLineFacade cliFacade = buildCliFacade(args);
EmbeddedTitusMaster titusMaster = EmbeddedTitusMaster.aTitusMaster()
.withEmbeddedKubeCluster(EmbeddedKubeClusters.basicCluster(2))
.withApiPort(8080)
.withGrpcPort(7104)
.withEnableDisruptionBudget(true)
.build();
boolean federationEnabled = cliFacade.isEnabled("f");
EmbeddedTitusCell cell = EmbeddedTitusCell.aTitusCell()
.withMaster(titusMaster)
.withGateway(
EmbeddedTitusGateway.aDefaultTitusGateway()
.withMasterEndpoint("localhost", 8090, 8080)
.withHttpPort(8081)
.withGrpcPort(8091)
// Binds to the default TaskRelocation service configuration
// TODO Make it configurable via command line parameter
.withProperty("titus.relocation.grpcClient.grpcPort", "7105")
.withProperty("titus.feature.mergingTaskMigrationPlanInGatewayEnabled", "true")
.build(),
!federationEnabled
)
.build();
cell.boot();
if (federationEnabled) {
EmbeddedTitusFederation stack = EmbeddedTitusFederation.aDefaultTitusFederation()
.withCell(".*", cell)
.withHttpPort(8082)
.withGrpcPort(8092)
.build();
stack.boot();
}
System.out.println("TitusStack started");
Thread.sleep(24 * 60 * 60 * 1000L);
}
private static CommandLineFacade buildCliFacade(String[] args) {
CommandLineFacade cliFacade = CommandLineBuilder.newApacheCli()
.withHostAndPortOption("Simulator/GRPC")
.withOption(Option.builder("f").longOpt("federation").argName("federation_enabled").hasArg(false)
.desc("Run TitusFederation")
.build()
)
.build(args);
if (cliFacade.hasHelpOption()) {
cliFacade.printHelp("EmbeddedTitusStackRunner");
System.exit(-1);
}
return cliFacade;
}
}
| 1,112 |
0 | Create_ds/titus-control-plane/titus-testkit/src/main/java/com/netflix/titus/testkit | Create_ds/titus-control-plane/titus-testkit/src/main/java/com/netflix/titus/testkit/embedded/EmbeddedTitusOperations.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.testkit.embedded;
import com.netflix.titus.grpc.protogen.HealthGrpc;
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.testkit.embedded.kube.EmbeddedKubeCluster;
import static com.netflix.titus.grpc.protogen.EvictionServiceGrpc.EvictionServiceBlockingStub;
public interface EmbeddedTitusOperations {
EmbeddedKubeCluster getKubeCluster();
HealthGrpc.HealthStub getHealthClient();
SchedulerServiceGrpc.SchedulerServiceBlockingStub getV3BlockingSchedulerClient();
JobManagementServiceGrpc.JobManagementServiceStub getV3GrpcClient();
JobManagementServiceGrpc.JobManagementServiceBlockingStub getV3BlockingGrpcClient();
LoadBalancerServiceGrpc.LoadBalancerServiceStub getLoadBalancerGrpcClient();
EvictionServiceBlockingStub getBlockingGrpcEvictionClient();
}
| 1,113 |
0 | Create_ds/titus-control-plane/titus-testkit/src/main/java/com/netflix/titus/testkit/embedded | Create_ds/titus-control-plane/titus-testkit/src/main/java/com/netflix/titus/testkit/embedded/cell/EmbeddedCellTitusOperations.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.testkit.embedded.cell;
import java.util.Optional;
import com.netflix.titus.grpc.protogen.EvictionServiceGrpc;
import com.netflix.titus.grpc.protogen.HealthGrpc;
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.testkit.embedded.EmbeddedTitusOperations;
import com.netflix.titus.testkit.embedded.cell.gateway.EmbeddedTitusGateway;
import com.netflix.titus.testkit.embedded.cell.master.EmbeddedTitusMaster;
import com.netflix.titus.testkit.embedded.kube.EmbeddedKubeCluster;
public class EmbeddedCellTitusOperations implements EmbeddedTitusOperations {
private final EmbeddedTitusMaster master;
private final Optional<EmbeddedTitusGateway> gateway;
private final EmbeddedKubeCluster kubeCluster;
public EmbeddedCellTitusOperations(EmbeddedTitusMaster master) {
this(master, null);
}
public EmbeddedCellTitusOperations(EmbeddedTitusMaster master, EmbeddedTitusGateway gateway) {
this.master = master;
this.gateway = Optional.ofNullable(gateway);
this.kubeCluster = master.getEmbeddedKubeCluster();
}
@Override
public EmbeddedKubeCluster getKubeCluster() {
return kubeCluster;
}
@Override
public HealthGrpc.HealthStub getHealthClient() {
return gateway.map(EmbeddedTitusGateway::getHealthClient).orElse(master.getHealthClient());
}
@Override
public SchedulerServiceGrpc.SchedulerServiceBlockingStub getV3BlockingSchedulerClient() {
return gateway.map(EmbeddedTitusGateway::getV3BlockingSchedulerClient).orElse(master.getV3BlockingSchedulerClient());
}
@Override
public JobManagementServiceGrpc.JobManagementServiceStub getV3GrpcClient() {
return gateway.map(EmbeddedTitusGateway::getV3GrpcClient).orElse(master.getV3GrpcClient());
}
@Override
public JobManagementServiceGrpc.JobManagementServiceBlockingStub getV3BlockingGrpcClient() {
return gateway.map(EmbeddedTitusGateway::getV3BlockingGrpcClient).orElse(master.getV3BlockingGrpcClient());
}
@Override
public LoadBalancerServiceGrpc.LoadBalancerServiceStub getLoadBalancerGrpcClient() {
return gateway.map(EmbeddedTitusGateway::getLoadBalancerGrpcClient).orElse(master.getLoadBalancerGrpcClient());
}
@Override
public EvictionServiceGrpc.EvictionServiceBlockingStub getBlockingGrpcEvictionClient() {
return gateway.map(EmbeddedTitusGateway::getBlockingGrpcEvictionClient).orElse(master.getBlockingGrpcEvictionClient());
}
}
| 1,114 |
0 | Create_ds/titus-control-plane/titus-testkit/src/main/java/com/netflix/titus/testkit/embedded | Create_ds/titus-control-plane/titus-testkit/src/main/java/com/netflix/titus/testkit/embedded/cell/EmbeddedTitusCell.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.testkit.embedded.cell;
import com.google.common.base.Function;
import com.google.common.base.Preconditions;
import com.netflix.titus.api.jobmanager.model.job.JobDescriptor;
import com.netflix.titus.common.model.admission.AdmissionSanitizer;
import com.netflix.titus.common.model.admission.AdmissionValidator;
import com.netflix.titus.runtime.endpoint.admission.PassJobValidator;
import com.netflix.titus.testkit.embedded.EmbeddedTitusOperations;
import com.netflix.titus.testkit.embedded.cell.gateway.EmbeddedTitusGateway;
import com.netflix.titus.testkit.embedded.cell.master.EmbeddedTitusMaster;
import com.netflix.titus.testkit.embedded.kube.EmbeddedKubeCluster;
/**
* Represents complete Titus stack, which includes master, gateway and agents.
*/
public class EmbeddedTitusCell {
private final EmbeddedTitusMaster master;
private final EmbeddedTitusGateway gateway;
private final EmbeddedTitusOperations titusOperations;
private EmbeddedTitusCell(EmbeddedTitusMaster master,
EmbeddedTitusGateway gateway) {
this.master = master;
this.gateway = gateway;
this.titusOperations = new EmbeddedCellTitusOperations(master, gateway);
}
public EmbeddedTitusCell toMaster(Function<EmbeddedTitusMaster.Builder, EmbeddedTitusMaster.Builder> masterTransformer) {
EmbeddedTitusMaster newMaster = masterTransformer.apply(master.toBuilder()).build();
return new EmbeddedTitusCell(newMaster, gateway.toBuilder().withMaster(newMaster).build());
}
public EmbeddedTitusCell boot() {
master.boot();
gateway.boot();
return this;
}
public EmbeddedTitusCell shutdown() {
gateway.shutdown();
master.shutdown();
return this;
}
public EmbeddedTitusMaster getMaster() {
return master;
}
public EmbeddedTitusGateway getGateway() {
return gateway;
}
public EmbeddedTitusOperations getTitusOperations() {
return titusOperations;
}
public static EmbeddedTitusCell.Builder aTitusCell() {
return new Builder();
}
public EmbeddedKubeCluster getEmbeddedKubeCluster() {
return master.getEmbeddedKubeCluster();
}
public static class Builder {
private EmbeddedTitusMaster master;
private EmbeddedTitusGateway gateway;
private boolean enableREST;
private boolean defaultGateway;
private AdmissionValidator<JobDescriptor> validator = new PassJobValidator();
private AdmissionSanitizer<JobDescriptor> jobSanitizer = new PassJobValidator();
public Builder withMaster(EmbeddedTitusMaster master) {
this.master = master;
return this;
}
public Builder withGateway(EmbeddedTitusGateway gateway, boolean enableREST) {
this.gateway = gateway;
this.enableREST = enableREST;
return this;
}
public Builder withDefaultGateway() {
this.defaultGateway = true;
return this;
}
public Builder withJobValidator(AdmissionValidator<JobDescriptor> validator) {
this.validator = validator;
return this;
}
public Builder withJobSanitizer(AdmissionSanitizer<JobDescriptor> jobSanitizer) {
this.jobSanitizer = jobSanitizer;
return this;
}
public EmbeddedTitusCell build() {
Preconditions.checkNotNull(master, "TitusMaster not set");
Preconditions.checkState(gateway != null || defaultGateway, "TitusGateway not set, nor default gateway requested");
master = master.toBuilder().withEnableREST(false).build();
if (defaultGateway) {
gateway = EmbeddedTitusGateway.aDefaultTitusGateway()
.withMaster(master)
.withStore(master.getJobStore())
.withEnableREST(enableREST)
.withJobValidator(validator)
.withJobSanitizer(jobSanitizer)
.build();
} else {
gateway = gateway.toBuilder()
.withMaster(master)
.withStore(master.getJobStore())
.withEnableREST(enableREST)
.build();
}
return new EmbeddedTitusCell(master, gateway);
}
}
}
| 1,115 |
0 | Create_ds/titus-control-plane/titus-testkit/src/main/java/com/netflix/titus/testkit/embedded | Create_ds/titus-control-plane/titus-testkit/src/main/java/com/netflix/titus/testkit/embedded/cell/EmbeddedTitusCells.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.testkit.embedded.cell;
import com.netflix.titus.testkit.embedded.cell.master.EmbeddedTitusMaster;
import com.netflix.titus.testkit.embedded.cell.master.EmbeddedTitusMasters;
import com.netflix.titus.testkit.embedded.kube.EmbeddedKubeCluster;
import com.netflix.titus.testkit.embedded.kube.EmbeddedKubeClusters;
public class EmbeddedTitusCells {
public static EmbeddedTitusCell basicKubeCell(int desired) {
return basicKubeCell(EmbeddedTitusMaster.CELL_NAME, desired);
}
public static EmbeddedTitusCell basicKubeCellWithCustomZones(int desired, String... zones) {
return basicKubeCell(EmbeddedTitusMaster.CELL_NAME, EmbeddedKubeClusters.basicClusterWithCustomZones(desired, zones));
}
public static EmbeddedTitusCell basicKubeCell(String cellName, int desired) {
return basicKubeCell(cellName, EmbeddedKubeClusters.basicCluster(desired));
}
private static EmbeddedTitusCell basicKubeCell(String cellName, EmbeddedKubeCluster embeddedKubeCluster) {
return EmbeddedTitusCell.aTitusCell()
.withMaster(EmbeddedTitusMasters.basicMasterWithKubeIntegration(embeddedKubeCluster).toBuilder()
.withCellName(cellName)
.build()
)
.withDefaultGateway()
.build();
}
}
| 1,116 |
0 | Create_ds/titus-control-plane/titus-testkit/src/main/java/com/netflix/titus/testkit/embedded/cell | Create_ds/titus-control-plane/titus-testkit/src/main/java/com/netflix/titus/testkit/embedded/cell/master/EmbeddedTitusMasters.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.testkit.embedded.cell.master;
import com.netflix.titus.testkit.embedded.kube.EmbeddedKubeCluster;
import com.netflix.titus.testkit.embedded.kube.EmbeddedKubeClusters;
/**
* A collection of preconfigured {@link EmbeddedTitusMaster} instances with different configuration tuning targets.
*/
public final class EmbeddedTitusMasters {
/**
* Embedded TitusMaster with configuration tuned up for faster execution, to make test fast.
*/
public static EmbeddedTitusMaster basicMasterWithKubeIntegration(EmbeddedKubeCluster embeddedKubeCluster) {
return EmbeddedTitusMaster.aTitusMaster()
.withEmbeddedKubeCluster(embeddedKubeCluster)
.withProperty("titus.master.capacityManagement.availableCapacityUpdateIntervalMs", "10")
.withProperty("titus.master.grpcServer.shutdownTimeoutMs", "0")
.withProperty("titusMaster.jobManager.taskInLaunchedStateTimeoutMs", "30000")
.withProperty("titusMaster.jobManager.batchTaskInStartInitiatedStateTimeoutMs", "30000")
.withProperty("titusMaster.jobManager.serviceTaskInStartInitiatedStateTimeoutMs", "30000")
.withProperty("titusMaster.jobManager.reconcilerIdleTimeoutMs", "100")
.withProperty("titusMaster.jobManager.reconcilerActiveTimeoutMs", "10")
.withProperty("titus.master.grpcServer.loadbalancer.enabled", "true")
.withProperty("titus.master.loadBalancer.engineEnabled", "true")
.withProperty("titusMaster.eviction.eventStreamQuotaUpdateIntervalMs", "100")
.withProperty("titus.features.jobManager.disruptionBudget.whiteList", ".*")
.withProperty("titusMaster.kubernetes.pod.gpuResourcePoolNames", EmbeddedKubeClusters.RESOURCE_POOL_GPU)
.withProperty("titusMaster.directKube.ebsVolumePvEnabled", "true")
.build();
}
}
| 1,117 |
0 | Create_ds/titus-control-plane/titus-testkit/src/main/java/com/netflix/titus/testkit/embedded/cell | Create_ds/titus-control-plane/titus-testkit/src/main/java/com/netflix/titus/testkit/embedded/cell/master/EmbeddedTitusRunner.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.testkit.embedded.cell.master;
import com.netflix.titus.common.runtime.internal.DefaultTitusRuntime;
import com.netflix.titus.testkit.embedded.kube.EmbeddedKubeClusters;
public class EmbeddedTitusRunner {
public static void main(String[] args) throws InterruptedException {
System.setProperty(DefaultTitusRuntime.FIT_ACTIVATION_PROPERTY, "true");
EmbeddedTitusMaster.Builder builder = EmbeddedTitusMaster.aTitusMaster()
.withEmbeddedKubeCluster(EmbeddedKubeClusters.basicCluster(2))
.withCassadraV3JobStore()
.withApiPort(8080)
.withGrpcPort(8090);
EmbeddedTitusMaster titusMaster = builder.build();
titusMaster.boot();
System.out.println("TitusMaster started");
Thread.sleep(24 * 60 * 60 * 1000L);
}
}
| 1,118 |
0 | Create_ds/titus-control-plane/titus-testkit/src/main/java/com/netflix/titus/testkit/embedded/cell | Create_ds/titus-control-plane/titus-testkit/src/main/java/com/netflix/titus/testkit/embedded/cell/master/EmbeddedTitusMaster.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.testkit.embedded.cell.master;
import java.util.List;
import java.util.Properties;
import java.util.concurrent.CopyOnWriteArrayList;
import java.util.concurrent.TimeUnit;
import javax.inject.Singleton;
import com.google.common.base.Preconditions;
import com.google.common.base.Stopwatch;
import com.google.inject.AbstractModule;
import com.google.inject.Key;
import com.google.inject.Module;
import com.google.inject.Provides;
import com.google.inject.util.Modules;
import com.netflix.archaius.config.DefaultSettableConfig;
import com.netflix.archaius.guice.ArchaiusModule;
import com.netflix.governator.InjectorBuilder;
import com.netflix.governator.LifecycleInjector;
import com.netflix.governator.guice.jetty.JettyModule;
import com.netflix.spectator.api.DefaultRegistry;
import com.netflix.spectator.api.Registry;
import com.netflix.titus.api.appscale.store.AppScalePolicyStore;
import com.netflix.titus.api.audit.model.AuditLogEvent;
import com.netflix.titus.api.audit.service.AuditLogService;
import com.netflix.titus.api.connector.cloud.LoadBalancerConnector;
import com.netflix.titus.api.connector.cloud.noop.NoOpLoadBalancerConnector;
import com.netflix.titus.api.jobmanager.store.JobStore;
import com.netflix.titus.api.json.ObjectMappers;
import com.netflix.titus.api.loadbalancer.model.sanitizer.LoadBalancerJobValidator;
import com.netflix.titus.api.loadbalancer.model.sanitizer.NoOpLoadBalancerJobValidator;
import com.netflix.titus.api.loadbalancer.store.LoadBalancerStore;
import com.netflix.titus.api.supervisor.service.LeaderActivator;
import com.netflix.titus.api.supervisor.service.MasterDescription;
import com.netflix.titus.api.supervisor.service.MasterMonitor;
import com.netflix.titus.common.runtime.TitusRuntime;
import com.netflix.titus.common.util.archaius2.Archaius2ConfigurationLogger;
import com.netflix.titus.common.util.guice.ContainerEventBus;
import com.netflix.titus.ext.cassandra.testkit.store.EmbeddedCassandraStoreFactory;
import com.netflix.titus.grpc.protogen.AutoScalingServiceGrpc;
import com.netflix.titus.grpc.protogen.EvictionServiceGrpc;
import com.netflix.titus.grpc.protogen.HealthGrpc;
import com.netflix.titus.grpc.protogen.HealthGrpc.HealthStub;
import com.netflix.titus.grpc.protogen.JobManagementServiceGrpc;
import com.netflix.titus.grpc.protogen.JobManagementServiceGrpc.JobManagementServiceBlockingStub;
import com.netflix.titus.grpc.protogen.JobManagementServiceGrpc.JobManagementServiceStub;
import com.netflix.titus.grpc.protogen.LoadBalancerServiceGrpc;
import com.netflix.titus.grpc.protogen.SchedulerServiceGrpc;
import com.netflix.titus.grpc.protogen.SupervisorServiceGrpc;
import com.netflix.titus.grpc.protogen.SupervisorServiceGrpc.SupervisorServiceBlockingStub;
import com.netflix.titus.master.TitusMaster;
import com.netflix.titus.master.TitusMasterModule;
import com.netflix.titus.master.TitusRuntimeModule;
import com.netflix.titus.master.endpoint.grpc.TitusMasterGrpcServer;
import com.netflix.titus.master.eviction.service.quota.system.ArchaiusSystemDisruptionBudgetResolver;
import com.netflix.titus.master.eviction.service.quota.system.SystemDisruptionBudgetDescriptor;
import com.netflix.titus.master.service.management.ApplicationSlaManagementService;
import com.netflix.titus.master.service.management.InMemoryApplicationSlaManagementService;
import com.netflix.titus.master.supervisor.service.leader.LocalMasterMonitor;
import com.netflix.titus.runtime.endpoint.common.rest.EmbeddedJettyModule;
import com.netflix.titus.runtime.store.v3.memory.InMemoryJobStore;
import com.netflix.titus.runtime.store.v3.memory.InMemoryLoadBalancerStore;
import com.netflix.titus.runtime.store.v3.memory.InMemoryPolicyStore;
import com.netflix.titus.testkit.client.ReactorTitusMasterClient;
import com.netflix.titus.testkit.client.TitusMasterClient;
import com.netflix.titus.testkit.embedded.kube.EmbeddedKubeCluster;
import com.netflix.titus.testkit.embedded.kube.EmbeddedKubeModule;
import com.netflix.titus.testkit.grpc.TestKitGrpcClientErrorUtils;
import io.grpc.ManagedChannel;
import io.grpc.ManagedChannelBuilder;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import rx.Observable;
/**
* Run TitusMaster server with mocked external integrations (Kubernetes, storage).
*/
public class EmbeddedTitusMaster {
private static final Logger logger = LoggerFactory.getLogger(EmbeddedTitusMaster.class);
public static final String CELL_NAME = "embeddedCell";
private final Properties properties;
private final DefaultSettableConfig config;
private int apiPort;
private int grpcPort;
private final boolean enableREST;
private final boolean enableDisruptionBudget;
private final String cellName;
private final MasterDescription masterDescription;
private final JobStore jobStore;
private final boolean cassandraJobStore;
private final EmbeddedKubeCluster embeddedKubeCluster;
private LifecycleInjector injector;
private final List<AuditLogEvent> auditLogs = new CopyOnWriteArrayList<>();
private ManagedChannel grpcChannel;
private EmbeddedTitusMaster(Builder builder) {
this.config = new DefaultSettableConfig();
this.properties = builder.props;
this.config.setProperties(builder.props);
this.apiPort = builder.apiPort;
this.grpcPort = builder.grpcPort;
this.enableREST = builder.enableREST;
this.enableDisruptionBudget = builder.enableDisruptionBudget;
this.cellName = builder.cellName;
this.masterDescription = new MasterDescription(
"embedded_titus_master", "192.168.0.1", builder.apiPort, "api/postjobstatus",
System.currentTimeMillis()
);
this.jobStore = builder.v3JobStore == null ? new InMemoryJobStore() : builder.v3JobStore;
this.cassandraJobStore = builder.cassandraJobStore;
String resourceDir = TitusMaster.class.getClassLoader().getResource("static").toExternalForm();
Properties embeddedProperties = new Properties();
embeddedProperties.put("governator.jetty.embedded.webAppResourceBase", resourceDir);
embeddedProperties.put("titus.master.cellName", cellName);
if (enableDisruptionBudget) {
embeddedProperties.put("titusMaster.jobManager.features.disruptionBudget.featureEnabled", "true");
embeddedProperties.put("titusMaster.jobManager.features.disruptionBudget.whiteList", ".*");
}
config.setProperties(embeddedProperties);
this.embeddedKubeCluster = builder.embeddedKubeCluster;
}
public EmbeddedTitusMaster boot() {
Stopwatch timer = Stopwatch.createStarted();
logger.info("Starting Titus Master");
Module embeddedKubeModule;
if (embeddedKubeCluster == null) {
embeddedKubeModule = new AbstractModule() {
@Override
protected void configure() {
}
};
} else {
embeddedKubeModule = new EmbeddedKubeModule(embeddedKubeCluster);
}
injector = InjectorBuilder.fromModules(
Modules.override(new TitusRuntimeModule(false)).with(new AbstractModule() {
@Override
protected void configure() {
bind(Archaius2ConfigurationLogger.class).asEagerSingleton();
bind(Registry.class).toInstance(new DefaultRegistry());
}
}),
embeddedKubeModule,
Modules.override(new TitusMasterModule(enableREST, TitusMasterModule.Mode.EMBEDDED_KUBE))
.with(new AbstractModule() {
@Override
protected void configure() {
bind(MasterDescription.class).toInstance(masterDescription);
bind(MasterMonitor.class).to(LocalMasterMonitor.class);
bind(ApplicationSlaManagementService.class).to(InMemoryApplicationSlaManagementService.class);
bind(AppScalePolicyStore.class).to(InMemoryPolicyStore.class);
bind(LoadBalancerStore.class).to(InMemoryLoadBalancerStore.class);
bind(LoadBalancerConnector.class).to(NoOpLoadBalancerConnector.class);
bind(LoadBalancerJobValidator.class).to(NoOpLoadBalancerJobValidator.class);
}
@Provides
@Singleton
public JobStore getJobStore(TitusRuntime titusRuntime) {
if (!cassandraJobStore) {
return jobStore;
}
try {
JobStore jobStore = EmbeddedCassandraStoreFactory.newBuilder()
.withTitusRuntime(titusRuntime)
.build()
.getJobStore();
return jobStore;
} catch (Throwable e) {
e.printStackTrace();
return null;
}
}
}
),
newJettyModule(),
new ArchaiusModule() {
@Override
protected void configureArchaius() {
bindApplicationConfigurationOverride().toInstance(config);
}
}).createInjector();
if (grpcPort <= 0) {
grpcPort = getGrpcPort();
config.setProperty("titus.master.grpcServer.port", "" + grpcPort);
}
injector.getInstance(ContainerEventBus.class).submitInOrder(new ContainerEventBus.ContainerStartedEvent());
injector.getInstance(LeaderActivator.class).becomeLeader();
injector.getInstance(AuditLogService.class).auditLogEvents().subscribe(auditLogs::add);
if (enableREST) {
// Since jetty API server is run on a separate thread, it may not be ready yet
// We do not have better way, but call it until it replies.
getClient().findAllApplicationSLA().retryWhen(attempts -> {
return attempts.zipWith(Observable.range(1, 5), (n, i) -> i).flatMap(i -> {
return Observable.timer(i, TimeUnit.SECONDS);
});
}
).timeout(30, TimeUnit.SECONDS).toBlocking().firstOrDefault(null);
}
logger.info("Embedded TitusMaster started in {}ms", timer.elapsed(TimeUnit.MILLISECONDS));
return this;
}
private Module newJettyModule() {
if (!enableREST) {
return Modules.EMPTY_MODULE;
}
return new EmbeddedJettyModule(apiPort);
}
public void shutdown() {
if (grpcChannel != null) {
grpcChannel.shutdown();
grpcChannel = null;
}
if (injector != null) {
injector.close();
}
}
public DefaultSettableConfig getConfig() {
return config;
}
public TitusMasterClient getClient() {
int jettyPort = injector.getInstance(JettyModule.JettyRunner.class).getLocalPort();
return new ReactorTitusMasterClient("127.0.0.1", jettyPort);
}
public HealthStub getHealthClient() {
HealthStub client = HealthGrpc.newStub(getOrCreateGrpcChannel());
return TestKitGrpcClientErrorUtils.attachCallHeaders(client);
}
public SupervisorServiceBlockingStub getSupervisorBlockingGrpcClient() {
SupervisorServiceBlockingStub client = SupervisorServiceGrpc.newBlockingStub(getOrCreateGrpcChannel());
return TestKitGrpcClientErrorUtils.attachCallHeaders(client);
}
public SchedulerServiceGrpc.SchedulerServiceBlockingStub getV3BlockingSchedulerClient() {
SchedulerServiceGrpc.SchedulerServiceBlockingStub client = SchedulerServiceGrpc.newBlockingStub(getOrCreateGrpcChannel());
return TestKitGrpcClientErrorUtils.attachCallHeaders(client);
}
public JobManagementServiceStub getV3GrpcClient() {
JobManagementServiceStub client = JobManagementServiceGrpc.newStub(getOrCreateGrpcChannel());
return TestKitGrpcClientErrorUtils.attachCallHeaders(client);
}
public JobManagementServiceBlockingStub getV3BlockingGrpcClient() {
JobManagementServiceBlockingStub client = JobManagementServiceGrpc.newBlockingStub(getOrCreateGrpcChannel());
return TestKitGrpcClientErrorUtils.attachCallHeaders(client);
}
public AutoScalingServiceGrpc.AutoScalingServiceStub getAutoScaleGrpcClient() {
AutoScalingServiceGrpc.AutoScalingServiceStub client = AutoScalingServiceGrpc.newStub(getOrCreateGrpcChannel());
return TestKitGrpcClientErrorUtils.attachCallHeaders(client);
}
public LoadBalancerServiceGrpc.LoadBalancerServiceStub getLoadBalancerGrpcClient() {
LoadBalancerServiceGrpc.LoadBalancerServiceStub client = LoadBalancerServiceGrpc.newStub(getOrCreateGrpcChannel());
return TestKitGrpcClientErrorUtils.attachCallHeaders(client);
}
public EvictionServiceGrpc.EvictionServiceBlockingStub getBlockingGrpcEvictionClient() {
return EvictionServiceGrpc.newBlockingStub(getOrCreateGrpcChannel());
}
private ManagedChannel getOrCreateGrpcChannel() {
if (grpcChannel == null) {
this.grpcChannel = ManagedChannelBuilder.forAddress("127.0.0.1", getGrpcPort())
.usePlaintext()
.build();
}
return grpcChannel;
}
public JobStore getJobStore() {
return jobStore;
}
public void reboot() {
shutdown();
boot();
}
public <T> T getInstance(Class<T> type) {
return injector.getInstance(type);
}
public <T> T getInstance(Key<T> type) {
return injector.getInstance(type);
}
public static Builder aTitusMaster() {
return new Builder();
}
public String getCellName() {
return cellName;
}
public int getGrpcPort() {
Preconditions.checkNotNull(injector, "TitusMaster not started yet");
return injector.getInstance(TitusMasterGrpcServer.class).getGrpcPort();
}
public EmbeddedKubeCluster getEmbeddedKubeCluster() {
return embeddedKubeCluster;
}
public Builder toBuilder() {
return new Builder()
.withApiPort(apiPort)
.withGrpcPort(grpcPort)
.withCellName(cellName)
.withEmbeddedKubeCluster(embeddedKubeCluster)
.withProperties(properties)
.withEnableDisruptionBudget(enableDisruptionBudget)
.withV3JobStore(jobStore);
}
public static class Builder {
private Properties props = new Properties();
public String cellName = CELL_NAME;
private int apiPort;
private int grpcPort;
private boolean enableREST = true;
private boolean enableDisruptionBudget;
private JobStore v3JobStore;
private boolean cassandraJobStore;
private EmbeddedKubeCluster embeddedKubeCluster;
private SystemDisruptionBudgetDescriptor systemDisruptionBudgetDescriptor;
public Builder() {
props.put("titusMaster.job.configuration.defaultSecurityGroups", "sg-12345,sg-34567");
props.put("titusMaster.job.configuration.defaultIamRole", "iam-12345");
}
public Builder withCellName(String cellName) {
this.cellName = cellName;
return this;
}
public Builder withApiPort(int apiPort) {
this.apiPort = apiPort;
return this;
}
public Builder withGrpcPort(int grpcPort) {
this.grpcPort = grpcPort;
return this;
}
public Builder withEnableREST(boolean enableREST) {
this.enableREST = enableREST;
return this;
}
public Builder withEnableDisruptionBudget(boolean enableDisruptionBudget) {
this.enableDisruptionBudget = enableDisruptionBudget;
return this;
}
public Builder withProperty(String name, String value) {
props.put(name, value);
return this;
}
public Builder withProperties(Properties properties) {
props.putAll(properties);
return this;
}
public Builder withSystemDisruptionBudgetDescriptor(SystemDisruptionBudgetDescriptor systemDisruptionBudgetDescriptor) {
this.systemDisruptionBudgetDescriptor = systemDisruptionBudgetDescriptor;
return this;
}
public Builder withV3JobStore(JobStore jobStore) {
this.v3JobStore = jobStore;
return this;
}
public Builder withCassadraV3JobStore() {
this.cassandraJobStore = true;
return this;
}
public Builder withEmbeddedKubeCluster(EmbeddedKubeCluster embeddedKubeCluster) {
this.embeddedKubeCluster = embeddedKubeCluster;
return this;
}
public EmbeddedTitusMaster build() {
if (systemDisruptionBudgetDescriptor != null) {
try {
props.put(
ArchaiusSystemDisruptionBudgetResolver.PROPERTY_KEY,
ObjectMappers.storeMapper().writeValueAsString(systemDisruptionBudgetDescriptor)
);
} catch (Exception e) {
throw new IllegalArgumentException(e);
}
}
props.put("titus.master.audit.auditLogFolder", "build/auditLogs");
props.put("titus.master.apiport", Integer.toString(apiPort));
props.put("titus.master.grpcServer.port", Integer.toString(grpcPort));
return new EmbeddedTitusMaster(this);
}
}
}
| 1,119 |
0 | Create_ds/titus-control-plane/titus-testkit/src/main/java/com/netflix/titus/testkit/embedded/cell | Create_ds/titus-control-plane/titus-testkit/src/main/java/com/netflix/titus/testkit/embedded/cell/gateway/EmbeddedTitusGateway.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.testkit.embedded.cell.gateway;
import java.util.Collections;
import java.util.Properties;
import java.util.concurrent.TimeUnit;
import com.google.common.base.Preconditions;
import com.google.common.base.Stopwatch;
import com.google.inject.AbstractModule;
import com.google.inject.Module;
import com.google.inject.Provides;
import com.google.inject.Singleton;
import com.google.inject.TypeLiteral;
import com.google.inject.util.Modules;
import com.netflix.archaius.config.DefaultSettableConfig;
import com.netflix.archaius.guice.ArchaiusModule;
import com.netflix.governator.InjectorBuilder;
import com.netflix.governator.LifecycleInjector;
import com.netflix.titus.api.jobmanager.model.job.JobDescriptor;
import com.netflix.titus.api.jobmanager.store.JobStore;
import com.netflix.titus.common.model.admission.AdmissionSanitizer;
import com.netflix.titus.common.model.admission.AdmissionValidator;
import com.netflix.titus.common.model.admission.TitusValidatorConfiguration;
import com.netflix.titus.gateway.endpoint.v3.grpc.TitusGatewayGrpcServer;
import com.netflix.titus.gateway.startup.TitusGatewayModule;
import com.netflix.titus.grpc.protogen.AutoScalingServiceGrpc;
import com.netflix.titus.grpc.protogen.EvictionServiceGrpc;
import com.netflix.titus.grpc.protogen.HealthGrpc;
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.grpc.protogen.v4.MachineServiceGrpc;
import com.netflix.titus.master.TitusMaster;
import com.netflix.titus.runtime.endpoint.admission.AggregatingSanitizer;
import com.netflix.titus.runtime.endpoint.admission.PassJobValidator;
import com.netflix.titus.runtime.endpoint.common.rest.EmbeddedJettyModule;
import com.netflix.titus.runtime.endpoint.metadata.V3HeaderInterceptor;
import com.netflix.titus.testkit.embedded.cell.master.EmbeddedTitusMaster;
import io.grpc.ManagedChannel;
import io.grpc.Metadata;
import io.grpc.netty.shaded.io.grpc.netty.NettyChannelBuilder;
import io.grpc.stub.AbstractStub;
import io.grpc.stub.MetadataUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import static com.netflix.titus.common.util.Evaluators.getOrDefault;
/**
* Run embedded version of TitusGateway.
*/
public class EmbeddedTitusGateway {
private static final Logger logger = LoggerFactory.getLogger(EmbeddedTitusGateway.class);
private final EmbeddedTitusMaster embeddedTitusMaster;
private final String masterGrpcHost;
private int masterGrpcPort;
private int masterHttpPort;
private int httpPort;
private final int grpcPort;
private final boolean enableREST;
private final JobStore store;
private final Properties properties;
private final DefaultSettableConfig config;
private final AdmissionValidator<JobDescriptor> validator;
private final AdmissionSanitizer<JobDescriptor> jobSanitizer;
private LifecycleInjector injector;
private ManagedChannel grpcChannel;
public EmbeddedTitusGateway(Builder builder) {
this.embeddedTitusMaster = builder.embeddedTitusMaster;
if (embeddedTitusMaster == null) {
this.masterGrpcHost = getOrDefault(builder.masterGrpcHost, "localhost");
this.masterGrpcPort = builder.masterGrpcPort;
this.masterHttpPort = builder.masterHttpPort;
} else {
this.masterGrpcHost = "localhost";
}
this.httpPort = builder.httpPort;
this.grpcPort = builder.grpcPort;
this.enableREST = builder.enableREST;
this.store = builder.store;
this.properties = builder.properties;
this.config = new DefaultSettableConfig();
this.config.setProperties(properties);
this.validator = builder.validator;
this.jobSanitizer = builder.jobSanitizer;
String resourceDir = TitusMaster.class.getClassLoader().getResource("static").toExternalForm();
Properties props = new Properties();
props.put("titusGateway.endpoint.grpc.port", grpcPort);
props.put("governator.jetty.embedded.webAppResourceBase", resourceDir);
props.put("titusMaster.job.configuration.defaultSecurityGroups", "sg-12345,sg-34567");
props.put("titusMaster.job.configuration.defaultIamRole", "iam-12345");
props.put("titusGateway.endpoint.grpc.loadbalancer.enabled", "true");
props.put("titus.connector.relocationService.enabled", "false");
config.setProperties(props);
}
public int getGrpcPort() {
Preconditions.checkNotNull(injector, "Gateway not started yet");
return injector.getInstance(TitusGatewayGrpcServer.class).getPort();
}
public EmbeddedTitusGateway boot() {
Stopwatch timer = Stopwatch.createStarted();
logger.info("Starting Titus Gateway");
injector = InjectorBuilder.fromModules(
newJettyModule(),
new ArchaiusModule() {
@Override
protected void configureArchaius() {
config.setProperty("titus.masterClient.masterIp", masterGrpcHost);
if (embeddedTitusMaster == null) {
config.setProperty("titus.masterClient.masterGrpcPort", masterGrpcPort);
config.setProperty("titus.masterClient.masterHttpPort", masterHttpPort);
} else {
// In the embedded mode, master cannot run jetty, so we set only GRPC port.
config.setProperty("titus.masterClient.masterGrpcPort", embeddedTitusMaster.getGrpcPort());
config.setProperty("titus.masterClient.masterHttpPort", "0");
}
bindApplicationConfigurationOverride().toInstance(config);
}
},
Modules.override(new TitusGatewayModule(enableREST)).with(new AbstractModule() {
@Override
protected void configure() {
if (store != null) {
bind(JobStore.class).toInstance(store);
}
bind(new TypeLiteral<AdmissionValidator<JobDescriptor>>() {
}).toInstance(validator);
}
@Provides
@Singleton
public AdmissionSanitizer<JobDescriptor> getJobSanitizer(TitusValidatorConfiguration configuration) {
return new AggregatingSanitizer(configuration, Collections.singletonList(jobSanitizer));
}
})
).createInjector();
logger.info("Embedded TitusGateway started in {}ms", timer.elapsed(TimeUnit.MILLISECONDS));
return this;
}
private Module newJettyModule() {
if (!enableREST) {
return Modules.EMPTY_MODULE;
}
return new EmbeddedJettyModule(httpPort);
}
public EmbeddedTitusGateway shutdown() {
if (injector != null) {
injector.close();
}
if (grpcChannel != null) {
grpcChannel.shutdownNow();
}
return this;
}
public HealthGrpc.HealthStub getHealthClient() {
HealthGrpc.HealthStub client = HealthGrpc.newStub(getOrCreateGrpcChannel());
return attachCallHeaders(client);
}
public SchedulerServiceGrpc.SchedulerServiceBlockingStub getV3BlockingSchedulerClient() {
SchedulerServiceGrpc.SchedulerServiceBlockingStub client = SchedulerServiceGrpc.newBlockingStub(getOrCreateGrpcChannel());
return attachCallHeaders(client);
}
public JobManagementServiceGrpc.JobManagementServiceStub getV3GrpcClient() {
JobManagementServiceGrpc.JobManagementServiceStub client = JobManagementServiceGrpc.newStub(getOrCreateGrpcChannel());
return attachCallHeaders(client);
}
public JobManagementServiceGrpc.JobManagementServiceBlockingStub getV3BlockingGrpcClient() {
JobManagementServiceGrpc.JobManagementServiceBlockingStub client = JobManagementServiceGrpc.newBlockingStub(getOrCreateGrpcChannel());
return attachCallHeaders(client);
}
public AutoScalingServiceGrpc.AutoScalingServiceStub getAutoScaleGrpcClient() {
AutoScalingServiceGrpc.AutoScalingServiceStub client = AutoScalingServiceGrpc.newStub(getOrCreateGrpcChannel());
return attachCallHeaders(client);
}
public LoadBalancerServiceGrpc.LoadBalancerServiceStub getLoadBalancerGrpcClient() {
LoadBalancerServiceGrpc.LoadBalancerServiceStub client = LoadBalancerServiceGrpc.newStub(getOrCreateGrpcChannel());
return attachCallHeaders(client);
}
public EvictionServiceGrpc.EvictionServiceBlockingStub getBlockingGrpcEvictionClient() {
return EvictionServiceGrpc.newBlockingStub(getOrCreateGrpcChannel());
}
public <I> I getInstance(Class<I> instanceType) {
return injector.getInstance(instanceType);
}
private ManagedChannel getOrCreateGrpcChannel() {
if (grpcChannel == null) {
this.grpcChannel = NettyChannelBuilder.forAddress("localhost", getGrpcPort())
.usePlaintext()
.maxInboundMetadataSize(65536)
.build();
}
return grpcChannel;
}
private <STUB extends AbstractStub<STUB>> STUB attachCallHeaders(STUB client) {
Metadata metadata = new Metadata();
metadata.put(V3HeaderInterceptor.CALLER_ID_KEY, "embeddedGatewayClient");
metadata.put(V3HeaderInterceptor.CALL_REASON_KEY, "test call");
metadata.put(V3HeaderInterceptor.DEBUG_KEY, "true");
return client.withInterceptors(MetadataUtils.newAttachHeadersInterceptor(metadata));
}
public Builder toBuilder() {
return aDefaultTitusGateway()
.withStore(store)
.withMasterEndpoint(masterGrpcHost, masterGrpcPort, masterHttpPort)
.withMaster(embeddedTitusMaster)
.withHttpPort(httpPort)
.withGrpcPort(grpcPort)
.withProperties(properties)
.withJobValidator(validator)
.withJobSanitizer(jobSanitizer);
}
public static Builder aDefaultTitusGateway() {
return new Builder()
.withProperty("titusGateway.endpoint.grpc.shutdownTimeoutMs", "0");
// TODO Uncomment when TitusGateway cache is enabled
// .withProperty("titus.connector.jobService.keepAliveReplicatedStreamEnabled", "true")
// .withProperty("titus.connector.jobService.keepAliveIntervalMs", "10")
// .withProperty("titusGateway.maxAcceptableCacheStalenessMs", "30000")
// .withProperty("titusGateway.queryFromCacheCallerId", ".*");
}
public static class Builder {
private String masterGrpcHost;
private int masterGrpcPort;
private int masterHttpPort;
private int grpcPort;
private int httpPort;
private boolean enableREST = true;
private JobStore store;
private Properties properties = new Properties();
private AdmissionValidator<JobDescriptor> validator = new PassJobValidator();
private AdmissionSanitizer<JobDescriptor> jobSanitizer = new PassJobValidator();
private EmbeddedTitusMaster embeddedTitusMaster;
public Builder withMasterEndpoint(String host, int grpcPort, int httpPort) {
this.masterGrpcHost = host;
this.masterGrpcPort = grpcPort;
this.masterHttpPort = httpPort;
return this;
}
public Builder withMaster(EmbeddedTitusMaster embeddedTitusMaster) {
this.embeddedTitusMaster = embeddedTitusMaster;
return this;
}
public Builder withGrpcPort(int grpcPort) {
this.grpcPort = grpcPort;
return this;
}
public Builder withHttpPort(int httpPort) {
this.httpPort = httpPort;
return this;
}
public Builder withEnableREST(boolean enableREST) {
this.enableREST = enableREST;
return this;
}
public Builder withStore(JobStore store) {
this.store = store;
return this;
}
public Builder withProperty(String name, String value) {
properties.put(name, value);
return this;
}
public Builder withProperties(Properties properties) {
this.properties.putAll(properties);
return this;
}
public Builder withJobValidator(AdmissionValidator<JobDescriptor> validator) {
this.validator = validator;
return this;
}
public Builder withJobSanitizer(AdmissionSanitizer<JobDescriptor> jobSanitizer) {
this.jobSanitizer = jobSanitizer;
return this;
}
public EmbeddedTitusGateway build() {
return new EmbeddedTitusGateway(this);
}
}
}
| 1,120 |
0 | Create_ds/titus-control-plane/titus-testkit/src/main/java/com/netflix/titus/testkit/embedded | Create_ds/titus-control-plane/titus-testkit/src/main/java/com/netflix/titus/testkit/embedded/federation/EmbeddedFederationTitusOperations.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.testkit.embedded.federation;
import com.netflix.titus.grpc.protogen.EvictionServiceGrpc;
import com.netflix.titus.grpc.protogen.HealthGrpc;
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.testkit.embedded.EmbeddedTitusOperations;
import com.netflix.titus.testkit.embedded.kube.EmbeddedKubeCluster;
class EmbeddedFederationTitusOperations implements EmbeddedTitusOperations {
private final EmbeddedTitusFederation federation;
private final EmbeddedKubeCluster kubeCluster;
EmbeddedFederationTitusOperations(EmbeddedTitusFederation federation) {
this.federation = federation;
// We assume, a single cloud simulator instance is shared between all cells.
EmbeddedTitusOperations titusOperations = this.federation.getCells().get(0).getTitusOperations();
this.kubeCluster = titusOperations.getKubeCluster();
}
@Override
public EmbeddedKubeCluster getKubeCluster() {
return kubeCluster;
}
@Override
public HealthGrpc.HealthStub getHealthClient() {
return federation.getHealthGrpcClient();
}
@Override
public SchedulerServiceGrpc.SchedulerServiceBlockingStub getV3BlockingSchedulerClient() {
return federation.getV3BlockingSchedulerClient();
}
@Override
public JobManagementServiceGrpc.JobManagementServiceStub getV3GrpcClient() {
return federation.getV3GrpcClient();
}
@Override
public JobManagementServiceGrpc.JobManagementServiceBlockingStub getV3BlockingGrpcClient() {
return federation.getV3BlockingGrpcClient();
}
@Override
public LoadBalancerServiceGrpc.LoadBalancerServiceStub getLoadBalancerGrpcClient() {
return federation.getLoadBalancerGrpcClient();
}
@Override
public EvictionServiceGrpc.EvictionServiceBlockingStub getBlockingGrpcEvictionClient() {
return federation.getBlockingGrpcEvictionClient();
}
}
| 1,121 |
0 | Create_ds/titus-control-plane/titus-testkit/src/main/java/com/netflix/titus/testkit/embedded | Create_ds/titus-control-plane/titus-testkit/src/main/java/com/netflix/titus/testkit/embedded/federation/EmbeddedTitusFederation.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.testkit.embedded.federation;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Properties;
import java.util.stream.Collectors;
import com.google.common.base.Preconditions;
import com.netflix.archaius.config.DefaultSettableConfig;
import com.netflix.archaius.guice.ArchaiusModule;
import com.netflix.governator.InjectorBuilder;
import com.netflix.governator.LifecycleInjector;
import com.netflix.titus.federation.endpoint.grpc.TitusFederationGrpcServer;
import com.netflix.titus.federation.startup.TitusFederationModule;
import com.netflix.titus.grpc.protogen.AutoScalingServiceGrpc;
import com.netflix.titus.grpc.protogen.EvictionServiceGrpc;
import com.netflix.titus.grpc.protogen.HealthGrpc;
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.master.TitusMaster;
import com.netflix.titus.runtime.endpoint.common.rest.EmbeddedJettyModule;
import com.netflix.titus.runtime.endpoint.metadata.V3HeaderInterceptor;
import com.netflix.titus.testkit.embedded.EmbeddedTitusOperations;
import com.netflix.titus.testkit.embedded.cell.EmbeddedTitusCell;
import io.grpc.ManagedChannel;
import io.grpc.ManagedChannelBuilder;
import io.grpc.Metadata;
import io.grpc.stub.AbstractStub;
import io.grpc.stub.MetadataUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
/**
* Run embedded version of TitusFederation.
*/
public class EmbeddedTitusFederation {
private static final Logger logger = LoggerFactory.getLogger(EmbeddedTitusFederation.class);
private final Map<String, CellInfo> cells;
private int httpPort;
private final int grpcPort;
private final Properties properties;
private final DefaultSettableConfig config;
private LifecycleInjector injector;
private ManagedChannel grpcChannel;
private final EmbeddedTitusOperations titusOperations;
public EmbeddedTitusFederation(Builder builder) {
this.cells = builder.cells;
this.httpPort = builder.httpPort;
this.grpcPort = builder.grpcPort;
this.properties = builder.properties;
this.config = new DefaultSettableConfig();
this.config.setProperties(properties);
String resourceDir = TitusMaster.class.getClassLoader().getResource("static").toExternalForm();
Properties props = new Properties();
if (!properties.containsKey("titus.federation.stack")) {
props.put("titus.federation.stack", "embedded");
}
props.put("titus.federation.endpoint.grpcPort", grpcPort);
props.put("titus.federation.routingRules", buildRoutingRules());
props.put("governator.jetty.embedded.webAppResourceBase", resourceDir);
config.setProperties(props);
this.titusOperations = new EmbeddedFederationTitusOperations(this);
}
public int getGrpcPort() {
Preconditions.checkNotNull(injector);
return injector.getInstance(TitusFederationGrpcServer.class).getGrpcPort();
}
private String buildCellString() {
StringBuilder sb = new StringBuilder();
cells.forEach((cellId, cellInfo) ->
sb.append(';').append(cellId).append("=localhost:").append(cellInfo.getCell().getGateway().getGrpcPort())
);
return sb.substring(1);
}
private String buildRoutingRules() {
StringBuilder sb = new StringBuilder();
cells.forEach((cellId, cellInfo) ->
sb.append(';').append(cellId).append('=').append(cellInfo.getRoutingRules())
);
return sb.substring(1);
}
public EmbeddedTitusFederation boot() {
logger.info("Starting Titus Federation");
injector = InjectorBuilder.fromModules(
new EmbeddedJettyModule(httpPort),
new ArchaiusModule() {
@Override
protected void configureArchaius() {
// We can set some properties only after the gateway is started.ł
config.setProperty("titus.federation.cells", buildCellString());
bindApplicationConfigurationOverride().toInstance(config);
}
},
new TitusFederationModule()
).createInjector();
return this;
}
public EmbeddedTitusFederation shutdown() {
if (injector != null) {
injector.close();
}
if (grpcChannel != null) {
grpcChannel.shutdownNow();
}
return this;
}
public EmbeddedTitusCell getCell(String cellId) {
return cells.get(cellId).getCell();
}
public List<EmbeddedTitusCell> getCells() {
return new ArrayList<>(cells.values().stream().map(CellInfo::getCell).collect(Collectors.toList()));
}
public EmbeddedTitusOperations getTitusOperations() {
return titusOperations;
}
public HealthGrpc.HealthStub getHealthGrpcClient() {
HealthGrpc.HealthStub client = HealthGrpc.newStub(getOrCreateGrpcChannel());
return attachCallHeaders(client);
}
public SchedulerServiceGrpc.SchedulerServiceBlockingStub getV3BlockingSchedulerClient() {
SchedulerServiceGrpc.SchedulerServiceBlockingStub client = SchedulerServiceGrpc.newBlockingStub(getOrCreateGrpcChannel());
return attachCallHeaders(client);
}
public JobManagementServiceGrpc.JobManagementServiceStub getV3GrpcClient() {
JobManagementServiceGrpc.JobManagementServiceStub client = JobManagementServiceGrpc.newStub(getOrCreateGrpcChannel());
return attachCallHeaders(client);
}
public JobManagementServiceGrpc.JobManagementServiceBlockingStub getV3BlockingGrpcClient() {
JobManagementServiceGrpc.JobManagementServiceBlockingStub client = JobManagementServiceGrpc.newBlockingStub(getOrCreateGrpcChannel());
return attachCallHeaders(client);
}
public AutoScalingServiceGrpc.AutoScalingServiceStub getAutoScaleGrpcClient() {
AutoScalingServiceGrpc.AutoScalingServiceStub client = AutoScalingServiceGrpc.newStub(getOrCreateGrpcChannel());
return attachCallHeaders(client);
}
public LoadBalancerServiceGrpc.LoadBalancerServiceStub getLoadBalancerGrpcClient() {
LoadBalancerServiceGrpc.LoadBalancerServiceStub client = LoadBalancerServiceGrpc.newStub(getOrCreateGrpcChannel());
return attachCallHeaders(client);
}
public EvictionServiceGrpc.EvictionServiceBlockingStub getBlockingGrpcEvictionClient() {
return EvictionServiceGrpc.newBlockingStub(getOrCreateGrpcChannel());
}
private ManagedChannel getOrCreateGrpcChannel() {
if (grpcChannel == null) {
this.grpcChannel = ManagedChannelBuilder.forAddress("localhost", getGrpcPort())
.usePlaintext()
.build();
}
return grpcChannel;
}
private <STUB extends AbstractStub<STUB>> STUB attachCallHeaders(STUB client) {
Metadata metadata = new Metadata();
metadata.put(V3HeaderInterceptor.CALLER_ID_KEY, "embeddedFederationClient");
metadata.put(V3HeaderInterceptor.CALL_REASON_KEY, "test call");
metadata.put(V3HeaderInterceptor.DEBUG_KEY, "true");
return client.withInterceptors(MetadataUtils.newAttachHeadersInterceptor(metadata));
}
public Builder toBuilder() {
Builder builder = aDefaultTitusFederation()
.withHttpPort(httpPort)
.withGrpcPort(grpcPort)
.withProperties(properties);
cells.forEach((cellId, cellInfo) -> builder.withCell(cellInfo.getRoutingRules(), cellInfo.getCell()));
return builder;
}
public static Builder aDefaultTitusFederation() {
return new Builder()
.withProperty("titus.federation.endpoint.grpcServerShutdownTimeoutMs", "0");
}
public static class Builder {
private final Map<String, CellInfo> cells = new HashMap<>();
private int grpcPort;
private int httpPort;
private Properties properties = new Properties();
public Builder withCell(String routingRules, EmbeddedTitusCell cell) {
String cellId = cell.getMaster().getCellName();
cells.put(cellId, new CellInfo(cellId, routingRules, cell));
return this;
}
public Builder withHttpPort(int httpPort) {
this.httpPort = httpPort;
return this;
}
public Builder withGrpcPort(int grpcPort) {
this.grpcPort = grpcPort;
return this;
}
public Builder withProperty(String name, String value) {
properties.put(name, value);
return this;
}
public Builder withProperties(Properties properties) {
this.properties.putAll(properties);
return this;
}
public EmbeddedTitusFederation build() {
return new EmbeddedTitusFederation(this);
}
}
private static class CellInfo {
private final String cellId;
private final EmbeddedTitusCell cell;
private final String routingRules;
private CellInfo(String cellId, String routingRules, EmbeddedTitusCell cell) {
this.cellId = cellId;
this.cell = cell;
this.routingRules = routingRules;
}
private String getCellId() {
return cellId;
}
private String getRoutingRules() {
return routingRules;
}
private EmbeddedTitusCell getCell() {
return cell;
}
}
}
| 1,122 |
0 | Create_ds/titus-control-plane/titus-testkit/src/main/java/com/netflix/titus/testkit/embedded | Create_ds/titus-control-plane/titus-testkit/src/main/java/com/netflix/titus/testkit/embedded/kube/EmbeddedKubeClusters.java | /*
* Copyright 2021 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.testkit.embedded.kube;
import java.util.Set;
import com.netflix.titus.common.aws.AwsInstanceType;
import com.netflix.titus.common.util.CollectionsExt;
public class EmbeddedKubeClusters {
public static String SERVER_GROUP_CRITICAL = "critical1";
public static String SERVER_GROUP_ELASTIC = "flex1";
public static String SERVER_GROUP_GPU = "flexGpu";
public static String RESOURCE_POOL_ELASTIC = "elastic";
public static String RESOURCE_POOL_RESERVED = "reserved";
public static String RESOURCE_POOL_GPU = "gpu";
public static EmbeddedKubeCluster basicCluster(int desired) {
EmbeddedKubeCluster embedded = new EmbeddedKubeCluster();
embedded.addServerGroup(newReservedServerGroup(desired, AwsInstanceType.M3_XLARGE, null));
embedded.addServerGroup(newElasticServerGroup(desired, AwsInstanceType.M3_2XLARGE, null));
embedded.addServerGroup(newGpuServerGroup(desired, AwsInstanceType.G2_2XLarge, null));
return embedded;
}
public static EmbeddedKubeCluster basicClusterWithCustomZones(int desired, String[] zones) {
Set<String> zoneSet = CollectionsExt.asSet(zones);
EmbeddedKubeCluster embedded = new EmbeddedKubeCluster();
embedded.addServerGroup(newReservedServerGroup(desired, AwsInstanceType.M3_XLARGE, zoneSet));
embedded.addServerGroup(newElasticServerGroup(desired, AwsInstanceType.M3_2XLARGE, zoneSet));
embedded.addServerGroup(newGpuServerGroup(desired, AwsInstanceType.G2_2XLarge, zoneSet));
return embedded;
}
public static EmbeddedKubeCluster basicClusterWithLargeInstances(int desired) {
EmbeddedKubeCluster embedded = new EmbeddedKubeCluster();
embedded.addServerGroup(newReservedServerGroup(desired, AwsInstanceType.M5_Metal, null));
embedded.addServerGroup(newElasticServerGroup(desired, AwsInstanceType.R5_Metal, null));
embedded.addServerGroup(newGpuServerGroup(desired, AwsInstanceType.P3_16XLarge, null));
return embedded;
}
private static EmbeddedServerGroup newReservedServerGroup(int desired, AwsInstanceType instanceType, Set<String> zones) {
return EmbeddedServerGroup.newBuilder()
.withName(SERVER_GROUP_CRITICAL)
.withInstanceType(instanceType.name())
.withResourcePool(RESOURCE_POOL_RESERVED)
.withSize(desired)
.withZones(zones)
.build();
}
private static EmbeddedServerGroup newElasticServerGroup(int desired, AwsInstanceType instanceType, Set<String> zones) {
return EmbeddedServerGroup.newBuilder()
.withName(SERVER_GROUP_ELASTIC)
.withInstanceType(instanceType.name())
.withResourcePool(RESOURCE_POOL_ELASTIC)
.withSize(desired)
.withZones(zones)
.build();
}
private static EmbeddedServerGroup newGpuServerGroup(int desired, AwsInstanceType instanceType, Set<String> zones) {
return EmbeddedServerGroup.newBuilder()
.withName(SERVER_GROUP_GPU)
.withInstanceType(instanceType.name())
.withResourcePool(RESOURCE_POOL_GPU)
.withSize(desired)
.withZones(zones)
.build();
}
}
| 1,123 |
0 | Create_ds/titus-control-plane/titus-testkit/src/main/java/com/netflix/titus/testkit/embedded | Create_ds/titus-control-plane/titus-testkit/src/main/java/com/netflix/titus/testkit/embedded/kube/EmbeddedKubeFleet.java | /*
* Copyright 2021 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.testkit.embedded.kube;
import java.util.HashMap;
import java.util.Map;
import java.util.UUID;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;
import java.util.stream.Collectors;
import com.google.common.base.Preconditions;
import com.netflix.titus.testkit.embedded.kube.event.EmbeddedKubeEvent;
import io.kubernetes.client.openapi.models.V1Pod;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import reactor.core.publisher.Flux;
import reactor.core.publisher.Sinks;
public class EmbeddedKubeFleet {
private static final Logger logger = LoggerFactory.getLogger(EmbeddedKubeFleet.class);
private final ConcurrentMap<String, EmbeddedServerGroup> serverGroups = new ConcurrentHashMap<>();
private final ConcurrentMap<String, EmbeddedKubeNode> nodes = new ConcurrentHashMap<>();
private final Sinks.Many<EmbeddedKubeEvent<EmbeddedKubeNode>> nodePublisher = Sinks.many().multicast().directAllOrNothing();
public Map<String, EmbeddedServerGroup> getServerGroups() {
return new HashMap<>(serverGroups);
}
public Map<String, EmbeddedKubeNode> getNodes() {
return new HashMap<>(nodes);
}
public synchronized void addServerGroup(EmbeddedServerGroup serverGroup) {
logger.info("Adding server group {}", serverGroup);
serverGroups.put(serverGroup.getName(), serverGroup);
for (int i = 0; i < serverGroup.getSize(); i++) {
addNodeToServerGroup(serverGroup.getName());
}
}
public synchronized EmbeddedKubeNode addNodeToServerGroup(String name) {
EmbeddedServerGroup serverGroup = Preconditions.checkNotNull(serverGroups.get(name), "Server group not found %s", name);
EmbeddedKubeNode newNode = EmbeddedKubeNode.newBuilder()
.withName(UUID.randomUUID().toString())
.withResourcePool(serverGroup.getResourcePool())
.withZone(findUnderProvisionedZone(serverGroup))
.withServerGroup(serverGroup)
.withIpAddress(EmbeddedKubeUtil.nextIpAddress())
.withNodeResources(serverGroup.getNodeResources())
.build();
logger.info("Adding node {}", newNode.toStringCompact());
nodes.put(newNode.getName(), newNode);
nodePublisher.tryEmitNext(EmbeddedKubeEvent.added(newNode));
return newNode;
}
private String findUnderProvisionedZone(EmbeddedServerGroup serverGroup) {
String minZone = null;
int minSize = Integer.MAX_VALUE;
for (String zone : serverGroup.getZones()) {
Map<String, EmbeddedKubeNode> nodes = getServerGroupNodesInZone(serverGroup, zone);
if (nodes.size() < minSize) {
minZone = zone;
minSize = nodes.size();
}
}
return Preconditions.checkNotNull(minZone);
}
private Map<String, EmbeddedKubeNode> getServerGroupNodesInZone(EmbeddedServerGroup serverGroup, String zoneId) {
return nodes.values().stream()
.filter(node -> node.getServerGroup().getName().equals(serverGroup.getName()))
.filter(node -> node.getZone().equals(zoneId))
.collect(Collectors.toMap(EmbeddedKubeNode::getName, n -> n));
}
public synchronized EmbeddedKubeNode addNode(EmbeddedKubeNode node) {
Preconditions.checkArgument(serverGroups.containsKey(node.getServerGroup().getName()), "Server group not found %s", node.getServerGroup().getName());
EmbeddedKubeNode previous = nodes.put(node.getName(), node);
if (previous != null) {
logger.info("Updating node {}", node.toStringCompact());
nodePublisher.tryEmitNext(EmbeddedKubeEvent.updated(node, previous));
} else {
logger.info("Adding node {}", node.toStringCompact());
nodePublisher.tryEmitNext(EmbeddedKubeEvent.added(node));
}
return node;
}
public synchronized boolean deleteNode(String name) {
EmbeddedKubeNode deleted = nodes.remove(name);
if (deleted == null) {
return false;
}
logger.info("Deleted node {}", name);
nodePublisher.tryEmitNext(EmbeddedKubeEvent.deleted(deleted));
return true;
}
public synchronized void assignPodToNode(V1Pod pod, EmbeddedKubeNode node) {
EmbeddedKubeNode current = Preconditions.checkNotNull(nodes.get(node.getName()), "Node %s not found", node.getName());
EmbeddedKubeNode updated = current.toBuilder()
.withPod(pod)
.build();
nodes.put(node.getName(), updated);
logger.info("Assign pod to a node: podI={}, nodeId={}, serverGroup={}", pod.getMetadata().getName(), node.getName(), node.getServerGroup().getName());
}
public void removePodFromNode(V1Pod pod) {
String nodeName = pod.getSpec().getNodeName();
EmbeddedKubeNode node = Preconditions.checkNotNull(
nodes.get(nodeName),
"Node not found: nodeName=%s, assignedToPod=%s", nodeName, pod.getMetadata().getName()
);
Map<String, V1Pod> assignedPods = new HashMap<>(node.getAssignedPods());
assignedPods.remove(pod.getMetadata().getName());
EmbeddedKubeNode updated = node.toBuilder().withAssignedPods(assignedPods).build();
nodes.put(node.getName(), updated);
logger.info("Removed pod from a node: podI={}, nodeId={}, serverGroup={}", pod.getMetadata().getName(), node.getName(), node.getServerGroup().getName());
}
public Flux<EmbeddedKubeEvent<EmbeddedKubeNode>> observeNodes() {
return nodePublisher.asFlux();
}
}
| 1,124 |
0 | Create_ds/titus-control-plane/titus-testkit/src/main/java/com/netflix/titus/testkit/embedded | Create_ds/titus-control-plane/titus-testkit/src/main/java/com/netflix/titus/testkit/embedded/kube/EmbeddedStdKubeApiFacade.java | /*
* Copyright 2021 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.testkit.embedded.kube;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.stream.Collectors;
import com.netflix.titus.runtime.connector.kubernetes.KubeApiException;
import com.netflix.titus.runtime.connector.kubernetes.std.StdKubeApiFacade;
import com.netflix.titus.testkit.embedded.kube.event.SharedInformerStub;
import io.kubernetes.client.informer.SharedIndexInformer;
import io.kubernetes.client.openapi.models.V1Node;
import io.kubernetes.client.openapi.models.V1PersistentVolume;
import io.kubernetes.client.openapi.models.V1PersistentVolumeClaim;
import io.kubernetes.client.openapi.models.V1Pod;
import reactor.core.publisher.Flux;
import reactor.core.publisher.Mono;
public class EmbeddedStdKubeApiFacade implements StdKubeApiFacade {
private final EmbeddedKubeCluster embeddedKubeCluster;
private final EmbeddedKubeFleet fleet;
public EmbeddedStdKubeApiFacade(EmbeddedKubeCluster embeddedKubeCluster) {
fleet = embeddedKubeCluster.getFleet();
this.embeddedKubeCluster = embeddedKubeCluster;
}
@Override
public void deleteNode(String nodeName) throws KubeApiException {
}
@Override
public SharedIndexInformer<V1Node> getNodeInformer() {
List<V1Node> snapshot = fleet.getNodes().values().stream().map(EmbeddedKubeNode::getV1Node).collect(Collectors.toList());
return new SharedInformerStub<>(snapshot, fleet.observeNodes().map(event -> event.map(EmbeddedKubeNode::getV1Node)));
}
@Override
public void createNamespacedPod(String namespace, V1Pod pod) throws KubeApiException {
embeddedKubeCluster.addPod(pod);
}
@Override
public Mono<V1Pod> createNamespacedPodAsync(String namespace, V1Pod pod) {
return Mono.fromRunnable(() -> {
embeddedKubeCluster.addPod(pod);
});
}
@Override
public void deleteNamespacedPod(String namespace, String podName) throws KubeApiException {
embeddedKubeCluster.deletePod(podName, 0);
}
@Override
public void deleteNamespacedPod(String namespace, String podName, int deleteGracePeriod) throws KubeApiException {
embeddedKubeCluster.deletePod(podName, deleteGracePeriod);
}
@Override
public SharedIndexInformer<V1Pod> getPodInformer() {
List<V1Pod> snapshot = new ArrayList<>(embeddedKubeCluster.getPods().values());
return new SharedInformerStub<>(snapshot, embeddedKubeCluster.observePods());
}
@Override
public void createPersistentVolume(V1PersistentVolume v1PersistentVolume) throws KubeApiException {
}
@Override
public void createNamespacedPersistentVolumeClaim(String namespace, V1PersistentVolumeClaim v1PersistentVolumeClaim) throws KubeApiException {
}
@Override
public void deleteNamespacedPersistentVolumeClaim(String namespace, String volumeClaimName) throws KubeApiException {
}
@Override
public void replacePersistentVolume(V1PersistentVolume persistentVolume) throws KubeApiException {
}
@Override
public void deletePersistentVolume(String volumeName) throws KubeApiException {
}
@Override
public SharedIndexInformer<V1PersistentVolume> getPersistentVolumeInformer() {
return new SharedInformerStub<>(Collections.emptyList(), Flux.never());
}
@Override
public SharedIndexInformer<V1PersistentVolumeClaim> getPersistentVolumeClaimInformer() {
return new SharedInformerStub<>(Collections.emptyList(), Flux.never());
}
}
| 1,125 |
0 | Create_ds/titus-control-plane/titus-testkit/src/main/java/com/netflix/titus/testkit/embedded | Create_ds/titus-control-plane/titus-testkit/src/main/java/com/netflix/titus/testkit/embedded/kube/EmbeddedServerGroup.java | /*
* Copyright 2021 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.testkit.embedded.kube;
import java.util.Objects;
import java.util.Set;
import com.google.common.base.Preconditions;
import com.netflix.titus.api.model.ResourceDimension;
import com.netflix.titus.common.aws.AwsInstanceType;
import com.netflix.titus.common.util.CollectionsExt;
public class EmbeddedServerGroup {
private final String name;
private final String instanceType;
private final Set<String> zones;
private final ResourceDimension nodeResources;
private final String resourcePool;
private final int size;
public EmbeddedServerGroup(String name,
String instanceType,
Set<String> zones,
ResourceDimension nodeResources,
String resourcePool,
int size) {
this.name = name;
this.instanceType = instanceType;
this.zones = zones;
this.nodeResources = nodeResources;
this.resourcePool = resourcePool;
this.size = size;
}
public String getName() {
return name;
}
public String getInstanceType() {
return instanceType;
}
public ResourceDimension getNodeResources() {
return nodeResources;
}
public String getResourcePool() {
return resourcePool;
}
public int getSize() {
return size;
}
public Set<String> getZones() {
return zones;
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
EmbeddedServerGroup that = (EmbeddedServerGroup) o;
return size == that.size && Objects.equals(name, that.name) && Objects.equals(instanceType, that.instanceType) && Objects.equals(nodeResources, that.nodeResources) && Objects.equals(resourcePool, that.resourcePool);
}
@Override
public int hashCode() {
return Objects.hash(name, instanceType, nodeResources, resourcePool, size);
}
@Override
public String toString() {
return "EmbeddedServerGroup{" +
"name='" + name + '\'' +
", instanceType='" + instanceType + '\'' +
", nodeResources=" + nodeResources +
", resourcePool='" + resourcePool + '\'' +
", size=" + size +
'}';
}
public static Builder newBuilder() {
return new Builder();
}
public static final class Builder {
private String name;
private String instanceType;
private ResourceDimension nodeResources;
private String resourcePool;
private int size;
private Set<String> zones;
private Builder() {
}
public Builder withName(String name) {
this.name = name;
return this;
}
public Builder withInstanceType(String instanceType) {
this.instanceType = instanceType;
return this;
}
public Builder withNodeResources(ResourceDimension nodeResources) {
this.nodeResources = nodeResources;
return this;
}
public Builder withResourcePool(String resourcePool) {
this.resourcePool = resourcePool;
return this;
}
public Builder withSize(int size) {
this.size = size;
return this;
}
public Builder withZones(Set<String> zones) {
this.zones = zones;
return this;
}
public EmbeddedServerGroup build() {
Preconditions.checkNotNull(name, "Name is null");
Preconditions.checkNotNull(instanceType, "Instance type is null");
if (zones == null) {
zones = CollectionsExt.asSet("zoneA", "zoneB", "zoneC");
}
if (nodeResources == null) {
AwsInstanceType awsInstanceType = AwsInstanceType.withName(instanceType);
nodeResources = ResourceDimension.newBuilder()
.withCpus(awsInstanceType.getDescriptor().getvCPUs())
.withGpu(awsInstanceType.getDescriptor().getvGPUs())
.withMemoryMB(awsInstanceType.getDescriptor().getMemoryGB() * 1024L)
.withDiskMB(awsInstanceType.getDescriptor().getStorageGB() * 1024L)
.withNetworkMbs(awsInstanceType.getDescriptor().getNetworkMbs())
.build();
}
return new EmbeddedServerGroup(name, instanceType, zones, nodeResources, resourcePool, size);
}
}
}
| 1,126 |
0 | Create_ds/titus-control-plane/titus-testkit/src/main/java/com/netflix/titus/testkit/embedded | Create_ds/titus-control-plane/titus-testkit/src/main/java/com/netflix/titus/testkit/embedded/kube/EmbeddedKubePod.java | /*
* Copyright 2021 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.testkit.embedded.kube;
import io.kubernetes.client.openapi.models.V1Pod;
import static com.netflix.titus.common.kube.Annotations.AnnotationKeyNetworkStaticIPAllocationUUID;
public class EmbeddedKubePod {
private final V1Pod pod;
public EmbeddedKubePod(V1Pod pod) {
this.pod = pod;
}
public V1Pod getV1Pod() {
return pod;
}
public String getNodeName() {
return pod.getSpec().getNodeName();
}
public String getStaticIpAllocation() {
return pod.getMetadata().getAnnotations().get(AnnotationKeyNetworkStaticIPAllocationUUID);
}
}
| 1,127 |
0 | Create_ds/titus-control-plane/titus-testkit/src/main/java/com/netflix/titus/testkit/embedded | Create_ds/titus-control-plane/titus-testkit/src/main/java/com/netflix/titus/testkit/embedded/kube/EmbeddedKubeScheduler.java | /*
* Copyright 2021 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.testkit.embedded.kube;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.Set;
import com.netflix.titus.api.model.ResourceDimension;
import com.netflix.titus.common.util.CollectionsExt;
import com.netflix.titus.common.util.StringExt;
import com.netflix.titus.master.model.ResourceDimensions;
import com.netflix.titus.runtime.kubernetes.KubeConstants;
import io.kubernetes.client.openapi.models.V1NodeSelector;
import io.kubernetes.client.openapi.models.V1NodeSelectorRequirement;
import io.kubernetes.client.openapi.models.V1NodeSelectorTerm;
import io.kubernetes.client.openapi.models.V1Pod;
class EmbeddedKubeScheduler {
private final EmbeddedKubeCluster embeddedKubeCluster;
EmbeddedKubeScheduler(EmbeddedKubeCluster embeddedKubeCluster) {
this.embeddedKubeCluster = embeddedKubeCluster;
}
void doSchedule() {
Map<String, V1Pod> pods = embeddedKubeCluster.getPods();
pods.forEach((name, pod) -> {
if (pod.getStatus() == null || pod.getStatus().getHostIP() == null) {
trySchedulePod(pod);
}
});
}
private void trySchedulePod(V1Pod pod) {
Set<String> zoneConstraints = getZonesOfPod(pod);
Map<String, EmbeddedKubeNode> nodes = getNodesOf(pod, zoneConstraints);
ResourceDimension podResources = EmbeddedKubeUtil.fromPodToResourceDimension(pod);
for (EmbeddedKubeNode node : nodes.values()) {
ResourceDimension unassignedResources = node.getUnassignedResources();
if (unassignedResources.equals(podResources) || ResourceDimensions.isBigger(unassignedResources, podResources)) {
embeddedKubeCluster.assignPodToNode(pod.getMetadata().getName(), node);
return;
}
}
}
private List<String> findNodeSelectorTerm(V1Pod pod, String key) {
if (pod.getSpec() == null
|| pod.getSpec().getAffinity() == null
|| pod.getSpec().getAffinity().getNodeAffinity() == null
|| pod.getSpec().getAffinity().getNodeAffinity().getRequiredDuringSchedulingIgnoredDuringExecution() == null) {
return null;
}
V1NodeSelector nodeSelector = pod.getSpec().getAffinity().getNodeAffinity().getRequiredDuringSchedulingIgnoredDuringExecution();
for (V1NodeSelectorTerm term : nodeSelector.getNodeSelectorTerms()) {
for (V1NodeSelectorRequirement matcher : term.getMatchExpressions()) {
if (matcher.getKey().equals(key)) {
return matcher.getValues();
}
}
}
return null;
}
public String getResourcePoolOfPod(V1Pod pod) {
List<String> nodeSelectorTerm = findNodeSelectorTerm(pod, KubeConstants.NODE_LABEL_RESOURCE_POOL);
return CollectionsExt.isNullOrEmpty(nodeSelectorTerm) ? "" : nodeSelectorTerm.get(0);
}
public Set<String> getZonesOfPod(V1Pod pod) {
List<String> zones = findNodeSelectorTerm(pod, KubeConstants.NODE_LABEL_ZONE);
return CollectionsExt.isNullOrEmpty(zones) ? Collections.emptySet() : new HashSet<>(zones);
}
private Map<String, EmbeddedKubeNode> getNodesOf(V1Pod pod, Set<String> zoneConstraints) {
String resourcePool = getResourcePoolOfPod(pod);
if (StringExt.isEmpty(resourcePool)) {
return Collections.emptyMap();
}
Map<String, EmbeddedKubeNode> poolNodes = new HashMap<>(embeddedKubeCluster.getFleet().getNodes());
poolNodes.values().removeIf(node -> !isInResourcePool(node, resourcePool) || !isInZone(node, zoneConstraints));
return poolNodes;
}
private boolean isInResourcePool(EmbeddedKubeNode node, String resourcePool) {
return Objects.equals(node.getResourcePool(), resourcePool);
}
private boolean isInZone(EmbeddedKubeNode node, Set<String> zoneConstraints) {
return zoneConstraints.isEmpty() || zoneConstraints.contains(node.getZone());
}
}
| 1,128 |
0 | Create_ds/titus-control-plane/titus-testkit/src/main/java/com/netflix/titus/testkit/embedded | Create_ds/titus-control-plane/titus-testkit/src/main/java/com/netflix/titus/testkit/embedded/kube/EmbeddedKubeNode.java | /*
* Copyright 2021 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.testkit.embedded.kube;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.Map;
import java.util.Objects;
import com.google.common.base.Preconditions;
import com.netflix.titus.api.model.ResourceDimension;
import com.netflix.titus.common.util.CollectionsExt;
import com.netflix.titus.master.model.ResourceDimensions;
import com.netflix.titus.runtime.kubernetes.KubeConstants;
import io.kubernetes.client.openapi.models.V1Node;
import io.kubernetes.client.openapi.models.V1NodeAddress;
import io.kubernetes.client.openapi.models.V1NodeStatus;
import io.kubernetes.client.openapi.models.V1ObjectMeta;
import io.kubernetes.client.openapi.models.V1Pod;
import static com.netflix.titus.testkit.embedded.kube.EmbeddedKubeUtil.fromPodToResourceDimension;
import static com.netflix.titus.testkit.embedded.kube.EmbeddedKubeUtil.fromResourceDimensionsToKubeQuantityMap;
public class EmbeddedKubeNode {
private final String name;
private final String resourcePool;
private final EmbeddedServerGroup serverGroup;
private final String zone;
private final boolean deployed;
private final String ipAddress;
private final ResourceDimension nodeResources;
private final ResourceDimension nodeUnassignedResources;
private final Map<String, V1Pod> assignedPods;
private final V1Node v1Node;
public EmbeddedKubeNode(String name,
String resourcePool,
EmbeddedServerGroup serverGroup,
String zone,
boolean deployed,
String ipAddress,
ResourceDimension nodeResources,
ResourceDimension nodeUnassignedResources,
Map<String, V1Pod> assignedPods) {
this.name = name;
this.resourcePool = resourcePool;
this.serverGroup = serverGroup;
this.zone = zone;
this.deployed = deployed;
this.ipAddress = ipAddress;
this.nodeResources = nodeResources;
this.nodeUnassignedResources = nodeUnassignedResources;
this.assignedPods = assignedPods;
Map<String, String> labels = new HashMap<>();
if (resourcePool != null) {
labels.put(KubeConstants.NODE_LABEL_RESOURCE_POOL, resourcePool);
}
this.v1Node = new V1Node()
.metadata(new V1ObjectMeta()
.name(name)
.annotations(CollectionsExt.asMap(
KubeConstants.NODE_LABEL_ZONE, zone
))
.labels(labels)
)
.status(new V1NodeStatus()
.allocatable(fromResourceDimensionsToKubeQuantityMap(nodeUnassignedResources))
.addresses(ipAddress == null
? Collections.emptyList()
: Collections.singletonList(new V1NodeAddress().address(ipAddress))
)
);
}
public String getName() {
return name;
}
public String getResourcePool() {
return resourcePool;
}
public EmbeddedServerGroup getServerGroup() {
return serverGroup;
}
public String getZone() {
return zone;
}
public boolean isDeployed() {
return deployed;
}
public String getIpAddress() {
return ipAddress;
}
public ResourceDimension getNodeResources() {
return nodeResources;
}
public ResourceDimension getUnassignedResources() {
return nodeUnassignedResources;
}
public Map<String, V1Pod> getAssignedPods() {
return assignedPods;
}
public V1Node getV1Node() {
return v1Node;
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
EmbeddedKubeNode that = (EmbeddedKubeNode) o;
return deployed == that.deployed && Objects.equals(name, that.name) && Objects.equals(resourcePool, that.resourcePool) && Objects.equals(serverGroup, that.serverGroup) && Objects.equals(ipAddress, that.ipAddress) && Objects.equals(nodeResources, that.nodeResources) && Objects.equals(nodeUnassignedResources, that.nodeUnassignedResources) && Objects.equals(assignedPods, that.assignedPods) && Objects.equals(v1Node, that.v1Node);
}
@Override
public int hashCode() {
return Objects.hash(name, resourcePool, serverGroup, deployed, ipAddress, nodeResources, nodeUnassignedResources, assignedPods, v1Node);
}
@Override
public String toString() {
return "EmbeddedKubeNode{" +
"name='" + name + '\'' +
", resourcePool='" + resourcePool + '\'' +
", serverGroup=" + serverGroup +
", deployed=" + deployed +
", ipAddress='" + ipAddress + '\'' +
", nodeResources=" + nodeResources +
", nodeUnassignedResources=" + nodeUnassignedResources +
", assignedPodsCount=" + assignedPods.size() +
", v1Node=" + v1Node +
'}';
}
public String toStringCompact() {
return "EmbeddedKubeNode{" +
"name='" + name + '\'' +
", resourcePool='" + resourcePool + '\'' +
", serverGroup=" + serverGroup.getName() +
", zone=" + zone +
", deployed=" + deployed +
", ipAddress='" + ipAddress + '\'' +
", nodeUnassignedResources=" + nodeUnassignedResources +
", assignedPodsCount=" + assignedPods.size() +
'}';
}
public Builder toBuilder() {
return newBuilder()
.withName(name)
.withResourcePool(resourcePool)
.withServerGroup(serverGroup)
.withZone(zone)
.withDeployed(deployed)
.withIpAddress(ipAddress)
.withNodeResources(nodeResources)
.withAssignedPods(assignedPods);
}
public static Builder newBuilder() {
return new Builder();
}
public static final class Builder {
private String name;
private EmbeddedServerGroup serverGroup;
private boolean deployed;
private String ipAddress;
private ResourceDimension nodeResources;
private Map<String, V1Pod> assignedPods = new HashMap<>();
private String resourcePool;
private String zone;
private Builder() {
}
public Builder withName(String name) {
this.name = name;
return this;
}
public Builder withResourcePool(String resourcePool) {
this.resourcePool = resourcePool;
return this;
}
public Builder withServerGroup(EmbeddedServerGroup serverGroup) {
this.serverGroup = serverGroup;
return this;
}
public Builder withZone(String zone) {
this.zone = zone;
return this;
}
public Builder withDeployed(boolean deployed) {
this.deployed = deployed;
return this;
}
public Builder withIpAddress(String ipAddress) {
this.ipAddress = ipAddress;
return this;
}
public Builder withNodeResources(ResourceDimension nodeResources) {
this.nodeResources = nodeResources;
return this;
}
public Builder withAssignedPods(Map<String, V1Pod> assignedPods) {
this.assignedPods = new HashMap<>(assignedPods);
return this;
}
public Builder withPod(V1Pod pod) {
assignedPods.put(pod.getMetadata().getName(), pod);
return this;
}
public EmbeddedKubeNode build() {
Preconditions.checkNotNull(name, "Node name not set");
Preconditions.checkNotNull(serverGroup, "Server group name not set");
Preconditions.checkNotNull(ipAddress, "Ip address not set");
Preconditions.checkNotNull(nodeResources, "Node resources not set");
if (zone == null) {
int zoneCount = serverGroup.getZones().size();
int idx = Math.min((int) Math.round(Math.random() * zoneCount), zoneCount - 1);
zone = new ArrayList<>(serverGroup.getZones()).get(idx);
}
return new EmbeddedKubeNode(name, resourcePool, serverGroup, zone, deployed, ipAddress, nodeResources, buildNodeUnassignedResources(), assignedPods);
}
private ResourceDimension buildNodeUnassignedResources() {
ResourceDimension podsTotal = ResourceDimension.empty();
for (V1Pod pod : assignedPods.values()) {
podsTotal = ResourceDimensions.add(podsTotal, fromPodToResourceDimension(pod));
}
return ResourceDimensions.subtractPositive(nodeResources, podsTotal);
}
}
}
| 1,129 |
0 | Create_ds/titus-control-plane/titus-testkit/src/main/java/com/netflix/titus/testkit/embedded | Create_ds/titus-control-plane/titus-testkit/src/main/java/com/netflix/titus/testkit/embedded/kube/EmbeddedKubeUtil.java | /*
* Copyright 2021 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.testkit.embedded.kube;
import java.util.HashMap;
import java.util.Map;
import com.google.gson.Gson;
import com.netflix.titus.api.jobmanager.model.job.TaskState;
import com.netflix.titus.api.model.ResourceDimension;
import com.netflix.titus.common.data.generator.MutableDataGenerator;
import com.netflix.titus.testkit.model.PrimitiveValueGenerators;
import io.kubernetes.client.custom.Quantity;
import io.kubernetes.client.openapi.models.V1Pod;
import static com.netflix.titus.master.kubernetes.pod.KubePodConstants.RESOURCE_CPU;
import static com.netflix.titus.master.kubernetes.pod.KubePodConstants.RESOURCE_EPHERMERAL_STORAGE;
import static com.netflix.titus.master.kubernetes.pod.KubePodConstants.RESOURCE_GPU;
import static com.netflix.titus.master.kubernetes.pod.KubePodConstants.RESOURCE_MEMORY;
import static com.netflix.titus.master.kubernetes.pod.KubePodConstants.RESOURCE_NETWORK;
public class EmbeddedKubeUtil {
private static final int ONE_MB = 1024 * 1024;
private static final int ONE_MBPS = 1_000_000;
private static final MutableDataGenerator<String> IP_ADDRESS_GENERATOR = new MutableDataGenerator<>(PrimitiveValueGenerators.ipv4CIDRs("10.0.0.0/24"));
public synchronized static String nextIpAddress() {
return IP_ADDRESS_GENERATOR.getValue();
}
public static ResourceDimension fromPodToResourceDimension(V1Pod pod) {
Map<String, Quantity> resources = pod.getSpec().getContainers().get(0).getResources().getRequests();
return ResourceDimension.newBuilder()
.withCpus(resources.get(RESOURCE_CPU).getNumber().doubleValue())
.withGpu(resources.get(RESOURCE_GPU).getNumber().longValue())
.withMemoryMB(resources.get(RESOURCE_MEMORY).getNumber().longValue() / ONE_MB)
.withDiskMB(resources.get(RESOURCE_EPHERMERAL_STORAGE).getNumber().longValue() / ONE_MB)
.withNetworkMbs(resources.get(RESOURCE_NETWORK).getNumber().longValue() / ONE_MBPS)
.build();
}
public static Map<String, Quantity> fromResourceDimensionsToKubeQuantityMap(ResourceDimension resources) {
Map<String, Quantity> quantityMap = new HashMap<>();
quantityMap.put(RESOURCE_CPU, new Quantity(String.valueOf(resources.getCpu())));
quantityMap.put(RESOURCE_GPU, new Quantity(String.valueOf(resources.getGpu())));
Quantity memory = new Quantity(resources.getMemoryMB() + "Mi");
Quantity disk = new Quantity(resources.getDiskMB() + "Mi");
Quantity network = new Quantity(resources.getNetworkMbs() + "M");
quantityMap.put(RESOURCE_MEMORY, memory);
quantityMap.put(RESOURCE_EPHERMERAL_STORAGE, disk);
quantityMap.put(RESOURCE_NETWORK, network);
return quantityMap;
}
public static TaskState getPodState(V1Pod pod) {
if (pod.getSpec().getNodeName() == null) {
return TaskState.Accepted;
}
if ("SCHEDULED".equals(pod.getStatus().getReason())) {
return TaskState.Launched;
}
if ("TASK_STARTING".equals(pod.getStatus().getReason())) {
return TaskState.StartInitiated;
}
if ("TASK_RUNNING".equals(pod.getStatus().getReason())) {
return TaskState.Started;
}
if (pod.getMetadata().getDeletionTimestamp() != null) {
return TaskState.KillInitiated;
}
return TaskState.Finished;
}
public static <T> T copy(T value) {
Gson gson = new Gson();
return (T) gson.fromJson(gson.toJson(value), value.getClass());
}
}
| 1,130 |
0 | Create_ds/titus-control-plane/titus-testkit/src/main/java/com/netflix/titus/testkit/embedded | Create_ds/titus-control-plane/titus-testkit/src/main/java/com/netflix/titus/testkit/embedded/kube/EmbeddedKubeModule.java | /*
* Copyright 2021 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.testkit.embedded.kube;
import javax.inject.Singleton;
import com.google.inject.AbstractModule;
import com.google.inject.Provides;
import com.netflix.archaius.ConfigProxyFactory;
import com.netflix.titus.master.jobmanager.service.ComputeProvider;
import com.netflix.titus.master.kubernetes.client.DefaultDirectKubeApiServerIntegrator;
import com.netflix.titus.master.kubernetes.client.DirectKubeApiServerIntegrator;
import com.netflix.titus.master.kubernetes.client.DirectKubeConfiguration;
import com.netflix.titus.runtime.connector.kubernetes.std.StdKubeApiFacade;
import io.fabric8.kubernetes.client.NamespacedKubernetesClient;
public class EmbeddedKubeModule extends AbstractModule {
private final EmbeddedKubeCluster embeddedKubeCluster;
public EmbeddedKubeModule(EmbeddedKubeCluster embeddedKubeCluster) {
this.embeddedKubeCluster = embeddedKubeCluster;
}
@Override
protected void configure() {
bind(StdKubeApiFacade.class).toInstance(embeddedKubeCluster.getKubeApiFacade());
bind(NamespacedKubernetesClient.class).toInstance(embeddedKubeCluster.getNamespacedKubernetesClient());
bind(DirectKubeApiServerIntegrator.class).to(DefaultDirectKubeApiServerIntegrator.class);
}
@Provides
@Singleton
public DirectKubeConfiguration getDirectKubeConfiguration(ConfigProxyFactory factory) {
return factory.newProxy(DirectKubeConfiguration.class);
}
@Provides
@Singleton
public ComputeProvider getComputeProvider(DirectKubeApiServerIntegrator integrator) {
return integrator;
}
}
| 1,131 |
0 | Create_ds/titus-control-plane/titus-testkit/src/main/java/com/netflix/titus/testkit/embedded | Create_ds/titus-control-plane/titus-testkit/src/main/java/com/netflix/titus/testkit/embedded/kube/EmbeddedKubeCluster.java | /*
* Copyright 2021 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.testkit.embedded.kube;
import java.time.OffsetDateTime;
import java.util.Collections;
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;
import java.util.stream.Collectors;
import com.google.common.base.Preconditions;
import com.netflix.titus.testkit.embedded.kube.event.EmbeddedKubeEvent;
import io.fabric8.kubernetes.client.NamespacedKubernetesClient;
import io.kubernetes.client.openapi.models.V1ContainerState;
import io.kubernetes.client.openapi.models.V1ContainerStateRunning;
import io.kubernetes.client.openapi.models.V1ContainerStateTerminated;
import io.kubernetes.client.openapi.models.V1ContainerStateWaiting;
import io.kubernetes.client.openapi.models.V1ContainerStatus;
import io.kubernetes.client.openapi.models.V1Pod;
import io.kubernetes.client.openapi.models.V1PodIP;
import io.kubernetes.client.openapi.models.V1PodStatus;
import org.mockito.Mockito;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import reactor.core.publisher.Flux;
import reactor.core.publisher.Sinks;
public class EmbeddedKubeCluster {
private static final Logger logger = LoggerFactory.getLogger(EmbeddedKubeCluster.class);
private final EmbeddedKubeFleet embeddedKubeFleet = new EmbeddedKubeFleet();
private final EmbeddedStdKubeApiFacade kubeIntegrator;
private final EmbeddedKubeScheduler kubeScheduler;
private final ConcurrentMap<String, EmbeddedKubePod> pods = new ConcurrentHashMap<>();
private final Sinks.Many<EmbeddedKubeEvent<V1Pod>> podPublisher = Sinks.many().multicast().directAllOrNothing();
private volatile boolean allowPodTermination;
public EmbeddedKubeCluster() {
this.kubeIntegrator = new EmbeddedStdKubeApiFacade(this);
this.kubeScheduler = new EmbeddedKubeScheduler(this);
}
public EmbeddedStdKubeApiFacade getKubeApiFacade() {
return kubeIntegrator;
}
public NamespacedKubernetesClient getNamespacedKubernetesClient() {
return Mockito.mock(NamespacedKubernetesClient.class);
}
public EmbeddedKubeFleet getFleet() {
return embeddedKubeFleet;
}
public void addServerGroup(EmbeddedServerGroup serverGroup) {
embeddedKubeFleet.addServerGroup(serverGroup);
}
public EmbeddedKubeNode addNodeToServerGroup(String serverGroupName) {
return embeddedKubeFleet.addNodeToServerGroup(serverGroupName);
}
public EmbeddedKubeNode addNode(EmbeddedKubeNode node) {
return embeddedKubeFleet.addNode(node);
}
public boolean deleteNode(String name) {
return embeddedKubeFleet.deleteNode(name);
}
public void addPod(V1Pod pod) {
String podName = pod.getMetadata().getName();
pod.status(new V1PodStatus().phase("PENDING"));
pod.getMetadata().creationTimestamp(OffsetDateTime.now());
EmbeddedKubePod embeddedPod = new EmbeddedKubePod(pod);
synchronized (pods) {
EmbeddedKubePod previous = pods.put(podName, embeddedPod);
if (previous == null) {
logger.info("Adding pod: {}", podName);
podPublisher.tryEmitNext(EmbeddedKubeEvent.added(pod));
} else {
logger.info("Updating pod: {}", podName);
podPublisher.tryEmitNext(EmbeddedKubeEvent.updated(pod, previous.getV1Pod()));
}
}
}
public void updatePod(V1Pod pod) {
String podName = pod.getMetadata().getName();
synchronized (pods) {
logger.info("Updating pod: {}", podName);
EmbeddedKubePod previous = Preconditions.checkNotNull(pods.get(podName));
pods.put(podName, new EmbeddedKubePod(pod));
podPublisher.tryEmitNext(EmbeddedKubeEvent.updated(pod, previous.getV1Pod()));
}
}
public boolean deletePod(String podName, long deleteGracePeriod) {
synchronized (pods) {
if (allowPodTermination && deleteGracePeriod <= 0) {
EmbeddedKubePod removed = pods.remove(podName);
if (removed == null) {
return false;
}
logger.info("Deleted pod: {}", podName);
podPublisher.tryEmitNext(EmbeddedKubeEvent.deleted(removed.getV1Pod()));
} else {
moveToKillInitiatedState(podName, deleteGracePeriod);
}
}
return true;
}
public Map<String, EmbeddedKubePod> getEmbeddedPods() {
return new HashMap<>(pods);
}
public Map<String, V1Pod> getPods() {
return pods.values().stream()
.map(EmbeddedKubePod::getV1Pod)
.collect(Collectors.toMap(p -> p.getMetadata().getName(), p -> p));
}
public String getPlacementZone(String podName) {
EmbeddedKubePod embeddedKubePod = pods.get(podName);
if (embeddedKubePod == null || embeddedKubePod.getNodeName() == null) {
return null;
}
return getFleet().getNodes().get(embeddedKubePod.getNodeName()).getZone();
}
public void schedule() {
kubeScheduler.doSchedule();
}
public void assignPodToNode(String podName, EmbeddedKubeNode node) {
synchronized (pods) {
EmbeddedKubePod embeddedKubePod = Preconditions.checkNotNull(pods.get(podName), "Pod not found: podName=%s", podName);
V1Pod pod = embeddedKubePod.getV1Pod();
embeddedKubeFleet.assignPodToNode(pod, node);
V1Pod updatedPod = EmbeddedKubeUtil.copy(pod);
updatedPod.getSpec()
.nodeName(node.getName());
updatedPod.getStatus()
.nominatedNodeName(node.getName())
.containerStatuses(Collections.singletonList(
new V1ContainerStatus().ready(true)
))
.phase("Pending")
.reason("SCHEDULED");
pods.put(podName, new EmbeddedKubePod(updatedPod));
logger.info("Pod assigned to a node: podName={}, nodeName={}, nodeZone={}", podName, node.getName(), node.getZone());
podPublisher.tryEmitNext(EmbeddedKubeEvent.updated(updatedPod, pod));
}
}
public void moveToStartInitiatedState(String podName) {
synchronized (pods) {
EmbeddedKubePod embeddedKubePod = Preconditions.checkNotNull(pods.get(podName), "Pod not found: podName=%s", podName);
Preconditions.checkNotNull(embeddedKubePod.getNodeName(), "Pod not assigned to any node: podName=%s", podName);
V1Pod pod = embeddedKubePod.getV1Pod();
if ("TASK_STARTING".equals(pod.getStatus().getReason())) {
return;
}
V1Pod updatedPod = EmbeddedKubeUtil.copy(pod);
String podIpAddress = EmbeddedKubeUtil.nextIpAddress();
updatedPod.getStatus()
.podIP(podIpAddress)
.podIPs(Collections.singletonList(new V1PodIP().ip(podIpAddress)))
.containerStatuses(Collections.singletonList(
new V1ContainerStatus()
.ready(true)
.state(new V1ContainerState().waiting(
new V1ContainerStateWaiting()
))
))
.phase("Pending")
.reason("TASK_STARTING");
pods.put(podName, new EmbeddedKubePod(updatedPod));
logger.info("Moved pod starting state: {}", podName);
podPublisher.tryEmitNext(EmbeddedKubeEvent.updated(updatedPod, pod));
}
}
public void moveToStartedState(String podName) {
synchronized (pods) {
EmbeddedKubePod embeddedKubePod = Preconditions.checkNotNull(pods.get(podName), "Pod not found: podName=%s", podName);
Preconditions.checkNotNull(embeddedKubePod.getNodeName(), "Pod not assigned to any node: podName=%s", podName);
V1Pod pod = embeddedKubePod.getV1Pod();
if ("TASK_RUNNING".equals(pod.getStatus().getReason())) {
return;
}
V1Pod updatedPod = EmbeddedKubeUtil.copy(pod);
updatedPod.getStatus()
.containerStatuses(Collections.singletonList(
new V1ContainerStatus()
.started(true)
.state(new V1ContainerState().running(
new V1ContainerStateRunning().startedAt(OffsetDateTime.now())
))
))
.phase("Running")
.reason("TASK_RUNNING");
pods.put(podName, new EmbeddedKubePod(updatedPod));
logger.info("Moved pod running state: {}", podName);
podPublisher.tryEmitNext(EmbeddedKubeEvent.updated(updatedPod, pod));
}
}
public void moveToKillInitiatedState(String podName, long deleteGracePeriodMs) {
synchronized (pods) {
EmbeddedKubePod embeddedKubePod = Preconditions.checkNotNull(pods.get(podName), "Pod not found: podName=%s", podName);
V1Pod pod = embeddedKubePod.getV1Pod();
V1Pod updatedPod = EmbeddedKubeUtil.copy(pod);
updatedPod.getMetadata()
.deletionGracePeriodSeconds(deleteGracePeriodMs / 1_000)
.deletionTimestamp(OffsetDateTime.now());
pods.put(podName, new EmbeddedKubePod(updatedPod));
logger.info("Moved pod killInitiated state: {}", podName);
podPublisher.tryEmitNext(EmbeddedKubeEvent.updated(updatedPod, pod));
}
}
public void moveToFinishedSuccess(String podName) {
moveToFinishedState(podName, true, "OK");
}
public void moveToFinishedFailed(String podName, String message) {
moveToFinishedState(podName, false, message);
}
private void moveToFinishedState(String podName, boolean succeeded, String message) {
synchronized (pods) {
EmbeddedKubePod embeddedKubePod = Preconditions.checkNotNull(pods.get(podName), "Pod not found: podName=%s", podName);
V1Pod pod = embeddedKubePod.getV1Pod();
V1Pod updatedPod = EmbeddedKubeUtil.copy(pod);
updatedPod.getStatus()
.containerStatuses(Collections.singletonList(
new V1ContainerStatus()
.started(true)
.state(new V1ContainerState().terminated(
new V1ContainerStateTerminated().finishedAt(OffsetDateTime.now())
))
));
if (!pod.getStatus().getPhase().equals("Running")) {
updatedPod.getStatus()
.phase("Failed")
.reason(message);
} else if (succeeded) {
updatedPod.getStatus()
.phase("Succeeded")
.reason(message);
} else {
updatedPod.getStatus()
.phase("Failed")
.reason(message);
}
pods.put(podName, new EmbeddedKubePod(updatedPod));
if (pod.getSpec().getNodeName() != null) {
embeddedKubeFleet.removePodFromNode(pod);
}
logger.info("Moved pod finished state: {}", podName);
podPublisher.tryEmitNext(EmbeddedKubeEvent.updated(updatedPod, pod));
}
}
public void removePod(String podName) {
pods.remove(podName);
}
public void allowPodTermination(boolean allow) {
this.allowPodTermination = allow;
}
public Flux<EmbeddedKubeEvent<V1Pod>> observePods() {
return podPublisher.asFlux();
}
}
| 1,132 |
0 | Create_ds/titus-control-plane/titus-testkit/src/main/java/com/netflix/titus/testkit/embedded/kube | Create_ds/titus-control-plane/titus-testkit/src/main/java/com/netflix/titus/testkit/embedded/kube/event/SharedInformerIndexer.java | /*
* Copyright 2021 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.testkit.embedded.kube.event;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentMap;
import java.util.function.Function;
import io.kubernetes.client.common.KubernetesObject;
import io.kubernetes.client.informer.cache.Indexer;
class SharedInformerIndexer<ApiType extends KubernetesObject> implements Indexer<ApiType> {
private final ConcurrentMap<String, ApiType> cache;
SharedInformerIndexer(ConcurrentMap<String, ApiType> cache) {
this.cache = cache;
}
@Override
public List<ApiType> index(String indexName, ApiType obj) {
throw new IllegalStateException("not implemented");
}
@Override
public List<String> indexKeys(String indexName, String indexKey) {
throw new IllegalStateException("not implemented");
}
@Override
public List<ApiType> byIndex(String indexName, String indexKey) {
throw new IllegalStateException("not implemented");
}
@Override
public Map<String, Function<ApiType, List<String>>> getIndexers() {
throw new IllegalStateException("not implemented");
}
@Override
public void addIndexers(Map<String, Function<ApiType, List<String>>> indexers) {
throw new IllegalStateException("not implemented");
}
@Override
public void add(ApiType obj) {
}
@Override
public void update(ApiType obj) {
}
@Override
public void delete(ApiType obj) {
}
@Override
public void replace(List<ApiType> list, String resourceVersion) {
throw new IllegalStateException("not implemented");
}
@Override
public void resync() {
}
@Override
public List<String> listKeys() {
return new ArrayList<>(cache.keySet());
}
@Override
public Object get(ApiType obj) {
return null;
}
@Override
public ApiType getByKey(String key) {
return null;
}
@Override
public List<ApiType> list() {
return new ArrayList<>(cache.values());
}
}
| 1,133 |
0 | Create_ds/titus-control-plane/titus-testkit/src/main/java/com/netflix/titus/testkit/embedded/kube | Create_ds/titus-control-plane/titus-testkit/src/main/java/com/netflix/titus/testkit/embedded/kube/event/EmbeddedKubeEvent.java | /*
* Copyright 2021 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.testkit.embedded.kube.event;
import java.util.function.Function;
public class EmbeddedKubeEvent<T> {
public enum Kind {
ADDED,
UPDATED,
DELETED
}
private final Kind kind;
private final T current;
private final T previous;
private EmbeddedKubeEvent(Kind kind, T current, T previous) {
this.kind = kind;
this.current = current;
this.previous = previous;
}
public Kind getKind() {
return kind;
}
public T getCurrent() {
return current;
}
public T getPrevious() {
return previous;
}
public <V> EmbeddedKubeEvent<V> map(Function<T, V> mapper) {
V currentMapped = mapper.apply(current);
V previousMapped = previous == null ? null : mapper.apply(previous);
return new EmbeddedKubeEvent<>(kind, currentMapped, previousMapped);
}
public static <T> EmbeddedKubeEvent<T> added(T current) {
return new EmbeddedKubeEvent<>(Kind.ADDED, current, null);
}
public static <T> EmbeddedKubeEvent<T> updated(T current, T previous) {
return new EmbeddedKubeEvent<>(Kind.UPDATED, current, previous);
}
public static <T> EmbeddedKubeEvent<T> deleted(T current) {
return new EmbeddedKubeEvent<>(Kind.DELETED, current, null);
}
}
| 1,134 |
0 | Create_ds/titus-control-plane/titus-testkit/src/main/java/com/netflix/titus/testkit/embedded/kube | Create_ds/titus-control-plane/titus-testkit/src/main/java/com/netflix/titus/testkit/embedded/kube/event/SharedInformerStub.java | /*
* Copyright 2021 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.testkit.embedded.kube.event;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;
import java.util.function.Function;
import io.kubernetes.client.common.KubernetesObject;
import io.kubernetes.client.informer.ResourceEventHandler;
import io.kubernetes.client.informer.SharedIndexInformer;
import io.kubernetes.client.informer.cache.Indexer;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import reactor.core.publisher.Flux;
public class SharedInformerStub<ApiType extends KubernetesObject> implements SharedIndexInformer<ApiType> {
private static final Logger logger = LoggerFactory.getLogger(SharedInformerStub.class);
private final Flux<EmbeddedKubeEvent<ApiType>> changes;
private final SharedInformerIndexer<ApiType> indexer;
private final ConcurrentMap<String, ApiType> cache = new ConcurrentHashMap<>();
public SharedInformerStub(List<ApiType> snapshot, Flux<EmbeddedKubeEvent<ApiType>> changes) {
this.changes = changes;
this.indexer = new SharedInformerIndexer<>(cache);
snapshot.forEach(v -> cache.put(v.getMetadata().getName(), v));
changes.subscribe(
next -> {
ApiType current = next.getCurrent();
String name = current.getMetadata().getName();
switch (next.getKind()) {
case ADDED:
cache.put(name, current);
indexer.add(current);
break;
case UPDATED:
cache.put(name, current);
indexer.update(current);
break;
case DELETED:
cache.remove(name);
indexer.delete(current);
break;
}
},
e -> logger.error("Shared informer cache updater error", e),
() -> logger.info("Shared informer cache updater completed")
);
}
@Override
public void addIndexers(Map<String, Function<ApiType, List<String>>> indexers) {
}
@Override
public Indexer<ApiType> getIndexer() {
return indexer;
}
@Override
public void addEventHandler(ResourceEventHandler<ApiType> handler) {
addEventHandlerWithResyncPeriod(handler, 0);
}
@Override
public void addEventHandlerWithResyncPeriod(ResourceEventHandler<ApiType> handler, long resyncPeriod) {
cache.forEach((id, value) -> handler.onAdd(value));
changes.subscribe(
next -> {
switch (next.getKind()) {
case ADDED:
handler.onAdd(next.getCurrent());
break;
case UPDATED:
handler.onUpdate(next.getPrevious(), next.getCurrent());
break;
case DELETED:
handler.onDelete(next.getCurrent(), false);
break;
}
},
e -> logger.error("SharedInformer error", e),
() -> logger.info("SharedInformer completed")
);
}
@Override
public void run() {
}
@Override
public void stop() {
}
@Override
public boolean hasSynced() {
return true;
}
@Override
public String lastSyncResourceVersion() {
return "1";
}
}
| 1,135 |
0 | Create_ds/titus-control-plane/titus-cli/src/main/java/com/netflix/titus | Create_ds/titus-control-plane/titus-cli/src/main/java/com/netflix/titus/cli/CLI.java | /*
* Copyright 2021 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.cli;
import java.io.PrintWriter;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashMap;
import java.util.Map;
import java.util.logging.Level;
import com.google.common.collect.ImmutableMap;
import com.google.common.collect.ImmutableSortedMap;
import com.netflix.titus.cli.command.HealthCommand;
import com.netflix.titus.cli.command.eviction.EvictionEventsCommand;
import com.netflix.titus.cli.command.job.JobGetCommand;
import com.netflix.titus.cli.command.job.JobInServiceCommand;
import com.netflix.titus.cli.command.job.JobKillCommand;
import com.netflix.titus.cli.command.job.JobProcessesCommand;
import com.netflix.titus.cli.command.job.JobResizeCommand;
import com.netflix.titus.cli.command.job.JobSubmitCommand;
import com.netflix.titus.cli.command.job.JobTemplateCommand;
import com.netflix.titus.cli.command.job.JobsGetCommand;
import com.netflix.titus.cli.command.job.KillTaskCommand;
import com.netflix.titus.cli.command.job.ObserveJobsCommand;
import com.netflix.titus.cli.command.job.TaskGetCommand;
import com.netflix.titus.cli.command.job.TasksGetCommand;
import com.netflix.titus.cli.command.job.unschedulable.PrintUnschedulableJobsCommand;
import com.netflix.titus.cli.command.job.unschedulable.RemoveUnschedulableJobsCommand;
import com.netflix.titus.cli.command.scheduler.ObserveSchedulingResultCommand;
import com.netflix.titus.cli.command.supervisor.SupervisorObserveEventsCommand;
import io.grpc.StatusRuntimeException;
import org.apache.commons.cli.CommandLine;
import org.apache.commons.cli.CommandLineParser;
import org.apache.commons.cli.DefaultParser;
import org.apache.commons.cli.HelpFormatter;
import org.apache.commons.cli.Option;
import org.apache.commons.cli.Options;
import org.apache.commons.cli.ParseException;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
/**
* Titus CLI client.
*/
public class CLI {
private static final Logger logger = LoggerFactory.getLogger(CLI.class);
static {
System.setProperty("org.slf4j.simpleLogger.defaultLogLevel", "error");
// GRPC is using netty logger, which makes a lot of noise
java.util.logging.Logger rootLog = java.util.logging.Logger.getLogger("");
rootLog.setLevel(Level.WARNING);
rootLog.getHandlers()[0].setLevel(Level.WARNING);
}
private static final Map<String, CliCommand> BUILTIN_COMMANDS = ImmutableMap.<String, CliCommand>builder()
.put("health", new HealthCommand())
// Job management
.put("submit", new JobSubmitCommand())
.put("jobTemplate", new JobTemplateCommand())
.put("findJobs", new JobsGetCommand())
.put("findJob", new JobGetCommand())
.put("findTasks", new TasksGetCommand())
.put("findTask", new TaskGetCommand())
.put("observeJobs", new ObserveJobsCommand())
.put("inService", new JobInServiceCommand())
.put("jobProcesses", new JobProcessesCommand())
.put("resizeJob", new JobResizeCommand())
.put("killJob", new JobKillCommand())
.put("killTask", new KillTaskCommand())
// Eviction
.put("evictionEvents", new EvictionEventsCommand())
// Scheduler
.put("schedulingResults", new ObserveSchedulingResultCommand())
// Supervisor
.put("supervisorEvents", new SupervisorObserveEventsCommand())
// Unschedulable jobs
.put("printUnschedulableJobs", new PrintUnschedulableJobsCommand())
.put("removeUnschedulableJobs", new RemoveUnschedulableJobsCommand())
.build();
private final boolean helpRequested;
private final String cmdName;
private final String[] args;
public CLI(String[] args) {
this.helpRequested = hasHelpOption(args);
if (helpRequested) {
this.cmdName = null;
this.args = args;
} else {
this.cmdName = takeCommand(args);
this.args = Arrays.copyOfRange(args, 1, args.length);
}
}
public void execute() {
if (helpRequested) {
printHelp();
return;
}
CliCommand cmdExec = findCommand();
CommandLine commandLine = parseOptions(cmdExec);
CommandContext context = createCommandContext(commandLine);
try {
cmdExec.execute(context);
} catch (Exception e) {
context.shutdown();
logger.error("Command execution failure", e);
if (e instanceof StatusRuntimeException) {
GrpcClientErrorUtils.printDetails((StatusRuntimeException) e);
}
}
}
protected CommandContext createCommandContext(CommandLine commandLine) {
return new CommandContext(commandLine);
}
protected Map<String, CliCommand> getCommandOverrides() {
return Collections.emptyMap();
}
private Map<String, CliCommand> getCommands() {
Map<String, CliCommand> merged = new HashMap<>(BUILTIN_COMMANDS);
merged.putAll(getCommandOverrides());
return ImmutableSortedMap.<String, CliCommand>naturalOrder().putAll(merged).build();
}
private boolean hasHelpOption(String[] args) {
for (String arg : args) {
if (arg.equals("-h") || arg.equals("--help")) {
return true;
}
}
return false;
}
private String takeCommand(String[] args) {
if (args.length == 0) {
printHelp();
throw new IllegalArgumentException("Command argument expected");
}
return args[0];
}
private void printHelp() {
PrintWriter writer = new PrintWriter(System.out);
HelpFormatter formatter = new HelpFormatter();
Options common = new Options();
appendDefaultOptions(common);
Options connectivity = new Options();
appendConnectivityOptions(connectivity);
writer.println("Usage: TitusCLI <cmd> -H <host> [-p <port>] [cmd options] [params]");
writer.println();
writer.println("Common options:");
formatter.printOptions(writer, 128, common, 4, 4);
writer.println();
writer.println("Connectivity options:");
formatter.printOptions(writer, 128, connectivity, 4, 4);
writer.println();
writer.println("Available commands:");
writer.println();
for (Map.Entry<String, CliCommand> entry : getCommands().entrySet()) {
CliCommand cliCmd = entry.getValue();
writer.println(entry.getKey() + " (" + cliCmd.getDescription() + ')');
formatter.printOptions(writer, 128, cliCmd.getOptions(), 4, 4);
}
writer.flush();
}
private CliCommand findCommand() {
CliCommand cmd = getCommands().get(cmdName);
if (cmd == null) {
throw new IllegalArgumentException("Unrecognized command " + cmdName);
}
return cmd;
}
private CommandLine parseOptions(CliCommand cmd) {
Options options = cmd.getOptions();
appendDefaultOptions(options);
if (cmd.isRemote()) {
appendConnectivityOptions(options);
}
CommandLineParser parser = new DefaultParser();
try {
return parser.parse(options, args);
} catch (ParseException e) {
throw new IllegalArgumentException(e.getMessage());
}
}
private void appendDefaultOptions(Options options) {
options.addOption(Option.builder("h").longOpt("help").desc("This help information").build());
options.addOption(Option.builder("r").longOpt("region").argName("name").hasArg()
.desc("Region (default us-east-1)").build());
}
private void appendConnectivityOptions(Options options) {
options.addOption(Option.builder("H").longOpt("host").hasArg().required().desc("Titus server host name").build());
options.addOption(Option.builder("p").longOpt("port").hasArg().type(Number.class).desc("Titus server GRPC port").build());
}
public static void main(String[] args) {
try {
new CLI(args).execute();
} catch (IllegalArgumentException e) {
System.err.println("ERROR: " + e.getMessage());
System.exit(-1);
}
}
}
| 1,136 |
0 | Create_ds/titus-control-plane/titus-cli/src/main/java/com/netflix/titus | Create_ds/titus-control-plane/titus-cli/src/main/java/com/netflix/titus/cli/GrpcClientErrorUtils.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.cli;
import com.google.protobuf.Any;
import com.google.protobuf.Descriptors;
import com.google.protobuf.InvalidProtocolBufferException;
import com.google.rpc.BadRequest;
import com.google.rpc.DebugInfo;
import com.netflix.titus.runtime.endpoint.metadata.V3HeaderInterceptor;
import io.grpc.Metadata;
import io.grpc.StatusRuntimeException;
import io.grpc.stub.AbstractStub;
import io.grpc.stub.MetadataUtils;
import static com.netflix.titus.runtime.common.grpc.GrpcClientErrorUtils.KEY_TITUS_ERROR_REPORT;
import static com.netflix.titus.runtime.common.grpc.GrpcClientErrorUtils.X_TITUS_ERROR;
import static com.netflix.titus.runtime.common.grpc.GrpcClientErrorUtils.X_TITUS_ERROR_BIN;
/**
* Titus GRPC error replies are based on Google RPC model: https://github.com/googleapis/googleapis/tree/master/google/rpc.
* Additional error context data is encoded in HTTP2 headers. A client is not required to understand and process the error
* context, but it will provide more insight into the cause of the error.
*/
public class GrpcClientErrorUtils {
public static <STUB extends AbstractStub<STUB>> STUB attachCallHeaders(STUB client) {
Metadata metadata = new Metadata();
metadata.put(V3HeaderInterceptor.CALLER_ID_KEY, "titusCLI");
metadata.put(V3HeaderInterceptor.CALL_REASON_KEY, "Titus operations request");
metadata.put(V3HeaderInterceptor.DEBUG_KEY, "true");
return client.withInterceptors(MetadataUtils.newAttachHeadersInterceptor(metadata));
}
public static void printDetails(StatusRuntimeException error) {
System.out.println("Error context:");
if (error.getTrailers() == null) {
System.out.println("no trailers");
return;
}
// ASCII encoded error message
String errorMessage = error.getTrailers().get(KEY_TITUS_ERROR_REPORT);
if (errorMessage == null) {
System.out.println("no context data available");
return;
}
System.out.printf("%s=%s\n", X_TITUS_ERROR, errorMessage);
// GRPC RPC 'Status'
System.out.println(X_TITUS_ERROR_BIN + ':');
com.netflix.titus.runtime.common.grpc.GrpcClientErrorUtils.getStatus(error).getDetailsList().forEach(GrpcClientErrorUtils::print);
}
private static void print(Any any) {
Descriptors.Descriptor descriptor = any.getDescriptorForType();
Descriptors.FieldDescriptor typeUrlField = descriptor.findFieldByName("type_url");
String typeUrl = (String) any.getField(typeUrlField);
Class type;
if (typeUrl.contains(DebugInfo.class.getSimpleName())) {
type = DebugInfo.class;
} else if (typeUrl.contains(BadRequest.class.getSimpleName())) {
type = BadRequest.class;
} else {
System.out.println("Unknown detail type " + typeUrl);
return;
}
try {
System.out.printf("Detail %s:\n", type);
System.out.println(any.unpack(type));
} catch (InvalidProtocolBufferException e) {
System.out.println("Something went wrong with detail parsing");
e.printStackTrace();
}
}
}
| 1,137 |
0 | Create_ds/titus-control-plane/titus-cli/src/main/java/com/netflix/titus | Create_ds/titus-control-plane/titus-cli/src/main/java/com/netflix/titus/cli/PrettyPrinters.java | /*
* Copyright 2021 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.cli;
import com.fasterxml.jackson.databind.JsonNode;
import com.google.protobuf.InvalidProtocolBufferException;
import com.google.protobuf.MessageOrBuilder;
import com.google.protobuf.util.JsonFormat;
import static com.netflix.titus.api.json.ObjectMappers.compactMapper;
public final class PrettyPrinters {
public static String print(MessageOrBuilder message) {
try {
return JsonFormat.printer().print(message);
} catch (InvalidProtocolBufferException e) {
throw new IllegalArgumentException("Protobuf to JSON formatting error", e);
}
}
public static String printCompact(MessageOrBuilder message) {
try {
JsonNode jsonNode = compactMapper().readTree(JsonFormat.printer().print(message));
return compactMapper().writeValueAsString(jsonNode);
} catch (Exception e) {
throw new IllegalArgumentException("Protobuf to JSON formatting error", e);
}
}
}
| 1,138 |
0 | Create_ds/titus-control-plane/titus-cli/src/main/java/com/netflix/titus | Create_ds/titus-control-plane/titus-cli/src/main/java/com/netflix/titus/cli/CliCommand.java | /*
* Copyright 2021 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.cli;
import org.apache.commons.cli.Options;
/**
*/
public interface CliCommand {
String getDescription();
boolean isRemote();
Options getOptions();
void execute(CommandContext context) throws Exception;
}
| 1,139 |
0 | Create_ds/titus-control-plane/titus-cli/src/main/java/com/netflix/titus | Create_ds/titus-control-plane/titus-cli/src/main/java/com/netflix/titus/cli/CommandContext.java | /*
* Copyright 2021 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.cli;
import java.time.Duration;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import com.netflix.titus.api.model.callmetadata.CallMetadata;
import com.netflix.titus.api.model.callmetadata.Caller;
import com.netflix.titus.common.runtime.TitusRuntime;
import com.netflix.titus.common.runtime.TitusRuntimes;
import com.netflix.titus.common.util.archaius2.Archaius2Ext;
import com.netflix.titus.common.util.grpc.reactor.GrpcToReactorClientFactory;
import com.netflix.titus.common.util.grpc.reactor.client.ReactorToGrpcClientBuilder;
import com.netflix.titus.grpc.protogen.JobManagementServiceGrpc;
import com.netflix.titus.grpc.protogen.SchedulerServiceGrpc;
import com.netflix.titus.runtime.connector.GrpcRequestConfiguration;
import com.netflix.titus.runtime.connector.jobmanager.JobConnectorConfiguration;
import com.netflix.titus.runtime.connector.jobmanager.ReactorJobManagementServiceStub;
import com.netflix.titus.runtime.connector.jobmanager.RemoteJobManagementClient;
import com.netflix.titus.runtime.connector.jobmanager.RemoteJobManagementClientWithKeepAlive;
import com.netflix.titus.runtime.endpoint.metadata.AnonymousCallMetadataResolver;
import com.netflix.titus.runtime.endpoint.metadata.CommonCallMetadataUtils;
import io.grpc.ManagedChannel;
import io.grpc.ManagedChannelBuilder;
import io.grpc.ServiceDescriptor;
import io.grpc.netty.shaded.io.grpc.netty.NettyChannelBuilder;
import io.grpc.stub.AbstractStub;
import org.apache.commons.cli.CommandLine;
import org.apache.commons.cli.ParseException;
/**
*
*/
public class CommandContext {
private static final int DEFAULT_PORT = 8980;
protected final TitusRuntime titusRuntime = TitusRuntimes.internal();
protected final CommandLine commandLine;
protected final String region;
protected final String host;
protected final int port;
protected final List<ManagedChannel> channels = new ArrayList<>();
public CommandContext(CommandLine commandLine) {
this.commandLine = commandLine;
this.region = commandLine.hasOption('r') ? commandLine.getOptionValue('r') : "us-east-1";
this.host = commandLine.getOptionValue('H');
this.port = resolvePort();
}
public CommandLine getCLI() {
return commandLine;
}
public TitusRuntime getTitusRuntime() {
return titusRuntime;
}
public String getRegion() {
return region;
}
public synchronized ManagedChannel createChannel() {
ManagedChannelBuilder channelBuilder = ManagedChannelBuilder.forAddress(host, port)
.usePlaintext();
if (channelBuilder instanceof NettyChannelBuilder) {
NettyChannelBuilder nettyChannelBuilder = (NettyChannelBuilder) channelBuilder;
nettyChannelBuilder.maxInboundMetadataSize(128 * 1024);
}
ManagedChannel channel = channelBuilder.build();
channels.add(channel);
return channel;
}
public CallMetadata getCallMetadata(String reason) {
return CallMetadata.newBuilder()
.withCallers(Collections.singletonList(Caller.newBuilder().withId("cli").build()))
.withCallReason(reason)
.build();
}
public GrpcToReactorClientFactory getGrpcToReactorClientFactory() {
return new GrpcToReactorClientFactory() {
@Override
public <GRPC_STUB extends AbstractStub<GRPC_STUB>, REACT_API> REACT_API apply(GRPC_STUB stub, Class<REACT_API> apiType, ServiceDescriptor serviceDescriptor) {
return ReactorToGrpcClientBuilder
.<REACT_API, GRPC_STUB, CallMetadata>newBuilder(
apiType, stub, serviceDescriptor, CallMetadata.class
)
.withGrpcStubDecorator(CommonCallMetadataUtils.newGrpcStubDecorator(AnonymousCallMetadataResolver.getInstance()))
.withTimeout(Duration.ofMillis(GrpcRequestConfiguration.DEFAULT_REQUEST_TIMEOUT_MS))
.withStreamingTimeout(Duration.ofMillis(GrpcRequestConfiguration.DEFAULT_STREAMING_TIMEOUT_MS))
.build();
}
};
}
public JobManagementServiceGrpc.JobManagementServiceStub getJobManagementGrpcStub() {
return JobManagementServiceGrpc.newStub(createChannel());
}
public JobManagementServiceGrpc.JobManagementServiceBlockingStub getJobManagementGrpcBlockingStub() {
return JobManagementServiceGrpc.newBlockingStub(createChannel());
}
public RemoteJobManagementClient getJobManagementClient() {
ReactorJobManagementServiceStub reactorStub = getGrpcToReactorClientFactory().apply(
getJobManagementGrpcStub(),
ReactorJobManagementServiceStub.class,
JobManagementServiceGrpc.getServiceDescriptor()
);
return new RemoteJobManagementClient("cli", reactorStub, titusRuntime);
}
public RemoteJobManagementClient getJobManagementClientWithKeepAlive(long keepAliveInternalMs) {
JobManagementServiceGrpc.JobManagementServiceStub stub = getJobManagementGrpcStub();
ReactorJobManagementServiceStub reactorStub = getGrpcToReactorClientFactory().apply(
stub,
ReactorJobManagementServiceStub.class,
JobManagementServiceGrpc.getServiceDescriptor()
);
JobConnectorConfiguration configuration = Archaius2Ext.newConfiguration(JobConnectorConfiguration.class,
"titus.connector.jobService.keepAliveIntervalMs", "" + keepAliveInternalMs
);
return new RemoteJobManagementClientWithKeepAlive("cli", configuration, stub, reactorStub, titusRuntime);
}
public SchedulerServiceGrpc.SchedulerServiceBlockingStub getSchedulerServiceBlockingStub() {
return SchedulerServiceGrpc.newBlockingStub(createChannel());
}
public void shutdown() {
channels.forEach(ManagedChannel::shutdown);
}
private int resolvePort() {
int port;
try {
port = commandLine.hasOption('p') ? ((Number) commandLine.getParsedOptionValue("p")).intValue() : DEFAULT_PORT;
} catch (ParseException e) {
throw new IllegalArgumentException("Invalid port number " + commandLine.getOptionValue("p"));
}
return port;
}
}
| 1,140 |
0 | Create_ds/titus-control-plane/titus-cli/src/main/java/com/netflix/titus/cli | Create_ds/titus-control-plane/titus-cli/src/main/java/com/netflix/titus/cli/command/HealthCommand.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.cli.command;
import com.netflix.titus.cli.CliCommand;
import com.netflix.titus.cli.CommandContext;
import com.netflix.titus.cli.PrettyPrinters;
import com.netflix.titus.grpc.protogen.HealthCheckRequest;
import com.netflix.titus.grpc.protogen.HealthCheckResponse;
import com.netflix.titus.grpc.protogen.HealthGrpc;
import org.apache.commons.cli.Options;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public class HealthCommand implements CliCommand {
private static final Logger logger = LoggerFactory.getLogger(HealthCommand.class);
@Override
public String getDescription() {
return "Get health status";
}
@Override
public boolean isRemote() {
return true;
}
@Override
public Options getOptions() {
return new Options();
}
@Override
public void execute(CommandContext context) {
HealthGrpc.HealthBlockingStub client = HealthGrpc.newBlockingStub(context.createChannel());
try {
HealthCheckResponse response = client.check(HealthCheckRequest.newBuilder().build());
logger.info(PrettyPrinters.print(response));
} catch (Exception e) {
ErrorReports.handleReplyError("Error querying status", e);
}
}
}
| 1,141 |
0 | Create_ds/titus-control-plane/titus-cli/src/main/java/com/netflix/titus/cli | Create_ds/titus-control-plane/titus-cli/src/main/java/com/netflix/titus/cli/command/ErrorReports.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.cli.command;
import com.netflix.titus.cli.GrpcClientErrorUtils;
import io.grpc.StatusRuntimeException;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public final class ErrorReports {
private static final Logger logger = LoggerFactory.getLogger(ErrorReports.class);
public static void handleReplyError(String message, Throwable e) {
logger.error(message + ": " + e.getMessage());
if (e instanceof StatusRuntimeException) {
GrpcClientErrorUtils.printDetails((StatusRuntimeException) e);
}
logger.info("stack trace", e);
}
}
| 1,142 |
0 | Create_ds/titus-control-plane/titus-cli/src/main/java/com/netflix/titus/cli/command | Create_ds/titus-control-plane/titus-cli/src/main/java/com/netflix/titus/cli/command/scheduler/ObserveSchedulingResultCommand.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.cli.command.scheduler;
import java.util.List;
import java.util.stream.Collectors;
import com.netflix.titus.grpc.protogen.SchedulerServiceGrpc;
import com.netflix.titus.grpc.protogen.SchedulingResultRequest;
import com.netflix.titus.cli.CliCommand;
import com.netflix.titus.cli.CommandContext;
import org.apache.commons.cli.Option;
import org.apache.commons.cli.Options;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
/**
*/
public class ObserveSchedulingResultCommand implements CliCommand {
private static final Logger logger = LoggerFactory.getLogger(ObserveSchedulingResultCommand.class);
@Override
public String getDescription() {
return "observe scheduler result for a task";
}
@Override
public boolean isRemote() {
return true;
}
@Override
public Options getOptions() {
Options options = new Options();
options.addOption(Option.builder("i").longOpt("task_id").hasArg().desc("Task id").build());
return options;
}
@Override
public void execute(CommandContext context) {
String taskId = context.getCLI().getOptionValue('i');
SchedulerServiceGrpc.newBlockingStub(context.createChannel()).observeSchedulingResults(
SchedulingResultRequest.newBuilder().setTaskId(taskId).build()
).forEachRemaining(event -> {
switch (event.getStatusCase()) {
case SUCCESS:
logger.info("Task scheduled: {}", event.getSuccess().getMessage());
break;
case FAILURES:
List<String> failures = event.getFailures().getFailuresList().stream()
.map(f -> String.format("%s (failureCount=%d): %s", f.getReason(), f.getFailureCount(), f.getAgentIdSamplesList()))
.collect(Collectors.toList());
logger.info("Failures: {}", failures);
break;
default:
logger.warn("Unexpected event: {}", event);
}
});
}
}
| 1,143 |
0 | Create_ds/titus-control-plane/titus-cli/src/main/java/com/netflix/titus/cli/command | Create_ds/titus-control-plane/titus-cli/src/main/java/com/netflix/titus/cli/command/job/JobTemplateCommand.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.cli.command.job;
import java.io.File;
import java.io.FileWriter;
import java.util.Collections;
import java.util.Map;
import com.google.protobuf.util.JsonFormat;
import com.netflix.titus.grpc.protogen.BatchJobSpec;
import com.netflix.titus.grpc.protogen.Capacity;
import com.netflix.titus.grpc.protogen.Constraints;
import com.netflix.titus.grpc.protogen.Container;
import com.netflix.titus.grpc.protogen.Image;
import com.netflix.titus.grpc.protogen.JobDescriptor;
import com.netflix.titus.grpc.protogen.JobDescriptor.JobSpecCase;
import com.netflix.titus.grpc.protogen.JobGroupInfo;
import com.netflix.titus.grpc.protogen.Owner;
import com.netflix.titus.grpc.protogen.RetryPolicy;
import com.netflix.titus.grpc.protogen.SecurityProfile;
import com.netflix.titus.grpc.protogen.ServiceJobSpec;
import com.netflix.titus.cli.CliCommand;
import com.netflix.titus.cli.CommandContext;
import org.apache.commons.cli.CommandLine;
import org.apache.commons.cli.Option;
import org.apache.commons.cli.Options;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import static com.netflix.titus.common.util.CollectionsExt.asMap;
import static java.util.Arrays.asList;
/**
* Write to file system job template.
*/
public class JobTemplateCommand implements CliCommand {
private static final Logger logger = LoggerFactory.getLogger(JobTemplateCommand.class);
@Override
public String getDescription() {
return "generate job template file";
}
@Override
public boolean isRemote() {
return false;
}
@Override
public Options getOptions() {
Options options = new Options();
options.addOption(Option.builder("t").longOpt("type").argName("name").hasArg()
.desc("Job type, one of {BATCH, SERVICE} (defaults to 'BATCH')").build());
options.addOption(Option.builder("f").longOpt("file").argName("file name").hasArg().required()
.desc("Template file name").build());
return options;
}
@Override
public void execute(CommandContext context) throws Exception {
CommandLine cli = context.getCLI();
JobSpecCase jobCase = JobSpecCase.BATCH;
if (cli.hasOption('t')) {
String jobType = cli.getOptionValue('t');
try {
jobCase = JobSpecCase.valueOf(jobType);
} catch (IllegalArgumentException e) {
logger.error("Unknown job type {}. Expected one of {}", jobType, asList(JobSpecCase.BATCH, JobSpecCase.SERVICE));
return;
}
}
File templateFile = new File(cli.getOptionValue('f'));
JobDescriptor jobDescriptor;
switch (jobCase) {
case SERVICE:
jobDescriptor = createServiceJobDescriptor();
break;
default:
jobDescriptor = createBatchJobDescriptor();
}
String formatted = JsonFormat.printer().print(jobDescriptor);
try (FileWriter fw = new FileWriter(templateFile)) {
fw.write(formatted);
}
logger.info("Generated template file in {}", templateFile.getAbsoluteFile());
}
private JobDescriptor createBatchJobDescriptor() {
Container container = createContainer()
.addAllEntryPoint(asList("echo", "\"Hello\""))
.build();
BatchJobSpec jobSpec = BatchJobSpec.newBuilder()
.setRuntimeLimitSec(180)
.setSize(1)
.setRetryPolicy(RetryPolicy.newBuilder().setDelayed(RetryPolicy.Delayed.newBuilder().setDelayMs(1000).setRetries(3)))
.build();
return JobDescriptor.newBuilder()
.setApplicationName("myBatchApp")
.setOwner(createUser())
.setCapacityGroup("batch_workloads")
.setContainer(container)
.putAllAttributes(createLabels())
.setJobGroupInfo(createJobGroupInfo())
.setBatch(jobSpec)
.build();
}
private JobDescriptor createServiceJobDescriptor() {
Container container = createContainer()
.addAllEntryPoint(asList("sleep", "30"))
.build();
ServiceJobSpec jobSpec = ServiceJobSpec.newBuilder()
.setCapacity(Capacity.newBuilder().setMin(1).setDesired(5).setMax(10).build())
.setEnabled(true)
.setRetryPolicy(RetryPolicy.newBuilder().setDelayed(RetryPolicy.Delayed.newBuilder().setDelayMs(1000).setRetries(3)))
.build();
return JobDescriptor.newBuilder()
.setApplicationName("myServiceApp")
.setOwner(createUser())
.setCapacityGroup("service_workloads")
.setContainer(container)
.putAllAttributes(createLabels())
.setJobGroupInfo(createJobGroupInfo())
.setService(jobSpec)
.build();
}
private Map<String, String> createLabels() {
return asMap("labelA", "valueA");
}
private JobGroupInfo.Builder createJobGroupInfo() {
return JobGroupInfo.newBuilder()
.setStack("myStack")
.setDetail("detail")
.setSequence("001");
}
private Container.Builder createContainer() {
return Container.newBuilder()
.setImage(Image.newBuilder().setName("trustybase").setTag("latest"))
.setResources(createResources())
.setSecurityProfile(createSecurityProfile())
.setSoftConstraints(createSoftConstraints())
.setHardConstraints(createHardConstraints())
.putAllEnv(Collections.singletonMap("MY_ENV", "myEnv"));
}
private com.netflix.titus.grpc.protogen.ContainerResources createResources() {
return com.netflix.titus.grpc.protogen.ContainerResources.newBuilder()
.setCpu(1)
.setMemoryMB(4096)
.setDiskMB(16384)
.setNetworkMbps(256)
.setAllocateIP(true)
.build();
}
private SecurityProfile createSecurityProfile() {
return SecurityProfile.newBuilder()
.addSecurityGroups("nf.datacenter").addSecurityGroups("nf.infrastructure")
.setIamRole("myapp-role")
.build();
}
private Owner.Builder createUser() {
return Owner.newBuilder().setTeamEmail("myteam@netflix.com");
}
private Constraints createHardConstraints() {
return Constraints.newBuilder().putConstraints("ZoneBalance", "true").build();
}
private Constraints createSoftConstraints() {
return Constraints.newBuilder().putConstraints("UniqueHost", "true").build();
}
}
| 1,144 |
0 | Create_ds/titus-control-plane/titus-cli/src/main/java/com/netflix/titus/cli/command | Create_ds/titus-control-plane/titus-cli/src/main/java/com/netflix/titus/cli/command/job/TaskGetCommand.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.cli.command.job;
import java.time.Duration;
import com.netflix.titus.api.jobmanager.model.job.Task;
import com.netflix.titus.cli.CliCommand;
import com.netflix.titus.cli.CommandContext;
import com.netflix.titus.cli.command.ErrorReports;
import org.apache.commons.cli.CommandLine;
import org.apache.commons.cli.Option;
import org.apache.commons.cli.Options;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public class TaskGetCommand implements CliCommand {
private static final Logger logger = LoggerFactory.getLogger(TaskGetCommand.class);
@Override
public String getDescription() {
return "find task by id";
}
@Override
public boolean isRemote() {
return true;
}
@Override
public Options getOptions() {
Options options = new Options();
options.addOption(Option.builder("i").longOpt("task_id").hasArg().required()
.desc("Task id").build());
return options;
}
@Override
public void execute(CommandContext context) throws Exception {
CommandLine cli = context.getCLI();
String id = cli.getOptionValue('i');
try {
Task task = context.getJobManagementClient().findTask(id).block(Duration.ofMinutes(1));
logger.info("Found task: " + task);
} catch (Exception e) {
ErrorReports.handleReplyError("Command execution error", e);
}
}
}
| 1,145 |
0 | Create_ds/titus-control-plane/titus-cli/src/main/java/com/netflix/titus/cli/command | Create_ds/titus-control-plane/titus-cli/src/main/java/com/netflix/titus/cli/command/job/KillTaskCommand.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.cli.command.job;
import java.time.Duration;
import com.netflix.titus.cli.CliCommand;
import com.netflix.titus.cli.CommandContext;
import com.netflix.titus.cli.command.ErrorReports;
import org.apache.commons.cli.CommandLine;
import org.apache.commons.cli.Option;
import org.apache.commons.cli.Options;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public class KillTaskCommand implements CliCommand {
private static final Logger logger = LoggerFactory.getLogger(KillTaskCommand.class);
@Override
public String getDescription() {
return "Kill a task";
}
@Override
public boolean isRemote() {
return true;
}
@Override
public Options getOptions() {
Options options = new Options();
options.addOption(Option.builder("i").longOpt("task_id").hasArg().required().desc("Task id").build());
options.addOption(Option.builder("s").longOpt("shrink").desc("Shrink job").build());
return options;
}
@Override
public void execute(CommandContext context) throws Exception {
CommandLine cli = context.getCLI();
String id = cli.getOptionValue('i');
boolean shrink = cli.hasOption('s');
try {
context.getJobManagementClient().killTask(id, shrink, context.getCallMetadata("Kill task command"))
.block(Duration.ofMinutes(1));
logger.info("Killed task {}", id);
} catch (Exception e) {
ErrorReports.handleReplyError("Command execution error", e);
}
}
}
| 1,146 |
0 | Create_ds/titus-control-plane/titus-cli/src/main/java/com/netflix/titus/cli/command | Create_ds/titus-control-plane/titus-cli/src/main/java/com/netflix/titus/cli/command/job/JobGetCommand.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.cli.command.job;
import java.time.Duration;
import java.util.concurrent.CountDownLatch;
import com.netflix.titus.api.jobmanager.model.job.Job;
import com.netflix.titus.cli.CliCommand;
import com.netflix.titus.cli.CommandContext;
import org.apache.commons.cli.CommandLine;
import org.apache.commons.cli.Option;
import org.apache.commons.cli.Options;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public class JobGetCommand implements CliCommand {
private static final Logger logger = LoggerFactory.getLogger(JobGetCommand.class);
@Override
public String getDescription() {
return "get for a given id";
}
@Override
public boolean isRemote() {
return true;
}
@Override
public Options getOptions() {
Options options = new Options();
options.addOption(Option.builder("i").longOpt("job_id").hasArg().required()
.desc("Job id").build());
options.addOption(Option.builder("m").longOpt("monitor").hasArg(false)
.desc("If set to true, connect to job update stream").build());
return options;
}
@Override
public void execute(CommandContext context) throws Exception {
CommandLine cli = context.getCLI();
String id = cli.getOptionValue('i');
if (!cli.hasOption('m')) {
getOneJob(context, id);
} else {
subscribeToJobUpdateStream(context, id);
}
}
private void getOneJob(CommandContext context, String id) {
Job<?> job = context.getJobManagementClient().findJob(id).block(Duration.ofSeconds(60));
logger.info("Found job: {}", job);
}
private void subscribeToJobUpdateStream(CommandContext context, String id) throws InterruptedException {
CountDownLatch latch = new CountDownLatch(1);
context.getJobManagementClient().observeJob(id)
.doFinally(signal -> latch.countDown())
.subscribe(
job -> logger.info("Job notification: {}", job),
e -> logger.error("Command execution error", e)
);
latch.await();
}
} | 1,147 |
0 | Create_ds/titus-control-plane/titus-cli/src/main/java/com/netflix/titus/cli/command | Create_ds/titus-control-plane/titus-cli/src/main/java/com/netflix/titus/cli/command/job/ObserveJobsCommand.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.cli.command.job;
import java.util.Collections;
import java.util.Iterator;
import java.util.Optional;
import java.util.Set;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicBoolean;
import com.google.common.base.Stopwatch;
import com.netflix.titus.api.jobmanager.model.job.Job;
import com.netflix.titus.api.jobmanager.model.job.Task;
import com.netflix.titus.api.jobmanager.model.job.event.JobKeepAliveEvent;
import com.netflix.titus.api.jobmanager.model.job.event.JobManagerEvent;
import com.netflix.titus.api.jobmanager.model.job.event.JobUpdateEvent;
import com.netflix.titus.api.jobmanager.model.job.event.TaskUpdateEvent;
import com.netflix.titus.common.util.StringExt;
import com.netflix.titus.common.util.event.EventPropagationTrace;
import com.netflix.titus.grpc.protogen.JobChangeNotification;
import com.netflix.titus.grpc.protogen.JobManagementServiceGrpc.JobManagementServiceBlockingStub;
import com.netflix.titus.grpc.protogen.ObserveJobsQuery;
import com.netflix.titus.runtime.connector.jobmanager.JobEventPropagationMetrics;
import com.netflix.titus.runtime.connector.jobmanager.RemoteJobManagementClient;
import com.netflix.titus.cli.CliCommand;
import com.netflix.titus.cli.CommandContext;
import com.netflix.titus.cli.command.ErrorReports;
import org.apache.commons.cli.Option;
import org.apache.commons.cli.Options;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import reactor.core.Disposable;
import reactor.core.publisher.Flux;
/**
*
*/
public class ObserveJobsCommand implements CliCommand {
private static final Logger logger = LoggerFactory.getLogger(ObserveJobsCommand.class);
@Override
public String getDescription() {
return "observe state changes of active job(s)";
}
@Override
public boolean isRemote() {
return true;
}
@Override
public Options getOptions() {
Options options = new Options();
options.addOption(Option.builder("i").longOpt("job-id").hasArg().desc("Job id").build());
options.addOption(Option.builder("j").longOpt("job-fields").hasArg().desc("Job fields").build());
options.addOption(Option.builder("t").longOpt("task-fields").hasArg().desc("Task fields").build());
options.addOption(Option.builder("s").longOpt("snapshot").desc("Fetch snapshot end exit").build());
options.addOption(Option.builder("l").longOpt("latency").desc("If set, print the propagation latency").build());
options.addOption(Option.builder("n").longOpt("no-event").desc("If set, do not print the events").build());
options.addOption(Option.builder("k").longOpt("keepalive").hasArg().desc("If set, use the keep alive enabled client with the configured interval").build());
return options;
}
@Override
public void execute(CommandContext context) throws Exception {
long keepAliveMs = context.getCLI().hasOption('k') ? Long.parseLong(context.getCLI().getOptionValue('k')) : -1;
RemoteJobManagementClient service = keepAliveMs > 0 ? context.getJobManagementClientWithKeepAlive(keepAliveMs) : context.getJobManagementClient();
Flux<JobManagerEvent<?>> events;
Set<String> jobFields = StringExt.splitByCommaIntoSet(context.getCLI().getOptionValue('j'));
Set<String> taskFields = StringExt.splitByCommaIntoSet(context.getCLI().getOptionValue('t'));
boolean printLatency = context.getCLI().hasOption('l');
boolean printEvents = !context.getCLI().hasOption('n');
boolean snapshotOnly = context.getCLI().hasOption('s');
JobEventPropagationMetrics metrics = JobEventPropagationMetrics.newExternalClientMetrics("cli", context.getTitusRuntime());
if (context.getCLI().hasOption('i')) {
String jobId = context.getCLI().getOptionValue('i');
events = service.observeJob(jobId);
} else if (jobFields.isEmpty() && taskFields.isEmpty()) {
events = service.observeJobs(Collections.emptyMap());
} else {
// Special case. Fields filtering cannot be used with RemoteJobManagementClient which converts data to
// the core model. We have to use GRPC directly.
executeWithFiltering(context, jobFields, taskFields, printEvents, snapshotOnly);
return;
}
while (true) {
logger.info("Establishing a new connection to the job event stream endpoint...");
executeOnce(events, metrics, printLatency, printEvents, snapshotOnly);
if (snapshotOnly) {
return;
}
}
}
private void executeOnce(Flux<JobManagerEvent<?>> events, JobEventPropagationMetrics metrics, boolean printLatency, boolean printEvents, boolean snapshotOnly) throws InterruptedException {
CountDownLatch latch = new CountDownLatch(1);
AtomicBoolean snapshotRead = new AtomicBoolean();
Stopwatch stopwatch = Stopwatch.createStarted();
Disposable disposable = events.subscribe(
next -> {
if (next == JobManagerEvent.snapshotMarker()) {
logger.info("Emitted: snapshot marker in {}ms", stopwatch.elapsed(TimeUnit.MILLISECONDS));
snapshotRead.set(true);
if (snapshotOnly) {
latch.countDown();
}
} else if (next instanceof JobUpdateEvent) {
Job<?> job = ((JobUpdateEvent) next).getCurrent();
if (printEvents) {
logger.info("Emitted job update: jobId={}({}), jobState={}, version={}",
job.getId(), next.isArchived() ? "archived" : job.getStatus().getState(), job.getStatus(), job.getVersion()
);
}
Optional<EventPropagationTrace> trace = metrics.recordJob(((JobUpdateEvent) next).getCurrent(), !snapshotRead.get());
if (printLatency) {
trace.ifPresent(t -> {
logger.info("Event propagation data: stages={}", t);
});
}
} else if (next instanceof TaskUpdateEvent) {
Task task = ((TaskUpdateEvent) next).getCurrent();
if (printEvents) {
logger.info("Emitted task update: jobId={}({}), taskId={}, taskState={}, version={}",
task.getJobId(), next.isArchived() ? "archived" : task.getStatus().getState(), task.getId(), task.getStatus(), task.getVersion()
);
}
Optional<EventPropagationTrace> trace = metrics.recordTask(((TaskUpdateEvent) next).getCurrent(), !snapshotRead.get());
if (printLatency) {
trace.ifPresent(t -> logger.info("Event propagation data: {}", t));
}
} else if (next instanceof JobKeepAliveEvent) {
if (printEvents) {
logger.info("Keep alive response: " + next);
}
} else {
logger.info("Unrecognized event type: {}", next);
}
},
e -> {
ErrorReports.handleReplyError("Error in the event stream", e);
latch.countDown();
},
() -> {
logger.info("Event stream closed");
latch.countDown();
}
);
latch.await();
disposable.dispose();
}
private void executeWithFiltering(CommandContext context, Set<String> jobFields, Set<String> taskFields, boolean printEvents, boolean snapshotOnly) {
JobManagementServiceBlockingStub stub = context.getJobManagementGrpcBlockingStub();
Stopwatch stopwatch = Stopwatch.createStarted();
ObserveJobsQuery query = ObserveJobsQuery.newBuilder().addAllJobFields(jobFields).addAllTaskFields(taskFields).build();
Iterator<JobChangeNotification> eventIt = stub.observeJobs(query);
while (eventIt.hasNext()) {
JobChangeNotification next = eventIt.next();
if (next.getNotificationCase() == JobChangeNotification.NotificationCase.SNAPSHOTEND) {
logger.info("Emitted: snapshot marker in {}ms", stopwatch.elapsed(TimeUnit.MILLISECONDS));
if (snapshotOnly) {
return;
}
} else if (next.getNotificationCase() == JobChangeNotification.NotificationCase.JOBUPDATE) {
com.netflix.titus.grpc.protogen.Job job = next.getJobUpdate().getJob();
if (printEvents) {
logger.info("Emitted job update: jobId={}({}), jobState={}, version={}",
job.getId(), next.getJobUpdate().getArchived() ? "archived" : job.getStatus().getState(), job.getStatus(), job.getVersion()
);
}
} else if (next.getNotificationCase() == JobChangeNotification.NotificationCase.TASKUPDATE) {
com.netflix.titus.grpc.protogen.Task task = next.getTaskUpdate().getTask();
if (printEvents) {
logger.info("Emitted task update: jobId={}({}), taskId={}, taskState={}, version={}",
task.getJobId(), next.getTaskUpdate().getArchived() ? "archived" : task.getStatus().getState(), task.getId(), task.getStatus(), task.getVersion()
);
}
} else {
logger.info("Unrecognized event type: {}", next);
}
}
}
}
| 1,148 |
0 | Create_ds/titus-control-plane/titus-cli/src/main/java/com/netflix/titus/cli/command | Create_ds/titus-control-plane/titus-cli/src/main/java/com/netflix/titus/cli/command/job/JobResizeCommand.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.cli.command.job;
import java.time.Duration;
import com.netflix.titus.api.jobmanager.model.job.Capacity;
import com.netflix.titus.cli.CliCommand;
import com.netflix.titus.cli.CommandContext;
import com.netflix.titus.cli.command.ErrorReports;
import org.apache.commons.cli.CommandLine;
import org.apache.commons.cli.Option;
import org.apache.commons.cli.Options;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public class JobResizeCommand implements CliCommand {
private static final Logger logger = LoggerFactory.getLogger(JobResizeCommand.class);
@Override
public String getDescription() {
return "change job size (min/desired/max)";
}
@Override
public boolean isRemote() {
return true;
}
@Override
public Options getOptions() {
Options options = new Options();
options.addOption(Option.builder("i").longOpt("job_id").hasArg().required()
.desc("Job id").build());
options.addOption(Option.builder("min").longOpt("min").hasArg(true).type(Number.class).required()
.desc("Job min size").build());
options.addOption(Option.builder("desired").longOpt("desired").hasArg(true).type(Number.class).required()
.desc("Job min size").build());
options.addOption(Option.builder("max").longOpt("max").hasArg(true).type(Number.class).required()
.desc("Job min size").build());
return options;
}
@Override
public void execute(CommandContext context) throws Exception {
CommandLine cli = context.getCLI();
String id = cli.getOptionValue('i');
int min = (int) (long) cli.getParsedOptionValue("min");
int desired = (int) (long) cli.getParsedOptionValue("desired");
int max = (int) (long) cli.getParsedOptionValue("max");
try {
context.getJobManagementClient().updateJobCapacity(id,
Capacity.newBuilder()
.withMin(min)
.withDesired(desired)
.withMax(max)
.build(),
context.getCallMetadata("Job resize command")
).block(Duration.ofMinutes(1));
} catch (Exception e) {
ErrorReports.handleReplyError("Error status", e);
}
}
}
| 1,149 |
0 | Create_ds/titus-control-plane/titus-cli/src/main/java/com/netflix/titus/cli/command | Create_ds/titus-control-plane/titus-cli/src/main/java/com/netflix/titus/cli/command/job/JobsGetCommand.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.cli.command.job;
import com.netflix.titus.cli.CliCommand;
import com.netflix.titus.cli.CommandContext;
import com.netflix.titus.cli.PrettyPrinters;
import com.netflix.titus.cli.command.ErrorReports;
import com.netflix.titus.common.util.StringExt;
import com.netflix.titus.grpc.protogen.JobQuery;
import com.netflix.titus.grpc.protogen.JobQueryResult;
import com.netflix.titus.grpc.protogen.Page;
import org.apache.commons.cli.CommandLine;
import org.apache.commons.cli.Option;
import org.apache.commons.cli.Options;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public class JobsGetCommand implements CliCommand {
private static final Logger logger = LoggerFactory.getLogger(JobsGetCommand.class);
@Override
public String getDescription() {
return "get jobs meeting search criteria";
}
@Override
public boolean isRemote() {
return true;
}
@Override
public Options getOptions() {
Options options = new Options();
options.addOption(Option.builder("a").longOpt("archived").hasArg(false)
.desc("If set, return also archived jobs").build());
options.addOption(Option.builder("t").longOpt("type")
.desc("Search by job type").build());
options.addOption(Option.builder("s").longOpt("page_size").hasArg().type(Number.class)
.desc("Maximum number of items to return").build());
options.addOption(Option.builder("n").longOpt("page_number").hasArg().type(Number.class)
.desc("Number of page to return starting from 0").build());
options.addOption(Option.builder("f").longOpt("fields").hasArg()
.desc("Comma separated list of fields to return").build());
return options;
}
@Override
public void execute(CommandContext context) throws Exception {
CommandLine cli = context.getCLI();
JobQuery.Builder queryBuilder = JobQuery.newBuilder();
if (cli.hasOption('a')) {
queryBuilder.putFilteringCriteria("archived", "true");
}
Page.Builder pageBuilder = Page.newBuilder();
if (cli.hasOption('s')) {
pageBuilder.setPageSize(((Number) cli.getParsedOptionValue("s")).intValue());
} else {
pageBuilder.setPageSize(100);
}
if (cli.hasOption('n')) {
pageBuilder.setPageNumber(((Number) cli.getParsedOptionValue("n")).intValue());
}
queryBuilder.setPage(pageBuilder);
if (cli.hasOption('f')) {
queryBuilder.addAllFields(StringExt.splitByComma(cli.getOptionValue('f')));
}
try {
JobQueryResult result = context.getJobManagementGrpcBlockingStub().findJobs(queryBuilder.build());
logger.info("Found jobs: " + PrettyPrinters.print(result));
} catch (Exception e) {
ErrorReports.handleReplyError("Command execution error", e);
}
}
}
| 1,150 |
0 | Create_ds/titus-control-plane/titus-cli/src/main/java/com/netflix/titus/cli/command | Create_ds/titus-control-plane/titus-cli/src/main/java/com/netflix/titus/cli/command/job/JobProcessesCommand.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.cli.command.job;
import java.time.Duration;
import com.netflix.titus.api.jobmanager.model.job.ServiceJobProcesses;
import com.netflix.titus.cli.CliCommand;
import com.netflix.titus.cli.CommandContext;
import com.netflix.titus.cli.command.ErrorReports;
import org.apache.commons.cli.CommandLine;
import org.apache.commons.cli.Option;
import org.apache.commons.cli.Options;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public class JobProcessesCommand implements CliCommand {
private static final Logger logger = LoggerFactory.getLogger(JobProcessesCommand.class);
@Override
public String getDescription() {
return "Enable or disable scaling processes on a Job";
}
@Override
public boolean isRemote() {
return true;
}
@Override
public Options getOptions() {
Options options = new Options();
options.addOption(Option.builder("i").longOpt("job_id").hasArg().required()
.desc("Job id").build());
options.addOption(Option.builder("up").longOpt("enable-increase").hasArg(true).required()
.desc("If set to true, enable scaling up the job").build());
options.addOption(Option.builder("down").longOpt("enable-decrease").hasArg(true).required()
.desc("If set to true, enable scaling down the job").build());
return options;
}
@Override
public void execute(CommandContext context) throws Exception {
CommandLine cli = context.getCLI();
String id = cli.getOptionValue('i');
boolean up = "true".equalsIgnoreCase(cli.getOptionValue("up"));
boolean down = "true".equalsIgnoreCase(cli.getOptionValue("down"));
try {
context.getJobManagementClient().updateJobProcesses(id,
ServiceJobProcesses.newBuilder()
.withDisableIncreaseDesired(!up)
.withDisableDecreaseDesired(!down)
.build(),
context.getCallMetadata("Job process command")
).block(Duration.ofMinutes(1));
} catch (Exception e) {
ErrorReports.handleReplyError("Error status", e);
}
}
}
| 1,151 |
0 | Create_ds/titus-control-plane/titus-cli/src/main/java/com/netflix/titus/cli/command | Create_ds/titus-control-plane/titus-cli/src/main/java/com/netflix/titus/cli/command/job/JobInServiceCommand.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.cli.command.job;
import java.time.Duration;
import com.netflix.titus.cli.CliCommand;
import com.netflix.titus.cli.CommandContext;
import com.netflix.titus.cli.command.ErrorReports;
import org.apache.commons.cli.CommandLine;
import org.apache.commons.cli.Option;
import org.apache.commons.cli.Options;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public class JobInServiceCommand implements CliCommand {
private static final Logger logger = LoggerFactory.getLogger(JobInServiceCommand.class);
@Override
public String getDescription() {
return "Enable or disable a service job";
}
@Override
public boolean isRemote() {
return true;
}
@Override
public Options getOptions() {
Options options = new Options();
options.addOption(Option.builder("i").longOpt("job_id").hasArg().required()
.desc("Job id").build());
options.addOption(Option.builder("e").longOpt("enable").hasArg(true).required()
.desc("If set to true, enable the job").build());
return options;
}
@Override
public void execute(CommandContext context) throws Exception {
CommandLine cli = context.getCLI();
String id = cli.getOptionValue('i');
boolean enable = "true".equalsIgnoreCase(cli.getOptionValue('e'));
try {
context.getJobManagementClient()
.updateJobStatus(id, enable, context.getCallMetadata("Change job status"))
.block(Duration.ofMinutes(1));
} catch (Exception e) {
ErrorReports.handleReplyError("Command execution error", e);
}
}
}
| 1,152 |
0 | Create_ds/titus-control-plane/titus-cli/src/main/java/com/netflix/titus/cli/command | Create_ds/titus-control-plane/titus-cli/src/main/java/com/netflix/titus/cli/command/job/JobUtil.java | /*
* Copyright 2021 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.cli.command.job;
import java.util.Collections;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import com.netflix.titus.api.jobmanager.model.job.Job;
import com.netflix.titus.api.jobmanager.model.job.JobState;
import com.netflix.titus.api.jobmanager.model.job.Task;
import com.netflix.titus.api.jobmanager.model.job.event.JobManagerEvent;
import com.netflix.titus.api.jobmanager.model.job.event.JobUpdateEvent;
import com.netflix.titus.api.jobmanager.model.job.event.TaskUpdateEvent;
import com.netflix.titus.cli.CommandContext;
import com.netflix.titus.common.util.tuple.Pair;
public class JobUtil {
public static Pair<Map<String, Job>, Map<String, Map<String, Task>>> loadActiveJobsAndTasks(CommandContext context) {
Map<String, Job> activeJobs = new HashMap<>();
Map<String, Map<String, Task>> activeTasks = new HashMap<>();
Iterator<JobManagerEvent<?>> it = context.getJobManagementClient().observeJobs(Collections.emptyMap())
.toIterable()
.iterator();
while (it.hasNext()) {
JobManagerEvent<?> event = it.next();
if (event instanceof JobUpdateEvent) {
JobUpdateEvent je = (JobUpdateEvent) event;
Job job = je.getCurrent();
if (job.getStatus().getState() == JobState.Accepted) {
activeJobs.put(job.getId(), job);
}
} else if (event instanceof TaskUpdateEvent) {
TaskUpdateEvent te = (TaskUpdateEvent) event;
Task task = te.getCurrent();
if (activeJobs.containsKey(task.getJobId())) {
activeTasks.computeIfAbsent(task.getJobId(), j -> new HashMap<>()).put(task.getId(), task);
}
} else if (event.equals(JobManagerEvent.snapshotMarker())) {
break;
}
}
return Pair.of(activeJobs, activeTasks);
}
}
| 1,153 |
0 | Create_ds/titus-control-plane/titus-cli/src/main/java/com/netflix/titus/cli/command | Create_ds/titus-control-plane/titus-cli/src/main/java/com/netflix/titus/cli/command/job/JobSubmitCommand.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.cli.command.job;
import java.io.File;
import java.io.FileReader;
import java.io.IOException;
import com.google.protobuf.util.JsonFormat;
import com.netflix.titus.cli.CliCommand;
import com.netflix.titus.cli.CommandContext;
import com.netflix.titus.cli.PrettyPrinters;
import com.netflix.titus.cli.command.ErrorReports;
import com.netflix.titus.grpc.protogen.JobDescriptor;
import com.netflix.titus.grpc.protogen.JobId;
import org.apache.commons.cli.Option;
import org.apache.commons.cli.Options;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
/**
*
*/
public class JobSubmitCommand implements CliCommand {
private static final Logger logger = LoggerFactory.getLogger(JobSubmitCommand.class);
@Override
public String getDescription() {
return "submit a new job";
}
@Override
public boolean isRemote() {
return true;
}
@Override
public Options getOptions() {
Options options = new Options();
options.addOption(Option.builder("f").longOpt("file").argName("file name").hasArg().required()
.desc("File with job data").build());
options.addOption(Option.builder("d").longOpt("display")
.desc("Display file content before sending it").build());
return options;
}
@Override
public void execute(CommandContext context) throws Exception {
JobDescriptor jobDescriptor = loadTemplate(context);
try {
JobId result = context.getJobManagementGrpcBlockingStub().createJob(jobDescriptor);
logger.info("Job submit succeeded: " + PrettyPrinters.print(result));
} catch (Exception e) {
ErrorReports.handleReplyError("Job submit error", e);
}
}
private JobDescriptor loadTemplate(CommandContext context) throws IOException {
File templateFile = new File(context.getCLI().getOptionValue('f'));
System.out.println("Submitting job from file " + templateFile);
JobDescriptor.Builder builder = JobDescriptor.newBuilder();
try (FileReader fr = new FileReader(templateFile)) {
JsonFormat.parser().merge(fr, builder);
}
JobDescriptor applicajobDescriptorionInfo = builder.build();
if (context.getCLI().hasOption('d')) {
System.out.println(JsonFormat.printer().print(applicajobDescriptorionInfo));
}
return applicajobDescriptorionInfo;
}
}
| 1,154 |
0 | Create_ds/titus-control-plane/titus-cli/src/main/java/com/netflix/titus/cli/command | Create_ds/titus-control-plane/titus-cli/src/main/java/com/netflix/titus/cli/command/job/TasksGetCommand.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.cli.command.job;
import com.netflix.titus.cli.CliCommand;
import com.netflix.titus.cli.CommandContext;
import com.netflix.titus.cli.PrettyPrinters;
import com.netflix.titus.cli.command.ErrorReports;
import com.netflix.titus.common.util.StringExt;
import com.netflix.titus.grpc.protogen.Page;
import com.netflix.titus.grpc.protogen.TaskQuery;
import com.netflix.titus.grpc.protogen.TaskQueryResult;
import org.apache.commons.cli.CommandLine;
import org.apache.commons.cli.Option;
import org.apache.commons.cli.Options;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
/**
*
*/
public class TasksGetCommand implements CliCommand {
private static final Logger logger = LoggerFactory.getLogger(TaskGetCommand.class);
@Override
public String getDescription() {
return "get task meeting search criteria";
}
@Override
public boolean isRemote() {
return true;
}
@Override
public Options getOptions() {
Options options = new Options();
options.addOption(Option.builder("t").longOpt("type")
.desc("Search by job type").build());
options.addOption(Option.builder("s").longOpt("page_size").hasArg().type(Number.class)
.desc("Maximum number of items to return").build());
options.addOption(Option.builder("n").longOpt("page_number").hasArg().type(Number.class)
.desc("Number of page to return starting from 0").build());
options.addOption(Option.builder("f").longOpt("fields").hasArg()
.desc("Comma separated list of fields to return").build());
return options;
}
@Override
public void execute(CommandContext context) throws Exception {
CommandLine cli = context.getCLI();
TaskQuery.Builder queryBuilder = TaskQuery.newBuilder();
Page.Builder pageBuilder = Page.newBuilder();
if (cli.hasOption('s')) {
pageBuilder.setPageSize(((Number) cli.getParsedOptionValue("s")).intValue());
} else {
pageBuilder.setPageSize(100);
}
if (cli.hasOption('n')) {
pageBuilder.setPageNumber(((Number) cli.getParsedOptionValue("n")).intValue());
}
queryBuilder.setPage(pageBuilder);
if (cli.hasOption('f')) {
queryBuilder.addAllFields(StringExt.splitByComma(cli.getOptionValue('f')));
}
try {
TaskQueryResult result = context.getJobManagementGrpcBlockingStub().findTasks(queryBuilder.build());
logger.info("Found tasks: " + PrettyPrinters.print(result));
} catch (Exception e) {
ErrorReports.handleReplyError("Command execution error", e);
}
}
}
| 1,155 |
0 | Create_ds/titus-control-plane/titus-cli/src/main/java/com/netflix/titus/cli/command | Create_ds/titus-control-plane/titus-cli/src/main/java/com/netflix/titus/cli/command/job/JobKillCommand.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.cli.command.job;
import java.time.Duration;
import com.netflix.titus.cli.CliCommand;
import com.netflix.titus.cli.CommandContext;
import com.netflix.titus.cli.command.ErrorReports;
import org.apache.commons.cli.CommandLine;
import org.apache.commons.cli.Option;
import org.apache.commons.cli.Options;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public class JobKillCommand implements CliCommand {
private static final Logger logger = LoggerFactory.getLogger(JobKillCommand.class);
@Override
public String getDescription() {
return "Kill job";
}
@Override
public boolean isRemote() {
return true;
}
@Override
public Options getOptions() {
Options options = new Options();
options.addOption(Option.builder("i").longOpt("job_id").hasArg().required()
.desc("Job id").build());
return options;
}
@Override
public void execute(CommandContext context) throws Exception {
CommandLine cli = context.getCLI();
String id = cli.getOptionValue('i');
try {
context.getJobManagementClient().killJob(id, context.getCallMetadata("Job kill command"))
.block(Duration.ofMinutes(1));
} catch (Exception e) {
ErrorReports.handleReplyError("Error querying status", e);
}
}
}
| 1,156 |
0 | Create_ds/titus-control-plane/titus-cli/src/main/java/com/netflix/titus/cli/command/job | Create_ds/titus-control-plane/titus-cli/src/main/java/com/netflix/titus/cli/command/job/unschedulable/RemoveUnschedulableJobsCommand.java | /*
* Copyright 2021 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.cli.command.job.unschedulable;
import java.time.Duration;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;
import com.netflix.titus.api.jobmanager.model.job.Job;
import com.netflix.titus.api.jobmanager.model.job.Task;
import com.netflix.titus.api.model.callmetadata.CallMetadata;
import com.netflix.titus.api.model.callmetadata.Caller;
import com.netflix.titus.api.model.callmetadata.CallerType;
import com.netflix.titus.cli.CliCommand;
import com.netflix.titus.cli.CommandContext;
import com.netflix.titus.common.util.Evaluators;
import com.netflix.titus.common.util.tuple.Pair;
import com.netflix.titus.common.util.unit.TimeUnitExt;
import com.netflix.titus.runtime.connector.jobmanager.RemoteJobManagementClient;
import org.apache.commons.cli.Option;
import org.apache.commons.cli.Options;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import static com.netflix.titus.cli.command.job.JobUtil.loadActiveJobsAndTasks;
public class RemoveUnschedulableJobsCommand implements CliCommand {
private static final Logger logger = LoggerFactory.getLogger(PrintUnschedulableJobsCommand.class);
@Override
public String getDescription() {
return "remove unschedulable jobs";
}
@Override
public boolean isRemote() {
return true;
}
@Override
public Options getOptions() {
Options options = new Options();
options.addOption(Option.builder("e").longOpt("expiry").hasArg().required()
.desc("Duration threshold after which a not scheduled task can be regarded as non-schedulable (8h, 5d, etc).").build());
options.addOption(Option.builder("l").longOpt("limit").hasArg().required()
.desc("Maximum number of jobs to remove").build());
return options;
}
@Override
public void execute(CommandContext context) throws Exception {
long stuckInAcceptedThresholdMs = TimeUnitExt.toMillis(context.getCLI().getOptionValue('e'))
.orElseThrow(() -> new IllegalArgumentException("Wrong expiry threshold"));
int limit = Integer.parseInt(context.getCLI().getOptionValue('l'));
Pair<Map<String, Job>, Map<String, Map<String, Task>>> all = loadActiveJobsAndTasks(context);
Map<String, Job> jobs = all.getLeft();
Map<String, UnschedulableJob> unschedulable = UnschedulableFinder.findUnschedulableJobs(context, all.getLeft(), all.getRight(), stuckInAcceptedThresholdMs);
logger.info("Found {} unschedulable jobs", unschedulable.size());
logger.info("Removing the oldest {}...", limit);
List<Job> orderedJobs = unschedulable.keySet().stream().map(jobs::get)
.sorted(Comparator.comparingLong(j -> j.getStatus().getTimestamp()))
.collect(Collectors.toList());
RemoteJobManagementClient jobClient = context.getJobManagementClient();
int len = Math.min(orderedJobs.size(), limit);
for (int i = 0; i < len; i++) {
Job jobToRemove = orderedJobs.get(i);
logger.info("Removing job {}...", jobToRemove);
CallMetadata callMetadata = CallMetadata.newBuilder()
.withCallReason(unschedulable.get(jobToRemove.getId()).getReason())
.withCallers(Collections.singletonList(
Caller.newBuilder()
.withId(Evaluators.getOrDefault(System.getenv("USER"), "titusCLI"))
.withCallerType(CallerType.User)
.build()
))
.build();
jobClient.killJob(jobToRemove.getId(), callMetadata).block(Duration.ofSeconds(60));
}
logger.info("Removed {} unschedulable jobs out of {} (left {})", len, unschedulable.size(), unschedulable.size() - len);
}
}
| 1,157 |
0 | Create_ds/titus-control-plane/titus-cli/src/main/java/com/netflix/titus/cli/command/job | Create_ds/titus-control-plane/titus-cli/src/main/java/com/netflix/titus/cli/command/job/unschedulable/UnschedulableJob.java | /*
* Copyright 2021 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.cli.command.job.unschedulable;
class UnschedulableJob {
private final String jobId;
private final String reason;
private final String failures;
public UnschedulableJob(String jobId, String reason, String failures) {
this.jobId = jobId;
this.reason = reason;
this.failures = failures;
}
public String getJobId() {
return jobId;
}
public String getReason() {
return reason;
}
public String getFailures() {
return failures;
}
@Override
public String toString() {
return "UnschedulableJob{" +
"jobId='" + jobId + '\'' +
", reason='" + reason + '\'' +
", failures='" + failures + '\'' +
'}';
}
}
| 1,158 |
0 | Create_ds/titus-control-plane/titus-cli/src/main/java/com/netflix/titus/cli/command/job | Create_ds/titus-control-plane/titus-cli/src/main/java/com/netflix/titus/cli/command/job/unschedulable/UnschedulableFinder.java | /*
* Copyright 2021 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.cli.command.job.unschedulable;
import java.util.HashMap;
import java.util.Map;
import java.util.Optional;
import com.google.protobuf.InvalidProtocolBufferException;
import com.google.protobuf.util.JsonFormat;
import com.netflix.titus.api.jobmanager.model.job.Job;
import com.netflix.titus.api.jobmanager.model.job.Task;
import com.netflix.titus.api.jobmanager.model.job.TaskState;
import com.netflix.titus.cli.CommandContext;
import com.netflix.titus.common.util.CollectionsExt;
import com.netflix.titus.common.util.DateTimeExt;
import com.netflix.titus.grpc.protogen.SchedulingResultEvent;
import com.netflix.titus.grpc.protogen.SchedulingResultRequest;
public class UnschedulableFinder {
static Map<String, UnschedulableJob> findUnschedulableJobs(CommandContext context,
Map<String, Job> jobs,
Map<String, Map<String, Task>> tasks,
long stuckInAcceptedThresholdMs) {
Map<String, UnschedulableJob> suspectedJobs = new HashMap<>();
tasks.forEach((jobId, jobTasks) ->
processJob(context, jobs.get(jobId), jobTasks, stuckInAcceptedThresholdMs).ifPresent(u -> suspectedJobs.put(jobId, u))
);
return suspectedJobs;
}
private static Optional<UnschedulableJob> processJob(CommandContext context, Job job, Map<String, Task> tasks, long stuckInAcceptedThresholdMs) {
if (tasks.isEmpty()) {
return Optional.empty();
}
boolean anyScheduled = tasks.values().stream().anyMatch(t -> t.getStatus().getState() != TaskState.Accepted);
if (anyScheduled) {
return Optional.empty();
}
// All tasks not scheduled yet. Check if all of them are in the Accepted state long enough to be regarded
// as not-schedulable.
long youngest = Long.MAX_VALUE;
long oldest = Long.MIN_VALUE;
for (Task task : tasks.values()) {
long acceptedTimestamp = task.getStatus().getTimestamp();
youngest = Math.min(youngest, acceptedTimestamp);
oldest = Math.max(oldest, acceptedTimestamp);
long waitTimeMs = System.currentTimeMillis() - acceptedTimestamp;
if (waitTimeMs < stuckInAcceptedThresholdMs) {
return Optional.empty();
}
}
// Fetch scheduling result for any task.
SchedulingResultEvent result = context.getSchedulerServiceBlockingStub().getSchedulingResult(SchedulingResultRequest.newBuilder()
.setTaskId(CollectionsExt.first(tasks.values()).getId())
.build()
);
// All tasks are in the Accepted state for more than stuckInAcceptedThreshold.
long now = System.currentTimeMillis();
String failures;
try {
failures = JsonFormat.printer().omittingInsignificantWhitespace().print(result);
} catch (InvalidProtocolBufferException e) {
failures = result.toString();
}
return Optional.of(new UnschedulableJob(
job.getId(),
String.format(
"All tasks are stuck in the 'Accepted' state for too long (between %s and %s). " +
"Most likely they do not fit into any available node resources.",
DateTimeExt.toTimeUnitString(now - oldest, 2),
DateTimeExt.toTimeUnitString(now - youngest, 2)
),
failures
));
}
}
| 1,159 |
0 | Create_ds/titus-control-plane/titus-cli/src/main/java/com/netflix/titus/cli/command/job | Create_ds/titus-control-plane/titus-cli/src/main/java/com/netflix/titus/cli/command/job/unschedulable/PrintUnschedulableJobsCommand.java | /*
* Copyright 2021 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.cli.command.job.unschedulable;
import java.util.Map;
import com.netflix.titus.api.jobmanager.model.job.Job;
import com.netflix.titus.api.jobmanager.model.job.Task;
import com.netflix.titus.cli.CliCommand;
import com.netflix.titus.cli.CommandContext;
import com.netflix.titus.common.util.tuple.Pair;
import com.netflix.titus.common.util.unit.TimeUnitExt;
import org.apache.commons.cli.Option;
import org.apache.commons.cli.Options;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import static com.netflix.titus.cli.command.job.JobUtil.loadActiveJobsAndTasks;
public class PrintUnschedulableJobsCommand implements CliCommand {
private static final Logger logger = LoggerFactory.getLogger(PrintUnschedulableJobsCommand.class);
@Override
public String getDescription() {
return "print all unschedulable jobs";
}
@Override
public boolean isRemote() {
return true;
}
@Override
public Options getOptions() {
Options options = new Options();
options.addOption(Option.builder("e").longOpt("expiry").hasArg().required()
.desc("Duration threshold after which a not scheduled task can be regarded as non-schedulable (8h, 5d, etc).").build());
return options;
}
@Override
public void execute(CommandContext context) throws Exception {
long stuckInAcceptedThresholdMs = TimeUnitExt.toMillis(context.getCLI().getOptionValue('e'))
.orElseThrow(() -> new IllegalArgumentException("Wrong expiry threshold"));
Pair<Map<String, Job>, Map<String, Map<String, Task>>> all = loadActiveJobsAndTasks(context);
Map<String, UnschedulableJob> unschedulable = UnschedulableFinder.findUnschedulableJobs(context, all.getLeft(), all.getRight(), stuckInAcceptedThresholdMs);
logger.info("Found {} unschedulable jobs", unschedulable.size());
unschedulable.forEach((jobId, info) -> {
logger.info(" {}: reason={}", jobId, info.getReason());
logger.info(" failures={}", info.getFailures());
});
}
} | 1,160 |
0 | Create_ds/titus-control-plane/titus-cli/src/main/java/com/netflix/titus/cli/command | Create_ds/titus-control-plane/titus-cli/src/main/java/com/netflix/titus/cli/command/supervisor/SupervisorObserveEventsCommand.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.cli.command.supervisor;
import com.google.protobuf.Empty;
import com.netflix.titus.cli.CliCommand;
import com.netflix.titus.cli.CommandContext;
import com.netflix.titus.cli.GrpcClientErrorUtils;
import com.netflix.titus.grpc.protogen.SupervisorServiceGrpc;
import com.netflix.titus.grpc.protogen.SupervisorServiceGrpc.SupervisorServiceBlockingStub;
import com.netflix.titus.master.supervisor.endpoint.grpc.SupervisorGrpcModelConverters;
import org.apache.commons.cli.Options;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
/**
*
*/
public class SupervisorObserveEventsCommand implements CliCommand {
private static final Logger logger = LoggerFactory.getLogger(SupervisorObserveEventsCommand.class);
@Override
public String getDescription() {
return "observe supervisor events";
}
@Override
public boolean isRemote() {
return true;
}
@Override
public Options getOptions() {
Options options = new Options();
return options;
}
@Override
public void execute(CommandContext context) {
SupervisorServiceBlockingStub stub = GrpcClientErrorUtils.attachCallHeaders(SupervisorServiceGrpc.newBlockingStub(context.createChannel()));
stub.observeEvents(Empty.getDefaultInstance())
.forEachRemaining(event -> {
switch (event.getEventCase()) {
case MASTERINSTANCEUPDATE:
logger.info("Add/updated: {}", SupervisorGrpcModelConverters.toCoreMasterInstance(event.getMasterInstanceUpdate().getInstance()));
break;
case MASTERINSTANCEREMOVED:
logger.info("Removed: {}", event.getMasterInstanceRemoved().getInstanceId());
break;
}
}
);
}
}
| 1,161 |
0 | Create_ds/titus-control-plane/titus-cli/src/main/java/com/netflix/titus/cli/command | Create_ds/titus-control-plane/titus-cli/src/main/java/com/netflix/titus/cli/command/eviction/EvictionEventsCommand.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.cli.command.eviction;
import java.util.Iterator;
import com.netflix.titus.grpc.protogen.EvictionServiceEvent;
import com.netflix.titus.grpc.protogen.EvictionServiceGrpc;
import com.netflix.titus.grpc.protogen.ObserverEventRequest;
import com.netflix.titus.cli.CliCommand;
import com.netflix.titus.cli.CommandContext;
import org.apache.commons.cli.Options;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public class EvictionEventsCommand implements CliCommand {
private static final Logger logger = LoggerFactory.getLogger(EvictionEventsCommand.class);
@Override
public String getDescription() {
return "observe eviction event stream";
}
@Override
public boolean isRemote() {
return true;
}
@Override
public Options getOptions() {
return new Options();
}
@Override
public void execute(CommandContext context) {
Iterator<EvictionServiceEvent> it = EvictionServiceGrpc.newBlockingStub(context.createChannel()).observeEvents(
ObserverEventRequest.newBuilder()
.setIncludeSnapshot(true)
.build()
);
while (it.hasNext()) {
logger.info("Emitted: {}", it.next());
}
}
}
| 1,162 |
0 | Create_ds/titus-control-plane/titus-client/src/test/java/com/netflix/titus/runtime/endpoint/v3 | Create_ds/titus-control-plane/titus-client/src/test/java/com/netflix/titus/runtime/endpoint/v3/grpc/GrpcJobManagementModelConvertersTest.java | package com.netflix.titus.runtime.endpoint.v3.grpc;
import java.util.HashMap;
import java.util.Map;
import com.netflix.titus.grpc.protogen.LogLocation;
import com.netflix.titus.grpc.protogen.Task;
import org.junit.Test;
import static com.netflix.titus.api.jobmanager.TaskAttributes.TASK_ATTRIBUTES_RESUBMIT_NUMBER;
import static com.netflix.titus.api.jobmanager.TaskAttributes.TASK_ATTRIBUTES_TASK_ORIGINAL_ID;
import static com.netflix.titus.api.jobmanager.TaskAttributes.TASK_ATTRIBUTE_LOG_LIVE_STREAM;
import static com.netflix.titus.api.jobmanager.TaskAttributes.TASK_ATTRIBUTE_LOG_S3_ACCOUNT_ID;
import static com.netflix.titus.api.jobmanager.TaskAttributes.TASK_ATTRIBUTE_LOG_S3_ACCOUNT_NAME;
import static com.netflix.titus.api.jobmanager.TaskAttributes.TASK_ATTRIBUTE_LOG_S3_BUCKET_NAME;
import static com.netflix.titus.api.jobmanager.TaskAttributes.TASK_ATTRIBUTE_LOG_S3_KEY;
import static com.netflix.titus.api.jobmanager.TaskAttributes.TASK_ATTRIBUTE_LOG_S3_REGION;
import static com.netflix.titus.api.jobmanager.TaskAttributes.TASK_ATTRIBUTE_LOG_UI_LOCATION;
import static org.assertj.core.api.Assertions.assertThat;
public class GrpcJobManagementModelConvertersTest {
@Test
public void coreTaskLogAttributes() {
String taskId = "tid-1";
String uiLocation = "http://titus-ui/tasks/" + taskId;
String liveStream = "http://agentIp:8080/logs/" + taskId;
String s3Bucket = "bucket-1";
String s3Key = "key-1";
String s3AccountId = "acc-1";
String s3AccountName = "acc-name-1";
String s3Region = "us-east-1";
Map<String, String> taskContext = new HashMap<>();
taskContext.put(TASK_ATTRIBUTES_TASK_ORIGINAL_ID, taskId);
taskContext.put(TASK_ATTRIBUTES_RESUBMIT_NUMBER, "1");
Task grpcTask = Task.newBuilder()
.setId(taskId)
.putAllTaskContext(taskContext)
.setLogLocation(LogLocation.newBuilder()
.setUi(LogLocation.UI.newBuilder().setUrl(uiLocation))
.setLiveStream(LogLocation.LiveStream.newBuilder().setUrl(liveStream).build())
.setS3(LogLocation.S3.newBuilder()
.setRegion(s3Region)
.setBucket(s3Bucket)
.setKey(s3Key)
.setAccountId(s3AccountId)
.setAccountName(s3AccountName))
.build())
.build();
com.netflix.titus.api.jobmanager.model.job.Task coreTask = GrpcJobManagementModelConverters.toCoreTask(grpcTask);
assertThat(coreTask).isNotNull();
assertThat(coreTask.getAttributes()).hasSizeGreaterThan(0);
assertThat(coreTask.getAttributes().containsKey(TASK_ATTRIBUTE_LOG_S3_KEY)).isTrue();
assertThat(coreTask.getAttributes().get(TASK_ATTRIBUTE_LOG_S3_KEY)).isEqualTo(s3Key);
assertThat(coreTask.getAttributes().containsKey(TASK_ATTRIBUTE_LOG_S3_BUCKET_NAME)).isTrue();
assertThat(coreTask.getAttributes().get(TASK_ATTRIBUTE_LOG_S3_BUCKET_NAME)).isEqualTo(s3Bucket);
assertThat(coreTask.getAttributes().containsKey(TASK_ATTRIBUTE_LOG_S3_ACCOUNT_ID)).isTrue();
assertThat(coreTask.getAttributes().get(TASK_ATTRIBUTE_LOG_S3_ACCOUNT_ID)).isEqualTo(s3AccountId);
assertThat(coreTask.getAttributes().containsKey(TASK_ATTRIBUTE_LOG_S3_ACCOUNT_NAME)).isTrue();
assertThat(coreTask.getAttributes().get(TASK_ATTRIBUTE_LOG_S3_ACCOUNT_NAME)).isEqualTo(s3AccountName);
assertThat(coreTask.getAttributes().containsKey(TASK_ATTRIBUTE_LOG_S3_REGION)).isTrue();
assertThat(coreTask.getAttributes().get(TASK_ATTRIBUTE_LOG_S3_REGION)).isEqualTo(s3Region);
assertThat(coreTask.getAttributes().containsKey(TASK_ATTRIBUTE_LOG_UI_LOCATION)).isTrue();
assertThat(coreTask.getAttributes().get(TASK_ATTRIBUTE_LOG_UI_LOCATION)).isEqualTo(uiLocation);
assertThat(coreTask.getAttributes().containsKey(TASK_ATTRIBUTE_LOG_LIVE_STREAM)).isTrue();
assertThat(coreTask.getAttributes().get(TASK_ATTRIBUTE_LOG_LIVE_STREAM)).isEqualTo(liveStream);
}
} | 1,163 |
0 | Create_ds/titus-control-plane/titus-client/src/test/java/com/netflix/titus/runtime/endpoint/v3 | Create_ds/titus-control-plane/titus-client/src/test/java/com/netflix/titus/runtime/endpoint/v3/grpc/DefaultGrpcObjectsCacheTest.java | package com.netflix.titus.runtime.endpoint.v3.grpc;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;
import com.netflix.titus.api.jobmanager.model.job.Job;
import com.netflix.titus.api.jobmanager.model.job.LogStorageInfo;
import com.netflix.titus.api.jobmanager.model.job.Task;
import com.netflix.titus.api.jobmanager.service.V3JobOperations;
import com.netflix.titus.api.supervisor.service.LeaderActivator;
import com.netflix.titus.common.runtime.TitusRuntimes;
import com.netflix.titus.common.util.Evaluators;
import com.netflix.titus.common.util.tuple.Pair;
import com.netflix.titus.runtime.endpoint.common.EmptyLogStorageInfo;
import com.netflix.titus.testkit.model.job.JobGenerator;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import static com.jayway.awaitility.Awaitility.await;
import static org.assertj.core.api.AssertionsForClassTypes.assertThat;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
public class DefaultGrpcObjectsCacheTest {
private final GrpcObjectsCacheConfiguration configuration = mock(GrpcObjectsCacheConfiguration.class);
private final V3JobOperations v3JobOperations = mock(V3JobOperations.class);
private final LeaderActivator leaderActivator = mock(LeaderActivator.class);
private final LogStorageInfo<com.netflix.titus.api.jobmanager.model.job.Task> logStorageInfo = EmptyLogStorageInfo.empty();
private DefaultGrpcObjectsCache grpcObjectsCache;
private final SomeJobs someJobs = new SomeJobs();
@Before
public void setUp() {
when(configuration.getCacheRefreshInitialDelayMs()).thenReturn(1L);
when(configuration.getCacheRefreshIntervalMs()).thenReturn(1L);
when(configuration.getCacheCleanupDelayMs()).thenReturn(1L);
when(leaderActivator.isActivated()).thenReturn(true);
someJobs.addJob(2);
someJobs.addJob(5);
someJobs.addJob(10);
someJobs.addJob(20);
someJobs.addJob(50);
someJobs.resetMock();
}
private void setupGrpcObjectCache(boolean isEnabled) {
when(configuration.isGrpcObjectsCacheEnabled()).thenReturn(isEnabled);
grpcObjectsCache = new DefaultGrpcObjectsCache(v3JobOperations, configuration, logStorageInfo, leaderActivator, TitusRuntimes.internal());
grpcObjectsCache.activate();
}
@After
public void tearDown() {
Evaluators.acceptNotNull(grpcObjectsCache, DefaultGrpcObjectsCache::shutdown);
}
private void verifyTasksCacheBehavior(boolean isEnabled, int numCoreTasks) {
setupGrpcObjectCache(isEnabled);
List<Task> coreTasks = v3JobOperations.getTasks();
List<com.netflix.titus.grpc.protogen.Task> grpcTasks1 = coreTasks.stream().map(grpcObjectsCache::getTask).collect(Collectors.toList());
assertThat(grpcTasks1.size()).isEqualTo(coreTasks.size());
List<com.netflix.titus.grpc.protogen.Task> grpcTasks2 = coreTasks.stream().map(grpcObjectsCache::getTask).collect(Collectors.toList());
assertThat(grpcTasks2.size()).isEqualTo(coreTasks.size());
for (int i = 0; i < grpcTasks1.size(); i++) {
assertThat(grpcTasks1.get(i) == grpcTasks2.get(i)).isEqualTo(isEnabled);
}
if (isEnabled) {
assertThat(grpcObjectsCache.taskCache.cache.size()).isEqualTo(numCoreTasks);
} else {
assertThat(grpcObjectsCache.taskCache.cache.size()).isEqualTo(0);
}
}
private void verifyJobsCacheBehavior(boolean isEnabled, int numCoreJobs) {
setupGrpcObjectCache(isEnabled);
List<Job> coreJobs = v3JobOperations.getJobs();
List<com.netflix.titus.grpc.protogen.Job> grpcJobs1 = coreJobs.stream().map(grpcObjectsCache::getJob).collect(Collectors.toList());
assertThat(grpcJobs1.size()).isEqualTo(coreJobs.size());
List<com.netflix.titus.grpc.protogen.Job> grpcJobs2 = coreJobs.stream().map(grpcObjectsCache::getJob).collect(Collectors.toList());
assertThat(grpcJobs2.size()).isEqualTo(coreJobs.size());
for (int i = 0; i < grpcJobs1.size(); i++) {
assertThat(grpcJobs1.get(i) == grpcJobs2.get(i)).isEqualTo(isEnabled);
}
if (isEnabled) {
assertThat(grpcObjectsCache.jobCache.cache.size()).isEqualTo(numCoreJobs);
} else {
assertThat(grpcObjectsCache.jobCache.cache.size()).isEqualTo(0);
}
}
@Test
public void jobsCacheEnabled() {
verifyJobsCacheBehavior(true, 5);
}
@Test
public void jobsCacheDisabled() {
verifyJobsCacheBehavior(false, 5);
}
@Test
public void jobCleanup() {
setupGrpcObjectCache(true);
Job job = someJobs.getJobs().get(0);
grpcObjectsCache.getJob(job);
assertThat(grpcObjectsCache.jobCache.cache.containsKey(job.getId())).isTrue();
someJobs.removeJob(job.getId());
someJobs.resetMock();
await().until(() -> !grpcObjectsCache.jobCache.cache.containsKey(job.getId()));
}
@Test
public void tasksCacheEnabled() {
verifyTasksCacheBehavior(true, 87);
}
@Test
public void tasksCacheDisabled() {
verifyTasksCacheBehavior(false, 87);
}
@Test
public void taskCleanup() {
setupGrpcObjectCache(true);
Job job = someJobs.getJobs().get(0);
List<Task> tasks = someJobs.getTasks(job.getId());
Task task0 = tasks.get(0);
grpcObjectsCache.getTask(task0);
assertThat(grpcObjectsCache.taskCache.cache.containsKey(task0.getId())).isTrue();
someJobs.removeJob(job.getId());
someJobs.resetMock();
await().until(() -> !grpcObjectsCache.taskCache.cache.containsKey(task0.getId()));
}
class SomeJobs {
private final Map<String, Pair<Job, List<Task>>> jobsAndTasks = new HashMap<>();
void addJob(int numTasks) {
Job job = JobGenerator.oneBatchJob();
List tasks = JobGenerator.batchTasks(job).getValues(numTasks);
jobsAndTasks.put(job.getId(), Pair.of(job, tasks));
}
void removeJob(String jobId) {
jobsAndTasks.remove(jobId);
}
List<Job> getJobs() {
return jobsAndTasks.values().stream().map(Pair::getLeft).collect(Collectors.toList());
}
List<Task> getTasks(String jobId) {
return jobsAndTasks.get(jobId).getRight();
}
List<Task> getTasks() {
return jobsAndTasks.values().stream().flatMap(p -> p.getRight().stream()).collect(Collectors.toList());
}
void resetMock() {
when(v3JobOperations.getJobs()).thenReturn(getJobs());
when(v3JobOperations.getTasks()).thenReturn(getTasks());
}
}
} | 1,164 |
0 | Create_ds/titus-control-plane/titus-client/src/test/java/com/netflix/titus/runtime/connector | Create_ds/titus-control-plane/titus-client/src/test/java/com/netflix/titus/runtime/connector/jobmanager/RemoteJobManagementClientWithKeepAliveTest.java | /*
* Copyright 2021 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.runtime.connector.jobmanager;
import java.io.IOException;
import java.util.Collections;
import java.util.Iterator;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingDeque;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicBoolean;
import com.netflix.titus.common.runtime.TitusRuntime;
import com.netflix.titus.common.runtime.TitusRuntimes;
import com.netflix.titus.common.util.Evaluators;
import com.netflix.titus.common.util.FunctionExt;
import com.netflix.titus.common.util.archaius2.Archaius2Ext;
import com.netflix.titus.grpc.protogen.Job;
import com.netflix.titus.grpc.protogen.JobChangeNotification;
import com.netflix.titus.grpc.protogen.JobManagementServiceGrpc;
import com.netflix.titus.grpc.protogen.KeepAliveRequest;
import com.netflix.titus.grpc.protogen.KeepAliveResponse;
import com.netflix.titus.grpc.protogen.ObserveJobsWithKeepAliveRequest;
import io.grpc.ManagedChannel;
import io.grpc.Server;
import io.grpc.Status;
import io.grpc.StatusRuntimeException;
import io.grpc.inprocess.InProcessChannelBuilder;
import io.grpc.inprocess.InProcessServerBuilder;
import io.grpc.stub.ServerCallStreamObserver;
import io.grpc.stub.StreamObserver;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import reactor.core.Disposable;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.fail;
import static org.mockito.Mockito.mock;
public class RemoteJobManagementClientWithKeepAliveTest {
private static final Object COMPLETED = new Object();
private final TitusRuntime titusRuntime = TitusRuntimes.test();
private final JobConnectorConfiguration configuration = Archaius2Ext.newConfiguration(JobConnectorConfiguration.class);
private final ReactorJobManagementServiceStub reactorStub = mock(ReactorJobManagementServiceStub.class);
private RemoteJobManagementClientWithKeepAlive client;
private Server server;
private ManagedChannel channel;
private ServerCallStreamObserver<JobChangeNotification> responseObserver;
private final StreamObserver<ObserveJobsWithKeepAliveRequest> requestObserver = new StreamObserver<ObserveJobsWithKeepAliveRequest>() {
@Override
public void onNext(ObserveJobsWithKeepAliveRequest value) {
receivedFromClient.add(value);
}
@Override
public void onError(Throwable error) {
receivedFromClient.add(error);
}
@Override
public void onCompleted() {
receivedFromClient.add(COMPLETED);
}
};
private final BlockingQueue<Object> receivedFromClient = new LinkedBlockingDeque<>();
private boolean clientCancelled;
@Before
public void setUp() {
this.server = newServerConnection();
this.channel = InProcessChannelBuilder.forName("test").directExecutor().build();
this.client = new RemoteJobManagementClientWithKeepAlive(
"test",
configuration,
JobManagementServiceGrpc.newStub(channel),
reactorStub,
titusRuntime
);
}
@After
public void tearDown() {
Evaluators.acceptNotNull(channel, ManagedChannel::shutdown);
Evaluators.acceptNotNull(server, Server::shutdown);
}
@Test
public void testJobEvent() throws InterruptedException {
Iterator<JobChangeNotification> it = newClientConnection();
responseObserver.onNext(newJobUpdateEvent("job1"));
expectJobChangeNotification(it, JobChangeNotification.NotificationCase.JOBUPDATE);
}
@Test
public void testKeepAlive() throws InterruptedException {
Iterator<JobChangeNotification> it = newClientConnection();
KeepAliveRequest keepAliveRequest = waitForClientKeepAliveRequest();
responseObserver.onNext(JobChangeNotification.newBuilder()
.setKeepAliveResponse(KeepAliveResponse.newBuilder().setRequest(keepAliveRequest).build())
.build()
);
KeepAliveResponse keepAliveResponse = expectJobChangeNotification(it,
JobChangeNotification.NotificationCase.KEEPALIVERESPONSE).getKeepAliveResponse();
assertThat(keepAliveResponse.getRequest()).isEqualTo(keepAliveRequest);
}
@Test
public void testClientCancel() throws InterruptedException {
AtomicBoolean keepAliveCompleted = new AtomicBoolean();
Disposable disposable = client.connectObserveJobs(Collections.emptyMap(), () -> keepAliveCompleted.set(true)).subscribe();
// Read and discard the query message
receivedFromClient.poll(30, TimeUnit.SECONDS);
disposable.dispose();
Object value = receivedFromClient.poll(30, TimeUnit.SECONDS);
assertThat(value).isInstanceOf(StatusRuntimeException.class);
assertThat(((StatusRuntimeException) value).getStatus().getCode()).isEqualTo(Status.Code.CANCELLED);
assertThat(keepAliveCompleted).isTrue();
assertThat(clientCancelled).isTrue();
}
@Test
public void testServerError() throws InterruptedException {
AtomicBoolean keepAliveCompleted = new AtomicBoolean();
Iterator<JobChangeNotification> it = newClientConnection(() -> keepAliveCompleted.set(true));
// Read and discard the query message
receivedFromClient.poll(30, TimeUnit.SECONDS);
responseObserver.onError(new StatusRuntimeException(Status.ABORTED.augmentDescription("simulated error")));
try {
it.next();
fail("expected an exception");
} catch (StatusRuntimeException e) {
assertThat(e.getStatus().getCode()).isEqualTo(Status.Code.ABORTED);
assertThat(keepAliveCompleted).isTrue();
}
}
@Test
public void testServerCompleted() throws InterruptedException {
AtomicBoolean keepAliveCompleted = new AtomicBoolean();
Iterator<JobChangeNotification> it = newClientConnection(() -> keepAliveCompleted.set(true));
waitForClientKeepAliveRequest();
responseObserver.onCompleted();
assertThat(it.hasNext()).isFalse();
assertThat(keepAliveCompleted).isTrue();
}
private Server newServerConnection() {
try {
return InProcessServerBuilder.forName("test")
.directExecutor()
.addService(new GrpcJobServiceStub())
.build()
.start();
} catch (IOException e) {
throw new IllegalStateException(e);
}
}
private Iterator<JobChangeNotification> newClientConnection(Runnable keepAliveCompleted) throws InterruptedException {
Iterator<JobChangeNotification> it = client.connectObserveJobs(Collections.emptyMap(), keepAliveCompleted).toIterable().iterator();
Object clientRequestEvent = receivedFromClient.poll(30, TimeUnit.SECONDS);
assertThat(clientRequestEvent).isNotNull().isInstanceOf(ObserveJobsWithKeepAliveRequest.class);
assertThat(((ObserveJobsWithKeepAliveRequest) clientRequestEvent).getKindCase()).isEqualTo(ObserveJobsWithKeepAliveRequest.KindCase.QUERY);
return it;
}
private Iterator<JobChangeNotification> newClientConnection() throws InterruptedException {
return newClientConnection(FunctionExt.noop());
}
private JobChangeNotification expectJobChangeNotification(Iterator<JobChangeNotification> it, JobChangeNotification.NotificationCase eventCase) {
JobChangeNotification jobEvent = it.next();
assertThat(jobEvent).isNotNull();
assertThat(jobEvent.getNotificationCase()).isEqualTo(eventCase);
return jobEvent;
}
private KeepAliveRequest waitForClientKeepAliveRequest() throws InterruptedException {
Object value = receivedFromClient.poll(30, TimeUnit.SECONDS);
assertThat(value).isNotNull().isInstanceOf(ObserveJobsWithKeepAliveRequest.class);
ObserveJobsWithKeepAliveRequest event = (ObserveJobsWithKeepAliveRequest) value;
assertThat(event.getKindCase()).isEqualTo(ObserveJobsWithKeepAliveRequest.KindCase.KEEPALIVEREQUEST);
return event.getKeepAliveRequest();
}
private JobChangeNotification newJobUpdateEvent(String jobId) {
return JobChangeNotification.newBuilder()
.setJobUpdate(JobChangeNotification.JobUpdate.newBuilder()
.setJob(Job.newBuilder()
.setId(jobId)
.build()
)
.build()
)
.build();
}
private class GrpcJobServiceStub extends JobManagementServiceGrpc.JobManagementServiceImplBase {
@Override
public StreamObserver<ObserveJobsWithKeepAliveRequest> observeJobsWithKeepAlive(StreamObserver<JobChangeNotification> responseObserver) {
ServerCallStreamObserver<JobChangeNotification> responseObserver2 = (ServerCallStreamObserver<JobChangeNotification>) responseObserver;
RemoteJobManagementClientWithKeepAliveTest.this.responseObserver = responseObserver2;
responseObserver2.setOnCancelHandler(() -> RemoteJobManagementClientWithKeepAliveTest.this.clientCancelled = true);
return requestObserver;
}
}
} | 1,165 |
0 | Create_ds/titus-control-plane/titus-client/src/test/java/com/netflix/titus/runtime/connector/jobmanager | Create_ds/titus-control-plane/titus-client/src/test/java/com/netflix/titus/runtime/connector/jobmanager/snapshot/PCollectionJobSnapshotTest.java | /*
* Copyright 2021 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.runtime.connector.jobmanager.snapshot;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import com.netflix.titus.api.jobmanager.model.job.Job;
import com.netflix.titus.api.jobmanager.model.job.Task;
import com.netflix.titus.common.runtime.TitusRuntime;
import com.netflix.titus.common.runtime.TitusRuntimes;
import com.netflix.titus.common.util.tuple.Pair;
import org.junit.Test;
import static com.netflix.titus.runtime.connector.jobmanager.snapshot.JobSnapshotTestUtil.newJobWithTasks;
import static com.netflix.titus.runtime.connector.jobmanager.snapshot.JobSnapshotTestUtil.newSnapshot;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.fail;
/**
* Negative test scenarios only. Positive tests are in {@link JobSnapshotTest}.
*/
public class PCollectionJobSnapshotTest {
private final TitusRuntime titusRuntime = TitusRuntimes.internal();
private final List<String> inconsistenciesReports = new ArrayList<>();
@Test
public void testAutoFixMode() {
Pair<Job<?>, Map<String, Task>> pair1 = newJobWithTasks(1, 2);
List<Task> tasks1 = new ArrayList<>(pair1.getRight().values());
JobSnapshot initial = newSnapshot(newFactory(true), pair1);
JobSnapshot updated = initial.updateTask(tasks1.get(0), true).orElse(null);
assertThat(updated).isNotNull();
assertThat(inconsistenciesReports).hasSize(1);
}
@Test
public void testNoAutoFixMode() {
Pair<Job<?>, Map<String, Task>> pair1 = newJobWithTasks(1, 2);
List<Task> tasks1 = new ArrayList<>(pair1.getRight().values());
JobSnapshot initial = newSnapshot(newFactory(false), pair1);
try {
initial.updateTask(tasks1.get(0), true);
fail("error expected");
} catch (Exception e) {
assertThat(e).isInstanceOf(IllegalStateException.class);
}
assertThat(inconsistenciesReports).hasSize(1);
}
private JobSnapshotFactory newFactory(boolean autoFix) {
return JobSnapshotFactories.newDefault(autoFix, false, inconsistenciesReports::add, titusRuntime);
}
} | 1,166 |
0 | Create_ds/titus-control-plane/titus-client/src/test/java/com/netflix/titus/runtime/connector/jobmanager | Create_ds/titus-control-plane/titus-client/src/test/java/com/netflix/titus/runtime/connector/jobmanager/snapshot/CachedBatchJobTest.java | /*
* Copyright 2021 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.runtime.connector.jobmanager.snapshot;
import java.util.Collections;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
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.JobState;
import com.netflix.titus.api.jobmanager.model.job.JobStatus;
import com.netflix.titus.api.jobmanager.model.job.Task;
import com.netflix.titus.api.jobmanager.model.job.TaskState;
import com.netflix.titus.api.jobmanager.model.job.TaskStatus;
import com.netflix.titus.api.jobmanager.model.job.ext.BatchJobExt;
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.tuple.Pair;
import com.netflix.titus.common.util.tuple.Triple;
import org.junit.Test;
import org.pcollections.PMap;
import static com.netflix.titus.runtime.connector.jobmanager.snapshot.JobSnapshotTestUtil.newBatchJobWithTasks;
import static org.assertj.core.api.Assertions.assertThat;
public class CachedBatchJobTest {
private final TitusRuntime titusRuntime = TitusRuntimes.test();
@Test
public void testInitial() {
Pair<Job<BatchJobExt>, PMap<String, Task>> jobAndTasks = newBatchJobWithTasks(0, 2);
Job<BatchJobExt> job = jobAndTasks.getLeft();
PMap<String, Task> tasks = jobAndTasks.getRight();
CachedJob cached1 = CachedBatchJob.newBatchInstance(job, tasks, titusRuntime);
assertThat(cached1.getJob()).isEqualTo(job);
assertThat(cached1.getTasks()).containsAllEntriesOf(tasks);
}
@Test
public void testUpdateJob() {
PCollectionJobSnapshot initialSnapshot = initialSnapshot(2, 2).getFirst();
CachedJob cached1 = CollectionsExt.first(initialSnapshot.cachedJobsById.values());
Job<?> updatedJob = JobFunctions.changeJobStatus(cached1.getJob(), JobStatus.newBuilder().withState(JobState.KillInitiated).build());
JobSnapshot updatedSnapshot = cached1.updateJob(initialSnapshot, updatedJob).orElse(null);
assertThat(updatedSnapshot).isNotNull();
assertThat(updatedSnapshot.getJobMap()).containsValue(updatedJob);
}
@Test
public void testRemoveJob() {
PCollectionJobSnapshot initialSnapshot = initialSnapshot(2, 2).getFirst();
CachedJob cached1 = CollectionsExt.first(initialSnapshot.cachedJobsById.values());
Job<?> updatedJob = JobFunctions.changeJobStatus(cached1.getJob(), JobStatus.newBuilder().withState(JobState.Finished).build());
JobSnapshot updatedSnapshot = cached1.removeJob(initialSnapshot, updatedJob).orElse(null);
assertThat(updatedSnapshot).isNotNull();
assertThat(updatedSnapshot.getJobMap()).isEmpty();
assertThat(updatedSnapshot.getTaskMap()).isEmpty();
}
@Test
public void testAddTask() {
Triple<PCollectionJobSnapshot, Map<Integer, Task>, Map<Integer, Task>> initial = initialSnapshot(2, 0);
PCollectionJobSnapshot initialSnapshot = initial.getFirst();
Map<Integer, Task> skippedTasks = initial.getThird();
// Empty
CachedJob cached1 = CollectionsExt.first(initialSnapshot.cachedJobsById.values());
assertThat(cached1.getTasks()).isEmpty();
// One task
PCollectionJobSnapshot withOneTask = (PCollectionJobSnapshot) cached1.updateTask(initialSnapshot, skippedTasks.get(0)).orElse(null);
CachedJob cached2 = CollectionsExt.first(withOneTask.cachedJobsById.values());
assertThat(cached2.getTasks()).containsValue(skippedTasks.get(0));
// Two tasks
PCollectionJobSnapshot withTwoTasks = (PCollectionJobSnapshot) cached2.updateTask(withOneTask, skippedTasks.get(1)).orElse(null);
CachedJob cached3 = CollectionsExt.first(withTwoTasks.cachedJobsById.values());
assertThat(cached3.getTasks()).hasSize(2);
assertThat(cached3.getTasks()).containsValue(skippedTasks.get(1));
}
@Test
public void testUpdateTask() {
Triple<PCollectionJobSnapshot, Map<Integer, Task>, Map<Integer, Task>> initial = initialSnapshot(2, 2);
PCollectionJobSnapshot initialSnapshot = initial.getFirst();
Map<Integer, Task> tasksByIndexes = initial.getSecond();
CachedJob cached1 = CollectionsExt.first(initialSnapshot.cachedJobsById.values());
assertThat(cached1.getTasks()).hasSize(2);
// Update task at index 0
Task task0Updated = tasksByIndexes.get(0).toBuilder().withStatus(TaskStatus.newBuilder().withState(TaskState.Started).build()).build();
PCollectionJobSnapshot snapshot2 = (PCollectionJobSnapshot) cached1.updateTask(initialSnapshot, task0Updated).orElse(null);
CachedJob cached2 = CollectionsExt.first(snapshot2.cachedJobsById.values());
assertThat(cached2.getTasks()).hasSize(2);
assertThat(cached2.getTasks().get(task0Updated.getId())).isEqualTo(task0Updated);
}
/**
* Create a snapshot with a single job and size == taskCount. Create up to tasksCreated tasks, leaving
* the remaining slots empty.
*/
private Triple<PCollectionJobSnapshot, Map<Integer, Task>, Map<Integer, Task>> initialSnapshot(int taskCount, int tasksCreated) {
Pair<Job<BatchJobExt>, PMap<String, Task>> jobAndTasks = newBatchJobWithTasks(0, taskCount);
Job<BatchJobExt> job = jobAndTasks.getLeft();
Map<Integer, Task> tasksByIndex = new HashMap<>();
Map<String, Task> tasks = new HashMap<>(jobAndTasks.getRight());
Map<Integer, Task> skipped = new HashMap<>();
Iterator<Task> it = tasks.values().iterator();
while (it.hasNext()) {
Task task = it.next();
int index = CachedBatchJob.indexOf(task, taskCount, titusRuntime);
if (index >= tasksCreated) {
it.remove();
skipped.put(index, task);
} else {
tasksByIndex.put(index, task);
}
}
PCollectionJobSnapshot snapshot = PCollectionJobSnapshot.newInstance("test",
Collections.singletonMap(job.getId(), job),
Collections.singletonMap(job.getId(), tasks),
false,
false,
error -> {
throw new IllegalStateException(error);
},
titusRuntime
);
return Triple.of(snapshot, tasksByIndex, skipped);
}
} | 1,167 |
0 | Create_ds/titus-control-plane/titus-client/src/test/java/com/netflix/titus/runtime/connector/jobmanager | Create_ds/titus-control-plane/titus-client/src/test/java/com/netflix/titus/runtime/connector/jobmanager/snapshot/JobSnapshotTest.java | /*
* Copyright 2021 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.runtime.connector.jobmanager.snapshot;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Map;
import com.netflix.titus.api.jobmanager.TaskAttributes;
import com.netflix.titus.api.jobmanager.model.job.Job;
import com.netflix.titus.api.jobmanager.model.job.JobState;
import com.netflix.titus.api.jobmanager.model.job.JobStatus;
import com.netflix.titus.api.jobmanager.model.job.Task;
import com.netflix.titus.api.jobmanager.model.job.TaskState;
import com.netflix.titus.api.jobmanager.model.job.TaskStatus;
import com.netflix.titus.api.jobmanager.model.job.Version;
import com.netflix.titus.api.jobmanager.model.job.ext.ServiceJobExt;
import com.netflix.titus.common.runtime.TitusRuntime;
import com.netflix.titus.common.runtime.TitusRuntimes;
import com.netflix.titus.common.util.tuple.Pair;
import org.junit.Test;
import org.pcollections.PMap;
import static com.netflix.titus.runtime.connector.jobmanager.snapshot.JobSnapshotTestUtil.newBatchJobWithTasks;
import static com.netflix.titus.runtime.connector.jobmanager.snapshot.JobSnapshotTestUtil.newJobWithTasks;
import static com.netflix.titus.runtime.connector.jobmanager.snapshot.JobSnapshotTestUtil.newServiceJobWithTasks;
import static com.netflix.titus.runtime.connector.jobmanager.snapshot.JobSnapshotTestUtil.newSnapshot;
import static org.assertj.core.api.Assertions.assertThat;
public class JobSnapshotTest {
private static final TitusRuntime titusRuntime = TitusRuntimes.internal();
private final JobSnapshotFactory factory = JobSnapshotFactories.newDefault(titusRuntime);
@Test
public void testInitialization() {
Pair<Job<?>, Map<String, Task>> pair1 = newJobWithTasks(1, 5);
Pair<Job<?>, Map<String, Task>> pair2 = newJobWithTasks(2, 10);
Job<?> job1 = pair1.getLeft();
Job<?> job2 = pair2.getLeft();
Map<String, Task> tasks1 = pair1.getRight();
Map<String, Task> tasks2 = pair2.getRight();
JobSnapshot jobSnapshot = newSnapshot(factory, pair1, pair2);
// getJobMap()
assertThat(jobSnapshot.getJobMap()).containsKeys(job1.getId(), job2.getId());
// getTasks(<jobId>)
assertThat(jobSnapshot.getTasks(job1.getId()).values()).containsAll(tasks1.values());
assertThat(jobSnapshot.getTasks(job2.getId()).values()).containsAll(tasks2.values());
// getTasksMap()
assertThat(jobSnapshot.getTaskMap().values()).containsAll(tasks1.values()).containsAll(tasks2.values());
// ------------------------------------------------------
// DEPRECATED
// getJobs()
assertThat(jobSnapshot.getJobs()).contains(job1, job2);
// getTasks()
assertThat(jobSnapshot.getTasks()).containsAll(tasks1.values()).containsAll(tasks2.values());
// getJobsAndTasks()
assertThat(jobSnapshot.getJobsAndTasks()).contains(Pair.of(job1, tasks1)).contains(Pair.of(job2, tasks2));
}
@Test
public void testJobAndTaskUpdate() {
Pair<Job<?>, Map<String, Task>> pair1 = (Pair) newServiceJobWithTasks(1, 2, 1_000);
Pair<Job<?>, Map<String, Task>> pair2 = (Pair) newBatchJobWithTasks(2, 2);
Job<?> job1 = pair1.getLeft();
Job<?> job2 = pair2.getLeft();
List<Task> tasks1 = new ArrayList<>(pair1.getRight().values());
List<Task> tasks2 = new ArrayList<>(pair2.getRight().values());
JobSnapshot initial = newSnapshot(factory, pair1);
// Add job2
JobSnapshot updated = initial.updateJob(job2).orElse(null);
assertThat(updated).isNotNull();
assertThat(updated.getJobMap()).containsValues(job1, job2);
// Add tasks of job2
updated = updated.updateTask(tasks2.get(0), false).orElse(null);
assertThat(updated).isNotNull();
updated = updated.updateTask(tasks2.get(1), false).orElse(null);
assertThat(updated).isNotNull();
assertThat(updated.getTasks(job2.getId()).values()).containsAll(tasks2);
assertThat(updated.getTaskMap()).hasSize(4);
// Modify job1
Job<?> updatedJob = job1.toBuilder().withVersion(Version.newBuilder().withTimestamp(123).build()).build();
updated = updated.updateJob(updatedJob).orElse(null);
assertThat(updated).isNotNull();
assertThat(updated.getJobMap()).containsValues(updatedJob, job2);
// Modify task (job1)
Task updatedTask = tasks1.get(0).toBuilder().withVersion(Version.newBuilder().withTimestamp(123).build()).build();
updated = updated.updateTask(updatedTask, false).orElse(null);
assertThat(updated).isNotNull();
assertThat(updated.getTasks(job1.getId())).hasSize(2);
assertThat(updated.getTasks(job1.getId()).values()).contains(tasks1.get(1)).contains(updatedTask);
assertThat(updated.getTaskMap()).hasSize(4);
assertThat(updated.getTaskMap().get(updatedTask.getId())).isEqualTo(updatedTask);
// Remove task (job1)
updated = updated.updateTask(
updatedTask.toBuilder().withStatus(TaskStatus.newBuilder().withState(TaskState.Finished).build()).build(), false
).orElse(null);
assertThat(updated).isNotNull();
assertThat(updated.getTasks(job1.getId()).values()).containsExactly(tasks1.get(1));
assertThat(updated.getTaskMap()).hasSize(3);
// Remove job1
updated = updated.updateJob(
updatedJob.toBuilder().withStatus(JobStatus.newBuilder().withState(JobState.Finished).build()).build()
).orElse(null);
assertThat(updated).isNotNull();
assertThat(updated.getJobMap()).hasSize(1).containsEntry(job2.getId(), job2);
assertThat(updated.getTasks(job2.getId()).values()).containsAll(tasks2);
assertThat(updated.getTaskMap()).hasSize(2).containsValues(tasks2.get(0), tasks2.get(1));
}
@Test
public void testMovedTask() {
Pair<Job<ServiceJobExt>, PMap<String, Task>> pair1 = newServiceJobWithTasks(1, 2, 1_000);
Pair<Job<ServiceJobExt>, PMap<String, Task>> pair2 = newServiceJobWithTasks(2, 0, 1_000);
Job<?> job1 = pair1.getLeft();
Job<?> job2 = pair2.getLeft();
List<Task> tasks1 = new ArrayList<>(pair1.getRight().values());
JobSnapshot initial = newSnapshot(factory, (Pair) pair1, (Pair) pair2);
Task movedTask = tasks1.get(0).toBuilder()
.withJobId(job2.getId())
.withTaskContext(Collections.singletonMap(TaskAttributes.TASK_ATTRIBUTES_MOVED_FROM_JOB, job1.getId()))
.build();
JobSnapshot updated = initial.updateTask(movedTask, true).orElse(null);
assertThat(updated).isNotNull();
assertThat(updated.getJobMap()).hasSize(2).containsValues(job1, job2);
assertThat(updated.getTaskMap()).containsValues(movedTask, tasks1.get(1));
assertThat(updated.getTasks(job1.getId()).values()).containsExactly(tasks1.get(1));
assertThat(updated.getTasks(job2.getId()).values()).containsExactly(movedTask);
}
}
| 1,168 |
0 | Create_ds/titus-control-plane/titus-client/src/test/java/com/netflix/titus/runtime/connector/jobmanager | Create_ds/titus-control-plane/titus-client/src/test/java/com/netflix/titus/runtime/connector/jobmanager/snapshot/JobSnapshotPerf.java | /*
* Copyright 2021 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.runtime.connector.jobmanager.snapshot;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Map;
import java.util.Random;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicLong;
import com.google.common.base.Stopwatch;
import com.netflix.titus.api.jobmanager.model.job.BatchJobTask;
import com.netflix.titus.api.jobmanager.model.job.Job;
import com.netflix.titus.api.jobmanager.model.job.JobState;
import com.netflix.titus.api.jobmanager.model.job.JobStatus;
import com.netflix.titus.api.jobmanager.model.job.Task;
import com.netflix.titus.api.jobmanager.model.job.TaskState;
import com.netflix.titus.api.jobmanager.model.job.TaskStatus;
import com.netflix.titus.api.jobmanager.model.job.Version;
import com.netflix.titus.api.jobmanager.model.job.ext.BatchJobExt;
import com.netflix.titus.common.runtime.TitusRuntime;
import com.netflix.titus.common.runtime.TitusRuntimes;
import com.netflix.titus.common.util.tuple.Pair;
import com.netflix.titus.testkit.model.job.JobGenerator;
import org.pcollections.HashTreePMap;
import org.pcollections.PMap;
import org.pcollections.PSequence;
import org.pcollections.TreePVector;
/**
* Performance test for {@link PCollectionJobSnapshot}.
*/
public class JobSnapshotPerf {
private final TitusRuntime titusRuntime = TitusRuntimes.internal();
private final int taskPerJobCount;
private final double createUpdateRatio;
private final AtomicLong jobIdx = new AtomicLong();
private final AtomicLong taskIdx = new AtomicLong();
private final Random random = new Random();
private JobSnapshot snapshot;
private PSequence<Pair<Job<?>, PMap<String, Task>>> jobAndTasks = TreePVector.empty();
public JobSnapshotPerf(int jobCount, int taskPerJobCount, double createUpdateRatio) {
this.taskPerJobCount = taskPerJobCount;
this.createUpdateRatio = createUpdateRatio;
Map<String, Job<?>> jobs = new HashMap<>();
Map<String, Map<String, Task>> taskByJobId = new HashMap<>();
for (int j = 0; j < jobCount; j++) {
Pair<Job<?>, Map<String, Task>> jobWithTasks = newJobWithTasks();
Job<?> job = jobWithTasks.getLeft();
Map<String, Task> tasks = jobWithTasks.getRight();
jobs.put(job.getId(), job);
taskByJobId.put(job.getId(), tasks);
jobAndTasks = jobAndTasks.plus(Pair.of(job, HashTreePMap.from(tasks)));
}
this.snapshot = PCollectionJobSnapshot.newInstance(
"test", jobs, taskByJobId, false, false, message -> {
},
titusRuntime
);
}
private Pair<Job<?>, Map<String, Task>> newJobWithTasks() {
Job<BatchJobExt> job = JobGenerator.oneBatchJob().toBuilder().withId("job#" + jobIdx.getAndIncrement()).build();
Map<String, Task> tasks = new HashMap<>();
for (int t = 0; t < taskPerJobCount; t++) {
BatchJobTask task = newTask(job);
tasks.put(task.getId(), task);
}
return Pair.of(job, tasks);
}
private BatchJobTask newTask(Job<?> job) {
return JobGenerator.oneBatchTask().toBuilder()
.withId("task#" + taskIdx.getAndIncrement() + "@" + job.getId())
.withJobId(job.getId())
.withVersion(Version.newBuilder().withTimestamp(System.currentTimeMillis()).build())
.build();
}
private void run(long updateCount) {
long createActions = 1;
long updateActions = 1;
for (int i = 0; i < updateCount; i++) {
boolean doJob = random.nextBoolean();
if ((createUpdateRatio * createActions) < updateActions) {
if (doJob) {
createJob();
} else {
createTask();
}
createActions++;
} else {
if (doJob) {
updateJob();
} else {
updateTask();
}
updateActions++;
}
}
}
private void createJob() {
Job<?> toRemove = jobAndTasks.get(0).getLeft();
Pair<Job<?>, Map<String, Task>> toAdd = newJobWithTasks();
Job<?> toAddJob = toAdd.getLeft();
Map<String, Task> toAddTasks = toAdd.getRight();
// Remove old job by moving it to the finished state.
Job<?> finishedJob = toRemove.toBuilder().withStatus(JobStatus.newBuilder().withState(JobState.Finished).build()).build();
snapshot.updateJob(finishedJob).ifPresent(newSnapshot -> this.snapshot = newSnapshot);
// Add new job as a replacement
snapshot.updateJob(toAddJob).ifPresent(newSnapshot -> this.snapshot = newSnapshot);
toAddTasks.forEach((taskId, task) ->
snapshot.updateTask(task, false).ifPresent(newSnapshot -> this.snapshot = newSnapshot)
);
// Clean local map
jobAndTasks = jobAndTasks.minus(0).plus(Pair.of(toAddJob, HashTreePMap.from(toAddTasks)));
}
private void updateJob() {
int idx = random.nextInt(jobAndTasks.size());
Pair<Job<?>, PMap<String, Task>> jobToUpdate = jobAndTasks.get(idx);
Job<?> updatedJob = jobToUpdate.getLeft().toBuilder().withVersion(Version.newBuilder().withTimestamp(System.currentTimeMillis()).build()).build();
snapshot.updateJob(updatedJob).ifPresent(newSnapshot -> this.snapshot = newSnapshot);
// Clean local map
jobAndTasks = jobAndTasks.with(idx, Pair.of(updatedJob, jobToUpdate.getRight()));
}
private void createTask() {
int idx = random.nextInt(jobAndTasks.size());
Pair<Job<?>, PMap<String, Task>> toUpdate = this.jobAndTasks.get(idx);
Job<?> job = toUpdate.getLeft();
PMap<String, Task> tasks = toUpdate.getRight();
// Remove task
int taskIdx = random.nextInt(tasks.size());
String taskToRemoveId = new ArrayList<>(tasks.values()).get(taskIdx).getId();
Task taskToRemove = snapshot.getTaskMap().get(taskToRemoveId);
if (taskToRemove == null) {
return;
}
Task finishedTask = taskToRemove.toBuilder().withStatus(TaskStatus.newBuilder().withState(TaskState.Finished).build()).build();
snapshot.updateTask(finishedTask, false).ifPresent(newSnapshot -> this.snapshot = newSnapshot);
// Create replacement
Task newTask = newTask(job);
snapshot.updateTask(newTask, false).ifPresent(newSnapshot -> this.snapshot = newSnapshot);
// Clean local map
jobAndTasks = jobAndTasks.with(idx, Pair.of(job, tasks.minus(taskIdx).plus(newTask.getId(), newTask)));
}
private void updateTask() {
int idx = random.nextInt(jobAndTasks.size());
Pair<Job<?>, PMap<String, Task>> toUpdate = this.jobAndTasks.get(idx);
Job<?> job = toUpdate.getLeft();
PMap<String, Task> tasks = toUpdate.getRight();
int taskIdx = random.nextInt(tasks.size());
Task taskToUpdate = new ArrayList<>(tasks.values()).get(taskIdx);
Task updatedTask = taskToUpdate.toBuilder().withVersion(Version.newBuilder().withTimestamp(System.currentTimeMillis()).build()).build();
snapshot.updateTask(updatedTask, false).ifPresent(newSnapshot -> this.snapshot = newSnapshot);
// Clean local map
jobAndTasks = jobAndTasks.with(idx, Pair.of(job, tasks.plus(updatedTask.getId(), updatedTask)));
}
public static void main(String[] args) {
JobSnapshotPerf perf = new JobSnapshotPerf(5000, 1, 0.5);
Stopwatch stopwatch = Stopwatch.createStarted();
perf.run(10_000);
System.out.println("Finished in: " + stopwatch.elapsed(TimeUnit.MILLISECONDS) + "[ms]");
}
} | 1,169 |
0 | Create_ds/titus-control-plane/titus-client/src/test/java/com/netflix/titus/runtime/connector/jobmanager | Create_ds/titus-control-plane/titus-client/src/test/java/com/netflix/titus/runtime/connector/jobmanager/snapshot/CachedBatchJobWithOneTaskTest.java | /*
* Copyright 2021 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.runtime.connector.jobmanager.snapshot;
import java.util.Collections;
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.JobState;
import com.netflix.titus.api.jobmanager.model.job.JobStatus;
import com.netflix.titus.api.jobmanager.model.job.Task;
import com.netflix.titus.api.jobmanager.model.job.TaskState;
import com.netflix.titus.api.jobmanager.model.job.TaskStatus;
import com.netflix.titus.api.jobmanager.model.job.Version;
import com.netflix.titus.api.jobmanager.model.job.ext.BatchJobExt;
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.tuple.Pair;
import org.junit.Test;
import org.pcollections.PMap;
import static com.netflix.titus.runtime.connector.jobmanager.snapshot.JobSnapshotTestUtil.newBatchJobWithTasks;
import static org.assertj.core.api.Assertions.assertThat;
public class CachedBatchJobWithOneTaskTest {
private final TitusRuntime titusRuntime = TitusRuntimes.test();
@Test
public void testInitial() {
Pair<Job<BatchJobExt>, PMap<String, Task>> jobAndTasks = newBatchJobWithTasks(0, 1);
Job<BatchJobExt> job = jobAndTasks.getLeft();
PMap<String, Task> tasks = jobAndTasks.getRight();
// Create finished task for slot 0 to test filtering.
Task task = CollectionsExt.first(tasks.values());
Task finishedTask = task.toBuilder()
.withId("finishedTaskId")
.withStatus(TaskStatus.newBuilder().withState(TaskState.Finished).build())
.withVersion(Version.newBuilder().withTimestamp(task.getVersion().getTimestamp() - 1_000).build())
.build();
tasks = tasks.plus(finishedTask.getId(), finishedTask);
CachedJob cached1 = CachedBatchJobWithOneTask.newBatchInstance(job, tasks, titusRuntime);
assertThat(cached1.getJob()).isEqualTo(job);
assertThat(cached1.getTasks()).hasSize(1);
assertThat(cached1.getTasks()).containsValue(task);
}
@Test
public void testUpdateJob() {
PCollectionJobSnapshot initialSnapshot = initialSnapshot(true).getLeft();
CachedJob cached1 = CollectionsExt.first(initialSnapshot.cachedJobsById.values());
Job<?> updatedJob = JobFunctions.changeJobStatus(cached1.getJob(), JobStatus.newBuilder().withState(JobState.KillInitiated).build());
JobSnapshot updatedSnapshot = cached1.updateJob(initialSnapshot, updatedJob).orElse(null);
assertThat(updatedSnapshot).isNotNull();
assertThat(updatedSnapshot.getJobMap()).containsValue(updatedJob);
}
@Test
public void testRemoveJob() {
PCollectionJobSnapshot initialSnapshot = initialSnapshot(true).getLeft();
CachedJob cached1 = CollectionsExt.first(initialSnapshot.cachedJobsById.values());
Job<?> updatedJob = JobFunctions.changeJobStatus(cached1.getJob(), JobStatus.newBuilder().withState(JobState.Finished).build());
JobSnapshot updatedSnapshot = cached1.removeJob(initialSnapshot, updatedJob).orElse(null);
assertThat(updatedSnapshot).isNotNull();
assertThat(updatedSnapshot.getJobMap()).isEmpty();
assertThat(updatedSnapshot.getTaskMap()).isEmpty();
}
@Test
public void testRemoveJobWithoutTask() {
PCollectionJobSnapshot initialSnapshot = initialSnapshot(false).getLeft();
CachedJob cached1 = CollectionsExt.first(initialSnapshot.cachedJobsById.values());
assertThat(cached1.getTasks()).isEmpty();
JobSnapshot updatedSnapshot = cached1.removeJob(initialSnapshot, cached1.getJob()).orElse(null);
assertThat(updatedSnapshot).isNotNull();
assertThat(updatedSnapshot.getJobMap()).hasSize(0);
assertThat(updatedSnapshot.getTaskMap()).hasSize(0);
}
@Test
public void testAddTask() {
Pair<PCollectionJobSnapshot, Task> initial = initialSnapshot(false);
PCollectionJobSnapshot initialSnapshot = initial.getLeft();
Task task = initial.getRight();
// Empty
CachedJob cached1 = CollectionsExt.first(initialSnapshot.cachedJobsById.values());
assertThat(cached1.getTasks()).isEmpty();
// One task
PCollectionJobSnapshot withOneTask = (PCollectionJobSnapshot) cached1.updateTask(initialSnapshot, task).orElse(null);
CachedJob cached2 = CollectionsExt.first(withOneTask.cachedJobsById.values());
assertThat(cached2.getTasks()).containsValue(task);
}
@Test
public void testUpdateTask() {
Pair<PCollectionJobSnapshot, Task> initial = initialSnapshot(true);
PCollectionJobSnapshot initialSnapshot = initial.getLeft();
Task task = initial.getRight();
Task task0Updated = task.toBuilder().withStatus(TaskStatus.newBuilder().withState(TaskState.Started).build()).build();
CachedJob cached1 = CollectionsExt.first(initialSnapshot.cachedJobsById.values());
PCollectionJobSnapshot snapshot2 = (PCollectionJobSnapshot) cached1.updateTask(initialSnapshot, task0Updated).orElse(null);
CachedJob cached2 = CollectionsExt.first(snapshot2.cachedJobsById.values());
assertThat(cached2.getTasks()).hasSize(1);
assertThat(cached2.getTasks().get(task0Updated.getId())).isEqualTo(task0Updated);
}
private Pair<PCollectionJobSnapshot, Task> initialSnapshot(boolean create) {
Pair<Job<BatchJobExt>, PMap<String, Task>> jobAndTasks = newBatchJobWithTasks(0, 1);
Job<BatchJobExt> job = jobAndTasks.getLeft();
Task task = CollectionsExt.first(jobAndTasks.getRight().values());
PCollectionJobSnapshot snapshot = PCollectionJobSnapshot.newInstance("test",
Collections.singletonMap(job.getId(), job),
Collections.singletonMap(job.getId(), create ? Collections.singletonMap(task.getId(), task) : Collections.emptyMap()),
false,
false,
error -> {
throw new IllegalStateException(error);
},
titusRuntime
);
return Pair.of(snapshot, task);
}
} | 1,170 |
0 | Create_ds/titus-control-plane/titus-client/src/test/java/com/netflix/titus/runtime/connector/jobmanager | Create_ds/titus-control-plane/titus-client/src/test/java/com/netflix/titus/runtime/connector/jobmanager/snapshot/CachedServiceJobTest.java | /*
* Copyright 2021 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.runtime.connector.jobmanager.snapshot;
import java.util.Collections;
import java.util.HashMap;
import java.util.Map;
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.JobState;
import com.netflix.titus.api.jobmanager.model.job.JobStatus;
import com.netflix.titus.api.jobmanager.model.job.Task;
import com.netflix.titus.api.jobmanager.model.job.TaskState;
import com.netflix.titus.api.jobmanager.model.job.TaskStatus;
import com.netflix.titus.api.jobmanager.model.job.ext.ServiceJobExt;
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.tuple.Pair;
import org.junit.Test;
import org.pcollections.PMap;
import static com.netflix.titus.runtime.connector.jobmanager.snapshot.JobSnapshotTestUtil.newServiceJobWithTasks;
import static com.netflix.titus.runtime.connector.jobmanager.snapshot.JobSnapshotTestUtil.newServiceTask;
import static org.assertj.core.api.Assertions.assertThat;
public class CachedServiceJobTest {
private final TitusRuntime titusRuntime = TitusRuntimes.test();
@Test
public void testInitial() {
Pair<Job<ServiceJobExt>, PMap<String, Task>> jobAndTasks = newServiceJobWithTasks(0, 2, 1_000);
Job<ServiceJobExt> job = jobAndTasks.getLeft();
PMap<String, Task> tasks = jobAndTasks.getRight();
CachedJob cached1 = CachedServiceJob.newServiceInstance(job, tasks, false, titusRuntime);
assertThat(cached1.getJob()).isEqualTo(job);
assertThat(cached1.getTasks()).containsAllEntriesOf(tasks);
}
@Test
public void testUpdateJob() {
PCollectionJobSnapshot initialSnapshot = initialSnapshot(2, false);
CachedJob cached1 = CollectionsExt.first(initialSnapshot.cachedJobsById.values());
Job<?> updatedJob = JobFunctions.changeJobStatus(cached1.getJob(), JobStatus.newBuilder().withState(JobState.KillInitiated).build());
JobSnapshot updatedSnapshot = cached1.updateJob(initialSnapshot, updatedJob).orElse(null);
assertThat(updatedSnapshot).isNotNull();
assertThat(updatedSnapshot.getJobMap()).containsValue(updatedJob);
}
@Test
public void testRemoveJob() {
PCollectionJobSnapshot initialSnapshot = initialSnapshot(2, false);
CachedJob cached1 = CollectionsExt.first(initialSnapshot.cachedJobsById.values());
Job<?> updatedJob = JobFunctions.changeJobStatus(cached1.getJob(), JobStatus.newBuilder().withState(JobState.Finished).build());
JobSnapshot updatedSnapshot = cached1.removeJob(initialSnapshot, updatedJob).orElse(null);
assertThat(updatedSnapshot).isNotNull();
assertThat(updatedSnapshot.getJobMap()).isEmpty();
assertThat(updatedSnapshot.getTaskMap()).isEmpty();
}
@Test
public void testAddTask() {
PCollectionJobSnapshot initialSnapshot = initialSnapshot(2, false);
// Empty
CachedJob cached1 = CollectionsExt.first(initialSnapshot.cachedJobsById.values());
assertThat(cached1.getTasks()).hasSize(2);
// One task
Task extraTask = newServiceTask((Job<ServiceJobExt>) cached1.getJob(), 3);
PCollectionJobSnapshot withThreeTasks = (PCollectionJobSnapshot) cached1.updateTask(initialSnapshot, extraTask).orElse(null);
CachedJob cached2 = CollectionsExt.first(withThreeTasks.cachedJobsById.values());
assertThat(cached2.getTasks()).hasSize(3);
assertThat(cached2.getTasks()).containsValue(extraTask);
}
@Test
public void testUpdateTask() {
PCollectionJobSnapshot initialSnapshot = initialSnapshot(2, false);
CachedJob cached1 = CollectionsExt.first(initialSnapshot.cachedJobsById.values());
Task someTask = CollectionsExt.first(cached1.getTasks().values());
Task updatedTask = someTask.toBuilder().withStatus(TaskStatus.newBuilder().withState(TaskState.Started).build()).build();
PCollectionJobSnapshot snapshot2 = (PCollectionJobSnapshot) cached1.updateTask(initialSnapshot, updatedTask).orElse(null);
CachedJob cached2 = CollectionsExt.first(snapshot2.cachedJobsById.values());
assertThat(cached2.getTasks()).hasSize(2);
assertThat(cached2.getTasks().get(updatedTask.getId())).isEqualTo(updatedTask);
}
@Test
public void testUpdateFinishedTask() {
PCollectionJobSnapshot initialSnapshot = initialSnapshot(2, true);
CachedJob cached1 = CollectionsExt.first(initialSnapshot.cachedJobsById.values());
Task someTask = CollectionsExt.first(cached1.getTasks().values());
Task updatedTask = someTask.toBuilder().withStatus(TaskStatus.newBuilder().withState(TaskState.Finished).build()).build();
// In archive mode we do not remove finished tasks immediately
PCollectionJobSnapshot snapshot2 = (PCollectionJobSnapshot) cached1.updateTask(initialSnapshot, updatedTask).orElse(null);
CachedJob cached2 = CollectionsExt.first(snapshot2.cachedJobsById.values());
assertThat(cached2.getTasks()).hasSize(2);
assertThat(cached2.getTasks().get(updatedTask.getId()).getStatus().getState()).isEqualTo(TaskState.Finished);
// Now remove it explicitly
PCollectionJobSnapshot snapshot3 = (PCollectionJobSnapshot) cached1.removeTask(initialSnapshot, updatedTask).orElse(null);
CachedJob cached3 = CollectionsExt.first(snapshot3.cachedJobsById.values());
assertThat(cached3.getTasks()).hasSize(1);
}
@Test
public void testRemoveTask() {
PCollectionJobSnapshot initialSnapshot = initialSnapshot(2, false);
CachedJob cached1 = CollectionsExt.first(initialSnapshot.cachedJobsById.values());
Task someTask = CollectionsExt.first(cached1.getTasks().values());
PCollectionJobSnapshot snapshot2 = (PCollectionJobSnapshot) cached1.removeTask(initialSnapshot, someTask).orElse(null);
CachedJob cached2 = CollectionsExt.first(snapshot2.cachedJobsById.values());
assertThat(cached2.getTasks()).hasSize(1);
}
private PCollectionJobSnapshot initialSnapshot(int taskCount, boolean archiveMode) {
Pair<Job<ServiceJobExt>, PMap<String, Task>> jobAndTasks = newServiceJobWithTasks(0, taskCount, 1_000);
Job<ServiceJobExt> job = jobAndTasks.getLeft();
Map<String, Task> tasks = new HashMap<>(jobAndTasks.getRight());
return PCollectionJobSnapshot.newInstance(
"test",
Collections.singletonMap(job.getId(), job),
Collections.singletonMap(job.getId(), tasks),
false,
archiveMode,
error -> {
throw new IllegalStateException(error);
},
titusRuntime
);
}
} | 1,171 |
0 | Create_ds/titus-control-plane/titus-client/src/test/java/com/netflix/titus/runtime/connector/jobmanager | Create_ds/titus-control-plane/titus-client/src/test/java/com/netflix/titus/runtime/connector/jobmanager/snapshot/JobSnapshotTestUtil.java | /*
* Copyright 2021 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.runtime.connector.jobmanager.snapshot;
import java.util.HashMap;
import java.util.Map;
import java.util.stream.Collectors;
import com.netflix.titus.api.jobmanager.model.job.Job;
import com.netflix.titus.api.jobmanager.model.job.JobDescriptor;
import com.netflix.titus.api.jobmanager.model.job.Task;
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.tuple.Pair;
import com.netflix.titus.testkit.model.job.JobDescriptorGenerator;
import com.netflix.titus.testkit.model.job.JobGenerator;
import org.pcollections.HashTreePMap;
import org.pcollections.PMap;
import static com.netflix.titus.api.jobmanager.model.job.JobFunctions.ofServiceSize;
class JobSnapshotTestUtil {
static JobSnapshot newSnapshot(JobSnapshotFactory factory, Pair<Job<?>, Map<String, Task>>... pairs) {
Map<String, Job<?>> jobsById = new HashMap<>();
Map<String, Map<String, Task>> tasksByJobId = new HashMap<>();
for (Pair<Job<?>, Map<String, Task>> pair : pairs) {
Job<?> job = pair.getLeft();
jobsById.put(job.getId(), job);
tasksByJobId.put(job.getId(), pair.getRight());
}
return factory.newSnapshot(jobsById, tasksByJobId);
}
static Pair<Job<?>, Map<String, Task>> newJobWithTasks(int jobIdx, int taskCount) {
return (Pair) newBatchJobWithTasks(jobIdx, taskCount);
}
static Pair<Job<ServiceJobExt>, PMap<String, Task>> newServiceJobWithTasks(int jobIdx, int taskCount, int maxSize) {
Job<ServiceJobExt> job = JobGenerator.serviceJobs(
JobDescriptorGenerator.serviceJobDescriptors(ofServiceSize(maxSize)).getValue()
).getValue().toBuilder().withId("job#" + jobIdx).build();
Map<String, Task> tasks = JobGenerator.serviceTasks(job).getValues(taskCount)
.stream().collect(Collectors.toMap(Task::getId, t -> t));
return Pair.of(job, HashTreePMap.from(tasks));
}
static Task newServiceTask(Job<ServiceJobExt> job, int taskIdx) {
return JobGenerator.serviceTasks(job).getValue().toBuilder()
.withId(job.getId() + "-Task#" + taskIdx)
.build();
}
static Pair<Job<BatchJobExt>, PMap<String, Task>> newBatchJobWithTasks(int jobIdx, int taskCount) {
Job<BatchJobExt> job = JobGenerator.batchJobs(JobDescriptorGenerator.batchJobDescriptor(taskCount)).getValue()
.toBuilder().withId("job#" + jobIdx).build();
Map<String, Task> tasks = JobGenerator.batchTasks(job).getValues(taskCount)
.stream().collect(Collectors.toMap(Task::getId, t -> t));
return Pair.of(job, HashTreePMap.from(tasks));
}
}
| 1,172 |
0 | Create_ds/titus-control-plane/titus-client/src/test/java/com/netflix/titus/runtime/connector/jobmanager | Create_ds/titus-control-plane/titus-client/src/test/java/com/netflix/titus/runtime/connector/jobmanager/replicator/GrpcJobReplicatorEventStreamTest.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.runtime.connector.jobmanager.replicator;
import java.time.Duration;
import java.util.ArrayList;
import java.util.List;
import java.util.Optional;
import java.util.concurrent.TimeoutException;
import com.netflix.titus.api.jobmanager.TaskAttributes;
import com.netflix.titus.api.jobmanager.model.job.BatchJobTask;
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.JobDescriptor;
import com.netflix.titus.api.jobmanager.model.job.JobFunctions;
import com.netflix.titus.api.jobmanager.model.job.JobState;
import com.netflix.titus.api.jobmanager.model.job.JobStatus;
import com.netflix.titus.api.jobmanager.model.job.Task;
import com.netflix.titus.api.jobmanager.model.job.TaskState;
import com.netflix.titus.api.jobmanager.model.job.TaskStatus;
import com.netflix.titus.api.jobmanager.model.job.event.JobManagerEvent;
import com.netflix.titus.api.jobmanager.model.job.event.JobUpdateEvent;
import com.netflix.titus.api.jobmanager.model.job.event.TaskUpdateEvent;
import com.netflix.titus.api.model.callmetadata.CallMetadata;
import com.netflix.titus.api.model.callmetadata.CallMetadataConstants;
import com.netflix.titus.common.runtime.TitusRuntime;
import com.netflix.titus.common.runtime.TitusRuntimes;
import com.netflix.titus.common.util.rx.ReactorExt;
import com.netflix.titus.common.util.tuple.Pair;
import com.netflix.titus.runtime.connector.common.replicator.DataReplicatorMetrics;
import com.netflix.titus.runtime.connector.common.replicator.ReplicatorEvent;
import com.netflix.titus.runtime.connector.jobmanager.JobConnectorConfiguration;
import com.netflix.titus.runtime.connector.jobmanager.JobManagementClient;
import com.netflix.titus.runtime.connector.jobmanager.replicator.GrpcJobReplicatorEventStream.CacheUpdater;
import com.netflix.titus.runtime.connector.jobmanager.snapshot.JobSnapshot;
import com.netflix.titus.runtime.connector.jobmanager.snapshot.JobSnapshotFactories;
import com.netflix.titus.testkit.model.job.JobComponentStub;
import com.netflix.titus.testkit.model.job.JobDescriptorGenerator;
import com.netflix.titus.testkit.model.job.JobGenerator;
import org.junit.Before;
import org.junit.Test;
import org.mockito.Mockito;
import reactor.core.scheduler.Schedulers;
import reactor.test.StepVerifier;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.fail;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
public class GrpcJobReplicatorEventStreamTest {
private static final String SERVICE_JOB = "serviceJob";
private static final String BATCH_JOB = "batchJob";
private static final int SERVICE_DESIRED = 5;
private static final int BATCH_DESIRED = 1;
private final TitusRuntime titusRuntime = TitusRuntimes.test();
private final JobConnectorConfiguration configuration = Mockito.mock(JobConnectorConfiguration.class);
private final JobComponentStub jobServiceStub = new JobComponentStub(titusRuntime);
private final JobManagementClient client = mock(JobManagementClient.class);
@Before
public void setUp() {
jobServiceStub.addJobTemplate(SERVICE_JOB, JobDescriptorGenerator.serviceJobDescriptors()
.map(jd -> jd.but(d -> d.getExtensions().toBuilder().withCapacity(Capacity.newBuilder().withDesired(SERVICE_DESIRED).withMax(10).build())))
.cast(JobDescriptor.class)
);
jobServiceStub.addJobTemplate(BATCH_JOB, JobDescriptorGenerator.batchJobDescriptors()
.map(jd -> jd.but(d -> d.getExtensions().toBuilder().withSize(BATCH_DESIRED)))
.cast(JobDescriptor.class)
);
}
@Test
public void testCacheBootstrap() {
jobServiceStub.creteMultipleJobsAndTasks(SERVICE_JOB, BATCH_JOB);
newConnectVerifier()
.assertNext(initialReplicatorEvent -> {
assertThat(initialReplicatorEvent).isNotNull();
JobSnapshot cache = initialReplicatorEvent.getSnapshot();
assertThat(cache.getJobMap()).hasSize(2);
assertThat(cache.getTaskMap()).hasSize(SERVICE_DESIRED + BATCH_DESIRED);
})
.thenCancel()
.verify();
}
@Test
public void testCacheJobUpdate() {
Job job = jobServiceStub.createJob(SERVICE_JOB);
newConnectVerifier()
.assertNext(next -> assertThat(next.getSnapshot().getJobs().get(0).getStatus().getState()).isEqualTo(JobState.Accepted))
.then(() -> jobServiceStub.moveJobToKillInitiatedState(job))
.assertNext(next -> assertThat(next.getSnapshot().getJobs().get(0).getStatus().getState()).isEqualTo(JobState.KillInitiated))
.thenCancel()
.verify();
}
@Test
public void testCacheJobRemove() {
Job job = jobServiceStub.createJob(SERVICE_JOB);
jobServiceStub.moveJobToKillInitiatedState(job);
newConnectVerifier()
.assertNext(next -> assertThat(next.getSnapshot().getJobs().get(0).getStatus().getState()).isEqualTo(JobState.KillInitiated))
.then(() -> jobServiceStub.finishJob(job))
.assertNext(next -> assertThat(next.getSnapshot().getJobs()).isEmpty())
.thenCancel()
.verify();
}
@Test
public void testCacheTaskUpdate() {
Pair<Job, List<Task>> pair = jobServiceStub.createJobAndTasks(BATCH_JOB);
Task task = pair.getRight().get(0);
newConnectVerifier()
.assertNext(next -> assertThat(next.getSnapshot().getTasks().get(0).getStatus().getState()).isEqualTo(TaskState.Accepted))
.then(() -> jobServiceStub.moveTaskToState(task, TaskState.Launched))
.assertNext(next -> assertThat(next.getSnapshot().getTasks().get(0).getStatus().getState()).isEqualTo(TaskState.Launched))
.thenCancel()
.verify();
}
@Test
public void testCacheTaskMove() {
Pair<Job, List<Task>> pair = jobServiceStub.createJobAndTasks(SERVICE_JOB);
Job target = jobServiceStub.createJob(SERVICE_JOB);
Task task = pair.getRight().get(0);
String sourceJobId = pair.getLeft().getId();
String targetJobId = target.getId();
List<ReplicatorEvent<JobSnapshot, JobManagerEvent<?>>> events = new ArrayList<>();
newConnectVerifier()
.assertNext(next -> assertThat(next.getSnapshot().getTaskMap().values())
.allSatisfy(t -> assertThat(t.getStatus().getState()).isEqualTo(TaskState.Accepted)))
.then(() -> jobServiceStub.moveTaskToState(task, TaskState.Started))
.assertNext(next -> {
JobSnapshot snapshot = next.getSnapshot();
Optional<Pair<Job<?>, Task>> taskOpt = snapshot.findTaskById(task.getId());
assertThat(taskOpt).isPresent();
assertThat(taskOpt.get().getRight().getStatus().getState()).isEqualTo(TaskState.Started);
assertThat(snapshot.getTasks(sourceJobId)).containsKey(task.getId());
})
.then(() -> jobServiceStub.getJobOperations()
.moveServiceTask(sourceJobId, targetJobId, task.getId(), CallMetadata.newBuilder().withCallerId("Test").withCallReason("testing").build())
.test()
.awaitTerminalEvent()
.assertNoErrors()
)
.recordWith(() -> events)
.thenConsumeWhile(next -> {
JobManagerEvent<?> trigger = next.getTrigger();
if (!(trigger instanceof TaskUpdateEvent)) {
return true;
}
TaskUpdateEvent taskUpdateEvent = (TaskUpdateEvent) trigger;
return !taskUpdateEvent.isMovedFromAnotherJob();
})
.thenCancel()
.verify();
assertThat(events).hasSize(3);
events.stream().map(ReplicatorEvent::getTrigger).forEach(jobManagerEvent -> {
if (jobManagerEvent instanceof JobUpdateEvent) {
JobUpdateEvent jobUpdateEvent = (JobUpdateEvent) jobManagerEvent;
String eventJobId = jobUpdateEvent.getCurrent().getId();
assertThat(eventJobId).isIn(sourceJobId, targetJobId);
} else if (jobManagerEvent instanceof TaskUpdateEvent) {
TaskUpdateEvent taskUpdateEvent = (TaskUpdateEvent) jobManagerEvent;
assertThat(taskUpdateEvent.isMovedFromAnotherJob()).isTrue();
assertThat(taskUpdateEvent.getCurrentJob().getId()).isEqualTo(targetJobId);
assertThat(taskUpdateEvent.getCurrent().getJobId()).isEqualTo(targetJobId);
assertThat(taskUpdateEvent.getCurrent().getTaskContext().get(TaskAttributes.TASK_ATTRIBUTES_MOVED_FROM_JOB))
.isEqualTo(sourceJobId);
} else {
fail("Unexpected event type: %s", jobManagerEvent);
}
});
}
@Test
public void testCacheTaskRemove() {
Pair<Job, List<Task>> pair = jobServiceStub.createJobAndTasks(SERVICE_JOB);
List<Task> tasks = pair.getRight();
Task task = tasks.get(0);
newConnectVerifier()
.assertNext(next -> assertThat(next.getSnapshot().getTasks().get(0).getStatus().getState()).isEqualTo(TaskState.Accepted))
.then(() -> jobServiceStub.moveTaskToState(task, TaskState.Finished))
.assertNext(next -> assertThat(next.getSnapshot().getTaskMap()).hasSize(tasks.size() - 1))
.thenCancel()
.verify();
}
@Test
public void testReemit() {
jobServiceStub.creteMultipleJobsAndTasks(SERVICE_JOB, BATCH_JOB);
newConnectVerifier()
.expectNextCount(1)
.expectNoEvent(Duration.ofMillis(GrpcJobReplicatorEventStream.LATENCY_REPORT_INTERVAL_MS))
.expectNextCount(1)
.thenCancel()
.verify();
}
@Test
public void testConnectionTimeout() {
when(configuration.getConnectionTimeoutMs()).thenReturn(30_000L);
when(configuration.isConnectionTimeoutEnabled()).thenReturn(true);
jobServiceStub.creteMultipleJobsAndTasks(SERVICE_JOB, BATCH_JOB);
jobServiceStub.delayConnection();
newConnectVerifier()
.thenAwait(Duration.ofMillis(30_000))
.expectError(TimeoutException.class)
.verify();
}
@Test
public void testCacheSnapshotFiltersCompletedJobs() {
Job<?> acceptedJob = JobGenerator.oneBatchJob();
BatchJobTask acceptedTask = JobGenerator.oneBatchTask().toBuilder()
.withJobId(acceptedJob.getId())
.withStatus(TaskStatus.newBuilder().withState(TaskState.Accepted).build())
.build();
Job<?> finishedJob = JobFunctions.changeJobStatus(acceptedJob, JobStatus.newBuilder().withState(JobState.Finished).build());
Task finishedTask = JobFunctions.changeTaskStatus(acceptedTask, TaskStatus.newBuilder().withState(TaskState.Finished).build());
CacheUpdater cacheUpdater = new CacheUpdater(JobSnapshotFactories.newDefault(titusRuntime), false, titusRuntime);
assertThat(cacheUpdater.onEvent(JobUpdateEvent.newJob(acceptedJob, CallMetadataConstants.UNDEFINED_CALL_METADATA))).isEmpty();
assertThat(cacheUpdater.onEvent(TaskUpdateEvent.newTask(acceptedJob, acceptedTask, CallMetadataConstants.UNDEFINED_CALL_METADATA))).isEmpty();
assertThat(cacheUpdater.onEvent(TaskUpdateEvent.taskChange(acceptedJob, finishedTask, acceptedTask, CallMetadataConstants.UNDEFINED_CALL_METADATA))).isEmpty();
assertThat(cacheUpdater.onEvent(JobUpdateEvent.jobChange(finishedJob, acceptedJob, CallMetadataConstants.UNDEFINED_CALL_METADATA))).isEmpty();
ReplicatorEvent<JobSnapshot, JobManagerEvent<?>> snapshotEvent = cacheUpdater.onEvent(JobManagerEvent.snapshotMarker()).orElse(null);
assertThat(snapshotEvent).isNotNull();
assertThat(snapshotEvent.getSnapshot().getJobMap()).isEmpty();
assertThat(snapshotEvent.getSnapshot().getTaskMap()).isEmpty();
}
private GrpcJobReplicatorEventStream newStream() {
when(client.observeJobs(any())).thenReturn(ReactorExt.toFlux(jobServiceStub.observeJobs(true)));
return new GrpcJobReplicatorEventStream(client, JobSnapshotFactories.newDefault(titusRuntime), configuration, new DataReplicatorMetrics("test", false, titusRuntime), titusRuntime, Schedulers.parallel());
}
private StepVerifier.FirstStep<ReplicatorEvent<JobSnapshot, JobManagerEvent<?>>> newConnectVerifier() {
return StepVerifier.withVirtualTime(() -> newStream().connect().log());
}
}
| 1,173 |
0 | Create_ds/titus-control-plane/titus-client/src/test/java/com/netflix/titus/runtime/connector/common | Create_ds/titus-control-plane/titus-client/src/test/java/com/netflix/titus/runtime/connector/common/replicator/StreamDataReplicatorTest.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.runtime.connector.common.replicator;
import java.time.Duration;
import java.util.Objects;
import java.util.concurrent.atomic.AtomicReference;
import com.netflix.titus.common.runtime.TitusRuntime;
import com.netflix.titus.common.runtime.TitusRuntimes;
import org.junit.Test;
import reactor.core.publisher.Flux;
import reactor.core.publisher.Sinks;
import reactor.test.StepVerifier;
import static org.assertj.core.api.Assertions.assertThat;
public class StreamDataReplicatorTest {
private final TitusRuntime titusRuntime = TitusRuntimes.test();
private final ReplicatorEventStreamStub replicatorEventStream = new ReplicatorEventStreamStub();
private final DataReplicatorMetrics metrics = new DataReplicatorMetrics("test", false, titusRuntime);
private final Sinks.Many<ReplicatorEvent<StringSnapshot, String>> eventSink = Sinks.many().multicast().directAllOrNothing();
@Test
public void testBootstrap() {
StepVerifier
.withVirtualTime(() -> StreamDataReplicator.newStreamDataReplicator(replicatorEventStream, false, metrics, titusRuntime))
.expectSubscription()
.expectNoEvent(Duration.ofSeconds(1))
.then(() -> eventSink.emitNext(new ReplicatorEvent<>(new StringSnapshot("firstUpdate"), "firstTrigger", 0), Sinks.EmitFailureHandler.FAIL_FAST))
.assertNext(replicator -> {
assertThat(replicator.getCurrent()).isEqualTo(new StringSnapshot("firstUpdate"));
})
.thenCancel()
.verify();
}
@Test
public void testShutdown() {
AtomicReference<StreamDataReplicator> replicatorRef = new AtomicReference<>();
StepVerifier
.withVirtualTime(() ->
StreamDataReplicator.newStreamDataReplicator(replicatorEventStream, false, metrics, titusRuntime)
.flatMap(replicator -> {
replicatorRef.set(replicator);
return replicator.events();
})
)
.expectSubscription()
.then(() -> eventSink.emitNext(new ReplicatorEvent<>(new StringSnapshot("firstUpdate"), "firstTrigger", 0), Sinks.EmitFailureHandler.FAIL_FAST))
.then(() -> {
assertThat(eventSink.currentSubscriberCount()).isEqualTo(1);
replicatorRef.get().close();
assertThat(eventSink.currentSubscriberCount()).isZero();
})
.verifyErrorMatches(error -> error.getMessage().equals("Data replicator closed"));
}
private static class StringSnapshot extends ReplicatedSnapshot {
private final String value;
private StringSnapshot(String value) {
this.value = value;
}
@Override
public boolean equals(Object o) {
if (this == o) {
return true;
}
if (o == null || getClass() != o.getClass()) {
return false;
}
StringSnapshot that = (StringSnapshot) o;
return Objects.equals(value, that.value);
}
@Override
public int hashCode() {
return Objects.hash(value);
}
@Override
public String toSummaryString() {
return value;
}
}
private class ReplicatorEventStreamStub implements ReplicatorEventStream<StringSnapshot, String> {
@Override
public Flux<ReplicatorEvent<StringSnapshot, String>> connect() {
return eventSink.asFlux();
}
}
} | 1,174 |
0 | Create_ds/titus-control-plane/titus-client/src/test/java/com/netflix/titus/runtime/connector/common | Create_ds/titus-control-plane/titus-client/src/test/java/com/netflix/titus/runtime/connector/common/replicator/RetryableReplicatorEventStreamTest.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.runtime.connector.common.replicator;
import java.time.Duration;
import com.netflix.titus.common.runtime.TitusRuntime;
import com.netflix.titus.common.runtime.TitusRuntimes;
import org.junit.Test;
import org.reactivestreams.Processor;
import reactor.core.publisher.EmitterProcessor;
import reactor.core.publisher.Flux;
import reactor.core.scheduler.Schedulers;
import reactor.test.StepVerifier;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
public class RetryableReplicatorEventStreamTest {
private final TitusRuntime titusRuntime = TitusRuntimes.test();
private final ReplicatorEventStream<String, String> delegate = mock(ReplicatorEventStream.class);
private Processor<ReplicatorEvent<String, String>, ReplicatorEvent<String, String>> eventSubject;
@Test
public void testImmediateConnect() {
newConnectVerifier()
// Event 1
.then(() -> eventSubject.onNext(new ReplicatorEvent<>("event1", "trigger1", 1)))
.assertNext(e -> assertThat(e.getLastUpdateTime()).isEqualTo(1))
// Event 2
.then(() -> eventSubject.onNext(new ReplicatorEvent<>("event2", "trigger2", 2)))
.assertNext(e -> assertThat(e.getLastUpdateTime()).isEqualTo(2))
.thenCancel()
.verify();
}
@Test
public void testImmediateFailureWithSuccessfulReconnect() {
newConnectVerifier()
// Simulated error
.then(() -> eventSubject.onError(new RuntimeException("simulated error")))
.expectNoEvent(Duration.ofMillis(RetryableReplicatorEventStream.INITIAL_RETRY_DELAY_MS))
// Event 1
.then(() -> eventSubject.onNext(new ReplicatorEvent<>("event1", "trigger1", 1)))
.assertNext(e -> assertThat(e.getLastUpdateTime()).isEqualTo(1))
.thenCancel()
.verify();
}
@Test
public void testReconnectAfterFailure() {
newConnectVerifier()
// Event 1
.then(() -> eventSubject.onNext(new ReplicatorEvent<>("event1", "trigger1", 1)))
.assertNext(e -> assertThat(e.getLastUpdateTime()).isEqualTo(1))
// Now fail
.then(() -> eventSubject.onError(new RuntimeException("simulated error")))
.expectNoEvent(Duration.ofMillis(RetryableReplicatorEventStream.INITIAL_RETRY_DELAY_MS))
// Recover
.then(() -> eventSubject.onNext(new ReplicatorEvent<>("even2", "trigger2", 2)))
.assertNext(e -> assertThat(e.getLastUpdateTime()).isEqualTo(2))
// Fail again
.then(() -> eventSubject.onError(new RuntimeException("simulated error")))
.expectNoEvent(Duration.ofMillis(RetryableReplicatorEventStream.INITIAL_RETRY_DELAY_MS * 2))
// Recover again
.then(() -> eventSubject.onNext(new ReplicatorEvent<>("even3", "trigger3", 3)))
.assertNext(e -> assertThat(e.getLastUpdateTime()).isEqualTo(3))
.thenCancel()
.verify();
}
@Test
public void testInProlongedOutageTheLastKnownItemIsReEmitted() {
newConnectVerifier()
// Event 1
.then(() -> eventSubject.onNext(new ReplicatorEvent<>("event1", "trigger1", 1)))
.assertNext(e -> assertThat(e.getLastUpdateTime()).isEqualTo(1))
// Now fail
.then(() -> eventSubject.onError(new RuntimeException("simulated error")))
// Expect re-emit
.expectNoEvent(Duration.ofMillis(RetryableReplicatorEventStream.LATENCY_REPORT_INTERVAL_MS))
.assertNext(e -> assertThat(e.getLastUpdateTime()).isEqualTo(1))
.thenCancel()
.verify();
}
private RetryableReplicatorEventStream<String, String> newStream() {
when(delegate.connect()).thenAnswer(invocation -> Flux.defer(() -> {
eventSubject = EmitterProcessor.create();
return eventSubject;
}));
return new RetryableReplicatorEventStream<>(
delegate, new DataReplicatorMetrics("test", false, titusRuntime), titusRuntime, Schedulers.parallel()
);
}
private StepVerifier.FirstStep<ReplicatorEvent<String, String>> newConnectVerifier() {
return StepVerifier.withVirtualTime(() -> newStream().connect().log());
}
} | 1,175 |
0 | Create_ds/titus-control-plane/titus-client/src/test/java/com/netflix/titus/runtime/connector/common | Create_ds/titus-control-plane/titus-client/src/test/java/com/netflix/titus/runtime/connector/common/replicator/StreamDataReplicatorPerf.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.runtime.connector.common.replicator;
import java.time.Duration;
import com.netflix.titus.api.jobmanager.model.job.Job;
import com.netflix.titus.api.jobmanager.model.job.Task;
import com.netflix.titus.api.jobmanager.model.job.event.JobManagerEvent;
import com.netflix.titus.api.jobmanager.model.job.event.JobUpdateEvent;
import com.netflix.titus.api.jobmanager.model.job.event.TaskUpdateEvent;
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.runtime.connector.jobmanager.JobDataReplicator;
import com.netflix.titus.runtime.connector.jobmanager.JobManagementClient;
import com.netflix.titus.runtime.connector.jobmanager.JobConnectorConfiguration;
import com.netflix.titus.runtime.connector.jobmanager.replicator.JobDataReplicatorProvider;
import com.netflix.titus.runtime.connector.jobmanager.snapshot.JobSnapshotFactories;
import com.netflix.titus.testkit.model.job.JobGenerator;
import org.mockito.ArgumentMatchers;
import org.mockito.Mockito;
import reactor.core.publisher.Flux;
/**
* Test to expose memory leaks.
*/
public class StreamDataReplicatorPerf {
private static final Job<?> JOB = JobGenerator.oneBatchJob();
private static final Task TASK = JobGenerator.oneBatchTask().toBuilder().withJobId(JOB.getId()).build();
public static void main(String[] args) throws InterruptedException {
TitusRuntime titusRuntime = TitusRuntimes.internal();
JobManagementClient client = Mockito.mock(JobManagementClient.class);
JobConnectorConfiguration configuration = Mockito.mock(JobConnectorConfiguration.class);
Mockito.when(client.observeJobs(ArgumentMatchers.any())).thenAnswer(invocation -> Flux.defer(() -> {
JobManagerEvent jobUpdateEvent = JobUpdateEvent.newJob(JOB, JobManagerConstants.GRPC_REPLICATOR_CALL_METADATA);
JobManagerEvent taskUpdateEvent = TaskUpdateEvent.newTask(JOB, TASK, JobManagerConstants.GRPC_REPLICATOR_CALL_METADATA);
return Flux.just(jobUpdateEvent, JobManagerEvent.snapshotMarker())
.concatWith(Flux.interval(Duration.ofSeconds(1)).take(1).map(tick -> taskUpdateEvent))
.concatWith(Flux.interval(Duration.ofSeconds(1)).take(1).flatMap(tick -> Flux.error(new RuntimeException("Simulated error"))));
}));
JobDataReplicator replicator = new JobDataReplicatorProvider(configuration, client,
JobSnapshotFactories.newDefault(titusRuntime), titusRuntime
).get();
replicator.events().subscribe(System.out::println);
Thread.sleep(3600_000);
}
}
| 1,176 |
0 | Create_ds/titus-control-plane/titus-client/src/test/java/com/netflix/titus/runtime/connector/relocation | Create_ds/titus-control-plane/titus-client/src/test/java/com/netflix/titus/runtime/connector/relocation/replicator/GrpcRelocationReplicatorEventStreamTest.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.runtime.connector.relocation.replicator;
import com.netflix.titus.api.relocation.model.TaskRelocationPlan;
import com.netflix.titus.api.relocation.model.event.TaskRelocationEvent;
import com.netflix.titus.common.runtime.TitusRuntime;
import com.netflix.titus.common.runtime.TitusRuntimes;
import com.netflix.titus.runtime.connector.common.replicator.DataReplicatorMetrics;
import com.netflix.titus.runtime.connector.common.replicator.ReplicatorEvent;
import com.netflix.titus.runtime.connector.relocation.RelocationServiceClient;
import com.netflix.titus.runtime.connector.relocation.TaskRelocationSnapshot;
import com.netflix.titus.testkit.model.relocation.RelocationComponentStub;
import org.junit.Test;
import reactor.core.scheduler.Schedulers;
import reactor.test.StepVerifier;
import static org.assertj.core.api.Assertions.assertThat;
public class GrpcRelocationReplicatorEventStreamTest {
private final TitusRuntime titusRuntime = TitusRuntimes.test();
private final RelocationComponentStub relocationConnectorStubs = new RelocationComponentStub(titusRuntime);
private final RelocationServiceClient client = relocationConnectorStubs.getClient();
@Test
public void testCacheBootstrap() {
relocationConnectorStubs.addPlan(TaskRelocationPlan.newBuilder().withTaskId("task1").build());
newConnectVerifier()
.assertNext(snapshotEvent -> {
assertThat(snapshotEvent.getSnapshot().getPlans()).containsKey("task1");
})
.thenCancel()
.verify();
}
@Test
public void testPlanAddAndRemove() {
newConnectVerifier()
.assertNext(snapshotEvent -> {
assertThat(snapshotEvent.getSnapshot().getPlans()).isEmpty();
})
.then(() ->
relocationConnectorStubs.addPlan(TaskRelocationPlan.newBuilder().withTaskId("task1").build())
)
.assertNext(snapshotEvent -> {
assertThat(snapshotEvent.getSnapshot().getPlans()).containsKey("task1");
})
.then(() -> {
relocationConnectorStubs.removePlan("task1");
})
.thenCancel()
.verify();
}
private GrpcRelocationReplicatorEventStream newStream() {
return new GrpcRelocationReplicatorEventStream(client, new DataReplicatorMetrics("test", false, titusRuntime), titusRuntime, Schedulers.parallel());
}
private StepVerifier.FirstStep<ReplicatorEvent<TaskRelocationSnapshot, TaskRelocationEvent>> newConnectVerifier() {
return StepVerifier.withVirtualTime(() -> newStream().connect().log());
}
} | 1,177 |
0 | Create_ds/titus-control-plane/titus-client/src/test/java/com/netflix/titus/runtime/connector/eviction | Create_ds/titus-control-plane/titus-client/src/test/java/com/netflix/titus/runtime/connector/eviction/replicator/GrpcEvictionReplicatorEventStreamTest.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.runtime.connector.eviction.replicator;
import java.time.Duration;
import com.netflix.titus.api.eviction.model.event.EvictionEvent;
import com.netflix.titus.api.model.reference.Reference;
import com.netflix.titus.common.runtime.TitusRuntime;
import com.netflix.titus.common.runtime.TitusRuntimes;
import com.netflix.titus.runtime.connector.common.replicator.DataReplicatorMetrics;
import com.netflix.titus.runtime.connector.common.replicator.ReplicatorEvent;
import com.netflix.titus.runtime.connector.eviction.EvictionDataSnapshot;
import com.netflix.titus.runtime.connector.eviction.EvictionServiceClient;
import com.netflix.titus.runtime.connector.jobmanager.replicator.GrpcJobReplicatorEventStream;
import com.netflix.titus.testkit.model.eviction.EvictionComponentStub;
import com.netflix.titus.testkit.model.job.JobComponentStub;
import org.junit.Test;
import reactor.core.scheduler.Schedulers;
import reactor.test.StepVerifier;
import static org.assertj.core.api.Assertions.assertThat;
public class GrpcEvictionReplicatorEventStreamTest {
private final TitusRuntime titusRuntime = TitusRuntimes.test();
private final JobComponentStub JobComponentStub = new JobComponentStub(titusRuntime);
private final EvictionComponentStub evictionComponentStub = new EvictionComponentStub(
JobComponentStub,
titusRuntime
);
private final EvictionServiceClient client = evictionComponentStub.getEvictionServiceClient();
@Test
public void testCacheBootstrap() {
evictionComponentStub.setSystemQuota(25);
evictionComponentStub.setJobQuota("job1", 5);
newConnectVerifier()
.assertNext(initialReplicatorEvent -> {
assertThat(initialReplicatorEvent).isNotNull();
EvictionDataSnapshot cache = initialReplicatorEvent.getSnapshot();
assertThat(cache.getSystemEvictionQuota().getQuota()).isEqualTo(25);
assertThat(cache.findEvictionQuota(Reference.job("job1")).get().getQuota()).isEqualTo(5);
})
.thenCancel()
.verify();
}
@Test
public void testSystemQuotaUpdate() {
evictionComponentStub.setSystemQuota(25);
newConnectVerifier()
.assertNext(next -> assertThat(next.getSnapshot().getSystemEvictionQuota().getQuota()).isEqualTo(25))
.then(() -> evictionComponentStub.setSystemQuota(50))
.thenConsumeWhile(next -> !isSystemQuotaUpdate(next, 50))
.assertNext(next -> assertThat(next.getSnapshot().getSystemEvictionQuota().getQuota()).isEqualTo(50))
.thenCancel()
.verify();
}
@Test
public void testJobQuotaUpdate() {
evictionComponentStub.setJobQuota("job1", 1);
newConnectVerifier()
.assertNext(next -> assertThat(next.getSnapshot().findEvictionQuota(Reference.job("job1")).get().getQuota()).isEqualTo(1))
.then(() -> evictionComponentStub.setJobQuota("job1", 5))
.thenConsumeWhile(next -> !isJobQuotaUpdate(next, "job1", 5))
.assertNext(next -> assertThat(next.getSnapshot().findEvictionQuota(Reference.job("job1")).get().getQuota()).isEqualTo(5))
.thenCancel()
.verify();
}
@Test
public void testReEmit() {
newConnectVerifier()
.expectNextCount(1)
.expectNoEvent(Duration.ofMillis(GrpcJobReplicatorEventStream.LATENCY_REPORT_INTERVAL_MS))
.expectNextCount(1)
.thenCancel()
.verify();
}
private GrpcEvictionReplicatorEventStream newStream() {
return new GrpcEvictionReplicatorEventStream(client, new DataReplicatorMetrics("test", false, titusRuntime), titusRuntime, Schedulers.parallel());
}
private StepVerifier.FirstStep<ReplicatorEvent<EvictionDataSnapshot, EvictionEvent>> newConnectVerifier() {
return StepVerifier.withVirtualTime(() -> newStream().connect().log());
}
private boolean isSystemQuotaUpdate(ReplicatorEvent<EvictionDataSnapshot, EvictionEvent> event, int expectedSystemQuota) {
return event.getSnapshot().getSystemEvictionQuota().getQuota() == expectedSystemQuota;
}
private boolean isJobQuotaUpdate(ReplicatorEvent<EvictionDataSnapshot, EvictionEvent> event, String jobId, int expectedJobQuota) {
return event.getSnapshot().findEvictionQuota(Reference.job(jobId)).map(q -> q.getQuota() == expectedJobQuota).orElse(false);
}
} | 1,178 |
0 | Create_ds/titus-control-plane/titus-client/src/main/java/com/netflix/titus/runtime/relocation | Create_ds/titus-control-plane/titus-client/src/main/java/com/netflix/titus/runtime/relocation/endpoint/RelocationGrpcModelConverters.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.runtime.relocation.endpoint;
import java.util.List;
import java.util.Optional;
import java.util.stream.Collectors;
import com.google.common.base.Preconditions;
import com.netflix.titus.api.relocation.model.TaskRelocationPlan;
import com.netflix.titus.api.relocation.model.TaskRelocationStatus;
import com.netflix.titus.api.relocation.model.TaskRelocationStatus.TaskRelocationState;
import com.netflix.titus.api.relocation.model.event.TaskRelocationEvent;
import com.netflix.titus.api.relocation.model.event.TaskRelocationPlanRemovedEvent;
import com.netflix.titus.api.relocation.model.event.TaskRelocationPlanUpdateEvent;
import com.netflix.titus.grpc.protogen.RelocationEvent;
import com.netflix.titus.grpc.protogen.TaskRelocationExecution;
import com.netflix.titus.grpc.protogen.TaskRelocationExecutions;
import com.netflix.titus.grpc.protogen.TaskRelocationPlans;
import static com.netflix.titus.common.util.CollectionsExt.last;
public class RelocationGrpcModelConverters {
public static TaskRelocationPlans toGrpcTaskRelocationPlans(List<TaskRelocationPlan> corePlans) {
return TaskRelocationPlans.newBuilder()
.addAllPlans(corePlans.stream().map(RelocationGrpcModelConverters::toGrpcTaskRelocationPlan).collect(Collectors.toList()))
.build();
}
public static com.netflix.titus.grpc.protogen.TaskRelocationPlan toGrpcTaskRelocationPlan(TaskRelocationPlan plan) {
return com.netflix.titus.grpc.protogen.TaskRelocationPlan.newBuilder()
.setTaskId(plan.getTaskId())
.setReasonCode(plan.getReason().name())
.setReasonMessage(plan.getReasonMessage())
.setDecisionTime(plan.getDecisionTime())
.setRelocationTime(plan.getRelocationTime())
.build();
}
public static TaskRelocationPlan toCoreTaskRelocationPlan(com.netflix.titus.grpc.protogen.TaskRelocationPlan grpcPlan) {
return TaskRelocationPlan.newBuilder()
.withTaskId(grpcPlan.getTaskId())
.withReason(TaskRelocationPlan.TaskRelocationReason.valueOf(grpcPlan.getReasonCode()))
.withReasonMessage(grpcPlan.getReasonMessage())
.withDecisionTime(grpcPlan.getDecisionTime())
.withRelocationTime(grpcPlan.getRelocationTime())
.build();
}
public static TaskRelocationExecution toGrpcTaskRelocationExecution(List<TaskRelocationStatus> attempts) {
Preconditions.checkArgument(!attempts.isEmpty(), "Empty list of TaskRelocationStatus objects");
return TaskRelocationExecution.newBuilder()
.setTaskRelocationPlan(toGrpcTaskRelocationPlan(last(attempts).getTaskRelocationPlan()))
.addAllRelocationAttempts(attempts.stream().map(RelocationGrpcModelConverters::toGrpcTaskRelocationStatus).collect(Collectors.toList()))
.build();
}
public static TaskRelocationExecution toGrpcTaskRelocationExecution(TaskRelocationStatus coreResult) {
return TaskRelocationExecution.newBuilder()
.addRelocationAttempts(toGrpcTaskRelocationStatus(coreResult))
.setTaskRelocationPlan(toGrpcTaskRelocationPlan(coreResult.getTaskRelocationPlan()))
.build();
}
public static TaskRelocationExecutions toGrpcTaskRelocationExecutions(List<TaskRelocationStatus> coreResults) {
return TaskRelocationExecutions.newBuilder()
.addAllResults(coreResults.stream().map(RelocationGrpcModelConverters::toGrpcTaskRelocationExecution).collect(Collectors.toList()))
.build();
}
public static com.netflix.titus.grpc.protogen.TaskRelocationStatus toGrpcTaskRelocationStatus(TaskRelocationStatus coreResult) {
return com.netflix.titus.grpc.protogen.TaskRelocationStatus.newBuilder()
.setState(toGrpcRelocationState(coreResult.getState()))
.setStatusCode(coreResult.getStatusCode())
.setStatusMessage(coreResult.getStatusMessage())
.build();
}
public static com.netflix.titus.grpc.protogen.TaskRelocationStatus.TaskRelocationState toGrpcRelocationState(TaskRelocationState coreState) {
switch (coreState) {
case Success:
return com.netflix.titus.grpc.protogen.TaskRelocationStatus.TaskRelocationState.Success;
case Failure:
return com.netflix.titus.grpc.protogen.TaskRelocationStatus.TaskRelocationState.Failure;
}
throw new IllegalStateException("Unrecognized state: " + coreState);
}
public static Optional<RelocationEvent> toGrpcRelocationEvent(TaskRelocationEvent coreEvent) {
RelocationEvent grpcEvent = null;
if (coreEvent.equals(TaskRelocationEvent.newSnapshotEndEvent())) {
grpcEvent = RelocationEvent.newBuilder()
.setSnapshotEnd(RelocationEvent.SnapshotEnd.getDefaultInstance())
.build();
} else if (coreEvent instanceof TaskRelocationPlanUpdateEvent) {
TaskRelocationPlanUpdateEvent updateEvent = (TaskRelocationPlanUpdateEvent) coreEvent;
grpcEvent = RelocationEvent.newBuilder()
.setTaskRelocationPlanUpdateEvent(RelocationEvent.TaskRelocationPlanUpdateEvent.newBuilder()
.setPlan(toGrpcTaskRelocationPlan(updateEvent.getPlan()))
)
.build();
} else if (coreEvent instanceof TaskRelocationPlanRemovedEvent) {
TaskRelocationPlanRemovedEvent removedEvent = (TaskRelocationPlanRemovedEvent) coreEvent;
grpcEvent = RelocationEvent.newBuilder()
.setTaskRelocationPlanRemoveEvent(RelocationEvent.TaskRelocationPlanRemoveEvent.newBuilder()
.setTaskId(removedEvent.getTaskId())
)
.build();
}
return Optional.ofNullable(grpcEvent);
}
public static Optional<TaskRelocationEvent> toCoreRelocationEvent(RelocationEvent grpcEvent) {
switch (grpcEvent.getEventCase()) {
case SNAPSHOTEND:
return Optional.of(TaskRelocationEvent.newSnapshotEndEvent());
case TASKRELOCATIONPLANUPDATEEVENT:
return Optional.of(TaskRelocationEvent.taskRelocationPlanUpdated(toCoreTaskRelocationPlan(grpcEvent.getTaskRelocationPlanUpdateEvent().getPlan())));
case TASKRELOCATIONPLANREMOVEEVENT:
return Optional.of(TaskRelocationEvent.taskRelocationPlanRemoved(grpcEvent.getTaskRelocationPlanRemoveEvent().getTaskId()));
case TASKRELOCATIONRESULTEVENT:
case EVENT_NOT_SET:
default:
return Optional.empty();
}
}
}
| 1,179 |
0 | Create_ds/titus-control-plane/titus-client/src/main/java/com/netflix/titus/runtime | Create_ds/titus-control-plane/titus-client/src/main/java/com/netflix/titus/runtime/endpoint/JobQueryCriteria.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.runtime.endpoint;
import java.util.Collections;
import java.util.Map;
import java.util.Objects;
import java.util.Optional;
import java.util.Set;
import com.netflix.titus.common.util.CollectionsExt;
import static com.netflix.titus.common.util.CollectionsExt.nonNull;
/**
* {@link JobQueryCriteria} covers now v2 API search criteria. It must be refactored once v3 query mechanism
* is finalized.
*/
public class JobQueryCriteria<TASK_STATE, JOB_TYPE extends Enum<JOB_TYPE>> {
private final Set<String> jobIds;
private final Set<String> taskIds;
private final boolean includeArchived;
private final Optional<Object> jobState;
private final Set<TASK_STATE> taskStates;
private final Set<String> taskStateReasons;
private final Optional<String> owner;
private final Map<String, Set<String>> labels;
private final boolean labelsAndOp;
private final Optional<String> imageName;
private final Optional<String> imageTag;
private final Optional<String> appName;
private final Optional<String> capacityGroup;
private final Optional<JOB_TYPE> jobType;
private final Optional<String> jobGroupStack;
private final Optional<String> jobGroupDetail;
private final Optional<String> jobGroupSequence;
private final boolean needsMigration;
private final boolean skipSystemFailures;
private final Optional<String> platformSidecar;
private final Optional<String> platformSidecarChannel;
private final int limit;
private JobQueryCriteria(Set<String> jobIds,
Set<String> taskIds,
boolean includeArchived,
Object jobState,
Set<TASK_STATE> taskStates,
Set<String> taskStateReasons,
String owner,
Map<String, Set<String>> labels,
boolean labelsAndOp,
String imageName,
String imageTag,
String appName,
String capacityGroup,
JOB_TYPE jobType,
String jobGroupStack,
String jobGroupDetail,
String jobGroupSequence,
boolean needsMigration,
boolean skipSystemFailures,
String platformSidecar,
String platformSidecarChannel,
int limit) {
this.jobIds = nonNull(jobIds);
this.taskIds = nonNull(taskIds);
this.includeArchived = includeArchived;
this.jobState = Optional.ofNullable(jobState);
this.taskStates = CollectionsExt.nonNull(taskStates);
this.taskStateReasons = CollectionsExt.nonNull(taskStateReasons);
this.owner = Optional.ofNullable(owner);
this.labels = labels == null ? Collections.emptyMap() : labels;
this.labelsAndOp = labelsAndOp;
this.imageName = Optional.ofNullable(imageName);
this.imageTag = Optional.ofNullable(imageTag);
this.appName = Optional.ofNullable(appName);
this.capacityGroup = Optional.ofNullable(capacityGroup);
this.jobType = Optional.ofNullable(jobType);
this.jobGroupStack = Optional.ofNullable(jobGroupStack);
this.jobGroupDetail = Optional.ofNullable(jobGroupDetail);
this.jobGroupSequence = Optional.ofNullable(jobGroupSequence);
this.needsMigration = needsMigration;
this.platformSidecar = Optional.ofNullable(platformSidecar);
this.platformSidecarChannel = Optional.ofNullable(platformSidecarChannel);
this.skipSystemFailures = skipSystemFailures;
this.limit = limit;
}
public static <TASK_STATE, JOB_TYPE extends Enum<JOB_TYPE>> Builder<TASK_STATE, JOB_TYPE> newBuilder() {
return new Builder<>();
}
public Set<String> getJobIds() {
return jobIds;
}
public Set<String> getTaskIds() {
return taskIds;
}
public boolean isIncludeArchived() {
return includeArchived;
}
public Optional<Object> getJobState() {
return jobState;
}
public Set<TASK_STATE> getTaskStates() {
return taskStates;
}
public Set<String> getTaskStateReasons() {
return taskStateReasons;
}
public Optional<String> getOwner() {
return owner;
}
public Map<String, Set<String>> getLabels() {
return labels;
}
public boolean isLabelsAndOp() {
return labelsAndOp;
}
public Optional<String> getImageName() {
return imageName;
}
public Optional<String> getImageTag() {
return imageTag;
}
public Optional<String> getAppName() {
return appName;
}
public Optional<String> getCapacityGroup() {
return capacityGroup;
}
public Optional<JOB_TYPE> getJobType() {
return jobType;
}
public Optional<String> getJobGroupStack() {
return jobGroupStack;
}
public Optional<String> getJobGroupDetail() {
return jobGroupDetail;
}
public Optional<String> getJobGroupSequence() {
return jobGroupSequence;
}
public boolean isNeedsMigration() {
return needsMigration;
}
public boolean isSkipSystemFailures() {
return skipSystemFailures;
}
public Optional<String> getPlatformSidecar() {
return platformSidecar;
}
public Optional<String> getPlatformSidecarChannel() {
return platformSidecarChannel;
}
public int getLimit() {
return limit;
}
public Builder<TASK_STATE, JOB_TYPE> toBuilder() {
Builder<TASK_STATE, JOB_TYPE> builder = new Builder<>();
return builder
.withJobIds(this.jobIds)
.withTaskIds(this.taskIds)
.withJobState(this.jobState.orElse(null))
.withTaskStates(this.taskStates)
.withOwner(this.owner.orElse(null))
.withLabels(this.labels)
.withImageName(this.imageName.orElse(null))
.withImageTag(this.imageTag.orElse(null))
.withAppName(this.appName.orElse(null))
.withCapacityGroup(this.capacityGroup.orElse(null))
.withJobType(this.jobType.orElse(null))
.withJobGroupDetail(this.jobGroupDetail.orElse(null))
.withJobGroupStack(this.jobGroupStack.orElse(null))
.withJobGroupSequence(this.jobGroupSequence.orElse(null))
.withNeedsMigration(needsMigration)
.withPlatformSidecar(this.platformSidecar.orElse(null))
.withPlatformSidecarChannel(this.platformSidecarChannel.orElse(null))
.withLimit(this.limit);
}
public boolean isEmpty() {
return jobIds.isEmpty()
&& taskIds.isEmpty()
&& !jobState.isPresent()
&& taskStates.isEmpty()
&& !owner.isPresent()
&& labels.isEmpty()
&& !imageName.isPresent()
&& !imageTag.isPresent()
&& !appName.isPresent()
&& !capacityGroup.isPresent()
&& !jobType.isPresent()
&& !jobGroupDetail.isPresent()
&& !jobGroupStack.isPresent()
&& !jobGroupSequence.isPresent()
&& !needsMigration
&& !platformSidecar.isPresent()
&& !platformSidecarChannel.isPresent()
&& limit < 1;
}
@Override
public boolean equals(Object o) {
if (this == o) {
return true;
}
if (o == null || getClass() != o.getClass()) {
return false;
}
JobQueryCriteria<?, ?> that = (JobQueryCriteria<?, ?>) o;
return includeArchived == that.includeArchived &&
labelsAndOp == that.labelsAndOp &&
needsMigration == that.needsMigration &&
skipSystemFailures == that.skipSystemFailures &&
limit == that.limit &&
Objects.equals(jobIds, that.jobIds) &&
Objects.equals(taskIds, that.taskIds) &&
Objects.equals(jobState, that.jobState) &&
Objects.equals(taskStates, that.taskStates) &&
Objects.equals(taskStateReasons, that.taskStateReasons) &&
Objects.equals(owner, that.owner) &&
Objects.equals(labels, that.labels) &&
Objects.equals(imageName, that.imageName) &&
Objects.equals(imageTag, that.imageTag) &&
Objects.equals(appName, that.appName) &&
Objects.equals(capacityGroup, that.capacityGroup) &&
Objects.equals(jobType, that.jobType) &&
Objects.equals(jobGroupStack, that.jobGroupStack) &&
Objects.equals(jobGroupDetail, that.jobGroupDetail) &&
Objects.equals(jobGroupSequence, that.jobGroupSequence) &&
Objects.equals(platformSidecar, that.platformSidecar) &&
Objects.equals(platformSidecarChannel, that.platformSidecarChannel);
}
@Override
public int hashCode() {
return Objects.hash(jobIds, taskIds, includeArchived, jobState, taskStates, taskStateReasons, owner, labels, labelsAndOp, imageName, imageTag, appName, capacityGroup, jobType, jobGroupStack, jobGroupDetail, jobGroupSequence, needsMigration, skipSystemFailures, platformSidecar, platformSidecarChannel, limit);
}
@Override
public String toString() {
return "JobQueryCriteria{" +
"jobIds=" + jobIds +
", taskIds=" + taskIds +
", includeArchived=" + includeArchived +
", jobState=" + jobState +
", taskStates=" + taskStates +
", taskStateReasons=" + taskStateReasons +
", owner=" + owner +
", labels=" + labels +
", labelsAndOp=" + labelsAndOp +
", imageName=" + imageName +
", imageTag=" + imageTag +
", appName=" + appName +
", capacityGroup=" + capacityGroup +
", jobType=" + jobType +
", jobGroupStack=" + jobGroupStack +
", jobGroupDetail=" + jobGroupDetail +
", jobGroupSequence=" + jobGroupSequence +
", needsMigration=" + needsMigration +
", skipSystemFailures=" + skipSystemFailures +
", platformSidecar=" + platformSidecar +
", platformSidecarChannel=" + platformSidecarChannel +
", limit=" + limit +
'}';
}
public static final class Builder<TASK_STATE, JOB_TYPE extends Enum<JOB_TYPE>> {
private Set<String> jobIds;
private Set<String> taskIds;
private boolean includeArchived;
private Object jobState;
private Set<TASK_STATE> taskStates;
private Set<String> taskStateReasons;
private String owner;
private Map<String, Set<String>> labels;
private boolean labelsAndOp;
private String imageName;
private String imageTag;
private String appName;
private String capacityGroup;
private JOB_TYPE jobType;
private String jobGroupStack;
private String jobGroupDetail;
private String jobGroupSequence;
private boolean needsMigration;
private boolean skipSystemFailures;
private String platformSidecar;
private String platformSidecarChannel;
private int limit;
private Builder() {
}
public Builder<TASK_STATE, JOB_TYPE> withJobIds(Set<String> jobIds) {
this.jobIds = jobIds;
return this;
}
public Builder<TASK_STATE, JOB_TYPE> withTaskIds(Set<String> taskIds) {
this.taskIds = taskIds;
return this;
}
public Builder<TASK_STATE, JOB_TYPE> withIncludeArchived(boolean includeArchived) {
this.includeArchived = includeArchived;
return this;
}
public Builder<TASK_STATE, JOB_TYPE> withJobState(Object jobState) {
this.jobState = jobState;
return this;
}
public Builder<TASK_STATE, JOB_TYPE> withTaskStates(Set<TASK_STATE> taskStates) {
this.taskStates = taskStates;
return this;
}
public Builder<TASK_STATE, JOB_TYPE> withTaskStateReasons(Set<String> taskStateReasons) {
this.taskStateReasons = taskStateReasons;
return this;
}
public Builder<TASK_STATE, JOB_TYPE> withOwner(String owner) {
this.owner = owner;
return this;
}
public Builder<TASK_STATE, JOB_TYPE> withLabels(Map<String, Set<String>> labels) {
this.labels = labels;
return this;
}
public Builder<TASK_STATE, JOB_TYPE> withLabelsAndOp(boolean labelsAndOp) {
this.labelsAndOp = labelsAndOp;
return this;
}
public Builder<TASK_STATE, JOB_TYPE> withImageName(String imageName) {
this.imageName = imageName;
return this;
}
public Builder<TASK_STATE, JOB_TYPE> withImageTag(String imageTag) {
this.imageTag = imageTag;
return this;
}
public Builder<TASK_STATE, JOB_TYPE> withPlatformSidecar(String platformSidecar) {
this.platformSidecar = platformSidecar;
return this;
}
public Builder<TASK_STATE, JOB_TYPE> withPlatformSidecarChannel(String platformSidecarChannel) {
this.platformSidecarChannel = platformSidecarChannel;
return this;
}
public Builder<TASK_STATE, JOB_TYPE> withAppName(String appName) {
this.appName = appName;
return this;
}
public Builder<TASK_STATE, JOB_TYPE> withCapacityGroup(String capacityGroup) {
this.capacityGroup = capacityGroup;
return this;
}
public Builder<TASK_STATE, JOB_TYPE> withJobType(JOB_TYPE jobType) {
this.jobType = jobType;
return this;
}
public Builder<TASK_STATE, JOB_TYPE> withJobGroupStack(String jobGroupStack) {
this.jobGroupStack = jobGroupStack;
return this;
}
public Builder<TASK_STATE, JOB_TYPE> withJobGroupDetail(String jobGroupDetail) {
this.jobGroupDetail = jobGroupDetail;
return this;
}
public Builder<TASK_STATE, JOB_TYPE> withJobGroupSequence(String jobGroupSequence) {
this.jobGroupSequence = jobGroupSequence;
return this;
}
public Builder<TASK_STATE, JOB_TYPE> withNeedsMigration(boolean needsMigration) {
this.needsMigration = needsMigration;
return this;
}
public Builder<TASK_STATE, JOB_TYPE> withSkipSystemFailures(boolean skipSystemFailures) {
this.skipSystemFailures = skipSystemFailures;
return this;
}
public Builder<TASK_STATE, JOB_TYPE> withLimit(int limit) {
this.limit = limit;
return this;
}
public Builder<TASK_STATE, JOB_TYPE> but() {
return JobQueryCriteria.<TASK_STATE, JOB_TYPE>newBuilder()
.withJobIds(jobIds)
.withIncludeArchived(includeArchived)
.withJobState(jobState)
.withTaskStates(taskStates)
.withTaskStateReasons(taskStateReasons)
.withLabels(labels)
.withLabelsAndOp(labelsAndOp)
.withImageName(imageName)
.withAppName(appName)
.withJobType(jobType)
.withNeedsMigration(needsMigration)
.withSkipSystemFailures(skipSystemFailures)
.withPlatformSidecar(platformSidecar)
.withPlatformSidecarChannel(platformSidecarChannel)
.withLimit(limit);
}
public JobQueryCriteria<TASK_STATE, JOB_TYPE> build() {
return new JobQueryCriteria<>(jobIds, taskIds, includeArchived, jobState, taskStates, taskStateReasons, owner, labels,
labelsAndOp, imageName, imageTag, appName, capacityGroup, jobType, jobGroupStack, jobGroupDetail, jobGroupSequence,
needsMigration, skipSystemFailures, platformSidecar, platformSidecarChannel, limit);
}
}
}
| 1,180 |
0 | Create_ds/titus-control-plane/titus-client/src/main/java/com/netflix/titus/runtime/endpoint/v3 | Create_ds/titus-control-plane/titus-client/src/main/java/com/netflix/titus/runtime/endpoint/v3/grpc/GrpcObjectsCache.java | package com.netflix.titus.runtime.endpoint.v3.grpc;
import com.netflix.titus.grpc.protogen.Job;
import com.netflix.titus.grpc.protogen.Task;
public interface GrpcObjectsCache {
/**
* Get Grpc Job object for the corresponding core Job object
*/
Job getJob(com.netflix.titus.api.jobmanager.model.job.Job<?> coreJob);
/**
* Get Grpc Task object for the corresponding core Task object
*/
Task getTask(com.netflix.titus.api.jobmanager.model.job.Task coreTask);
}
| 1,181 |
0 | Create_ds/titus-control-plane/titus-client/src/main/java/com/netflix/titus/runtime/endpoint/v3 | Create_ds/titus-control-plane/titus-client/src/main/java/com/netflix/titus/runtime/endpoint/v3/grpc/ProtobufCache.java | /*
* Copyright 2021 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.runtime.endpoint.v3.grpc;
import java.time.Duration;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;
import java.util.function.Function;
import java.util.function.Predicate;
import java.util.function.Supplier;
import com.google.common.annotations.VisibleForTesting;
import com.netflix.spectator.api.Counter;
import com.netflix.spectator.api.Registry;
import com.netflix.spectator.api.patterns.PolledMeter;
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.time.Clock;
class ProtobufCache<E, C> {
private static final String METRICS_ROOT = "protobufCache.";
private final Function<E, C> converter;
private final Supplier<Predicate<E>> expiredPredicateSupplier;
private final GrpcObjectsCacheConfiguration configuration;
private final Clock clock;
@VisibleForTesting
final ConcurrentMap<String, CacheEntry<E, C>> cache = new ConcurrentHashMap<>();
@VisibleForTesting
final ConcurrentMap<String, Long> toBeRemoved = new ConcurrentHashMap<>();
private final ScheduleReference scheduleRef;
private final Counter cacheHit;
private final Counter cacheMiss;
ProtobufCache(String name,
Function<E, C> converter,
Supplier<Predicate<E>> expiredPredicateSupplier,
GrpcObjectsCacheConfiguration configuration,
TitusRuntime titusRuntime) {
this.converter = converter;
this.expiredPredicateSupplier = expiredPredicateSupplier;
this.configuration = configuration;
this.clock = titusRuntime.getClock();
Registry registry = titusRuntime.getRegistry();
PolledMeter.using(registry).withId(registry.createId(METRICS_ROOT + "cacheSize", "cache", name)).monitorSize(cache);
PolledMeter.using(registry).withId(registry.createId(METRICS_ROOT + "toBeRemoved", "cache", name)).monitorSize(toBeRemoved);
this.cacheHit = registry.counter(METRICS_ROOT + "cacheAccess", "cache", name, "cacheHit", "true");
this.cacheMiss = registry.counter(METRICS_ROOT + "cacheAccess", "cache", name, "cacheHit", "false");
ScheduleDescriptor gcScheduleDescriptor = ScheduleDescriptor.newBuilder()
.withName(ProtobufCache.class.getSimpleName() + "#" + name)
.withDescription("Protobuf entity cache")
.withInitialDelay(Duration.ofMillis(configuration.getCacheRefreshInitialDelayMs()))
.withInterval(Duration.ofMillis(configuration.getCacheRefreshIntervalMs()))
.withTimeout(Duration.ofMillis(configuration.getCacheRefreshTimeoutMs()))
.build();
this.scheduleRef = titusRuntime.getLocalScheduler().schedule(gcScheduleDescriptor, context -> removeExpiredEntries(), true);
}
void shutdown() {
scheduleRef.cancel();
}
C get(String id, E entity) {
CacheEntry<E, C> entry = cache.get(id);
if (entry != null) {
if (entry.getCoreEntity() == entity) {
cacheHit.increment();
return entry.getProtobufEntity();
}
}
CacheEntry<E, C> newEntry = new CacheEntry<>(id, entity, converter.apply(entity));
cache.put(id, newEntry);
cacheMiss.increment();
return newEntry.getProtobufEntity();
}
private void removeExpiredEntries() {
long now = clock.wallTime();
// Do cleanup
Iterator<Map.Entry<String, Long>> it = toBeRemoved.entrySet().iterator();
while (it.hasNext()) {
Map.Entry<String, Long> entry = it.next();
if (entry.getValue() < now) {
it.remove();
cache.remove(entry.getKey());
}
}
// Find expired entries
Predicate<E> expiredPredicate = expiredPredicateSupplier.get();
Set<String> candidates = CollectionsExt.copyAndRemove(cache.keySet(), toBeRemoved.keySet());
candidates.forEach(id -> {
CacheEntry<E, C> entry = cache.get(id);
if (expiredPredicate.test(entry.getCoreEntity())) {
toBeRemoved.put(id, now + configuration.getCacheCleanupDelayMs());
}
});
}
private static class CacheEntry<C, G> {
private final String id;
private final C coreEntity;
private final G protobufEntity;
private CacheEntry(String id, C coreEntity, G protobufEntity) {
this.id = id;
this.coreEntity = coreEntity;
this.protobufEntity = protobufEntity;
}
public String getId() {
return id;
}
public C getCoreEntity() {
return coreEntity;
}
public G getProtobufEntity() {
return protobufEntity;
}
}
}
| 1,182 |
0 | Create_ds/titus-control-plane/titus-client/src/main/java/com/netflix/titus/runtime/endpoint/v3 | Create_ds/titus-control-plane/titus-client/src/main/java/com/netflix/titus/runtime/endpoint/v3/grpc/DefaultGrpcObjectsCache.java | package com.netflix.titus.runtime.endpoint.v3.grpc;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import javax.annotation.PreDestroy;
import javax.inject.Inject;
import javax.inject.Singleton;
import com.google.protobuf.GeneratedMessageV3;
import com.netflix.titus.api.jobmanager.model.job.LogStorageInfo;
import com.netflix.titus.api.jobmanager.service.V3JobOperations;
import com.netflix.titus.api.supervisor.service.LeaderActivator;
import com.netflix.titus.common.runtime.TitusRuntime;
import com.netflix.titus.common.util.Evaluators;
import com.netflix.titus.common.util.guice.annotation.Activator;
import com.netflix.titus.common.util.guice.annotation.Deactivator;
import com.netflix.titus.grpc.protogen.Job;
import com.netflix.titus.grpc.protogen.Task;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
@Singleton
public class DefaultGrpcObjectsCache implements GrpcObjectsCache {
private static final Logger logger = LoggerFactory.getLogger(DefaultGrpcObjectsCache.class);
protected ProtobufCache<com.netflix.titus.api.jobmanager.model.job.Job<?>, Job> jobCache;
protected ProtobufCache<com.netflix.titus.api.jobmanager.model.job.Task, Task> taskCache;
private final V3JobOperations jobOperations;
private final GrpcObjectsCacheConfiguration configuration;
private final LogStorageInfo<com.netflix.titus.api.jobmanager.model.job.Task> logStorageInfo;
private final LeaderActivator leaderActivator;
private final TitusRuntime titusRuntime;
@Inject
public DefaultGrpcObjectsCache(V3JobOperations jobOperations,
GrpcObjectsCacheConfiguration configuration,
LogStorageInfo<com.netflix.titus.api.jobmanager.model.job.Task> logStorageInfo,
LeaderActivator leaderActivator,
TitusRuntime titusRuntime) {
this.leaderActivator = leaderActivator;
this.titusRuntime = titusRuntime;
this.configuration = configuration;
this.logStorageInfo = logStorageInfo;
this.jobOperations = jobOperations;
}
@Activator
public void activate() {
// Initialize cache
this.jobCache = new ProtobufCache<>(
"jobs",
coreJob -> {
Job job = GrpcJobManagementModelConverters.toGrpcJob(coreJob);
// Need to serialize it once since GeneratedMessageV3 isn't entirely immutable.
// It needs to initialize memoizedSize field (non-volatile) before being used from multiple threads
serializeGrpcObject(job);
return job;
},
() -> {
// FIXME DefaultGrpcObjectsCache activation happens immediately in DefaultJobManagementServiceGrpc
if (!leaderActivator.isActivated()) {
return job -> true;
}
List<com.netflix.titus.api.jobmanager.model.job.Job> allJobs = jobOperations.getJobs();
Set<String> knownJobIds = new HashSet<>();
allJobs.forEach(job -> knownJobIds.add(job.getId()));
return job -> !knownJobIds.contains(job.getId());
},
configuration,
titusRuntime
);
this.taskCache = new ProtobufCache<>(
"tasks",
coreTask -> {
Task task = GrpcJobManagementModelConverters.toGrpcTask(coreTask, logStorageInfo);
// Need to serialize it once since GeneratedMessageV3 isn't entirely immutable.
// It needs to initialize memoizedSize field (non-volatile) before being used from multiple threads
serializeGrpcObject(task);
return task;
},
() -> {
// FIXME DefaultGrpcObjectsCache activation happens immediately in DefaultJobManagementServiceGrpc
if (!leaderActivator.isActivated()) {
return job -> true;
}
List<com.netflix.titus.api.jobmanager.model.job.Task> allTasks = jobOperations.getTasks();
Set<String> knownTasksIds = new HashSet<>();
allTasks.forEach(task -> knownTasksIds.add(task.getId()));
return task -> !knownTasksIds.contains(task.getId());
},
configuration,
titusRuntime
);
}
@Deactivator
@PreDestroy
public void shutdown() {
Evaluators.acceptNotNull(jobCache, ProtobufCache::shutdown);
Evaluators.acceptNotNull(taskCache, ProtobufCache::shutdown);
}
public Job getJob(com.netflix.titus.api.jobmanager.model.job.Job<?> coreJob) {
if (configuration.isGrpcObjectsCacheEnabled()) {
return jobCache.get(coreJob.getId(), coreJob);
} else {
return GrpcJobManagementModelConverters.toGrpcJob(coreJob);
}
}
public Task getTask(com.netflix.titus.api.jobmanager.model.job.Task coreTask) {
if (configuration.isGrpcObjectsCacheEnabled()) {
return taskCache.get(coreTask.getId(), coreTask);
} else {
return GrpcJobManagementModelConverters.toGrpcTask(coreTask, logStorageInfo);
}
}
private <T extends GeneratedMessageV3> void serializeGrpcObject(T msg) {
int serializedSize = msg.getSerializedSize();
ByteArrayOutputStream bos = new ByteArrayOutputStream(serializedSize);
try {
msg.writeTo(bos);
logger.debug("Serialized size for grpc type {}", serializedSize);
} catch (IOException e) {
logger.error("Error serializing grpc type ", e);
}
}
}
| 1,183 |
0 | Create_ds/titus-control-plane/titus-client/src/main/java/com/netflix/titus/runtime/endpoint/v3 | Create_ds/titus-control-plane/titus-client/src/main/java/com/netflix/titus/runtime/endpoint/v3/grpc/GrpcJobQueryModelConverters.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.runtime.endpoint.v3.grpc;
import java.util.Collections;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import com.netflix.titus.api.service.TitusServiceException;
import com.netflix.titus.common.util.StringExt;
import com.netflix.titus.grpc.protogen.JobDescriptor.JobSpecCase;
import com.netflix.titus.grpc.protogen.JobQuery;
import com.netflix.titus.grpc.protogen.JobStatus;
import com.netflix.titus.grpc.protogen.ObserveJobsQuery;
import com.netflix.titus.grpc.protogen.TaskQuery;
import com.netflix.titus.grpc.protogen.TaskStatus;
import com.netflix.titus.runtime.endpoint.JobQueryCriteria;
import com.netflix.titus.runtime.endpoint.common.grpc.CommonRuntimeGrpcModelConverters;
import static com.netflix.titus.common.util.CollectionsExt.asSet;
import static com.netflix.titus.common.util.CollectionsExt.copyAndRemove;
import static com.netflix.titus.common.util.CollectionsExt.first;
import static com.netflix.titus.common.util.Evaluators.applyNotNull;
import static com.netflix.titus.common.util.StringExt.trimAndApplyIfNonEmpty;
import static java.util.Arrays.asList;
/**
* Collection of functions to translate between GRPC and Titus common models.
*/
public class GrpcJobQueryModelConverters extends CommonRuntimeGrpcModelConverters {
public static final List<TaskStatus.TaskState> ALL_TASK_STATES = asList(TaskStatus.TaskState.values());
public static final Set<String> CRITERIA_JOB_FIELDS = asSet(
"jobIds", "taskIds", "owner", "appName", "applicationName", "imageName", "imageTag", "capacityGroup",
"jobGroupStack", "jobGroupDetail", "jobGroupSequence",
"jobType", "attributes", "attributes.op", "labels", "labels.op", "jobState", "taskStates", "taskStateReasons",
"needsMigration", "skipSystemFailures", "platformSidecar", "platformSidecarChannel"
);
public static JobQueryCriteria<TaskStatus.TaskState, JobSpecCase> toJobQueryCriteria(ObserveJobsQuery query) {
if (query.getFilteringCriteriaCount() == 0) {
return JobQueryCriteria.<TaskStatus.TaskState, JobSpecCase>newBuilder().build();
}
return toJobQueryCriteria(query.getFilteringCriteriaMap());
}
public static JobQueryCriteria<TaskStatus.TaskState, JobSpecCase> toJobQueryCriteria(JobQuery jobQuery) {
if (jobQuery.getFilteringCriteriaCount() == 0) {
return JobQueryCriteria.<TaskStatus.TaskState, JobSpecCase>newBuilder().build();
}
return toJobQueryCriteria(jobQuery.getFilteringCriteriaMap());
}
public static JobQueryCriteria<TaskStatus.TaskState, JobSpecCase> toJobQueryCriteria(TaskQuery taskQuery) {
if (taskQuery.getFilteringCriteriaCount() == 0) {
return JobQueryCriteria.<TaskStatus.TaskState, JobSpecCase>newBuilder().build();
}
return toJobQueryCriteria(taskQuery.getFilteringCriteriaMap());
}
private static JobQueryCriteria<TaskStatus.TaskState, JobSpecCase> toJobQueryCriteria(Map<String, String> criteriaMap) {
JobQueryCriteria.Builder<TaskStatus.TaskState, JobSpecCase> criteriaBuilder = JobQueryCriteria.newBuilder();
Set<String> unknown = copyAndRemove(criteriaMap.keySet(), CRITERIA_JOB_FIELDS);
if (!unknown.isEmpty()) {
throw TitusServiceException.invalidArgument("Unrecognized field(s) " + unknown);
}
criteriaBuilder.withJobIds(new HashSet<>(StringExt.splitByComma(criteriaMap.get("jobIds"))));
criteriaBuilder.withTaskIds(new HashSet<>(StringExt.splitByComma(criteriaMap.get("taskIds"))));
trimAndApplyIfNonEmpty(criteriaMap.get("owner"), criteriaBuilder::withOwner);
trimAndApplyIfNonEmpty(criteriaMap.get("appName"), criteriaBuilder::withAppName);
trimAndApplyIfNonEmpty(criteriaMap.get("applicationName"), criteriaBuilder::withAppName);
trimAndApplyIfNonEmpty(criteriaMap.get("capacityGroup"), criteriaBuilder::withCapacityGroup);
trimAndApplyIfNonEmpty(criteriaMap.get("imageName"), criteriaBuilder::withImageName);
trimAndApplyIfNonEmpty(criteriaMap.get("imageTag"), criteriaBuilder::withImageTag);
// PlatformSidecar-related criteria
trimAndApplyIfNonEmpty(criteriaMap.get("platformSidecar"), criteriaBuilder::withPlatformSidecar);
trimAndApplyIfNonEmpty(criteriaMap.get("platformSidecarChannel"), criteriaBuilder::withPlatformSidecarChannel);
// Job type
String jobType = criteriaMap.get("jobType");
if (jobType != null) {
try {
criteriaBuilder.withJobType(StringExt.parseEnumIgnoreCase(jobType, JobSpecCase.class));
} catch (Exception e) {
throw TitusServiceException.invalidArgument("Invalid jobType value " + jobType);
}
}
// Job group info
trimAndApplyIfNonEmpty(criteriaMap.get("jobGroupStack"), criteriaBuilder::withJobGroupStack);
trimAndApplyIfNonEmpty(criteriaMap.get("jobGroupDetail"), criteriaBuilder::withJobGroupDetail);
trimAndApplyIfNonEmpty(criteriaMap.get("jobGroupSequence"), criteriaBuilder::withJobGroupSequence);
criteriaBuilder.withNeedsMigration(criteriaMap.getOrDefault("needsMigration", "false").equalsIgnoreCase("true"));
criteriaBuilder.withSkipSystemFailures(criteriaMap.getOrDefault("skipSystemFailures", "false").equalsIgnoreCase("true"));
// Job state
String jobStateStr = criteriaMap.get("jobState");
applyNotNull(jobStateStr, js -> criteriaBuilder.withJobState(StringExt.parseEnumIgnoreCase(js, JobStatus.JobState.class)));
// Task states
String taskStatesStr = criteriaMap.get("taskStates");
if (taskStatesStr != null) {
List<TaskStatus.TaskState> taskStates = StringExt.parseEnumListIgnoreCase(taskStatesStr, TaskStatus.TaskState.class, n -> {
if (n.equalsIgnoreCase("any")) {
return ALL_TASK_STATES;
}
return null;
});
if (!taskStates.isEmpty()) {
criteriaBuilder.withTaskStates(new HashSet<>(taskStates));
}
}
// Task reason
String taskStateReasonsStr = criteriaMap.get("taskStateReasons");
if (!StringExt.isEmpty(taskStateReasonsStr)) {
criteriaBuilder.withTaskStateReasons(new HashSet<>(StringExt.splitByComma(taskStateReasonsStr)));
}
// Attributes
String attributeStr = criteriaMap.getOrDefault("attributes", criteriaMap.get("labels"));
if (attributeStr != null) {
Map<String, Set<String>> attributes = StringExt.parseKeyValuesList(attributeStr);
// As we cannot pass null in GRPC, if attribute key contains is single value which is empty string, assume no value was given
for (Map.Entry<String, Set<String>> entry : attributes.entrySet()) {
Set<String> values = entry.getValue();
if (values.size() == 1 && "".equals(first(values))) {
attributes.put(entry.getKey(), Collections.emptySet());
}
}
if (!attributes.isEmpty()) {
criteriaBuilder.withLabels(attributes);
}
String labelsOp = criteriaMap.getOrDefault("attributes.op", criteriaMap.getOrDefault("labels.op", "and")).toLowerCase();
criteriaBuilder.withLabelsAndOp("and".equals(labelsOp));
}
return criteriaBuilder.build();
}
}
| 1,184 |
0 | Create_ds/titus-control-plane/titus-client/src/main/java/com/netflix/titus/runtime/endpoint/v3 | Create_ds/titus-control-plane/titus-client/src/main/java/com/netflix/titus/runtime/endpoint/v3/grpc/GrpcObjectsCacheConfiguration.java | package com.netflix.titus.runtime.endpoint.v3.grpc;
import com.netflix.archaius.api.annotations.Configuration;
import com.netflix.archaius.api.annotations.DefaultValue;
@Configuration(prefix = "titus.grpc.cache")
public interface GrpcObjectsCacheConfiguration {
/**
* @return whether or not the cache is enabled
*/
@DefaultValue("true")
boolean isGrpcObjectsCacheEnabled();
/**
* @return the initial delay in milliseconds before the cache refresh controller runs
*/
@DefaultValue("10000")
long getCacheRefreshInitialDelayMs();
/**
* @return the interval in milliseconds of how often the cache refreshes
*/
@DefaultValue("30000")
long getCacheRefreshIntervalMs();
/**
* @return the timeout of the cache refresh controller loop.
*/
@DefaultValue("60000")
long getCacheRefreshTimeoutMs();
/**
* @return time to wait before an expired value is removed from the cache.
*/
@DefaultValue("60000")
long getCacheCleanupDelayMs();
}
| 1,185 |
0 | Create_ds/titus-control-plane/titus-client/src/main/java/com/netflix/titus/runtime/endpoint/v3 | Create_ds/titus-control-plane/titus-client/src/main/java/com/netflix/titus/runtime/endpoint/v3/grpc/GrpcJobManagementModelConverters.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.runtime.endpoint.v3.grpc;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.concurrent.TimeUnit;
import java.util.stream.Collectors;
import com.google.common.base.Preconditions;
import com.google.protobuf.ByteString;
import com.google.protobuf.InvalidProtocolBufferException;
import com.google.protobuf.Struct;
import com.google.protobuf.util.JsonFormat;
import com.netflix.titus.api.jobmanager.model.job.BasicContainer;
import com.netflix.titus.api.jobmanager.model.job.BatchJobTask;
import com.netflix.titus.api.jobmanager.model.job.CapacityAttributes;
import com.netflix.titus.api.jobmanager.model.job.Container;
import com.netflix.titus.api.jobmanager.model.job.ContainerResources;
import com.netflix.titus.api.jobmanager.model.job.Image;
import com.netflix.titus.api.jobmanager.model.job.Job;
import com.netflix.titus.api.jobmanager.model.job.JobDescriptor;
import com.netflix.titus.api.jobmanager.model.job.JobGroupInfo;
import com.netflix.titus.api.jobmanager.model.job.JobModel;
import com.netflix.titus.api.jobmanager.model.job.JobState;
import com.netflix.titus.api.jobmanager.model.job.JobStatus;
import com.netflix.titus.api.jobmanager.model.job.LogStorageInfo;
import com.netflix.titus.api.jobmanager.model.job.NetworkConfiguration;
import com.netflix.titus.api.jobmanager.model.job.Owner;
import com.netflix.titus.api.jobmanager.model.job.PlatformSidecar;
import com.netflix.titus.api.jobmanager.model.job.ServiceJobProcesses;
import com.netflix.titus.api.jobmanager.model.job.ServiceJobTask;
import com.netflix.titus.api.jobmanager.model.job.Task;
import com.netflix.titus.api.jobmanager.model.job.TaskState;
import com.netflix.titus.api.jobmanager.model.job.TaskStatus;
import com.netflix.titus.api.jobmanager.model.job.TwoLevelResource;
import com.netflix.titus.api.jobmanager.model.job.Version;
import com.netflix.titus.api.jobmanager.model.job.VolumeMount;
import com.netflix.titus.api.jobmanager.model.job.disruptionbudget.AvailabilityPercentageLimitDisruptionBudgetPolicy;
import com.netflix.titus.api.jobmanager.model.job.disruptionbudget.ContainerHealthProvider;
import com.netflix.titus.api.jobmanager.model.job.disruptionbudget.Day;
import com.netflix.titus.api.jobmanager.model.job.disruptionbudget.DisruptionBudget;
import com.netflix.titus.api.jobmanager.model.job.disruptionbudget.DisruptionBudgetPolicy;
import com.netflix.titus.api.jobmanager.model.job.disruptionbudget.DisruptionBudgetRate;
import com.netflix.titus.api.jobmanager.model.job.disruptionbudget.HourlyTimeWindow;
import com.netflix.titus.api.jobmanager.model.job.disruptionbudget.PercentagePerHourDisruptionBudgetRate;
import com.netflix.titus.api.jobmanager.model.job.disruptionbudget.RatePerIntervalDisruptionBudgetRate;
import com.netflix.titus.api.jobmanager.model.job.disruptionbudget.RatePercentagePerIntervalDisruptionBudgetRate;
import com.netflix.titus.api.jobmanager.model.job.disruptionbudget.RelocationLimitDisruptionBudgetPolicy;
import com.netflix.titus.api.jobmanager.model.job.disruptionbudget.SelfManagedDisruptionBudgetPolicy;
import com.netflix.titus.api.jobmanager.model.job.disruptionbudget.TimeWindow;
import com.netflix.titus.api.jobmanager.model.job.disruptionbudget.UnhealthyTasksLimitDisruptionBudgetPolicy;
import com.netflix.titus.api.jobmanager.model.job.disruptionbudget.UnlimitedDisruptionBudgetRate;
import com.netflix.titus.api.jobmanager.model.job.ebs.EbsVolume;
import com.netflix.titus.api.jobmanager.model.job.ebs.EbsVolumeUtils;
import com.netflix.titus.api.jobmanager.model.job.event.JobKeepAliveEvent;
import com.netflix.titus.api.jobmanager.model.job.event.JobManagerEvent;
import com.netflix.titus.api.jobmanager.model.job.event.JobUpdateEvent;
import com.netflix.titus.api.jobmanager.model.job.event.TaskUpdateEvent;
import com.netflix.titus.api.jobmanager.model.job.ext.BatchJobExt;
import com.netflix.titus.api.jobmanager.model.job.ext.ServiceJobExt;
import com.netflix.titus.api.jobmanager.model.job.migration.MigrationDetails;
import com.netflix.titus.api.jobmanager.model.job.migration.MigrationPolicy;
import com.netflix.titus.api.jobmanager.model.job.migration.SelfManagedMigrationPolicy;
import com.netflix.titus.api.jobmanager.model.job.migration.SystemDefaultMigrationPolicy;
import com.netflix.titus.api.jobmanager.model.job.retry.DelayedRetryPolicy;
import com.netflix.titus.api.jobmanager.model.job.retry.ExponentialBackoffRetryPolicy;
import com.netflix.titus.api.jobmanager.model.job.retry.ImmediateRetryPolicy;
import com.netflix.titus.api.jobmanager.model.job.retry.RetryPolicy;
import com.netflix.titus.api.jobmanager.model.job.volume.SaaSVolumeSource;
import com.netflix.titus.api.jobmanager.model.job.volume.SharedContainerVolumeSource;
import com.netflix.titus.api.jobmanager.model.job.volume.Volume;
import com.netflix.titus.api.jobmanager.model.job.volume.VolumeSource;
import com.netflix.titus.api.jobmanager.model.job.vpc.IpAddressAllocation;
import com.netflix.titus.api.jobmanager.model.job.vpc.IpAddressLocation;
import com.netflix.titus.api.jobmanager.model.job.vpc.SignedIpAddressAllocation;
import com.netflix.titus.api.model.EfsMount;
import com.netflix.titus.api.service.TitusServiceException;
import com.netflix.titus.common.util.Evaluators;
import com.netflix.titus.common.util.StringExt;
import com.netflix.titus.common.util.tuple.Either;
import com.netflix.titus.grpc.protogen.AddressAllocation;
import com.netflix.titus.grpc.protogen.AddressLocation;
import com.netflix.titus.grpc.protogen.BatchJobSpec;
import com.netflix.titus.grpc.protogen.Capacity;
import com.netflix.titus.grpc.protogen.Constraints;
import com.netflix.titus.grpc.protogen.JobCapacityWithOptionalAttributes;
import com.netflix.titus.grpc.protogen.JobChangeNotification;
import com.netflix.titus.grpc.protogen.JobDescriptor.JobSpecCase;
import com.netflix.titus.grpc.protogen.JobDisruptionBudget;
import com.netflix.titus.grpc.protogen.KeepAliveResponse;
import com.netflix.titus.grpc.protogen.LogLocation;
import com.netflix.titus.grpc.protogen.MountPerm;
import com.netflix.titus.grpc.protogen.SecurityProfile;
import com.netflix.titus.grpc.protogen.ServiceJobSpec;
import com.netflix.titus.grpc.protogen.SignedAddressAllocation;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import static com.netflix.titus.api.jobmanager.TaskAttributes.TASK_ATTRIBUTES_EVICTION_RESUBMIT_NUMBER;
import static com.netflix.titus.api.jobmanager.TaskAttributes.TASK_ATTRIBUTES_NETWORK_INTERFACE_INDEX;
import static com.netflix.titus.api.jobmanager.TaskAttributes.TASK_ATTRIBUTES_RESUBMIT_NUMBER;
import static com.netflix.titus.api.jobmanager.TaskAttributes.TASK_ATTRIBUTES_SYSTEM_RESUBMIT_NUMBER;
import static com.netflix.titus.api.jobmanager.TaskAttributes.TASK_ATTRIBUTES_TASK_INDEX;
import static com.netflix.titus.api.jobmanager.TaskAttributes.TASK_ATTRIBUTES_TASK_ORIGINAL_ID;
import static com.netflix.titus.api.jobmanager.TaskAttributes.TASK_ATTRIBUTES_TASK_RESUBMIT_OF;
import static com.netflix.titus.api.jobmanager.TaskAttributes.TASK_ATTRIBUTE_LOG_LIVE_STREAM;
import static com.netflix.titus.api.jobmanager.TaskAttributes.TASK_ATTRIBUTE_LOG_S3_ACCOUNT_ID;
import static com.netflix.titus.api.jobmanager.TaskAttributes.TASK_ATTRIBUTE_LOG_S3_ACCOUNT_NAME;
import static com.netflix.titus.api.jobmanager.TaskAttributes.TASK_ATTRIBUTE_LOG_S3_BUCKET_NAME;
import static com.netflix.titus.api.jobmanager.TaskAttributes.TASK_ATTRIBUTE_LOG_S3_KEY;
import static com.netflix.titus.api.jobmanager.TaskAttributes.TASK_ATTRIBUTE_LOG_S3_REGION;
import static com.netflix.titus.api.jobmanager.TaskAttributes.TASK_ATTRIBUTE_LOG_UI_LOCATION;
import static com.netflix.titus.common.util.CollectionsExt.isNullOrEmpty;
import static com.netflix.titus.common.util.Evaluators.acceptNotNull;
import static com.netflix.titus.common.util.Evaluators.applyNotNull;
import static com.netflix.titus.common.util.StringExt.nonNull;
import static com.netflix.titus.common.util.StringExt.parseEnumIgnoreCase;
import static com.netflix.titus.grpc.protogen.Day.Friday;
import static com.netflix.titus.grpc.protogen.Day.Monday;
import static com.netflix.titus.grpc.protogen.Day.Saturday;
import static com.netflix.titus.grpc.protogen.Day.Sunday;
import static com.netflix.titus.grpc.protogen.Day.Thursday;
import static com.netflix.titus.grpc.protogen.Day.Tuesday;
import static com.netflix.titus.grpc.protogen.Day.Wednesday;
public final class GrpcJobManagementModelConverters {
private static final Logger logger = LoggerFactory.getLogger(GrpcJobManagementModelConverters.class);
private GrpcJobManagementModelConverters() {
}
public static Job toCoreJob(com.netflix.titus.grpc.protogen.Job grpcJob) {
return JobModel.newJob()
.withId(grpcJob.getId())
.withJobDescriptor(toCoreJobDescriptor(grpcJob.getJobDescriptor()))
.withStatus(toCoreJobStatus(grpcJob.getStatus()))
.withStatusHistory(grpcJob.getStatusHistoryList().stream().map(GrpcJobManagementModelConverters::toCoreJobStatus).collect(Collectors.toList()))
.withVersion(toCoreVersion(grpcJob.getVersion()))
.build();
}
public static Version toCoreVersion(com.netflix.titus.grpc.protogen.Version version) {
return Version.newBuilder()
.withTimestamp(version.getTimestamp())
.build();
}
public static JobStatus toCoreJobStatus(com.netflix.titus.grpc.protogen.JobStatus grpcJobStatus) {
return JobModel.newJobStatus()
.withState(toCoreJobState(grpcJobStatus.getState()))
.withReasonCode(grpcJobStatus.getReasonCode())
.withReasonMessage(grpcJobStatus.getReasonMessage())
.withTimestamp(grpcJobStatus.getTimestamp())
.build();
}
public static JobState toCoreJobState(com.netflix.titus.grpc.protogen.JobStatus.JobState grpcState) {
switch (grpcState) {
case Accepted:
return JobState.Accepted;
case KillInitiated:
return JobState.KillInitiated;
case Finished:
return JobState.Finished;
}
throw new IllegalStateException("Unrecognized GRPC JobState " + grpcState);
}
public static JobDescriptor toCoreJobDescriptor(com.netflix.titus.grpc.protogen.JobDescriptor grpcJobDescriptor) {
JobDescriptor coreJobDescriptor = JobDescriptor.newBuilder()
.withOwner(toCoreOwner(grpcJobDescriptor.getOwner()))
.withApplicationName(grpcJobDescriptor.getApplicationName())
.withJobGroupInfo(toCoreJobGroupInfo(grpcJobDescriptor.getJobGroupInfo()))
.withCapacityGroup(grpcJobDescriptor.getCapacityGroup())
.withContainer(toCoreContainer(grpcJobDescriptor.getContainer()))
.withNetworkConfiguration(toCoreNetworkConfiguration(grpcJobDescriptor.getNetworkConfiguration()))
.withAttributes(grpcJobDescriptor.getAttributesMap())
.withDisruptionBudget(toCoreDisruptionBudget(grpcJobDescriptor.getDisruptionBudget()))
.withExtraContainers(toCoreBasicContainers(grpcJobDescriptor.getExtraContainersList()))
.withVolumes(toCoreVolumes(grpcJobDescriptor.getVolumesList()))
.withPlatformSidecars(toCorePlatformSidecars(grpcJobDescriptor.getPlatformSidecarsList()))
.withExtensions(toCoreJobExtensions(grpcJobDescriptor))
.build();
return mapAttributesToCoreJobDescriptor(coreJobDescriptor);
}
/*
* Maps configurations that exist in job attributes to core model types.
*/
public static <E extends JobDescriptor.JobDescriptorExt> JobDescriptor<E> mapAttributesToCoreJobDescriptor(JobDescriptor<E> coreJobDescriptor) {
// Extract/map EBS volume attributes
List<EbsVolume> ebsVolumes = EbsVolumeUtils.getEbsVolumes(coreJobDescriptor);
return coreJobDescriptor.toBuilder()
.withContainer(coreJobDescriptor.getContainer().toBuilder()
.withContainerResources(coreJobDescriptor.getContainer().getContainerResources().toBuilder()
.withEbsVolumes(ebsVolumes)
.build())
.build())
.build();
}
public static Owner toCoreOwner(com.netflix.titus.grpc.protogen.Owner grpcOwner) {
return JobModel.newOwner().withTeamEmail(grpcOwner.getTeamEmail()).build();
}
public static JobGroupInfo toCoreJobGroupInfo(com.netflix.titus.grpc.protogen.JobGroupInfo grpcJobGroupInfo) {
return JobModel.newJobGroupInfo()
.withStack(grpcJobGroupInfo.getStack())
.withDetail(grpcJobGroupInfo.getDetail())
.withSequence(grpcJobGroupInfo.getSequence())
.build();
}
public static NetworkConfiguration toCoreNetworkConfiguration(com.netflix.titus.grpc.protogen.NetworkConfiguration grpcNetworkConfiguration) {
return JobModel.newNetworkConfiguration()
.withNetworkMode(grpcNetworkConfiguration.getNetworkModeValue())
.build();
}
public static Image toCoreImage(com.netflix.titus.grpc.protogen.Image grpcImage) {
return JobModel.newImage()
.withName(grpcImage.getName())
.withTag(grpcImage.getTag())
.withDigest(grpcImage.getDigest())
.build();
}
public static Image toCoreImage(com.netflix.titus.grpc.protogen.BasicImage grpcImage) {
return JobModel.newImage()
.withName(grpcImage.getName())
.withTag(grpcImage.getTag())
.withDigest(grpcImage.getDigest())
.build();
}
public static EfsMount toCoreEfsMount(com.netflix.titus.grpc.protogen.ContainerResources.EfsMount grpcEfsMount) {
return EfsMount.newBuilder()
.withEfsId(grpcEfsMount.getEfsId())
.withMountPerm(EfsMount.MountPerm.valueOf(grpcEfsMount.getMountPerm().name()))
.withMountPoint(grpcEfsMount.getMountPoint())
.withEfsRelativeMountPoint(grpcEfsMount.getEfsRelativeMountPoint())
.build();
}
private static IpAddressLocation toCoreIpAddressLocation(AddressLocation grpcAddressLocation) {
return IpAddressLocation.newBuilder()
.withAvailabilityZone(grpcAddressLocation.getAvailabilityZone())
.withRegion(grpcAddressLocation.getRegion())
.withSubnetId(grpcAddressLocation.getSubnetId())
.build();
}
private static IpAddressAllocation toCoreIpAddressAllocation(AddressAllocation grpcAddressAllocation) {
return IpAddressAllocation.newBuilder()
.withUuid(grpcAddressAllocation.getUuid())
.withIpAddressLocation(toCoreIpAddressLocation(grpcAddressAllocation.getAddressLocation()))
.withIpAddress(grpcAddressAllocation.getAddress())
.build();
}
public static SignedIpAddressAllocation toCoreSignedIpAddressAllocation(SignedAddressAllocation grpcSignedIpAddressAllocation) {
return SignedIpAddressAllocation.newBuilder()
.withIpAddressAllocation(toCoreIpAddressAllocation(grpcSignedIpAddressAllocation.getAddressAllocation()))
.withAuthoritativePublicKey(grpcSignedIpAddressAllocation.getAuthoritativePublicKey().toByteArray())
.withHostPublicKey(grpcSignedIpAddressAllocation.getHostPublicKey().toByteArray())
.withHostPublicKeySignature(grpcSignedIpAddressAllocation.getHostPublicKeySignature().toByteArray())
.withMessage(grpcSignedIpAddressAllocation.getMessage().toByteArray())
.withMessageSignature(grpcSignedIpAddressAllocation.getMessageSignature().toByteArray())
.build();
}
public static ContainerResources toCoreScalarResources(com.netflix.titus.grpc.protogen.ContainerResources grpcResources) {
List<EfsMount> coreEfsMounts = grpcResources.getEfsMountsCount() == 0
? Collections.emptyList()
: grpcResources.getEfsMountsList().stream().map(GrpcJobManagementModelConverters::toCoreEfsMount).collect(Collectors.toList());
List<SignedIpAddressAllocation> signedIpAddressAllocations = grpcResources.getSignedAddressAllocationsCount() == 0
? Collections.emptyList()
: grpcResources.getSignedAddressAllocationsList().stream().map(GrpcJobManagementModelConverters::toCoreSignedIpAddressAllocation)
.collect(Collectors.toList());
return JobModel.newContainerResources()
.withCpu(grpcResources.getCpu())
.withGpu(grpcResources.getGpu())
.withMemoryMB(grpcResources.getMemoryMB())
.withDiskMB(grpcResources.getDiskMB())
.withNetworkMbps(grpcResources.getNetworkMbps())
.withAllocateIP(grpcResources.getAllocateIP())
.withEfsMounts(coreEfsMounts)
.withShmMB(grpcResources.getShmSizeMB())
.withSignedIpAddressAllocations(signedIpAddressAllocations)
.build();
}
public static com.netflix.titus.api.jobmanager.model.job.SecurityProfile toCoreSecurityProfile(SecurityProfile grpcSecurityProfile) {
return JobModel.newSecurityProfile()
.withSecurityGroups(grpcSecurityProfile.getSecurityGroupsList())
.withIamRole(grpcSecurityProfile.getIamRole())
.withAttributes(grpcSecurityProfile.getAttributesMap())
.build();
}
public static Map<String, String> toCoreConstraints(Constraints grpcConstraints) {
return grpcConstraints.getConstraintsMap();
}
private static RetryPolicy toCoreRetryPolicy(com.netflix.titus.grpc.protogen.RetryPolicy grpcRetryPolicy) {
switch (grpcRetryPolicy.getPolicyCase()) {
case IMMEDIATE:
return JobModel.newImmediateRetryPolicy()
.withRetries(grpcRetryPolicy.getImmediate().getRetries()).build();
case DELAYED:
return JobModel.newDelayedRetryPolicy()
.withDelay(grpcRetryPolicy.getDelayed().getDelayMs(), TimeUnit.MILLISECONDS)
.withRetries(grpcRetryPolicy.getDelayed().getRetries())
.build();
case EXPONENTIALBACKOFF:
return JobModel.newExponentialBackoffRetryPolicy()
.withInitialDelayMs(grpcRetryPolicy.getExponentialBackOff().getInitialDelayMs())
.withMaxDelayMs(grpcRetryPolicy.getExponentialBackOff().getMaxDelayIntervalMs())
.withRetries(grpcRetryPolicy.getExponentialBackOff().getRetries())
.build();
default:
throw new IllegalArgumentException("Unknown retry policy " + grpcRetryPolicy.getPolicyCase());
}
}
public static ServiceJobProcesses toCoreServiceJobProcesses(ServiceJobSpec.ServiceJobProcesses serviceJobProcesses) {
return JobModel.newServiceJobProcesses()
.withDisableIncreaseDesired(serviceJobProcesses.getDisableIncreaseDesired())
.withDisableDecreaseDesired(serviceJobProcesses.getDisableDecreaseDesired())
.build();
}
public static ServiceJobSpec.ServiceJobProcesses toGrpcServiceJobProcesses(ServiceJobProcesses serviceJobProcesses) {
return ServiceJobSpec.ServiceJobProcesses.newBuilder()
.setDisableDecreaseDesired(serviceJobProcesses.isDisableDecreaseDesired())
.setDisableIncreaseDesired(serviceJobProcesses.isDisableIncreaseDesired())
.build();
}
private static MigrationPolicy toCoreMigrationPolicy(com.netflix.titus.grpc.protogen.MigrationPolicy grpcMigrationPolicy) {
switch (grpcMigrationPolicy.getPolicyCase()) {
case SYSTEMDEFAULT:
return JobModel.newSystemDefaultMigrationPolicy().build();
case SELFMANAGED:
return JobModel.newSelfManagedMigrationPolicy().build();
default:
return JobModel.newSystemDefaultMigrationPolicy().build();
}
}
public static Container toCoreContainer(com.netflix.titus.grpc.protogen.Container grpcContainer) {
return JobModel.newContainer()
.withImage(toCoreImage(grpcContainer.getImage()))
.withContainerResources(toCoreScalarResources(grpcContainer.getResources()))
.withSecurityProfile(toCoreSecurityProfile(grpcContainer.getSecurityProfile()))
.withEnv(grpcContainer.getEnvMap())
.withSoftConstraints(toCoreConstraints(grpcContainer.getSoftConstraints()))
.withHardConstraints(toCoreConstraints(grpcContainer.getHardConstraints()))
.withEntryPoint(grpcContainer.getEntryPointList())
.withCommand(grpcContainer.getCommandList())
.withAttributes(grpcContainer.getAttributesMap())
.withVolumeMounts(toCoreVolumeMounts(grpcContainer.getVolumeMountsList()))
.build();
}
private static List<VolumeMount> toCoreVolumeMounts(List<com.netflix.titus.grpc.protogen.VolumeMount> grpcVolumeMounts) {
List<VolumeMount> volumeMounts = new ArrayList<>();
if (grpcVolumeMounts == null) {
return volumeMounts;
}
for (com.netflix.titus.grpc.protogen.VolumeMount v : grpcVolumeMounts) {
volumeMounts.add(toCoreVolumeMount(v));
}
return volumeMounts;
}
private static VolumeMount toCoreVolumeMount(com.netflix.titus.grpc.protogen.VolumeMount v) {
return VolumeMount.newBuilder()
.withVolumeName(v.getVolumeName())
.withMountPath(v.getMountPath())
.withMountPropagation(v.getMountPropagation().toString())
.withReadOnly(v.getReadOnly())
.withSubPath(v.getSubPath())
.build();
}
private static List<BasicContainer> toCoreBasicContainers(List<com.netflix.titus.grpc.protogen.BasicContainer> extraContainersList) {
List<BasicContainer> basicContainers = new ArrayList<>();
for (com.netflix.titus.grpc.protogen.BasicContainer b : extraContainersList) {
basicContainers.add(toCoreBasicContainer(b));
}
return basicContainers;
}
private static BasicContainer toCoreBasicContainer(com.netflix.titus.grpc.protogen.BasicContainer grpcBasicContainer) {
return BasicContainer.newBuilder()
.withName(grpcBasicContainer.getName())
.withImage(toCoreImage(grpcBasicContainer.getImage()))
.withEntryPoint(grpcBasicContainer.getEntryPointList())
.withCommand(grpcBasicContainer.getCommandList())
.withVolumeMounts(toCoreVolumeMounts(grpcBasicContainer.getVolumeMountsList()))
.build();
}
private static List<Volume> toCoreVolumes(List<com.netflix.titus.grpc.protogen.Volume> volumes) {
List<Volume> coreVolumes = new ArrayList<>();
for (com.netflix.titus.grpc.protogen.Volume v : volumes) {
coreVolumes.add(toCoreVolume(v));
}
return coreVolumes;
}
private static Volume toCoreVolume(com.netflix.titus.grpc.protogen.Volume grpcVolume) {
switch (grpcVolume.getVolumeSourceCase()) {
case SHAREDCONTAINERVOLUMESOURCE:
VolumeSource source = toCoreSharedVolumeSource(grpcVolume.getSharedContainerVolumeSource());
return Volume.newBuilder()
.withName(grpcVolume.getName())
.withVolumeSource(source).build();
case SAASVOLUMESOURCE:
VolumeSource saaSSource = toCoreSaaSVolumeSource(grpcVolume.getSaaSVolumeSource());
return Volume.newBuilder()
.withName(grpcVolume.getName())
.withVolumeSource(saaSSource).build();
}
return null;
}
private static VolumeSource toCoreSaaSVolumeSource(com.netflix.titus.grpc.protogen.SaaSVolumeSource saaSVolumeSource) {
return SaaSVolumeSource.newBuilder()
.withSaaSVolumeID(saaSVolumeSource.getSaaSVolumeID())
.build();
}
private static SharedContainerVolumeSource toCoreSharedVolumeSource(com.netflix.titus.grpc.protogen.SharedContainerVolumeSource sharedContainerVolumeSource) {
return SharedContainerVolumeSource.newBuilder()
.withSourceContainer(sharedContainerVolumeSource.getSourceContainer())
.withSourcePath(sharedContainerVolumeSource.getSourcePath())
.build();
}
private static List<PlatformSidecar> toCorePlatformSidecars(List<com.netflix.titus.grpc.protogen.PlatformSidecar> platformSidecarList) {
List<PlatformSidecar> platformSidecars = new ArrayList<>();
for (com.netflix.titus.grpc.protogen.PlatformSidecar ps : platformSidecarList) {
platformSidecars.add(toCorePlatformSidecar(ps));
}
return platformSidecars;
}
private static PlatformSidecar toCorePlatformSidecar(com.netflix.titus.grpc.protogen.PlatformSidecar ps) {
return PlatformSidecar.newBuilder()
.withName(ps.getName())
.withChannel(ps.getChannel())
.withArguments(structToJSONString(ps.getArguments(), ps.getName()))
.build();
}
private static String structToJSONString(Struct arguments, String sidecarName) {
try {
return JsonFormat.printer().omittingInsignificantWhitespace().print(arguments);
} catch (InvalidProtocolBufferException e) {
throw TitusServiceException.newBuilder(TitusServiceException.ErrorCode.INVALID_JOB, "Unable to serialize arguments for the " + sidecarName + " sidecar: " + e.getMessage()).build();
}
}
public static DisruptionBudget toCoreDisruptionBudget(com.netflix.titus.grpc.protogen.JobDisruptionBudget
grpcDisruptionBudget) {
if (JobDisruptionBudget.getDefaultInstance().equals(grpcDisruptionBudget)) {
return DisruptionBudget.none();
}
return DisruptionBudget.newBuilder()
.withDisruptionBudgetPolicy(toCoreDisruptionBudgetPolicy(grpcDisruptionBudget))
.withDisruptionBudgetRate(toCoreDisruptionBudgetRate(grpcDisruptionBudget))
.withTimeWindows(toCoreTimeWindows(grpcDisruptionBudget.getTimeWindowsList()))
.withContainerHealthProviders(toCoreContainerHealthProviders(grpcDisruptionBudget.getContainerHealthProvidersList()))
.build();
}
public static DisruptionBudgetPolicy toCoreDisruptionBudgetPolicy(JobDisruptionBudget grpcDisruptionBudget) {
switch (grpcDisruptionBudget.getPolicyCase()) {
case SELFMANAGED:
return SelfManagedDisruptionBudgetPolicy.newBuilder()
.withRelocationTimeMs(grpcDisruptionBudget.getSelfManaged().getRelocationTimeMs())
.build();
case AVAILABILITYPERCENTAGELIMIT:
return AvailabilityPercentageLimitDisruptionBudgetPolicy.newBuilder()
.withPercentageOfHealthyContainers(grpcDisruptionBudget.getAvailabilityPercentageLimit().getPercentageOfHealthyContainers())
.build();
case UNHEALTHYTASKSLIMIT:
return UnhealthyTasksLimitDisruptionBudgetPolicy.newBuilder()
.withLimitOfUnhealthyContainers(grpcDisruptionBudget.getUnhealthyTasksLimit().getLimitOfUnhealthyContainers())
.build();
case RELOCATIONLIMIT:
return RelocationLimitDisruptionBudgetPolicy.newBuilder()
.withLimit(grpcDisruptionBudget.getRelocationLimit().getLimit())
.build();
default:
return SelfManagedDisruptionBudgetPolicy.newBuilder()
.build();
}
}
public static DisruptionBudgetRate toCoreDisruptionBudgetRate(JobDisruptionBudget grpcDisruptionBudget) {
switch (grpcDisruptionBudget.getRateCase()) {
case RATEUNLIMITED:
return UnlimitedDisruptionBudgetRate.newBuilder()
.build();
case RATEPERCENTAGEPERHOUR:
return PercentagePerHourDisruptionBudgetRate.newBuilder()
.withMaxPercentageOfContainersRelocatedInHour(grpcDisruptionBudget.getRatePercentagePerHour().getMaxPercentageOfContainersRelocatedInHour())
.build();
case RATEPERINTERVAL:
return RatePerIntervalDisruptionBudgetRate.newBuilder()
.withIntervalMs(grpcDisruptionBudget.getRatePerInterval().getIntervalMs())
.withLimitPerInterval(grpcDisruptionBudget.getRatePerInterval().getLimitPerInterval())
.build();
case RATEPERCENTAGEPERINTERVAL:
return RatePercentagePerIntervalDisruptionBudgetRate.newBuilder()
.withIntervalMs(grpcDisruptionBudget.getRatePercentagePerInterval().getIntervalMs())
.withPercentageLimitPerInterval(grpcDisruptionBudget.getRatePercentagePerInterval().getPercentageLimitPerInterval())
.build();
default:
return UnlimitedDisruptionBudgetRate.newBuilder()
.build();
}
}
public static List<TimeWindow> toCoreTimeWindows
(List<com.netflix.titus.grpc.protogen.TimeWindow> grpcTimeWindows) {
return grpcTimeWindows.stream().map(GrpcJobManagementModelConverters::toCoreTimeWindow).collect(Collectors.toList());
}
public static TimeWindow toCoreTimeWindow(com.netflix.titus.grpc.protogen.TimeWindow grpcTimeWindow) {
return TimeWindow.newBuilder()
.withDays(toCoreDays(grpcTimeWindow.getDaysList()))
.withHourlyTimeWindows(toCoreHourlyTimeWindows(grpcTimeWindow.getHourlyTimeWindowsList()))
.withTimeZone(grpcTimeWindow.getTimeZone())
.build();
}
public static List<Day> toCoreDays(List<com.netflix.titus.grpc.protogen.Day> grpcDays) {
return grpcDays.stream().map(GrpcJobManagementModelConverters::toCoreDay).collect(Collectors.toList());
}
public static Day toCoreDay(com.netflix.titus.grpc.protogen.Day grpcDay) {
switch (grpcDay) {
case Monday:
return Day.Monday;
case Tuesday:
return Day.Tuesday;
case Wednesday:
return Day.Wednesday;
case Thursday:
return Day.Thursday;
case Friday:
return Day.Friday;
case Saturday:
return Day.Saturday;
case Sunday:
return Day.Sunday;
default:
throw new IllegalArgumentException("Unknown day: " + grpcDay);
}
}
public static List<HourlyTimeWindow> toCoreHourlyTimeWindows
(List<com.netflix.titus.grpc.protogen.TimeWindow.HourlyTimeWindow> grpcHourlyTimeWindows) {
return grpcHourlyTimeWindows.stream().map(GrpcJobManagementModelConverters::toCoreHourlyTimeWindow).collect(Collectors.toList());
}
public static HourlyTimeWindow toCoreHourlyTimeWindow
(com.netflix.titus.grpc.protogen.TimeWindow.HourlyTimeWindow grpcHourlyTimeWindow) {
return HourlyTimeWindow.newBuilder()
.withStartHour(grpcHourlyTimeWindow.getStartHour())
.withEndHour(grpcHourlyTimeWindow.getEndHour())
.build();
}
public static List<ContainerHealthProvider> toCoreContainerHealthProviders
(List<com.netflix.titus.grpc.protogen.ContainerHealthProvider> grpcContainerHealthProviders) {
return grpcContainerHealthProviders.stream().map(GrpcJobManagementModelConverters::toCoreHourlyTimeWindow).collect(Collectors.toList());
}
public static ContainerHealthProvider toCoreHourlyTimeWindow
(com.netflix.titus.grpc.protogen.ContainerHealthProvider grpcContainerHealthProvider) {
return ContainerHealthProvider.newBuilder()
.withName(grpcContainerHealthProvider.getName())
.withAttributes(grpcContainerHealthProvider.getAttributesMap())
.build();
}
public static JobDescriptor.JobDescriptorExt toCoreJobExtensions(com.netflix.titus.grpc.protogen.JobDescriptor
grpcJobDescriptor) {
if (grpcJobDescriptor.getJobSpecCase() == JobSpecCase.BATCH) {
BatchJobSpec batchSpec = grpcJobDescriptor.getBatch();
return JobModel.newBatchJobExt()
.withSize(batchSpec.getSize())
.withRetryPolicy(toCoreRetryPolicy(batchSpec.getRetryPolicy()))
.withRuntimeLimitMs(batchSpec.getRuntimeLimitSec() * 1000)
.withRetryOnRuntimeLimit(batchSpec.getRetryOnRuntimeLimit())
.build();
}
ServiceJobSpec serviceSpec = grpcJobDescriptor.getService();
return JobModel.newServiceJobExt()
.withCapacity(toCoreCapacity(serviceSpec.getCapacity()))
.withRetryPolicy(toCoreRetryPolicy(serviceSpec.getRetryPolicy()))
.withMigrationPolicy(toCoreMigrationPolicy(serviceSpec.getMigrationPolicy()))
.withEnabled(serviceSpec.getEnabled())
.withServiceJobProcesses(toCoreServiceJobProcesses(serviceSpec.getServiceJobProcesses()))
.build();
}
public static com.netflix.titus.api.jobmanager.model.job.Capacity toCoreCapacity(Capacity capacity) {
return JobModel.newCapacity()
.withMin(capacity.getMin())
.withDesired(capacity.getDesired())
.withMax(capacity.getMax())
.build();
}
public static com.netflix.titus.api.jobmanager.model.job.CapacityAttributes toCoreCapacityAttributes
(JobCapacityWithOptionalAttributes capacity) {
CapacityAttributes.Builder builder = JobModel.newCapacityAttributes();
Evaluators.acceptIfTrue(capacity.hasDesired(), valueAccepted -> builder.withDesired(capacity.getDesired().getValue()));
Evaluators.acceptIfTrue(capacity.hasMin(), valueAccepted -> builder.withMin(capacity.getMin().getValue()));
Evaluators.acceptIfTrue(capacity.hasMax(), valueAccepted -> builder.withMax(capacity.getMax().getValue()));
return builder.build();
}
public static com.netflix.titus.api.jobmanager.model.job.CapacityAttributes toCoreCapacityAttributes(Capacity
capacity) {
return JobModel.newCapacityAttributes()
.withDesired(capacity.getDesired())
.withMax(capacity.getMax())
.withMin(capacity.getMin())
.build();
}
public static Task toCoreTask(com.netflix.titus.grpc.protogen.Task grpcTask) {
Map<String, String> taskContext = grpcTask.getTaskContextMap();
String originalId = Preconditions.checkNotNull(
taskContext.get(TASK_ATTRIBUTES_TASK_ORIGINAL_ID), TASK_ATTRIBUTES_TASK_ORIGINAL_ID + " missing in Task entity"
);
String resubmitOf = taskContext.get(TASK_ATTRIBUTES_TASK_RESUBMIT_OF);
int taskResubmitNumber = Integer.parseInt(taskContext.get(TASK_ATTRIBUTES_RESUBMIT_NUMBER));
int systemResubmitNumber = Integer.parseInt(grpcTask.getTaskContextMap().getOrDefault(TASK_ATTRIBUTES_SYSTEM_RESUBMIT_NUMBER, "0"));
int evictionResubmitNumber = Integer.parseInt(grpcTask.getTaskContextMap().getOrDefault(TASK_ATTRIBUTES_EVICTION_RESUBMIT_NUMBER, "0"));
String taskIndexStr = taskContext.get(TASK_ATTRIBUTES_TASK_INDEX);
// Based on presence of the task index, we decide if it is batch or service task.
boolean isBatchTask = taskIndexStr != null;
Task.TaskBuilder<?, ?> builder = isBatchTask ? JobModel.newBatchJobTask() : JobModel.newServiceJobTask();
builder.withId(grpcTask.getId())
.withJobId(grpcTask.getJobId())
.withStatus(toCoreTaskStatus(grpcTask.getStatus()))
.withStatusHistory(grpcTask.getStatusHistoryList().stream().map(GrpcJobManagementModelConverters::toCoreTaskStatus).collect(Collectors.toList()))
.withResubmitNumber(taskResubmitNumber)
.withOriginalId(originalId)
.withResubmitOf(resubmitOf)
.withSystemResubmitNumber(systemResubmitNumber)
.withEvictionResubmitNumber(evictionResubmitNumber)
.withTaskContext(taskContext)
.withAttributes(buildAttributesMapForCoreTask(grpcTask))
.withVersion(toCoreVersion(grpcTask.getVersion()));
if (isBatchTask) { // Batch job
((BatchJobTask.Builder) builder).withIndex(Integer.parseInt(taskIndexStr));
} else {
((ServiceJobTask.Builder) builder).withMigrationDetails(toCoreMigrationDetails(grpcTask.getMigrationDetails()));
}
return builder.build();
}
private static Map<String, String> buildAttributesMapForCoreTask(com.netflix.titus.grpc.protogen.Task grpcTask) {
Map<String, String> attributes = new HashMap<>(grpcTask.getAttributesMap());
if (grpcTask.hasLogLocation()) {
LogLocation logLocation = grpcTask.getLogLocation();
if (logLocation.hasUi()) {
attributes.put(TASK_ATTRIBUTE_LOG_UI_LOCATION, logLocation.getUi().getUrl());
}
if (logLocation.hasLiveStream()) {
attributes.put(TASK_ATTRIBUTE_LOG_LIVE_STREAM, logLocation.getLiveStream().getUrl());
}
if (logLocation.hasS3()) {
LogLocation.S3 s3 = logLocation.getS3();
attributes.put(TASK_ATTRIBUTE_LOG_S3_ACCOUNT_NAME, s3.getAccountName());
attributes.put(TASK_ATTRIBUTE_LOG_S3_ACCOUNT_ID, s3.getAccountId());
attributes.put(TASK_ATTRIBUTE_LOG_S3_BUCKET_NAME, s3.getBucket());
attributes.put(TASK_ATTRIBUTE_LOG_S3_KEY, s3.getKey());
attributes.put(TASK_ATTRIBUTE_LOG_S3_REGION, s3.getRegion());
}
}
return attributes;
}
public static Task toCoreTask(Job<?> job, com.netflix.titus.grpc.protogen.Task grpcTask) {
return toCoreTask(grpcTask).toBuilder()
.withTwoLevelResources(toCoreTwoLevelResources(job, grpcTask))
.build();
}
/**
* We do not expose the {@link TwoLevelResource} data outside Titus, so we try to reconstruct this information
* from the GRPC model.
*/
private static List<TwoLevelResource> toCoreTwoLevelResources
(Job<?> job, com.netflix.titus.grpc.protogen.Task grpcTask) {
Map<String, String> context = grpcTask.getTaskContextMap();
String eniIndex = context.get(TASK_ATTRIBUTES_NETWORK_INTERFACE_INDEX);
if (eniIndex == null) {
return Collections.emptyList();
}
TwoLevelResource resource = TwoLevelResource.newBuilder()
.withIndex(Integer.parseInt(eniIndex))
.withName("ENIs")
.withValue(StringExt.concatenate(job.getJobDescriptor().getContainer().getSecurityProfile().getSecurityGroups(), ":"))
.build();
return Collections.singletonList(resource);
}
public static TaskStatus toCoreTaskStatus(com.netflix.titus.grpc.protogen.TaskStatus grpcStatus) {
return JobModel.newTaskStatus()
.withState(toCoreTaskState(grpcStatus.getState()))
.withReasonCode(grpcStatus.getReasonCode())
.withReasonMessage(grpcStatus.getReasonMessage())
.withTimestamp(grpcStatus.getTimestamp())
.build();
}
public static TaskState toCoreTaskState(com.netflix.titus.grpc.protogen.TaskStatus.TaskState grpcState) {
TaskState state;
switch (grpcState) {
case Accepted:
state = TaskState.Accepted;
break;
case Launched:
state = TaskState.Launched;
break;
case StartInitiated:
state = TaskState.StartInitiated;
break;
case Started:
state = TaskState.Started;
break;
case KillInitiated:
state = TaskState.KillInitiated;
break;
case Disconnected:
state = TaskState.Disconnected;
break;
case Finished:
state = TaskState.Finished;
break;
default:
throw new IllegalArgumentException("Unrecognized task state " + grpcState);
}
return state;
}
public static com.netflix.titus.grpc.protogen.Owner toGrpcOwner(Owner owner) {
return com.netflix.titus.grpc.protogen.Owner.newBuilder()
.setTeamEmail(owner.getTeamEmail())
.build();
}
public static com.netflix.titus.grpc.protogen.JobGroupInfo toGrpcJobGroupInfo(JobGroupInfo jobGroupInfo) {
if (jobGroupInfo == null) {
return com.netflix.titus.grpc.protogen.JobGroupInfo.getDefaultInstance();
}
com.netflix.titus.grpc.protogen.JobGroupInfo.Builder builder = com.netflix.titus.grpc.protogen.JobGroupInfo.newBuilder();
acceptNotNull(jobGroupInfo.getStack(), builder::setStack);
acceptNotNull(jobGroupInfo.getDetail(), builder::setDetail);
acceptNotNull(jobGroupInfo.getSequence(), builder::setSequence);
return builder.build();
}
private static com.netflix.titus.grpc.protogen.Image toGrpcImage(Image image) {
com.netflix.titus.grpc.protogen.Image.Builder builder = com.netflix.titus.grpc.protogen.Image.newBuilder();
builder.setName(image.getName());
acceptNotNull(image.getTag(), builder::setTag);
acceptNotNull(image.getDigest(), builder::setDigest);
return builder.build();
}
private static com.netflix.titus.grpc.protogen.BasicImage toGrpcBasicImage(Image image) {
com.netflix.titus.grpc.protogen.BasicImage.Builder builder = com.netflix.titus.grpc.protogen.BasicImage.newBuilder();
builder.setName(image.getName());
acceptNotNull(image.getTag(), builder::setTag);
acceptNotNull(image.getDigest(), builder::setDigest);
return builder.build();
}
private static com.netflix.titus.grpc.protogen.NetworkConfiguration toGrpcNetworkConfiguration
(NetworkConfiguration networkConfiguration) {
com.netflix.titus.grpc.protogen.NetworkConfiguration.Builder builder = com.netflix.titus.grpc.protogen.NetworkConfiguration.newBuilder();
builder.setNetworkModeValue(networkConfiguration.getNetworkMode());
return builder.build();
}
public static com.netflix.titus.grpc.protogen.ContainerResources.EfsMount toGrpcEfsMount(EfsMount coreEfsMount) {
com.netflix.titus.grpc.protogen.ContainerResources.EfsMount.Builder builder = com.netflix.titus.grpc.protogen.ContainerResources.EfsMount.newBuilder()
.setEfsId(coreEfsMount.getEfsId())
.setMountPoint(coreEfsMount.getMountPoint())
.setEfsRelativeMountPoint(coreEfsMount.getEfsRelativeMountPoint());
applyNotNull(coreEfsMount.getMountPerm(), perm -> builder.setMountPerm(MountPerm.valueOf(perm.name())));
return builder.build();
}
public static AddressLocation toGrpcAddressLocation(IpAddressLocation coreIpAddressLocation) {
return AddressLocation.newBuilder()
.setAvailabilityZone(coreIpAddressLocation.getAvailabilityZone())
.setRegion(coreIpAddressLocation.getRegion())
.setSubnetId(coreIpAddressLocation.getSubnetId())
.build();
}
public static AddressAllocation toGrpcAddressAllocation(IpAddressAllocation coreIpAddressAllocation) {
return AddressAllocation.newBuilder()
.setUuid(coreIpAddressAllocation.getAllocationId())
.setAddress(coreIpAddressAllocation.getIpAddress())
.setAddressLocation(toGrpcAddressLocation(coreIpAddressAllocation.getIpAddressLocation()))
.build();
}
public static SignedAddressAllocation toGrpcSignedAddressAllocation(SignedIpAddressAllocation
coreSignedIpAddressAllocation) {
return SignedAddressAllocation.newBuilder()
.setAddressAllocation(toGrpcAddressAllocation(coreSignedIpAddressAllocation.getIpAddressAllocation()))
.setAuthoritativePublicKey(ByteString.copyFrom(coreSignedIpAddressAllocation.getAuthoritativePublicKey()))
.setHostPublicKey(ByteString.copyFrom(coreSignedIpAddressAllocation.getHostPublicKey()))
.setHostPublicKeySignature(ByteString.copyFrom(coreSignedIpAddressAllocation.getHostPublicKeySignature()))
.setMessage(ByteString.copyFrom(coreSignedIpAddressAllocation.getMessage()))
.setMessageSignature(ByteString.copyFrom(coreSignedIpAddressAllocation.getMessageSignature()))
.build();
}
public static com.netflix.titus.grpc.protogen.ContainerResources toGrpcResources(ContainerResources
containerResources) {
List<com.netflix.titus.grpc.protogen.ContainerResources.EfsMount> grpcEfsMounts = containerResources.getEfsMounts().isEmpty()
? Collections.emptyList()
: containerResources.getEfsMounts().stream().map(GrpcJobManagementModelConverters::toGrpcEfsMount).collect(Collectors.toList());
List<SignedAddressAllocation> grpcSignedAddressAllocation = containerResources.getSignedIpAddressAllocations().isEmpty()
? Collections.emptyList()
: containerResources.getSignedIpAddressAllocations().stream().map(GrpcJobManagementModelConverters::toGrpcSignedAddressAllocation)
.collect(Collectors.toList());
return com.netflix.titus.grpc.protogen.ContainerResources.newBuilder()
.setCpu(containerResources.getCpu())
.setGpu(containerResources.getGpu())
.setMemoryMB(containerResources.getMemoryMB())
.setDiskMB(containerResources.getDiskMB())
.setNetworkMbps(containerResources.getNetworkMbps())
.setAllocateIP(containerResources.isAllocateIP())
.addAllEfsMounts(grpcEfsMounts)
.setShmSizeMB(containerResources.getShmMB())
.addAllSignedAddressAllocations(grpcSignedAddressAllocation)
.build();
}
public static SecurityProfile toGrpcSecurityProfile(com.netflix.titus.api.jobmanager.model.job.SecurityProfile
coreSecurityProfile) {
return SecurityProfile.newBuilder()
.addAllSecurityGroups(coreSecurityProfile.getSecurityGroups())
.setIamRole(nonNull(coreSecurityProfile.getIamRole()))
.putAllAttributes(coreSecurityProfile.getAttributes())
.build();
}
public static Constraints toGrpcConstraints(Map<String, String> constraints) {
if (constraints.isEmpty()) {
return Constraints.getDefaultInstance();
}
return Constraints.newBuilder().putAllConstraints(constraints).build();
}
public static com.netflix.titus.grpc.protogen.Container toGrpcContainer(Container container) {
return com.netflix.titus.grpc.protogen.Container.newBuilder()
.setImage(toGrpcImage(container.getImage()))
.setResources(toGrpcResources(container.getContainerResources()))
.setSecurityProfile(toGrpcSecurityProfile(container.getSecurityProfile()))
.putAllAttributes(container.getAttributes())
.setSoftConstraints(toGrpcConstraints(container.getSoftConstraints()))
.setHardConstraints(toGrpcConstraints(container.getHardConstraints()))
.addAllEntryPoint(container.getEntryPoint())
.addAllCommand(container.getCommand())
.putAllEnv(container.getEnv())
.addAllVolumeMounts(toGrpcVolumeMounts(container.getVolumeMounts()))
.build();
}
private static com.netflix.titus.grpc.protogen.RetryPolicy toGrpcRetryPolicy(RetryPolicy retryPolicy) {
com.netflix.titus.grpc.protogen.RetryPolicy.Builder builder = com.netflix.titus.grpc.protogen.RetryPolicy.newBuilder();
if (retryPolicy instanceof ImmediateRetryPolicy) {
builder.setImmediate(com.netflix.titus.grpc.protogen.RetryPolicy.Immediate.newBuilder().setRetries(retryPolicy.getRetries()));
} else if (retryPolicy instanceof DelayedRetryPolicy) {
DelayedRetryPolicy delayed = (DelayedRetryPolicy) retryPolicy;
builder.setDelayed(com.netflix.titus.grpc.protogen.RetryPolicy.Delayed.newBuilder()
.setRetries(retryPolicy.getRetries())
.setDelayMs(delayed.getDelayMs())
);
} else if (retryPolicy instanceof ExponentialBackoffRetryPolicy) {
ExponentialBackoffRetryPolicy exponential = (ExponentialBackoffRetryPolicy) retryPolicy;
builder.setExponentialBackOff(com.netflix.titus.grpc.protogen.RetryPolicy.ExponentialBackOff.newBuilder()
.setInitialDelayMs(exponential.getInitialDelayMs())
.setMaxDelayIntervalMs(exponential.getMaxDelayMs())
.setRetries(retryPolicy.getRetries())
);
} else {
throw new IllegalStateException("Unknown retry policy " + retryPolicy);
}
return builder.build();
}
private static com.netflix.titus.grpc.protogen.MigrationPolicy toGrpcMigrationPolicy(MigrationPolicy
migrationPolicy) {
com.netflix.titus.grpc.protogen.MigrationPolicy.Builder builder = com.netflix.titus.grpc.protogen.MigrationPolicy.newBuilder();
if (migrationPolicy instanceof SystemDefaultMigrationPolicy) {
builder.setSystemDefault(com.netflix.titus.grpc.protogen.MigrationPolicy.SystemDefault.newBuilder());
} else if (migrationPolicy instanceof SelfManagedMigrationPolicy) {
builder.setSelfManaged(com.netflix.titus.grpc.protogen.MigrationPolicy.SelfManaged.newBuilder());
} else {
builder.setSystemDefault(com.netflix.titus.grpc.protogen.MigrationPolicy.SystemDefault.newBuilder());
}
return builder.build();
}
public static BatchJobSpec toGrpcBatchSpec(BatchJobExt batchJobExt) {
int desired = batchJobExt.getSize();
return BatchJobSpec.newBuilder()
.setSize(desired)
.setRuntimeLimitSec(batchJobExt.getRuntimeLimitMs() / 1000)
.setRetryPolicy(toGrpcRetryPolicy(batchJobExt.getRetryPolicy()))
.setRetryOnRuntimeLimit(batchJobExt.isRetryOnRuntimeLimit())
.build();
}
public static ServiceJobSpec toGrpcServiceSpec(ServiceJobExt serviceJobExt) {
com.netflix.titus.api.jobmanager.model.job.Capacity capacity = serviceJobExt.getCapacity();
ServiceJobSpec.Builder builder = ServiceJobSpec.newBuilder()
.setServiceJobProcesses(toGrpcServiceJobProcesses(serviceJobExt.getServiceJobProcesses()))
.setEnabled(serviceJobExt.isEnabled())
.setCapacity(toGrpcCapacity(capacity))
.setRetryPolicy(toGrpcRetryPolicy(serviceJobExt.getRetryPolicy()))
.setMigrationPolicy(toGrpcMigrationPolicy(serviceJobExt.getMigrationPolicy()));
return builder.build();
}
public static Capacity toGrpcCapacity(com.netflix.titus.api.jobmanager.model.job.Capacity capacity) {
return Capacity.newBuilder()
.setMin(capacity.getMin())
.setDesired(capacity.getDesired())
.setMax(capacity.getMax())
.build();
}
public static com.netflix.titus.grpc.protogen.JobDisruptionBudget toGrpcDisruptionBudget(DisruptionBudget
coreDisruptionBudget) {
JobDisruptionBudget.Builder builder = JobDisruptionBudget.newBuilder();
DisruptionBudgetPolicy disruptionBudgetPolicy = coreDisruptionBudget.getDisruptionBudgetPolicy();
if (disruptionBudgetPolicy instanceof SelfManagedDisruptionBudgetPolicy) {
builder.setSelfManaged(JobDisruptionBudget.SelfManaged.newBuilder()
.setRelocationTimeMs(((SelfManagedDisruptionBudgetPolicy) disruptionBudgetPolicy).getRelocationTimeMs()));
} else if (disruptionBudgetPolicy instanceof AvailabilityPercentageLimitDisruptionBudgetPolicy) {
builder.setAvailabilityPercentageLimit(JobDisruptionBudget.AvailabilityPercentageLimit.newBuilder()
.setPercentageOfHealthyContainers(((AvailabilityPercentageLimitDisruptionBudgetPolicy) disruptionBudgetPolicy).getPercentageOfHealthyContainers()));
} else if (disruptionBudgetPolicy instanceof UnhealthyTasksLimitDisruptionBudgetPolicy) {
builder.setUnhealthyTasksLimit(JobDisruptionBudget.UnhealthyTasksLimit.newBuilder()
.setLimitOfUnhealthyContainers(((UnhealthyTasksLimitDisruptionBudgetPolicy) disruptionBudgetPolicy).getLimitOfUnhealthyContainers()));
} else if (disruptionBudgetPolicy instanceof RelocationLimitDisruptionBudgetPolicy) {
builder.setRelocationLimit(JobDisruptionBudget.RelocationLimit.newBuilder()
.setLimit(((RelocationLimitDisruptionBudgetPolicy) disruptionBudgetPolicy).getLimit()));
}
DisruptionBudgetRate disruptionBudgetRate = coreDisruptionBudget.getDisruptionBudgetRate();
if (disruptionBudgetRate instanceof UnlimitedDisruptionBudgetRate) {
builder.setRateUnlimited(JobDisruptionBudget.RateUnlimited.newBuilder().build());
} else if (disruptionBudgetRate instanceof PercentagePerHourDisruptionBudgetRate) {
builder.setRatePercentagePerHour(JobDisruptionBudget.RatePercentagePerHour.newBuilder()
.setMaxPercentageOfContainersRelocatedInHour(((PercentagePerHourDisruptionBudgetRate) disruptionBudgetRate).getMaxPercentageOfContainersRelocatedInHour()));
} else if (disruptionBudgetRate instanceof RatePerIntervalDisruptionBudgetRate) {
RatePerIntervalDisruptionBudgetRate ratePerInterval = (RatePerIntervalDisruptionBudgetRate) disruptionBudgetRate;
builder.setRatePerInterval(JobDisruptionBudget.RatePerInterval.newBuilder()
.setIntervalMs(ratePerInterval.getIntervalMs())
.setLimitPerInterval(ratePerInterval.getLimitPerInterval())
.build()
);
} else if (disruptionBudgetRate instanceof RatePercentagePerIntervalDisruptionBudgetRate) {
RatePercentagePerIntervalDisruptionBudgetRate ratePercentagePerInterval = (RatePercentagePerIntervalDisruptionBudgetRate) disruptionBudgetRate;
builder.setRatePercentagePerInterval(JobDisruptionBudget.RatePercentagePerInterval.newBuilder()
.setIntervalMs(ratePercentagePerInterval.getIntervalMs())
.setPercentageLimitPerInterval(ratePercentagePerInterval.getPercentageLimitPerInterval())
.build()
);
}
return builder
.addAllTimeWindows(toGrpcTimeWindows(coreDisruptionBudget.getTimeWindows()))
.addAllContainerHealthProviders(toGrpcContainerHealthProviders(coreDisruptionBudget.getContainerHealthProviders()))
.build();
}
public static List<com.netflix.titus.grpc.protogen.TimeWindow> toGrpcTimeWindows
(List<TimeWindow> grpcTimeWindows) {
return grpcTimeWindows.stream().map(GrpcJobManagementModelConverters::toGrpcTimeWindow).collect(Collectors.toList());
}
public static com.netflix.titus.grpc.protogen.TimeWindow toGrpcTimeWindow(TimeWindow coreTimeWindow) {
return com.netflix.titus.grpc.protogen.TimeWindow.newBuilder()
.addAllDays(toGrpcDays(coreTimeWindow.getDays()))
.addAllHourlyTimeWindows(toGrpcHourlyTimeWindows(coreTimeWindow.getHourlyTimeWindows()))
.setTimeZone(coreTimeWindow.getTimeZone())
.build();
}
public static List<com.netflix.titus.grpc.protogen.Day> toGrpcDays(List<Day> coreDays) {
return coreDays.stream().map(GrpcJobManagementModelConverters::toGrpcDay).collect(Collectors.toList());
}
public static com.netflix.titus.grpc.protogen.Day toGrpcDay(Day coreDay) {
switch (coreDay) {
case Monday:
return Monday;
case Tuesday:
return Tuesday;
case Wednesday:
return Wednesday;
case Thursday:
return Thursday;
case Friday:
return Friday;
case Saturday:
return Saturday;
case Sunday:
return Sunday;
default:
throw new IllegalArgumentException("Unknown day: " + coreDay);
}
}
public static List<com.netflix.titus.grpc.protogen.TimeWindow.HourlyTimeWindow> toGrpcHourlyTimeWindows
(List<HourlyTimeWindow> coreHourlyTimeWindows) {
return coreHourlyTimeWindows.stream().map(GrpcJobManagementModelConverters::toGrpcHourlyTimeWindow).collect(Collectors.toList());
}
public static com.netflix.titus.grpc.protogen.TimeWindow.HourlyTimeWindow toGrpcHourlyTimeWindow
(HourlyTimeWindow coreHourlyTimeWindow) {
return com.netflix.titus.grpc.protogen.TimeWindow.HourlyTimeWindow.newBuilder()
.setStartHour(coreHourlyTimeWindow.getStartHour())
.setEndHour(coreHourlyTimeWindow.getEndHour())
.build();
}
public static List<com.netflix.titus.grpc.protogen.ContainerHealthProvider> toGrpcContainerHealthProviders
(List<ContainerHealthProvider> grpcContainerHealthProviders) {
return grpcContainerHealthProviders.stream().map(GrpcJobManagementModelConverters::toGrpcHourlyTimeWindow).collect(Collectors.toList());
}
public static com.netflix.titus.grpc.protogen.ContainerHealthProvider toGrpcHourlyTimeWindow
(ContainerHealthProvider coreContainerHealthProvider) {
return com.netflix.titus.grpc.protogen.ContainerHealthProvider.newBuilder()
.setName(coreContainerHealthProvider.getName())
.putAllAttributes(coreContainerHealthProvider.getAttributes())
.build();
}
public static com.netflix.titus.grpc.protogen.JobDescriptor toGrpcJobDescriptor
(JobDescriptor<?> jobDescriptor) {
com.netflix.titus.grpc.protogen.JobDescriptor.Builder builder = com.netflix.titus.grpc.protogen.JobDescriptor.newBuilder()
.setOwner(toGrpcOwner(jobDescriptor.getOwner()))
.setApplicationName(jobDescriptor.getApplicationName())
.setCapacityGroup(jobDescriptor.getCapacityGroup())
.setNetworkConfiguration(toGrpcNetworkConfiguration(jobDescriptor.getNetworkConfiguration()))
.setContainer(toGrpcContainer(jobDescriptor.getContainer()))
.setJobGroupInfo(toGrpcJobGroupInfo(jobDescriptor.getJobGroupInfo()))
.setDisruptionBudget(toGrpcDisruptionBudget(jobDescriptor.getDisruptionBudget()))
.addAllExtraContainers(toGrpcBasicContainers(jobDescriptor.getExtraContainers()))
.addAllVolumes(toGrpcVolumes(jobDescriptor.getVolumes()))
.addAllPlatformSidecars(toGrpcPlatformSidecars(jobDescriptor.getPlatformSidecars()))
.putAllAttributes(jobDescriptor.getAttributes());
if (jobDescriptor.getExtensions() instanceof BatchJobExt) {
builder.setBatch(toGrpcBatchSpec((BatchJobExt) jobDescriptor.getExtensions()));
} else {
builder.setService(toGrpcServiceSpec((ServiceJobExt) jobDescriptor.getExtensions()));
}
return builder.build();
}
private static List<com.netflix.titus.grpc.protogen.BasicContainer> toGrpcBasicContainers
(List<BasicContainer> extraContainers) {
return extraContainers.stream().map(GrpcJobManagementModelConverters::toGrpcBasicContainer).collect(Collectors.toList());
}
private static com.netflix.titus.grpc.protogen.BasicContainer toGrpcBasicContainer(BasicContainer basicContainer) {
return com.netflix.titus.grpc.protogen.BasicContainer.newBuilder()
.setName(basicContainer.getName())
.setImage(toGrpcBasicImage(basicContainer.getImage()))
.addAllEntryPoint(basicContainer.getEntryPoint())
.addAllCommand(basicContainer.getCommand())
.putAllEnv(basicContainer.getEnv())
.addAllVolumeMounts(toGrpcVolumeMounts(basicContainer.getVolumeMounts()))
.build();
}
private static List<com.netflix.titus.grpc.protogen.VolumeMount> toGrpcVolumeMounts(List<VolumeMount> volumeMounts) {
List<com.netflix.titus.grpc.protogen.VolumeMount> grpcVolumeMounts = new ArrayList<>();
if (volumeMounts == null) {
return grpcVolumeMounts;
}
for (VolumeMount v : volumeMounts) {
grpcVolumeMounts.add(toGrpcVolumeMount(v));
}
return grpcVolumeMounts;
}
private static com.netflix.titus.grpc.protogen.VolumeMount toGrpcVolumeMount(VolumeMount v) {
return com.netflix.titus.grpc.protogen.VolumeMount.newBuilder()
.setVolumeName(v.getVolumeName())
.setMountPath((v.getMountPath()))
.setMountPropagation(parseEnumIgnoreCase(v.getMountPropagation(), com.netflix.titus.grpc.protogen.VolumeMount.MountPropagation.class))
.setReadOnly(v.getReadOnly())
.setSubPath(v.getSubPath())
.build();
}
private static List<com.netflix.titus.grpc.protogen.Volume> toGrpcVolumes(List<Volume> volumes) {
if (volumes == null) {
return null;
}
return volumes.stream().map(GrpcJobManagementModelConverters::toGrpcVolume).collect(Collectors.toList());
}
private static com.netflix.titus.grpc.protogen.Volume toGrpcVolume(Volume volume) {
VolumeSource source = volume.getVolumeSource();
if (source instanceof SharedContainerVolumeSource) {
return com.netflix.titus.grpc.protogen.Volume.newBuilder()
.setName(volume.getName())
.setSharedContainerVolumeSource(toGrpcSharedVolumeSource((SharedContainerVolumeSource) source))
.build();
} else if (source instanceof SaaSVolumeSource) {
return com.netflix.titus.grpc.protogen.Volume.newBuilder()
.setName(volume.getName())
.setSaaSVolumeSource(toGrpcSaaSVolumeSource((SaaSVolumeSource) source))
.build();
} else {
return null;
}
}
private static com.netflix.titus.grpc.protogen.SaaSVolumeSource toGrpcSaaSVolumeSource(SaaSVolumeSource source) {
return com.netflix.titus.grpc.protogen.SaaSVolumeSource.newBuilder()
.setSaaSVolumeID(source.getSaaSVolumeID())
.build();
}
private static com.netflix.titus.grpc.protogen.SharedContainerVolumeSource toGrpcSharedVolumeSource
(SharedContainerVolumeSource source) {
return com.netflix.titus.grpc.protogen.SharedContainerVolumeSource.newBuilder()
.setSourceContainer(source.getSourceContainer())
.setSourcePath(source.getSourcePath())
.build();
}
private static List<com.netflix.titus.grpc.protogen.PlatformSidecar> toGrpcPlatformSidecars(List<PlatformSidecar> platformSidecarList) {
List<com.netflix.titus.grpc.protogen.PlatformSidecar> platformSidecars = new ArrayList<>();
for (PlatformSidecar ps : platformSidecarList) {
platformSidecars.add(toGrpcPlatformSidecar(ps));
}
return platformSidecars;
}
private static com.netflix.titus.grpc.protogen.PlatformSidecar toGrpcPlatformSidecar(PlatformSidecar ps) {
Either<Struct, String> args = jsonStringToStruct(ps.getArguments());
if (args.hasError()) {
logger.error("Couldn't create platform sidecar arguments for " + ps.getName() + ". Err: " + args.getError());
// If we couldn't create the args struct, we can do our best and return an object without any arguments
return com.netflix.titus.grpc.protogen.PlatformSidecar.newBuilder()
.setName(ps.getName())
.setChannel(ps.getChannel())
.build();
}
return com.netflix.titus.grpc.protogen.PlatformSidecar.newBuilder()
.setName(ps.getName())
.setChannel(ps.getChannel())
.setArguments(args.getValue())
.build();
}
private static Either<Struct, String> jsonStringToStruct(String arguments) {
Struct.Builder argsBuilder = Struct.newBuilder();
try {
JsonFormat.parser().merge(arguments, argsBuilder);
} catch (InvalidProtocolBufferException e) {
return Either.ofError(e.getMessage());
}
Struct args = argsBuilder.build();
return Either.ofValue(args);
}
public static com.netflix.titus.grpc.protogen.JobStatus toGrpcJobStatus(JobStatus status) {
com.netflix.titus.grpc.protogen.JobStatus.Builder builder = com.netflix.titus.grpc.protogen.JobStatus.newBuilder();
switch (status.getState()) {
case Accepted:
builder.setState(com.netflix.titus.grpc.protogen.JobStatus.JobState.Accepted);
break;
case KillInitiated:
builder.setState(com.netflix.titus.grpc.protogen.JobStatus.JobState.KillInitiated);
break;
case Finished:
builder.setState(com.netflix.titus.grpc.protogen.JobStatus.JobState.Finished);
break;
default:
builder.setState(com.netflix.titus.grpc.protogen.JobStatus.JobState.UNRECOGNIZED);
}
applyNotNull(status.getReasonCode(), builder::setReasonCode);
applyNotNull(status.getReasonMessage(), builder::setReasonMessage);
builder.setTimestamp(status.getTimestamp());
return builder.build();
}
public static List<com.netflix.titus.grpc.protogen.JobStatus> toGrpcJobStatusHistory
(List<JobStatus> statusHistory) {
if (isNullOrEmpty(statusHistory)) {
return Collections.emptyList();
}
return statusHistory.stream()
.map(GrpcJobManagementModelConverters::toGrpcJobStatus)
.collect(Collectors.toList());
}
public static com.netflix.titus.grpc.protogen.TaskStatus toGrpcTaskStatus(TaskStatus status) {
com.netflix.titus.grpc.protogen.TaskStatus.Builder builder = com.netflix.titus.grpc.protogen.TaskStatus.newBuilder();
builder.setState(toGrpcTaskState(status.getState()));
applyNotNull(status.getReasonCode(), builder::setReasonCode);
applyNotNull(status.getReasonMessage(), builder::setReasonMessage);
builder.setTimestamp(status.getTimestamp());
return builder.build();
}
public static com.netflix.titus.grpc.protogen.TaskStatus.TaskState toGrpcTaskState(TaskState coreTaskState) {
switch (coreTaskState) {
case Accepted:
return com.netflix.titus.grpc.protogen.TaskStatus.TaskState.Accepted;
case Launched:
return com.netflix.titus.grpc.protogen.TaskStatus.TaskState.Launched;
case StartInitiated:
return com.netflix.titus.grpc.protogen.TaskStatus.TaskState.StartInitiated;
case Started:
return com.netflix.titus.grpc.protogen.TaskStatus.TaskState.Started;
case Disconnected:
return com.netflix.titus.grpc.protogen.TaskStatus.TaskState.Disconnected;
case KillInitiated:
return com.netflix.titus.grpc.protogen.TaskStatus.TaskState.KillInitiated;
case Finished:
return com.netflix.titus.grpc.protogen.TaskStatus.TaskState.Finished;
default:
return com.netflix.titus.grpc.protogen.TaskStatus.TaskState.UNRECOGNIZED;
}
}
public static List<com.netflix.titus.grpc.protogen.TaskStatus> toGrpcTaskStatusHistory
(List<TaskStatus> statusHistory) {
if (isNullOrEmpty(statusHistory)) {
return Collections.emptyList();
}
return statusHistory.stream()
.map(GrpcJobManagementModelConverters::toGrpcTaskStatus)
.collect(Collectors.toList());
}
public static com.netflix.titus.grpc.protogen.Job toGrpcJob(Job<?> coreJob) {
return com.netflix.titus.grpc.protogen.Job.newBuilder()
.setId(coreJob.getId())
.setJobDescriptor(toGrpcJobDescriptor(coreJob.getJobDescriptor()))
.setStatus(toGrpcJobStatus(coreJob.getStatus()))
.addAllStatusHistory(toGrpcJobStatusHistory(coreJob.getStatusHistory()))
.setVersion(toGrpcVersion(coreJob.getVersion()))
.build();
}
private static com.netflix.titus.grpc.protogen.Version toGrpcVersion(Version version) {
return com.netflix.titus.grpc.protogen.Version.newBuilder()
.setTimestamp(version.getTimestamp())
.build();
}
public static com.netflix.titus.grpc.protogen.Task toGrpcTask(Task coreTask, LogStorageInfo<Task> logStorageInfo) {
Map<String, String> taskContext = new HashMap<>(coreTask.getTaskContext());
taskContext.put(TASK_ATTRIBUTES_TASK_ORIGINAL_ID, coreTask.getOriginalId());
taskContext.put(TASK_ATTRIBUTES_RESUBMIT_NUMBER, Integer.toString(coreTask.getResubmitNumber()));
taskContext.put(TASK_ATTRIBUTES_SYSTEM_RESUBMIT_NUMBER, Integer.toString(coreTask.getSystemResubmitNumber()));
taskContext.put(TASK_ATTRIBUTES_EVICTION_RESUBMIT_NUMBER, Integer.toString(coreTask.getEvictionResubmitNumber()));
coreTask.getResubmitOf().ifPresent(resubmitOf -> taskContext.put(TASK_ATTRIBUTES_TASK_RESUBMIT_OF, resubmitOf));
if (coreTask instanceof BatchJobTask) {
BatchJobTask batchTask = (BatchJobTask) coreTask;
taskContext.put(TASK_ATTRIBUTES_TASK_INDEX, Integer.toString(batchTask.getIndex()));
}
com.netflix.titus.grpc.protogen.Task.Builder taskBuilder = com.netflix.titus.grpc.protogen.Task.newBuilder()
.setId(coreTask.getId())
.setJobId(coreTask.getJobId())
.setStatus(toGrpcTaskStatus(coreTask.getStatus()))
.addAllStatusHistory(toGrpcTaskStatusHistory(coreTask.getStatusHistory()))
.putAllTaskContext(taskContext)
.putAllAttributes(coreTask.getAttributes())
.setLogLocation(toGrpcLogLocation(coreTask, logStorageInfo))
.setVersion(toGrpcVersion(coreTask.getVersion()));
if (coreTask instanceof ServiceJobTask) {
ServiceJobTask serviceTask = (ServiceJobTask) coreTask;
taskBuilder.setMigrationDetails(toGrpcMigrationDetails(serviceTask.getMigrationDetails()));
}
return taskBuilder.build();
}
public static <TASK> LogLocation toGrpcLogLocation(TASK task, LogStorageInfo<TASK> logStorageInfo) {
LogLocation.Builder logLocationBuilder = LogLocation.newBuilder();
// UI
logStorageInfo.getTitusUiLink(task).ifPresent(link -> logLocationBuilder.setUi(LogLocation.UI.newBuilder().setUrl(link)));
// Live links
LogStorageInfo.LogLinks links = logStorageInfo.getLinks(task);
links.getLiveLink().ifPresent(link -> logLocationBuilder.setLiveStream(LogLocation.LiveStream.newBuilder().setUrl(link)));
// S3
logStorageInfo.getS3LogLocation(task, true).ifPresent(s3LogLocation ->
logLocationBuilder.setS3(
LogLocation.S3.newBuilder()
.setAccountId(s3LogLocation.getAccountId())
.setAccountName(s3LogLocation.getAccountName())
.setRegion(s3LogLocation.getRegion())
.setBucket(s3LogLocation.getBucket())
.setKey(s3LogLocation.getKey())
));
return logLocationBuilder.build();
}
public static com.netflix.titus.grpc.protogen.MigrationDetails toGrpcMigrationDetails(MigrationDetails
migrationDetails) {
return com.netflix.titus.grpc.protogen.MigrationDetails.newBuilder()
.setNeedsMigration(migrationDetails.isNeedsMigration())
.setStarted(migrationDetails.getStarted())
.setDeadline(migrationDetails.getDeadline())
.build();
}
public static MigrationDetails toCoreMigrationDetails(com.netflix.titus.grpc.protogen.MigrationDetails
grpcMigrationDetails) {
return MigrationDetails.newBuilder()
.withNeedsMigration(grpcMigrationDetails.getNeedsMigration())
.withStarted(grpcMigrationDetails.getStarted())
.withDeadline(grpcMigrationDetails.getDeadline())
.build();
}
public static JobChangeNotification toGrpcJobChangeNotification(JobManagerEvent<?> event,
GrpcObjectsCache grpcObjectsCache,
long now) {
if (event instanceof JobUpdateEvent) {
JobUpdateEvent jobUpdateEvent = (JobUpdateEvent) event;
return JobChangeNotification.newBuilder()
.setJobUpdate(JobChangeNotification.JobUpdate.newBuilder()
.setJob(grpcObjectsCache.getJob(jobUpdateEvent.getCurrent()))
.setArchived(event.isArchived())
)
.setTimestamp(now)
.build();
}
if (event instanceof TaskUpdateEvent) {
TaskUpdateEvent taskUpdateEvent = (TaskUpdateEvent) event;
return JobChangeNotification.newBuilder()
.setTaskUpdate(
JobChangeNotification.TaskUpdate.newBuilder()
.setTask(grpcObjectsCache.getTask(taskUpdateEvent.getCurrent()))
.setArchived(event.isArchived())
.setMovedFromAnotherJob(taskUpdateEvent.isMovedFromAnotherJob())
)
.setTimestamp(now)
.build();
}
if (event instanceof JobKeepAliveEvent) {
JobKeepAliveEvent keepAliveEvent = (JobKeepAliveEvent) event;
return JobChangeNotification.newBuilder()
.setKeepAliveResponse(KeepAliveResponse.newBuilder()
.setTimestamp(keepAliveEvent.getTimestamp())
.build()
)
.build();
}
throw new IllegalStateException("Unrecognized JobManagerEvent type: " + event);
}
}
| 1,186 |
0 | Create_ds/titus-control-plane/titus-client/src/main/java/com/netflix/titus/runtime/connector | Create_ds/titus-control-plane/titus-client/src/main/java/com/netflix/titus/runtime/connector/jobmanager/RemoteJobManagementClientWithKeepAlive.java | /*
* Copyright 2021 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.runtime.connector.jobmanager;
import java.time.Duration;
import java.util.Map;
import java.util.concurrent.atomic.AtomicLong;
import java.util.concurrent.atomic.AtomicReference;
import com.google.common.annotations.VisibleForTesting;
import com.netflix.titus.common.runtime.TitusRuntime;
import com.netflix.titus.common.util.ExceptionExt;
import com.netflix.titus.common.util.FunctionExt;
import com.netflix.titus.grpc.protogen.JobChangeNotification;
import com.netflix.titus.grpc.protogen.JobManagementServiceGrpc.JobManagementServiceStub;
import com.netflix.titus.grpc.protogen.KeepAliveRequest;
import com.netflix.titus.grpc.protogen.ObserveJobsQuery;
import com.netflix.titus.grpc.protogen.ObserveJobsWithKeepAliveRequest;
import io.grpc.stub.ClientCallStreamObserver;
import io.grpc.stub.ClientResponseObserver;
import io.grpc.stub.StreamObserver;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import reactor.core.Disposable;
import reactor.core.publisher.Flux;
/**
* Extension of {@link RemoteJobManagementClient} that uses the new observeJobsWithKeepAlive GRPC method.
* Its usage is limited now to communication between TitusGateway and TJC.
*/
public class RemoteJobManagementClientWithKeepAlive extends RemoteJobManagementClient {
private static final Logger logger = LoggerFactory.getLogger(RemoteJobManagementClientWithKeepAlive.class);
private final JobConnectorConfiguration configuration;
/**
* Reactor bridge does not support input streams, so we have to use the GRPC stub directly here.
*/
private final JobManagementServiceStub stub;
private final TitusRuntime titusRuntime;
private final AtomicLong keepAliveIdGen = new AtomicLong();
public RemoteJobManagementClientWithKeepAlive(String clientName,
JobConnectorConfiguration configuration,
JobManagementServiceStub stub,
ReactorJobManagementServiceStub reactorStub,
TitusRuntime titusRuntime) {
super(clientName, reactorStub, titusRuntime);
this.configuration = configuration;
this.stub = stub;
this.titusRuntime = titusRuntime;
}
/**
* Only used for unit testing to ensure internal subscriptions are not leaked.
* The <t>keepAliveCompleted</t> callback runs when the keep alive (interval) subscription is disposed
*/
@VisibleForTesting
Flux<JobChangeNotification> connectObserveJobs(Map<String, String> filteringCriteria, Runnable keepAliveCompleted) {
return Flux.create(sink -> {
AtomicReference<ClientCallStreamObserver> requestStreamRef = new AtomicReference<>();
StreamObserver<JobChangeNotification> grpcStreamObserver = new ClientResponseObserver<JobChangeNotification, JobChangeNotification>() {
@Override
public void beforeStart(ClientCallStreamObserver requestStream) {
requestStreamRef.set(requestStream);
}
@Override
public void onNext(JobChangeNotification value) {
sink.next(value);
}
@Override
public void onError(Throwable error) {
sink.error(error);
}
@Override
public void onCompleted() {
sink.complete();
}
};
StreamObserver<ObserveJobsWithKeepAliveRequest> clientStreamObserver = stub.observeJobsWithKeepAlive(grpcStreamObserver);
clientStreamObserver.onNext(ObserveJobsWithKeepAliveRequest.newBuilder()
.setQuery(ObserveJobsQuery.newBuilder().putAllFilteringCriteria(filteringCriteria).build())
.build()
);
// Now emit keep alive requests periodically
Disposable keepAliveSubscription = Flux.interval(Duration.ofMillis(configuration.getKeepAliveIntervalMs()))
// doOnCancel is confusing: it's called when the subscription is disposed
// It should be named doOnDispose. See: https://github.com/reactor/reactor-core/issues/1240
.doOnCancel(
() -> ExceptionExt.doCatch(keepAliveCompleted)
.ifPresent(t -> logger.warn("Error running the keepAliveCompleted callback", t))
)
.subscribe(
next -> {
try {
clientStreamObserver.onNext(ObserveJobsWithKeepAliveRequest.newBuilder()
.setKeepAliveRequest(KeepAliveRequest.newBuilder()
.setRequestId(keepAliveIdGen.getAndIncrement())
.setTimestamp(titusRuntime.getClock().wallTime())
.build()
)
.build()
);
} catch (Exception error) {
clientStreamObserver.onError(error);
}
},
sink::error,
() -> sink.error(new IllegalArgumentException("Keep alive stream terminated. Closing the event stream"))
);
sink.onDispose(() -> {
keepAliveSubscription.dispose();
if (requestStreamRef.get() != null) {
requestStreamRef.get().cancel("ObserveJobs stream cancelled by the client", null);
}
});
});
}
@Override
protected Flux<JobChangeNotification> connectObserveJobs(Map<String, String> filteringCriteria) {
return connectObserveJobs(filteringCriteria, FunctionExt.noop());
}
}
| 1,187 |
0 | Create_ds/titus-control-plane/titus-client/src/main/java/com/netflix/titus/runtime/connector | Create_ds/titus-control-plane/titus-client/src/main/java/com/netflix/titus/runtime/connector/jobmanager/ReactorJobManagementServiceStub.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.runtime.connector.jobmanager;
import com.netflix.titus.api.model.callmetadata.CallMetadata;
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.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.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 reactor.core.publisher.Flux;
import reactor.core.publisher.Mono;
public interface ReactorJobManagementServiceStub {
// ------------------------------------------------------------
// Job operations
Mono<JobId> createJob(JobDescriptor jobDescriptor, CallMetadata callMetadata);
Mono<Void> updateJobCapacity(JobCapacityUpdate jobCapacityUpdate, CallMetadata callMetadata);
Mono<Void> updateJobStatus(JobStatusUpdate jobStatusUpdate, CallMetadata callMetadata);
Mono<Void> updateJobProcesses(JobProcessesUpdate jobProcessesUpdate, CallMetadata callMetadata);
Mono<Void> updateJobDisruptionBudget(JobDisruptionBudgetUpdate jobDisruptionBudgetUpdate, CallMetadata callMetadata);
Mono<JobQueryResult> findJobs(JobQuery jobQuery);
Mono<Job> findJob(JobId jobId);
Flux<JobChangeNotification> observeJob(JobId jobId);
Flux<JobChangeNotification> observeJobs(ObserveJobsQuery observeJobsQuery);
Mono<Void> killJob(JobId jobId, CallMetadata callMetadata);
Mono<Void> updateJobAttributes(JobAttributesUpdate jobAttributesUpdate, CallMetadata callMetadata);
Mono<Void> deleteJobAttributes(JobAttributesDeleteRequest jobAttributesDeleteRequest, CallMetadata callMetadata);
// ------------------------------------------------------------
// Task operations
Mono<Task> findTask(TaskId taskId);
Mono<TaskQueryResult> findTasks(TaskQuery taskQuery);
Mono<Void> killTask(TaskKillRequest taskKillRequest, CallMetadata callMetadata);
Mono<Void> updateTaskAttributes(TaskAttributesUpdate taskAttributesUpdate, CallMetadata callMetadata);
Mono<Void> deleteTaskAttributes(TaskAttributesDeleteRequest taskAttributesDeleteRequest, CallMetadata callMetadata);
Mono<Void> moveTask(TaskMoveRequest taskMoveRequest, CallMetadata callMetadata);
}
| 1,188 |
0 | Create_ds/titus-control-plane/titus-client/src/main/java/com/netflix/titus/runtime/connector | Create_ds/titus-control-plane/titus-client/src/main/java/com/netflix/titus/runtime/connector/jobmanager/CachedReadOnlyJobOperations.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.runtime.connector.jobmanager;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.function.Predicate;
import java.util.stream.Collectors;
import javax.inject.Inject;
import javax.inject.Singleton;
import com.netflix.titus.api.jobmanager.model.job.Job;
import com.netflix.titus.api.jobmanager.model.job.JobState;
import com.netflix.titus.api.jobmanager.model.job.Task;
import com.netflix.titus.api.jobmanager.model.job.event.JobManagerEvent;
import com.netflix.titus.api.jobmanager.model.job.event.JobUpdateEvent;
import com.netflix.titus.api.jobmanager.model.job.event.TaskUpdateEvent;
import com.netflix.titus.api.jobmanager.service.ReadOnlyJobOperations;
import com.netflix.titus.common.annotation.Experimental;
import com.netflix.titus.common.util.rx.ReactorExt;
import com.netflix.titus.common.util.tuple.Pair;
import com.netflix.titus.runtime.connector.jobmanager.snapshot.JobSnapshot;
import reactor.core.publisher.Flux;
import rx.Observable;
@Singleton
public class CachedReadOnlyJobOperations implements ReadOnlyJobOperations {
private final JobDataReplicator replicator;
@Inject
public CachedReadOnlyJobOperations(JobDataReplicator replicator) {
this.replicator = replicator;
}
@Override
public List<Job> getJobs() {
return (List) replicator.getCurrent().getJobs();
}
@Override
public Optional<Job<?>> getJob(String jobId) {
return replicator.getCurrent().findJob(jobId);
}
@Override
public List<Task> getTasks() {
return replicator.getCurrent().getTasks();
}
@Override
public List<Task> getTasks(String jobId) {
return new ArrayList<>(replicator.getCurrent().getTasks(jobId).values());
}
@Override
public List<Pair<Job, List<Task>>> getJobsAndTasks() {
List<Pair<Job<?>, Map<String, Task>>> jobsAndTasks = replicator.getCurrent().getJobsAndTasks();
List<Pair<Job, List<Task>>> allJobsAndTasks = new ArrayList<>(jobsAndTasks.size());
jobsAndTasks.forEach(jobMapPair -> {
Pair<Job, List<Task>> pair = Pair.of(jobMapPair.getLeft(), new ArrayList<>(jobMapPair.getRight().values()));
allJobsAndTasks.add(pair);
});
return allJobsAndTasks;
}
@Override
public List<Job<?>> findJobs(Predicate<Pair<Job<?>, List<Task>>> queryPredicate, int offset, int limit) {
JobSnapshot snapshot = replicator.getCurrent();
return snapshot.getJobMap().values().stream()
.filter(job -> queryPredicate.test(Pair.of(job, new ArrayList<>(snapshot.getTasks(job.getId()).values()))))
.skip(offset)
.limit(limit)
.collect(Collectors.toList());
}
@Override
public List<Pair<Job<?>, Task>> findTasks(Predicate<Pair<Job<?>, Task>> queryPredicate, int offset, int limit) {
JobSnapshot snapshot = replicator.getCurrent();
return snapshot.getJobMap().values().stream()
.flatMap(job -> snapshot.getTasks(job.getId()).values().stream()
.filter(task -> queryPredicate.test(Pair.of(job, task)))
.map(task -> Pair.<Job<?>, Task>of(job, task))
)
.skip(offset)
.limit(limit)
.collect(Collectors.toList());
}
@Override
public Optional<Pair<Job<?>, Task>> findTaskById(String taskId) {
return replicator.getCurrent().findTaskById(taskId);
}
/**
* TODO Emit snapshot on subscription
* TODO Handle failover scenarios (onError or make full snapshot diff)
*/
@Override
@Experimental(deadline = "03/2019")
public Observable<JobManagerEvent<?>> observeJobs(Predicate<Pair<Job<?>, List<Task>>> jobsPredicate,
Predicate<Pair<Job<?>, Task>> tasksPredicate,
boolean withCheckpoints) {
Flux<JobManagerEvent<?>> fluxStream = replicator.events()
.filter(event -> {
if (event.getRight() instanceof JobUpdateEvent) {
JobUpdateEvent jobUpdateEvent = (JobUpdateEvent) event.getRight();
Job<?> job = jobUpdateEvent.getCurrent();
List<Task> tasks = new ArrayList<>(replicator.getCurrent().getTasks(job.getId()).values());
return jobsPredicate.test(Pair.of(job, tasks));
}
if (event.getRight() instanceof TaskUpdateEvent) {
TaskUpdateEvent taskUpdateEvent = (TaskUpdateEvent) event.getRight();
return tasksPredicate.test(Pair.of(taskUpdateEvent.getCurrentJob(), taskUpdateEvent.getCurrentTask()));
}
return false;
})
.map(Pair::getRight);
return ReactorExt.toObservable(fluxStream);
}
/**
* TODO Handle case when job is not found or there is a reconnect during which time the job is terminated.
*/
@Override
@Experimental(deadline = "03/2019")
public Observable<JobManagerEvent<?>> observeJob(String jobId) {
return observeJobs(jobTasks -> jobTasks.getLeft().getId().equals(jobId), jobTask -> jobTask.getLeft().getId().equals(jobId), false)
.takeUntil(event -> {
if (event instanceof JobUpdateEvent) {
JobUpdateEvent jobUpdateEvent = (JobUpdateEvent) event;
return jobUpdateEvent.getCurrent().getStatus().getState() == JobState.Finished;
}
return false;
});
}
}
| 1,189 |
0 | Create_ds/titus-control-plane/titus-client/src/main/java/com/netflix/titus/runtime/connector | Create_ds/titus-control-plane/titus-client/src/main/java/com/netflix/titus/runtime/connector/jobmanager/JobEventPropagationUtil.java | /*
* Copyright 2021 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.runtime.connector.jobmanager;
import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import com.netflix.titus.api.jobmanager.model.job.Job;
import com.netflix.titus.api.jobmanager.model.job.JobDescriptor.JobDescriptorExt;
import com.netflix.titus.api.jobmanager.model.job.Task;
import com.netflix.titus.common.util.event.EventPropagationTrace;
import com.netflix.titus.common.util.event.EventPropagationUtil;
import com.netflix.titus.common.util.time.Clock;
/**
* Help utils for measuring job event notification propagation delays.
*/
public class JobEventPropagationUtil {
public static final String CHECKPOINT_TJC_INTERNAL = "tjcInternal";
public static final String CHECKPOINT_GATEWAY_CLIENT = "gwClient";
public static final String CHECKPOINT_GATEWAY_INTERNAL = "gwInternal";
public static final String CHECKPOINT_FED_CLIENT = "fedClient";
public static final String CHECKPOINT_FED_INTERNAL = "federationInternal";
public static final List<String> FEDERATION_LABELS = Arrays.asList(
CHECKPOINT_TJC_INTERNAL,
CHECKPOINT_GATEWAY_CLIENT,
CHECKPOINT_GATEWAY_INTERNAL,
CHECKPOINT_FED_CLIENT,
CHECKPOINT_FED_INTERNAL
);
public static <E extends JobDescriptorExt> Job<E> recordChannelLatency(String id, Job<E> job, long timestamp, Clock clock) {
Map<String, String> updated = EventPropagationUtil.copyAndAddNextStage(id, job.getJobDescriptor().getAttributes(), timestamp, clock.wallTime());
return job.toBuilder()
.withJobDescriptor(job.getJobDescriptor().toBuilder().withAttributes(updated).build())
.build();
}
public static com.netflix.titus.grpc.protogen.Job recordChannelLatency(String id, com.netflix.titus.grpc.protogen.Job job, long timestamp, Clock clock) {
String next = EventPropagationUtil.buildNextStage(id, job.getJobDescriptor().getAttributesMap(), timestamp, clock.wallTime());
return job.toBuilder()
.setJobDescriptor(job.getJobDescriptor().toBuilder()
.putAttributes(EventPropagationUtil.EVENT_ATTRIBUTE_PROPAGATION_STAGES, next)
.build()
)
.build();
}
public static Task recordChannelLatency(String id, Task task, long timestamp, Clock clock) {
Map<String, String> updated = EventPropagationUtil.copyAndAddNextStage(id, task.getAttributes(), timestamp, clock.wallTime());
return task.toBuilder().withAttributes(updated).build();
}
public static com.netflix.titus.grpc.protogen.Task recordChannelLatency(String id, com.netflix.titus.grpc.protogen.Task task, long timestamp, Clock clock) {
String next = EventPropagationUtil.buildNextStage(id, task.getAttributesMap(), timestamp, clock.wallTime());
return task.toBuilder()
.putAttributes(EventPropagationUtil.EVENT_ATTRIBUTE_PROPAGATION_STAGES, next)
.build();
}
public static Optional<EventPropagationTrace> newTrace(Job job, boolean snapshot, List<String> labels) {
return EventPropagationUtil.parseTrace(job.getJobDescriptor().getAttributes(), snapshot, job.getVersion().getTimestamp(), labels);
}
}
| 1,190 |
0 | Create_ds/titus-control-plane/titus-client/src/main/java/com/netflix/titus/runtime/connector | Create_ds/titus-control-plane/titus-client/src/main/java/com/netflix/titus/runtime/connector/jobmanager/JobEventPropagationMetrics.java | /*
* Copyright 2021 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.runtime.connector.jobmanager;
import java.util.List;
import java.util.Optional;
import com.netflix.titus.api.jobmanager.model.job.Job;
import com.netflix.titus.api.jobmanager.model.job.Task;
import com.netflix.titus.common.runtime.TitusRuntime;
import com.netflix.titus.common.util.CollectionsExt;
import com.netflix.titus.common.util.event.EventPropagationMetrics;
import com.netflix.titus.common.util.event.EventPropagationTrace;
import com.netflix.titus.common.util.event.EventPropagationUtil;
import static com.netflix.titus.runtime.connector.jobmanager.JobEventPropagationUtil.FEDERATION_LABELS;
public class JobEventPropagationMetrics {
private final List<String> stageNames;
private final EventPropagationMetrics metrics;
private JobEventPropagationMetrics(String name, List<String> stageNames, TitusRuntime titusRuntime) {
this.stageNames = stageNames;
this.metrics = new EventPropagationMetrics(
titusRuntime.getRegistry().createId(name),
stageNames,
titusRuntime
);
}
public Optional<EventPropagationTrace> recordJob(Job job, boolean snapshot) {
Optional<EventPropagationTrace> trace = EventPropagationUtil.parseTrace(
job.getJobDescriptor().getAttributes(),
snapshot,
job.getVersion().getTimestamp(),
stageNames
);
trace.ifPresent(metrics::record);
return trace;
}
public Optional<EventPropagationTrace> recordTask(Task task, boolean snapshot) {
Optional<EventPropagationTrace> trace = EventPropagationUtil.parseTrace(
task.getAttributes(),
snapshot,
task.getVersion().getTimestamp(),
stageNames
);
trace.ifPresent(metrics::record);
return trace;
}
public static JobEventPropagationMetrics newFederationMetrics(TitusRuntime titusRuntime) {
return new JobEventPropagationMetrics("titus.eventPropagation", FEDERATION_LABELS, titusRuntime);
}
public static JobEventPropagationMetrics newExternalClientMetrics(String clientName, TitusRuntime titusRuntime) {
List<String> labels = CollectionsExt.copyAndAdd(FEDERATION_LABELS, clientName);
return new JobEventPropagationMetrics("titus.eventPropagation", labels, titusRuntime);
}
}
| 1,191 |
0 | Create_ds/titus-control-plane/titus-client/src/main/java/com/netflix/titus/runtime/connector | Create_ds/titus-control-plane/titus-client/src/main/java/com/netflix/titus/runtime/connector/jobmanager/RemoteJobManagementClient.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.runtime.connector.jobmanager;
import java.util.Map;
import java.util.Objects;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.atomic.AtomicReference;
import java.util.stream.Collectors;
import javax.inject.Inject;
import javax.inject.Singleton;
import com.netflix.titus.api.jobmanager.TaskAttributes;
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.JobDescriptor;
import com.netflix.titus.api.jobmanager.model.job.ServiceJobProcesses;
import com.netflix.titus.api.jobmanager.model.job.Task;
import com.netflix.titus.api.jobmanager.model.job.disruptionbudget.DisruptionBudget;
import com.netflix.titus.api.jobmanager.model.job.event.JobManagerEvent;
import com.netflix.titus.api.jobmanager.model.job.event.JobUpdateEvent;
import com.netflix.titus.api.jobmanager.model.job.event.TaskUpdateEvent;
import com.netflix.titus.api.jobmanager.service.JobManagerConstants;
import com.netflix.titus.api.model.Page;
import com.netflix.titus.api.model.PageResult;
import com.netflix.titus.api.model.callmetadata.CallMetadata;
import com.netflix.titus.common.runtime.TitusRuntime;
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.JobChangeNotification;
import com.netflix.titus.grpc.protogen.JobDisruptionBudgetUpdate;
import com.netflix.titus.grpc.protogen.JobId;
import com.netflix.titus.grpc.protogen.JobProcessesUpdate;
import com.netflix.titus.grpc.protogen.JobQuery;
import com.netflix.titus.grpc.protogen.JobStatusUpdate;
import com.netflix.titus.grpc.protogen.ObserveJobsQuery;
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.runtime.endpoint.v3.grpc.GrpcJobManagementModelConverters;
import com.netflix.titus.runtime.endpoint.v3.grpc.GrpcJobQueryModelConverters;
import reactor.core.publisher.Flux;
import reactor.core.publisher.Mono;
@Singleton
public class RemoteJobManagementClient implements JobManagementClient {
private final String clientName;
private final ReactorJobManagementServiceStub stub;
private final TitusRuntime titusRuntime;
@Inject
public RemoteJobManagementClient(String clientName, ReactorJobManagementServiceStub stub, TitusRuntime titusRuntime) {
this.clientName = clientName;
this.stub = stub;
this.titusRuntime = titusRuntime;
}
@Override
public Mono<String> createJob(JobDescriptor jobDescriptor, CallMetadata callMetadata) {
return stub.createJob(GrpcJobManagementModelConverters.toGrpcJobDescriptor(jobDescriptor), callMetadata).map(JobId::getId);
}
@Override
public Mono<Void> updateJobCapacity(String jobId, Capacity capacity, CallMetadata callMetadata) {
return stub.updateJobCapacity(
JobCapacityUpdate.newBuilder()
.setJobId(jobId)
.setCapacity(GrpcJobManagementModelConverters.toGrpcCapacity(capacity))
.build(),
callMetadata
);
}
@Override
public Mono<Void> updateJobStatus(String jobId, boolean enabled, CallMetadata callMetadata) {
return stub.updateJobStatus(
JobStatusUpdate.newBuilder()
.setId(jobId)
.setEnableStatus(enabled)
.build(),
callMetadata
);
}
@Override
public Mono<Void> updateJobProcesses(String jobId, ServiceJobProcesses serviceJobProcesses, CallMetadata callMetadata) {
return stub.updateJobProcesses(
JobProcessesUpdate.newBuilder()
.setJobId(jobId)
.setServiceJobProcesses(GrpcJobManagementModelConverters.toGrpcServiceJobProcesses(serviceJobProcesses))
.build(),
callMetadata
);
}
@Override
public Mono<Void> updateJobDisruptionBudget(String jobId, DisruptionBudget disruptionBudget, CallMetadata callMetadata) {
return stub.updateJobDisruptionBudget(
JobDisruptionBudgetUpdate.newBuilder()
.setJobId(jobId)
.setDisruptionBudget(GrpcJobManagementModelConverters.toGrpcDisruptionBudget(disruptionBudget))
.build(),
callMetadata
);
}
@Override
public Mono<Job> findJob(String jobId) {
return stub.findJob(JobId.newBuilder().setId(jobId).build()).map(GrpcJobManagementModelConverters::toCoreJob);
}
@Override
public Mono<PageResult<Job<?>>> findJobs(Map<String, String> filteringCriteria, Page page) {
return (Mono) stub.findJobs(
JobQuery.newBuilder()
.setPage(GrpcJobQueryModelConverters.toGrpcPage(page))
.putAllFilteringCriteria(filteringCriteria)
.build()
).map(response -> PageResult.pageOf(
response.getItemsList().stream().map(GrpcJobManagementModelConverters::toCoreJob).collect(Collectors.toList()),
GrpcJobQueryModelConverters.toPagination(response.getPagination())
));
}
/**
* Single job subscription has a limitation that for tasks moved to another job there will be no notification.
*/
@Override
public Flux<JobManagerEvent<?>> observeJob(String jobId) {
return Flux.defer(() -> {
AtomicReference<Job> jobRef = new AtomicReference<>();
Map<String, Task> taskMap = new ConcurrentHashMap<>();
return stub.observeJob(JobId.newBuilder().setId(jobId).build())
.map(event -> {
switch (event.getNotificationCase()) {
case JOBUPDATE:
Job newJob = GrpcJobManagementModelConverters.toCoreJob(event.getJobUpdate().getJob());
Job oldJob = jobRef.get();
jobRef.set(newJob);
return oldJob == null
? JobUpdateEvent.newJob(newJob, JobManagerConstants.GRPC_REPLICATOR_CALL_METADATA)
: JobUpdateEvent.jobChange(newJob, oldJob, JobManagerConstants.GRPC_REPLICATOR_CALL_METADATA);
case TASKUPDATE:
Task newTask = GrpcJobManagementModelConverters.toCoreTask(jobRef.get(), event.getTaskUpdate().getTask());
Task oldTask = taskMap.get(newTask.getId());
taskMap.put(newTask.getId(), newTask);
if (event.getTaskUpdate().getMovedFromAnotherJob()) {
return TaskUpdateEvent.newTaskFromAnotherJob(jobRef.get(), newTask, JobManagerConstants.GRPC_REPLICATOR_CALL_METADATA);
}
return oldTask == null
? TaskUpdateEvent.newTask(jobRef.get(), newTask, JobManagerConstants.GRPC_REPLICATOR_CALL_METADATA)
: TaskUpdateEvent.taskChange(jobRef.get(), newTask, oldTask, JobManagerConstants.GRPC_REPLICATOR_CALL_METADATA);
case SNAPSHOTEND:
return JobManagerEvent.snapshotMarker();
case KEEPALIVERESPONSE:
return JobManagerEvent.keepAliveEvent(event.getKeepAliveResponse().getRequest().getTimestamp());
case NOTIFICATION_NOT_SET:
default:
return null;
}
})
.filter(Objects::nonNull);
});
}
@Override
public Flux<JobManagerEvent<?>> observeJobs(Map<String, String> filteringCriteria) {
return Flux.defer(() -> {
Map<String, Job> jobMap = new ConcurrentHashMap<>();
Map<String, Task> taskMap = new ConcurrentHashMap<>();
return connectObserveJobs(filteringCriteria)
.map(event -> {
switch (event.getNotificationCase()) {
case JOBUPDATE:
Job newJob = JobEventPropagationUtil.recordChannelLatency(
clientName,
GrpcJobManagementModelConverters.toCoreJob(event.getJobUpdate().getJob()),
event.getTimestamp(),
titusRuntime.getClock()
);
Job oldJob = jobMap.get(newJob.getId());
jobMap.put(newJob.getId(), newJob);
if (event.getJobUpdate().getArchived()) {
return JobUpdateEvent.jobArchived(newJob, JobManagerConstants.GRPC_REPLICATOR_CALL_METADATA);
}
return oldJob == null
? JobUpdateEvent.newJob(newJob, JobManagerConstants.GRPC_REPLICATOR_CALL_METADATA)
: JobUpdateEvent.jobChange(newJob, oldJob, JobManagerConstants.GRPC_REPLICATOR_CALL_METADATA);
case TASKUPDATE:
com.netflix.titus.grpc.protogen.Task grpcTask = event.getTaskUpdate().getTask();
Job job = jobMap.get(grpcTask.getJobId());
Task newTask = JobEventPropagationUtil.recordChannelLatency(
clientName,
GrpcJobManagementModelConverters.toCoreTask(job, grpcTask),
event.getTimestamp(),
titusRuntime.getClock()
);
Task oldTask = taskMap.get(newTask.getId());
taskMap.put(newTask.getId(), newTask);
// Check if task moved
if (isTaskMoved(newTask, oldTask)) {
return TaskUpdateEvent.newTaskFromAnotherJob(job, newTask, JobManagerConstants.GRPC_REPLICATOR_CALL_METADATA);
}
if (event.getTaskUpdate().getArchived()) {
return TaskUpdateEvent.taskArchived(job, newTask, JobManagerConstants.GRPC_REPLICATOR_CALL_METADATA);
}
return oldTask == null
? TaskUpdateEvent.newTask(job, newTask, JobManagerConstants.GRPC_REPLICATOR_CALL_METADATA)
: TaskUpdateEvent.taskChange(job, newTask, oldTask, JobManagerConstants.GRPC_REPLICATOR_CALL_METADATA);
case SNAPSHOTEND:
return JobManagerEvent.snapshotMarker();
case KEEPALIVERESPONSE:
return JobManagerEvent.keepAliveEvent(event.getKeepAliveResponse().getRequest().getTimestamp());
case NOTIFICATION_NOT_SET:
default:
return null;
}
})
.filter(Objects::nonNull);
});
}
protected Flux<JobChangeNotification> connectObserveJobs(Map<String, String> filteringCriteria) {
return stub.observeJobs(ObserveJobsQuery.newBuilder().putAllFilteringCriteria(filteringCriteria).build());
}
@Override
public Mono<Void> killJob(String jobId, CallMetadata callMetadata) {
return stub.killJob(JobId.newBuilder().setId(jobId).build(), callMetadata);
}
@Override
public Mono<Void> updateJobAttributes(String jobId, Map<String, String> attributes, CallMetadata callMetadata) {
return stub.updateJobAttributes(
JobAttributesUpdate.newBuilder()
.setJobId(jobId)
.putAllAttributes(attributes)
.build(),
callMetadata
);
}
@Override
public Mono<Void> deleteJobAttributes(String jobId, Set<String> attributeKeys, CallMetadata callMetadata) {
return stub.deleteJobAttributes(
JobAttributesDeleteRequest.newBuilder()
.setJobId(jobId)
.addAllKeys(attributeKeys)
.build(),
callMetadata
);
}
@Override
public Mono<Task> findTask(String taskId) {
return stub.findTask(TaskId.newBuilder().setId(taskId).build()).map(GrpcJobManagementModelConverters::toCoreTask);
}
@Override
public Mono<PageResult<Task>> findTasks(Map<String, String> filteringCriteria, Page page) {
return stub.findTasks(
TaskQuery.newBuilder()
.setPage(GrpcJobQueryModelConverters.toGrpcPage(page))
.putAllFilteringCriteria(filteringCriteria)
.build()
).map(response -> PageResult.pageOf(
response.getItemsList().stream().map(GrpcJobManagementModelConverters::toCoreTask).collect(Collectors.toList()),
GrpcJobQueryModelConverters.toPagination(response.getPagination())
));
}
@Override
public Mono<Void> killTask(String taskId, boolean shrink, CallMetadata callMetadata) {
return stub.killTask(TaskKillRequest.newBuilder().setTaskId(taskId).setShrink(shrink).build(), callMetadata);
}
@Override
public Mono<Void> updateTaskAttributes(String taskId, Map<String, String> attributes, CallMetadata callMetadata) {
return stub.updateTaskAttributes(
TaskAttributesUpdate.newBuilder()
.setTaskId(taskId)
.putAllAttributes(attributes)
.build(),
callMetadata
);
}
@Override
public Mono<Void> deleteTaskAttributes(String taskId, Set<String> attributeKeys, CallMetadata callMetadata) {
return stub.deleteTaskAttributes(
TaskAttributesDeleteRequest.newBuilder().setTaskId(taskId).addAllKeys(attributeKeys).build(),
callMetadata
);
}
@Override
public Mono<Void> moveTask(String sourceJobId, String targetJobId, String taskId, CallMetadata callMetadata) {
return stub.moveTask(
TaskMoveRequest.newBuilder()
.setSourceJobId(sourceJobId)
.setTargetJobId(targetJobId)
.setTaskId(taskId)
.build(),
callMetadata
);
}
static boolean isTaskMoved(Task newTask, Task oldTask) {
if (oldTask == null || oldTask.getJobId().equals(newTask.getJobId())) {
return false;
}
return newTask.getTaskContext().get(TaskAttributes.TASK_ATTRIBUTES_MOVED_FROM_JOB) != null;
}
}
| 1,192 |
0 | Create_ds/titus-control-plane/titus-client/src/main/java/com/netflix/titus/runtime/connector | Create_ds/titus-control-plane/titus-client/src/main/java/com/netflix/titus/runtime/connector/jobmanager/JobManagerConnectorComponent.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.runtime.connector.jobmanager;
import javax.inject.Named;
import com.netflix.titus.common.runtime.TitusRuntime;
import com.netflix.titus.grpc.protogen.JobManagementServiceGrpc;
import com.netflix.titus.common.util.grpc.reactor.GrpcToReactorClientFactory;
import io.grpc.Channel;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
@Configuration
public class JobManagerConnectorComponent {
public static final String JOB_MANAGER_CHANNEL = "jobManagerChannel";
@Bean
public JobManagementClient getJobManagementClient(ReactorJobManagementServiceStub stub, TitusRuntime titusRuntime) {
return new RemoteJobManagementClient("extClient", stub, titusRuntime);
}
@Bean
public ReactorJobManagementServiceStub getReactorJobManagementServiceStub(GrpcToReactorClientFactory factory,
@Named(JOB_MANAGER_CHANNEL) Channel channel) {
return factory.apply(JobManagementServiceGrpc.newStub(channel), ReactorJobManagementServiceStub.class, JobManagementServiceGrpc.getServiceDescriptor());
}
}
| 1,193 |
0 | Create_ds/titus-control-plane/titus-client/src/main/java/com/netflix/titus/runtime/connector | Create_ds/titus-control-plane/titus-client/src/main/java/com/netflix/titus/runtime/connector/jobmanager/JobManagerConnectorModule.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.runtime.connector.jobmanager;
import javax.inject.Named;
import com.google.inject.AbstractModule;
import com.google.inject.Provides;
import com.google.inject.Singleton;
import com.netflix.titus.api.jobmanager.service.ReadOnlyJobOperations;
import com.netflix.titus.common.runtime.TitusRuntime;
import com.netflix.titus.common.util.grpc.reactor.GrpcToReactorClientFactory;
import com.netflix.titus.grpc.protogen.JobManagementServiceGrpc;
import com.netflix.titus.runtime.connector.jobmanager.replicator.JobDataReplicatorProvider;
import com.netflix.titus.runtime.connector.jobmanager.snapshot.JobSnapshotFactories;
import com.netflix.titus.runtime.connector.jobmanager.snapshot.JobSnapshotFactory;
import io.grpc.Channel;
public class JobManagerConnectorModule extends AbstractModule {
public static final String MANAGED_CHANNEL_NAME = "ManagedChannel";
public static final String KEEP_ALIVE_ENABLED = "keepAliveEnabled";
private final String clientName;
public JobManagerConnectorModule(String clientName) {
this.clientName = clientName;
}
@Override
protected void configure() {
bind(JobDataReplicator.class).toProvider(JobDataReplicatorProvider.class);
bind(ReadOnlyJobOperations.class).to(CachedReadOnlyJobOperations.class);
}
@Provides
@Singleton
public JobManagementClient getJobManagementClient(ReactorJobManagementServiceStub stub, TitusRuntime titusRuntime) {
return new RemoteJobManagementClient(clientName, stub, titusRuntime);
}
@Provides
@Singleton
@Named(KEEP_ALIVE_ENABLED)
public JobManagementClient getJobManagementClient(JobConnectorConfiguration configuration,
JobManagementServiceGrpc.JobManagementServiceStub stub,
ReactorJobManagementServiceStub reactorStub,
TitusRuntime titusRuntime) {
return new RemoteJobManagementClientWithKeepAlive(clientName, configuration, stub, reactorStub, titusRuntime);
}
@Provides
@Singleton
public ReactorJobManagementServiceStub getReactorReactorJobManagementServiceStub(GrpcToReactorClientFactory factory,
@Named(MANAGED_CHANNEL_NAME) Channel channel) {
return factory.apply(JobManagementServiceGrpc.newStub(channel), ReactorJobManagementServiceStub.class, JobManagementServiceGrpc.getServiceDescriptor());
}
@Provides
@Singleton
public JobSnapshotFactory getJobSnapshotFactory(JobConnectorConfiguration configuration,
TitusRuntime titusRuntime) {
return JobSnapshotFactories.newDefault(false,
configuration.isKeepAliveReplicatedStreamEnabled(),
error -> titusRuntime.getCodeInvariants().inconsistent(error),
titusRuntime
);
}
}
| 1,194 |
0 | Create_ds/titus-control-plane/titus-client/src/main/java/com/netflix/titus/runtime/connector | Create_ds/titus-control-plane/titus-client/src/main/java/com/netflix/titus/runtime/connector/jobmanager/JobDataReplicator.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.runtime.connector.jobmanager;
import com.netflix.titus.api.jobmanager.model.job.event.JobManagerEvent;
import com.netflix.titus.runtime.connector.common.replicator.DataReplicator;
import com.netflix.titus.runtime.connector.jobmanager.snapshot.JobSnapshot;
public interface JobDataReplicator extends DataReplicator<JobSnapshot, JobManagerEvent<?>> {
}
| 1,195 |
0 | Create_ds/titus-control-plane/titus-client/src/main/java/com/netflix/titus/runtime/connector | Create_ds/titus-control-plane/titus-client/src/main/java/com/netflix/titus/runtime/connector/jobmanager/JobManagementDataReplicationComponent.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.runtime.connector.jobmanager;
import com.netflix.titus.api.jobmanager.service.ReadOnlyJobOperations;
import com.netflix.titus.common.environment.MyEnvironment;
import com.netflix.titus.common.runtime.TitusRuntime;
import com.netflix.titus.common.util.archaius2.Archaius2Ext;
import com.netflix.titus.runtime.connector.jobmanager.replicator.JobDataReplicatorProvider;
import com.netflix.titus.runtime.connector.jobmanager.snapshot.JobSnapshotFactories;
import com.netflix.titus.runtime.connector.jobmanager.snapshot.JobSnapshotFactory;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
@Configuration
public class JobManagementDataReplicationComponent {
@Bean
public JobConnectorConfiguration getJobDataReplicatorConfiguration(MyEnvironment environment) {
return Archaius2Ext.newConfiguration(JobConnectorConfiguration.class, environment);
}
@Bean
public JobSnapshotFactory getJobSnapshotFactory(TitusRuntime titusRuntime) {
return JobSnapshotFactories.newDefault(titusRuntime);
}
@Bean
public JobDataReplicator getJobDataReplicator(JobConnectorConfiguration configuration,
JobManagementClient jobManagementClient,
JobSnapshotFactory jobSnapshotFactory,
TitusRuntime titusRuntime) {
return new JobDataReplicatorProvider(configuration, jobManagementClient, jobSnapshotFactory, titusRuntime).get();
}
@Bean
public ReadOnlyJobOperations getReadOnlyJobOperations(JobDataReplicator replicator) {
return new CachedReadOnlyJobOperations(replicator);
}
}
| 1,196 |
0 | Create_ds/titus-control-plane/titus-client/src/main/java/com/netflix/titus/runtime/connector | Create_ds/titus-control-plane/titus-client/src/main/java/com/netflix/titus/runtime/connector/jobmanager/JobConnectorConfiguration.java | /*
* Copyright 2021 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.runtime.connector.jobmanager;
import com.netflix.archaius.api.annotations.Configuration;
import com.netflix.archaius.api.annotations.DefaultValue;
@Configuration(prefix = "titus.connector.jobService")
public interface JobConnectorConfiguration {
/**
* Set to true to enable connection timeout if the first event is not emitted in the configured amount of time.
*/
@DefaultValue("false")
boolean isConnectionTimeoutEnabled();
/**
* See {@link #isConnectionTimeoutEnabled()}.
*/
@DefaultValue("30000")
long getConnectionTimeoutMs();
/**
* Enable {@link JobDataReplicator} with the server side keep alive mechanism. Use only in TitusGateway.
*/
@DefaultValue("false")
boolean isKeepAliveReplicatedStreamEnabled();
/**
* Internal at which the keep alive requests are sent over the GRPC channel.
*/
@DefaultValue("100")
long getKeepAliveIntervalMs();
}
| 1,197 |
0 | Create_ds/titus-control-plane/titus-client/src/main/java/com/netflix/titus/runtime/connector | Create_ds/titus-control-plane/titus-client/src/main/java/com/netflix/titus/runtime/connector/jobmanager/JobManagementClient.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.runtime.connector.jobmanager;
import java.util.Map;
import java.util.Set;
import com.netflix.titus.api.model.callmetadata.CallMetadata;
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.JobDescriptor;
import com.netflix.titus.api.jobmanager.model.job.ServiceJobProcesses;
import com.netflix.titus.api.jobmanager.model.job.Task;
import com.netflix.titus.api.jobmanager.model.job.disruptionbudget.DisruptionBudget;
import com.netflix.titus.api.jobmanager.model.job.event.JobManagerEvent;
import com.netflix.titus.api.model.Page;
import com.netflix.titus.api.model.PageResult;
import reactor.core.publisher.Flux;
import reactor.core.publisher.Mono;
public interface JobManagementClient {
// ------------------------------------------------------------
// Job operations
Mono<String> createJob(JobDescriptor jobDescriptor, CallMetadata callMetadata);
Mono<Void> updateJobCapacity(String jobId, Capacity capacity, CallMetadata callMetadata);
Mono<Void> updateJobStatus(String jobId, boolean enabled, CallMetadata callMetadata);
Mono<Void> updateJobProcesses(String jobId, ServiceJobProcesses serviceJobProcesses, CallMetadata callMetadata);
Mono<Void> updateJobDisruptionBudget(String jobId, DisruptionBudget disruptionBudget, CallMetadata callMetadata);
Mono<Job> findJob(String jobId);
Mono<PageResult<Job<?>>> findJobs(Map<String, String> filteringCriteria, Page page);
Flux<JobManagerEvent<?>> observeJob(String jobId);
Flux<JobManagerEvent<?>> observeJobs(Map<String, String> filteringCriteria);
Mono<Void> killJob(String jobId, CallMetadata callMetadata);
Mono<Void> updateJobAttributes(String jobId, Map<String, String> attributes, CallMetadata callMetadata);
Mono<Void> deleteJobAttributes(String jobId, Set<String> attributeKeys, CallMetadata callMetadata);
// ------------------------------------------------------------
// Task operations
Mono<Task> findTask(String taskId);
Mono<PageResult<Task>> findTasks(Map<String, String> filteringCriteria, Page page);
Mono<Void> killTask(String taskId, boolean shrink, CallMetadata callMetadata);
Mono<Void> updateTaskAttributes(String taskId, Map<String, String> attributes, CallMetadata callMetadata);
Mono<Void> deleteTaskAttributes(String taskId, Set<String> attributeKeys, CallMetadata callMetadata);
Mono<Void> moveTask(String sourceJobId, String targetJobId, String taskId, CallMetadata callMetadata);
}
| 1,198 |
0 | Create_ds/titus-control-plane/titus-client/src/main/java/com/netflix/titus/runtime/connector | Create_ds/titus-control-plane/titus-client/src/main/java/com/netflix/titus/runtime/connector/jobmanager/JobManagementClientDelegate.java | /*
* Copyright 2021 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.runtime.connector.jobmanager;
import java.util.Map;
import java.util.Set;
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.JobDescriptor;
import com.netflix.titus.api.jobmanager.model.job.ServiceJobProcesses;
import com.netflix.titus.api.jobmanager.model.job.Task;
import com.netflix.titus.api.jobmanager.model.job.disruptionbudget.DisruptionBudget;
import com.netflix.titus.api.jobmanager.model.job.event.JobManagerEvent;
import com.netflix.titus.api.model.Page;
import com.netflix.titus.api.model.PageResult;
import com.netflix.titus.api.model.callmetadata.CallMetadata;
import reactor.core.publisher.Flux;
import reactor.core.publisher.Mono;
public class JobManagementClientDelegate implements JobManagementClient {
private final JobManagementClient delegate;
public JobManagementClientDelegate(JobManagementClient delegate) {
this.delegate = delegate;
}
@Override
public Mono<String> createJob(JobDescriptor jobDescriptor, CallMetadata callMetadata) {
return delegate.createJob(jobDescriptor, callMetadata);
}
@Override
public Mono<Void> updateJobCapacity(String jobId, Capacity capacity, CallMetadata callMetadata) {
return delegate.updateJobCapacity(jobId, capacity, callMetadata);
}
@Override
public Mono<Void> updateJobStatus(String jobId, boolean enabled, CallMetadata callMetadata) {
return delegate.updateJobStatus(jobId, enabled, callMetadata);
}
@Override
public Mono<Void> updateJobProcesses(String jobId, ServiceJobProcesses serviceJobProcesses, CallMetadata callMetadata) {
return delegate.updateJobProcesses(jobId, serviceJobProcesses, callMetadata);
}
@Override
public Mono<Void> updateJobDisruptionBudget(String jobId, DisruptionBudget disruptionBudget, CallMetadata callMetadata) {
return delegate.updateJobDisruptionBudget(jobId, disruptionBudget, callMetadata);
}
@Override
public Mono<Job> findJob(String jobId) {
return delegate.findJob(jobId);
}
@Override
public Mono<PageResult<Job<?>>> findJobs(Map<String, String> filteringCriteria, Page page) {
return delegate.findJobs(filteringCriteria, page);
}
@Override
public Flux<JobManagerEvent<?>> observeJob(String jobId) {
return delegate.observeJob(jobId);
}
@Override
public Flux<JobManagerEvent<?>> observeJobs(Map<String, String> filteringCriteria) {
return delegate.observeJobs(filteringCriteria);
}
@Override
public Mono<Void> killJob(String jobId, CallMetadata callMetadata) {
return delegate.killJob(jobId, callMetadata);
}
@Override
public Mono<Void> updateJobAttributes(String jobId, Map<String, String> attributes, CallMetadata callMetadata) {
return delegate.updateJobAttributes(jobId, attributes, callMetadata);
}
@Override
public Mono<Void> deleteJobAttributes(String jobId, Set<String> attributeKeys, CallMetadata callMetadata) {
return delegate.deleteJobAttributes(jobId, attributeKeys, callMetadata);
}
@Override
public Mono<Task> findTask(String taskId) {
return delegate.findTask(taskId);
}
@Override
public Mono<PageResult<Task>> findTasks(Map<String, String> filteringCriteria, Page page) {
return delegate.findTasks(filteringCriteria, page);
}
@Override
public Mono<Void> killTask(String taskId, boolean shrink, CallMetadata callMetadata) {
return delegate.killTask(taskId, shrink, callMetadata);
}
@Override
public Mono<Void> updateTaskAttributes(String taskId, Map<String, String> attributes, CallMetadata callMetadata) {
return delegate.updateTaskAttributes(taskId, attributes, callMetadata);
}
@Override
public Mono<Void> deleteTaskAttributes(String taskId, Set<String> attributeKeys, CallMetadata callMetadata) {
return delegate.deleteTaskAttributes(taskId, attributeKeys, callMetadata);
}
@Override
public Mono<Void> moveTask(String sourceJobId, String targetJobId, String taskId, CallMetadata callMetadata) {
return delegate.moveTask(sourceJobId, targetJobId, taskId, callMetadata);
}
}
| 1,199 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.