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-server-master/src/test/java/com/netflix/titus/master/kubernetes/pod | Create_ds/titus-control-plane/titus-server-master/src/test/java/com/netflix/titus/master/kubernetes/pod/resourcepool/FarzonePodResourcePoolResolverTest.java | /*
* Copyright 2020 Netflix, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.netflix.titus.master.kubernetes.pod.resourcepool;
import java.util.Collections;
import java.util.List;
import com.netflix.titus.api.jobmanager.JobConstraints;
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.ext.BatchJobExt;
import com.netflix.titus.common.util.archaius2.Archaius2Ext;
import com.netflix.titus.master.kubernetes.pod.KubePodConfiguration;
import com.netflix.titus.testkit.model.job.JobGenerator;
import org.junit.Test;
import static org.assertj.core.api.Assertions.assertThat;
public class FarzonePodResourcePoolResolverTest {
private static final String FARZONE_ID = "myFarzone";
private final KubePodConfiguration configuration = Archaius2Ext.newConfiguration(KubePodConfiguration.class,
"titusMaster.kubernetes.pod.farzones", FARZONE_ID
);
private final FarzonePodResourcePoolResolver resolver = new FarzonePodResourcePoolResolver(configuration);
private final Task task = JobGenerator.oneBatchTask();
@Test
public void testFarzoneJobAssignment() {
List<ResourcePoolAssignment> result = resolver.resolve(newJob(FARZONE_ID), task);
assertThat(result).hasSize(1);
assertThat(result.get(0).getResourcePoolName()).isEqualTo(PodResourcePoolResolvers.RESOURCE_POOL_ELASTIC_FARZONE_PREFIX + FARZONE_ID);
}
@Test
public void testNoneFarzoneJobAssignment() {
List<ResourcePoolAssignment> result = resolver.resolve(newJob("regularZone"), task);
assertThat(result).hasSize(0);
}
private Job newJob(String zoneId) {
Job<BatchJobExt> job = JobGenerator.oneBatchJob();
job = job.toBuilder()
.withJobDescriptor(job.getJobDescriptor().toBuilder()
.withContainer(job.getJobDescriptor().getContainer().toBuilder()
.withHardConstraints(Collections.singletonMap(JobConstraints.AVAILABILITY_ZONE, zoneId))
.build()
)
.build()
)
.build();
return job;
}
} | 0 |
0 | Create_ds/titus-control-plane/titus-server-master/src/test/java/com/netflix/titus/master/kubernetes/pod | Create_ds/titus-control-plane/titus-server-master/src/test/java/com/netflix/titus/master/kubernetes/pod/resourcepool/ExplicitJobPodResourcePoolResolverTest.java | /*
* Copyright 2020 Netflix, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.netflix.titus.master.kubernetes.pod.resourcepool;
import java.util.Collections;
import java.util.List;
import com.netflix.titus.api.jobmanager.JobAttributes;
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.ext.BatchJobExt;
import com.netflix.titus.testkit.model.job.JobGenerator;
import org.junit.Test;
import static org.assertj.core.api.Assertions.assertThat;
public class ExplicitJobPodResourcePoolResolverTest {
private final ExplicitJobPodResourcePoolResolver resolver = new ExplicitJobPodResourcePoolResolver();
private final Task task = JobGenerator.oneBatchTask();
@Test
public void testAssignment() {
List<ResourcePoolAssignment> result = resolver.resolve(newJob("myResourcePool"), task);
assertThat(result).hasSize(1);
assertThat(result.get(0).getResourcePoolName()).isEqualTo("myResourcePool");
}
private Job newJob(String resourcePool) {
Job<BatchJobExt> job = JobGenerator.oneBatchJob();
job = job.toBuilder()
.withJobDescriptor(job.getJobDescriptor().toBuilder()
.withAttributes(Collections.singletonMap(
JobAttributes.JOB_PARAMETER_RESOURCE_POOLS,
resourcePool
))
.build()
)
.build();
return job;
}
} | 1 |
0 | Create_ds/titus-control-plane/titus-server-master/src/test/java/com/netflix/titus/master/kubernetes/pod | Create_ds/titus-control-plane/titus-server-master/src/test/java/com/netflix/titus/master/kubernetes/pod/resourcepool/GpuPodResourcePoolResolverTest.java | /*
* Copyright 2020 Netflix, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.netflix.titus.master.kubernetes.pod.resourcepool;
import java.util.List;
import com.netflix.archaius.config.DefaultSettableConfig;
import com.netflix.titus.api.jobmanager.model.job.ContainerResources;
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.ext.BatchJobExt;
import com.netflix.titus.api.model.ApplicationSLA;
import com.netflix.titus.api.model.Tier;
import com.netflix.titus.common.util.archaius2.Archaius2Ext;
import com.netflix.titus.master.kubernetes.pod.KubePodConfiguration;
import com.netflix.titus.master.service.management.ApplicationSlaManagementService;
import com.netflix.titus.testkit.model.job.JobGenerator;
import org.junit.Before;
import org.junit.Test;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
public class GpuPodResourcePoolResolverTest {
private final DefaultSettableConfig config = new DefaultSettableConfig();
private final KubePodConfiguration configuration = Archaius2Ext.newConfiguration(KubePodConfiguration.class, config);
private final ApplicationSlaManagementService capacityGroupService = mock(ApplicationSlaManagementService.class);
private GpuPodResourcePoolResolver resolver;
private final Task task = JobGenerator.oneBatchTask();
@Before
public void setUp() {
config.setProperty("titusMaster.kubernetes.pod.gpuResourcePoolNames", "gpu1,gpu2");
resolver = new GpuPodResourcePoolResolver(configuration, capacityGroupService);
}
@Test
public void testNonGpuJob() {
assertThat(resolver.resolve(newJob(0, null), task)).isEmpty();
}
@Test
public void testGpuJob() {
config.setProperty("titusMaster.kubernetes.pod.gpuResourcePoolNames", "gpu1,gpu2");
List<ResourcePoolAssignment> result = resolver.resolve(newJob(1, null), task);
assertThat(result).hasSize(2);
assertThat(result.get(0).getResourcePoolName()).isEqualTo("gpu1");
assertThat(result.get(1).getResourcePoolName()).isEqualTo("gpu2");
}
private Job<?> newJob(int gpuCount, String capacityGroup) {
Job<BatchJobExt> job = JobGenerator.oneBatchJob();
return job.toBuilder().withJobDescriptor(
job.getJobDescriptor().toBuilder()
.withCapacityGroup(capacityGroup)
.withContainer(job.getJobDescriptor().getContainer().toBuilder()
.withContainerResources(
ContainerResources.newBuilder().withGpu(gpuCount).build()
)
.build()
)
.build()
).build();
}
@Test
// Validate that when the job is using a Capacity Group with a GPU resource pool, we resolve to
// exactly that one resource pool
public void testGpuJobWithGpuCapacityGroup() {
when(capacityGroupService.getApplicationSLA("gpu1_capacity_group")).thenReturn(
ApplicationSLA.newBuilder()
.withAppName("gpu1_capacity_group")
.withTier(Tier.Flex)
.withResourcePool("gpu1")
.build()
);
Job<?> job = newJob(1, "gpu1_capacity_group");
List<ResourcePoolAssignment> result = resolver.resolve(job, task);
assertThat(result).hasSize(1);
assertThat(result.get(0).getResourcePoolName()).isEqualTo("gpu1");
}
@Test
// Validate despite specifying a Capacity Group with a non-GPU resource pool, we get the resolution
// to a pre-configured GPU resource pools list
public void testGpuJobWithElasticCapacityGroup() {
when(capacityGroupService.getApplicationSLA("cg_with_elastic_resourcepool")).thenReturn(
ApplicationSLA.newBuilder()
.withAppName("cg_with_elastic_resourcepool")
.withTier(Tier.Flex)
.withResourcePool("elastic")
.build()
);
Job<?> job = newJob(1, "cg_with_elastic_resourcepool");
List<ResourcePoolAssignment> result = resolver.resolve(job, task);
assertThat(result).hasSize(2);
assertThat(result.get(0).getResourcePoolName()).isEqualTo("gpu1");
assertThat(result.get(1).getResourcePoolName()).isEqualTo("gpu2");
}
} | 2 |
0 | Create_ds/titus-control-plane/titus-server-master/src/test/java/com/netflix/titus/master/kubernetes/pod | Create_ds/titus-control-plane/titus-server-master/src/test/java/com/netflix/titus/master/kubernetes/pod/resourcepool/PodResourcePoolResolverChainTest.java | /*
* Copyright 2020 Netflix, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.netflix.titus.master.kubernetes.pod.resourcepool;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import com.netflix.titus.common.runtime.TitusRuntimes;
import com.netflix.titus.testkit.model.job.JobGenerator;
import org.junit.Test;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
public class PodResourcePoolResolverChainTest {
private final PodResourcePoolResolver delegate1 = mock(PodResourcePoolResolver.class);
private final PodResourcePoolResolver delegate2 = mock(PodResourcePoolResolver.class);
private final PodResourcePoolResolverChain resolver = new PodResourcePoolResolverChain(Arrays.asList(delegate1, delegate2), TitusRuntimes.internal());
@Test
public void testChainedExecution() {
when(delegate1.resolve(any(), any())).thenReturn(Collections.emptyList());
when(delegate2.resolve(any(), any())).thenReturn(Collections.singletonList(
ResourcePoolAssignment.newBuilder().withResourcePoolName("elastic").withRule("rule").build())
);
List<ResourcePoolAssignment> result = resolver.resolve(JobGenerator.oneBatchJob(), JobGenerator.oneBatchTask());
assertThat(result).hasSize(1);
assertThat(result.get(0).getResourcePoolName()).isEqualTo("elastic");
}
} | 3 |
0 | Create_ds/titus-control-plane/titus-server-master/src/test/java/com/netflix/titus/master/kubernetes/pod | Create_ds/titus-control-plane/titus-server-master/src/test/java/com/netflix/titus/master/kubernetes/pod/resourcepool/MixedSchedulerResourcePoolTest.java | /*
* Copyright 2020 Netflix, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.netflix.titus.master.kubernetes.pod.resourcepool;
import java.util.List;
import com.netflix.archaius.config.DefaultSettableConfig;
import com.netflix.titus.api.jobmanager.model.job.ContainerResources;
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.common.util.archaius2.Archaius2Ext;
import com.netflix.titus.master.kubernetes.pod.KubePodConfiguration;
import com.netflix.titus.testkit.model.job.JobGenerator;
import org.junit.Before;
import org.junit.Test;
import static com.netflix.titus.testkit.model.job.JobDescriptorGenerator.oneTaskBatchJobDescriptor;
import static org.assertj.core.api.Assertions.assertThat;
public class MixedSchedulerResourcePoolTest {
private final Task task = JobGenerator.oneBatchTask();
private final DefaultSettableConfig config = new DefaultSettableConfig();
private final KubePodConfiguration configuration = Archaius2Ext.newConfiguration(KubePodConfiguration.class, config);
private MixedSchedulerResourcePoolResolver resolver;
@Before
public void setUp() throws Exception {
config.setProperty("titusMaster.kubernetes.pod.mixedSchedulingEnabled", "true");
resolver = new MixedSchedulerResourcePoolResolver(configuration);
}
@Test
public void testCPUHeavyJobGetsBothPoolsAndPrefersReserved() {
List<ResourcePoolAssignment> result = resolver.resolve(newCPUJob(), task);
assertThat(result).hasSize(2);
assertThat(result.get(0).getResourcePoolName()).isEqualTo(PodResourcePoolResolvers.RESOURCE_POOL_ELASTIC);
assertThat(result.get(0).preferred()).isFalse();
assertThat(result.get(1).getResourcePoolName()).isEqualTo(PodResourcePoolResolvers.RESOURCE_POOL_RESERVED);
assertThat(result.get(1).preferred()).isTrue();
}
@Test
public void testRamHeavyJobGetsBothPoolsAndPrefersElastic() {
List<ResourcePoolAssignment> result = resolver.resolve(newRamJob(), task);
assertThat(result).hasSize(2);
assertThat(result.get(0).getResourcePoolName()).isEqualTo(PodResourcePoolResolvers.RESOURCE_POOL_ELASTIC);
assertThat(result.get(0).preferred()).isTrue();
assertThat(result.get(1).getResourcePoolName()).isEqualTo(PodResourcePoolResolvers.RESOURCE_POOL_RESERVED);
assertThat(result.get(1).preferred()).isFalse();
}
private Job newCPUJob() {
JobDescriptor<BatchJobExt> j = oneTaskBatchJobDescriptor().but(jd -> jd.getContainer().toBuilder()
.withContainerResources(ContainerResources.newBuilder()
.withCpu(100)
.withMemoryMB(1_000)
.build()
)
.build()
);
return JobGenerator.oneBatchJob().toBuilder()
.withJobDescriptor(j).build();
}
private Job newRamJob() {
JobDescriptor<BatchJobExt> j = oneTaskBatchJobDescriptor().but(jd -> jd.getContainer().toBuilder()
.withContainerResources(ContainerResources.newBuilder()
.withCpu(1)
.withMemoryMB(472_000)
.build()
)
.build()
);
return JobGenerator.oneBatchJob().toBuilder()
.withJobDescriptor(j).build();
}
} | 4 |
0 | Create_ds/titus-control-plane/titus-server-master/src/test/java/com/netflix/titus/master/kubernetes/pod | Create_ds/titus-control-plane/titus-server-master/src/test/java/com/netflix/titus/master/kubernetes/pod/resourcepool/CapacityGroupPodResourcePoolResolverTest.java | /*
* Copyright 2020 Netflix, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.netflix.titus.master.kubernetes.pod.resourcepool;
import java.util.List;
import java.util.concurrent.TimeUnit;
import com.netflix.archaius.config.DefaultSettableConfig;
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.ext.BatchJobExt;
import com.netflix.titus.api.model.ApplicationSLA;
import com.netflix.titus.api.model.Tier;
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.time.TestClock;
import com.netflix.titus.master.kubernetes.pod.KubePodConfiguration;
import com.netflix.titus.master.service.management.ApplicationSlaManagementService;
import com.netflix.titus.testkit.model.job.JobGenerator;
import org.junit.Before;
import org.junit.Test;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
public class CapacityGroupPodResourcePoolResolverTest {
private final TitusRuntime titusRuntime = TitusRuntimes.test();
private final TestClock clock = (TestClock) titusRuntime.getClock();
private final DefaultSettableConfig config = new DefaultSettableConfig();
private final KubePodConfiguration configuration = Archaius2Ext.newConfiguration(KubePodConfiguration.class, config);
private final ApplicationSlaManagementService capacityGroupService = mock(ApplicationSlaManagementService.class);
private final CapacityGroupPodResourcePoolResolver resolver = new CapacityGroupPodResourcePoolResolver(
configuration,
config,
capacityGroupService,
titusRuntime
);
private final Task task = JobGenerator.oneBatchTask();
@Before
public void setUp() throws Exception {
when(capacityGroupService.getApplicationSLA("myFlex")).thenReturn(ApplicationSLA.newBuilder()
.withAppName("myFlex")
.withTier(Tier.Flex)
.build()
);
when(capacityGroupService.getApplicationSLA("myCritical")).thenReturn(ApplicationSLA.newBuilder()
.withAppName("myCritical")
.withTier(Tier.Critical)
.build()
);
config.setProperty("elastic", ".*Flex");
config.setProperty("reserved", ".*Critical");
clock.advanceTime(1, TimeUnit.HOURS);
}
@Test
public void testBasic() {
// Map to elastic
List<ResourcePoolAssignment> result = resolver.resolve(newJob("myFlex"), task);
assertThat(result).hasSize(1);
assertThat(result.get(0).getResourcePoolName()).isEqualTo("elastic");
// Map to reserved
result = resolver.resolve(newJob("myCritical"), task);
assertThat(result).hasSize(1);
assertThat(result.get(0).getResourcePoolName()).isEqualTo("reserved");
}
@Test
public void testUpdate() {
// Entries are ordered so this one gets ahead
config.setProperty("anElastic", ".*Flex");
clock.advanceTime(1, TimeUnit.HOURS);
List<ResourcePoolAssignment> result = resolver.resolve(newJob("myFlex"), task);
assertThat(result).hasSize(1);
assertThat(result.get(0).getResourcePoolName()).isEqualTo("anElastic");
}
private Job newJob(String capacityGroup) {
Job<BatchJobExt> job = JobGenerator.oneBatchJob();
job = job.toBuilder()
.withJobDescriptor(job.getJobDescriptor().toBuilder()
.withCapacityGroup(capacityGroup)
.build()
)
.build();
return job;
}
} | 5 |
0 | Create_ds/titus-control-plane/titus-server-master/src/test/java/com/netflix/titus/master/kubernetes | Create_ds/titus-control-plane/titus-server-master/src/test/java/com/netflix/titus/master/kubernetes/controller/PodOnUnknownNodeGcControllerTest.java | /*
* Copyright 2020 Netflix, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.netflix.titus.master.kubernetes.controller;
import java.util.Collections;
import com.netflix.titus.common.framework.scheduler.LocalScheduler;
import com.netflix.titus.common.runtime.TitusRuntime;
import com.netflix.titus.common.runtime.TitusRuntimes;
import com.netflix.titus.common.util.limiter.tokenbucket.FixedIntervalTokenBucketConfiguration;
import com.netflix.titus.common.util.time.TestClock;
import com.netflix.titus.common.util.time.internal.DefaultTestClock;
import com.netflix.titus.runtime.connector.kubernetes.std.StdKubeApiFacade;
import io.kubernetes.client.openapi.models.V1ObjectMeta;
import io.kubernetes.client.openapi.models.V1Pod;
import io.kubernetes.client.openapi.models.V1PodSpec;
import org.assertj.core.api.Assertions;
import org.junit.jupiter.api.Test;
import static org.mockito.Mockito.mock;
public class PodOnUnknownNodeGcControllerTest {
private static final String NODE_NAME = "node-name";
private static final String POD_NAME = "pod-name";
private static final TestClock clock = new DefaultTestClock();
private final TitusRuntime titusRuntime = TitusRuntimes.test(clock);
private final FixedIntervalTokenBucketConfiguration tokenBucketConfiguration = mock(FixedIntervalTokenBucketConfiguration.class);
private final ControllerConfiguration controllerConfiguration = mock(ControllerConfiguration.class);
private final StdKubeApiFacade kubeApiFacade = mock(StdKubeApiFacade.class);
private final LocalScheduler scheduler = mock(LocalScheduler.class);
private final PodOnUnknownNodeGcController podGcController = new PodOnUnknownNodeGcController(
titusRuntime,
scheduler,
tokenBucketConfiguration,
controllerConfiguration,
kubeApiFacade
);
/**
* The pod has a node name for a node that is not known and should return true.
*/
@Test
void podIsOnUnknownNode() {
V1Pod pod = new V1Pod()
.metadata(new V1ObjectMeta().name(POD_NAME))
.spec(new V1PodSpec().nodeName(NODE_NAME))
.status(null);
Assertions.assertThat(podGcController.isPodOnUnknownNode(pod, Collections.emptySet())).isTrue();
}
/**
* The pod has a node name for a node that is known and should return false.
*/
@Test
void podIsOnKnownNode() {
V1Pod pod = new V1Pod()
.metadata(new V1ObjectMeta().name(POD_NAME))
.spec(new V1PodSpec().nodeName(NODE_NAME))
.status(null);
Assertions.assertThat(podGcController.isPodOnUnknownNode(pod, Collections.singleton(NODE_NAME))).isFalse();
}
} | 6 |
0 | Create_ds/titus-control-plane/titus-server-master/src/test/java/com/netflix/titus/master/kubernetes | Create_ds/titus-control-plane/titus-server-master/src/test/java/com/netflix/titus/master/kubernetes/controller/PersistentVolumeUnassociatedGcControllerTest.java | /*
* Copyright 2020 Netflix, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.netflix.titus.master.kubernetes.controller;
import java.time.Duration;
import java.util.Collections;
import java.util.Set;
import com.netflix.titus.api.jobmanager.service.V3JobOperations;
import com.netflix.titus.common.framework.scheduler.LocalScheduler;
import com.netflix.titus.common.runtime.TitusRuntime;
import com.netflix.titus.common.runtime.TitusRuntimes;
import com.netflix.titus.common.util.limiter.tokenbucket.FixedIntervalTokenBucketConfiguration;
import com.netflix.titus.common.util.time.TestClock;
import com.netflix.titus.common.util.time.internal.DefaultTestClock;
import com.netflix.titus.runtime.connector.kubernetes.std.StdKubeApiFacade;
import io.kubernetes.client.openapi.apis.CoreV1Api;
import io.kubernetes.client.openapi.models.V1ObjectMeta;
import io.kubernetes.client.openapi.models.V1PersistentVolume;
import io.kubernetes.client.openapi.models.V1PersistentVolumeStatus;
import org.junit.Before;
import org.junit.Test;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
public class PersistentVolumeUnassociatedGcControllerTest {
private static final String PERSISTENT_VOLUME_NAME = "vol-1";
private static final TestClock clock = new DefaultTestClock();
private static final long PERSISTENT_VOLUME_GRACE_PERIOD_MS = 1000L;
private final TitusRuntime titusRuntime = TitusRuntimes.test(clock);
private final FixedIntervalTokenBucketConfiguration tokenBucketConfiguration = mock(FixedIntervalTokenBucketConfiguration.class);
private final ControllerConfiguration controllerConfiguration = mock(ControllerConfiguration.class);
private final StdKubeApiFacade kubeApiFacade = mock(StdKubeApiFacade.class);
private final LocalScheduler scheduler = mock(LocalScheduler.class);
private final KubeControllerConfiguration kubeControllerConfiguration = mock(KubeControllerConfiguration.class);
private final V3JobOperations v3JobOperations = mock(V3JobOperations.class);
private final CoreV1Api coreV1Api = mock(CoreV1Api.class);
private final PersistentVolumeUnassociatedGcController pvGcController = new PersistentVolumeUnassociatedGcController(
titusRuntime,
scheduler,
tokenBucketConfiguration,
controllerConfiguration,
kubeApiFacade,
kubeControllerConfiguration,
v3JobOperations
);
@Before
public void setUp() {
when(kubeControllerConfiguration.getPersistentVolumeUnassociatedGracePeriodMs()).thenReturn(PERSISTENT_VOLUME_GRACE_PERIOD_MS);
}
/**
* Tests that a persistent volume that is not associated with a job for enough time is GC'd.
*/
@Test
public void testPvIsUnassociated() {
V1PersistentVolume v1PersistentVolume = new V1PersistentVolume()
.metadata(new V1ObjectMeta()
.name(PERSISTENT_VOLUME_NAME))
.status(new V1PersistentVolumeStatus()
.phase("Available"));
Set<String> currentEbsVolume = Collections.singleton("vol-2");
// Initially checking this volume should mark it but not consider it unassociated
assertThat(pvGcController.isPersistentVolumeUnassociated(v1PersistentVolume, currentEbsVolume)).isFalse();
// Move time forward and expect the volume to be considered unassociated
clock.advanceTime(Duration.ofMillis(PERSISTENT_VOLUME_GRACE_PERIOD_MS + 1));
assertThat(pvGcController.isPersistentVolumeUnassociated(v1PersistentVolume, currentEbsVolume)).isTrue();
}
/**
* Tests that a persistent volume that is associated with a current job is not GC'd.
*/
@Test
public void testPvIsAssociated() {
V1PersistentVolume v1PersistentVolume = new V1PersistentVolume()
.metadata(new V1ObjectMeta()
.name(PERSISTENT_VOLUME_NAME))
.status(new V1PersistentVolumeStatus()
.phase("Available"));
Set<String> currentEbsVolume = Collections.singleton(PERSISTENT_VOLUME_NAME);
// Initially checking this volume should not mark it
assertThat(pvGcController.isPersistentVolumeUnassociated(v1PersistentVolume, currentEbsVolume)).isFalse();
// Move time forward and expect the volume to be GC'd
clock.advanceTime(Duration.ofMillis(PERSISTENT_VOLUME_GRACE_PERIOD_MS + 1));
assertThat(pvGcController.isPersistentVolumeUnassociated(v1PersistentVolume, currentEbsVolume)).isFalse();
}
}
| 7 |
0 | Create_ds/titus-control-plane/titus-server-master/src/test/java/com/netflix/titus/master/kubernetes | Create_ds/titus-control-plane/titus-server-master/src/test/java/com/netflix/titus/master/kubernetes/controller/PodUnknownGcControllerTest.java | /*
* Copyright 2020 Netflix, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.netflix.titus.master.kubernetes.controller;
import java.time.Duration;
import java.util.Collections;
import java.util.Map;
import com.netflix.titus.api.jobmanager.model.job.Task;
import com.netflix.titus.api.jobmanager.service.V3JobOperations;
import com.netflix.titus.common.framework.scheduler.LocalScheduler;
import com.netflix.titus.common.runtime.TitusRuntime;
import com.netflix.titus.common.runtime.TitusRuntimes;
import com.netflix.titus.common.util.DateTimeExt;
import com.netflix.titus.common.util.limiter.tokenbucket.FixedIntervalTokenBucketConfiguration;
import com.netflix.titus.common.util.time.TestClock;
import com.netflix.titus.common.util.time.internal.DefaultTestClock;
import com.netflix.titus.runtime.connector.kubernetes.std.StdKubeApiFacade;
import io.kubernetes.client.openapi.models.V1ObjectMeta;
import io.kubernetes.client.openapi.models.V1Pod;
import io.kubernetes.client.openapi.models.V1PodStatus;
import org.assertj.core.api.Assertions;
import org.junit.jupiter.api.Test;
import static com.netflix.titus.runtime.kubernetes.KubeConstants.RUNNING;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
public class PodUnknownGcControllerTest {
private static final String POD_NAME = "pod-name";
private static final TestClock clock = new DefaultTestClock();
private static final long POD_UNKNOWN_GRACE_PERIOD = 1000L;
private final TitusRuntime titusRuntime = TitusRuntimes.test(clock);
private final FixedIntervalTokenBucketConfiguration tokenBucketConfiguration = mock(FixedIntervalTokenBucketConfiguration.class);
private final ControllerConfiguration controllerConfiguration = mock(ControllerConfiguration.class);
private final StdKubeApiFacade kubeApiFacade = mock(StdKubeApiFacade.class);
private final LocalScheduler scheduler = mock(LocalScheduler.class);
private final KubeControllerConfiguration kubeControllerConfiguration = mock(KubeControllerConfiguration.class);
private final V3JobOperations v3JobOperations = mock(V3JobOperations.class);
private final PodUnknownGcController podGcController = new PodUnknownGcController(
titusRuntime,
scheduler,
tokenBucketConfiguration,
controllerConfiguration,
kubeApiFacade,
kubeControllerConfiguration,
v3JobOperations
);
/**
* The pod is known to job management and should not be GC'ed
*/
@Test
void podIsKnownToJobManagement() {
when(kubeControllerConfiguration.getPodUnknownGracePeriodMs()).thenReturn(POD_UNKNOWN_GRACE_PERIOD);
V1Pod pod = new V1Pod()
.metadata(new V1ObjectMeta().name(POD_NAME).creationTimestamp(DateTimeExt.fromMillis(clock.wallTime())))
.status(new V1PodStatus().phase(RUNNING));
clock.advanceTime(Duration.ofMillis(POD_UNKNOWN_GRACE_PERIOD + 1));
Map<String, Task> currentTasks = Collections.singletonMap(POD_NAME, mock(Task.class));
Assertions.assertThat(podGcController.isPodUnknownToJobManagement(pod, currentTasks)).isFalse();
}
/**
* The pod is unknown to job management and should be GC'ed
*/
@Test
void podIsUnknownToJobManagement() {
when(kubeControllerConfiguration.getPodUnknownGracePeriodMs()).thenReturn(POD_UNKNOWN_GRACE_PERIOD);
V1Pod pod = new V1Pod()
.metadata(new V1ObjectMeta().name(POD_NAME).creationTimestamp(DateTimeExt.fromMillis(clock.wallTime())))
.status(new V1PodStatus().phase(RUNNING));
clock.advanceTime(Duration.ofMillis(POD_UNKNOWN_GRACE_PERIOD + 1));
Map<String, Task> currentTasks = Collections.singletonMap("", mock(Task.class));
Assertions.assertThat(podGcController.isPodUnknownToJobManagement(pod, currentTasks)).isTrue();
}
} | 8 |
0 | Create_ds/titus-control-plane/titus-server-master/src/test/java/com/netflix/titus/master/kubernetes | Create_ds/titus-control-plane/titus-server-master/src/test/java/com/netflix/titus/master/kubernetes/controller/PersistentVolumeReclaimControllerTest.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.master.kubernetes.controller;
import com.netflix.titus.common.framework.scheduler.LocalScheduler;
import com.netflix.titus.common.runtime.TitusRuntime;
import com.netflix.titus.common.runtime.TitusRuntimes;
import com.netflix.titus.common.util.limiter.tokenbucket.FixedIntervalTokenBucketConfiguration;
import com.netflix.titus.runtime.connector.kubernetes.std.StdKubeApiFacade;
import io.kubernetes.client.openapi.models.V1ObjectMeta;
import io.kubernetes.client.openapi.models.V1PersistentVolume;
import io.kubernetes.client.openapi.models.V1PersistentVolumeStatus;
import org.junit.Test;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.Mockito.mock;
public class PersistentVolumeReclaimControllerTest {
private static final String PERSISTENT_VOLUME_NAME = "vol-1";
private final TitusRuntime titusRuntime = TitusRuntimes.test();
private final FixedIntervalTokenBucketConfiguration tokenBucketConfiguration = mock(FixedIntervalTokenBucketConfiguration.class);
private final ControllerConfiguration controllerConfiguration = mock(ControllerConfiguration.class);
private final StdKubeApiFacade kubeApiFacade = mock(StdKubeApiFacade.class);
private final LocalScheduler scheduler = mock(LocalScheduler.class);
private final PersistentVolumeReclaimController pvcReclaimController = new PersistentVolumeReclaimController(
titusRuntime,
scheduler,
tokenBucketConfiguration,
controllerConfiguration,
kubeApiFacade
);
/**
* Tests that a bound VPC is not selected for reclamation.
*/
@Test
public void testBoundPvcIsNotReclaimed() {
V1PersistentVolume v1PersistentVolume = new V1PersistentVolume()
.metadata(new V1ObjectMeta()
.name(PERSISTENT_VOLUME_NAME))
.status(new V1PersistentVolumeStatus()
.phase("Bound"));
assertThat(pvcReclaimController.isPvReleased(v1PersistentVolume)).isFalse();
}
/**
* Tests that a released PVC is reclaimed.
*/
@Test
public void testReleasedPvcIsReclaimed() {
V1PersistentVolume v1PersistentVolume = new V1PersistentVolume()
.metadata(new V1ObjectMeta()
.name(PERSISTENT_VOLUME_NAME))
.status(new V1PersistentVolumeStatus()
.phase("Released"));
assertThat(pvcReclaimController.isPvReleased(v1PersistentVolume)).isTrue();
}
}
| 9 |
0 | Create_ds/titus-control-plane/titus-server-master/src/test/java/com/netflix/titus/master/kubernetes | Create_ds/titus-control-plane/titus-server-master/src/test/java/com/netflix/titus/master/kubernetes/controller/PodTerminalGcControllerTest.java | /*
* Copyright 2020 Netflix, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.netflix.titus.master.kubernetes.controller;
import java.time.Duration;
import java.util.Collections;
import java.util.Map;
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.service.V3JobOperations;
import com.netflix.titus.common.framework.scheduler.LocalScheduler;
import com.netflix.titus.common.runtime.TitusRuntime;
import com.netflix.titus.common.runtime.TitusRuntimes;
import com.netflix.titus.common.util.DateTimeExt;
import com.netflix.titus.common.util.limiter.tokenbucket.FixedIntervalTokenBucketConfiguration;
import com.netflix.titus.common.util.time.TestClock;
import com.netflix.titus.common.util.time.internal.DefaultTestClock;
import com.netflix.titus.runtime.connector.kubernetes.std.StdKubeApiFacade;
import com.netflix.titus.testkit.model.job.JobGenerator;
import io.kubernetes.client.openapi.models.V1ObjectMeta;
import io.kubernetes.client.openapi.models.V1Pod;
import io.kubernetes.client.openapi.models.V1PodStatus;
import org.assertj.core.api.Assertions;
import org.junit.jupiter.api.Test;
import static com.netflix.titus.runtime.kubernetes.KubeConstants.RUNNING;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
public class PodTerminalGcControllerTest {
private static final String POD_NAME = "pod-name";
private static final TestClock clock = new DefaultTestClock();
private static final long POD_TERMINAL_GRACE_PERIOD = 1000L;
private final TitusRuntime titusRuntime = TitusRuntimes.test(clock);
private final FixedIntervalTokenBucketConfiguration tokenBucketConfiguration = mock(FixedIntervalTokenBucketConfiguration.class);
private final ControllerConfiguration controllerConfiguration = mock(ControllerConfiguration.class);
private final StdKubeApiFacade kubeApiFacade = mock(StdKubeApiFacade.class);
private final LocalScheduler scheduler = mock(LocalScheduler.class);
private final KubeControllerConfiguration kubeControllerConfiguration = mock(KubeControllerConfiguration.class);
private final V3JobOperations v3JobOperations = mock(V3JobOperations.class);
private final PodTerminalGcController podGcController = new PodTerminalGcController(
titusRuntime,
scheduler,
tokenBucketConfiguration,
controllerConfiguration,
kubeApiFacade,
kubeControllerConfiguration,
v3JobOperations
);
/**
* The pod is not terminal and should not be GC'ed
*/
@Test
void podIsNotTerminal() {
when(kubeControllerConfiguration.getPodTerminalGracePeriodMs()).thenReturn(POD_TERMINAL_GRACE_PERIOD);
V1Pod pod = new V1Pod()
.metadata(new V1ObjectMeta().name(POD_NAME).creationTimestamp(DateTimeExt.fromMillis(clock.wallTime())))
.status(new V1PodStatus().phase(RUNNING));
TaskStatus taskStatus = TaskStatus.newBuilder()
.withState(TaskState.Started)
.withTimestamp(clock.wallTime())
.build();
Task task = JobGenerator.oneBatchTask().toBuilder().withStatus(taskStatus).build();
clock.advanceTime(Duration.ofMillis(POD_TERMINAL_GRACE_PERIOD + 1));
Map<String, Task> currentTasks = Collections.singletonMap(POD_NAME, task);
Assertions.assertThat(podGcController.isPodTerminal(pod, currentTasks)).isFalse();
}
/**
* The pod is terminal but has not yet passed the configured grace period so it should not be GC'ed
*/
@Test
void podIsTerminalWithoutGracePeriod() {
when(kubeControllerConfiguration.getPodTerminalGracePeriodMs()).thenReturn(POD_TERMINAL_GRACE_PERIOD);
V1Pod pod = new V1Pod()
.metadata(new V1ObjectMeta().name(POD_NAME).creationTimestamp(DateTimeExt.fromMillis(clock.wallTime())))
.status(new V1PodStatus().phase(RUNNING));
TaskStatus taskStatus = TaskStatus.newBuilder()
.withState(TaskState.Started)
.withTimestamp(clock.wallTime())
.build();
Task task = JobGenerator.oneBatchTask().toBuilder().withStatus(taskStatus).build();
Map<String, Task> currentTasks = Collections.singletonMap(POD_NAME, task);
Assertions.assertThat(podGcController.isPodTerminal(pod, currentTasks)).isFalse();
}
/**
* The pod is terminal and should be GC'ed
*/
@Test
void podIsTerminal() {
when(kubeControllerConfiguration.getPodTerminalGracePeriodMs()).thenReturn(POD_TERMINAL_GRACE_PERIOD);
V1Pod pod = new V1Pod()
.metadata(new V1ObjectMeta().name(POD_NAME).creationTimestamp(DateTimeExt.fromMillis(clock.wallTime())))
.status(new V1PodStatus().phase(RUNNING));
TaskStatus taskStatus = TaskStatus.newBuilder()
.withState(TaskState.Finished)
.withTimestamp(clock.wallTime())
.build();
Task task = JobGenerator.oneBatchTask().toBuilder().withStatus(taskStatus).build();
clock.advanceTime(Duration.ofMillis(POD_TERMINAL_GRACE_PERIOD + 1));
Map<String, Task> currentTasks = Collections.singletonMap(POD_NAME, task);
Assertions.assertThat(podGcController.isPodTerminal(pod, currentTasks)).isTrue();
}
} | 10 |
0 | Create_ds/titus-control-plane/titus-server-master/src/test/java/com/netflix/titus/master/kubernetes | Create_ds/titus-control-plane/titus-server-master/src/test/java/com/netflix/titus/master/kubernetes/controller/PodDeletionGcControllerTest.java | /*
* Copyright 2020 Netflix, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.netflix.titus.master.kubernetes.controller;
import java.time.Duration;
import com.netflix.titus.common.framework.scheduler.LocalScheduler;
import com.netflix.titus.common.runtime.TitusRuntime;
import com.netflix.titus.common.runtime.TitusRuntimes;
import com.netflix.titus.common.util.DateTimeExt;
import com.netflix.titus.common.util.limiter.tokenbucket.FixedIntervalTokenBucketConfiguration;
import com.netflix.titus.common.util.time.TestClock;
import com.netflix.titus.common.util.time.internal.DefaultTestClock;
import com.netflix.titus.runtime.connector.kubernetes.std.StdKubeApiFacade;
import io.kubernetes.client.openapi.models.V1ObjectMeta;
import io.kubernetes.client.openapi.models.V1Pod;
import io.kubernetes.client.openapi.models.V1PodSpec;
import io.kubernetes.client.openapi.models.V1PodStatus;
import org.assertj.core.api.Assertions;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import static com.netflix.titus.runtime.kubernetes.KubeConstants.PENDING;
import static com.netflix.titus.runtime.kubernetes.KubeConstants.RUNNING;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
public class PodDeletionGcControllerTest {
private static final String NODE_NAME = "node-name";
private static final String POD_NAME = "pod-name";
private static final TestClock clock = new DefaultTestClock();
private static final long POD_DELETION_TIMESTAMP_GRACE_PERIOD = 1000L;
private static final long POD_TERMINATION_GRACE_PERIOD_SEC = 30L;
private static final long POD_TERMINATION_GRACE_PERIOD_MS = POD_TERMINATION_GRACE_PERIOD_SEC * 1000;
private final TitusRuntime titusRuntime = TitusRuntimes.test(clock);
private final FixedIntervalTokenBucketConfiguration tokenBucketConfiguration = mock(FixedIntervalTokenBucketConfiguration.class);
private final ControllerConfiguration controllerConfiguration = mock(ControllerConfiguration.class);
private final StdKubeApiFacade kubeApiFacade = mock(StdKubeApiFacade.class);
private final LocalScheduler scheduler = mock(LocalScheduler.class);
private final KubeControllerConfiguration kubeControllerConfiguration = mock(KubeControllerConfiguration.class);
private final PodDeletionGcController podDeletionGcController = new PodDeletionGcController(
titusRuntime,
scheduler,
tokenBucketConfiguration,
controllerConfiguration,
kubeApiFacade,
kubeControllerConfiguration
);
@BeforeEach
void setUp() {
when(kubeControllerConfiguration.getPodsPastTerminationGracePeriodMs()).thenReturn(POD_DELETION_TIMESTAMP_GRACE_PERIOD);
}
/**
* The pod has a deletion timestamp that is past the termination and deletion grace periods and should return true.
*/
@Test
void podIsPastDeletionTimestamp() {
V1Pod pod = new V1Pod()
.metadata(
new V1ObjectMeta()
.name(POD_NAME)
.deletionTimestamp(DateTimeExt.fromMillis(clock.wallTime()))
)
.spec(
new V1PodSpec()
.nodeName(NODE_NAME)
.terminationGracePeriodSeconds(POD_TERMINATION_GRACE_PERIOD_SEC))
.status(null);
clock.advanceTime(Duration.ofMillis(POD_TERMINATION_GRACE_PERIOD_MS + POD_DELETION_TIMESTAMP_GRACE_PERIOD + 1));
Assertions.assertThat(podDeletionGcController.isPodPastDeletionTimestamp(pod)).isTrue();
}
/**
* The pod has a deletion timestamp that is not past the termination and deletion grace periods and should return false.
*/
@Test
void podIsNotPastDeletionTimestamp() {
V1Pod pod = new V1Pod()
.metadata(
new V1ObjectMeta()
.name(POD_NAME)
.deletionTimestamp(DateTimeExt.fromMillis(clock.wallTime()))
)
.spec(
new V1PodSpec()
.nodeName(NODE_NAME)
.terminationGracePeriodSeconds(POD_TERMINATION_GRACE_PERIOD_SEC))
.status(null);
Assertions.assertThat(podDeletionGcController.isPodPastDeletionTimestamp(pod)).isFalse();
}
/**
* The pod has a deletion timestamp and is in the Pending phase so should return true.
*/
@Test
void podIsPendingPhaseWithDeletionTimestamp() {
V1Pod pod = new V1Pod()
.metadata(
new V1ObjectMeta()
.name(POD_NAME)
.deletionTimestamp(DateTimeExt.fromMillis(clock.wallTime()))
)
.spec(new V1PodSpec())
.status(new V1PodStatus().phase(PENDING));
Assertions.assertThat(podDeletionGcController.isPodInPendingPhaseWithDeletionTimestamp(pod)).isTrue();
}
/**
* The pod has a deletion timestamp and is in the Running phase so should return false.
*/
@Test
void podIsInRunningPhaseWithDeletionTimestamp() {
V1Pod pod = new V1Pod()
.metadata(
new V1ObjectMeta()
.name(POD_NAME)
.deletionTimestamp(DateTimeExt.fromMillis(clock.wallTime()))
)
.spec(new V1PodSpec())
.status(new V1PodStatus().phase(RUNNING));
Assertions.assertThat(podDeletionGcController.isPodInPendingPhaseWithDeletionTimestamp(pod)).isFalse();
}
/**
* The pod does not have a deletion timestamp and is in the Pending phase so should return false.
*/
@Test
void podDoesNotHaveDeletionTimestamp() {
V1Pod pod = new V1Pod()
.metadata(
new V1ObjectMeta()
.name(POD_NAME)
)
.spec(new V1PodSpec())
.status(new V1PodStatus().phase(PENDING));
Assertions.assertThat(podDeletionGcController.isPodInPendingPhaseWithDeletionTimestamp(pod)).isFalse();
}
} | 11 |
0 | Create_ds/titus-control-plane/titus-server-master/src/test/java/com/netflix/titus/master/kubernetes | Create_ds/titus-control-plane/titus-server-master/src/test/java/com/netflix/titus/master/kubernetes/controller/PersistentVolumeClaimGcControllerTest.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.master.kubernetes.controller;
import java.util.Optional;
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.ext.BatchJobExt;
import com.netflix.titus.api.jobmanager.service.V3JobOperations;
import com.netflix.titus.common.framework.scheduler.LocalScheduler;
import com.netflix.titus.common.runtime.TitusRuntime;
import com.netflix.titus.common.runtime.TitusRuntimes;
import com.netflix.titus.common.util.limiter.tokenbucket.FixedIntervalTokenBucketConfiguration;
import com.netflix.titus.common.util.tuple.Pair;
import com.netflix.titus.runtime.connector.kubernetes.std.StdKubeApiFacade;
import com.netflix.titus.testkit.model.job.JobGenerator;
import io.kubernetes.client.openapi.models.V1ObjectMeta;
import io.kubernetes.client.openapi.models.V1PersistentVolumeClaim;
import io.kubernetes.client.openapi.models.V1PersistentVolumeClaimStatus;
import org.junit.Test;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
public class PersistentVolumeClaimGcControllerTest {
private static final String PERSISTENT_VOLUME_NAME = "vol-1";
private static final Job<BatchJobExt> BATCH_JOB = JobGenerator.oneBatchJob();
private static final BatchJobTask BATCH_TASK = JobGenerator.batchTasks(BATCH_JOB).getValue();
private final TitusRuntime titusRuntime = TitusRuntimes.test();
private final FixedIntervalTokenBucketConfiguration tokenBucketConfiguration = mock(FixedIntervalTokenBucketConfiguration.class);
private final ControllerConfiguration controllerConfiguration = mock(ControllerConfiguration.class);
private final StdKubeApiFacade kubeApiFacade = mock(StdKubeApiFacade.class);
private final LocalScheduler scheduler = mock(LocalScheduler.class);
private final V3JobOperations v3JobOperations = mock(V3JobOperations.class);
private final PersistentVolumeClaimGcController pvcGcController = new PersistentVolumeClaimGcController(
titusRuntime,
scheduler,
tokenBucketConfiguration,
controllerConfiguration,
kubeApiFacade,
v3JobOperations
);
/**
* Tests that a PVC that is Bound is not GC'd.
*/
@Test
public void testBoundPvc() {
String taskId = BATCH_TASK.getId();
V1PersistentVolumeClaim v1PersistentVolumeClaim = new V1PersistentVolumeClaim()
.metadata(new V1ObjectMeta()
.name(PERSISTENT_VOLUME_NAME + "." + taskId))
.status(new V1PersistentVolumeClaimStatus()
.phase("Bound"));
when(v3JobOperations.findTaskById(taskId)).thenReturn(Optional.of(Pair.of(BATCH_JOB, BATCH_TASK)));
assertThat(pvcGcController.gcItem(v1PersistentVolumeClaim)).isFalse();
}
/**
* Tests that a PVC that is released is GC'd.
*/
@Test
public void testReleasedPvc() {
String taskId = BATCH_TASK.getId();
V1PersistentVolumeClaim v1PersistentVolumeClaim = new V1PersistentVolumeClaim()
.metadata(new V1ObjectMeta()
.name(PERSISTENT_VOLUME_NAME + "." + taskId))
.status(new V1PersistentVolumeClaimStatus()
.phase("Bound"));
when(v3JobOperations.findTaskById(taskId)).thenReturn(Optional.empty());
assertThat(pvcGcController.gcItem(v1PersistentVolumeClaim)).isTrue();
}
}
| 12 |
0 | Create_ds/titus-control-plane/titus-server-master/src/test/java/com/netflix/titus/master/appscale/endpoint.v3 | Create_ds/titus-control-plane/titus-server-master/src/test/java/com/netflix/titus/master/appscale/endpoint.v3/grpc/DefaultAutoScalingServiceGrpcTest.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.master.appscale.endpoint.v3.grpc;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;
import com.google.protobuf.Empty;
import com.netflix.spectator.api.DefaultRegistry;
import com.netflix.titus.api.appscale.model.PolicyType;
import com.netflix.titus.api.appscale.service.AppScaleManager;
import com.netflix.titus.api.appscale.store.AppScalePolicyStore;
import com.netflix.titus.common.model.sanitizer.EntitySanitizer;
import com.netflix.titus.common.runtime.TitusRuntimes;
import com.netflix.titus.grpc.protogen.DeletePolicyRequest;
import com.netflix.titus.grpc.protogen.GetPolicyResult;
import com.netflix.titus.grpc.protogen.JobId;
import com.netflix.titus.grpc.protogen.PutPolicyRequest;
import com.netflix.titus.grpc.protogen.ScalingPolicyID;
import com.netflix.titus.grpc.protogen.ScalingPolicyResult;
import com.netflix.titus.master.appscale.service.AutoScalingPolicyTests;
import com.netflix.titus.master.appscale.service.DefaultAppScaleManager;
import com.netflix.titus.runtime.store.v3.memory.InMemoryPolicyStore;
import com.netflix.titus.testkit.grpc.TestStreamObserver;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import rx.schedulers.Schedulers;
import static com.netflix.titus.grpc.protogen.ScalingPolicyStatus.ScalingPolicyState.Applied;
import static com.netflix.titus.grpc.protogen.ScalingPolicyStatus.ScalingPolicyState.Deleted;
import static org.assertj.core.api.AssertionsForClassTypes.assertThat;
import static org.mockito.Mockito.mock;
public class DefaultAutoScalingServiceGrpcTest {
private static Logger log = LoggerFactory.getLogger(DefaultAutoScalingServiceGrpcTest.class);
private final AppScalePolicyStore appScalePolicyStore = new InMemoryPolicyStore();
private final AppScaleManager appScaleManager = new DefaultAppScaleManager(appScalePolicyStore,
new AutoScalingPolicyTests.MockAlarmClient(),
new AutoScalingPolicyTests.MockAppAutoScalingClient(), null,
new DefaultRegistry(),
AutoScalingPolicyTests.mockAppScaleManagerConfiguration(),
Schedulers.immediate(),
TitusRuntimes.test());
private final DefaultAutoScalingServiceGrpc service = new DefaultAutoScalingServiceGrpc(appScaleManager, mock(EntitySanitizer.class));
@Before
public void setUp() throws Exception {
}
@After
public void tearDown() throws Exception {
}
/**
* Tests setting and getting a Target Tracking Policy.
*
* @throws Exception
*/
@Test
public void testTargetTrackingPolicy() throws Exception {
String jobId = "Titus-123";
ScalingPolicyID scalingPolicyID = putPolicyWithJobId(jobId, PolicyType.TargetTrackingScaling);
TestStreamObserver<GetPolicyResult> getResponse = new TestStreamObserver<>();
service.getScalingPolicy(scalingPolicyID, getResponse);
GetPolicyResult getPolicyResult = getResponse.takeNext();
log.info("Got response {}", getPolicyResult);
assertThat(getPolicyResult.getItemsCount()).isEqualTo(1);
assertThat(getPolicyResult.getItems(0).getId()).isEqualTo(scalingPolicyID);
assertThat(getPolicyResult.getItems(0).getJobId()).isEqualTo(jobId);
}
/**
* Tests setting and getting policies by Job ID.
*
* @throws Exception
*/
@Test
public void testSetAndGetJobScalingPolicy() throws Exception {
int numJobs = 2;
int numPoliciesPerJob = 3;
Map<String, Set<ScalingPolicyID>> jobIdToPoliciesMap = putPoliciesPerJob(numJobs, numPoliciesPerJob, PolicyType.StepScaling);
// For each job, check that all of the policies exist
jobIdToPoliciesMap.forEach((jobId, policyIDSet) -> {
TestStreamObserver<GetPolicyResult> getResponse = new TestStreamObserver<>();
JobId jobIdRequest = JobId.newBuilder().setId(jobId).build();
service.getJobScalingPolicies(jobIdRequest, getResponse);
GetPolicyResult getPolicyResult = getResponse.takeNext();
assertThat(getPolicyResult.getItemsCount()).isEqualTo(numPoliciesPerJob);
for (int i = 0; i < getPolicyResult.getItemsCount(); i++) {
ScalingPolicyResult scalingPolicyResult = getPolicyResult.getItems(i);
assertThat(policyIDSet.contains(scalingPolicyResult.getId())).isTrue();
}
});
}
/**
* Tests getting policies by Ref ID.
*
* @throws Exception
*/
@Test
public void testGetByPolicyId() throws Exception {
String jobId = "Titus-123";
ScalingPolicyID scalingPolicyID = putPolicyWithJobId(jobId, PolicyType.StepScaling);
TestStreamObserver<GetPolicyResult> getResponse = new TestStreamObserver<>();
service.getScalingPolicy(scalingPolicyID, getResponse);
GetPolicyResult getPolicyResult = getResponse.takeNext();
log.info("Got response {}", getPolicyResult);
assertThat(getPolicyResult.getItemsCount()).isEqualTo(1);
assertThat(getPolicyResult.getItems(0).getId()).isEqualTo(scalingPolicyID);
assertThat(getPolicyResult.getItems(0).getJobId()).isEqualTo(jobId);
}
/**
* Test getting all policies across multiple jobs
*
* @throws Exception
*/
@Test
public void testGetAllPolicies() throws Exception {
int numJobs = 20;
int numPoliciesPerJob = 5;
Map<String, Set<ScalingPolicyID>> jobIdToPoliciesMap = putPoliciesPerJob(numJobs, numPoliciesPerJob, PolicyType.StepScaling);
Empty request = Empty.newBuilder().build();
TestStreamObserver<GetPolicyResult> getResponse = new TestStreamObserver<>();
service.getAllScalingPolicies(request, getResponse);
GetPolicyResult getPolicyResult = getResponse.takeNext();
assertThat(getPolicyResult.getItemsCount()).isEqualTo(numJobs * numPoliciesPerJob);
}
/**
* Tests deleting policies by Ref ID.
*
* @throws Exception
*/
@Test
public void testDeletePolicyId() throws Exception {
String jobId = "Titus-123";
ScalingPolicyID scalingPolicyID = putPolicyWithJobId(jobId, PolicyType.StepScaling);
DeletePolicyRequest deletePolicyRequest = DeletePolicyRequest.newBuilder()
.setId(scalingPolicyID)
.build();
TestStreamObserver<Empty> deleteResponse = new TestStreamObserver<>();
service.deleteAutoScalingPolicy(deletePolicyRequest, deleteResponse);
deleteResponse.awaitDone();
AutoScalingPolicyTests.waitForCondition(() -> {
TestStreamObserver<GetPolicyResult> getResponse = new TestStreamObserver<>();
service.getScalingPolicy(scalingPolicyID, getResponse);
GetPolicyResult getPolicyResult = getResponse.takeNext();
return getPolicyResult.getItemsCount() == 1 &&
getPolicyResult.getItems(0).getPolicyState().getState() == Deleted;
});
TestStreamObserver<GetPolicyResult> getResponse = new TestStreamObserver<>();
service.getScalingPolicy(scalingPolicyID, getResponse);
GetPolicyResult getPolicyResult = getResponse.takeNext();
// Check that the policy still exists but the state is updated
assertThat(getPolicyResult.getItemsCount()).isEqualTo(1);
assertThat(getPolicyResult.getItems(0).getPolicyState().getState()).isEqualTo(Deleted);
}
@Test
public void testUpdatePolicyConfigurationForTargetTracking() throws Exception {
ScalingPolicyID policyId = putPolicyWithJobId("Job-1", PolicyType.TargetTrackingScaling);
TestStreamObserver<Empty> updateResponse = new TestStreamObserver<>();
service.updateAutoScalingPolicy(
AutoScalingTestUtils.generateUpdateTargetTrackingPolicyRequest(policyId.getId(), 100.0),
updateResponse);
AutoScalingPolicyTests.waitForCondition(() -> {
TestStreamObserver<GetPolicyResult> getResponse = new TestStreamObserver<>();
service.getScalingPolicy(policyId, getResponse);
GetPolicyResult getPolicyResult = getResponse.takeNext();
return getPolicyResult.getItems(0).getScalingPolicy().getTargetPolicyDescriptor().getTargetValue().getValue() == 100.0 &&
getPolicyResult.getItems(0).getPolicyState().getState() == Applied;
});
TestStreamObserver<GetPolicyResult> getResponse = new TestStreamObserver<>();
service.getScalingPolicy(policyId, getResponse);
GetPolicyResult getPolicyResult = getResponse.takeNext();
assertThat(getPolicyResult.getItems(0).getScalingPolicy().getTargetPolicyDescriptor().getTargetValue().getValue()).isEqualTo(100.0);
assertThat(getPolicyResult.getItems(0).getPolicyState().getState()).isEqualTo(Applied);
}
@Test
public void testUpdatePolicyConfigurationForStepScaling() throws Exception {
ScalingPolicyID policyId = putPolicyWithJobId("Job-1", PolicyType.StepScaling);
TestStreamObserver<Empty> updateResponse = new TestStreamObserver<>();
service.updateAutoScalingPolicy(
AutoScalingTestUtils.generateUpdateStepScalingPolicyRequest(policyId.getId(), 100.0),
updateResponse);
updateResponse.awaitDone();
AutoScalingPolicyTests.waitForCondition(() -> {
TestStreamObserver<GetPolicyResult> getResponse = new TestStreamObserver<>();
service.getScalingPolicy(policyId, getResponse);
GetPolicyResult getPolicyResult = getResponse.takeNext();
return getPolicyResult.getItems(0).getScalingPolicy().getStepPolicyDescriptor().getAlarmConfig().getThreshold().getValue() == 100.0 &&
getPolicyResult.getItems(0).getPolicyState().getState() == Applied;
});
TestStreamObserver<GetPolicyResult> getResponse = new TestStreamObserver<>();
service.getScalingPolicy(policyId, getResponse);
GetPolicyResult getPolicyResult = getResponse.takeNext();
assertThat(getPolicyResult.getItems(0).getScalingPolicy().getStepPolicyDescriptor().getAlarmConfig().getThreshold().getValue()).isEqualTo(100.0);
assertThat(getPolicyResult.getItems(0).getPolicyState().getState()).isEqualTo(Applied);
}
/**
* Puts multiple a specified number of policies for given jobs.
*
* @return
*/
private Map<String, Set<ScalingPolicyID>> putPoliciesPerJob(int numJobs, int numPoliciesPerJob, PolicyType policyType) {
// Create job entries
Map<String, Set<ScalingPolicyID>> jobIdToPoliciesMap = new ConcurrentHashMap<>();
for (int i = 1; i <= numJobs; i++) {
jobIdToPoliciesMap.put("Titus-" + i, new HashSet<>());
}
// For each job, insert policies
jobIdToPoliciesMap.forEach((jobId, policyIDSet) -> {
for (int i = 0; i < numPoliciesPerJob; i++) {
policyIDSet.add(putPolicyWithJobId(jobId, policyType));
}
});
return jobIdToPoliciesMap;
}
private ScalingPolicyID putPolicyWithJobId(String jobId, PolicyType policyType) {
PutPolicyRequest putPolicyRequest = AutoScalingTestUtils.generatePutPolicyRequest(jobId, policyType);
TestStreamObserver<ScalingPolicyID> putResponse = new TestStreamObserver<>();
service.setAutoScalingPolicy(putPolicyRequest, putResponse);
log.info("Put policy {}", putPolicyRequest);
ScalingPolicyID scalingPolicyID = putResponse.takeNext();
assertThat(scalingPolicyID.getId()).isNotEmpty();
return scalingPolicyID;
}
}
| 13 |
0 | Create_ds/titus-control-plane/titus-server-master/src/test/java/com/netflix/titus/master/appscale/endpoint.v3 | Create_ds/titus-control-plane/titus-server-master/src/test/java/com/netflix/titus/master/appscale/endpoint.v3/grpc/AutoScalingTestUtils.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.master.appscale.endpoint.v3.grpc;
import java.util.concurrent.ThreadLocalRandom;
import com.google.protobuf.BoolValue;
import com.google.protobuf.DoubleValue;
import com.google.protobuf.Int32Value;
import com.google.protobuf.Int64Value;
import com.netflix.titus.api.appscale.model.PolicyType;
import com.netflix.titus.grpc.protogen.AlarmConfiguration;
import com.netflix.titus.grpc.protogen.CustomizedMetricSpecification;
import com.netflix.titus.grpc.protogen.MetricDimension;
import com.netflix.titus.grpc.protogen.PutPolicyRequest;
import com.netflix.titus.grpc.protogen.ScalingPolicy;
import com.netflix.titus.grpc.protogen.ScalingPolicyID;
import com.netflix.titus.grpc.protogen.StepAdjustments;
import com.netflix.titus.grpc.protogen.StepScalingPolicy;
import com.netflix.titus.grpc.protogen.StepScalingPolicyDescriptor;
import com.netflix.titus.grpc.protogen.TargetTrackingPolicyDescriptor;
import com.netflix.titus.grpc.protogen.UpdatePolicyRequest;
public class AutoScalingTestUtils {
public static UpdatePolicyRequest generateUpdateTargetTrackingPolicyRequest(String policyRefId, double targetValue) {
ScalingPolicy scalingPolicy = generateTargetPolicy();
TargetTrackingPolicyDescriptor targetPolicyDescriptor = scalingPolicy.getTargetPolicyDescriptor();
TargetTrackingPolicyDescriptor targetPolicyWithUpdatedValue = targetPolicyDescriptor.toBuilder().setTargetValue(DoubleValue.newBuilder().setValue(targetValue).build()).build();
ScalingPolicy scalingPolicyTobeUpdated = scalingPolicy.toBuilder().setTargetPolicyDescriptor(targetPolicyWithUpdatedValue).build();
UpdatePolicyRequest updatePolicyRequest = UpdatePolicyRequest.newBuilder().setPolicyId(ScalingPolicyID.newBuilder().setId(policyRefId).build())
.setScalingPolicy(scalingPolicyTobeUpdated).build();
return updatePolicyRequest;
}
public static UpdatePolicyRequest generateUpdateStepScalingPolicyRequest(String policyRefId, double threshold) {
ScalingPolicy scalingPolicy = generateStepPolicy();
AlarmConfiguration alarmConfig = scalingPolicy.getStepPolicyDescriptor().getAlarmConfig().toBuilder().setThreshold(DoubleValue.newBuilder().setValue(threshold).build()).build();
StepScalingPolicyDescriptor stepScalingPolicyDescriptor = scalingPolicy.getStepPolicyDescriptor().toBuilder().setAlarmConfig(alarmConfig).build();
ScalingPolicy scalingPolicyToBeUpdated = scalingPolicy.toBuilder().setStepPolicyDescriptor(stepScalingPolicyDescriptor).build();
UpdatePolicyRequest updatePolicyRequest = UpdatePolicyRequest.newBuilder().setPolicyId(ScalingPolicyID.newBuilder().setId(policyRefId).build())
.setScalingPolicy(scalingPolicyToBeUpdated).build();
return updatePolicyRequest;
}
public static PutPolicyRequest generatePutPolicyRequest(String jobId, PolicyType policyType) {
ScalingPolicy scalingPolicy;
if (policyType == PolicyType.StepScaling) {
scalingPolicy = generateStepPolicy();
} else {
scalingPolicy = generateTargetPolicy();
}
return PutPolicyRequest.newBuilder()
.setJobId(jobId)
.setScalingPolicy(scalingPolicy)
.build();
}
public static ScalingPolicy generateTargetPolicy() {
CustomizedMetricSpecification customizedMetricSpec = CustomizedMetricSpecification.newBuilder()
.addDimensions(MetricDimension.newBuilder()
.setName("testName")
.setValue("testValue")
.build())
.setMetricName("testMetric")
.setNamespace("NFLX/EPIC")
.setStatistic(AlarmConfiguration.Statistic.Sum)
.setMetricName("peanuts")
.build();
TargetTrackingPolicyDescriptor targetTrackingPolicyDescriptor = TargetTrackingPolicyDescriptor.newBuilder()
.setTargetValue(DoubleValue.newBuilder()
.setValue(ThreadLocalRandom.current().nextDouble())
.build())
.setScaleInCooldownSec(Int32Value.newBuilder()
.setValue(ThreadLocalRandom.current().nextInt())
.build())
.setScaleOutCooldownSec(Int32Value.newBuilder()
.setValue(ThreadLocalRandom.current().nextInt())
.build())
.setDisableScaleIn(BoolValue.newBuilder()
.setValue(false)
.build())
.setCustomizedMetricSpecification(customizedMetricSpec)
.build();
return ScalingPolicy.newBuilder().setTargetPolicyDescriptor(targetTrackingPolicyDescriptor).build();
}
/**
* Builds a random scaling policy for use with tests.
*
* @return
*/
public static ScalingPolicy generateStepPolicy() {
// TODO(Andrew L): Add target tracking support
AlarmConfiguration alarmConfig = AlarmConfiguration.newBuilder()
.setActionsEnabled(BoolValue.newBuilder()
.setValue(ThreadLocalRandom.current().nextBoolean())
.build())
.setComparisonOperator(AlarmConfiguration.ComparisonOperator.GreaterThanThreshold)
.setEvaluationPeriods(Int32Value.newBuilder()
.setValue(ThreadLocalRandom.current().nextInt())
.build())
.setPeriodSec(Int32Value.newBuilder()
.setValue(ThreadLocalRandom.current().nextInt())
.build())
.setThreshold(DoubleValue.newBuilder()
.setValue(ThreadLocalRandom.current().nextDouble())
.build())
.setMetricNamespace("NFLX/EPIC")
.setMetricName("Metric-" + ThreadLocalRandom.current().nextInt())
.setStatistic(AlarmConfiguration.Statistic.Sum)
.build();
StepScalingPolicy stepScalingPolicy = StepScalingPolicy.newBuilder()
.setAdjustmentType(StepScalingPolicy.AdjustmentType.ChangeInCapacity)
.setCooldownSec(Int32Value.newBuilder()
.setValue(ThreadLocalRandom.current().nextInt())
.build())
.setMinAdjustmentMagnitude(Int64Value.newBuilder()
.setValue(ThreadLocalRandom.current().nextLong())
.build())
.setMetricAggregationType(StepScalingPolicy.MetricAggregationType.Maximum)
.addStepAdjustments(StepAdjustments.newBuilder()
.setMetricIntervalLowerBound(DoubleValue.newBuilder()
.setValue(ThreadLocalRandom.current().nextDouble())
.build())
.setMetricIntervalUpperBound(DoubleValue.newBuilder()
.setValue(ThreadLocalRandom.current().nextDouble())
.build())
.setScalingAdjustment(Int32Value.newBuilder()
.setValue(ThreadLocalRandom.current().nextInt())
.build()))
.build();
StepScalingPolicyDescriptor stepScalingPolicyDescriptor = StepScalingPolicyDescriptor.newBuilder()
.setAlarmConfig(alarmConfig)
.setScalingPolicy(stepScalingPolicy)
.build();
return ScalingPolicy.newBuilder().setStepPolicyDescriptor(stepScalingPolicyDescriptor).build();
}
}
| 14 |
0 | Create_ds/titus-control-plane/titus-server-master/src/test/java/com/netflix/titus/master/appscale | Create_ds/titus-control-plane/titus-server-master/src/test/java/com/netflix/titus/master/appscale/service/AutoScalingPolicyTests.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.master.appscale.service;
import java.util.Arrays;
import java.util.List;
import java.util.function.BooleanSupplier;
import com.netflix.titus.api.appscale.model.AlarmConfiguration;
import com.netflix.titus.api.appscale.model.AutoScalableTarget;
import com.netflix.titus.api.appscale.model.AutoScalingPolicy;
import com.netflix.titus.api.appscale.model.ComparisonOperator;
import com.netflix.titus.api.appscale.model.CustomizedMetricSpecification;
import com.netflix.titus.api.appscale.model.MetricAggregationType;
import com.netflix.titus.api.appscale.model.PolicyConfiguration;
import com.netflix.titus.api.appscale.model.PolicyStatus;
import com.netflix.titus.api.appscale.model.PolicyType;
import com.netflix.titus.api.appscale.model.Statistic;
import com.netflix.titus.api.appscale.model.StepAdjustment;
import com.netflix.titus.api.appscale.model.StepAdjustmentType;
import com.netflix.titus.api.appscale.model.StepScalingPolicyConfiguration;
import com.netflix.titus.api.appscale.model.TargetTrackingPolicy;
import com.netflix.titus.api.connector.cloud.AppAutoScalingClient;
import com.netflix.titus.api.connector.cloud.CloudAlarmClient;
import rx.Completable;
import rx.Observable;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
public class AutoScalingPolicyTests {
public static class MockAlarmClient implements CloudAlarmClient {
int numOfAlarmsCreated = 0;
@Override
public Observable<String> createOrUpdateAlarm(String policyRefId, String jobId, AlarmConfiguration alarmConfiguration,
String autoScalingGroup, List<String> actions) {
numOfAlarmsCreated++;
return Observable.just("alarmARM");
}
@Override
public Completable deleteAlarm(String jobId, String alarmName) {
numOfAlarmsCreated--;
return Completable.complete();
}
public int getNumOfAlarmsCreated() {
return numOfAlarmsCreated;
}
}
public static class MockAppAutoScalingClient implements AppAutoScalingClient {
int numScalableTargets = 0;
int numPolicies = 0;
public int getNumScalableTargets() {
return numScalableTargets;
}
public int getNumPolicies() {
return numPolicies;
}
@Override
public Completable createScalableTarget(String jobId, int minCapacity, int maxCapacity) {
numScalableTargets++;
return Completable.complete();
}
@Override
public Observable<String> createOrUpdateScalingPolicy(String policyRefId, String jobId, PolicyConfiguration policyConfiguration) {
numPolicies++;
return Observable.just("policyARN");
}
@Override
public Completable deleteScalableTarget(String jobId) {
numScalableTargets--;
return Completable.complete();
}
@Override
public Completable deleteScalingPolicy(String policyRefId, String jobId) {
numPolicies--;
return Completable.complete();
}
@Override
public Observable<AutoScalableTarget> getScalableTargetsForJob(String jobId) {
return Observable.empty();
}
}
public static AutoScalingPolicy buildTargetTrackingPolicy(String jobId) {
CustomizedMetricSpecification customizedMetricSpec = CustomizedMetricSpecification.newBuilder()
.withNamespace("foobar")
.withNamespace("NFLX/EPIC")
.withStatistic(Statistic.Sum)
.withUnit("Seconds")
.build();
TargetTrackingPolicy targetTrackingPolicy = TargetTrackingPolicy.newBuilder()
.withDisableScaleIn(false)
.withScaleInCooldownSec(10)
.withScaleOutCooldownSec(5)
.withCustomizedMetricSpecification(customizedMetricSpec)
.build();
PolicyConfiguration policyConfiguration = PolicyConfiguration.newBuilder()
.withTargetTrackingPolicy(targetTrackingPolicy)
.withPolicyType(PolicyType.TargetTrackingScaling)
.build();
AutoScalingPolicy autoScalingPolicy = AutoScalingPolicy.newBuilder()
.withPolicyConfiguration(policyConfiguration)
.withStatus(PolicyStatus.Pending)
.withStatusMessage("ICE-ed by AWS")
.withJobId(jobId)
.build();
return autoScalingPolicy;
}
public static AutoScalingPolicy buildStepScalingPolicy(String jobId) {
AlarmConfiguration alarmConfiguration = AlarmConfiguration.newBuilder()
.withActionsEnabled(true)
.withComparisonOperator(ComparisonOperator.GreaterThanThreshold)
.withEvaluationPeriods(1)
.withPeriodSec(60)
.withMetricName("CPUUtilization")
.withMetricNamespace("AWS/EC2")
.withName(jobId)
.withStatistic(Statistic.Average)
.build();
StepAdjustment stepAdjustment = StepAdjustment.newBuilder()
.withMetricIntervalLowerBound(0)
.withScalingAdjustment(1)
.build();
StepScalingPolicyConfiguration stepScalingPolicyConfiguration = StepScalingPolicyConfiguration.newBuilder()
.withAdjustmentType(StepAdjustmentType.ChangeInCapacity)
.withCoolDownSec(60)
.withMetricAggregatorType(MetricAggregationType.Average)
.withMinAdjustmentMagnitude(1)
.withSteps(Arrays.asList(stepAdjustment))
.build();
PolicyConfiguration policyConfiguration = PolicyConfiguration.newBuilder()
.withAlarmConfiguration(alarmConfiguration)
.withStepScalingPolicyConfiguration(stepScalingPolicyConfiguration)
.withPolicyType(PolicyType.StepScaling)
.withName(jobId)
.build();
AutoScalingPolicy autoScalingPolicy = AutoScalingPolicy.newBuilder()
.withPolicyConfiguration(policyConfiguration)
.withStatus(PolicyStatus.Pending)
.withStatusMessage("ICE-ed by AWS")
.withJobId(jobId)
.build();
return autoScalingPolicy;
}
public static AppScaleManagerConfiguration mockAppScaleManagerConfiguration() {
AppScaleManagerConfiguration appScaleManagerConfiguration = mock(AppScaleManagerConfiguration.class);
when(appScaleManagerConfiguration.getReconcileFinishedJobsIntervalMins()).thenReturn(1L);
when(appScaleManagerConfiguration.getReconcileTargetsIntervalMins()).thenReturn(1L);
when(appScaleManagerConfiguration.getStoreInitTimeoutSeconds()).thenReturn(5L);
return appScaleManagerConfiguration;
}
public static boolean waitForCondition(BooleanSupplier booleanSupplier) throws Exception {
int maxChecks = 20;
int i = 0;
while (true) {
if (booleanSupplier.getAsBoolean()) {
return true;
} else {
Thread.sleep(100);
}
if (i++ >= maxChecks) {
return true;
}
}
}
}
| 15 |
0 | Create_ds/titus-control-plane/titus-server-master/src/test/java/com/netflix/titus/master/appscale | Create_ds/titus-control-plane/titus-server-master/src/test/java/com/netflix/titus/master/appscale/service/DefaultAppScaleManagerTest.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.master.appscale.service;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.UUID;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.TimeUnit;
import java.util.stream.Collectors;
import com.netflix.spectator.api.DefaultRegistry;
import com.netflix.titus.api.appscale.model.AutoScalableTarget;
import com.netflix.titus.api.appscale.model.AutoScalingPolicy;
import com.netflix.titus.api.appscale.model.PolicyType;
import com.netflix.titus.api.appscale.service.AutoScalePolicyException;
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.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.event.JobManagerEvent;
import com.netflix.titus.api.jobmanager.model.job.event.JobUpdateEvent;
import com.netflix.titus.api.jobmanager.model.job.ext.ServiceJobExt;
import com.netflix.titus.api.jobmanager.service.V3JobOperations;
import com.netflix.titus.api.model.callmetadata.CallMetadata;
import com.netflix.titus.common.runtime.TitusRuntime;
import com.netflix.titus.runtime.store.v3.memory.InMemoryPolicyStore;
import org.assertj.core.api.Assertions;
import org.junit.Test;
import org.mockito.invocation.InvocationOnMock;
import org.mockito.stubbing.Answer;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import rx.Completable;
import rx.Observable;
import rx.schedulers.Schedulers;
import static com.jayway.awaitility.Awaitility.await;
import static java.util.Arrays.asList;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
public class DefaultAppScaleManagerTest {
private static Logger log = LoggerFactory.getLogger(DefaultAppScaleManagerTest.class);
private CallMetadata callMetadata = CallMetadata.newBuilder().withCallerId("app scale test").build();
@Test
public void checkTargetTrackingPolicy() throws Exception {
checkCreatePolicyFlow(PolicyType.TargetTrackingScaling);
}
@Test
public void checkStepCreatePolicyFlow() throws Exception {
checkCreatePolicyFlow(PolicyType.StepScaling);
}
private void checkCreatePolicyFlow(PolicyType policyType) throws Exception {
// create instance of DefaultAppScaleManager
AutoScalingPolicyTests.MockAlarmClient mockAlarmClient = new AutoScalingPolicyTests.MockAlarmClient();
AutoScalingPolicyTests.MockAppAutoScalingClient mockAppAutoScalingClient = new AutoScalingPolicyTests.MockAppAutoScalingClient();
InMemoryPolicyStore policyStore = new InMemoryPolicyStore();
String jobIdOne = UUID.randomUUID().toString();
String jobIdTwo = UUID.randomUUID().toString();
V3JobOperations v3JobOperations = mockV3Operations(jobIdOne, jobIdTwo);
DefaultAppScaleManager appScaleManager = new DefaultAppScaleManager(policyStore, mockAlarmClient,
mockAppAutoScalingClient,
v3JobOperations,
new DefaultRegistry(),
AutoScalingPolicyTests.mockAppScaleManagerConfiguration(),
Schedulers.immediate(),
mock(TitusRuntime.class));
AutoScalingPolicy autoScalingPolicyOne;
AutoScalingPolicy autoScalingPolicyTwo;
if (policyType == PolicyType.StepScaling) {
autoScalingPolicyOne = AutoScalingPolicyTests.buildStepScalingPolicy(jobIdOne);
autoScalingPolicyTwo = AutoScalingPolicyTests.buildStepScalingPolicy(jobIdTwo);
} else {
autoScalingPolicyOne = AutoScalingPolicyTests.buildTargetTrackingPolicy(jobIdOne);
autoScalingPolicyTwo = AutoScalingPolicyTests.buildTargetTrackingPolicy(jobIdTwo);
}
// call - createAutoScalingPolicy
appScaleManager.createAutoScalingPolicy(autoScalingPolicyOne).toBlocking().single();
String policyRefIdTwo = appScaleManager.createAutoScalingPolicy(autoScalingPolicyTwo).toBlocking().single();
AutoScalingPolicyTests.waitForCondition(() -> {
List<AutoScalingPolicy> policies = policyStore.retrievePolicies(false).toList().toBlocking().first();
return policies.size() == 2 && mockAppAutoScalingClient.getNumPolicies() == 2
&& mockAppAutoScalingClient.getNumScalableTargets() == 2;
});
// verify counts in CloudAlarmClient, AppAutoScaleClient and AppScalePolicyStore
List<AutoScalingPolicy> policiesStored = policyStore.retrievePolicies(false).toList().toBlocking().first();
Assertions.assertThat(policiesStored.size()).isEqualTo(2);
Assertions.assertThat(mockAppAutoScalingClient.getNumPolicies()).isEqualTo(2);
Assertions.assertThat(mockAppAutoScalingClient.getNumScalableTargets()).isEqualTo(2);
if (policyType == PolicyType.StepScaling) {
Assertions.assertThat(mockAlarmClient.getNumOfAlarmsCreated()).isEqualTo(2);
}
appScaleManager.removeAutoScalingPolicy(policyRefIdTwo).await();
AutoScalingPolicyTests.waitForCondition(() -> {
List<AutoScalingPolicy> policies = policyStore.retrievePolicies(false).toList().toBlocking().first();
return policies.size() == 1 && mockAppAutoScalingClient.getNumPolicies() == 1
&& mockAppAutoScalingClient.getNumScalableTargets() == 1;
});
// verify counts in CloudAlarmClient, AppAutoScaleClient and AppScalePolicyStore
policiesStored = policyStore.retrievePolicies(false).toList().toBlocking().first();
Assertions.assertThat(policiesStored.size()).isEqualTo(1);
Assertions.assertThat(mockAppAutoScalingClient.getNumPolicies()).isEqualTo(1);
Assertions.assertThat(mockAppAutoScalingClient.getNumScalableTargets()).isEqualTo(1);
if (policyType == PolicyType.StepScaling) {
Assertions.assertThat(mockAlarmClient.getNumOfAlarmsCreated()).isEqualTo(1);
}
}
@Test
public void checkV3LiveStreamTargetUpdates() throws Exception {
String jobIdOne = UUID.randomUUID().toString();
String jobIdTwo = UUID.randomUUID().toString();
InMemoryPolicyStore policyStore = new InMemoryPolicyStore();
V3JobOperations v3JobOperations = mockV3Operations(jobIdOne, jobIdTwo);
AppScaleClientWithScalingPolicyConstraints appScalingClient = new AppScaleClientWithScalingPolicyConstraints();
DefaultAppScaleManager appScaleManager = new DefaultAppScaleManager(policyStore,
new AutoScalingPolicyTests.MockAlarmClient(),
appScalingClient,
v3JobOperations,
new DefaultRegistry(),
AutoScalingPolicyTests.mockAppScaleManagerConfiguration(),
Schedulers.immediate(),
mock(TitusRuntime.class));
List<String> refIds = submitTwoJobs(appScaleManager, jobIdOne, jobIdTwo, policyStore);
Assertions.assertThat(refIds.size()).isEqualTo(2);
CountDownLatch latch = new CountDownLatch(1);
Observable<String> jobIdTargetUpdates = appScaleManager.v3LiveStreamTargetUpdates();
List<String> targetsUpdated = new ArrayList<>();
jobIdTargetUpdates.subscribe(targetUpdated -> {
log.info("Got ScalableTarget to be updated {}", targetUpdated);
Assertions.assertThat(targetUpdated).isEqualTo(jobIdTwo);
targetsUpdated.add(targetUpdated);
latch.countDown();
},
e -> log.error("Error in v2 live stream for scalable target update", e),
() -> log.info("Completed"));
latch.await(60, TimeUnit.SECONDS);
AutoScalingPolicyTests.waitForCondition(() -> {
JobScalingConstraints jpc = appScalingClient.getJobScalingPolicyConstraintsForJob(jobIdTwo);
return jpc != null && jpc.getMinCapacity() == 5 && jpc.getMaxCapacity() == 15;
});
Assertions.assertThat(targetsUpdated.size()).isEqualTo(1);
Assertions.assertThat(appScalingClient.getJobScalingPolicyConstraintsForJob(jobIdOne).getMinCapacity()).isEqualTo(1);
Assertions.assertThat(appScalingClient.getJobScalingPolicyConstraintsForJob(jobIdOne).getMaxCapacity()).isEqualTo(10);
Assertions.assertThat(appScalingClient.getJobScalingPolicyConstraintsForJob(jobIdTwo).getMinCapacity()).isEqualTo(5);
Assertions.assertThat(appScalingClient.getJobScalingPolicyConstraintsForJob(jobIdTwo).getMaxCapacity()).isEqualTo(15);
}
@Test
public void checkASGNameBuildingV3() {
JobGroupInfo jobGroupInfoOne = JobGroupInfo.newBuilder()
.withDetail("^1.0.0")
.withSequence("v001")
.withStack("main")
.build();
JobDescriptor<JobDescriptor.JobDescriptorExt> jobDescriptorOne = JobDescriptor.newBuilder()
.withApplicationName("testapp")
.withJobGroupInfo(jobGroupInfoOne).build();
String autoScalingGroup = DefaultAppScaleManager.buildAutoScalingGroupV3(jobDescriptorOne);
Assertions.assertThat(autoScalingGroup).isEqualTo("testapp-main-^1.0.0-v001");
JobGroupInfo jobGroupInfoTwo = JobGroupInfo.newBuilder()
.withDetail("^1.0.0")
.withStack("main")
.build();
JobDescriptor<JobDescriptor.JobDescriptorExt> jobDescriptorTwo = JobDescriptor.newBuilder()
.withApplicationName("testapp")
.withJobGroupInfo(jobGroupInfoTwo).build();
autoScalingGroup = DefaultAppScaleManager.buildAutoScalingGroupV3(jobDescriptorTwo);
Assertions.assertThat(autoScalingGroup).isEqualTo("testapp-main-^1.0.0-v000");
JobGroupInfo jobGroupInfoThree = JobGroupInfo.newBuilder()
.withDetail("^1.0.0")
.build();
JobDescriptor<JobDescriptor.JobDescriptorExt> jobDescriptorThree = JobDescriptor.newBuilder()
.withApplicationName("testapp")
.withJobGroupInfo(jobGroupInfoThree).build();
autoScalingGroup = DefaultAppScaleManager.buildAutoScalingGroupV3(jobDescriptorThree);
Assertions.assertThat(autoScalingGroup).isEqualTo("testapp--^1.0.0-v000");
JobGroupInfo jobGroupInfoFour = JobGroupInfo.newBuilder().build();
JobDescriptor<JobDescriptor.JobDescriptorExt> jobDescriptorFour = JobDescriptor.newBuilder()
.withApplicationName("testapp")
.withJobGroupInfo(jobGroupInfoFour).build();
autoScalingGroup = DefaultAppScaleManager.buildAutoScalingGroupV3(jobDescriptorFour);
Assertions.assertThat(autoScalingGroup).isEqualTo("testapp-v000");
JobGroupInfo jobGroupInfoFive = JobGroupInfo.newBuilder()
.withDetail("titus")
.withSequence("v038")
.build();
JobDescriptor<JobDescriptor.JobDescriptorExt> jobDescriptorFive = JobDescriptor.newBuilder()
.withApplicationName("tbd")
.withJobGroupInfo(jobGroupInfoFive)
.build();
autoScalingGroup = DefaultAppScaleManager.buildAutoScalingGroupV3(jobDescriptorFive);
Assertions.assertThat(autoScalingGroup).isEqualTo("tbd--titus-v038");
}
@Test
public void checkNestedExceptionHandling() throws Exception {
RuntimeException exceptionContainingUnknownPolicy =
new RuntimeException
(new RuntimeException(
new RuntimeException(
new RuntimeException(AutoScalePolicyException.unknownScalingPolicy("policyId", "Not found")))));
Optional<AutoScalePolicyException> autoScalePolicyException = DefaultAppScaleManager.extractAutoScalePolicyException(exceptionContainingUnknownPolicy);
AutoScalingPolicyTests.waitForCondition(() -> autoScalePolicyException.isPresent());
Assertions.assertThat(autoScalePolicyException.isPresent()).isTrue();
AutoScalingPolicyTests.waitForCondition(() -> autoScalePolicyException.get().getErrorCode() == AutoScalePolicyException.ErrorCode.UnknownScalingPolicy);
Assertions.assertThat(autoScalePolicyException.get().getErrorCode()).isEqualTo(AutoScalePolicyException.ErrorCode.UnknownScalingPolicy);
RuntimeException runtimeException = new RuntimeException(new RuntimeException(new Exception("Bad input")));
Optional<AutoScalePolicyException> notAutoScalePolicyException = DefaultAppScaleManager.extractAutoScalePolicyException(runtimeException);
AutoScalingPolicyTests.waitForCondition(() -> !notAutoScalePolicyException.isPresent());
Assertions.assertThat(notAutoScalePolicyException.isPresent()).isFalse();
}
@Test
public void checkBulkPolicyCreations() {
AutoScalingPolicyTests.MockAlarmClient mockAlarmClient = new AutoScalingPolicyTests.MockAlarmClient();
AutoScalingPolicyTests.MockAppAutoScalingClient mockAppAutoScalingClient = new AutoScalingPolicyTests.MockAppAutoScalingClient();
InMemoryPolicyStore policyStore = new InMemoryPolicyStore();
final int totalJobs = 300;
List<String> jobIds = new ArrayList<>(totalJobs);
for (int i = 0; i < totalJobs; i++) {
String jobId = UUID.randomUUID().toString();
jobIds.add(jobId);
}
V3JobOperations v3JobOperations = mockV3OperationsForJobs(jobIds);
DefaultAppScaleManager appScaleManager = new DefaultAppScaleManager(policyStore, mockAlarmClient,
mockAppAutoScalingClient,
v3JobOperations,
new DefaultRegistry(),
AutoScalingPolicyTests.mockAppScaleManagerConfiguration(),
Schedulers.computation(),
mock(TitusRuntime.class));
final CountDownLatch latch = new CountDownLatch(totalJobs);
for (int i = 0; i < totalJobs; i++) {
final AutoScalingPolicy autoScalingPolicy = AutoScalingPolicyTests.buildStepScalingPolicy(jobIds.get(i));
appScaleManager.createAutoScalingPolicy(autoScalingPolicy).subscribe(pid -> {
log.info("Policy created {}", pid);
latch.countDown();
});
}
await().timeout(30, TimeUnit.SECONDS).until(() -> mockAppAutoScalingClient.getNumPolicies() == totalJobs);
}
public static class AppScaleClientWithScalingPolicyConstraints extends AutoScalingPolicyTests.MockAppAutoScalingClient {
Map<String, JobScalingConstraints> scalingPolicyConstraints;
AppScaleClientWithScalingPolicyConstraints() {
scalingPolicyConstraints = new ConcurrentHashMap<>();
}
@Override
public Completable createScalableTarget(String jobId, int minCapacity, int maxCapacity) {
JobScalingConstraints jobScalingConstraints = new JobScalingConstraints(minCapacity, maxCapacity);
scalingPolicyConstraints.put(jobId, new JobScalingConstraints(minCapacity, maxCapacity));
return super.createScalableTarget(jobId, jobScalingConstraints.getMinCapacity(), jobScalingConstraints.getMaxCapacity());
}
@Override
public Observable<AutoScalableTarget> getScalableTargetsForJob(String jobId) {
if (scalingPolicyConstraints.containsKey(jobId)) {
JobScalingConstraints jobScalingConstraints = scalingPolicyConstraints.get(jobId);
AutoScalableTarget autoScalableTarget = AutoScalableTarget.newBuilder()
.withMinCapacity(jobScalingConstraints.getMinCapacity())
.withMaxCapacity(jobScalingConstraints.getMaxCapacity())
.withResourceId(jobId)
.build();
return Observable.just(autoScalableTarget);
}
return super.getScalableTargetsForJob(jobId);
}
JobScalingConstraints getJobScalingPolicyConstraintsForJob(String jobId) {
return scalingPolicyConstraints.get(jobId);
}
}
private List<String> submitTwoJobs(DefaultAppScaleManager appScaleManager, String jobIdOne, String jobIdTwo,
InMemoryPolicyStore policyStore) throws Exception {
// call - createAutoScalingPolicy
AutoScalingPolicy autoScalingPolicyOne = AutoScalingPolicyTests.buildStepScalingPolicy(jobIdOne);
appScaleManager.createAutoScalingPolicy(autoScalingPolicyOne).toBlocking().single();
// call - createAutoScalingPolicy
AutoScalingPolicy autoScalingPolicyTwo = AutoScalingPolicyTests.buildStepScalingPolicy(jobIdTwo);
appScaleManager.createAutoScalingPolicy(autoScalingPolicyTwo).toBlocking().single();
// call - processPendingPolicies
List<AutoScalingPolicy> savedPolicies = policyStore.retrievePolicies(false).toList().toBlocking().first();
AutoScalingPolicyTests.waitForCondition(() -> savedPolicies.size() == 2);
Assertions.assertThat(savedPolicies.size()).isEqualTo(2);
return savedPolicies.stream().map(policy -> policy.getRefId()).collect(Collectors.toList());
}
private JobGroupInfo buildMockJobGroupInfo(String jobId) {
JobGroupInfo jobGroupInfo = mock(JobGroupInfo.class);
when(jobGroupInfo.getDetail()).thenReturn("ii" + jobId);
when(jobGroupInfo.getStack()).thenReturn("test");
when(jobGroupInfo.getSequence()).thenReturn("001");
return jobGroupInfo;
}
private V3JobOperations mockV3OperationsForJobs(List<String> jobIds) {
V3JobOperations v3JobOperations = mock(V3JobOperations.class);
for (String jobId : jobIds) {
// FIXME Use JobGenerator instead of mocking.
Job job = mock(Job.class);
when(job.getId()).thenReturn(jobId);
JobDescriptor jobDescriptorOne = mock(JobDescriptor.class);
ServiceJobExt serviceJobExtOne = mock(ServiceJobExt.class);
JobGroupInfo jobGroupInfoOne = buildMockJobGroupInfo(jobId);
Capacity capacityOne = mock(Capacity.class);
when(capacityOne.getMax()).thenReturn(10);
when(capacityOne.getMin()).thenReturn(1);
when(serviceJobExtOne.getCapacity()).thenReturn(capacityOne);
when(jobDescriptorOne.getExtensions()).thenReturn(serviceJobExtOne);
when(job.getJobDescriptor()).thenReturn(jobDescriptorOne);
when(jobDescriptorOne.getJobGroupInfo()).thenReturn(jobGroupInfoOne);
when(jobDescriptorOne.getApplicationName()).thenReturn("testApp");
when(v3JobOperations.getJob(jobId)).thenReturn(Optional.of(job));
JobManagerEvent<?> jobUpdateEvent = JobUpdateEvent.newJob(job, callMetadata);
when(v3JobOperations.observeJobs()).thenAnswer(invocation -> Observable.from(asList(jobUpdateEvent)));
}
return v3JobOperations;
}
private V3JobOperations mockV3Operations(String jobIdOne, String jobIdTwo) {
V3JobOperations v3JobOperations = mock(V3JobOperations.class);
// FIXME Use JobGenerator instead of mocking.
Job jobOne = mock(Job.class);
when(jobOne.getId()).thenReturn(jobIdOne);
JobDescriptor jobDescriptorOne = mock(JobDescriptor.class);
ServiceJobExt serviceJobExtOne = mock(ServiceJobExt.class);
JobGroupInfo jobGroupInfoOne = buildMockJobGroupInfo(jobIdOne);
Capacity capacityOne = mock(Capacity.class);
when(capacityOne.getMax()).thenReturn(10);
when(capacityOne.getMin()).thenReturn(1);
when(serviceJobExtOne.getCapacity()).thenReturn(capacityOne);
when(jobDescriptorOne.getExtensions()).thenReturn(serviceJobExtOne);
when(jobOne.getJobDescriptor()).thenReturn(jobDescriptorOne);
when(jobDescriptorOne.getJobGroupInfo()).thenReturn(jobGroupInfoOne);
when(jobDescriptorOne.getApplicationName()).thenReturn("testApp1");
Job jobTwo = mock(Job.class);
when(jobTwo.getId()).thenReturn(jobIdTwo);
JobDescriptor jobDescriptorTwo = mock(JobDescriptor.class);
ServiceJobExt serviceJobExtTwo = mock(ServiceJobExt.class);
Capacity capacityJobTwo = mock(Capacity.class);
when(capacityJobTwo.getMin())
.thenAnswer(new Answer<Integer>() {
private int count = 0;
@Override
public Integer answer(InvocationOnMock invocation) throws Throwable {
if (count++ < 2) {
return 1;
} else {
return 5;
}
}
});
when(capacityJobTwo.getMax()).thenAnswer(new Answer<Integer>() {
private int count = 0;
@Override
public Integer answer(InvocationOnMock invocation) throws Throwable {
if (count++ < 2) {
return 10;
} else {
return 15;
}
}
});
when(serviceJobExtTwo.getCapacity()).thenReturn(capacityJobTwo);
when(jobDescriptorTwo.getExtensions()).thenReturn(serviceJobExtTwo);
when(jobDescriptorTwo.getJobGroupInfo()).thenReturn(jobGroupInfoOne);
when(jobDescriptorTwo.getApplicationName()).thenReturn("testApp2");
when(jobTwo.getJobDescriptor()).thenReturn(jobDescriptorTwo);
when(jobTwo.getStatus()).thenReturn(JobModel.newJobStatus().withState(JobState.Accepted).build());
when(v3JobOperations.getJob(jobIdOne)).thenReturn(Optional.of(jobOne));
when(v3JobOperations.getJob(jobIdTwo)).thenReturn(Optional.of(jobTwo));
JobManagerEvent<?> jobUpdateEvent = JobUpdateEvent.newJob(jobTwo, callMetadata);
when(v3JobOperations.observeJobs()).thenAnswer(invocation -> Observable.from(asList(jobUpdateEvent)));
return v3JobOperations;
}
}
| 16 |
0 | Create_ds/titus-control-plane/titus-server-master/src/test/java/com/netflix/titus/master/supervisor | Create_ds/titus-control-plane/titus-server-master/src/test/java/com/netflix/titus/master/supervisor/service/DefaultSupervisorOperationsTest.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.master.supervisor.service;
import java.util.List;
import com.netflix.governator.LifecycleManager;
import com.netflix.titus.api.supervisor.service.LeaderActivator;
import com.netflix.titus.api.supervisor.service.MasterMonitor;
import com.netflix.titus.common.data.generator.MutableDataGenerator;
import com.netflix.titus.common.runtime.TitusRuntime;
import com.netflix.titus.common.runtime.TitusRuntimes;
import com.netflix.titus.api.supervisor.model.MasterInstance;
import com.netflix.titus.api.supervisor.model.MasterState;
import com.netflix.titus.api.supervisor.model.event.MasterInstanceRemovedEvent;
import com.netflix.titus.api.supervisor.model.event.MasterInstanceUpdateEvent;
import com.netflix.titus.api.supervisor.model.event.SupervisorEvent;
import com.netflix.titus.testkit.model.supervisor.MasterInstanceGenerator;
import com.netflix.titus.testkit.rx.ExtTestSubscriber;
import org.junit.Before;
import org.junit.Test;
import rx.subjects.PublishSubject;
import static com.netflix.titus.testkit.model.supervisor.MasterInstanceGenerator.masterInstances;
import static java.util.Arrays.asList;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
public class DefaultSupervisorOperationsTest {
private final TitusRuntime titusRuntime = TitusRuntimes.test();
private final MasterMonitor masterMonitor = mock(MasterMonitor.class);
private final PublishSubject<List<MasterInstance>> masterMonitorSubject = PublishSubject.create();
private LeaderActivator leaderActivator = mock(LeaderActivator.class);
private DefaultSupervisorOperations supervisorOperations;
@Before
public void setUp() throws Exception {
when(masterMonitor.observeMasters()).thenReturn(masterMonitorSubject);
supervisorOperations = new DefaultSupervisorOperations(new LifecycleManager(), masterMonitor, leaderActivator, titusRuntime);
}
@Test
public void testEventStream() {
ExtTestSubscriber<SupervisorEvent> eventSubscriber = new ExtTestSubscriber<>();
supervisorOperations.events().subscribe(eventSubscriber);
List<MasterInstance> initialInstances = new MutableDataGenerator<>(
masterInstances(MasterState.Starting, "id1", "id2", "id3")
).getValues(3);
// Initial set
for (int i = 0; i < 3; i++) {
masterMonitorSubject.onNext(initialInstances.subList(0, i + 1));
expectMasterInstanceUpdateEvent(eventSubscriber, initialInstances.get(i));
}
// Change state of first instance
List<MasterInstance> firstUpdated = asList(
MasterInstanceGenerator.moveTo(initialInstances.get(0), MasterState.NonLeader),
initialInstances.get(1),
initialInstances.get(2)
);
masterMonitorSubject.onNext(firstUpdated);
expectMasterInstanceUpdateEvent(eventSubscriber, firstUpdated.get(0));
// Remove last instance
masterMonitorSubject.onNext(firstUpdated.subList(0, 2));
expectMasterInstanceRemovedEvent(eventSubscriber, firstUpdated.get(2));
}
private void expectMasterInstanceUpdateEvent(ExtTestSubscriber<SupervisorEvent> eventSubscriber, MasterInstance instance) {
SupervisorEvent event = eventSubscriber.takeNext();
assertThat(event).isInstanceOf(MasterInstanceUpdateEvent.class);
MasterInstanceUpdateEvent updateEvent = (MasterInstanceUpdateEvent) event;
assertThat(updateEvent.getMasterInstance()).isEqualTo(instance);
}
private void expectMasterInstanceRemovedEvent(ExtTestSubscriber<SupervisorEvent> eventSubscriber, MasterInstance removed) {
SupervisorEvent event = eventSubscriber.takeNext();
assertThat(event).isInstanceOf(MasterInstanceRemovedEvent.class);
MasterInstanceRemovedEvent removedEvent = (MasterInstanceRemovedEvent) event;
assertThat(removedEvent.getMasterInstance()).isEqualTo(removed);
}
} | 17 |
0 | Create_ds/titus-control-plane/titus-server-master/src/test/java/com/netflix/titus/master/supervisor/service | Create_ds/titus-control-plane/titus-server-master/src/test/java/com/netflix/titus/master/supervisor/service/leader/LeaderElectionOrchestratorTest.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.master.supervisor.service.leader;
import com.netflix.titus.api.supervisor.model.MasterInstance;
import com.netflix.titus.api.supervisor.model.MasterState;
import com.netflix.titus.api.supervisor.service.LeaderElector;
import com.netflix.titus.api.supervisor.service.LocalMasterInstanceResolver;
import com.netflix.titus.api.supervisor.service.MasterMonitor;
import com.netflix.titus.common.runtime.TitusRuntime;
import com.netflix.titus.common.runtime.TitusRuntimes;
import com.netflix.titus.master.supervisor.SupervisorConfiguration;
import com.netflix.titus.testkit.model.supervisor.MasterInstanceGenerator;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import org.mockito.ArgumentCaptor;
import org.mockito.InOrder;
import org.mockito.Mockito;
import reactor.core.publisher.DirectProcessor;
import rx.Completable;
import rx.schedulers.Schedulers;
import rx.schedulers.TestScheduler;
import rx.subjects.PublishSubject;
import static com.netflix.titus.testkit.model.supervisor.MasterInstanceGenerator.moveTo;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.Mockito.inOrder;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
public class LeaderElectionOrchestratorTest {
private final TestScheduler testScheduler = Schedulers.test();
private final TitusRuntime titusRuntime = TitusRuntimes.test(testScheduler);
private final SupervisorConfiguration configuration = mock(SupervisorConfiguration.class);
private final LocalMasterInstanceResolver localMasterInstanceResolver = mock(LocalMasterInstanceResolver.class);
private final DirectProcessor<MasterInstance> localMasterUpdates = DirectProcessor.create();
private final MasterMonitor masterMonitor = mock(MasterMonitor.class);
private final InOrder masterMonitorInOrder = inOrder(masterMonitor);
private final LeaderElector leaderElector = mock(LeaderElector.class);
private final PublishSubject<MasterState> leaderUpdates = PublishSubject.create();
private LeaderElectionOrchestrator orchestrator;
private MasterInstance localMasterInstance = MasterInstanceGenerator.getLocalMasterInstance(MasterState.Starting);
@Before
public void setUp() throws Exception {
when(localMasterInstanceResolver.observeLocalMasterInstanceUpdates()).thenReturn(localMasterUpdates);
when(leaderElector.awaitElection()).thenReturn(leaderUpdates);
resetMasterMonitor();
orchestrator = new LeaderElectionOrchestrator(
configuration,
localMasterInstanceResolver,
masterMonitor,
leaderElector,
localMasterInstance,
titusRuntime,
testScheduler
);
verify(masterMonitor, times(1)).updateOwnMasterInstance(localMasterInstance);
resetMasterMonitor();
}
@After
public void tearDown() {
if (orchestrator != null) {
orchestrator.shutdown();
}
}
@Test
public void testForceLeaderElection() {
when(configuration.isForceLeaderElectionEnabled()).thenReturn(true);
orchestrator = new LeaderElectionOrchestrator(
configuration,
localMasterInstanceResolver,
masterMonitor,
leaderElector,
localMasterInstance,
titusRuntime,
testScheduler
);
verify(leaderElector, times(1)).join();
}
@Test
public void testBootstrapSequence() {
// Change state to 'NonLeader'
localMasterUpdates.onNext((localMasterInstance = moveTo(localMasterInstance, MasterState.NonLeader)));
masterMonitorInOrder.verify(masterMonitor, times(1)).updateOwnMasterInstance(localMasterInstance);
verify(leaderElector, times(1)).join();
// Start leader activation process
leaderUpdates.onNext(MasterState.LeaderActivating);
verifyUpdatedOwnInstanceTo(MasterState.LeaderActivating);
// Move to the activated state
leaderUpdates.onNext(MasterState.LeaderActivated);
verifyUpdatedOwnInstanceTo(MasterState.LeaderActivated);
}
@Test
public void testDeactivation() {
// Change state to 'NonLeader'
localMasterUpdates.onNext((localMasterInstance = moveTo(localMasterInstance, MasterState.NonLeader)));
masterMonitorInOrder.verify(masterMonitor, times(1)).updateOwnMasterInstance(localMasterInstance);
verify(leaderElector, times(1)).join();
// Change back to 'Inactive'
localMasterUpdates.onNext((localMasterInstance = moveTo(localMasterInstance, MasterState.Inactive)));
masterMonitorInOrder.verify(masterMonitor, times(1)).updateOwnMasterInstance(localMasterInstance);
verify(leaderElector, times(1)).leaveIfNotLeader();
}
private void resetMasterMonitor() {
Mockito.reset(masterMonitor);
when(masterMonitor.getCurrentMasterInstance()).thenAnswer(invocation -> localMasterInstance);
when(masterMonitor.updateOwnMasterInstance(any())).thenReturn(Completable.complete());
}
private void verifyUpdatedOwnInstanceTo(MasterState expectedState) {
ArgumentCaptor<MasterInstance> captor = ArgumentCaptor.forClass(MasterInstance.class);
masterMonitorInOrder.verify(masterMonitor, times(1)).updateOwnMasterInstance(captor.capture());
assertThat(captor.getValue().getStatus().getState()).isEqualTo(expectedState);
}
} | 18 |
0 | Create_ds/titus-control-plane/titus-server-master/src/test/java/com/netflix/titus/master/supervisor/service | Create_ds/titus-control-plane/titus-server-master/src/test/java/com/netflix/titus/master/supervisor/service/resolver/HealthLocalMasterReadinessResolverTest.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.master.supervisor.service.resolver;
import java.time.Duration;
import java.util.Collections;
import java.util.Iterator;
import java.util.concurrent.CompletableFuture;
import com.netflix.runtime.health.api.HealthCheckAggregator;
import com.netflix.runtime.health.api.HealthCheckStatus;
import com.netflix.titus.api.supervisor.model.ReadinessState;
import com.netflix.titus.api.supervisor.model.ReadinessStatus;
import com.netflix.titus.common.runtime.TitusRuntime;
import com.netflix.titus.common.runtime.TitusRuntimes;
import org.junit.Before;
import org.junit.Test;
import reactor.core.scheduler.Schedulers;
import static com.jayway.awaitility.Awaitility.await;
import static com.netflix.titus.master.supervisor.service.resolver.HealthLocalMasterReadinessResolver.REFRESH_SCHEDULER_DESCRIPTOR;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
public class HealthLocalMasterReadinessResolverTest {
private static final HealthCheckStatus HEALTHY = new HealthCheckStatus(true, Collections.emptyList());
private static final HealthCheckStatus UNHEALTHY = new HealthCheckStatus(false, Collections.emptyList());
private final TitusRuntime titusRuntime = TitusRuntimes.internal();
private final HealthCheckAggregator healthcheck = mock(HealthCheckAggregator.class);
private HealthLocalMasterReadinessResolver resolver;
private volatile HealthCheckStatus currentHealthStatus = HEALTHY;
private volatile Throwable simulatedError;
private volatile int invocationCounter;
@Before
public void setUp() throws Exception {
when(healthcheck.check()).thenAnswer(invocation -> {
CompletableFuture<HealthCheckStatus> future = new CompletableFuture<>();
if (simulatedError != null) {
future.completeExceptionally(new RuntimeException("simulated error"));
} else if (currentHealthStatus != null) {
future.complete(currentHealthStatus);
} // else never complete
invocationCounter++;
return future;
});
this.resolver = new HealthLocalMasterReadinessResolver(
healthcheck,
REFRESH_SCHEDULER_DESCRIPTOR.toBuilder()
.withInterval(Duration.ofMillis(1))
.withTimeout(Duration.ofMillis(1))
.build(),
titusRuntime,
Schedulers.parallel()
);
}
@Test(timeout = 30_000)
public void testResolve() {
Iterator<ReadinessStatus> it = newStreamInitiallyHealthy();
// Change to unhealthy
currentHealthStatus = UNHEALTHY;
await().until(() -> it.next().getState() == ReadinessState.Disabled);
// Back to healthy
currentHealthStatus = HEALTHY;
await().until(() -> it.next().getState() == ReadinessState.Enabled);
}
@Test(timeout = 30_000)
public void testError() {
Iterator<ReadinessStatus> it = newStreamInitiallyHealthy();
// Simulate error (no change expected)
simulatedError = new RuntimeException("simulated error");
int currentCounter = invocationCounter;
await().until(() -> invocationCounter > currentCounter);
// Change state
currentHealthStatus = UNHEALTHY;
simulatedError = null;
await().until(() -> it.next().getState() == ReadinessState.Disabled);
}
@Test(timeout = 30_000)
public void testTimeout() {
Iterator<ReadinessStatus> it = newStreamInitiallyHealthy();
// Trigger timeout
currentHealthStatus = null;
int currentCounter = invocationCounter;
await().until(() -> invocationCounter > (currentCounter + 1));
// Change state
currentHealthStatus = UNHEALTHY;
await().until(() -> it.next().getState() == ReadinessState.Disabled);
}
private Iterator<ReadinessStatus> newStreamInitiallyHealthy() {
// Starts healthy
Iterator<ReadinessStatus> it = resolver.observeLocalMasterReadinessUpdates().toIterable().iterator();
ReadinessState first = it.next().getState();
if (first == ReadinessState.NotReady) {
assertThat(it.next().getState()).isEqualTo(ReadinessState.Enabled);
} else {
assertThat(first).isEqualTo(ReadinessState.Enabled);
}
return it;
}
} | 19 |
0 | Create_ds/titus-control-plane/titus-server-master/src/test/java/com/netflix/titus/master/supervisor/service | Create_ds/titus-control-plane/titus-server-master/src/test/java/com/netflix/titus/master/supervisor/service/resolver/DefaultLocalMasterInstanceResolverTest.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.master.supervisor.service.resolver;
import java.util.Iterator;
import com.netflix.titus.api.supervisor.model.MasterInstance;
import com.netflix.titus.api.supervisor.model.MasterState;
import com.netflix.titus.api.supervisor.model.ReadinessState;
import com.netflix.titus.api.supervisor.model.ReadinessStatus;
import com.netflix.titus.api.supervisor.service.LocalMasterReadinessResolver;
import com.netflix.titus.testkit.model.supervisor.MasterInstanceGenerator;
import org.junit.Before;
import org.junit.Test;
import reactor.core.publisher.EmitterProcessor;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
public class DefaultLocalMasterInstanceResolverTest {
private final LocalMasterReadinessResolver localMasterReadinessResolver = mock(LocalMasterReadinessResolver.class);
private MasterInstance initial = MasterInstanceGenerator.masterInstances(MasterState.Starting, "testId").getValue();
private DefaultLocalMasterInstanceResolver resolver;
private final EmitterProcessor<ReadinessStatus> readinessUpdatesProcessor = EmitterProcessor.create(1);
@Before
public void setUp() throws Exception {
when(localMasterReadinessResolver.observeLocalMasterReadinessUpdates()).thenReturn(readinessUpdatesProcessor);
resolver = new DefaultLocalMasterInstanceResolver(localMasterReadinessResolver, initial);
}
@Test(timeout = 30_000)
public void testResolver() {
Iterator<MasterInstance> it = resolver.observeLocalMasterInstanceUpdates().toIterable().iterator();
readinessUpdatesProcessor.onNext(newReadinessStatus(ReadinessState.NotReady));
assertThat(it.next().getStatus().getState()).isEqualTo(MasterState.Starting);
readinessUpdatesProcessor.onNext(newReadinessStatus(ReadinessState.Enabled));
assertThat(it.next().getStatus().getState()).isEqualTo(MasterState.NonLeader);
}
private ReadinessStatus newReadinessStatus(ReadinessState state) {
return ReadinessStatus.newBuilder()
.withState(state)
.withMessage("Test")
.build();
}
} | 20 |
0 | Create_ds/titus-control-plane/titus-server-master/src/test/java/com/netflix/titus/master/supervisor/service | Create_ds/titus-control-plane/titus-server-master/src/test/java/com/netflix/titus/master/supervisor/service/resolver/OnOffLocalMasterReadinessResolverTest.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.master.supervisor.service.resolver;
import java.time.Duration;
import java.util.function.Supplier;
import com.netflix.titus.api.supervisor.model.ReadinessState;
import com.netflix.titus.api.supervisor.model.ReadinessStatus;
import com.netflix.titus.api.supervisor.service.LocalMasterReadinessResolver;
import org.junit.Before;
import org.junit.Test;
import org.mockito.Mockito;
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.when;
public class OnOffLocalMasterReadinessResolverTest {
private static final ReadinessStatus TURNED_OFF = ReadinessStatus.newBuilder().withState(ReadinessState.Disabled).withMessage("Turned off").build();
private static final Duration CHECK_INTERVAL = Duration.ofMillis(1);
private LocalMasterReadinessResolver delegate = Mockito.mock(LocalMasterReadinessResolver.class);
private volatile boolean currentIsOn = true;
private Supplier<Boolean> isOnSupplier = () -> currentIsOn;
private Supplier<ReadinessStatus> enforcedStatusSupplier = () -> TURNED_OFF;
private final EmitterProcessor<ReadinessStatus> delegateUpdatesProcessor = EmitterProcessor.create();
@Before
public void setUp() throws Exception {
when(delegate.observeLocalMasterReadinessUpdates()).thenReturn(delegateUpdatesProcessor);
}
private Flux<ReadinessStatus> newResolverStream() {
return new OnOffLocalMasterReadinessResolver(delegate, isOnSupplier, enforcedStatusSupplier, CHECK_INTERVAL, Schedulers.parallel()).observeLocalMasterReadinessUpdates();
}
@Test
public void testOverride() {
StepVerifier.withVirtualTime(this::newResolverStream)
.then(() -> emitDelegateStateUpdate(ReadinessState.NotReady))
.assertNext(status -> assertThat(status.getState()).isEqualTo(ReadinessState.NotReady))
// Enable
.then(() -> emitDelegateStateUpdate(ReadinessState.Enabled))
.assertNext(status -> assertThat(status.getState()).isEqualTo(ReadinessState.Enabled))
// Turn off
.then(() -> currentIsOn = false)
.thenAwait(CHECK_INTERVAL)
.assertNext(status -> assertThat(status.getState()).isEqualTo(ReadinessState.Disabled))
// Turn back on
.then(() -> currentIsOn = true)
.thenAwait(CHECK_INTERVAL)
.assertNext(status -> assertThat(status.getState()).isEqualTo(ReadinessState.Enabled))
.thenCancel()
.verify();
}
private void emitDelegateStateUpdate(ReadinessState state) {
delegateUpdatesProcessor.onNext(ReadinessStatus.newBuilder().withState(state).build());
}
} | 21 |
0 | Create_ds/titus-control-plane/titus-server-master/src/test/java/com/netflix/titus/master/eviction | Create_ds/titus-control-plane/titus-server-master/src/test/java/com/netflix/titus/master/eviction/integration/EvictionComponentIntegrationTest.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.master.eviction.integration;
import java.util.Collections;
import java.util.Iterator;
import java.util.concurrent.TimeUnit;
import com.jayway.awaitility.Awaitility;
import com.jayway.awaitility.core.ConditionFactory;
import com.netflix.titus.api.jobmanager.model.job.JobDescriptor;
import com.netflix.titus.api.jobmanager.model.job.ext.BatchJobExt;
import com.netflix.titus.grpc.protogen.EvictionQuota;
import com.netflix.titus.grpc.protogen.EvictionServiceEvent;
import com.netflix.titus.grpc.protogen.EvictionServiceGrpc.EvictionServiceBlockingStub;
import com.netflix.titus.grpc.protogen.ObserverEventRequest;
import com.netflix.titus.grpc.protogen.Reference;
import com.netflix.titus.grpc.protogen.TaskStatus;
import com.netflix.titus.master.eviction.service.quota.system.SystemDisruptionBudgetDescriptor;
import com.netflix.titus.master.integration.BaseIntegrationTest;
import com.netflix.titus.master.integration.v3.scenario.JobScenarioBuilder;
import com.netflix.titus.master.integration.v3.scenario.JobsScenarioBuilder;
import com.netflix.titus.master.integration.v3.scenario.ScenarioTemplates;
import com.netflix.titus.master.integration.v3.scenario.TaskScenarioBuilder;
import com.netflix.titus.testkit.embedded.cell.EmbeddedTitusCell;
import com.netflix.titus.testkit.embedded.cell.master.EmbeddedTitusMasters;
import com.netflix.titus.testkit.embedded.kube.EmbeddedKubeClusters;
import com.netflix.titus.testkit.junit.category.IntegrationTest;
import com.netflix.titus.testkit.junit.master.TitusStackResource;
import org.junit.BeforeClass;
import org.junit.ClassRule;
import org.junit.Test;
import org.junit.experimental.categories.Category;
import org.junit.rules.RuleChain;
import static com.netflix.titus.testkit.model.eviction.DisruptionBudgetGenerator.budget;
import static com.netflix.titus.testkit.model.eviction.DisruptionBudgetGenerator.hourlyRatePercentage;
import static com.netflix.titus.testkit.model.eviction.DisruptionBudgetGenerator.newBatchJobDescriptor;
import static com.netflix.titus.testkit.model.eviction.DisruptionBudgetGenerator.percentageOfHealthyPolicy;
import static org.assertj.core.api.Assertions.assertThat;
@Category(IntegrationTest.class)
public class EvictionComponentIntegrationTest extends BaseIntegrationTest {
private static final JobDescriptor<BatchJobExt> JOB_TEMPLATE = newBatchJobDescriptor(
4,
budget(percentageOfHealthyPolicy(50), hourlyRatePercentage(50), Collections.emptyList())
);
private static final TitusStackResource titusStackResource = new TitusStackResource(EmbeddedTitusCell.aTitusCell()
.withMaster(EmbeddedTitusMasters.basicMasterWithKubeIntegration(EmbeddedKubeClusters.basicCluster(4)).toBuilder()
.withCellName("test")
.withSystemDisruptionBudgetDescriptor(new SystemDisruptionBudgetDescriptor(10, 10, Collections.emptyList()))
.build()
)
.withDefaultGateway()
.build(), false);
private static final JobsScenarioBuilder jobsScenarioBuilder = new JobsScenarioBuilder(titusStackResource);
@ClassRule
public static final RuleChain ruleChain = RuleChain.outerRule(titusStackResource).around(jobsScenarioBuilder);
private static EvictionServiceBlockingStub client;
@BeforeClass
public static void setUp() {
client = titusStackResource.getOperations().getBlockingGrpcEvictionClient();
}
@Test
public void testGlobalQuotaAccess() {
EvictionQuota quota = client.getEvictionQuota(Reference.newBuilder().setSystem(Reference.System.getDefaultInstance()).build());
assertThat(quota.getTarget().getReferenceCase()).isEqualTo(Reference.ReferenceCase.SYSTEM);
assertThat(quota.getQuota()).isGreaterThan(0);
}
@Test(timeout = LONG_TEST_TIMEOUT_MS)
public void testJobQuotaAccess() throws Exception {
jobsScenarioBuilder.schedule(JOB_TEMPLATE, jobScenarioBuilder -> jobScenarioBuilder
.template(ScenarioTemplates.startTasksInNewJob())
.andThen(() -> awaitQuota(jobScenarioBuilder, 2))
.inTask(0, tsb -> tsb.transitionTo(TaskStatus.TaskState.Finished))
.andThen(() -> awaitQuota(jobScenarioBuilder, 1))
);
}
@Test(timeout = LONG_TEST_TIMEOUT_MS)
public void testEventStream() throws Exception {
Iterator<EvictionServiceEvent> eventIt = client.observeEvents(ObserverEventRequest.getDefaultInstance());
jobsScenarioBuilder.schedule(JOB_TEMPLATE, jobScenarioBuilder -> jobScenarioBuilder
.template(ScenarioTemplates.startTasksInNewJob())
.andThen(() -> await().until(() -> hasJobQuotaEvent(eventIt, 2)))
.inTask(0, TaskScenarioBuilder::evictTask)
.andThen(() -> await().until(() -> hasJobQuotaEvent(eventIt, 1)))
.inTask(1, TaskScenarioBuilder::evictTask)
.andThen(() -> await().until(() -> hasJobQuotaEvent(eventIt, 0)))
.inTask(2, tsb -> {
try {
tsb.evictTask();
throw new IllegalStateException("Error expected");
} catch (Exception e) {
// Expected
}
return tsb.andThen(() -> await().until(() -> awaitTaskTerminationError(eventIt, tsb.getTask().getId())));
}
)
);
}
private ConditionFactory await() {
return Awaitility.await().timeout(10, TimeUnit.SECONDS);
}
private void awaitQuota(JobScenarioBuilder jobScenarioBuilder, int expectedQuota) {
await().until(() -> {
EvictionQuota quota = client.getEvictionQuota(Reference.newBuilder().setJobId(jobScenarioBuilder.getJobId()).build());
assertThat(quota.getTarget().getReferenceCase()).isEqualTo(Reference.ReferenceCase.JOBID);
assertThat(quota.getQuota()).isEqualTo(expectedQuota);
});
}
private boolean awaitTaskTerminationError(Iterator<EvictionServiceEvent> eventIt, String taskId) {
while (eventIt.hasNext()) {
EvictionServiceEvent event = eventIt.next();
if (event.getEventCase() == EvictionServiceEvent.EventCase.TASKTERMINATIONEVENT) {
EvictionServiceEvent.TaskTerminationEvent termination = event.getTaskTerminationEvent();
if (termination.getTaskId().equals(taskId)) {
assertThat(termination.getApproved()).isFalse();
return true;
}
}
}
return false;
}
private boolean hasJobQuotaEvent(Iterator<EvictionServiceEvent> eventIt, int quotaLevel) {
while (eventIt.hasNext()) {
EvictionServiceEvent event = eventIt.next();
if (event.getEventCase() == EvictionServiceEvent.EventCase.EVICTIONQUOTAEVENT) {
EvictionQuota quota = event.getEvictionQuotaEvent().getQuota();
if (quota.getTarget().getReferenceCase() == Reference.ReferenceCase.JOBID) {
return quota.getQuota() == quotaLevel;
}
}
}
return false;
}
}
| 22 |
0 | Create_ds/titus-control-plane/titus-server-master/src/test/java/com/netflix/titus/master/eviction | Create_ds/titus-control-plane/titus-server-master/src/test/java/com/netflix/titus/master/eviction/service/TaskTerminationExecutorTest.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.master.eviction.service;
import java.util.List;
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.model.event.TaskTerminationEvent;
import com.netflix.titus.api.eviction.service.EvictionException;
import com.netflix.titus.api.eviction.service.EvictionException.ErrorCode;
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.Task;
import com.netflix.titus.api.jobmanager.model.job.TaskState;
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.common.util.archaius2.Archaius2Ext;
import com.netflix.titus.common.util.tuple.Pair;
import com.netflix.titus.master.eviction.service.quota.ConsumptionResult;
import com.netflix.titus.master.eviction.service.quota.TitusQuotasManager;
import com.netflix.titus.testkit.model.job.JobComponentStub;
import com.netflix.titus.testkit.model.job.JobGenerator;
import com.netflix.titus.testkit.rx.TitusRxSubscriber;
import org.junit.Test;
import org.mockito.Mockito;
import reactor.core.publisher.Flux;
import reactor.core.scheduler.Schedulers;
import reactor.test.StepVerifier;
import static com.netflix.titus.testkit.model.job.JobDescriptorGenerator.oneTaskBatchJobDescriptor;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
public class TaskTerminationExecutorTest {
private static final String EVICTION_REASON = "Test eviction";
private final TitusRuntime titusRuntime = TitusRuntimes.test();
private final EvictionServiceConfiguration configuration = Archaius2Ext.newConfiguration(EvictionServiceConfiguration.class);
private final JobComponentStub jobComponentStub = new JobComponentStub(titusRuntime);
private final TitusQuotasManager quotasManager = Mockito.mock(TitusQuotasManager.class);
private final TitusRxSubscriber<EvictionEvent> eventSubscriber = new TitusRxSubscriber<>();
@Test
public void testTerminateTaskWithEnoughQuota() {
Pair<Job, List<Task>> jobAndTask = createAndStartJobWithTasks(1);
Job<?> job = jobAndTask.getLeft();
Task task = jobAndTask.getRight().get(0);
when(quotasManager.findEvictionQuota(Reference.job(job.getId()))).thenReturn(Optional.of(EvictionQuota.jobQuota(job.getId(), 1, "Test")));
when(quotasManager.tryConsumeQuota(job, task)).thenReturn(ConsumptionResult.approved());
StepVerifier.withVirtualTime(
() -> newTerminationExecutor().terminateTask(task.getId(), EVICTION_REASON, "callerContext")
).verifyComplete();
expectTaskTerminationEvent(task, true);
verify(quotasManager, times(1)).tryConsumeQuota(job, task);
}
@Test
public void testTerminateTaskWithNoQuota() {
Pair<Job, List<Task>> jobAndTask = createAndStartJobWithTasks(1);
Job<?> job = jobAndTask.getLeft();
Task task = jobAndTask.getRight().get(0);
when(quotasManager.tryConsumeQuota(job, task)).thenReturn(ConsumptionResult.rejected("no quota"));
StepVerifier
.withVirtualTime(() -> newTerminationExecutor().terminateTask(task.getId(), EVICTION_REASON, "callerContext"))
.consumeErrorWith(e -> expectEvictionError(e, ErrorCode.NoQuota))
.verify();
expectTaskTerminationEvent(task, false);
verify(quotasManager, times(1)).tryConsumeQuota(job, task);
}
@Test
public void testTerminateTwoTasksWithQuotaForOne() {
Pair<Job, List<Task>> jobAndTasks = createAndStartJobWithTasks(2);
Job<?> job = jobAndTasks.getLeft();
List<Task> tasks = jobAndTasks.getRight();
when(quotasManager.tryConsumeQuota(job, tasks.get(0))).thenReturn(ConsumptionResult.approved());
when(quotasManager.tryConsumeQuota(job, tasks.get(1))).thenReturn(ConsumptionResult.rejected("no quota"));
StepVerifier
.withVirtualTime(() -> {
TaskTerminationExecutor executor = newTerminationExecutor();
return terminate(executor, tasks.get(0)).mergeWith(terminate(executor, tasks.get(1))).collectList();
})
.assertNext(next -> {
long succeededCount = next.stream().filter(p -> !p.isPresent()).count();
Optional<Throwable> failed = next.stream().filter(Optional::isPresent).map(Optional::get).findFirst();
assertThat(succeededCount).isEqualTo(1);
assertThat(failed).isPresent();
expectEvictionError(failed.get(), ErrorCode.NoQuota);
})
.verifyComplete();
}
private Flux<Optional<Throwable>> terminate(TaskTerminationExecutor executor, Task task) {
return executor.terminateTask(task.getId(), EVICTION_REASON, "callerContext")
.materialize()
.map(signal -> (Optional<Throwable>) (signal.isOnError() ? Optional.of(signal.getThrowable()) : Optional.empty()))
.flux();
}
private TaskTerminationExecutor newTerminationExecutor() {
TaskTerminationExecutor executor = new TaskTerminationExecutor(
configuration,
jobComponentStub.getJobOperations(),
quotasManager,
titusRuntime,
Schedulers.parallel()
);
executor.events().subscribe(eventSubscriber);
return executor;
}
private Pair<Job, List<Task>> createAndStartJobWithTasks(int taskCount) {
Job job = jobComponentStub.createJob(JobGenerator.batchJobs(oneTaskBatchJobDescriptor().but(JobFunctions.ofBatchSize(taskCount))).getValue());
List<Task> tasks = jobComponentStub.createDesiredTasks(job);
tasks.forEach(t -> jobComponentStub.moveTaskToState(t, TaskState.Started));
return Pair.of(job, jobComponentStub.getJobOperations().getTasks(job.getId()));
}
private void expectEvictionError(Throwable error, ErrorCode expectedErrorCode) {
assertThat(error).isInstanceOf(EvictionException.class);
assertThat(((EvictionException) error).getErrorCode()).isEqualTo(expectedErrorCode);
}
private void expectTaskTerminationEvent(Task task, boolean approved) {
EvictionEvent event = eventSubscriber.takeNext();
assertThat(event).isInstanceOf(TaskTerminationEvent.class);
TaskTerminationEvent terminationEvent = (TaskTerminationEvent) event;
assertThat(terminationEvent.getTaskId()).isEqualTo(task.getId());
assertThat(terminationEvent.isApproved()).isEqualTo(approved);
if (!approved) {
assertThat(terminationEvent.getError().get().getMessage()).contains("no quota");
}
}
} | 23 |
0 | Create_ds/titus-control-plane/titus-server-master/src/test/java/com/netflix/titus/master/eviction/service | Create_ds/titus-control-plane/titus-server-master/src/test/java/com/netflix/titus/master/eviction/service/quota/QuotaEventEmitterTest.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.master.eviction.service.quota;
import java.time.Duration;
import java.util.List;
import java.util.Optional;
import java.util.concurrent.TimeUnit;
import com.jayway.awaitility.Awaitility;
import com.jayway.awaitility.core.ConditionFactory;
import com.netflix.titus.api.eviction.model.EvictionQuota;
import com.netflix.titus.api.eviction.model.event.EvictionEvent;
import com.netflix.titus.api.eviction.model.event.EvictionQuotaEvent;
import com.netflix.titus.api.jobmanager.model.job.Job;
import com.netflix.titus.api.jobmanager.model.job.ext.BatchJobExt;
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.master.eviction.service.EvictionServiceConfiguration;
import com.netflix.titus.testkit.model.job.JobComponentStub;
import com.netflix.titus.testkit.rx.TitusRxSubscriber;
import org.junit.After;
import org.junit.Before;
import org.junit.BeforeClass;
import org.junit.Test;
import static com.netflix.titus.testkit.model.eviction.DisruptionBudgetGenerator.budget;
import static com.netflix.titus.testkit.model.eviction.DisruptionBudgetGenerator.hourlyRatePercentage;
import static com.netflix.titus.testkit.model.eviction.DisruptionBudgetGenerator.newBatchJob;
import static com.netflix.titus.testkit.model.eviction.DisruptionBudgetGenerator.numberOfHealthyPolicy;
import static com.netflix.titus.testkit.model.eviction.DisruptionBudgetGenerator.officeHourTimeWindow;
import static java.util.Arrays.asList;
import static java.util.Collections.singletonList;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
public class QuotaEventEmitterTest {
private static final EvictionServiceConfiguration CONFIGURATION = mock(EvictionServiceConfiguration.class);
private static final long UPDATE_INTERVAL_MS = 10L;
private static final EvictionQuota SYSTEM_EVICTION_QUOTA = EvictionQuota.systemQuota(100, "Test");
private static final Duration EVENT_TIMEOUT = Duration.ofSeconds(5);
private final TitusRuntime titusRuntime = TitusRuntimes.internal();
private final JobComponentStub jobComponentStub = new JobComponentStub(titusRuntime);
private final TitusQuotasManager quotasManager = mock(TitusQuotasManager.class);
private final QuotaEventEmitter quotaEventEmitter = new QuotaEventEmitter(
CONFIGURATION,
jobComponentStub.getJobOperations(),
quotasManager,
titusRuntime
);
@BeforeClass
public static void setUpClass() {
when(CONFIGURATION.getEventStreamQuotaUpdateIntervalMs()).thenReturn(UPDATE_INTERVAL_MS);
}
@Before
public void setUp() throws Exception {
when(quotasManager.findEvictionQuota(Reference.system())).thenReturn(Optional.of(SYSTEM_EVICTION_QUOTA));
}
@After
public void tearDown() {
quotaEventEmitter.shutdown();
}
@Test
public void testOneSubscription() throws Exception {
TitusRxSubscriber<EvictionEvent> eventSubscriber = subscribeAndCheckSnapshot();
// Create one job and check its quota is emitted
Job<BatchJobExt> job = newBatchJob(
5,
budget(numberOfHealthyPolicy(8), hourlyRatePercentage(50), singletonList(officeHourTimeWindow()))
);
when(quotasManager.findEvictionQuota(Reference.job(job.getId()))).thenReturn(Optional.of(EvictionQuota.jobQuota(job.getId(), 2, "Test")));
jobComponentStub.createJob(job);
jobComponentStub.createDesiredTasks(job);
expectJobQuotaEvent(eventSubscriber, job, 2);
// Now change the quota
when(quotasManager.findEvictionQuota(Reference.job(job.getId()))).thenReturn(Optional.of(EvictionQuota.jobQuota(job.getId(), 5, "Test")));
expectJobQuotaEvent(eventSubscriber, job, 5);
cancelSubscriptionAndCheckIfSucceeded(eventSubscriber);
}
@Test
public void testManySubscriptions() throws InterruptedException {
List<TitusRxSubscriber<EvictionEvent>> subscribers = asList(subscribeAndCheckSnapshot(), subscribeAndCheckSnapshot());
cancelSubscriptionAndCheckIfSucceeded(subscribers.get(1));
TitusRxSubscriber<EvictionEvent> remaining = subscribers.get(0);
assertThat(remaining.isOpen()).isTrue();
}
private TitusRxSubscriber<EvictionEvent> subscribeAndCheckSnapshot() throws InterruptedException {
TitusRxSubscriber<EvictionEvent> eventSubscriber = new TitusRxSubscriber<>();
quotaEventEmitter.events(true).subscribe(eventSubscriber);
// Check snapshot
expectSystemQuota(eventSubscriber);
expectSnapshotEnd(eventSubscriber);
return eventSubscriber;
}
private void expectJobQuotaEvent(TitusRxSubscriber<EvictionEvent> eventSubscriber, Job job, int quota) throws InterruptedException {
EvictionQuotaEvent event = (EvictionQuotaEvent) eventSubscriber.takeNext(EVENT_TIMEOUT);
assertThat(event.getQuota().getReference()).isEqualTo(Reference.job(job.getId()));
assertThat(event.getQuota().getQuota()).isEqualTo(quota);
}
private void expectSnapshotEnd(TitusRxSubscriber<EvictionEvent> eventSubscriber) throws InterruptedException {
assertThat(eventSubscriber.takeNext(EVENT_TIMEOUT)).isEqualTo(EvictionEvent.newSnapshotEndEvent());
}
private void expectSystemQuota(TitusRxSubscriber<EvictionEvent> eventSubscriber) throws InterruptedException {
EvictionQuotaEvent event = (EvictionQuotaEvent) eventSubscriber.takeNext(EVENT_TIMEOUT);
assertThat(event.getQuota().getReference()).isEqualTo(Reference.system());
}
private void cancelSubscriptionAndCheckIfSucceeded(TitusRxSubscriber<EvictionEvent> eventSubscriber) {
int current = quotaEventEmitter.eventSubscriberSinks.size();
eventSubscriber.dispose();
await().until(() -> quotaEventEmitter.eventSubscriberSinks.size() == current - 1);
}
private ConditionFactory await() {
return Awaitility.await().timeout(EVENT_TIMEOUT.toMillis(), TimeUnit.MILLISECONDS);
}
} | 24 |
0 | Create_ds/titus-control-plane/titus-server-master/src/test/java/com/netflix/titus/master/eviction/service | Create_ds/titus-control-plane/titus-server-master/src/test/java/com/netflix/titus/master/eviction/service/quota/TitusQuotasManagerTest.java | package com.netflix.titus.master.eviction.service.quota;
import com.netflix.titus.api.jobmanager.model.job.Job;
import com.netflix.titus.api.jobmanager.model.job.ext.BatchJobExt;
import com.netflix.titus.master.eviction.service.quota.job.JobQuotaController;
import com.netflix.titus.master.eviction.service.quota.system.SystemQuotaConsumptionResults;
import com.netflix.titus.master.eviction.service.quota.system.SystemQuotaController;
import com.netflix.titus.runtime.connector.eviction.EvictionConfiguration;
import com.netflix.titus.testkit.model.job.JobGenerator;
import org.junit.Test;
import static com.netflix.titus.api.jobmanager.model.job.JobFunctions.withApplicationName;
import static org.assertj.core.api.AssertionsForClassTypes.assertThat;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
public class TitusQuotasManagerTest {
@Test
public void tryConsumeSystemAndJobQuota() {
String taskId = "job1Task1";
String jobQuotaRejectionReason = "Job does not allow any more terminations";
Job<BatchJobExt> job1 = JobGenerator.oneBatchJob().but(withApplicationName("app1Test"));
EvictionConfiguration config1 = mock(EvictionConfiguration.class);
when(config1.getAppsExemptFromSystemDisruptionWindow()).thenReturn("app1.*");
SystemQuotaController systemQuotaController = mock(SystemQuotaController.class);
when(systemQuotaController.consume(taskId)).thenReturn(ConsumptionResult.approved());
JobQuotaController jobQuotaController = mock(JobQuotaController.class);
when(jobQuotaController.consume(taskId)).thenReturn(ConsumptionResult.rejected(jobQuotaRejectionReason));
TitusQuotasManager titusQuotasManager = new TitusQuotasManager(null, null, null, systemQuotaController,
config1, null);
ConsumptionResult consumptionResult = titusQuotasManager.tryConsumeSystemAndJobQuota(jobQuotaController, job1, taskId);
assertThat(consumptionResult.isApproved()).isFalse();
assertThat(consumptionResult.getRejectionReason()).isPresent();
assertThat(consumptionResult.getRejectionReason().get()).isEqualTo(jobQuotaRejectionReason);
JobQuotaController jobQuotaController2 = mock(JobQuotaController.class);
when(jobQuotaController2.consume(taskId)).thenReturn(ConsumptionResult.approved());
ConsumptionResult consumptionResult2 = titusQuotasManager.tryConsumeSystemAndJobQuota(jobQuotaController2, job1, taskId);
assertThat(consumptionResult2.isApproved()).isTrue();
String quotaLimitExceededReason = SystemQuotaConsumptionResults.QUOTA_LIMIT_EXCEEDED.getRejectionReason().get();
when(systemQuotaController.consume(taskId)).thenReturn(ConsumptionResult.rejected(quotaLimitExceededReason));
ConsumptionResult consumptionResult3 = titusQuotasManager.tryConsumeSystemAndJobQuota(jobQuotaController2, job1, taskId);
assertThat(consumptionResult3.isApproved()).isFalse();
assertThat(consumptionResult3.getRejectionReason()).isPresent();
assertThat(consumptionResult3.getRejectionReason().get()).isEqualTo(quotaLimitExceededReason);
String outsideSystemWindowReason = SystemQuotaConsumptionResults.OUTSIDE_SYSTEM_TIME_WINDOW.getRejectionReason().get();
when(systemQuotaController.consume(taskId)).thenReturn(ConsumptionResult.rejected(outsideSystemWindowReason));
ConsumptionResult consumptionResult4 = titusQuotasManager.tryConsumeSystemAndJobQuota(jobQuotaController2, job1, taskId);
assertThat(consumptionResult4.isApproved()).isTrue();
}
@Test
public void isJobExemptFromSystemDisruptionWindow() {
Job<BatchJobExt> job1 = JobGenerator.oneBatchJob().but(withApplicationName("app1Test"));
EvictionConfiguration config1 = mock(EvictionConfiguration.class);
when(config1.getAppsExemptFromSystemDisruptionWindow()).thenReturn("app1.*");
TitusQuotasManager titusQuotasManager = new TitusQuotasManager(null, null, null, null,
config1, null);
boolean jobExemptFromSystemDisruptionBudget = titusQuotasManager.isJobExemptFromSystemDisruptionWindow(job1);
assertThat(jobExemptFromSystemDisruptionBudget).isTrue();
EvictionConfiguration config2 = mock(EvictionConfiguration.class);
when(config2.getAppsExemptFromSystemDisruptionWindow()).thenReturn("app2.*");
TitusQuotasManager titusQuotasManager2 = new TitusQuotasManager(null, null, null, null,
config2, null);
boolean jobExemptFromSystemDisruptionBudget2 = titusQuotasManager2.isJobExemptFromSystemDisruptionWindow(job1);
assertThat(jobExemptFromSystemDisruptionBudget2).isFalse();
}
} | 25 |
0 | Create_ds/titus-control-plane/titus-server-master/src/test/java/com/netflix/titus/master/eviction/service/quota | Create_ds/titus-control-plane/titus-server-master/src/test/java/com/netflix/titus/master/eviction/service/quota/system/ArchaiusSystemDisruptionBudgetResolverTest.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.master.eviction.service.quota.system;
import java.util.Collections;
import java.util.function.Consumer;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.netflix.archaius.api.PropertyRepository;
import com.netflix.titus.api.eviction.model.SystemDisruptionBudget;
import com.netflix.titus.api.eviction.service.EvictionException;
import com.netflix.titus.api.eviction.service.EvictionException.ErrorCode;
import com.netflix.titus.api.jobmanager.model.job.disruptionbudget.Day;
import com.netflix.titus.api.jobmanager.model.job.disruptionbudget.TimeWindow;
import com.netflix.titus.api.json.ObjectMappers;
import com.netflix.titus.testkit.rx.TitusRxSubscriber;
import org.junit.Before;
import org.junit.Test;
import static com.netflix.titus.master.eviction.service.quota.system.ArchaiusSystemDisruptionBudgetResolver.PROPERTY_KEY;
import static com.netflix.titus.master.eviction.service.quota.system.ArchaiusSystemDisruptionBudgetResolver.toDisruptionBudget;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.fail;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
public class ArchaiusSystemDisruptionBudgetResolverTest {
private static final SystemDisruptionBudgetDescriptor DESCRIPTOR_1_1 = new SystemDisruptionBudgetDescriptor(
1,
1,
Collections.singletonList(TimeWindow.newBuilder()
.withDays(Day.weekdays())
.withwithHourlyTimeWindows(8, 16)
.withTimeZone("PST")
.build()
)
);
private static final SystemDisruptionBudgetDescriptor DESCRIPTOR_2_2 = new SystemDisruptionBudgetDescriptor(2, 2, Collections.emptyList());
private final PropertyRepository repository = mock(PropertyRepository.class);
private final StubbedProperty property = new StubbedProperty();
private final TitusRxSubscriber<SystemDisruptionBudget> testSubscriber = new TitusRxSubscriber<>();
@Before
public void setUp() throws Exception {
when(repository.get(PROPERTY_KEY, String.class)).thenReturn(property);
}
@Test
public void testResolve() throws Exception {
property.set(toJson(DESCRIPTOR_1_1));
ArchaiusSystemDisruptionBudgetResolver resolver = new ArchaiusSystemDisruptionBudgetResolver(repository);
resolver.resolve().subscribe(testSubscriber);
// Should return the initial value.
assertThat(testSubscriber.takeNext()).isEqualTo(toDisruptionBudget(DESCRIPTOR_1_1));
// Now refresh
property.set(toJson(DESCRIPTOR_2_2));
assertThat(testSubscriber.takeNext()).isEqualTo(toDisruptionBudget(DESCRIPTOR_2_2));
}
@Test
public void testExceptionOnCreateIsPropagated() {
property.set("bad data");
try {
new ArchaiusSystemDisruptionBudgetResolver(repository);
fail("Exception expected");
} catch (EvictionException e) {
assertThat(e.getErrorCode()).isEqualTo(ErrorCode.BadConfiguration);
}
}
@Test
public void testLaterExceptionsAreReportedAndSwallowed() throws Exception {
property.set(toJson(DESCRIPTOR_1_1));
ArchaiusSystemDisruptionBudgetResolver resolver = new ArchaiusSystemDisruptionBudgetResolver(repository);
resolver.resolve().subscribe(testSubscriber);
// Should return the initial value.
assertThat(testSubscriber.takeNext()).isEqualTo(toDisruptionBudget(DESCRIPTOR_1_1));
// Now set bad data
property.set("bad data");
assertThat(testSubscriber.takeNext()).isNull();
// Now good again
property.set(toJson(DESCRIPTOR_2_2));
assertThat(testSubscriber.takeNext()).isEqualTo(toDisruptionBudget(DESCRIPTOR_2_2));
}
private String toJson(SystemDisruptionBudgetDescriptor systemDisruptionBudgetDescriptor) throws JsonProcessingException {
return ObjectMappers.storeMapper().writeValueAsString(systemDisruptionBudgetDescriptor);
}
private class StubbedProperty implements com.netflix.archaius.api.Property<String> {
private String value;
private Consumer<String> consumer = newValue -> {
};
@Override
public String get() {
return value;
}
void set(String newValue) {
this.value = newValue;
consumer.accept(newValue);
}
@Override
public String getKey() {
return PROPERTY_KEY;
}
@Override
public Subscription subscribe(Consumer<String> consumer) {
this.consumer = consumer;
return () -> {
};
}
}
} | 26 |
0 | Create_ds/titus-control-plane/titus-server-master/src/test/java/com/netflix/titus/master/eviction/service/quota | Create_ds/titus-control-plane/titus-server-master/src/test/java/com/netflix/titus/master/eviction/service/quota/system/SystemQuotaControllerTest.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.master.eviction.service.quota.system;
import java.time.DayOfWeek;
import java.time.Duration;
import java.time.Month;
import com.netflix.titus.api.eviction.model.SystemDisruptionBudget;
import com.netflix.titus.api.jobmanager.model.job.disruptionbudget.Day;
import com.netflix.titus.api.jobmanager.model.job.disruptionbudget.TimeWindow;
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.common.util.time.Clocks;
import com.netflix.titus.common.util.time.TestClock;
import org.junit.Before;
import org.junit.Test;
import reactor.core.publisher.EmitterProcessor;
import reactor.core.publisher.Flux;
import static com.jayway.awaitility.Awaitility.await;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
public class SystemQuotaControllerTest {
private static TestClock clock = Clocks.testWorldClock(2000, Month.JANUARY, 1).jumpForwardTo(DayOfWeek.MONDAY);
private final TitusRuntime titusRuntime = TitusRuntimes.test(clock);
private volatile EmitterProcessor<SystemDisruptionBudget> budgetEmitter = EmitterProcessor.create(1);
private final SystemDisruptionBudgetResolver budgetResolver = mock(SystemDisruptionBudgetResolver.class);
private SystemQuotaController quotaController;
@Before
public void setUp() throws Exception {
when(budgetResolver.resolve()).thenReturn(Flux.defer(() -> {
if (!isBudgetEmitterOpen()) {
budgetEmitter = EmitterProcessor.create(1);
}
return budgetEmitter;
}));
}
@Test
public void testQuotaConsumption() {
budgetEmitter.onNext(SystemDisruptionBudget.newBasicSystemDisruptionBudget(1, 1));
quotaController = newSystemQuotaController();
assertThat(quotaController.getQuota(Reference.system()).getQuota()).isEqualTo(1);
assertThat(quotaController.consume("someTaskId").isApproved()).isTrue();
}
@Test
public void testOutsideTimeWindow() {
budgetEmitter.onNext(SystemDisruptionBudget.newBasicSystemDisruptionBudget(
1,
1,
TimeWindow.newBuilder()
.withDays(Day.weekdays())
.withwithHourlyTimeWindows(8, 16)
.build()
));
// Outside time window
quotaController = newSystemQuotaController();
assertThat(quotaController.getQuota(Reference.system()).getQuota()).isEqualTo(0);
assertThat(quotaController.consume("someTaskId").isApproved()).isFalse();
// In time window
clock.resetTime(10, 0, 0);
assertThat(quotaController.getQuota(Reference.system()).getQuota()).isEqualTo(1);
assertThat(quotaController.consume("someTaskId").isApproved()).isTrue();
}
@Test
public void testBudgetReconfiguration() {
// Large quota
budgetEmitter.onNext(SystemDisruptionBudget.newBasicSystemDisruptionBudget(5, 5));
quotaController = newSystemQuotaController();
assertThat(quotaController.getQuota(Reference.system()).getQuota()).isEqualTo(5);
// Small quota
budgetEmitter.onNext(SystemDisruptionBudget.newBasicSystemDisruptionBudget(1, 1));
assertThat(quotaController.getQuota(Reference.system()).getQuota()).isEqualTo(1);
assertThat(quotaController.consume("someTaskId").isApproved()).isTrue();
assertThat(quotaController.consume("someTaskId").isApproved()).isFalse();
}
@Test(timeout = 60_000)
public void testRetryOnFailure() {
budgetEmitter.onNext(SystemDisruptionBudget.newBasicSystemDisruptionBudget(1, 1));
quotaController = newSystemQuotaController();
// Emit error
budgetEmitter.onError(new RuntimeException("Simulated error"));
await().until(this::isBudgetEmitterOpen); // Wait until is re-subscribed
budgetEmitter.onNext(SystemDisruptionBudget.newBasicSystemDisruptionBudget(5, 5));
await().until(() -> quotaController.getQuota(Reference.system()).getQuota() == 5);
}
private SystemQuotaController newSystemQuotaController() {
return new SystemQuotaController(budgetResolver, Duration.ofMillis(1), titusRuntime);
}
private boolean isBudgetEmitterOpen() {
return !(budgetEmitter.isTerminated() || budgetEmitter.isCancelled() || budgetEmitter.isDisposed());
}
}
| 27 |
0 | Create_ds/titus-control-plane/titus-server-master/src/test/java/com/netflix/titus/master/eviction/service/quota | Create_ds/titus-control-plane/titus-server-master/src/test/java/com/netflix/titus/master/eviction/service/quota/job/JobPercentagePerIntervalRateControllerTest.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.master.eviction.service.quota.job;
import java.time.Duration;
import java.util.Collections;
import com.netflix.titus.api.jobmanager.model.job.Job;
import com.netflix.titus.api.jobmanager.model.job.ext.BatchJobExt;
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.common.util.time.TestClock;
import org.junit.Test;
import static com.netflix.titus.master.eviction.service.quota.job.JobPercentagePerIntervalRateController.newJobPercentagePerIntervalRateController;
import static com.netflix.titus.testkit.model.eviction.DisruptionBudgetGenerator.budget;
import static com.netflix.titus.testkit.model.eviction.DisruptionBudgetGenerator.exceptRate;
import static com.netflix.titus.testkit.model.eviction.DisruptionBudgetGenerator.newBatchJob;
import static com.netflix.titus.testkit.model.eviction.DisruptionBudgetGenerator.percentageOfHealthyPolicy;
import static com.netflix.titus.testkit.model.eviction.DisruptionBudgetGenerator.ratePercentagePerInterval;
import static org.assertj.core.api.Assertions.assertThat;
public class JobPercentagePerIntervalRateControllerTest {
private static final Job<BatchJobExt> REFERENCE_JOB = newBatchJob(
10,
budget(percentageOfHealthyPolicy(100), ratePercentagePerInterval(600_000, 100), Collections.emptyList())
);
private static final Reference JOB_REFERENCE = Reference.job(REFERENCE_JOB.getId());
private static final Duration ONE_MINUTE = Duration.ofMinutes(1);
private final TitusRuntime titusRuntime = TitusRuntimes.test();
private final TestClock clock = (TestClock) titusRuntime.getClock();
@Test
public void testQuota() {
JobPercentagePerIntervalRateController quotaController = newJobPercentagePerIntervalRateController(
exceptRate(REFERENCE_JOB, ratePercentagePerInterval(600_000, 50)),
SelfJobDisruptionBudgetResolver.getInstance(),
titusRuntime
);
assertThat(quotaController.getQuota(JOB_REFERENCE).getQuota()).isEqualTo(5);
// Consume everything
consumeAtInterval(quotaController, 5, ONE_MINUTE);
assertThat(quotaController.getQuota(JOB_REFERENCE).getQuota()).isEqualTo(0);
// Now shift time and consume again
clock.advanceTime(ONE_MINUTE.multipliedBy(5));
clock.advanceTime(ONE_MINUTE);
assertThat(quotaController.consume("someTaskId").isApproved()).isTrue();
// Now move long into the future
clock.advanceTime(Duration.ofHours(2));
assertThat(quotaController.getQuota(JOB_REFERENCE).getQuota()).isEqualTo(5);
}
@Test
public void testJobUpdate() {
JobPercentagePerIntervalRateController firstController = newJobPercentagePerIntervalRateController(
exceptRate(REFERENCE_JOB, ratePercentagePerInterval(600_000, 50)),
SelfJobDisruptionBudgetResolver.getInstance(),
titusRuntime
);
// Take all
consumeAtInterval(firstController, 5, ONE_MINUTE);
assertThat(firstController.getQuota(JOB_REFERENCE).getQuota()).isEqualTo(0);
// Now increase the allowance
JobPercentagePerIntervalRateController updatedController = firstController.update(exceptRate(REFERENCE_JOB, ratePercentagePerInterval(150_000, 80)));
assertThat(updatedController.getQuota(JOB_REFERENCE).getQuota()).isEqualTo(3);
}
private void consumeAtInterval(JobPercentagePerIntervalRateController quotaController, int count, Duration interval) {
for (int i = 0; i < count; i++) {
clock.advanceTime(interval);
assertThat(quotaController.consume("someTaskId").isApproved()).isTrue();
}
}
} | 28 |
0 | Create_ds/titus-control-plane/titus-server-master/src/test/java/com/netflix/titus/master/eviction/service/quota | Create_ds/titus-control-plane/titus-server-master/src/test/java/com/netflix/titus/master/eviction/service/quota/job/JobPercentagePerHourRelocationRateControllerTest.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.master.eviction.service.quota.job;
import java.time.Duration;
import java.util.Collections;
import com.netflix.titus.api.jobmanager.model.job.Job;
import com.netflix.titus.api.jobmanager.model.job.ext.BatchJobExt;
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.common.util.time.TestClock;
import org.junit.Test;
import static com.netflix.titus.master.eviction.service.quota.job.JobPercentagePerHourRelocationRateController.newJobPercentagePerHourRelocationRateController;
import static com.netflix.titus.testkit.model.eviction.DisruptionBudgetGenerator.budget;
import static com.netflix.titus.testkit.model.eviction.DisruptionBudgetGenerator.exceptRate;
import static com.netflix.titus.testkit.model.eviction.DisruptionBudgetGenerator.hourlyRatePercentage;
import static com.netflix.titus.testkit.model.eviction.DisruptionBudgetGenerator.newBatchJob;
import static com.netflix.titus.testkit.model.eviction.DisruptionBudgetGenerator.percentageOfHealthyPolicy;
import static org.assertj.core.api.Assertions.assertThat;
public class JobPercentagePerHourRelocationRateControllerTest {
private static final Job<BatchJobExt> REFERENCE_JOB = newBatchJob(
10,
budget(percentageOfHealthyPolicy(100), hourlyRatePercentage(100), Collections.emptyList())
);
private static final Reference JOB_REFERENCE = Reference.job(REFERENCE_JOB.getId());
private static final Duration TEN_MINUTES = Duration.ofMinutes(10);
private final TitusRuntime titusRuntime = TitusRuntimes.test();
private final TestClock clock = (TestClock) titusRuntime.getClock();
@Test
public void testQuota() {
JobPercentagePerHourRelocationRateController quotaController = newJobPercentagePerHourRelocationRateController(
exceptRate(REFERENCE_JOB, hourlyRatePercentage(50)),
SelfJobDisruptionBudgetResolver.getInstance(),
titusRuntime
);
assertThat(quotaController.getQuota(JOB_REFERENCE).getQuota()).isEqualTo(5);
// Consume everything
consumeAtInterval(quotaController, 5, TEN_MINUTES);
assertThat(quotaController.getQuota(JOB_REFERENCE).getQuota()).isEqualTo(0);
// Now shift time and consume again
clock.advanceTime(TEN_MINUTES);
clock.advanceTime(TEN_MINUTES);
assertThat(quotaController.consume("someTaskId").isApproved()).isTrue();
// Now move long into the future
clock.advanceTime(Duration.ofHours(2));
assertThat(quotaController.getQuota(JOB_REFERENCE).getQuota()).isEqualTo(5);
}
@Test
public void testJobUpdate() {
JobPercentagePerHourRelocationRateController firstController = newJobPercentagePerHourRelocationRateController(
exceptRate(REFERENCE_JOB, hourlyRatePercentage(50)),
SelfJobDisruptionBudgetResolver.getInstance(),
titusRuntime
);
// Take all
consumeAtInterval(firstController, 5, TEN_MINUTES);
assertThat(firstController.getQuota(JOB_REFERENCE).getQuota()).isEqualTo(0);
// Now increase the allowance
JobPercentagePerHourRelocationRateController updatedController = firstController.update(exceptRate(REFERENCE_JOB, hourlyRatePercentage(80)));
assertThat(updatedController.getQuota(JOB_REFERENCE).getQuota()).isEqualTo(3);
}
private void consumeAtInterval(JobPercentagePerHourRelocationRateController quotaController, int count, Duration interval) {
for (int i = 0; i < count; i++) {
clock.advanceTime(interval);
assertThat(quotaController.consume("someTaskId").isApproved()).isTrue();
}
}
} | 29 |
0 | Create_ds/titus-control-plane/titus-server-master/src/test/java/com/netflix/titus/master/eviction/service/quota | Create_ds/titus-control-plane/titus-server-master/src/test/java/com/netflix/titus/master/eviction/service/quota/job/ArchaiusEffectiveJobDisruptionBudgetResolverTest.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.master.eviction.service.quota.job;
import java.util.Collections;
import java.util.function.Consumer;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.netflix.archaius.api.PropertyRepository;
import com.netflix.titus.api.jobmanager.model.job.Job;
import com.netflix.titus.api.jobmanager.model.job.disruptionbudget.DisruptionBudget;
import com.netflix.titus.api.json.ObjectMappers;
import com.netflix.titus.common.model.sanitizer.EntitySanitizer;
import com.netflix.titus.testkit.model.eviction.DisruptionBudgetGenerator;
import com.netflix.titus.testkit.model.job.JobGenerator;
import org.junit.Before;
import org.junit.Test;
import static com.netflix.titus.master.eviction.service.quota.job.ArchaiusEffectiveJobDisruptionBudgetResolver.PROPERTY_KEY;
import static com.netflix.titus.testkit.model.eviction.DisruptionBudgetGenerator.budget;
import static com.netflix.titus.testkit.model.eviction.DisruptionBudgetGenerator.selfManagedPolicy;
import static com.netflix.titus.testkit.model.eviction.DisruptionBudgetGenerator.unlimitedRate;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
public class ArchaiusEffectiveJobDisruptionBudgetResolverTest {
private static final Job<?> JOB_NOT_SELF_MANAGED = JobGenerator.oneBatchJob();
private static final Job<?> JOB_SELF_MANAGED = JobGenerator.oneBatchJob().but(j ->
j.toBuilder()
.withJobDescriptor(j.getJobDescriptor().toBuilder()
.withDisruptionBudget(budget(selfManagedPolicy(1_000), unlimitedRate(), Collections.emptyList()))
.build()
)
.build()
);
private static final DisruptionBudget FALLBACK_BUDGET_1 = budget(
DisruptionBudgetGenerator.perTaskRelocationLimitPolicy(100),
DisruptionBudgetGenerator.unlimitedRate(),
Collections.emptyList()
);
private static final DisruptionBudget FALLBACK_BUDGET_2 = budget(
DisruptionBudgetGenerator.perTaskRelocationLimitPolicy(50),
DisruptionBudgetGenerator.unlimitedRate(),
Collections.emptyList()
);
private final EntitySanitizer sanitizer = mock(EntitySanitizer.class);
private final PropertyRepository repository = mock(PropertyRepository.class);
private final StubbedProperty property = new StubbedProperty();
@Before
public void setUp() throws Exception {
when(repository.get(PROPERTY_KEY, String.class)).thenReturn(property);
}
@Test
public void testReturnsOriginalForNotSelfManagedJobs() throws Exception {
property.set(toJson(FALLBACK_BUDGET_1));
ArchaiusEffectiveJobDisruptionBudgetResolver resolver = new ArchaiusEffectiveJobDisruptionBudgetResolver(repository, sanitizer);
assertThat(resolver.resolve(JOB_NOT_SELF_MANAGED)).isEqualTo(JOB_NOT_SELF_MANAGED.getJobDescriptor().getDisruptionBudget());
}
@Test
public void testReturnsFallbackForSelfManagedJobs() throws Exception {
property.set(toJson(FALLBACK_BUDGET_1));
ArchaiusEffectiveJobDisruptionBudgetResolver resolver = new ArchaiusEffectiveJobDisruptionBudgetResolver(repository, sanitizer);
assertThat(resolver.resolve(JOB_SELF_MANAGED)).isEqualTo(FALLBACK_BUDGET_1);
}
@Test
public void testRefresh() throws Exception {
property.set(toJson(FALLBACK_BUDGET_1));
ArchaiusEffectiveJobDisruptionBudgetResolver resolver = new ArchaiusEffectiveJobDisruptionBudgetResolver(repository, sanitizer);
assertThat(resolver.resolve(JOB_SELF_MANAGED)).isEqualTo(FALLBACK_BUDGET_1);
property.set(toJson(FALLBACK_BUDGET_2));
assertThat(resolver.resolve(JOB_SELF_MANAGED)).isEqualTo(FALLBACK_BUDGET_2);
}
private String toJson(DisruptionBudget disruptionBudget) throws JsonProcessingException {
return ObjectMappers.storeMapper().writeValueAsString(disruptionBudget);
}
private class StubbedProperty implements com.netflix.archaius.api.Property<String> {
private String value;
private Consumer<String> consumer = newValue -> {
};
@Override
public String get() {
return value;
}
void set(String newValue) {
this.value = newValue;
consumer.accept(newValue);
}
@Override
public String getKey() {
return PROPERTY_KEY;
}
@Override
public Subscription subscribe(Consumer<String> consumer) {
this.consumer = consumer;
return () -> {
};
}
}
} | 30 |
0 | Create_ds/titus-control-plane/titus-server-master/src/test/java/com/netflix/titus/master/eviction/service/quota | Create_ds/titus-control-plane/titus-server-master/src/test/java/com/netflix/titus/master/eviction/service/quota/job/RatePerIntervalRateControllerTest.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.master.eviction.service.quota.job;
import java.time.Duration;
import java.util.Collections;
import com.netflix.titus.api.jobmanager.model.job.Job;
import com.netflix.titus.api.jobmanager.model.job.ext.BatchJobExt;
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.common.util.time.TestClock;
import org.junit.Test;
import static com.netflix.titus.master.eviction.service.quota.job.RatePerIntervalRateController.newRatePerIntervalRateController;
import static com.netflix.titus.testkit.model.eviction.DisruptionBudgetGenerator.budget;
import static com.netflix.titus.testkit.model.eviction.DisruptionBudgetGenerator.exceptRate;
import static com.netflix.titus.testkit.model.eviction.DisruptionBudgetGenerator.hourlyRatePercentage;
import static com.netflix.titus.testkit.model.eviction.DisruptionBudgetGenerator.newBatchJob;
import static com.netflix.titus.testkit.model.eviction.DisruptionBudgetGenerator.percentageOfHealthyPolicy;
import static com.netflix.titus.testkit.model.eviction.DisruptionBudgetGenerator.ratePerInterval;
import static org.assertj.core.api.Assertions.assertThat;
public class RatePerIntervalRateControllerTest {
private static final Job<BatchJobExt> REFERENCE_JOB = newBatchJob(
10,
budget(percentageOfHealthyPolicy(100), hourlyRatePercentage(100), Collections.emptyList())
);
private static final Reference JOB_REFERENCE = Reference.job(REFERENCE_JOB.getId());
private static final long WINDOW_MS = 60_000;
private static final Duration CONSUME_INTERVAL = Duration.ofSeconds(10);
private final TitusRuntime titusRuntime = TitusRuntimes.test();
private final TestClock clock = (TestClock) titusRuntime.getClock();
@Test
public void testQuota() {
RatePerIntervalRateController quotaController = newRatePerIntervalRateController(
exceptRate(REFERENCE_JOB, ratePerInterval(WINDOW_MS, 5)),
SelfJobDisruptionBudgetResolver.getInstance(),
titusRuntime
);
assertThat(quotaController.getQuota(JOB_REFERENCE).getQuota()).isEqualTo(5);
// Consume everything
consumeAtInterval(quotaController, 5, CONSUME_INTERVAL);
assertThat(quotaController.getQuota(JOB_REFERENCE).getQuota()).isEqualTo(0);
// Now shift time and consume again
clock.advanceTime(CONSUME_INTERVAL);
clock.advanceTime(CONSUME_INTERVAL);
assertThat(quotaController.consume("someTaskId").isApproved()).isTrue();
// Now move long into the future
clock.advanceTime(Duration.ofHours(2));
assertThat(quotaController.getQuota(JOB_REFERENCE).getQuota()).isEqualTo(5);
}
@Test
public void testJobUpdate() {
RatePerIntervalRateController firstController = newRatePerIntervalRateController(
exceptRate(REFERENCE_JOB, ratePerInterval(WINDOW_MS, 5)),
SelfJobDisruptionBudgetResolver.getInstance(),
titusRuntime
);
// Take all
consumeAtInterval(firstController, 5, CONSUME_INTERVAL);
assertThat(firstController.getQuota(JOB_REFERENCE).getQuota()).isEqualTo(0);
// Now increase the allowance by reducing the window size and increasing the rate limit
RatePerIntervalRateController updatedController = firstController.update(exceptRate(REFERENCE_JOB, ratePerInterval(WINDOW_MS / 2, 10)));
assertThat(updatedController.getQuota(JOB_REFERENCE).getQuota()).isEqualTo(5);
}
private void consumeAtInterval(RatePerIntervalRateController quotaController, int count, Duration interval) {
for (int i = 0; i < count; i++) {
clock.advanceTime(interval);
assertThat(quotaController.consume("someTaskId").isApproved()).isTrue();
}
}
} | 31 |
0 | Create_ds/titus-control-plane/titus-server-master/src/test/java/com/netflix/titus/master/eviction/service/quota | Create_ds/titus-control-plane/titus-server-master/src/test/java/com/netflix/titus/master/eviction/service/quota/job/UnhealthyTasksLimitTrackerTest.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.master.eviction.service.quota.job;
import java.util.Collections;
import com.netflix.titus.api.containerhealth.model.ContainerHealthState;
import com.netflix.titus.api.jobmanager.model.job.Job;
import com.netflix.titus.api.jobmanager.model.job.TaskState;
import com.netflix.titus.api.jobmanager.model.job.disruptionbudget.AvailabilityPercentageLimitDisruptionBudgetPolicy;
import com.netflix.titus.api.jobmanager.model.job.disruptionbudget.UnhealthyTasksLimitDisruptionBudgetPolicy;
import com.netflix.titus.api.jobmanager.model.job.ext.BatchJobExt;
import com.netflix.titus.api.jobmanager.service.V3JobOperations;
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.testkit.model.job.JobComponentStub;
import org.junit.Test;
import static com.netflix.titus.master.eviction.service.quota.job.UnhealthyTasksLimitTracker.computeHealthyPoolSizeFromAbsoluteLimit;
import static com.netflix.titus.master.eviction.service.quota.job.UnhealthyTasksLimitTracker.computeHealthyPoolSizeFromPercentage;
import static com.netflix.titus.testkit.model.eviction.DisruptionBudgetGenerator.budget;
import static com.netflix.titus.testkit.model.eviction.DisruptionBudgetGenerator.newBatchJob;
import static com.netflix.titus.testkit.model.eviction.DisruptionBudgetGenerator.numberOfHealthyPolicy;
import static com.netflix.titus.testkit.model.eviction.DisruptionBudgetGenerator.percentageOfHealthyPolicy;
import static com.netflix.titus.testkit.model.eviction.DisruptionBudgetGenerator.unlimitedRate;
import static org.assertj.core.api.Assertions.assertThat;
public class UnhealthyTasksLimitTrackerTest {
private final TitusRuntime titusRuntime = TitusRuntimes.test();
private final JobComponentStub jobComponentStub = new JobComponentStub(titusRuntime);
private final V3JobOperations jobOperations = jobComponentStub.getJobOperations();
@Test
public void testComputeHealthyPoolSizeFromPercentage() {
testComputeHealthyPoolSizeFromPercentage(newBatchJobWithPercentageLimit(0, 80), 0);
testComputeHealthyPoolSizeFromPercentage(newBatchJobWithPercentageLimit(1, 80), 0);
testComputeHealthyPoolSizeFromPercentage(newBatchJobWithPercentageLimit(2, 80), 1);
testComputeHealthyPoolSizeFromPercentage(newBatchJobWithPercentageLimit(10, 80), 8);
}
void testComputeHealthyPoolSizeFromPercentage(Job<BatchJobExt> job, int expectedHealthyPoolSize) {
AvailabilityPercentageLimitDisruptionBudgetPolicy policy = (AvailabilityPercentageLimitDisruptionBudgetPolicy) job.getJobDescriptor().getDisruptionBudget().getDisruptionBudgetPolicy();
assertThat(computeHealthyPoolSizeFromPercentage(job, policy)).isEqualTo(expectedHealthyPoolSize);
}
@Test
public void testComputeHealthyPoolSizeFromAbsoluteLimit() {
testComputeHealthyPoolSizeFromAbsoluteLimit(newBatchJobWithAbsoluteLimit(0, 10), 0);
testComputeHealthyPoolSizeFromAbsoluteLimit(newBatchJobWithAbsoluteLimit(1, 10), 0);
testComputeHealthyPoolSizeFromAbsoluteLimit(newBatchJobWithAbsoluteLimit(1, 2), 0);
testComputeHealthyPoolSizeFromAbsoluteLimit(newBatchJobWithAbsoluteLimit(10, 5), 5);
}
private void testComputeHealthyPoolSizeFromAbsoluteLimit(Job<?> job, int expectedHealthyPoolSize) {
UnhealthyTasksLimitDisruptionBudgetPolicy policy = (UnhealthyTasksLimitDisruptionBudgetPolicy) job.getJobDescriptor().getDisruptionBudget().getDisruptionBudgetPolicy();
assertThat(computeHealthyPoolSizeFromAbsoluteLimit(job, policy)).isEqualTo(expectedHealthyPoolSize);
}
@Test
public void testPercentageBasedQuota() {
Job<BatchJobExt> job = newBatchJobWithPercentageLimit(10, 80);
UnhealthyTasksLimitTracker tracker = UnhealthyTasksLimitTracker.percentageLimit(
job,
(AvailabilityPercentageLimitDisruptionBudgetPolicy) job.getJobDescriptor().getDisruptionBudget().getDisruptionBudgetPolicy(),
jobOperations,
jobComponentStub.getContainerHealthService()
);
testQuota(tracker, Reference.job(job.getId()));
}
@Test
public void testPercentageBasedQuotaWithOneTaskJob() {
Job<BatchJobExt> job = newBatchJobWithPercentageLimit(1, 95);
UnhealthyTasksLimitTracker tracker = UnhealthyTasksLimitTracker.percentageLimit(
job,
(AvailabilityPercentageLimitDisruptionBudgetPolicy) job.getJobDescriptor().getDisruptionBudget().getDisruptionBudgetPolicy(),
jobOperations,
jobComponentStub.getContainerHealthService()
);
Reference jobReference = Reference.job(job.getId());
// No tasks are started yet
assertThat(tracker.getQuota(jobReference).getQuota()).isEqualTo(1);
// Start task
jobOperations.getTasks().forEach(task -> jobComponentStub.moveTaskToState(task, TaskState.Started));
assertThat(tracker.getQuota(jobReference).getQuota()).isEqualTo(1);
// Now make one unhealthy. As this is the only task in the job, it should be possible to move it
jobComponentStub.changeContainerHealth(jobOperations.getTasks().get(0).getId(), ContainerHealthState.Unhealthy);
assertThat(tracker.getQuota(jobReference).getQuota()).isEqualTo(1);
}
@Test
public void testAbsoluteLimitBasedQuota() {
Job<?> job = newBatchJobWithAbsoluteLimit(10, 2);
UnhealthyTasksLimitTracker tracker = UnhealthyTasksLimitTracker.absoluteLimit(
job,
(UnhealthyTasksLimitDisruptionBudgetPolicy) job.getJobDescriptor().getDisruptionBudget().getDisruptionBudgetPolicy(),
jobOperations,
jobComponentStub.getContainerHealthService()
);
testQuota(tracker, Reference.job(job.getId()));
}
private void testQuota(UnhealthyTasksLimitTracker tracker, Reference jobReference) {
// No tasks are started yet
assertThat(tracker.getQuota(jobReference).getQuota()).isEqualTo(0);
// Start all of them
jobOperations.getTasks().forEach(task -> jobComponentStub.moveTaskToState(task, TaskState.Started));
assertThat(tracker.getQuota(jobReference).getQuota()).isEqualTo(2);
// Now make one unhealthy
jobComponentStub.changeContainerHealth(jobOperations.getTasks().get(0).getId(), ContainerHealthState.Unhealthy);
assertThat(tracker.getQuota(jobReference).getQuota()).isEqualTo(1);
}
private Job<BatchJobExt> newBatchJobWithPercentageLimit(int desired, int percentage) {
Job<BatchJobExt> job = newBatchJob(desired, budget(percentageOfHealthyPolicy(percentage), unlimitedRate(), Collections.emptyList()));
jobComponentStub.createJobAndTasks(job);
return job;
}
private Job<?> newBatchJobWithAbsoluteLimit(int desired, int absoluteLimit) {
Job<BatchJobExt> job = newBatchJob(desired, budget(numberOfHealthyPolicy(absoluteLimit), unlimitedRate(), Collections.emptyList()));
jobComponentStub.createJobAndTasks(job);
return job;
}
} | 32 |
0 | Create_ds/titus-control-plane/titus-server-master/src/test/java/com/netflix/titus/master/eviction/service/quota | Create_ds/titus-control-plane/titus-server-master/src/test/java/com/netflix/titus/master/eviction/service/quota/job/TaskRelocationLimitControllerTest.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.master.eviction.service.quota.job;
import java.util.Collections;
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.api.jobmanager.model.job.ext.BatchJobExt;
import com.netflix.titus.api.jobmanager.service.V3JobOperations;
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.testkit.model.job.JobComponentStub;
import org.junit.Test;
import static com.netflix.titus.api.jobmanager.model.job.JobFunctions.changeBatchJobSize;
import static com.netflix.titus.testkit.model.eviction.DisruptionBudgetGenerator.budget;
import static com.netflix.titus.testkit.model.eviction.DisruptionBudgetGenerator.exceptPolicy;
import static com.netflix.titus.testkit.model.eviction.DisruptionBudgetGenerator.hourlyRatePercentage;
import static com.netflix.titus.testkit.model.eviction.DisruptionBudgetGenerator.newBatchJob;
import static com.netflix.titus.testkit.model.eviction.DisruptionBudgetGenerator.perTaskRelocationLimitPolicy;
import static org.assertj.core.api.Assertions.assertThat;
public class TaskRelocationLimitControllerTest {
private static final Job<BatchJobExt> REFERENCE_JOB = newBatchJob(
10,
budget(perTaskRelocationLimitPolicy(10), hourlyRatePercentage(100), Collections.emptyList())
);
private final TitusRuntime titusRuntime = TitusRuntimes.test();
private final JobComponentStub jobComponentStub = new JobComponentStub(titusRuntime);
private final V3JobOperations jobOperations = jobComponentStub.getJobOperations();
@Test
public void testQuota() {
Job<BatchJobExt> job = createBatchJob(2);
Task task = jobOperations.getTasks(job.getId()).get(0);
Reference jobReference = Reference.job(job.getId());
Reference taskReference = Reference.task(task.getId());
TaskRelocationLimitController quotaController = new TaskRelocationLimitController(job, jobOperations, SelfJobDisruptionBudgetResolver.getInstance());
assertThat(quotaController.getQuota(jobReference).getQuota()).isEqualTo(10);
assertThat(quotaController.getQuota(taskReference).getQuota()).isEqualTo(1);
// Now consume quotas for the first task
assertThat(quotaController.consume(task.getId()).isApproved()).isTrue();
assertThat(quotaController.getQuota(taskReference).getQuota()).isEqualTo(1);
jobComponentStub.moveTaskToState(task, TaskState.Started);
jobComponentStub.killTask(task, false, false, V3JobOperations.Trigger.Eviction);
Task replacement1 = jobComponentStub.getJobOperations().getTasks().stream().filter(t -> t.getOriginalId().equals(task.getId())).findFirst().get();
assertThat(quotaController.consume(replacement1.getId()).isApproved()).isTrue();
assertThat(quotaController.getQuota(jobReference).getQuota()).isEqualTo(10);
assertThat(quotaController.getQuota(taskReference).getQuota()).isEqualTo(0);
jobComponentStub.moveTaskToState(replacement1, TaskState.Started);
jobComponentStub.killTask(replacement1, false, false, V3JobOperations.Trigger.Eviction);
Task replacement2 = jobComponentStub.getJobOperations().getTasks().stream().filter(t -> t.getOriginalId().equals(task.getId())).findFirst().get();
assertThat(quotaController.consume(replacement2.getId()).isApproved()).isFalse();
assertThat(quotaController.getQuota(jobReference).getQuota()).isEqualTo(9);
}
@Test
public void testJobUpdate() {
Job<BatchJobExt> job = createBatchJob(1);
Task task = jobOperations.getTasks(job.getId()).get(0);
Reference jobReference = Reference.job(job.getId());
// Consume in first instance of the controller
TaskRelocationLimitController firstController = new TaskRelocationLimitController(job, jobOperations, SelfJobDisruptionBudgetResolver.getInstance());
assertThat(firstController.consume(task.getId()).isApproved()).isTrue();
jobComponentStub.moveTaskToState(task, TaskState.Started);
jobComponentStub.killTask(task, false, false, V3JobOperations.Trigger.Eviction);
Task replacement1 = jobComponentStub.getJobOperations().getTasks().stream().filter(t -> t.getOriginalId().equals(task.getId())).findFirst().get();
assertThat(firstController.consume(replacement1.getId()).isApproved()).isFalse();
// Update
Job<BatchJobExt> updatedJob = exceptPolicy(changeBatchJobSize(job, 20), perTaskRelocationLimitPolicy(2));
jobComponentStub.changeJob(updatedJob);
jobComponentStub.createDesiredTasks(updatedJob);
TaskRelocationLimitController updatedController = firstController.update(updatedJob);
assertThat(updatedController.getQuota(jobReference).getQuota()).isEqualTo(20);
// Consume again, after limit increase
assertThat(updatedController.consume(replacement1.getId()).isApproved()).isTrue();
jobComponentStub.moveTaskToState(replacement1, TaskState.Started);
jobComponentStub.killTask(replacement1, false, false, V3JobOperations.Trigger.Eviction);
Task replacement2 = jobComponentStub.getJobOperations().getTasks().stream().filter(t -> t.getOriginalId().equals(task.getId())).findFirst().get();
assertThat(updatedController.consume(replacement2.getId()).isApproved()).isFalse();
assertThat(updatedController.getQuota(jobReference).getQuota()).isEqualTo(19);
}
private Job<BatchJobExt> createBatchJob(int limit) {
Job<BatchJobExt> job = exceptPolicy(REFERENCE_JOB, perTaskRelocationLimitPolicy(limit));
return jobComponentStub.createJobAndTasks(job).getLeft();
}
} | 33 |
0 | Create_ds/titus-control-plane/titus-server-master/src/test/java/com/netflix/titus/master/eviction/service/quota | Create_ds/titus-control-plane/titus-server-master/src/test/java/com/netflix/titus/master/eviction/service/quota/job/JobQuotaControllerTest.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.master.eviction.service.quota.job;
import java.time.DayOfWeek;
import java.util.Collections;
import java.util.List;
import java.util.Set;
import java.util.stream.Collectors;
import java.util.stream.Stream;
import com.netflix.titus.api.containerhealth.service.ContainerHealthService;
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.Task;
import com.netflix.titus.api.jobmanager.model.job.TaskState;
import com.netflix.titus.api.jobmanager.model.job.ext.BatchJobExt;
import com.netflix.titus.api.jobmanager.service.V3JobOperations;
import com.netflix.titus.common.runtime.TitusRuntime;
import com.netflix.titus.common.runtime.TitusRuntimes;
import com.netflix.titus.common.util.time.Clocks;
import com.netflix.titus.common.util.time.TestClock;
import com.netflix.titus.master.eviction.service.quota.ConsumptionResult;
import com.netflix.titus.master.eviction.service.quota.QuotaController;
import com.netflix.titus.master.eviction.service.quota.QuotaTracker;
import com.netflix.titus.master.eviction.service.quota.TimeWindowQuotaTracker;
import com.netflix.titus.testkit.model.job.JobComponentStub;
import org.junit.Test;
import static com.netflix.titus.master.eviction.service.quota.job.JobQuotaController.buildQuotaControllers;
import static com.netflix.titus.master.eviction.service.quota.job.JobQuotaController.buildQuotaTrackers;
import static com.netflix.titus.master.eviction.service.quota.job.JobQuotaController.mergeQuotaControllers;
import static com.netflix.titus.testkit.model.eviction.DisruptionBudgetGenerator.budget;
import static com.netflix.titus.testkit.model.eviction.DisruptionBudgetGenerator.exceptBudget;
import static com.netflix.titus.testkit.model.eviction.DisruptionBudgetGenerator.exceptPolicy;
import static com.netflix.titus.testkit.model.eviction.DisruptionBudgetGenerator.exceptRate;
import static com.netflix.titus.testkit.model.eviction.DisruptionBudgetGenerator.hourlyRatePercentage;
import static com.netflix.titus.testkit.model.eviction.DisruptionBudgetGenerator.newBatchJob;
import static com.netflix.titus.testkit.model.eviction.DisruptionBudgetGenerator.numberOfHealthyPolicy;
import static com.netflix.titus.testkit.model.eviction.DisruptionBudgetGenerator.officeHourTimeWindow;
import static com.netflix.titus.testkit.model.eviction.DisruptionBudgetGenerator.perTaskRelocationLimitPolicy;
import static com.netflix.titus.testkit.model.eviction.DisruptionBudgetGenerator.percentageOfHealthyPolicy;
import static com.netflix.titus.testkit.model.eviction.DisruptionBudgetGenerator.ratePerInterval;
import static com.netflix.titus.testkit.model.eviction.DisruptionBudgetGenerator.selfManagedPolicy;
import static com.netflix.titus.testkit.model.eviction.DisruptionBudgetGenerator.unlimitedRate;
import static java.util.Collections.singletonList;
import static org.assertj.core.api.Assertions.assertThat;
public class JobQuotaControllerTest {
private final TestClock clock = Clocks.testWorldClock("PST").jumpForwardTo(DayOfWeek.MONDAY).resetTime(9, 0, 0);
private final TitusRuntime titusRuntime = TitusRuntimes.test(clock);
private final JobComponentStub jobComponentStub = new JobComponentStub(titusRuntime);
private final V3JobOperations jobOperations = jobComponentStub.getJobOperations();
private final ContainerHealthService containerHealthService = jobComponentStub.getContainerHealthService();
@Test
public void testBuildQuotaTrackers() {
testBuildQuotaTrackers(
scheduleJob(
newBatchJob(10, budget(percentageOfHealthyPolicy(80.0), hourlyRatePercentage(5), Collections.emptyList())),
10
),
SelfJobDisruptionBudgetResolver.getInstance(),
UnhealthyTasksLimitTracker.class
);
testBuildQuotaTrackers(
scheduleJob(
newBatchJob(10, budget(percentageOfHealthyPolicy(80.0), hourlyRatePercentage(5), singletonList(officeHourTimeWindow()))),
10
),
SelfJobDisruptionBudgetResolver.getInstance(),
UnhealthyTasksLimitTracker.class, TimeWindowQuotaTracker.class
);
testBuildQuotaTrackers(
scheduleJob(
newBatchJob(10, budget(numberOfHealthyPolicy(2), hourlyRatePercentage(5), singletonList(officeHourTimeWindow()))),
10
),
SelfJobDisruptionBudgetResolver.getInstance(),
UnhealthyTasksLimitTracker.class, TimeWindowQuotaTracker.class
);
testBuildQuotaTrackers(
scheduleJob(
newBatchJob(10, budget(selfManagedPolicy(10_000), unlimitedRate(), Collections.emptyList())),
10
),
job -> budget(perTaskRelocationLimitPolicy(100), hourlyRatePercentage(5), singletonList(officeHourTimeWindow())),
TimeWindowQuotaTracker.class
);
}
private void testBuildQuotaTrackers(Job<?> job, EffectiveJobDisruptionBudgetResolver fallback, Class<?>... expectedTypes) {
List<QuotaTracker> trackers = buildQuotaTrackers(job, jobOperations, fallback, containerHealthService, titusRuntime);
checkContains(trackers, expectedTypes);
}
@Test
public void testBuildQuotaControllers() {
testBuildQuotaControllers(
scheduleJob(
newBatchJob(10, budget(perTaskRelocationLimitPolicy(3), unlimitedRate(), Collections.emptyList())),
10
),
SelfJobDisruptionBudgetResolver.getInstance(),
TaskRelocationLimitController.class
);
testBuildQuotaControllers(
scheduleJob(
newBatchJob(10, budget(perTaskRelocationLimitPolicy(3), hourlyRatePercentage(5), Collections.emptyList())),
10
),
SelfJobDisruptionBudgetResolver.getInstance(),
JobPercentagePerHourRelocationRateController.class, TaskRelocationLimitController.class
);
testBuildQuotaControllers(
scheduleJob(
newBatchJob(10, budget(perTaskRelocationLimitPolicy(3), ratePerInterval(60_000, 5), Collections.emptyList())),
10
),
SelfJobDisruptionBudgetResolver.getInstance(),
RatePerIntervalRateController.class, TaskRelocationLimitController.class
);
testBuildQuotaControllers(
scheduleJob(
newBatchJob(10, budget(selfManagedPolicy(10_000), unlimitedRate(), Collections.emptyList())),
10
),
job -> budget(perTaskRelocationLimitPolicy(100), hourlyRatePercentage(5), singletonList(officeHourTimeWindow())),
TaskRelocationLimitController.class, JobPercentagePerHourRelocationRateController.class
);
}
private void testBuildQuotaControllers(Job<?> job, EffectiveJobDisruptionBudgetResolver fallback, Class<?>... expectedTypes) {
List<QuotaController<Job<?>>> controllers = buildQuotaControllers(job, jobOperations, fallback, titusRuntime);
checkContains(controllers, expectedTypes);
}
@Test
public void testMergePercentagePerHourDisruptionBudgetRateQuotaController() {
// First version
Job<BatchJobExt> job = newBatchJob(10, budget(perTaskRelocationLimitPolicy(3), hourlyRatePercentage(50), Collections.emptyList()));
com.netflix.titus.api.model.reference.Reference jobReference = com.netflix.titus.api.model.reference.Reference.job(job.getId());
scheduleJob(job, 10);
List<QuotaController<Job<?>>> controllers = buildQuotaControllers(job, jobOperations, SelfJobDisruptionBudgetResolver.getInstance(), titusRuntime);
JobPercentagePerHourRelocationRateController controller = (JobPercentagePerHourRelocationRateController) controllers.get(0);
Task task = jobOperations.getTasks(job.getId()).get(0);
assertThat(controller.consume(task.getId()).isApproved()).isTrue();
assertThat(controller.getQuota(jobReference).getQuota()).isEqualTo(4);
// Change job descriptor and consume some quota
Job<BatchJobExt> updatedJob = jobComponentStub.changeJob(exceptRate(job, hourlyRatePercentage(80)));
List<QuotaController<Job<?>>> merged = mergeQuotaControllers(controllers, updatedJob, jobOperations, SelfJobDisruptionBudgetResolver.getInstance(), titusRuntime);
JobPercentagePerHourRelocationRateController updatedController = (JobPercentagePerHourRelocationRateController) merged.get(0);
assertThat(updatedController.getQuota(jobReference).getQuota()).isEqualTo(7);
}
@Test
public void testMergeRatePerIntervalDisruptionBudgetRateQuotaController() {
// First version
Job<BatchJobExt> job = newBatchJob(10, budget(perTaskRelocationLimitPolicy(3), ratePerInterval(60_000, 5), Collections.emptyList()));
com.netflix.titus.api.model.reference.Reference jobReference = com.netflix.titus.api.model.reference.Reference.job(job.getId());
scheduleJob(job, 10);
List<QuotaController<Job<?>>> controllers = buildQuotaControllers(job, jobOperations, SelfJobDisruptionBudgetResolver.getInstance(), titusRuntime);
RatePerIntervalRateController controller = (RatePerIntervalRateController) controllers.get(0);
Task task = jobOperations.getTasks(job.getId()).get(0);
assertThat(controller.consume(task.getId()).isApproved()).isTrue();
assertThat(controller.getQuota(jobReference).getQuota()).isEqualTo(4);
// Change job descriptor and consume some quota
Job<BatchJobExt> updatedJob = jobComponentStub.changeJob(exceptRate(job, ratePerInterval(30_000, 5)));
List<QuotaController<Job<?>>> merged = mergeQuotaControllers(controllers, updatedJob, jobOperations, SelfJobDisruptionBudgetResolver.getInstance(), titusRuntime);
RatePerIntervalRateController updatedController = (RatePerIntervalRateController) merged.get(0);
assertThat(updatedController.getQuota(jobReference).getQuota()).isEqualTo(4);
}
@Test
public void testMergeTaskRelocationLimitController() {
// First version
Job<BatchJobExt> job = newBatchJob(10, budget(perTaskRelocationLimitPolicy(1), unlimitedRate(), Collections.emptyList()));
scheduleJob(job, 10);
List<QuotaController<Job<?>>> controllers = buildQuotaControllers(job, jobOperations, SelfJobDisruptionBudgetResolver.getInstance(), titusRuntime);
TaskRelocationLimitController controller = (TaskRelocationLimitController) controllers.get(0);
Task task = jobOperations.getTasks(job.getId()).get(0);
assertThat(controller.consume(task.getId()).isApproved()).isTrue();
jobComponentStub.killTask(task, false, false, V3JobOperations.Trigger.Eviction);
assertThat(controller.consume(task.getId()).isApproved()).isFalse();
Task replacement1 = jobComponentStub.getJobOperations().getTasks().stream().filter(t -> t.getOriginalId().equals(task.getId())).findFirst().get();
jobComponentStub.moveTaskToState(replacement1, TaskState.Started);
// Change job descriptor and consume some quota
Job<BatchJobExt> updatedJob = jobComponentStub.changeJob(exceptPolicy(job, perTaskRelocationLimitPolicy(3)));
List<QuotaController<Job<?>>> merged = mergeQuotaControllers(controllers, updatedJob, jobOperations, SelfJobDisruptionBudgetResolver.getInstance(), titusRuntime);
TaskRelocationLimitController updatedController = (TaskRelocationLimitController) merged.get(0);
// Evict replacement 1
assertThat(updatedController.consume(replacement1.getId()).isApproved()).isTrue();
jobComponentStub.killTask(replacement1, false, false, V3JobOperations.Trigger.Eviction);
Task replacement2 = jobComponentStub.getJobOperations().getTasks().stream().filter(t -> t.getOriginalId().equals(task.getId())).findFirst().get();
jobComponentStub.moveTaskToState(replacement2, TaskState.Started);
// Evict replacement 2
assertThat(updatedController.consume(replacement2.getId()).isApproved()).isTrue();
jobComponentStub.killTask(replacement2, false, false, V3JobOperations.Trigger.Eviction);
Task replacement3 = jobComponentStub.getJobOperations().getTasks().stream().filter(t -> t.getOriginalId().equals(task.getId())).findFirst().get();
jobComponentStub.moveTaskToState(replacement3, TaskState.Started);
assertThat(updatedController.consume(replacement3.getId()).isApproved()).isFalse();
}
@Test
public void testGetQuota() {
Job<BatchJobExt> job = newBatchJob(10, budget(percentageOfHealthyPolicy(80.0), hourlyRatePercentage(50), singletonList(officeHourTimeWindow())));
com.netflix.titus.api.model.reference.Reference jobReference = com.netflix.titus.api.model.reference.Reference.job(job.getId());
scheduleJob(job, 10);
JobQuotaController jobController = new JobQuotaController(job, jobOperations, SelfJobDisruptionBudgetResolver.getInstance(), containerHealthService, titusRuntime);
assertThat(jobController.getQuota(jobReference).getQuota()).isEqualTo(2);
clock.jumpForwardTo(DayOfWeek.SATURDAY);
assertThat(jobController.getQuota(jobReference).getQuota()).isEqualTo(0);
}
@Test
public void testConsume() {
Job<BatchJobExt> job = newBatchJob(10, budget(percentageOfHealthyPolicy(80.0), hourlyRatePercentage(20), Collections.emptyList()));
com.netflix.titus.api.model.reference.Reference jobReference = com.netflix.titus.api.model.reference.Reference.job(job.getId());
scheduleJob(job, 10);
JobQuotaController jobController = new JobQuotaController(job, jobOperations, SelfJobDisruptionBudgetResolver.getInstance(), containerHealthService, titusRuntime);
assertThat(jobController.getQuota(jobReference).getQuota()).isEqualTo(2);
Task task = jobOperations.getTasks(job.getId()).get(0);
assertThat(jobController.consume(task.getId()).isApproved()).isTrue();
assertThat(jobController.consume(task.getId()).isApproved()).isTrue();
assertThat(jobController.getQuota(jobReference).getQuota()).isEqualTo(0);
ConsumptionResult failure = jobController.consume(task.getId());
assertThat(failure.isApproved()).isFalse();
assertThat(failure.getRejectionReason().get()).contains("JobPercentagePerHourRelocationRateController");
}
@Test
public void testUpdate() {
Job<BatchJobExt> job = newBatchJob(10, budget(perTaskRelocationLimitPolicy(2), hourlyRatePercentage(20), Collections.emptyList()));
com.netflix.titus.api.model.reference.Reference jobReference = com.netflix.titus.api.model.reference.Reference.job(job.getId());
scheduleJob(job, 10);
JobQuotaController jobController = new JobQuotaController(job, jobOperations, SelfJobDisruptionBudgetResolver.getInstance(), containerHealthService, titusRuntime);
assertThat(jobController.getQuota(jobReference).getQuota()).isEqualTo(2);
// Evict task 1
Task task = jobOperations.getTasks(job.getId()).get(0);
assertThat(jobController.consume(task.getId()).isApproved()).isTrue();
jobComponentStub.killTask(task, false, false, V3JobOperations.Trigger.Eviction);
Task replacement1 = jobComponentStub.getJobOperations().getTasks().stream().filter(t -> t.getOriginalId().equals(task.getId())).findFirst().get();
// Evict replacement 1
assertThat(jobController.consume(replacement1.getId()).isApproved()).isTrue();
jobComponentStub.moveTaskToState(replacement1, TaskState.Started);
jobComponentStub.killTask(replacement1, false, false, V3JobOperations.Trigger.Eviction);
Task replacement2 = jobComponentStub.getJobOperations().getTasks().stream().filter(t -> t.getOriginalId().equals(task.getId())).findFirst().get();
assertThat(jobController.consume(replacement2.getId()).isApproved()).isFalse();
assertThat(jobController.getQuota(jobReference).getQuota()).isEqualTo(0);
// Now bump up the limit by 1
Job<BatchJobExt> updatedJob = jobComponentStub.changeJob(
exceptBudget(job, budget(perTaskRelocationLimitPolicy(3), hourlyRatePercentage(80), Collections.emptyList()))
);
JobQuotaController updatedController = jobController.update(updatedJob);
// Evict replacement 2
assertThat(updatedController.consume(replacement2.getId()).isApproved()).isTrue();
jobComponentStub.moveTaskToState(replacement2, TaskState.Started);
jobComponentStub.killTask(replacement2, false, false, V3JobOperations.Trigger.Eviction);
Task replacement3 = jobComponentStub.getJobOperations().getTasks().stream().filter(t -> t.getOriginalId().equals(task.getId())).findFirst().get();
assertThat(updatedController.consume(replacement3.getId()).isApproved()).isFalse();
assertThat(updatedController.getQuota(jobReference).getQuota()).isEqualTo(5); // 3 task killed out of 8 allowed in an hour
// Now increase job size
Job<BatchJobExt> scaledJob = jobComponentStub.changeJob(JobFunctions.changeBatchJobSize(updatedJob, 20));
jobComponentStub.createDesiredTasks(scaledJob);
JobQuotaController updatedController2 = jobController.update(scaledJob);
assertThat(updatedController2.getQuota(jobReference).getQuota()).isEqualTo(13); // 3 task kills out of 16 allowed in an hour
}
@Test
public void testSelfManagedJobUsesInternalDisruptionBudget() {
Job<BatchJobExt> job = newBatchJob(10, budget(selfManagedPolicy(1_000), unlimitedRate(), Collections.emptyList()));
com.netflix.titus.api.model.reference.Reference jobReference = com.netflix.titus.api.model.reference.Reference.job(job.getId());
scheduleJob(job, 10);
EffectiveJobDisruptionBudgetResolver budgetResolver = j -> budget(perTaskRelocationLimitPolicy(100), hourlyRatePercentage(5), singletonList(officeHourTimeWindow()));
JobQuotaController jobController = new JobQuotaController(job, jobOperations, budgetResolver, containerHealthService, titusRuntime);
assertThat(jobController.getQuota(jobReference).getQuota()).isEqualTo(1);
Task task = jobOperations.getTasks(job.getId()).get(0);
assertThat(jobController.consume(task.getId()).isApproved()).isTrue();
assertThat(jobController.getQuota(jobReference).getQuota()).isEqualTo(0);
ConsumptionResult failure = jobController.consume(task.getId());
assertThat(failure.isApproved()).isFalse();
assertThat(failure.getRejectionReason().get()).contains("JobPercentagePerHourRelocationRateController");
}
private void checkContains(List<? extends QuotaTracker> trackers, Class<?>... expectedTypes) {
Set<String> found = trackers.stream().map(t -> t.getClass().getSimpleName()).collect(Collectors.toSet());
Set<String> expected = Stream.of(expectedTypes).map(Class::getSimpleName).collect(Collectors.toSet());
assertThat(found).isEqualTo(expected);
}
private Job<?> scheduleJob(Job<?> job, int started) {
jobComponentStub.createJob(job);
List<Task> tasks = jobComponentStub.createDesiredTasks(job);
for (int i = 0; i < started; i++) {
jobComponentStub.moveTaskToState(tasks.get(i), TaskState.Started);
}
return job;
}
} | 34 |
0 | Create_ds/titus-control-plane/titus-server-master/src/main/java/com/netflix/titus | Create_ds/titus-control-plane/titus-server-master/src/main/java/com/netflix/titus/master/TitusRuntimeModule.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.master;
import java.util.Optional;
import java.util.function.Function;
import javax.inject.Inject;
import javax.inject.Singleton;
import com.google.inject.AbstractModule;
import com.google.inject.Provides;
import com.google.protobuf.util.JsonFormat;
import com.netflix.archaius.api.Config;
import com.netflix.spectator.api.Registry;
import com.netflix.titus.api.jobmanager.service.V3JobOperations;
import com.netflix.titus.api.jobmanager.store.JobStoreFitAction;
import com.netflix.titus.api.model.callmetadata.CallMetadata;
import com.netflix.titus.api.model.callmetadata.CallMetadataConstants;
import com.netflix.titus.api.supervisor.service.LeaderActivator;
import com.netflix.titus.common.environment.MyEnvironments;
import com.netflix.titus.common.framework.fit.FitAction;
import com.netflix.titus.common.framework.fit.FitComponent;
import com.netflix.titus.common.framework.fit.FitFramework;
import com.netflix.titus.common.framework.fit.FitInjection;
import com.netflix.titus.common.framework.fit.FitRegistry;
import com.netflix.titus.common.framework.fit.FitUtil;
import com.netflix.titus.common.jhiccup.JHiccupModule;
import com.netflix.titus.common.runtime.SystemAbortListener;
import com.netflix.titus.common.runtime.SystemLogService;
import com.netflix.titus.common.runtime.TitusRuntime;
import com.netflix.titus.common.runtime.internal.DefaultTitusRuntime;
import com.netflix.titus.common.runtime.internal.LoggingSystemAbortListener;
import com.netflix.titus.common.runtime.internal.LoggingSystemLogService;
import com.netflix.titus.common.util.StringExt;
import com.netflix.titus.common.util.code.CodeInvariants;
import com.netflix.titus.common.util.code.CompositeCodeInvariants;
import com.netflix.titus.common.util.code.LoggingCodeInvariants;
import com.netflix.titus.common.util.code.SpectatorCodeInvariants;
import com.netflix.titus.common.util.grpc.reactor.GrpcToReactorServerFactory;
import com.netflix.titus.common.util.grpc.reactor.server.DefaultGrpcToReactorServerFactory;
import com.netflix.titus.common.util.guice.ContainerEventBusModule;
import com.netflix.titus.common.util.rx.eventbus.RxEventBus;
import com.netflix.titus.common.util.rx.eventbus.internal.DefaultRxEventBus;
import com.netflix.titus.master.kubernetes.client.DirectKubeApiServerIntegrator;
import com.netflix.titus.master.kubernetes.client.KubeFitAction;
import com.netflix.titus.runtime.Fit;
import com.netflix.titus.runtime.endpoint.metadata.CallMetadataResolver;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
/**
* Core runtime services.
*/
public class TitusRuntimeModule extends AbstractModule {
private static final Logger logger = LoggerFactory.getLogger(TitusRuntimeModule.class);
public static final String FIT_CONFIGURATION_PREFIX = "titusMaster.runtime.fitActions.";
private final boolean systemExitOnFailure;
public TitusRuntimeModule(boolean systemExitOnFailure) {
this.systemExitOnFailure = systemExitOnFailure;
}
@Override
protected void configure() {
// Framework services
install(new ContainerEventBusModule());
install(new JHiccupModule());
bind(SystemLogService.class).to(LoggingSystemLogService.class);
bind(SystemAbortListener.class).to(LoggingSystemAbortListener.class);
bind(FitActionInitializer.class).asEagerSingleton();
}
@Singleton
@Provides
public RxEventBus getRxEventBugs(Registry registry) {
return new DefaultRxEventBus(registry.createId(MetricConstants.METRIC_ROOT + "eventbus."), registry);
}
@Provides
@Singleton
public TitusRuntime getTitusRuntime(Config config, SystemLogService systemLogService, SystemAbortListener systemAbortListener, Registry registry) {
CodeInvariants codeInvariants = new CompositeCodeInvariants(
LoggingCodeInvariants.getDefault(),
new SpectatorCodeInvariants(registry.createId("titus.runtime.invariant.violations"), registry)
);
DefaultTitusRuntime titusRuntime = new DefaultTitusRuntime(
MyEnvironments.newArchaius(config),
codeInvariants, systemLogService, systemExitOnFailure, systemAbortListener, registry
);
// Setup FIT component hierarchy
FitFramework fitFramework = titusRuntime.getFitFramework();
if (fitFramework.isActive()) {
FitComponent root = fitFramework.getRootComponent();
root.createChild(LeaderActivator.COMPONENT);
root.createChild(V3JobOperations.COMPONENT);
root.createChild(DirectKubeApiServerIntegrator.COMPONENT);
// Add custom FIT actions
FitRegistry fitRegistry = fitFramework.getFitRegistry();
fitRegistry.registerActionKind(
JobStoreFitAction.DESCRIPTOR,
(id, properties) -> injection -> new JobStoreFitAction(id, properties, injection)
);
fitRegistry.registerActionKind(
KubeFitAction.DESCRIPTOR,
(id, properties) -> injection -> new KubeFitAction(id, properties, injection)
);
}
return titusRuntime;
}
@Provides
@Singleton
public GrpcToReactorServerFactory getGrpcToReactorServerFactory(CallMetadataResolver callMetadataResolver) {
return new DefaultGrpcToReactorServerFactory<>(
CallMetadata.class,
() -> callMetadataResolver.resolve().orElse(CallMetadataConstants.UNDEFINED_CALL_METADATA)
);
}
@Singleton
private static class FitActionInitializer {
@Inject
public FitActionInitializer(Config config, TitusRuntime titusRuntime) {
FitFramework fitFramework = titusRuntime.getFitFramework();
// Load FIT actions from configuration.
int i = 0;
Optional<Fit.AddAction> next;
while ((next = toFitAddAction(config, i)).isPresent()) {
Fit.AddAction request = next.get();
try {
FitComponent fitComponent = FitUtil.getFitComponentOrFail(fitFramework, request.getComponentId());
FitInjection fitInjection = FitUtil.getFitInjectionOrFail(request.getInjectionId(), fitComponent);
Function<FitInjection, FitAction> fitActionFactory = fitFramework.getFitRegistry().newFitActionFactory(
request.getActionKind(), request.getActionId(), request.getPropertiesMap()
);
fitInjection.addAction(fitActionFactory.apply(fitInjection));
} catch (Exception e) {
logger.error("Cannot add FIT action to the framework", e);
}
i++;
}
}
private Optional<Fit.AddAction> toFitAddAction(Config config, int index) {
String requestJson;
try {
requestJson = config.getString(FIT_CONFIGURATION_PREFIX + index);
if (!StringExt.isNotEmpty(requestJson)) {
return Optional.empty();
}
} catch (Exception e) {
logger.error("Cannot find FIT action at index {}; aborting the loading process", index);
return Optional.empty();
}
try {
Fit.AddAction.Builder builder = Fit.AddAction.newBuilder();
JsonFormat.parser().merge(requestJson, builder);
return Optional.of(builder.build());
} catch (Exception e) {
logger.error("Cannot parse FIT action add request; ignoring it: {}", requestJson, e);
return Optional.empty();
}
}
}
}
| 35 |
0 | Create_ds/titus-control-plane/titus-server-master/src/main/java/com/netflix/titus | Create_ds/titus-control-plane/titus-server-master/src/main/java/com/netflix/titus/master/MasterDescriptions.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.master;
import java.net.InetAddress;
import java.net.UnknownHostException;
import com.netflix.titus.master.config.MasterConfiguration;
import com.netflix.titus.api.supervisor.service.MasterDescription;
/**
*/
public final class MasterDescriptions {
private MasterDescriptions() {
}
public static MasterDescription create(MasterConfiguration masterConfiguration) {
return create(
masterConfiguration.getMasterHost(),
masterConfiguration.getMasterIP(),
masterConfiguration.getApiProxyPort(),
masterConfiguration.getApiStatusUri()
);
}
public static MasterDescription create(String masterHost, String masterIp, int apiPort, String apiStatusUri) {
return new MasterDescription(
getHost(masterHost),
getHostIP(masterIp),
apiPort,
apiStatusUri,
System.currentTimeMillis()
);
}
private static String getHost(String host) {
if (host != null && !host.isEmpty()) {
return host;
}
try {
return InetAddress.getLocalHost().getHostName();
} catch (UnknownHostException e) {
throw new RuntimeException("Failed to get the host information: " + e.getMessage(), e);
}
}
private static String getHostIP(String masterIp) {
String ip = masterIp;
if (ip != null && !ip.isEmpty()) {
return ip;
}
try {
return InetAddress.getLocalHost().getHostAddress();
} catch (UnknownHostException e) {
throw new RuntimeException("Failed to get the host information: " + e.getMessage(), e);
}
}
}
| 36 |
0 | Create_ds/titus-control-plane/titus-server-master/src/main/java/com/netflix/titus | Create_ds/titus-control-plane/titus-server-master/src/main/java/com/netflix/titus/master/TitusMaster.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.master;
import java.io.FileReader;
import java.io.IOException;
import java.util.Collections;
import java.util.Properties;
import com.google.inject.AbstractModule;
import com.google.inject.util.Modules;
import com.netflix.archaius.config.MapConfig;
import com.netflix.archaius.guice.ArchaiusModule;
import com.netflix.governator.InjectorBuilder;
import com.netflix.governator.LifecycleInjector;
import com.netflix.governator.guice.jetty.Archaius2JettyModule;
import com.netflix.spectator.api.DefaultRegistry;
import com.netflix.spectator.api.Registry;
import com.netflix.titus.common.util.archaius2.Archaius2ConfigurationLogger;
import com.netflix.titus.common.util.guice.ContainerEventBus;
import com.sampullara.cli.Args;
import com.sampullara.cli.Argument;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public class TitusMaster {
private static final Logger logger = LoggerFactory.getLogger(TitusMaster.class);
@Argument(alias = "p", description = "Specify a properties file", required = true)
private static String propertiesFile;
public static void main(String[] args) {
try {
Args.parse(TitusMaster.class, args);
} catch (IllegalArgumentException e) {
Args.usage(TitusMaster.class);
System.exit(1);
}
try {
String resourceDir = TitusMaster.class.getClassLoader().getResource("static").toExternalForm();
LifecycleInjector injector = InjectorBuilder.fromModules(
Modules.override(new TitusRuntimeModule(true)).with(
new AbstractModule() {
@Override
protected void configure() {
bind(Archaius2ConfigurationLogger.class).asEagerSingleton();
bind(Registry.class).toInstance(new DefaultRegistry());
}
}
),
new TitusMasterModule(),
new Archaius2JettyModule(),
new ArchaiusModule() {
@Override
protected void configureArchaius() {
bindDefaultConfig().toInstance(MapConfig.builder()
.put("governator.jetty.embedded.port", "${titus.master.apiport}")
.put("governator.jetty.embedded.webAppResourceBase", resourceDir)
.build());
bindApplicationConfigurationOverride().toInstance(loadPropertiesFile(propertiesFile));
}
}
).createInjector();
injector.getInstance(ContainerEventBus.class).submitInOrder(new ContainerEventBus.ContainerStartedEvent());
injector.awaitTermination();
} catch (Exception e) {
// unexpected to get a RuntimeException, will exit
logger.error("Unexpected error: {}", e.getMessage(), e);
System.exit(2);
}
}
private static MapConfig loadPropertiesFile(String propertiesFile) {
if (propertiesFile == null) {
return MapConfig.from(Collections.emptyMap());
}
Properties properties = new Properties();
try (FileReader fr = new FileReader(propertiesFile)) {
properties.load(fr);
} catch (IOException e) {
throw new IllegalArgumentException("Cannot load file: " + propertiesFile, e);
}
return MapConfig.from(properties);
}
} | 37 |
0 | Create_ds/titus-control-plane/titus-server-master/src/main/java/com/netflix/titus | Create_ds/titus-control-plane/titus-server-master/src/main/java/com/netflix/titus/master/MetricConstants.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.master;
/**
* Set of metric related constants that establish consistent naming convention.
*/
public class MetricConstants {
public static final String METRIC_ROOT = "titusMaster.";
public static final String METRIC_SUPERVISOR = METRIC_ROOT + "supervisor.";
public static final String METRIC_CAPACITY_MANAGEMENT = METRIC_ROOT + "capacity.";
public static final String METRIC_SCHEDULING_EVICTION = METRIC_ROOT + "eviction.";
public static final String METRIC_LEADER = METRIC_ROOT + "leader.";
public static final String METRIC_KUBERNETES = METRIC_ROOT + "kubernetes.";
public static final String METRIC_KUBERNETES_CONTROLLER = METRIC_KUBERNETES + "controller.";
public static final String METRIC_LOADBALANCER = METRIC_ROOT + "loadBalancer.";
public static final String METRIC_JOB_MANAGER = METRIC_ROOT + "jobManager.";
}
| 38 |
0 | Create_ds/titus-control-plane/titus-server-master/src/main/java/com/netflix/titus | Create_ds/titus-control-plane/titus-server-master/src/main/java/com/netflix/titus/master/TitusMasterModule.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.master;
import javax.inject.Singleton;
import com.google.common.base.Preconditions;
import com.google.inject.AbstractModule;
import com.google.inject.Provides;
import com.google.inject.multibindings.Multibinder;
import com.netflix.archaius.ConfigProxyFactory;
import com.netflix.governator.guice.jersey.GovernatorJerseySupportModule;
import com.netflix.titus.api.containerhealth.service.ContainerHealthService;
import com.netflix.titus.api.supervisor.service.MasterDescription;
import com.netflix.titus.master.appscale.endpoint.v3.AutoScalingModule;
import com.netflix.titus.master.audit.service.AuditModule;
import com.netflix.titus.master.config.CellInfoResolver;
import com.netflix.titus.master.config.ConfigurableCellInfoResolver;
import com.netflix.titus.master.config.MasterConfiguration;
import com.netflix.titus.master.endpoint.MasterEndpointModule;
import com.netflix.titus.master.endpoint.admission.JobCoordinatorAdmissionModule;
import com.netflix.titus.master.endpoint.common.ContextResolver;
import com.netflix.titus.master.endpoint.common.EmptyContextResolver;
import com.netflix.titus.master.endpoint.v2.rest.JerseyModule;
import com.netflix.titus.master.eviction.endpoint.grpc.EvictionEndpointModule;
import com.netflix.titus.master.eviction.service.EvictionServiceModule;
import com.netflix.titus.master.health.HealthModule;
import com.netflix.titus.master.jobmanager.endpoint.v3.V3EndpointModule;
import com.netflix.titus.master.jobmanager.service.V3JobManagerModule;
import com.netflix.titus.master.kubernetes.KubeModule;
import com.netflix.titus.master.kubernetes.controller.KubeControllerModule;
import com.netflix.titus.master.kubernetes.pod.KubePodModule;
import com.netflix.titus.master.loadbalancer.LoadBalancerModule;
import com.netflix.titus.master.scheduler.SchedulerModule;
import com.netflix.titus.master.service.management.ManagementModule;
import com.netflix.titus.master.store.StoreModule;
import com.netflix.titus.master.supervisor.endpoint.SupervisorEndpointModule;
import com.netflix.titus.master.supervisor.service.SupervisorServiceModule;
import com.netflix.titus.runtime.FeatureFlagModule;
import com.netflix.titus.runtime.TitusEntitySanitizerModule;
import com.netflix.titus.runtime.containerhealth.service.AlwaysHealthyContainerHealthService;
import com.netflix.titus.runtime.containerhealth.service.ContainerHealthServiceModule;
import com.netflix.titus.runtime.endpoint.common.EmptyLogStorageInfo;
import com.netflix.titus.runtime.endpoint.resolver.ByRemoteAddressHttpCallerIdResolver;
import com.netflix.titus.runtime.endpoint.resolver.HostCallerIdResolver;
import com.netflix.titus.runtime.endpoint.resolver.HttpCallerIdResolver;
import com.netflix.titus.runtime.endpoint.resolver.NoOpHostCallerIdResolver;
/**
* Main TitusMaster guice module.
*/
public class TitusMasterModule extends AbstractModule {
public enum Mode {
KUBE,
EMBEDDED_KUBE,
}
private final boolean enableREST;
private final Mode mode;
public TitusMasterModule() {
this(true, Mode.KUBE);
}
public TitusMasterModule(boolean enableREST, Mode mode) {
this.enableREST = enableREST;
this.mode = mode;
}
@Override
protected void configure() {
// Configuration
bind(CellInfoResolver.class).to(ConfigurableCellInfoResolver.class);
// Titus supervisor
install(new SupervisorServiceModule());
install(new SupervisorEndpointModule());
install(new TitusEntitySanitizerModule());
// Feature flags
install(new FeatureFlagModule());
// Kubernetes
Preconditions.checkNotNull(mode, "Kube mode not set");
if (mode == Mode.KUBE) {
install(new KubeModule());
} else if (mode == Mode.EMBEDDED_KUBE) {
install(new KubeControllerModule());
install(new KubePodModule());
}
// Storage
install(new StoreModule());
// Service
install(new AuditModule());
install(new SchedulerModule());
install(new V3JobManagerModule());
install(new ContainerHealthServiceModule());
Multibinder.newSetBinder(binder(), ContainerHealthService.class).addBinding().to(AlwaysHealthyContainerHealthService.class);
install(new ManagementModule());
// REST/GRPC
bind(V3EndpointModule.V3_LOG_STORAGE_INFO).toInstance(EmptyLogStorageInfo.INSTANCE);
bind(ContextResolver.class).toInstance(EmptyContextResolver.INSTANCE);
if (enableREST) {
install(new GovernatorJerseySupportModule());
// This should be in JerseyModule, but overrides get broken if we do that (possibly Governator bug).
bind(HttpCallerIdResolver.class).to(ByRemoteAddressHttpCallerIdResolver.class);
bind(HostCallerIdResolver.class).to(NoOpHostCallerIdResolver.class);
install(new JerseyModule());
}
install(new JobCoordinatorAdmissionModule());
install(new MasterEndpointModule());
install(new HealthModule());
install(new V3EndpointModule());
install(new AutoScalingModule());
install(new LoadBalancerModule());
install(new EvictionServiceModule());
install(new EvictionEndpointModule());
}
@Provides
@Singleton
public MasterConfiguration getMasterConfiguration(ConfigProxyFactory factory) {
return factory.newProxy(MasterConfiguration.class);
}
@Provides
@Singleton
public MasterDescription getMasterDescription(MasterConfiguration configuration) {
return MasterDescriptions.create(configuration);
}
}
| 39 |
0 | Create_ds/titus-control-plane/titus-server-master/src/main/java/com/netflix/titus/master/jobmanager/endpoint | Create_ds/titus-control-plane/titus-server-master/src/main/java/com/netflix/titus/master/jobmanager/endpoint/v3/V3EndpointModule.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.master.jobmanager.endpoint.v3;
import com.google.inject.AbstractModule;
import com.google.inject.Provides;
import com.google.inject.Singleton;
import com.google.inject.TypeLiteral;
import com.netflix.archaius.ConfigProxyFactory;
import com.netflix.titus.api.jobmanager.model.job.LogStorageInfo;
import com.netflix.titus.api.jobmanager.model.job.Task;
import com.netflix.titus.grpc.protogen.JobManagementServiceGrpc.JobManagementServiceImplBase;
import com.netflix.titus.master.jobmanager.endpoint.v3.grpc.DefaultJobManagementServiceGrpc;
import com.netflix.titus.runtime.endpoint.v3.grpc.DefaultGrpcObjectsCache;
import com.netflix.titus.runtime.endpoint.v3.grpc.GrpcObjectsCache;
import com.netflix.titus.runtime.endpoint.v3.grpc.GrpcObjectsCacheConfiguration;
import com.netflix.titus.runtime.service.TitusAgentSecurityGroupClient;
public class V3EndpointModule extends AbstractModule {
public static final TypeLiteral<LogStorageInfo<Task>> V3_LOG_STORAGE_INFO =
new TypeLiteral<LogStorageInfo<Task>>() {
};
@Override
protected void configure() {
bind(GrpcObjectsCache.class).to(DefaultGrpcObjectsCache.class);
bind(JobManagementServiceImplBase.class).to(DefaultJobManagementServiceGrpc.class);
}
@Provides
@Singleton
public GrpcObjectsCacheConfiguration getGrpcObjectsCacheConfiguration(ConfigProxyFactory factory) {
return factory.newProxy(GrpcObjectsCacheConfiguration.class);
}
}
| 40 |
0 | Create_ds/titus-control-plane/titus-server-master/src/main/java/com/netflix/titus/master/jobmanager/endpoint/v3 | Create_ds/titus-control-plane/titus-server-master/src/main/java/com/netflix/titus/master/jobmanager/endpoint/v3/grpc/ObserveJobsContext.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.master.jobmanager.endpoint.v3.grpc;
import com.netflix.titus.api.jobmanager.service.V3JobOperations;
import com.netflix.titus.common.runtime.TitusRuntime;
import com.netflix.titus.grpc.protogen.JobChangeNotification;
import com.netflix.titus.runtime.endpoint.metadata.CallMetadataResolver;
import com.netflix.titus.runtime.endpoint.v3.grpc.GrpcObjectsCache;
import rx.Scheduler;
/**
* A helper class to deal with job event stream subscriptions.
*/
class ObserveJobsContext {
static final JobChangeNotification SNAPSHOT_END_MARKER = JobChangeNotification.newBuilder()
.setSnapshotEnd(JobChangeNotification.SnapshotEnd.newBuilder())
.build();
private final V3JobOperations jobOperations;
private final CallMetadataResolver callMetadataResolver;
private final GrpcObjectsCache grpcObjectsCache;
private final Scheduler observeJobsScheduler;
private final DefaultJobManagementServiceGrpcMetrics metrics;
private final TitusRuntime titusRuntime;
ObserveJobsContext(V3JobOperations jobOperations,
CallMetadataResolver callMetadataResolver,
GrpcObjectsCache grpcObjectsCache,
Scheduler observeJobsScheduler,
DefaultJobManagementServiceGrpcMetrics metrics,
TitusRuntime titusRuntime) {
this.jobOperations = jobOperations;
this.callMetadataResolver = callMetadataResolver;
this.grpcObjectsCache = grpcObjectsCache;
this.observeJobsScheduler = observeJobsScheduler;
this.metrics = metrics;
this.titusRuntime = titusRuntime;
}
public V3JobOperations getJobOperations() {
return jobOperations;
}
public CallMetadataResolver getCallMetadataResolver() {
return callMetadataResolver;
}
public GrpcObjectsCache getGrpcObjectsCache() {
return grpcObjectsCache;
}
public Scheduler getObserveJobsScheduler() {
return observeJobsScheduler;
}
public DefaultJobManagementServiceGrpcMetrics getMetrics() {
return metrics;
}
public TitusRuntime getTitusRuntime() {
return titusRuntime;
}
JobChangeNotification toJobChangeNotification(com.netflix.titus.api.jobmanager.model.job.Job<?> coreJob, long now) {
com.netflix.titus.grpc.protogen.Job grpcJob = grpcObjectsCache.getJob(coreJob);
return JobChangeNotification.newBuilder()
.setJobUpdate(JobChangeNotification.JobUpdate.newBuilder().setJob(grpcJob))
.setTimestamp(now)
.build();
}
JobChangeNotification toJobChangeNotification(com.netflix.titus.api.jobmanager.model.job.Task coreTask, long now) {
com.netflix.titus.grpc.protogen.Task grpcTask = grpcObjectsCache.getTask(coreTask);
return JobChangeNotification.newBuilder()
.setTaskUpdate(JobChangeNotification.TaskUpdate.newBuilder().setTask(grpcTask))
.setTimestamp(now)
.build();
}
}
| 41 |
0 | Create_ds/titus-control-plane/titus-server-master/src/main/java/com/netflix/titus/master/jobmanager/endpoint/v3 | Create_ds/titus-control-plane/titus-server-master/src/main/java/com/netflix/titus/master/jobmanager/endpoint/v3/grpc/DefaultJobManagementServiceGrpc.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.master.jobmanager.endpoint.v3.grpc;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.Set;
import java.util.concurrent.ExecutorService;
import javax.annotation.PreDestroy;
import javax.inject.Inject;
import javax.inject.Named;
import javax.inject.Singleton;
import com.google.protobuf.Empty;
import com.netflix.titus.api.jobmanager.model.job.CapacityAttributes;
import com.netflix.titus.api.jobmanager.model.job.JobFunctions;
import com.netflix.titus.api.jobmanager.model.job.LogStorageInfo;
import com.netflix.titus.api.jobmanager.model.job.ServiceJobProcesses;
import com.netflix.titus.api.jobmanager.model.job.disruptionbudget.DisruptionBudget;
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.sanitizer.CustomJobConfiguration;
import com.netflix.titus.api.jobmanager.service.JobManagerException;
import com.netflix.titus.api.jobmanager.service.V3JobOperations;
import com.netflix.titus.api.jobmanager.service.V3JobOperations.Trigger;
import com.netflix.titus.api.model.Pagination;
import com.netflix.titus.api.model.PaginationUtil;
import com.netflix.titus.api.model.callmetadata.CallMetadata;
import com.netflix.titus.api.service.TitusServiceException;
import com.netflix.titus.api.supervisor.service.LeaderActivator;
import com.netflix.titus.common.model.admission.AdmissionSanitizer;
import com.netflix.titus.common.model.admission.AdmissionValidator;
import com.netflix.titus.common.model.sanitizer.EntitySanitizer;
import com.netflix.titus.common.model.sanitizer.ValidationError;
import com.netflix.titus.common.runtime.TitusRuntime;
import com.netflix.titus.common.util.CollectionsExt;
import com.netflix.titus.common.util.ExecutorsExt;
import com.netflix.titus.common.util.ProtobufExt;
import com.netflix.titus.common.util.archaius2.ObjectConfigurationResolver;
import com.netflix.titus.common.util.rx.ObservableExt;
import com.netflix.titus.common.util.tuple.Pair;
import com.netflix.titus.grpc.protogen.Job;
import com.netflix.titus.grpc.protogen.JobAttributesDeleteRequest;
import com.netflix.titus.grpc.protogen.JobAttributesUpdate;
import com.netflix.titus.grpc.protogen.JobCapacityUpdate;
import com.netflix.titus.grpc.protogen.JobCapacityUpdateWithOptionalAttributes;
import com.netflix.titus.grpc.protogen.JobChangeNotification;
import com.netflix.titus.grpc.protogen.JobDescriptor;
import com.netflix.titus.grpc.protogen.JobDisruptionBudget;
import com.netflix.titus.grpc.protogen.JobDisruptionBudgetUpdate;
import com.netflix.titus.grpc.protogen.JobId;
import com.netflix.titus.grpc.protogen.JobManagementServiceGrpc;
import com.netflix.titus.grpc.protogen.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.ObserveJobsWithKeepAliveRequest;
import com.netflix.titus.grpc.protogen.Task;
import com.netflix.titus.grpc.protogen.TaskAttributesDeleteRequest;
import com.netflix.titus.grpc.protogen.TaskAttributesUpdate;
import com.netflix.titus.grpc.protogen.TaskId;
import com.netflix.titus.grpc.protogen.TaskKillRequest;
import com.netflix.titus.grpc.protogen.TaskMoveRequest;
import com.netflix.titus.grpc.protogen.TaskQuery;
import com.netflix.titus.grpc.protogen.TaskQueryResult;
import com.netflix.titus.master.config.CellInfoResolver;
import com.netflix.titus.master.endpoint.common.CellDecorator;
import com.netflix.titus.master.endpoint.grpc.GrpcMasterEndpointConfiguration;
import com.netflix.titus.runtime.endpoint.authorization.AuthorizationService;
import com.netflix.titus.runtime.endpoint.authorization.AuthorizationStatus;
import com.netflix.titus.runtime.endpoint.metadata.CallMetadataResolver;
import com.netflix.titus.runtime.endpoint.metadata.CallMetadataUtils;
import com.netflix.titus.runtime.endpoint.v3.grpc.DefaultGrpcObjectsCache;
import com.netflix.titus.runtime.endpoint.v3.grpc.GrpcJobManagementModelConverters;
import com.netflix.titus.runtime.endpoint.v3.grpc.GrpcObjectsCacheConfiguration;
import com.netflix.titus.runtime.endpoint.v3.grpc.query.V3JobQueryCriteriaEvaluator;
import com.netflix.titus.runtime.endpoint.v3.grpc.query.V3TaskQueryCriteriaEvaluator;
import com.netflix.titus.runtime.jobmanager.JobComparators;
import com.netflix.titus.runtime.jobmanager.JobManagerCursors;
import io.grpc.Status;
import io.grpc.StatusRuntimeException;
import io.grpc.stub.ServerCallStreamObserver;
import io.grpc.stub.StreamObserver;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import reactor.core.publisher.Mono;
import rx.Observable;
import rx.Scheduler;
import rx.Subscription;
import rx.schedulers.Schedulers;
import static com.netflix.titus.api.jobmanager.model.job.sanitizer.JobSanitizerBuilder.JOB_STRICT_SANITIZER;
import static com.netflix.titus.master.jobmanager.endpoint.v3.grpc.ObserveJobsContext.SNAPSHOT_END_MARKER;
import static com.netflix.titus.runtime.endpoint.common.grpc.GrpcUtil.safeOnError;
import static com.netflix.titus.runtime.endpoint.metadata.CallMetadataUtils.execute;
import static com.netflix.titus.runtime.endpoint.v3.grpc.GrpcJobQueryModelConverters.toGrpcPagination;
import static com.netflix.titus.runtime.endpoint.v3.grpc.GrpcJobQueryModelConverters.toJobQueryCriteria;
import static com.netflix.titus.runtime.endpoint.v3.grpc.GrpcJobQueryModelConverters.toPage;
import static com.netflix.titus.runtime.endpoint.v3.grpc.TitusPaginationUtils.checkPageIsValid;
import static com.netflix.titus.runtime.jobmanager.gateway.JobServiceGateway.JOB_MINIMUM_FIELD_SET;
import static com.netflix.titus.runtime.jobmanager.gateway.JobServiceGateway.TASK_MINIMUM_FIELD_SET;
@Singleton
public class DefaultJobManagementServiceGrpc extends JobManagementServiceGrpc.JobManagementServiceImplBase {
private static final Logger logger = LoggerFactory.getLogger(DefaultJobManagementServiceGrpc.class);
private final V3JobOperations jobOperations;
private final EntitySanitizer entitySanitizer;
private final AdmissionValidator<com.netflix.titus.api.jobmanager.model.job.JobDescriptor> admissionValidator;
private final AdmissionSanitizer<com.netflix.titus.api.jobmanager.model.job.JobDescriptor> admissionSanitizer;
private final ObjectConfigurationResolver<com.netflix.titus.api.jobmanager.model.job.JobDescriptor, CustomJobConfiguration> customJobConfigurationResolver;
private final CallMetadataResolver callMetadataResolver;
private final CellDecorator cellDecorator;
private final AuthorizationService authorizationService;
private final TitusRuntime titusRuntime;
private final ExecutorService observeJobsThreadPool;
private final Scheduler observeJobsScheduler;
private final DefaultGrpcObjectsCache grpcObjectsCache;
private final DefaultJobManagementServiceGrpcMetrics metrics;
private final ObserveJobsContext eventProcessingContext;
@Inject
public DefaultJobManagementServiceGrpc(GrpcMasterEndpointConfiguration configuration,
V3JobOperations jobOperations,
LogStorageInfo<com.netflix.titus.api.jobmanager.model.job.Task> logStorageInfo,
@Named(JOB_STRICT_SANITIZER) EntitySanitizer entitySanitizer,
AdmissionValidator<com.netflix.titus.api.jobmanager.model.job.JobDescriptor> admissionValidator,
AdmissionSanitizer<com.netflix.titus.api.jobmanager.model.job.JobDescriptor> admissionSanitizer,
ObjectConfigurationResolver<com.netflix.titus.api.jobmanager.model.job.JobDescriptor, CustomJobConfiguration> customJobConfigurationResolver,
CallMetadataResolver callMetadataResolver,
CellInfoResolver cellInfoResolver,
AuthorizationService authorizationService,
GrpcObjectsCacheConfiguration grpcObjectsCacheConfiguration,
LeaderActivator leaderActivator,
TitusRuntime titusRuntime) {
this.jobOperations = jobOperations;
this.entitySanitizer = entitySanitizer;
this.admissionValidator = admissionValidator;
this.admissionSanitizer = admissionSanitizer;
this.customJobConfigurationResolver = customJobConfigurationResolver;
this.callMetadataResolver = callMetadataResolver;
this.cellDecorator = new CellDecorator(cellInfoResolver::getCellName);
this.authorizationService = authorizationService;
this.titusRuntime = titusRuntime;
this.observeJobsThreadPool = ExecutorsExt.instrumentedFixedSizeThreadPool(
titusRuntime.getRegistry(), "observeJobs", configuration.getServerStreamsThreadPoolSize()
);
this.observeJobsScheduler = Schedulers.from(observeJobsThreadPool);
this.grpcObjectsCache = new DefaultGrpcObjectsCache(jobOperations, grpcObjectsCacheConfiguration, logStorageInfo, leaderActivator, titusRuntime);
grpcObjectsCache.activate();
this.metrics = new DefaultJobManagementServiceGrpcMetrics(titusRuntime);
this.eventProcessingContext = new ObserveJobsContext(
jobOperations,
callMetadataResolver,
grpcObjectsCache,
observeJobsScheduler,
metrics,
titusRuntime
);
}
@PreDestroy
public void shutdown() {
metrics.shutdown();
grpcObjectsCache.shutdown();
observeJobsThreadPool.shutdownNow();
}
@Override
public void createJob(JobDescriptor jobDescriptor, StreamObserver<JobId> responseObserver) {
execute(callMetadataResolver, responseObserver, callMetadata -> validateAndConvertJobDescriptorToCoreModel(jobDescriptor)
.flatMap(sanitizedCoreJobDescriptor -> authorizeJobCreate(callMetadata, sanitizedCoreJobDescriptor)
.then(Mono.just(sanitizedCoreJobDescriptor)))
.flatMap(sanitizedCoreJobDescriptor -> jobOperations.createJobReactor(sanitizedCoreJobDescriptor, callMetadata))
.subscribe(
jobId -> responseObserver.onNext(JobId.newBuilder().setId(jobId).build()),
e -> safeOnError(logger, e, responseObserver),
responseObserver::onCompleted
));
}
private Mono<com.netflix.titus.api.jobmanager.model.job.JobDescriptor> validateAndConvertJobDescriptorToCoreModel(JobDescriptor jobDescriptor) {
return Mono.defer(() -> {
com.netflix.titus.api.jobmanager.model.job.JobDescriptor coreJobDescriptor;
try {
coreJobDescriptor = GrpcJobManagementModelConverters.toCoreJobDescriptor(cellDecorator.ensureCellInfo(jobDescriptor));
} catch (Exception e) {
return Mono.error(TitusServiceException.invalidArgument("Error when converting GRPC object to the internal representation: " + e.getMessage()));
}
return Mono.fromCallable(() -> entitySanitizer.sanitize(coreJobDescriptor).orElse(coreJobDescriptor))
.flatMap(admissionSanitizer::sanitizeAndApply)
.flatMap(sanitizedCoreJobDescriptor -> admissionValidator.validate(sanitizedCoreJobDescriptor)
.map(violations -> CollectionsExt.merge(
violations,
entitySanitizer.validate(sanitizedCoreJobDescriptor),
validateCustomJobLimits(sanitizedCoreJobDescriptor)))
.flatMap(violations -> {
if (!violations.isEmpty()) {
return Mono.error(TitusServiceException.invalidArgument(violations));
}
return Mono.just(sanitizedCoreJobDescriptor);
}));
});
}
@Override
public void findJobs(JobQuery jobQuery, StreamObserver<JobQueryResult> responseObserver) {
if (!checkPageIsValid(jobQuery.getPage(), responseObserver)) {
return;
}
try {
// We need to find all jobs to get the total number of them.
List<com.netflix.titus.api.jobmanager.model.job.Job<?>> allFilteredJobs = jobOperations.findJobs(
new V3JobQueryCriteriaEvaluator(toJobQueryCriteria(jobQuery), titusRuntime),
0,
Integer.MAX_VALUE / 2
);
Pair<List<com.netflix.titus.api.jobmanager.model.job.Job<?>>, Pagination> queryResult = PaginationUtil.takePageWithCursorAndKeyExtractor(
toPage(jobQuery.getPage()),
allFilteredJobs,
JobComparators::createJobKeyOf,
JobManagerCursors::coreJobIndexOf,
JobManagerCursors::newJobCoreCursorFrom
);
List<Job> grpcJobs = new ArrayList<>();
for (com.netflix.titus.api.jobmanager.model.job.Job<?> job : queryResult.getLeft()) {
Job toGrpcJob = grpcObjectsCache.getJob(job);
grpcJobs.add(toGrpcJob);
}
JobQueryResult grpcQueryResult;
if (jobQuery.getFieldsList().isEmpty()) {
grpcQueryResult = toJobQueryResult(grpcJobs, queryResult.getRight());
} else {
Set<String> fields = new HashSet<>(jobQuery.getFieldsList());
fields.addAll(JOB_MINIMUM_FIELD_SET);
List<Job> list = new ArrayList<>();
for (Job j : grpcJobs) {
list.add(ProtobufExt.copy(j, fields));
}
grpcQueryResult = toJobQueryResult(list, queryResult.getRight());
}
responseObserver.onNext(grpcQueryResult);
responseObserver.onCompleted();
} catch (Exception e) {
safeOnError(logger, e, responseObserver);
}
}
@Override
public void findJob(JobId request, StreamObserver<Job> responseObserver) {
String id = request.getId();
try {
com.netflix.titus.api.jobmanager.model.job.Job<?> coreJob = jobOperations.getJob(id).orElse(null);
if (coreJob == null) {
safeOnError(logger, JobManagerException.jobNotFound(id), responseObserver);
} else {
responseObserver.onNext(grpcObjectsCache.getJob(coreJob));
responseObserver.onCompleted();
}
} catch (Exception e) {
safeOnError(logger, e, responseObserver);
}
}
@Override
public void findTasks(TaskQuery taskQuery, StreamObserver<TaskQueryResult> responseObserver) {
if (!checkPageIsValid(taskQuery.getPage(), responseObserver)) {
return;
}
try {
// We need to find all tasks to get the total number of them.
List<com.netflix.titus.api.jobmanager.model.job.Task> allFilteredTasks = new ArrayList<>();
for (Pair<com.netflix.titus.api.jobmanager.model.job.Job<?>, com.netflix.titus.api.jobmanager.model.job.Task> jobTaskPair : jobOperations.findTasks(
new V3TaskQueryCriteriaEvaluator(toJobQueryCriteria(taskQuery), titusRuntime),
0,
Integer.MAX_VALUE / 2
)) {
com.netflix.titus.api.jobmanager.model.job.Task right = jobTaskPair.getRight();
allFilteredTasks.add(right);
}
Pair<List<com.netflix.titus.api.jobmanager.model.job.Task>, Pagination> queryResult = PaginationUtil.takePageWithCursorAndKeyExtractor(
toPage(taskQuery.getPage()),
allFilteredTasks,
JobComparators::createTaskKeyOf,
JobManagerCursors::coreTaskIndexOf,
JobManagerCursors::newTaskCoreCursorFrom
);
List<Task> grpcTasks = new ArrayList<>();
for (com.netflix.titus.api.jobmanager.model.job.Task task : queryResult.getLeft()) {
Task toGrpcTask = grpcObjectsCache.getTask(task);
grpcTasks.add(toGrpcTask);
}
TaskQueryResult grpcQueryResult;
if (taskQuery.getFieldsList().isEmpty()) {
grpcQueryResult = toTaskQueryResult(grpcTasks, queryResult.getRight());
} else {
Set<String> fields = new HashSet<>(taskQuery.getFieldsList());
fields.addAll(TASK_MINIMUM_FIELD_SET);
List<Task> filtered = new ArrayList<>();
for (Task t : grpcTasks) {
filtered.add(ProtobufExt.copy(t, fields));
}
grpcQueryResult = toTaskQueryResult(filtered, queryResult.getRight());
}
responseObserver.onNext(grpcQueryResult);
responseObserver.onCompleted();
} catch (Exception e) {
safeOnError(logger, e, responseObserver);
}
}
@Override
public void findTask(TaskId request, StreamObserver<Task> responseObserver) {
String id = request.getId();
try {
Pair<com.netflix.titus.api.jobmanager.model.job.Job<?>, com.netflix.titus.api.jobmanager.model.job.Task> coreJobAndTask = jobOperations.findTaskById(id).orElse(null);
if (coreJobAndTask == null) {
safeOnError(logger, JobManagerException.taskNotFound(id), responseObserver);
} else {
com.netflix.titus.api.jobmanager.model.job.Task coreTask = coreJobAndTask.getRight();
Task grpcTask = grpcObjectsCache.getTask(coreTask);
responseObserver.onNext(grpcTask);
responseObserver.onCompleted();
}
} catch (Exception e) {
safeOnError(logger, e, responseObserver);
}
}
@Override
public void updateJobCapacity(JobCapacityUpdate request, StreamObserver<Empty> responseObserver) {
execute(callMetadataResolver, responseObserver, callMetadata -> {
CapacityAttributes capacityAttributes = GrpcJobManagementModelConverters.toCoreCapacityAttributes(request.getCapacity());
verifyServiceJob(request.getJobId(), capacityAttributes);
authorizeJobUpdate(callMetadata, request.getJobId())
.concatWith(jobOperations.updateJobCapacityAttributesReactor(request.getJobId(), capacityAttributes, callMetadata))
.subscribe(
nothing -> {
},
e -> safeOnError(logger, e, responseObserver),
() -> {
responseObserver.onNext(Empty.getDefaultInstance());
responseObserver.onCompleted();
}
);
});
}
@Override
public void updateJobCapacityWithOptionalAttributes(JobCapacityUpdateWithOptionalAttributes request, StreamObserver<Empty> responseObserver) {
execute(callMetadataResolver, responseObserver, callMetadata -> {
CapacityAttributes capacityAttributes = GrpcJobManagementModelConverters.toCoreCapacityAttributes(request.getJobCapacityWithOptionalAttributes());
verifyServiceJob(request.getJobId(), capacityAttributes);
logger.info("updateJobCapacityWithOptionalAttributes to {}", capacityAttributes);
authorizeJobUpdate(callMetadata, request.getJobId())
.concatWith(jobOperations.updateJobCapacityAttributesReactor(request.getJobId(), capacityAttributes, callMetadata))
.subscribe(
nothing -> {
},
e -> safeOnError(logger, e, responseObserver),
() -> {
responseObserver.onNext(Empty.getDefaultInstance());
responseObserver.onCompleted();
}
);
});
}
@Override
public void updateJobProcesses(JobProcessesUpdate request, StreamObserver<Empty> responseObserver) {
execute(callMetadataResolver, responseObserver, callMetadata -> {
ServiceJobProcesses serviceJobProcesses = GrpcJobManagementModelConverters.toCoreServiceJobProcesses(request.getServiceJobProcesses());
authorizeJobUpdate(callMetadata, request.getJobId())
.concatWith(jobOperations.updateServiceJobProcessesReactor(request.getJobId(), serviceJobProcesses, callMetadata))
.subscribe(
nothing -> {
},
e -> safeOnError(logger, e, responseObserver),
() -> {
responseObserver.onNext(Empty.getDefaultInstance());
responseObserver.onCompleted();
}
);
});
}
@Override
public void updateJobStatus(JobStatusUpdate request, StreamObserver<Empty> responseObserver) {
execute(callMetadataResolver, responseObserver, callMetadata -> authorizeJobUpdate(callMetadata, request.getId())
.concatWith(jobOperations.updateJobStatusReactor(request.getId(), request.getEnableStatus(), callMetadata))
.subscribe(
nothing -> {
},
e -> safeOnError(logger, e, responseObserver),
() -> {
responseObserver.onNext(Empty.getDefaultInstance());
responseObserver.onCompleted();
}
));
}
@Override
public void updateJobDisruptionBudget(JobDisruptionBudgetUpdate request, StreamObserver<Empty> responseObserver) {
execute(callMetadataResolver, responseObserver, callMetadata -> {
com.netflix.titus.api.jobmanager.model.job.Job<?> job = jobOperations.getJob(request.getJobId()).orElse(null);
if (job == null) {
responseObserver.onError(JobManagerException.jobNotFound(request.getJobId()));
return;
}
validateAndConvertJobDisruptionBudgetToCoreModel(job, request.getDisruptionBudget(), responseObserver).ifPresent(sanitized ->
authorizeJobUpdate(callMetadata, job)
.concatWith(jobOperations.updateJobDisruptionBudget(request.getJobId(), sanitized, callMetadata))
.subscribe(
nothing -> {
},
e -> safeOnError(logger, e, responseObserver),
() -> {
responseObserver.onNext(Empty.getDefaultInstance());
responseObserver.onCompleted();
}
)
);
});
}
private Optional<DisruptionBudget> validateAndConvertJobDisruptionBudgetToCoreModel(com.netflix.titus.api.jobmanager.model.job.Job<?> coreJob,
JobDisruptionBudget grpcDisruptionBudget,
StreamObserver<Empty> responseObserver) {
DisruptionBudget coreDisruptionBudget;
try {
coreDisruptionBudget = GrpcJobManagementModelConverters.toCoreDisruptionBudget(grpcDisruptionBudget);
} catch (Exception e) {
safeOnError(logger, TitusServiceException.invalidArgument("Error when converting GRPC disruption budget to the internal model: " + e.getMessage()), responseObserver);
return Optional.empty();
}
DisruptionBudget sanitizedCoreDisruptionBudget = entitySanitizer.sanitize(coreDisruptionBudget).orElse(coreDisruptionBudget);
Set<ValidationError> violations = entitySanitizer.validate(sanitizedCoreDisruptionBudget);
if (!violations.isEmpty()) {
safeOnError(logger, TitusServiceException.invalidArgument(violations), responseObserver);
return Optional.empty();
}
return Optional.of(sanitizedCoreDisruptionBudget);
}
@Override
public void killJob(JobId request, StreamObserver<Empty> responseObserver) {
execute(callMetadataResolver, responseObserver, callMetadata -> {
String reason = String.format("User initiated job kill: %s", CallMetadataUtils.toReasonString(callMetadata));
authorizeJobUpdate(callMetadata, request.getId())
.concatWith(jobOperations.killJobReactor(request.getId(), reason, callMetadata))
.subscribe(
nothing -> {
},
e -> safeOnError(logger, e, responseObserver),
() -> {
responseObserver.onNext(Empty.getDefaultInstance());
responseObserver.onCompleted();
}
);
});
}
@Override
public void updateJobAttributes(JobAttributesUpdate request, StreamObserver<Empty> responseObserver) {
execute(callMetadataResolver, responseObserver, callMetadata -> authorizeJobUpdate(callMetadata, request.getJobId())
.concatWith(jobOperations.updateJobAttributes(request.getJobId(), request.getAttributesMap(), callMetadata))
.subscribe(
nothing -> {
},
e -> safeOnError(logger, e, responseObserver),
() -> {
responseObserver.onNext(Empty.getDefaultInstance());
responseObserver.onCompleted();
}
)
);
}
@Override
public void deleteJobAttributes(JobAttributesDeleteRequest request, StreamObserver<Empty> responseObserver) {
execute(callMetadataResolver, responseObserver, callMetadata -> authorizeJobUpdate(callMetadata, request.getJobId())
.concatWith(jobOperations.deleteJobAttributes(request.getJobId(), new HashSet<>(request.getKeysList()), callMetadata))
.subscribe(
nothing -> {
},
e -> safeOnError(logger, e, responseObserver),
() -> {
responseObserver.onNext(Empty.getDefaultInstance());
responseObserver.onCompleted();
}
)
);
}
@Override
public void killTask(TaskKillRequest request, StreamObserver<Empty> responseObserver) {
execute(callMetadataResolver, responseObserver, callMetadata -> authorizeTaskUpdate(callMetadata, request.getTaskId())
.concatWith(jobOperations.killTask(request.getTaskId(), request.getShrink(), request.getPreventMinSizeUpdate(), Trigger.API, callMetadata))
.subscribe(
nothing -> {
},
e -> safeOnError(logger, e, responseObserver),
() -> {
responseObserver.onNext(Empty.getDefaultInstance());
responseObserver.onCompleted();
}
)
);
}
@Override
public void moveTask(TaskMoveRequest request, StreamObserver<Empty> responseObserver) {
execute(callMetadataResolver, responseObserver, callMetadata ->
jobOperations.moveServiceTask(request.getSourceJobId(), request.getTargetJobId(), request.getTaskId(), callMetadata).subscribe(
nothing -> {
},
e -> safeOnError(logger, e, responseObserver),
() -> {
responseObserver.onNext(Empty.getDefaultInstance());
responseObserver.onCompleted();
}
)
);
}
@Override
public void updateTaskAttributes(TaskAttributesUpdate request, StreamObserver<Empty> responseObserver) {
execute(callMetadataResolver, responseObserver, callMetadata -> jobOperations.updateTask(
request.getTaskId(),
task -> {
Map<String, String> updatedAttributes = CollectionsExt.merge(task.getAttributes(), request.getAttributesMap());
return Optional.of(task.toBuilder().withAttributes(updatedAttributes).build());
},
Trigger.API,
"User request: userId=" + callMetadata.getCallerId(), callMetadata
).subscribe(
() -> {
responseObserver.onNext(Empty.getDefaultInstance());
responseObserver.onCompleted();
},
e -> safeOnError(logger, e, responseObserver)
));
}
@Override
public void deleteTaskAttributes(TaskAttributesDeleteRequest request, StreamObserver<Empty> responseObserver) {
execute(callMetadataResolver, responseObserver, callMetadata -> jobOperations.updateTask(
request.getTaskId(),
task -> {
Map<String, String> updatedAttributes = CollectionsExt.copyAndRemove(task.getAttributes(), request.getKeysList());
return Optional.of(task.toBuilder().withAttributes(updatedAttributes).build());
},
Trigger.API,
"User request: userId=" + callMetadata.getCallerId(),
callMetadata
).subscribe(
() -> {
responseObserver.onNext(Empty.getDefaultInstance());
responseObserver.onCompleted();
},
e -> safeOnError(logger, e, responseObserver)
));
}
@Override
public void observeJobs(ObserveJobsQuery query, StreamObserver<JobChangeNotification> responseObserver) {
new ObserveJobsSubscription(eventProcessingContext, false).observeJobs(query, responseObserver);
}
@Override
public StreamObserver<ObserveJobsWithKeepAliveRequest> observeJobsWithKeepAlive(StreamObserver<JobChangeNotification> responseObserver) {
return new ObserveJobsSubscription(eventProcessingContext, true).observeJobsWithKeepAlive(responseObserver);
}
@Override
public void observeJob(JobId request, StreamObserver<JobChangeNotification> responseObserver) {
String jobId = request.getId();
Observable<JobChangeNotification> eventStream = jobOperations.observeJob(jobId)
// avoid clogging the computation scheduler
.observeOn(observeJobsScheduler)
.subscribeOn(observeJobsScheduler, false)
.map(event -> GrpcJobManagementModelConverters.toGrpcJobChangeNotification(event, grpcObjectsCache, titusRuntime.getClock().wallTime()))
.compose(ObservableExt.head(() -> {
List<JobChangeNotification> snapshot = createJobSnapshot(jobId);
snapshot.add(SNAPSHOT_END_MARKER);
return snapshot;
}))
.doOnError(e -> {
if (!JobManagerException.isExpected(e)) {
logger.error("Unexpected error in job {} event stream", jobId, e);
} else {
logger.debug("Error in job {} event stream", jobId, e);
}
});
Subscription subscription = eventStream.subscribe(
responseObserver::onNext,
e -> responseObserver.onError(
new StatusRuntimeException(Status.INTERNAL
.withDescription(jobId + " job monitoring stream terminated with an error")
.withCause(e))
),
responseObserver::onCompleted
);
ServerCallStreamObserver<JobChangeNotification> serverObserver = (ServerCallStreamObserver<JobChangeNotification>) responseObserver;
serverObserver.setOnCancelHandler(subscription::unsubscribe);
}
List<JobChangeNotification> createJobSnapshot(String jobId) {
long now = titusRuntime.getClock().wallTime();
List<JobChangeNotification> snapshot = new ArrayList<>();
com.netflix.titus.api.jobmanager.model.job.Job<?> coreJob = jobOperations.getJob(jobId).orElseThrow(() -> new IllegalArgumentException("Job with id " + jobId + " not found"));
snapshot.add(eventProcessingContext.toJobChangeNotification(coreJob, now));
List<com.netflix.titus.api.jobmanager.model.job.Task> coreTasks = jobOperations.getTasks(jobId);
coreTasks.forEach(task -> snapshot.add(eventProcessingContext.toJobChangeNotification(task, now)));
return snapshot;
}
private Mono<Void> authorizeJobCreate(CallMetadata callMetadata, com.netflix.titus.api.jobmanager.model.job.JobDescriptor<?> jobDescriptor) {
return authorizationService.authorize(callMetadata, jobDescriptor).flatMap(this::processAuthorizationReply);
}
private Mono<Void> authorizeJobUpdate(CallMetadata callMetadata, String jobId) {
return Mono.defer(() -> {
com.netflix.titus.api.jobmanager.model.job.Job<?> job = jobOperations.getJob(jobId).orElse(null);
if (job == null) {
return Mono.error(JobManagerException.jobNotFound(jobId));
}
return authorizeJobUpdate(callMetadata, job);
});
}
private Mono<Void> authorizeJobUpdate(CallMetadata callMetadata, com.netflix.titus.api.jobmanager.model.job.Job<?> job) {
return authorizationService.authorize(callMetadata, job).flatMap(this::processAuthorizationReply);
}
private Mono<Void> authorizeTaskUpdate(CallMetadata callMetadata, String taskId) {
return Mono.defer(() -> {
Pair<com.netflix.titus.api.jobmanager.model.job.Job<?>, com.netflix.titus.api.jobmanager.model.job.Task> jobTaskPair = jobOperations.findTaskById(taskId).orElse(null);
if (jobTaskPair == null) {
return Mono.error(JobManagerException.taskNotFound(taskId));
}
return authorizeJobUpdate(callMetadata, jobTaskPair.getLeft());
});
}
private Mono<Void> processAuthorizationReply(AuthorizationStatus authorizationResult) {
if (!authorizationResult.isAuthorized()) {
Status status = Status.PERMISSION_DENIED
.withDescription("Request not authorized: " + authorizationResult.getReason());
return Mono.error(new StatusRuntimeException(status));
}
return Mono.empty();
}
private Set<ValidationError> validateCustomJobLimits(com.netflix.titus.api.jobmanager.model.job.JobDescriptor jobDescriptor) {
CustomJobConfiguration config = customJobConfigurationResolver.resolve(jobDescriptor);
if (JobFunctions.isServiceJob(jobDescriptor)) {
ServiceJobExt ext = (ServiceJobExt) jobDescriptor.getExtensions();
if (ext.getCapacity().getMax() > config.getMaxServiceJobSize()) {
String message = String.format("Service job size is limited to %s, but is %s", config.getMaxServiceJobSize(), ext.getCapacity().getMax());
return Collections.singleton(new ValidationError("jobDescriptor.extensions.capacity.max", message));
}
} else {
BatchJobExt ext = (BatchJobExt) jobDescriptor.getExtensions();
if (ext.getSize() > config.getMaxBatchJobSize()) {
String message = String.format("Batch job size is limited to %s, but is %s", config.getMaxBatchJobSize(), ext.getSize());
return Collections.singleton(new ValidationError("jobDescriptor.extensions.size", message));
}
}
return Collections.emptySet();
}
private JobQueryResult toJobQueryResult(List<Job> jobs, Pagination runtimePagination) {
return JobQueryResult.newBuilder()
.addAllItems(jobs)
.setPagination(toGrpcPagination(runtimePagination))
.build();
}
private TaskQueryResult toTaskQueryResult(List<Task> tasks, Pagination runtimePagination) {
return TaskQueryResult.newBuilder()
.addAllItems(tasks)
.setPagination(toGrpcPagination(runtimePagination))
.build();
}
private com.netflix.titus.api.jobmanager.model.job.Job<ServiceJobExt> verifyServiceJob(String jobId, CapacityAttributes capacityAttributes) {
return jobOperations
.getJob(jobId)
.map(j -> {
if (!JobFunctions.isServiceJob(j)) {
throw JobManagerException.notServiceJob(j.getId());
} else if (j.getJobDescriptor().getContainer().getContainerResources().getSignedIpAddressAllocations().size() > 0 &&
capacityAttributes.getMax().orElse(0) > j.getJobDescriptor().getContainer().getContainerResources().getSignedIpAddressAllocations().size()) {
throw JobManagerException.invalidMaxCapacity(
j.getId(),
capacityAttributes.getMax().orElse(0),
j.getJobDescriptor().getContainer().getContainerResources().getSignedIpAddressAllocations().size());
} else if (j.getJobDescriptor().getContainer().getContainerResources().getEbsVolumes().size() > 0 &&
capacityAttributes.getMax().orElse(0) > j.getJobDescriptor().getContainer().getContainerResources().getEbsVolumes().size()) {
throw JobManagerException.invalidMaxCapacity(
j.getId(),
capacityAttributes.getMax().orElse(0),
j.getJobDescriptor().getContainer().getContainerResources().getEbsVolumes().size());
}
return (com.netflix.titus.api.jobmanager.model.job.Job<ServiceJobExt>) j;
})
.orElseThrow(() -> JobManagerException.jobNotFound(jobId));
}
}
| 42 |
0 | Create_ds/titus-control-plane/titus-server-master/src/main/java/com/netflix/titus/master/jobmanager/endpoint/v3 | Create_ds/titus-control-plane/titus-server-master/src/main/java/com/netflix/titus/master/jobmanager/endpoint/v3/grpc/DefaultJobManagementServiceGrpcMetrics.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.master.jobmanager.endpoint.v3.grpc;
import java.time.Duration;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;
import java.util.concurrent.TimeUnit;
import com.netflix.spectator.api.Counter;
import com.netflix.spectator.api.Gauge;
import com.netflix.spectator.api.Registry;
import com.netflix.titus.api.model.callmetadata.CallMetadata;
import com.netflix.titus.common.framework.scheduler.ScheduleReference;
import com.netflix.titus.common.framework.scheduler.model.ScheduleDescriptor;
import com.netflix.titus.common.runtime.TitusRuntime;
import com.netflix.titus.common.util.CollectionsExt;
import com.netflix.titus.common.util.retry.Retryers;
import com.netflix.titus.master.MetricConstants;
/**
* Metrics for DefaultJobManagementServiceGrpc. They are supplementary to the GRPC metrics interceptor to provide
* more insight into the internal event stream processing.
*/
class DefaultJobManagementServiceGrpcMetrics {
private static final String ROOT = MetricConstants.METRIC_JOB_MANAGER + "grpcServer.";
private static final ScheduleDescriptor SCHEDULE_DESCRIPTOR = ScheduleDescriptor.newBuilder()
.withName(DefaultJobManagementServiceGrpcMetrics.class.getSimpleName())
.withDescription("GRPC job service metrics updater")
.withInitialDelay(Duration.ZERO)
.withInterval(Duration.ofSeconds(1))
.withTimeout(Duration.ofSeconds(5))
.withRetryerSupplier(Retryers::never)
.build();
private final Registry registry;
private final ConcurrentMap<String, StreamHolder> streamHolders = new ConcurrentHashMap<>();
private final ConcurrentMap<String, Gauge> pendingSubscriptionsByCallerId = new ConcurrentHashMap<>();
private final ScheduleReference scheduleRef;
DefaultJobManagementServiceGrpcMetrics(TitusRuntime titusRuntime) {
this.registry = titusRuntime.getRegistry();
this.scheduleRef = titusRuntime.getLocalScheduler().schedule(SCHEDULE_DESCRIPTOR, context -> updatePendingSubscriptionsGauges(), true);
}
void shutdown() {
scheduleRef.cancel();
}
void observeJobsStarted(String trxId, CallMetadata callMetadata) {
streamHolders.put(trxId, new StreamHolder(callMetadata));
}
void observeJobsUnsubscribed(String trxId, long elapsed) {
StreamHolder holder = streamHolders.remove(trxId);
if (holder != null) {
holder.unsubscribed(elapsed);
}
}
void observeJobsError(String trxId, long elapsed, Throwable e) {
StreamHolder holder = streamHolders.remove(trxId);
if (holder != null) {
holder.error(e.getClass().getSimpleName(), elapsed);
}
}
void observeJobsCompleted(String trxId, long elapsed) {
StreamHolder holder = streamHolders.remove(trxId);
if (holder != null) {
holder.completed(elapsed);
}
}
void observeJobsEventEmitted(String trxId) {
StreamHolder holder = streamHolders.get(trxId);
if (holder != null) {
holder.eventEmitted();
}
}
void updatePendingSubscriptionsGauges() {
Map<String, Integer> counters = new HashMap<>();
for (StreamHolder holder : streamHolders.values()) {
counters.put(holder.getCallerId(), counters.getOrDefault(holder.getCallerId(), 0) + 1);
}
Set<String> lost = CollectionsExt.copyAndRemove(pendingSubscriptionsByCallerId.keySet(), counters.keySet());
for (String id : lost) {
Gauge gauge = pendingSubscriptionsByCallerId.remove(id);
if (gauge != null) {
gauge.set(0);
}
}
counters.forEach((callerId, count) -> {
Gauge gauge = pendingSubscriptionsByCallerId.computeIfAbsent(callerId, c ->
registry.gauge(ROOT + "observeJobsSubscriptions", "callerId", callerId)
);
gauge.set(count);
});
}
private class StreamHolder {
private final String callerId;
private final Counter eventsCounter;
private StreamHolder(CallMetadata callMetadata) {
this.callerId = CollectionsExt.isNullOrEmpty(callMetadata.getCallers()) ? "unknown" : callMetadata.getCallers().get(0).getId();
this.eventsCounter = registry.counter(ROOT + "observeJobsSubscriptionEvents",
"callerId", callerId);
}
private String getCallerId() {
return callerId;
}
private void unsubscribed(long elapsed) {
registry.timer(ROOT + "observeJobsSubscriptionExecutionTime",
"callerId", callerId,
"status", "unsubscribed"
).record(elapsed, TimeUnit.MILLISECONDS);
}
private void error(String error, long elapsed) {
registry.timer(ROOT + "observeJobsSubscriptionExecutionTime",
"callerId", callerId,
"status", "error",
"error", error
).record(elapsed, TimeUnit.MILLISECONDS);
}
private void completed(long elapsed) {
registry.timer(ROOT + "observeJobsSubscriptionExecutionTime",
"callerId", callerId,
"status", "completed"
).record(elapsed, TimeUnit.MILLISECONDS);
}
private void eventEmitted() {
eventsCounter.increment();
}
}
}
| 43 |
0 | Create_ds/titus-control-plane/titus-server-master/src/main/java/com/netflix/titus/master/jobmanager/endpoint/v3 | Create_ds/titus-control-plane/titus-server-master/src/main/java/com/netflix/titus/master/jobmanager/endpoint/v3/grpc/JobAuthorizationService.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.master.jobmanager.endpoint.v3.grpc;
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.JobDescriptor;
import com.netflix.titus.common.util.StringExt;
import com.netflix.titus.runtime.endpoint.authorization.AuthorizationService;
import com.netflix.titus.runtime.endpoint.authorization.AuthorizationStatus;
import reactor.core.publisher.Mono;
public abstract class JobAuthorizationService implements AuthorizationService {
private static final String SECURITY_ATTRIBUTE_SECURITY_DOMAIN = "titus.securityDomain";
@Override
public <T> Mono<AuthorizationStatus> authorize(CallMetadata callMetadata, T object) {
if (object instanceof Job) {
return authorizeJob(callMetadata, (Job<?>) object);
}
if (object instanceof JobDescriptor) {
return authorizeJobDescriptor(callMetadata, (JobDescriptor<?>) object);
}
return Mono.just(AuthorizationStatus.success("Access granted for non-job object: objectType=" + object.getClass()));
}
protected abstract Mono<AuthorizationStatus> authorize(String originalCallerId, String securityDomainId, JobDescriptor<?> jobDescriptor);
private Mono<AuthorizationStatus> authorizeJob(CallMetadata callMetadata, Job<?> job) {
String originalCallerId = callMetadata.getCallerId();
if (StringExt.isEmpty(originalCallerId)) {
return Mono.just(AuthorizationStatus.success(
String.format("Request caller id missing; granting access to an identified user: jobId=%s, callMetadata=%s", job.getId(), callMetadata)
));
}
return authorizeCaller(job.getJobDescriptor(), originalCallerId);
}
private Mono<AuthorizationStatus> authorizeJobDescriptor(CallMetadata callMetadata, JobDescriptor<?> jobDescriptor) {
String originalCallerId = callMetadata.getCallerId();
if (StringExt.isEmpty(originalCallerId)) {
return Mono.just(AuthorizationStatus.success(String.format(
"Request caller id missing; granting access to an identified user to create a new job: applicationName=%s, callMetadata=%s",
jobDescriptor.getApplicationName(), callMetadata
)));
}
return authorizeCaller(jobDescriptor, originalCallerId);
}
private Mono<AuthorizationStatus> authorizeCaller(JobDescriptor<?> jobDescriptor, String originalCallerId) {
return authorize(originalCallerId, buildSecurityDomainId(jobDescriptor), jobDescriptor);
}
private String buildSecurityDomainId(JobDescriptor<?> jobDescriptor) {
Map<String, String> securityAttributes = jobDescriptor.getContainer().getSecurityProfile().getAttributes();
String securityDomain = securityAttributes.get(SECURITY_ATTRIBUTE_SECURITY_DOMAIN);
return StringExt.isNotEmpty(securityDomain) ? securityDomain : jobDescriptor.getApplicationName();
}
}
| 44 |
0 | Create_ds/titus-control-plane/titus-server-master/src/main/java/com/netflix/titus/master/jobmanager/endpoint/v3 | Create_ds/titus-control-plane/titus-server-master/src/main/java/com/netflix/titus/master/jobmanager/endpoint/v3/grpc/ObserveJobsSubscription.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.master.jobmanager.endpoint.v3.grpc;
import java.util.ArrayList;
import java.util.List;
import java.util.UUID;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingDeque;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.concurrent.atomic.AtomicLong;
import java.util.function.Predicate;
import com.google.common.annotations.VisibleForTesting;
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.model.callmetadata.CallMetadata;
import com.netflix.titus.api.model.callmetadata.CallMetadataConstants;
import com.netflix.titus.common.runtime.TitusRuntime;
import com.netflix.titus.common.util.ExceptionExt;
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.grpc.protogen.JobDescriptor;
import com.netflix.titus.grpc.protogen.KeepAliveRequest;
import com.netflix.titus.grpc.protogen.KeepAliveResponse;
import com.netflix.titus.grpc.protogen.ObserveJobsQuery;
import com.netflix.titus.grpc.protogen.ObserveJobsWithKeepAliveRequest;
import com.netflix.titus.grpc.protogen.TaskStatus;
import com.netflix.titus.runtime.endpoint.JobQueryCriteria;
import com.netflix.titus.runtime.endpoint.v3.grpc.GrpcJobManagementModelConverters;
import com.netflix.titus.runtime.endpoint.v3.grpc.query.V3JobQueryCriteriaEvaluator;
import com.netflix.titus.runtime.endpoint.v3.grpc.query.V3TaskQueryCriteriaEvaluator;
import io.grpc.Status;
import io.grpc.StatusRuntimeException;
import io.grpc.stub.ServerCallStreamObserver;
import io.grpc.stub.StreamObserver;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import rx.Observable;
import rx.Subscription;
import static com.netflix.titus.master.jobmanager.endpoint.v3.grpc.ObserveJobsContext.SNAPSHOT_END_MARKER;
import static com.netflix.titus.runtime.endpoint.v3.grpc.GrpcJobQueryModelConverters.toJobQueryCriteria;
class ObserveJobsSubscription {
private static final Logger logger = LoggerFactory.getLogger(ObserveJobsSubscription.class);
private final ObserveJobsContext context;
private final boolean withArchived;
private final DefaultJobManagementServiceGrpcMetrics metrics;
private final TitusRuntime titusRuntime;
// GRPC channel
private final BlockingQueue<Pair<Long, ObserveJobsWithKeepAliveRequest>> grpcClientEvents = new LinkedBlockingDeque<>();
private volatile StreamObserver<JobChangeNotification> grpcResponseObserver;
private volatile boolean grpcStreamInitiated;
private volatile boolean grpcSnapshotMarkerSent;
private volatile boolean grpcStreamCancelled;
// Job service
private final BlockingQueue<JobChangeNotification> jobServiceEvents = new LinkedBlockingDeque<>();
private volatile long lastCheckpointTimestampNano = System.nanoTime();
private volatile Throwable jobServiceError;
private volatile boolean jobServiceCompleted;
@VisibleForTesting
volatile Subscription jobServiceSubscription;
private final AtomicLong wip = new AtomicLong();
ObserveJobsSubscription(ObserveJobsContext context, boolean withArchived) {
this.context = context;
this.metrics = context.getMetrics();
this.titusRuntime = context.getTitusRuntime();
this.withArchived = withArchived;
}
void observeJobs(ObserveJobsQuery query, StreamObserver<JobChangeNotification> responseObserver) {
grpcClientEvents.add(Pair.of(0L, ObserveJobsWithKeepAliveRequest.newBuilder()
.setQuery(query)
.build()
));
connect(responseObserver);
drain();
}
StreamObserver<ObserveJobsWithKeepAliveRequest> observeJobsWithKeepAlive(StreamObserver<JobChangeNotification> responseObserver) {
connect(responseObserver);
return new StreamObserver<ObserveJobsWithKeepAliveRequest>() {
@Override
public void onNext(ObserveJobsWithKeepAliveRequest request) {
grpcClientEvents.add(Pair.of(System.nanoTime(), request));
drain();
}
@Override
public void onError(Throwable error) {
grpcStreamCancelled = true;
drain();
}
@Override
public void onCompleted() {
// It is ok that the GRPC input stream is closed. We will continue sending events to the client.
}
};
}
private void connect(StreamObserver<JobChangeNotification> responseObserver) {
this.grpcResponseObserver = responseObserver;
ServerCallStreamObserver<JobChangeNotification> serverObserver = (ServerCallStreamObserver<JobChangeNotification>) responseObserver;
serverObserver.setOnCancelHandler(() -> {
grpcStreamCancelled = true;
drain();
});
}
private void drain() {
try {
drainInternal();
} catch (Throwable error) {
logger.error("Unexpected error in the job event stream", error);
grpcStreamCancelled = true;
checkTerminated(true, true);
}
}
/**
* Based on: https://akarnokd.blogspot.com/2015/05/operator-concurrency-primitives_9.html
*/
private void drainInternal() {
if (wip.getAndIncrement() == 0) {
do {
if (checkTerminated(jobServiceCompleted, jobServiceEvents.isEmpty())) {
return;
}
wip.lazySet(1);
if (grpcStreamInitiated || tryInitialize()) {
while (true) {
boolean completed = jobServiceCompleted;
JobChangeNotification jobServiceEvent = jobServiceEvents.poll();
// We do not forward the internal keep alive / checkpoint requests, and only use it for synchronization
// with the client initiated keep alive.
if (jobServiceEvent != null && jobServiceEvent.getNotificationCase() == JobChangeNotification.NotificationCase.KEEPALIVERESPONSE) {
if (grpcSnapshotMarkerSent) {
this.lastCheckpointTimestampNano = jobServiceEvent.getKeepAliveResponse().getTimestamp();
}
} else {
if (checkTerminated(completed, jobServiceEvent == null)) {
return;
} else if (jobServiceEvent != null) {
if (jobServiceEvent.getNotificationCase() == JobChangeNotification.NotificationCase.SNAPSHOTEND) {
this.grpcSnapshotMarkerSent = true;
}
} else if (grpcSnapshotMarkerSent) {
// No more job service events to send. We can drain the GRPC input stream to process
// keep alive requests.
KeepAliveRequest keepAliveRequest = getLastKeepAliveEvent();
if (keepAliveRequest == null) {
break;
}
jobServiceEvent = toGrpcKeepAliveResponse(keepAliveRequest);
}
grpcResponseObserver.onNext(jobServiceEvent);
}
}
}
} while (wip.decrementAndGet() != 0);
}
}
private boolean tryInitialize() {
ObserveJobsQuery query = getLastObserveJobsQueryEvent();
if (query == null) {
return false;
}
Stopwatch start = Stopwatch.createStarted();
String trxId = UUID.randomUUID().toString();
CallMetadata callMetadata = context.getCallMetadataResolver().resolve().orElse(CallMetadataConstants.UNDEFINED_CALL_METADATA);
metrics.observeJobsStarted(trxId, callMetadata);
JobQueryCriteria<TaskStatus.TaskState, JobDescriptor.JobSpecCase> criteria = toJobQueryCriteria(query);
V3JobQueryCriteriaEvaluator jobsPredicate = new V3JobQueryCriteriaEvaluator(criteria, titusRuntime);
V3TaskQueryCriteriaEvaluator tasksPredicate = new V3TaskQueryCriteriaEvaluator(criteria, titusRuntime);
Observable<JobChangeNotification> eventStream = context.getJobOperations()
.observeJobs(jobsPredicate, tasksPredicate, true)
.filter(event -> withArchived || !event.isArchived())
// avoid clogging the computation scheduler
.observeOn(context.getObserveJobsScheduler())
.subscribeOn(context.getObserveJobsScheduler(), false)
.map(event -> GrpcJobManagementModelConverters.toGrpcJobChangeNotification(event, context.getGrpcObjectsCache(), titusRuntime.getClock().wallTime()))
.compose(ObservableExt.head(() -> {
List<JobChangeNotification> snapshot = createJobsSnapshot(jobsPredicate, tasksPredicate);
snapshot.add(SNAPSHOT_END_MARKER);
return snapshot;
}))
.doOnError(e -> logger.error("Unexpected error in jobs event stream", e));
AtomicBoolean closingProcessed = new AtomicBoolean();
this.jobServiceSubscription = eventStream
.doOnUnsubscribe(() -> {
if (!closingProcessed.getAndSet(true)) {
metrics.observeJobsUnsubscribed(trxId, start.elapsed(TimeUnit.MILLISECONDS));
}
})
.subscribe(
event -> {
metrics.observeJobsEventEmitted(trxId);
jobServiceEvents.add(event);
drain();
},
e -> {
if (!closingProcessed.getAndSet(true)) {
metrics.observeJobsError(trxId, start.elapsed(TimeUnit.MILLISECONDS), e);
}
jobServiceCompleted = true;
jobServiceError = new StatusRuntimeException(Status.INTERNAL
.withDescription("All jobs monitoring stream terminated with an error")
.withCause(e));
drain();
},
() -> {
if (!closingProcessed.getAndSet(true)) {
metrics.observeJobsCompleted(trxId, start.elapsed(TimeUnit.MILLISECONDS));
}
jobServiceCompleted = true;
drain();
}
);
this.grpcStreamInitiated = true;
return true;
}
private ObserveJobsQuery getLastObserveJobsQueryEvent() {
ObserveJobsQuery jobsQuery = null;
Pair<Long, ObserveJobsWithKeepAliveRequest> eventPair;
while ((eventPair = grpcClientEvents.poll()) != null) {
ObserveJobsWithKeepAliveRequest event = eventPair.getRight();
if (event.getKindCase() == ObserveJobsWithKeepAliveRequest.KindCase.QUERY) {
jobsQuery = event.getQuery();
}
}
return jobsQuery;
}
private KeepAliveRequest getLastKeepAliveEvent() {
Pair<Long, ObserveJobsWithKeepAliveRequest> firstKeepAliveRequestPair = null;
KeepAliveRequest lastKeepAliveRequest = null;
int count = 0;
Pair<Long, ObserveJobsWithKeepAliveRequest> eventPair;
while ((eventPair = grpcClientEvents.peek()) != null) {
ObserveJobsWithKeepAliveRequest event = eventPair.getRight();
if (event.getKindCase() == ObserveJobsWithKeepAliveRequest.KindCase.KEEPALIVEREQUEST) {
long requestTimestampNano = eventPair.getLeft();
if (requestTimestampNano > lastCheckpointTimestampNano) {
break;
}
lastKeepAliveRequest = event.getKeepAliveRequest();
count++;
if (firstKeepAliveRequestPair == null) {
firstKeepAliveRequestPair = eventPair;
}
}
grpcClientEvents.poll();
}
if (lastKeepAliveRequest != null && logger.isDebugEnabled()) {
KeepAliveRequest firstKeepAliveRequest = firstKeepAliveRequestPair.getRight().getKeepAliveRequest();
long internalSyncDelayMs = (System.nanoTime() - firstKeepAliveRequestPair.getLeft()) / 1_000_000;
logger.debug("Acknowledging the keep alive request(s): count={}, requestId(first)={}, requestTimestamp={}, internalSyncDelayMs={}",
count, firstKeepAliveRequest.getRequestId(), firstKeepAliveRequest.getTimestamp(), internalSyncDelayMs
);
}
return lastKeepAliveRequest;
}
private boolean checkTerminated(boolean isDone, boolean isEmpty) {
if (grpcStreamCancelled) {
ObservableExt.safeUnsubscribe(jobServiceSubscription);
return true;
}
if (isDone) {
Throwable e = jobServiceError;
if (e != null) {
jobServiceEvents.clear();
ExceptionExt.silent(() -> grpcResponseObserver.onError(e));
return true;
} else if (isEmpty) {
ExceptionExt.silent(() -> grpcResponseObserver.onCompleted());
return true;
}
}
return false;
}
private List<JobChangeNotification> createJobsSnapshot(
Predicate<Pair<Job<?>, List<Task>>> jobsPredicate,
Predicate<Pair<com.netflix.titus.api.jobmanager.model.job.Job<?>, com.netflix.titus.api.jobmanager.model.job.Task>> tasksPredicate) {
long now = titusRuntime.getClock().wallTime();
List<JobChangeNotification> snapshot = new ArrayList<>();
// Generics casting issue
List allJobsAndTasksRaw = context.getJobOperations().getJobsAndTasks();
List<Pair<com.netflix.titus.api.jobmanager.model.job.Job<?>, List<com.netflix.titus.api.jobmanager.model.job.Task>>> allJobsAndTasks = allJobsAndTasksRaw;
allJobsAndTasks.forEach(pair -> {
com.netflix.titus.api.jobmanager.model.job.Job<?> job = pair.getLeft();
List<com.netflix.titus.api.jobmanager.model.job.Task> tasks = pair.getRight();
if (jobsPredicate.test(pair)) {
snapshot.add(context.toJobChangeNotification(job, now));
}
tasks.forEach(task -> {
if (tasksPredicate.test(Pair.of(job, task))) {
snapshot.add(context.toJobChangeNotification(task, now));
}
});
});
return snapshot;
}
private JobChangeNotification toGrpcKeepAliveResponse(KeepAliveRequest keepAliveRequest) {
return JobChangeNotification.newBuilder()
.setKeepAliveResponse(KeepAliveResponse.newBuilder()
.setRequest(keepAliveRequest)
.setTimestamp(titusRuntime.getClock().wallTime())
.build()
)
.build();
}
}
| 45 |
0 | Create_ds/titus-control-plane/titus-server-master/src/main/java/com/netflix/titus/master/jobmanager | Create_ds/titus-control-plane/titus-server-master/src/main/java/com/netflix/titus/master/jobmanager/service/JobReconciliationFrameworkFactory.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.master.jobmanager.service;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.Set;
import java.util.stream.Collectors;
import javax.inject.Inject;
import javax.inject.Named;
import javax.inject.Singleton;
import com.netflix.spectator.api.BasicTag;
import com.netflix.spectator.api.Gauge;
import com.netflix.spectator.api.Registry;
import com.netflix.spectator.api.Tag;
import com.netflix.titus.api.FeatureActivationConfiguration;
import com.netflix.titus.api.jobmanager.TaskAttributes;
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.Task;
import com.netflix.titus.api.jobmanager.model.job.TaskState;
import com.netflix.titus.api.jobmanager.model.job.Version;
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.service.V3JobOperations;
import com.netflix.titus.api.jobmanager.store.JobStore;
import com.netflix.titus.common.framework.reconciler.ChangeAction;
import com.netflix.titus.common.framework.reconciler.DifferenceResolvers;
import com.netflix.titus.common.framework.reconciler.EntityHolder;
import com.netflix.titus.common.framework.reconciler.ReconciliationEngine.DifferenceResolver;
import com.netflix.titus.common.framework.reconciler.ReconciliationFramework;
import com.netflix.titus.common.framework.reconciler.internal.DefaultReconciliationEngine;
import com.netflix.titus.common.framework.reconciler.internal.DefaultReconciliationFramework;
import com.netflix.titus.common.framework.reconciler.internal.InternalReconciliationEngine;
import com.netflix.titus.common.model.sanitizer.EntitySanitizer;
import com.netflix.titus.common.model.sanitizer.EntitySanitizerUtil;
import com.netflix.titus.common.model.sanitizer.ValidationError;
import com.netflix.titus.common.runtime.TitusRuntime;
import com.netflix.titus.common.util.time.Clock;
import com.netflix.titus.common.util.tuple.Pair;
import com.netflix.titus.master.MetricConstants;
import com.netflix.titus.master.jobmanager.service.DefaultV3JobOperations.IndexKind;
import com.netflix.titus.master.jobmanager.service.common.action.TitusChangeAction;
import com.netflix.titus.master.jobmanager.service.common.action.task.TaskTimeoutChangeActions;
import com.netflix.titus.master.jobmanager.service.event.JobEventFactory;
import com.netflix.titus.master.jobmanager.service.event.JobManagerReconcilerEvent;
import com.netflix.titus.master.service.management.ApplicationSlaManagementService;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import rx.Observable;
import rx.Scheduler;
import static com.netflix.titus.api.jobmanager.model.job.sanitizer.JobSanitizerBuilder.JOB_PERMISSIVE_SANITIZER;
import static com.netflix.titus.api.jobmanager.model.job.sanitizer.JobSanitizerBuilder.JOB_STRICT_SANITIZER;
/**
* Helper class that encapsulates the creation process of job {@link ReconciliationFramework}.
*/
@Singleton
public class JobReconciliationFrameworkFactory {
private static final Logger logger = LoggerFactory.getLogger(JobReconciliationFrameworkFactory.class);
public static final String INCONSISTENT_DATA_FAILURE_ID = V3JobOperations.COMPONENT + ".inconsistentData";
static final String ROOT_METRIC_NAME = MetricConstants.METRIC_ROOT + "jobManager.bootstrap.";
private final FeatureActivationConfiguration featureConfiguration;
private enum TaskFenzoCheck {AddedToFenzo, EffectivelyFinished, FenzoAddError, Inconsistent}
static final String BATCH_RESOLVER = "batchResolver";
static final String SERVICE_RESOLVER = "serviceResolver";
private static final int MAX_RETRIEVE_TASK_CONCURRENCY = 100;
private static final JobEventFactory JOB_EVENT_FACTORY = new JobEventFactory();
private static final Map<Object, Comparator<EntityHolder>> INDEX_COMPARATORS = Collections.singletonMap(
IndexKind.StatusCreationTime, JobReconciliationFrameworkFactory::compareByStatusCreationTime
);
private final DifferenceResolver<JobManagerReconcilerEvent> dispatchingResolver;
private final JobManagerConfiguration jobManagerConfiguration;
private final JobStore store;
private final ApplicationSlaManagementService capacityGroupService;
private final EntitySanitizer permissiveEntitySanitizer;
private final EntitySanitizer strictEntitySanitizer;
private final VersionSupplier versionSupplier;
private final InitializationErrorCollector errorCollector; // Keep reference so it is not garbage collected (it holds metrics)
private final TitusRuntime titusRuntime;
private final Registry registry;
private final Clock clock;
private final Optional<Scheduler> optionalScheduler;
private final Gauge loadedJobs;
private final Gauge loadedTasks;
private final Gauge storeLoadTimeMs;
@Inject
public JobReconciliationFrameworkFactory(JobManagerConfiguration jobManagerConfiguration,
FeatureActivationConfiguration featureConfiguration,
@Named(BATCH_RESOLVER) DifferenceResolver<JobManagerReconcilerEvent> batchDifferenceResolver,
@Named(SERVICE_RESOLVER) DifferenceResolver<JobManagerReconcilerEvent> serviceDifferenceResolver,
JobStore store,
ApplicationSlaManagementService capacityGroupService,
@Named(JOB_PERMISSIVE_SANITIZER) EntitySanitizer permissiveEntitySanitizer,
@Named(JOB_STRICT_SANITIZER) EntitySanitizer strictEntitySanitizer,
VersionSupplier versionSupplier,
TitusRuntime titusRuntime) {
this(jobManagerConfiguration, featureConfiguration, batchDifferenceResolver, serviceDifferenceResolver, store,
capacityGroupService,
permissiveEntitySanitizer, strictEntitySanitizer, versionSupplier,
titusRuntime, Optional.empty());
}
public JobReconciliationFrameworkFactory(JobManagerConfiguration jobManagerConfiguration,
FeatureActivationConfiguration featureConfiguration,
DifferenceResolver<JobManagerReconcilerEvent> batchDifferenceResolver,
DifferenceResolver<JobManagerReconcilerEvent> serviceDifferenceResolver,
JobStore store,
ApplicationSlaManagementService capacityGroupService,
EntitySanitizer permissiveEntitySanitizer,
EntitySanitizer strictEntitySanitizer,
VersionSupplier versionSupplier,
TitusRuntime titusRuntime,
Optional<Scheduler> optionalScheduler) {
this.jobManagerConfiguration = jobManagerConfiguration;
this.featureConfiguration = featureConfiguration;
this.store = store;
this.capacityGroupService = capacityGroupService;
this.permissiveEntitySanitizer = permissiveEntitySanitizer;
this.strictEntitySanitizer = strictEntitySanitizer;
this.versionSupplier = versionSupplier;
this.optionalScheduler = optionalScheduler;
this.errorCollector = new InitializationErrorCollector(jobManagerConfiguration, titusRuntime);
this.titusRuntime = titusRuntime;
this.registry = titusRuntime.getRegistry();
this.clock = titusRuntime.getClock();
this.loadedJobs = registry.gauge(ROOT_METRIC_NAME + "loadedJobs");
this.loadedTasks = registry.gauge(ROOT_METRIC_NAME + "loadedTasks");
this.storeLoadTimeMs = registry.gauge(ROOT_METRIC_NAME + "storeLoadTimeMs");
this.dispatchingResolver = DifferenceResolvers.dispatcher(rootModel -> {
Job<?> job = rootModel.getEntity();
JobDescriptor.JobDescriptorExt extensions = job.getJobDescriptor().getExtensions();
if (extensions instanceof BatchJobExt) {
return batchDifferenceResolver;
} else if (extensions instanceof ServiceJobExt) {
return serviceDifferenceResolver;
} else {
throw new IllegalStateException("Unsupported job type " + extensions.getClass());
}
});
}
ReconciliationFramework<JobManagerReconcilerEvent> newInstance() {
List<Pair<Job, List<Task>>> jobsAndTasks = loadJobsAndTasksFromStore(errorCollector);
// initialize fenzo with running tasks
List<InternalReconciliationEngine<JobManagerReconcilerEvent>> engines = new ArrayList<>();
for (Pair<Job, List<Task>> pair : jobsAndTasks) {
Job job = pair.getLeft();
List<Task> tasks = pair.getRight();
InternalReconciliationEngine<JobManagerReconcilerEvent> engine = newRestoredEngine(job, tasks);
engines.add(engine);
for (Task task : tasks) {
Optional<Task> validatedTask = validateTask(task);
if (!validatedTask.isPresent()) {
errorCollector.invalidTaskRecord(task.getId());
}
}
}
errorCollector.failIfTooManyBadRecords();
return new DefaultReconciliationFramework<>(
engines,
bootstrapModel -> newEngine(bootstrapModel, true),
jobManagerConfiguration.getReconcilerIdleTimeoutMs(),
jobManagerConfiguration.getReconcilerActiveTimeoutMs(),
jobManagerConfiguration.getCheckpointIntervalMs(),
INDEX_COMPARATORS,
JOB_EVENT_FACTORY,
registry,
optionalScheduler
);
}
private InternalReconciliationEngine<JobManagerReconcilerEvent> newRestoredEngine(Job job, List<Task> tasks) {
EntityHolder jobHolder = EntityHolder.newRoot(job.getId(), job);
for (Task task : tasks) {
EntityHolder taskHolder = EntityHolder.newRoot(task.getId(), task);
EntityHolder decorated = TaskTimeoutChangeActions.setTimeoutOnRestoreFromStore(jobManagerConfiguration, taskHolder, clock);
jobHolder = jobHolder.addChild(decorated);
}
return newEngine(jobHolder, false);
}
private InternalReconciliationEngine<JobManagerReconcilerEvent> newEngine(EntityHolder bootstrapModel, boolean newlyCreated) {
return new DefaultReconciliationEngine<>(bootstrapModel,
newlyCreated,
dispatchingResolver,
INDEX_COMPARATORS,
JOB_EVENT_FACTORY,
this::extraChangeActionTags,
this::extraModelActionTags,
titusRuntime
);
}
private List<Tag> extraChangeActionTags(ChangeAction changeAction) {
if (changeAction instanceof TitusChangeAction) {
TitusChangeAction titusChangeAction = (TitusChangeAction) changeAction;
return Collections.singletonList(new BasicTag("action", titusChangeAction.getName()));
}
return Collections.emptyList();
}
private List<Tag> extraModelActionTags(JobManagerReconcilerEvent event) {
return Collections.singletonList(new BasicTag("event", event.getClass().getSimpleName()));
}
/**
* If the task is in KillInitiated state without resources assigned (this may happen for transition Accepted -> KillInitiated,
* as we always run through that state), do not add the task to Fenzo, as it was never assigned to any host, and we do
* not plan to run it. If the task is in Finished state, obviously it should not be added as well.
*/
private boolean isTaskEffectivelyFinished(Task task) {
TaskState taskState = task.getStatus().getState();
return taskState == TaskState.Finished || JobFunctions.containsExactlyTaskStates(task, TaskState.Accepted, TaskState.KillInitiated);
}
/**
* Check if task holds consistent state, and can be added to Fenzo
*/
private boolean hasPlacedTaskConsistentState(Task task) {
String host = task.getTaskContext().get(TaskAttributes.TASK_ATTRIBUTES_AGENT_HOST);
if (host == null) {
logger.warn("Task {} in state {} has no host assigned. Ignoring it.", task.getId(), task.getStatus().getState());
return false;
}
return true;
}
private List<Pair<Job, List<Task>>> loadJobsAndTasksFromStore(InitializationErrorCollector errorCollector) {
long startTime = clock.wallTime();
// load all job/task pairs
List<Pair<Job, Pair<List<Task>, Integer>>> jobTasksPairs;
try {
jobTasksPairs = store.init().andThen(store.retrieveJobs().flatMap(retrievedJobsAndErrors -> {
errorCollector.corruptedJobRecords(retrievedJobsAndErrors.getRight());
List<Job<?>> retrievedJobs = retrievedJobsAndErrors.getLeft();
List<Observable<Pair<Job, Pair<List<Task>, Integer>>>> retrieveTasksObservables = new ArrayList<>();
for (Job job : retrievedJobs) {
// TODO Finished jobs that were not archived immediately should be archived by background archive process
if (job.getStatus().getState() == JobState.Finished) {
logger.info("Not loading finished job: {}", job.getId());
continue;
}
Optional<Job> validatedJob = validateJob(job);
if (validatedJob.isPresent()) {
Observable<Pair<Job, Pair<List<Task>, Integer>>> retrieveTasksObservable = store.retrieveTasksForJob(job.getId())
.map(taskList -> new Pair<>(validatedJob.get(), taskList));
retrieveTasksObservables.add(retrieveTasksObservable);
} else {
errorCollector.invalidJob(job.getId());
}
}
return Observable.merge(retrieveTasksObservables, MAX_RETRIEVE_TASK_CONCURRENCY);
})).toList().toBlocking().singleOrDefault(Collections.emptyList());
int corruptedTaskRecords = jobTasksPairs.stream().mapToInt(p -> p.getRight().getRight()).sum();
errorCollector.corruptedTaskRecords(corruptedTaskRecords);
int taskCount = jobTasksPairs.stream().map(p -> p.getRight().getLeft().size()).reduce(0, (a, v) -> a + v);
loadedJobs.set(jobTasksPairs.size());
loadedTasks.set(taskCount);
for (Pair<Job, Pair<List<Task>, Integer>> jobTaskPair : jobTasksPairs) {
Job job = jobTaskPair.getLeft();
List<Task> tasks = jobTaskPair.getRight().getLeft();
List<String> taskStrings = tasks.stream()
.map(t -> String.format("<%s,ks:%s>", t.getId(), t.getStatus().getState()))
.collect(Collectors.toList());
logger.info("Loaded job: {} with tasks: {}", job.getId(), taskStrings);
}
logger.info("{} jobs and {} tasks loaded from store in {}ms", jobTasksPairs.size(), taskCount, clock.wallTime() - startTime);
} catch (Exception e) {
logger.error("Failed to load jobs from the store during initialization:", e);
throw new IllegalStateException("Failed to load jobs from the store during initialization", e);
} finally {
storeLoadTimeMs.set(clock.wallTime() - startTime);
}
return jobTasksPairs.stream().map(p -> Pair.of(p.getLeft(), p.getRight().getLeft())).collect(Collectors.toList());
}
private Optional<Job> validateJob(Job job) {
// Perform strict validation for reporting purposes
Set<ValidationError> strictViolations = strictEntitySanitizer.validate(job);
if (!strictViolations.isEmpty()) {
logger.error("No strictly consistent job record found: jobId={}, violations={}", job.getId(), EntitySanitizerUtil.toStringMap(strictViolations));
errorCollector.strictlyInvalidJob(job.getId());
}
// Required checks
Set<ValidationError> violations = permissiveEntitySanitizer.validate(job);
if (!violations.isEmpty()) {
logger.error("Bad job record found: jobId={}, violations={}", job.getId(), EntitySanitizerUtil.toStringMap(violations));
if (jobManagerConfiguration.isFailOnDataValidation()) {
return Optional.empty();
}
}
// If version is missing (old job objects) create one based on the current job state.
Job jobWithVersion = job;
if (job.getVersion() == null || job.getVersion().getTimestamp() < 0) {
Version newVersion = Version.newBuilder().withTimestamp(job.getStatus().getTimestamp()).build();
jobWithVersion = job.toBuilder().withVersion(newVersion).build();
}
return Optional.of(jobWithVersion);
}
private Optional<Task> validateTask(Task task) {
// Perform strict validation for reporting purposes
Set<ValidationError> strictViolations = strictEntitySanitizer.validate(task);
if (!strictViolations.isEmpty()) {
logger.error("No strictly consistent task record found: taskId={}, violations={}", task.getId(), EntitySanitizerUtil.toStringMap(strictViolations));
errorCollector.strictlyInvalidTask(task.getId());
}
// Required checks
Set<ValidationError> violations = permissiveEntitySanitizer.validate(task);
if (!violations.isEmpty()) {
logger.error("Bad task record found: taskId={}, violations={}", task.getId(), EntitySanitizerUtil.toStringMap(violations));
if (jobManagerConfiguration.isFailOnDataValidation()) {
return Optional.empty();
}
}
// If version is missing (old task objects) create one based on the current task state.
Task taskWithVersion = task;
if (task.getVersion() == null || task.getVersion().getTimestamp() < 0) {
Version newVersion = Version.newBuilder().withTimestamp(task.getStatus().getTimestamp()).build();
taskWithVersion = task.toBuilder().withVersion(newVersion).build();
}
return Optional.of(taskWithVersion);
}
private static int compareByStatusCreationTime(EntityHolder holder1, EntityHolder holder2) {
if (holder1.getEntity() instanceof Job) {
Job job1 = holder1.getEntity();
Job job2 = holder2.getEntity();
return Long.compare(job1.getStatus().getTimestamp(), job2.getStatus().getTimestamp());
}
Task task1 = holder1.getEntity();
Task task2 = holder2.getEntity();
return Long.compare(task1.getStatus().getTimestamp(), task2.getStatus().getTimestamp());
}
}
| 46 |
0 | Create_ds/titus-control-plane/titus-server-master/src/main/java/com/netflix/titus/master/jobmanager | Create_ds/titus-control-plane/titus-server-master/src/main/java/com/netflix/titus/master/jobmanager/service/V3JobManagerModule.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.master.jobmanager.service;
import javax.inject.Named;
import javax.inject.Singleton;
import com.google.inject.AbstractModule;
import com.google.inject.Key;
import com.google.inject.Provides;
import com.google.inject.TypeLiteral;
import com.google.inject.name.Names;
import com.netflix.archaius.ConfigProxyFactory;
import com.netflix.titus.api.jobmanager.service.ReadOnlyJobOperations;
import com.netflix.titus.api.jobmanager.service.V3JobOperations;
import com.netflix.titus.common.framework.reconciler.ReconciliationEngine.DifferenceResolver;
import com.netflix.titus.common.runtime.TitusRuntime;
import com.netflix.titus.common.util.limiter.Limiters;
import com.netflix.titus.common.util.limiter.tokenbucket.FixedIntervalTokenBucketConfiguration;
import com.netflix.titus.common.util.limiter.tokenbucket.TokenBucket;
import com.netflix.titus.master.jobmanager.service.batch.BatchDifferenceResolver;
import com.netflix.titus.master.jobmanager.service.event.JobManagerReconcilerEvent;
import com.netflix.titus.master.jobmanager.service.limiter.DefaultJobSubmitLimiter;
import com.netflix.titus.master.jobmanager.service.limiter.JobSubmitLimiter;
import com.netflix.titus.master.jobmanager.service.service.ServiceDifferenceResolver;
import com.netflix.titus.master.jobmanager.store.ArchivedTasksGc;
import com.netflix.titus.master.jobmanager.store.ArchivedTasksGcConfiguration;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public class V3JobManagerModule extends AbstractModule {
private static final Logger logger = LoggerFactory.getLogger(V3JobManagerModule.class);
private static final String STUCK_IN_STATE = "stuckInStateTokenBucketConfig";
private static final TypeLiteral<DifferenceResolver<JobManagerReconcilerEvent>> JOB_DIFFERENCE_RESOLVER =
new TypeLiteral<DifferenceResolver<JobManagerReconcilerEvent>>() {
};
@Override
protected void configure() {
bind(Key.get(JOB_DIFFERENCE_RESOLVER, Names.named(JobReconciliationFrameworkFactory.BATCH_RESOLVER))).to(BatchDifferenceResolver.class);
bind(Key.get(JOB_DIFFERENCE_RESOLVER, Names.named(JobReconciliationFrameworkFactory.SERVICE_RESOLVER))).to(ServiceDifferenceResolver.class);
bind(V3JobOperations.class).to(DefaultV3JobOperations.class);
bind(ReadOnlyJobOperations.class).to(DefaultV3JobOperations.class);
bind(JobSubmitLimiter.class).to(DefaultJobSubmitLimiter.class);
bind(KubeNotificationProcessor.class).asEagerSingleton();
bind(JobAndTaskMetrics.class).asEagerSingleton();
bind(ArchivedTasksGc.class).asEagerSingleton();
}
@Provides
@Singleton
public VersionSupplier getVersionSupplier(TitusRuntime titusRuntime) {
return VersionSuppliers.newInstance(titusRuntime.getClock());
}
@Provides
@Singleton
public JobManagerConfiguration getJobManagerConfiguration(ConfigProxyFactory factory) {
return factory.newProxy(JobManagerConfiguration.class);
}
@Provides
@Singleton
@Named(JobManagerConfiguration.STUCK_IN_STATE_TOKEN_BUCKET)
public TokenBucket getStuckInStateRateLimiter(@Named(STUCK_IN_STATE) FixedIntervalTokenBucketConfiguration config, TitusRuntime runtime) {
return Limiters.createInstrumentedFixedIntervalTokenBucket(
JobManagerConfiguration.STUCK_IN_STATE_TOKEN_BUCKET,
config,
currentTokenBucket -> logger.info("Detected {} token bucket configuration update: {}", JobManagerConfiguration.STUCK_IN_STATE_TOKEN_BUCKET, currentTokenBucket),
runtime
);
}
@Provides
@Singleton
@Named(STUCK_IN_STATE)
public FixedIntervalTokenBucketConfiguration getStuckInStateTokenBucketConfiguration(ConfigProxyFactory factory) {
return factory.newProxy(FixedIntervalTokenBucketConfiguration.class, "titusMaster.jobManager.stuckInStateTokenBucket");
}
@Provides
@Singleton
public ArchivedTasksGcConfiguration getArchivedTasksGcConfiguration(ConfigProxyFactory factory) {
return factory.newProxy(ArchivedTasksGcConfiguration.class);
}
}
| 47 |
0 | Create_ds/titus-control-plane/titus-server-master/src/main/java/com/netflix/titus/master/jobmanager | Create_ds/titus-control-plane/titus-server-master/src/main/java/com/netflix/titus/master/jobmanager/service/JobManagerUtil.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.master.jobmanager.service;
import java.util.HashMap;
import java.util.Map;
import java.util.Optional;
import java.util.function.BiConsumer;
import java.util.function.Function;
import com.netflix.titus.api.jobmanager.TaskAttributes;
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.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.disruptionbudget.SelfManagedDisruptionBudgetPolicy;
import com.netflix.titus.api.model.ApplicationSLA;
import com.netflix.titus.api.model.Tier;
import com.netflix.titus.common.runtime.TitusRuntime;
import com.netflix.titus.common.util.StringExt;
import com.netflix.titus.common.util.tuple.Pair;
import com.netflix.titus.master.kubernetes.client.model.PodWrapper;
import com.netflix.titus.master.service.management.ApplicationSlaManagementService;
import static com.netflix.titus.common.kube.Annotations.AnnotationKeyBranchEniID;
import static com.netflix.titus.common.kube.Annotations.AnnotationKeyEffectiveNetworkMode;
import static com.netflix.titus.common.kube.Annotations.AnnotationKeyElasticIPv4Address;
import static com.netflix.titus.common.kube.Annotations.AnnotationKeyIPAddress;
import static com.netflix.titus.common.kube.Annotations.AnnotationKeyIPv4Address;
import static com.netflix.titus.common.kube.Annotations.AnnotationKeyIPv4TransitionAddress;
import static com.netflix.titus.common.kube.Annotations.AnnotationKeyIPv6Address;
import static com.netflix.titus.common.kube.Annotations.AnnotationKeyNetworkSecurityGroups;
import static com.netflix.titus.common.kube.Annotations.AnnotationKeyNetworkSubnetIDs;
/**
* Collection of common functions.
*/
public final class JobManagerUtil {
private JobManagerUtil() {
}
public static Pair<Tier, String> getTierAssignment(Job job, ApplicationSlaManagementService capacityGroupService) {
return getTierAssignment(job.getJobDescriptor(), capacityGroupService);
}
public static Pair<Tier, String> getTierAssignment(JobDescriptor<?> jobDescriptor, ApplicationSlaManagementService capacityGroupService) {
String capacityGroup = jobDescriptor.getCapacityGroup();
ApplicationSLA applicationSLA = capacityGroupService.getApplicationSLA(capacityGroup);
if (applicationSLA == null) {
capacityGroup = ApplicationSlaManagementService.DEFAULT_APPLICATION;
applicationSLA = capacityGroupService.getApplicationSLA(capacityGroup);
}
return Pair.of(applicationSLA.getTier(), capacityGroup);
}
public static ApplicationSLA getCapacityGroupDescriptor(JobDescriptor<?> jobDescriptor, ApplicationSlaManagementService capacityGroupService) {
String capacityGroup = jobDescriptor.getCapacityGroup();
ApplicationSLA applicationSLA = capacityGroupService.getApplicationSLA(capacityGroup);
return applicationSLA == null ? capacityGroupService.getApplicationSLA(ApplicationSlaManagementService.DEFAULT_APPLICATION) : applicationSLA;
}
public static String getCapacityGroupDescriptorName(JobDescriptor<?> jobDescriptor, ApplicationSlaManagementService capacityGroupService) {
ApplicationSLA applicationSLA = getCapacityGroupDescriptor(jobDescriptor, capacityGroupService);
return applicationSLA == null ? ApplicationSlaManagementService.DEFAULT_APPLICATION : applicationSLA.getAppName();
}
public static Function<Task, Optional<Task>> newTaskStateUpdater(TaskStatus newTaskStatus, TitusRuntime titusRuntime) {
return oldTask -> {
TaskState oldState = oldTask.getStatus().getState();
TaskState newState = newTaskStatus.getState();
// De-duplicate task status updates. 'Launched' state is reported from two places, so we get
// 'Launched' state update twice. For other states there may be multiple updates, each with different reason.
// For example in 'StartInitiated', multiple updates are sent reporting progress of a container setup.
if (TaskStatus.areEquivalent(newTaskStatus, oldTask.getStatus())) {
return Optional.empty();
}
if (newState == oldState && newState == TaskState.Launched) {
return Optional.empty();
}
// Sanity check. If we got earlier task state, it is state model invariant violation.
if (TaskState.isBefore(newState, oldState)) {
titusRuntime.getCodeInvariants().inconsistent("Received task state update to a previous state: taskId=%s, previous=%s, current=%s", oldTask.getId(), oldState, newState);
return Optional.empty();
}
Task newTask = JobFunctions.changeTaskStatus(oldTask, newTaskStatus);
return Optional.of(newTask);
};
}
public static Task attachNetworkDataFromPod(Task task, PodWrapper podWrapper) {
Map<String, String> annotations = podWrapper.getV1Pod().getMetadata().getAnnotations();
if (annotations == null) {
return task;
}
String ipaddress = annotations.get(AnnotationKeyIPAddress);
String elasticIPAddress = annotations.get(AnnotationKeyElasticIPv4Address);
String eniIPAddress = annotations.get(AnnotationKeyIPv4Address);
String eniIPv6Address = annotations.get(AnnotationKeyIPv6Address);
String effectiveNetworkMode = annotations.get(AnnotationKeyEffectiveNetworkMode);
String eniID = annotations.get(AnnotationKeyBranchEniID);
String transitionIPAddress = annotations.get(AnnotationKeyIPv4TransitionAddress);
Map<String, String> newContext = new HashMap<>(task.getTaskContext());
BiConsumer<String, String> contextSetter = (key, value) -> StringExt.applyIfNonEmpty(value, v -> newContext.put(key, v));
contextSetter.accept(TaskAttributes.TASK_ATTRIBUTES_CONTAINER_IP, ipaddress);
contextSetter.accept(TaskAttributes.TASK_ATTRIBUTES_CONTAINER_IPV6, eniIPv6Address);
contextSetter.accept(TaskAttributes.TASK_ATTRIBUTES_NETWORK_INTERFACE_ID, eniID);
contextSetter.accept(TaskAttributes.TASK_ATTRIBUTES_NETWORK_EFFECTIVE_MODE, effectiveNetworkMode);
contextSetter.accept(TaskAttributes.TASK_ATTRIBUTES_TRANSITION_IPV4, transitionIPAddress);
contextSetter.accept(TaskAttributes.TASK_ATTRIBUTES_CONTAINER_IPV4, eniIPAddress);
contextSetter.accept(TaskAttributes.TASK_ATTRIBUTES_ELASTIC_IPV4, elasticIPAddress);
// In certain network modes, these annotations are available to be set
contextSetter.accept(TaskAttributes.TASK_ATTRIBUTES_NETWORK_SUBNETS, annotations.get(AnnotationKeyNetworkSubnetIDs));
contextSetter.accept(TaskAttributes.TASK_ATTRIBUTES_NETWORK_SECURITY_GROUPS, annotations.get(AnnotationKeyNetworkSecurityGroups));
return task.toBuilder().addAllToTaskContext(newContext).build();
}
/**
* @return {@link Optional#empty()} when no binpacking should be applied for task relocation purposes
*/
public static Optional<String> getRelocationBinpackMode(Job<?> job) {
return job.getJobDescriptor().getDisruptionBudget().getDisruptionBudgetPolicy() instanceof SelfManagedDisruptionBudgetPolicy
? Optional.of("SelfManaged")
: Optional.empty();
}
}
| 48 |
0 | Create_ds/titus-control-plane/titus-server-master/src/main/java/com/netflix/titus/master/jobmanager | Create_ds/titus-control-plane/titus-server-master/src/main/java/com/netflix/titus/master/jobmanager/service/JobServiceRuntime.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.master.jobmanager.service;
import java.util.concurrent.TimeUnit;
import javax.inject.Inject;
import javax.inject.Singleton;
import com.netflix.titus.common.runtime.TitusRuntime;
import com.netflix.titus.common.util.retry.Retryer;
import com.netflix.titus.common.util.retry.Retryers;
import com.netflix.titus.common.util.time.Clock;
@Singleton
public class JobServiceRuntime {
private final JobManagerConfiguration configuration;
private final ComputeProvider computeProvider;
private final TitusRuntime titusRuntime;
private final Clock clock;
private final Retryer systemRetryer;
@Inject
public JobServiceRuntime(JobManagerConfiguration configuration,
ComputeProvider computeProvider,
TitusRuntime titusRuntime) {
this.configuration = configuration;
this.computeProvider = computeProvider;
this.titusRuntime = titusRuntime;
this.clock = titusRuntime.getClock();
this.systemRetryer = Retryers.exponentialBackoff(
configuration.getSystemRetryerMinDelayMs(),
configuration.getSystemRetryerMaxDelayMs(),
TimeUnit.MILLISECONDS
);
}
public JobManagerConfiguration getConfiguration() {
return configuration;
}
public ComputeProvider getComputeProvider() {
return computeProvider;
}
public TitusRuntime getTitusRuntime() {
return titusRuntime;
}
public Clock getClock() {
return clock;
}
public Retryer getSystemRetryer() {
return systemRetryer;
}
}
| 49 |
0 | Create_ds/titus-control-plane/titus-server-master/src/main/java/com/netflix/titus/master/jobmanager | Create_ds/titus-control-plane/titus-server-master/src/main/java/com/netflix/titus/master/jobmanager/service/TaskStateReport.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.master.jobmanager.service;
import java.util.Arrays;
import java.util.HashSet;
import java.util.Set;
import com.netflix.titus.api.jobmanager.model.job.TaskState;
import com.netflix.titus.api.jobmanager.model.job.TaskStatus;
/**
* {@link TaskStatus} consists of the a task state, and reason code. To report task state metrics, we have to
* collapse task state/reason code to a single value.
*/
public enum TaskStateReport {
Accepted,
Launched,
StartInitiated,
Started,
KillInitiated,
Disconnected,
Finished,
Failed;
private static final Set<TaskStateReport> SET_OF_ALL = new HashSet<>(Arrays.asList(TaskStateReport.values()));
public static TaskStateReport of(TaskStatus taskStatus) {
TaskState taskState = taskStatus.getState();
switch (taskState) {
case Accepted:
return Accepted;
case Launched:
return Launched;
case StartInitiated:
return StartInitiated;
case Started:
return Started;
case KillInitiated:
return KillInitiated;
case Disconnected:
return Disconnected;
case Finished:
return TaskStatus.REASON_NORMAL.equals(taskStatus.getReasonCode()) ? Finished : Failed;
}
return Failed;
}
public static Set<TaskStateReport> setOfAll() {
return SET_OF_ALL;
}
public static boolean isTerminalState(TaskStateReport state) {
return state == Finished || state == Failed;
}
}
| 50 |
0 | Create_ds/titus-control-plane/titus-server-master/src/main/java/com/netflix/titus/master/jobmanager | Create_ds/titus-control-plane/titus-server-master/src/main/java/com/netflix/titus/master/jobmanager/service/KubeNotificationProcessor.java | /*
* Copyright 2020 Netflix, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.netflix.titus.master.jobmanager.service;
import java.time.Duration;
import java.util.ArrayList;
import java.util.Comparator;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicLong;
import javax.inject.Inject;
import javax.inject.Singleton;
import com.google.common.annotations.VisibleForTesting;
import com.google.common.base.Stopwatch;
import com.netflix.spectator.api.Counter;
import com.netflix.spectator.api.Gauge;
import com.netflix.spectator.api.Timer;
import com.netflix.titus.api.jobmanager.TaskAttributes;
import com.netflix.titus.api.jobmanager.model.job.ExecutableStatus;
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.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.service.V3JobOperations;
import com.netflix.titus.api.model.callmetadata.CallMetadata;
import com.netflix.titus.common.runtime.TitusRuntime;
import com.netflix.titus.common.util.CollectionsExt;
import com.netflix.titus.common.util.Evaluators;
import com.netflix.titus.common.util.ExecutorsExt;
import com.netflix.titus.common.util.guice.annotation.Activator;
import com.netflix.titus.common.util.rx.ReactorExt;
import com.netflix.titus.common.util.tuple.Either;
import com.netflix.titus.common.util.tuple.Pair;
import com.netflix.titus.master.MetricConstants;
import com.netflix.titus.master.kubernetes.ContainerResultCodeResolver;
import com.netflix.titus.master.kubernetes.KubeUtil;
import com.netflix.titus.master.kubernetes.KubernetesConfiguration;
import com.netflix.titus.master.kubernetes.PodToTaskMapper;
import com.netflix.titus.master.kubernetes.client.DirectKubeApiServerIntegrator;
import com.netflix.titus.master.kubernetes.client.model.PodDeletedEvent;
import com.netflix.titus.master.kubernetes.client.model.PodEvent;
import com.netflix.titus.master.kubernetes.client.model.PodNotFoundEvent;
import com.netflix.titus.master.kubernetes.client.model.PodUpdatedEvent;
import com.netflix.titus.master.kubernetes.client.model.PodWrapper;
import com.netflix.titus.master.kubernetes.controller.KubeJobManagementReconciler;
import io.kubernetes.client.openapi.models.V1ContainerState;
import io.kubernetes.client.openapi.models.V1Node;
import io.kubernetes.client.openapi.models.V1PodStatus;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import reactor.core.Disposable;
import reactor.core.publisher.Mono;
import reactor.core.scheduler.Scheduler;
import reactor.core.scheduler.Schedulers;
import reactor.util.retry.Retry;
import static com.netflix.titus.common.util.Evaluators.acceptNotNull;
import static com.netflix.titus.runtime.kubernetes.KubeConstants.TITUS_NODE_DOMAIN;
/**
* TODO Incorporate this into {@link DefaultV3JobOperations} once Fenzo is removed.
*/
@Singleton
public class KubeNotificationProcessor {
private static final Logger logger = LoggerFactory.getLogger(KubeNotificationProcessor.class);
private static final CallMetadata KUBE_CALL_METADATA = CallMetadata.newBuilder().withCallerId("Kube").build();
private static final String METRICS_ROOT = MetricConstants.METRIC_JOB_MANAGER + "kubeNotificationProcessor.";
private final KubernetesConfiguration configuration;
private final DirectKubeApiServerIntegrator kubeApiServerIntegrator;
private final KubeJobManagementReconciler kubeJobManagementReconciler;
private final V3JobOperations v3JobOperations;
private final ContainerResultCodeResolver containerResultCodeResolver;
private final TitusRuntime titusRuntime;
private final Timer metricsProcessed;
private final Gauge metricsRunning;
private final Gauge metricsLag;
private final Counter metricsChangesApplied;
private final Counter metricsNoChangesApplied;
private ExecutorService notificationHandlerExecutor;
private Scheduler scheduler;
private Disposable subscription;
@Inject
public KubeNotificationProcessor(KubernetesConfiguration configuration,
DirectKubeApiServerIntegrator kubeApiServerIntegrator,
KubeJobManagementReconciler kubeJobManagementReconciler,
V3JobOperations v3JobOperations,
ContainerResultCodeResolver containerResultCodeResolver,
TitusRuntime titusRuntime) {
this.configuration = configuration;
this.kubeApiServerIntegrator = kubeApiServerIntegrator;
this.kubeJobManagementReconciler = kubeJobManagementReconciler;
this.v3JobOperations = v3JobOperations;
this.containerResultCodeResolver = containerResultCodeResolver;
this.titusRuntime = titusRuntime;
this.metricsProcessed = titusRuntime.getRegistry().timer(METRICS_ROOT + "processed");
this.metricsRunning = titusRuntime.getRegistry().gauge(METRICS_ROOT + "running");
this.metricsLag = titusRuntime.getRegistry().gauge(METRICS_ROOT + "lag");
this.metricsChangesApplied = titusRuntime.getRegistry().counter(METRICS_ROOT + "changes", "changed", "true");
this.metricsNoChangesApplied = titusRuntime.getRegistry().counter(METRICS_ROOT + "changes", "changed", "false");
}
@Activator
public void enterActiveMode() {
this.scheduler = initializeNotificationScheduler();
AtomicLong pendingCounter = new AtomicLong();
this.subscription = kubeApiServerIntegrator.events().mergeWith(kubeJobManagementReconciler.getPodEventSource())
.subscribeOn(scheduler)
.publishOn(scheduler)
.doOnError(error -> logger.warn("Kube integration event stream terminated with an error (retrying soon)", error))
.retryWhen(Retry.backoff(Long.MAX_VALUE, Duration.ofSeconds(1)))
.subscribe(
event -> {
Stopwatch stopwatch = Stopwatch.createStarted();
pendingCounter.getAndIncrement();
metricsRunning.set(pendingCounter.get());
metricsLag.set(PodEvent.nextSequence() - event.getSequenceNumber());
logger.info("New event [pending={}, lag={}]: {}", pendingCounter.get(), PodEvent.nextSequence() - event.getSequenceNumber(), event);
processEvent(event)
.doAfterTerminate(() -> {
pendingCounter.decrementAndGet();
long elapsed = stopwatch.elapsed(TimeUnit.MILLISECONDS);
metricsProcessed.record(elapsed, TimeUnit.MILLISECONDS);
metricsRunning.set(pendingCounter.get());
logger.info("Event processed [pending={}]: event={}, elapsed={}", pendingCounter.get(), event, elapsed);
})
.subscribe(
next -> {
// nothing
},
error -> {
logger.info("Kube notification event state update error: event={}, error={}", event, error.getMessage());
logger.debug("Stack trace", error);
},
() -> {
// nothing
}
);
},
e -> logger.error("Event stream terminated"),
() -> logger.info("Event stream completed")
);
}
@VisibleForTesting
protected Scheduler initializeNotificationScheduler() {
this.notificationHandlerExecutor = ExecutorsExt.namedSingleThreadExecutor(KubeNotificationProcessor.class.getSimpleName());
return Schedulers.fromExecutor(notificationHandlerExecutor);
}
private Mono<Void> processEvent(PodEvent event) {
Pair<Job<?>, Task> jobAndTask = v3JobOperations.findTaskById(event.getTaskId()).orElse(null);
if (jobAndTask == null) {
logger.warn("Got Kube notification about unknown task: {}", event.getTaskId());
return Mono.empty();
}
Task task = jobAndTask.getRight();
if (event instanceof PodNotFoundEvent) {
return handlePodNotFoundEvent((PodNotFoundEvent) event);
}
// We depend in this flatmap on the fact that the task update event is added by the source thread to
// the job reconciler queue. This guarantees the right order of the execution.
// TODO Implement flatMapWithSequentialSubscription operator
return handlePodUpdatedEvent(event, jobAndTask.getLeft(), task);
}
public void shutdown() {
ReactorExt.safeDispose(subscription);
Evaluators.acceptNotNull(scheduler, Scheduler::dispose);
Evaluators.acceptNotNull(notificationHandlerExecutor, ExecutorService::shutdown);
}
private Mono<Void> handlePodUpdatedEvent(PodEvent event, Job job, Task task) {
// This is basic sanity check. If it fails, we have a major problem with pod state.
if (event.getPod() == null || event.getPod().getStatus() == null || event.getPod().getStatus().getPhase() == null) {
logger.warn("Pod notification with pod without status or phase set: taskId={}, pod={}", task.getId(), event.getPod());
metricsNoChangesApplied.increment();
return Mono.empty();
}
PodWrapper podWrapper = new PodWrapper(event.getPod());
Optional<V1Node> node;
if (event instanceof PodUpdatedEvent) {
node = ((PodUpdatedEvent) event).getNode();
} else if (event instanceof PodDeletedEvent) {
node = ((PodDeletedEvent) event).getNode();
} else {
node = Optional.empty();
}
Either<TaskStatus, String> newTaskStatusOrError = new PodToTaskMapper(configuration, podWrapper, node, task,
event instanceof PodDeletedEvent,
containerResultCodeResolver,
titusRuntime
).getNewTaskStatus();
if (newTaskStatusOrError.hasError()) {
logger.info(newTaskStatusOrError.getError());
metricsNoChangesApplied.increment();
return Mono.empty();
}
TaskStatus newTaskStatus = newTaskStatusOrError.getValue();
if (TaskStatus.areEquivalent(task.getStatus(), newTaskStatus)) {
logger.info("Pod change notification does not change task status: taskId={}, status={}, eventSequenceNumber={}", task.getId(), newTaskStatus, event.getSequenceNumber());
} else {
logger.info("Pod notification changes task status: taskId={}, fromStatus={}, toStatus={}, eventSequenceNumber={}", task.getId(),
task.getStatus(), newTaskStatus, event.getSequenceNumber());
}
// Check if the task is changed early before creating change action in the job service. If there is no material
// change to the task, return immediately. If there are differences, we will check again in the change action
// against most up to date task version.
if (!updateTaskStatus(podWrapper, newTaskStatus, node, task, true).isPresent()) {
return Mono.empty();
}
return ReactorExt.toMono(v3JobOperations.updateTask(
task.getId(),
current -> updateTaskStatus(podWrapper, newTaskStatus, node, current, false),
V3JobOperations.Trigger.Kube,
"Pod status updated from kubernetes node (k8phase='" + event.getPod().getStatus().getPhase() + "', taskState=" + task.getStatus().getState() + ")",
KUBE_CALL_METADATA
));
}
private Mono<Void> handlePodNotFoundEvent(PodNotFoundEvent event) {
Task task = event.getTask();
logger.info("Pod not found event: taskId={}, finalTaskStatus={}", task.getId(), event.getFinalTaskStatus());
return ReactorExt.toMono(v3JobOperations.updateTask(
task.getId(),
currentTask -> {
List<TaskStatus> newHistory = CollectionsExt.copyAndAdd(currentTask.getStatusHistory(), currentTask.getStatus());
Task updatedTask = currentTask.toBuilder()
.withStatus(event.getFinalTaskStatus())
.withStatusHistory(newHistory)
.build();
metricsChangesApplied.increment();
return Optional.of(updatedTask);
},
V3JobOperations.Trigger.Kube,
"Pod status updated from kubernetes node, it couldn't find the pod " + task.getId(),
KUBE_CALL_METADATA
));
}
@VisibleForTesting
Optional<Task> updateTaskStatus(PodWrapper podWrapper,
TaskStatus newTaskStatus,
Optional<V1Node> node,
Task currentTask,
boolean precheck) {
// This may happen as we build 'newTaskStatus' outside of the reconciler transaction. A real example:
// 1. a job is terminated by a user
// 2. reconciler moves the job's task to the 'KillInitiated' state, and calls KubeAPI.deleteNamespacedPod
// 3. before `KubeAPI.deleteNamespacedPod` completes, KubeAPI sends pod notification triggered by that action
// 4. pod notification handler receives the update. The latest committed task state is still 'Started'.
// 5. a new job transaction is created to write pod update (taskState='Started'), and is put into the reconciler queue
// 6. `KubeAPI.deleteNamespacedPod` completes, and the new task state 'KillInitiated' is written
// 7. the pod transaction is taken off the queue and is executed, and writes new task state 'Started'
// 8. in the next reconciliation loop a task is moved again to 'KillInitiated' state.
if (TaskState.isBefore(newTaskStatus.getState(), currentTask.getStatus().getState())) {
logger.info("[precheck={}] Ignoring an attempt to move the task state to the earlier one: taskId={}, attempt={}, current={}",
precheck, currentTask.getId(), newTaskStatus.getState(), currentTask.getStatus().getState()
);
metricsNoChangesApplied.increment();
return Optional.empty();
}
Task updatedTask;
if (TaskStatus.areEquivalent(currentTask.getStatus(), newTaskStatus)) {
updatedTask = currentTask;
} else {
List<TaskStatus> newHistory = CollectionsExt.copyAndAdd(currentTask.getStatusHistory(), currentTask.getStatus());
updatedTask = currentTask.toBuilder()
.withStatus(newTaskStatus)
.withStatusHistory(newHistory)
.build();
}
Task fixedTask = fillInMissingStates(podWrapper, updatedTask);
Task taskWithExecutorData = JobManagerUtil.attachNetworkDataFromPod(fixedTask, podWrapper);
Task taskWithNodeMetadata = node.map(n -> attachNodeMetadata(taskWithExecutorData, n)).orElse(taskWithExecutorData);
Optional<String> difference = areTasksEquivalent(currentTask, taskWithNodeMetadata);
if (!difference.isPresent()) {
logger.debug("[precheck={}] Ignoring the pod event as the update results in the identical task object as the current one: taskId={}",
precheck, currentTask.getId());
metricsNoChangesApplied.increment();
return Optional.empty();
}
if (!precheck) {
logger.info("[precheck={}] Tasks are different: difference='{}', current={}, updated={}",
precheck, difference.get(), currentTask, taskWithNodeMetadata);
metricsChangesApplied.increment();
}
return Optional.of(taskWithNodeMetadata);
}
private static Task attachNodeMetadata(Task task, V1Node node) {
Map<String, String> annotations = node.getMetadata().getAnnotations();
if (CollectionsExt.isNullOrEmpty(annotations)) {
return task;
}
Map<String, String> agentAttributes = new HashMap<>();
acceptNotNull(annotations.get(TITUS_NODE_DOMAIN + "ami"), ami -> agentAttributes.put(TaskAttributes.TASK_ATTRIBUTES_AGENT_AMI, ami));
acceptNotNull(annotations.get(TITUS_NODE_DOMAIN + "asg"), asg -> agentAttributes.put(TaskAttributes.TASK_ATTRIBUTES_AGENT_ASG, asg));
acceptNotNull(annotations.get(TITUS_NODE_DOMAIN + "cluster"), cluster -> agentAttributes.put(TaskAttributes.TASK_ATTRIBUTES_AGENT_CLUSTER, cluster));
acceptNotNull(annotations.get(TITUS_NODE_DOMAIN + "id"), id -> {
agentAttributes.put(TaskAttributes.TASK_ATTRIBUTES_AGENT_INSTANCE_ID, id);
agentAttributes.put("agent.id", id);
});
acceptNotNull(annotations.get(TITUS_NODE_DOMAIN + "itype"), itype -> agentAttributes.put(TaskAttributes.TASK_ATTRIBUTES_AGENT_ITYPE, itype));
acceptNotNull(annotations.get(TITUS_NODE_DOMAIN + "region"), region -> agentAttributes.put(TaskAttributes.TASK_ATTRIBUTES_AGENT_REGION, region));
acceptNotNull(annotations.get(TITUS_NODE_DOMAIN + "res"), res -> agentAttributes.put(TaskAttributes.TASK_ATTRIBUTES_AGENT_RES, res));
acceptNotNull(annotations.get(TITUS_NODE_DOMAIN + "stack"), stack -> {
agentAttributes.put(TaskAttributes.TASK_ATTRIBUTES_STACK, stack);
agentAttributes.put(TaskAttributes.TASK_ATTRIBUTES_AGENT_STACK, stack);
});
acceptNotNull(annotations.get(TITUS_NODE_DOMAIN + "zone"), zone -> agentAttributes.put(TaskAttributes.TASK_ATTRIBUTES_AGENT_ZONE, zone));
acceptNotNull(node.getMetadata().getName(), nodeName -> agentAttributes.put(TaskAttributes.TASK_ATTRIBUTES_KUBE_NODE_NAME, nodeName));
String nodeIpAddress = KubeUtil.getNodeIpV4Address(node).orElse("UnknownIpAddress");
agentAttributes.put(TaskAttributes.TASK_ATTRIBUTES_AGENT_HOST, nodeIpAddress);
agentAttributes.put(TaskAttributes.TASK_ATTRIBUTES_AGENT_HOST_IP, nodeIpAddress);
return task.toBuilder()
.withTaskContext(CollectionsExt.merge(task.getTaskContext(), agentAttributes))
.build();
}
private static Task fillInMissingStates(PodWrapper podWrapper, Task task) {
TaskState currentState = task.getStatus().getState();
if (currentState != TaskState.Started && currentState != TaskState.Finished) {
return task;
}
V1ContainerState containerState = podWrapper.findContainerState().orElse(null);
if (containerState == null) {
return task;
}
long startAtTimestamp;
if (currentState == TaskState.Started) {
if (containerState.getRunning() == null || containerState.getRunning().getStartedAt() == null) {
return task;
}
startAtTimestamp = containerState.getRunning().getStartedAt().toInstant().toEpochMilli();
} else { // TaskState.Finished
if (containerState.getTerminated() == null || containerState.getTerminated().getStartedAt() == null) {
// It must be the case where the container setup failed.
return fillInMissingStatesForContainerSetupFailure(podWrapper, task);
}
startAtTimestamp = containerState.getTerminated().getStartedAt().toInstant().toEpochMilli();
}
TaskStatus.Builder statusTemplate = TaskStatus.newBuilder()
.withReasonCode(TaskStatus.REASON_STATE_MISSING)
.withReasonMessage("Filled in missing state update that was missed previously")
.withTimestamp(startAtTimestamp);
List<TaskStatus> missingStatuses = new ArrayList<>();
addIfMissing(task, TaskState.Launched, statusTemplate).ifPresent(missingStatuses::add);
addIfMissing(task, TaskState.StartInitiated, statusTemplate).ifPresent(missingStatuses::add);
addIfMissing(task, TaskState.Started, statusTemplate).ifPresent(missingStatuses::add);
if (missingStatuses.isEmpty()) {
return task;
}
List<TaskStatus> newStatusHistory = new ArrayList<>(task.getStatusHistory());
newStatusHistory.addAll(missingStatuses);
newStatusHistory.sort(Comparator.comparing(ExecutableStatus::getState));
return task.toBuilder().withStatusHistory(newStatusHistory).build();
}
/**
* In case container could not be started, we do not have the container start time, only the finished time.
* The {@link V1PodStatus#getPhase()} is failed, and the {@link V1PodStatus#getMessage()} contains details on
* the nature of failure. There should be no launched state, so we add it to mark the container start attempt.
*/
private static Task fillInMissingStatesForContainerSetupFailure(PodWrapper podWrapper, Task task) {
// Sanity check. Should never be true.
if (JobFunctions.findTaskStatus(task, TaskState.Launched).isPresent()) {
return task;
}
long startAtTimestamp = podWrapper.findFinishedAt().orElse(task.getStatus().getTimestamp());
List<TaskStatus> newStatusHistory = new ArrayList<>(task.getStatusHistory());
newStatusHistory.add(TaskStatus.newBuilder()
.withState(TaskState.Launched)
.withReasonCode(TaskStatus.REASON_STATE_MISSING)
.withReasonMessage("Filled in missing state update that was missed previously due to container setup failure")
.withTimestamp(startAtTimestamp)
.build()
);
newStatusHistory.sort(Comparator.comparing(ExecutableStatus::getState));
return task.toBuilder().withStatusHistory(newStatusHistory).build();
}
private static Optional<TaskStatus> addIfMissing(Task task, TaskState expectedState, TaskStatus.Builder statusTemplate) {
Optional<TaskStatus> foundStatus = JobFunctions.findTaskStatus(task, expectedState);
if (!foundStatus.isPresent()) {
logger.debug("Adding missing task status: {} for task: {}", expectedState, task.getId());
return Optional.of(statusTemplate.withState(expectedState).build());
}
return Optional.empty();
}
/**
* 'updatedTask' is a modified copy of 'currentTask' (or exactly the same version of the object if nothing changed).
*/
@VisibleForTesting
static Optional<String> areTasksEquivalent(Task currentTask, Task updatedTask) {
if (currentTask == updatedTask) {
return Optional.empty();
}
if (!TaskStatus.areEquivalent(currentTask.getStatus(), updatedTask.getStatus())) {
return Optional.of("different task status");
}
if (!currentTask.getAttributes().equals(updatedTask.getAttributes())) {
return Optional.of("different task attributes");
}
if (!currentTask.getTaskContext().equals(updatedTask.getTaskContext())) {
return Optional.of("different task context");
}
if (!currentTask.getTwoLevelResources().equals(updatedTask.getTwoLevelResources())) {
return Optional.of("different task two level resources");
}
return Optional.empty();
}
}
| 51 |
0 | Create_ds/titus-control-plane/titus-server-master/src/main/java/com/netflix/titus/master/jobmanager | Create_ds/titus-control-plane/titus-server-master/src/main/java/com/netflix/titus/master/jobmanager/service/JobTransactionLogger.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.master.jobmanager.service;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicLong;
import com.netflix.titus.api.jobmanager.model.job.Task;
import com.netflix.titus.api.jobmanager.service.V3JobOperations;
import com.netflix.titus.common.framework.reconciler.ModelActionHolder;
import com.netflix.titus.common.framework.reconciler.ModelActionHolder.Model;
import com.netflix.titus.common.framework.reconciler.ReconciliationFramework;
import com.netflix.titus.common.util.ExceptionExt;
import com.netflix.titus.common.util.rx.ObservableExt;
import com.netflix.titus.common.util.time.Clock;
import com.netflix.titus.master.jobmanager.service.common.action.TitusChangeAction;
import com.netflix.titus.master.jobmanager.service.common.action.TitusModelAction;
import com.netflix.titus.master.jobmanager.service.event.JobChangeReconcilerEvent;
import com.netflix.titus.master.jobmanager.service.event.JobCheckpointReconcilerEvent;
import com.netflix.titus.master.jobmanager.service.event.JobManagerReconcilerEvent;
import com.netflix.titus.master.jobmanager.service.event.JobModelReconcilerEvent;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import rx.Observable;
import rx.Subscription;
import rx.schedulers.Schedulers;
/**
* Log all events in the following format:
* <br/>
* 'jobId=..., transactionId=..., status=ok, type=beforeChange, action=..., trigger=User , target=job , entityId=..., waited=..., elapsed=..., summary=...'
* <br/>
* 'jobId=..., transactionId=..., status=error, type=modelUpdate/reference, action=..., trigger=ComputeProvider, target=task, entityId=..., waited=..., elapsed=..., summary=...'
*/
class JobTransactionLogger {
private static final Logger logger = LoggerFactory.getLogger("JobTransactionLogger");
private static final long BUFFER_SIZE = 5000;
static Subscription logEvents(ReconciliationFramework<JobManagerReconcilerEvent> reconciliationFramework,
AtomicLong lastErrorRef,
Clock clock) {
lastErrorRef.set(-1);
return eventStreamWithBackpressure(reconciliationFramework)
.observeOn(Schedulers.io())
.retryWhen(errors -> errors.flatMap(
e -> {
// BUG: event stream breaks permanently, and cannot be retried.
// As we cannot fix the underlying issue yet, we have to be able to discover when it happens.
lastErrorRef.set(clock.wallTime());
logger.warn("Transactions may be missing in the log. The event stream has terminated with an error and must be re-subscribed: {}", ExceptionExt.toMessage(e));
return eventStreamWithBackpressure(reconciliationFramework);
}))
.subscribe(
event -> {
if (event instanceof JobCheckpointReconcilerEvent) {
logger.debug("Checkpoint: {}", event);
} else {
logger.info(doFormat(event));
}
},
e -> logger.error("Event stream terminated with an error", e),
() -> logger.info("Event stream completed")
);
}
static String doFormat(JobManagerReconcilerEvent event) {
if (event instanceof JobChangeReconcilerEvent.JobBeforeChangeReconcilerEvent) {
return logJobBeforeChangeReconcilerEvent((JobChangeReconcilerEvent.JobBeforeChangeReconcilerEvent) event);
}
if (event instanceof JobChangeReconcilerEvent.JobAfterChangeReconcilerEvent) {
return logJobAfterChangeReconcilerEvent((JobChangeReconcilerEvent.JobAfterChangeReconcilerEvent) event);
}
if (event instanceof JobChangeReconcilerEvent.JobChangeErrorReconcilerEvent) {
return logJobChangeErrorReconcilerEvent((JobChangeReconcilerEvent.JobChangeErrorReconcilerEvent) event);
}
if (event instanceof JobModelReconcilerEvent.JobNewModelReconcilerEvent) {
return logJobNewModelReconcilerEvent((JobModelReconcilerEvent.JobNewModelReconcilerEvent) event);
}
if (event instanceof JobModelReconcilerEvent.JobModelUpdateReconcilerEvent) {
return logJobModelUpdateReconcilerEvent((JobModelReconcilerEvent.JobModelUpdateReconcilerEvent) event);
}
if (event instanceof JobModelReconcilerEvent.JobModelUpdateErrorReconcilerEvent) {
return logJobModelUpdateErrorReconcilerEvent((JobModelReconcilerEvent.JobModelUpdateErrorReconcilerEvent) event);
}
return "Unknown event type: " + event.getClass();
}
private static Observable<JobManagerReconcilerEvent> eventStreamWithBackpressure(ReconciliationFramework<JobManagerReconcilerEvent> reconciliationFramework) {
return ObservableExt.onBackpressureDropAndNotify(
reconciliationFramework.events(),
BUFFER_SIZE,
droppedCount -> logger.warn("Dropping events due to buffer overflow in job transaction log: droppedCount={}", droppedCount),
1, TimeUnit.SECONDS
);
}
private static String logJobBeforeChangeReconcilerEvent(JobChangeReconcilerEvent.JobBeforeChangeReconcilerEvent event) {
TitusChangeAction changeAction = event.getChangeAction();
String jobId = event.getJob().getId();
String entityId = changeAction.getId();
return doFormat(
jobId,
event.getTransactionId(),
"ok",
"beforeChange",
event.getChangeAction().getName(),
changeAction.getTrigger(),
toTargetName(jobId, entityId),
entityId,
0,
0,
event.getCallMetadata().getCallerId(),
event.getCallMetadata().getCallReason(),
changeAction.getSummary()
);
}
private static String logJobAfterChangeReconcilerEvent(JobChangeReconcilerEvent.JobAfterChangeReconcilerEvent event) {
TitusChangeAction changeAction = event.getChangeAction();
String jobId = event.getJob().getId();
String entityId = changeAction.getId();
return doFormat(
jobId,
event.getTransactionId(),
"ok",
"afterChange",
event.getChangeAction().getName(),
changeAction.getTrigger(),
toTargetName(jobId, entityId),
entityId,
event.getWaitTimeMs(),
event.getExecutionTimeMs(),
event.getCallMetadata().getCallerId(),
event.getCallMetadata().getCallReason(),
changeAction.getSummary()
);
}
private static String logJobChangeErrorReconcilerEvent(JobChangeReconcilerEvent.JobChangeErrorReconcilerEvent event) {
TitusChangeAction changeAction = event.getChangeAction();
String jobId = event.getJob().getId();
String entityId = changeAction.getId();
return doFormat(
jobId,
event.getTransactionId(),
"error",
"afterChange",
event.getChangeAction().getName(),
changeAction.getTrigger(),
toTargetName(jobId, entityId),
entityId,
event.getWaitTimeMs(),
event.getExecutionTimeMs(),
event.getCallMetadata().getCallerId(),
event.getCallMetadata().getCallReason(),
event.getError().getMessage() + '(' + changeAction.getSummary() + ')'
);
}
private static String logJobNewModelReconcilerEvent(JobModelReconcilerEvent.JobNewModelReconcilerEvent event) {
String jobId = event.getJob().getId();
return doFormat(
jobId,
event.getTransactionId(),
"ok",
"modelUpdate/" + Model.Reference.name(),
"initial",
V3JobOperations.Trigger.API,
"job",
jobId,
0,
0,
event.getCallMetadata().getCallerId(),
event.getCallMetadata().getCallReason(),
"New job created"
);
}
private static String logJobModelUpdateReconcilerEvent(JobModelReconcilerEvent.JobModelUpdateReconcilerEvent event) {
String jobId = event.getJob().getId();
String entityId = event.getChangedEntityHolder().getId();
ModelActionHolder actionHolder = event.getModelActionHolder();
TitusModelAction action = (TitusModelAction) actionHolder.getAction();
String summary = event.getChangedEntityHolder().getEntity() instanceof Task
? action.getSummary() + "; " + taskChangeSummary(event)
: action.getSummary();
return doFormat(
jobId,
event.getTransactionId(),
"ok",
"modelUpdate/" + actionHolder.getModel().name(),
((TitusModelAction) actionHolder.getAction()).getName(),
event.getChangeAction().getTrigger(),
toTargetName(jobId, entityId),
entityId,
0,
0,
event.getCallMetadata().getCallerId(),
event.getCallMetadata().getCallReason(),
summary
);
}
private static String taskChangeSummary(JobModelReconcilerEvent.JobModelUpdateReconcilerEvent event) {
Task currentTask = event.getChangedEntityHolder().getEntity();
return String.format("Task{state=%s}", currentTask.getStatus().getState());
}
private static String logJobModelUpdateErrorReconcilerEvent(JobModelReconcilerEvent.JobModelUpdateErrorReconcilerEvent event) {
String jobId = event.getJob().getId();
String entityId = event.getPreviousEntityHolder().getId();
ModelActionHolder actionHolder = event.getModelActionHolder();
TitusModelAction action = (TitusModelAction) actionHolder.getAction();
return doFormat(
jobId,
event.getTransactionId(),
"error",
"modelUpdate/" + event.getModelActionHolder().getModel().name(),
((TitusModelAction) actionHolder.getAction()).getName(),
event.getChangeAction().getTrigger(),
toTargetName(jobId, entityId),
entityId,
0,
0,
event.getCallMetadata().getCallerId(),
event.getCallMetadata().getCallReason(),
action.getSummary()
);
}
private static String doFormat(String jobId,
String transactionId,
String status,
String type,
String action,
V3JobOperations.Trigger trigger,
String targetName,
String entityId,
long waitTimeMs,
long executionTime,
String callerID,
String callReason,
String summary) {
return String.format(
"jobId=%s entity=%s transactionId=%-5s target=%-4s status=%-5s type=%-22s action=%-45s trigger=%-10s callerId=%-15s callReason=%-20s %-16s %-15s summary=%s",
jobId,
entityId,
transactionId,
targetName,
status,
type,
action,
trigger,
callerID,
callReason,
"waited=" + waitTimeMs + "ms",
"elapsed=" + executionTime + "ms",
summary
);
}
private static String toTargetName(String jobId, String entityId) {
return jobId.equals(entityId) ? "job" : "task";
}
}
| 52 |
0 | Create_ds/titus-control-plane/titus-server-master/src/main/java/com/netflix/titus/master/jobmanager | Create_ds/titus-control-plane/titus-server-master/src/main/java/com/netflix/titus/master/jobmanager/service/VersionSupplier.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.master.jobmanager.service;
import com.netflix.titus.api.jobmanager.model.job.Version;
public interface VersionSupplier {
Version nextVersion();
}
| 53 |
0 | Create_ds/titus-control-plane/titus-server-master/src/main/java/com/netflix/titus/master/jobmanager | Create_ds/titus-control-plane/titus-server-master/src/main/java/com/netflix/titus/master/jobmanager/service/VersionSuppliers.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.master.jobmanager.service;
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.Version;
import com.netflix.titus.common.util.time.Clock;
public class VersionSuppliers {
public static VersionSupplier newInstance(Clock clock) {
return new SimpleVersionSupplier(clock);
}
public static <E extends JobDescriptor.JobDescriptorExt> Job<E> nextVersion(Job<E> job, VersionSupplier supplier) {
return job.toBuilder()
.withVersion(supplier.nextVersion())
.build();
}
public static <T extends Task> T nextVersion(T task, VersionSupplier supplier) {
return (T) task.toBuilder().withVersion(supplier.nextVersion()).build();
}
private static class SimpleVersionSupplier implements VersionSupplier {
private final Clock clock;
private SimpleVersionSupplier(Clock clock) {
this.clock = clock;
}
@Override
public Version nextVersion() {
return Version.newBuilder().withTimestamp(clock.wallTime()).build();
}
}
}
| 54 |
0 | Create_ds/titus-control-plane/titus-server-master/src/main/java/com/netflix/titus/master/jobmanager | Create_ds/titus-control-plane/titus-server-master/src/main/java/com/netflix/titus/master/jobmanager/service/DefaultV3JobOperations.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.master.jobmanager.service;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.Set;
import java.util.UUID;
import java.util.concurrent.atomic.AtomicLong;
import java.util.function.Function;
import java.util.function.Predicate;
import java.util.stream.Collectors;
import java.util.stream.Stream;
import javax.annotation.PreDestroy;
import javax.inject.Inject;
import javax.inject.Named;
import javax.inject.Singleton;
import com.google.common.collect.ImmutableMap;
import com.google.common.collect.ImmutableSet;
import com.netflix.spectator.api.patterns.PolledMeter;
import com.netflix.titus.api.FeatureActivationConfiguration;
import com.netflix.titus.api.jobmanager.JobAttributes;
import com.netflix.titus.api.jobmanager.TaskAttributes;
import com.netflix.titus.api.jobmanager.model.job.CapacityAttributes;
import com.netflix.titus.api.jobmanager.model.job.Job;
import com.netflix.titus.api.jobmanager.model.job.JobCompatibility;
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.ServiceJobProcesses;
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.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.model.job.ext.ServiceJobExt;
import com.netflix.titus.api.jobmanager.service.JobManagerConstants;
import com.netflix.titus.api.jobmanager.service.JobManagerException;
import com.netflix.titus.api.jobmanager.service.V3JobOperations;
import com.netflix.titus.api.jobmanager.store.JobStore;
import com.netflix.titus.api.model.callmetadata.CallMetadata;
import com.netflix.titus.common.framework.reconciler.ChangeAction;
import com.netflix.titus.common.framework.reconciler.EntityHolder;
import com.netflix.titus.common.framework.reconciler.ModelActionHolder;
import com.netflix.titus.common.framework.reconciler.ModelActionHolder.Model;
import com.netflix.titus.common.framework.reconciler.ReconciliationEngine;
import com.netflix.titus.common.framework.reconciler.ReconciliationFramework;
import com.netflix.titus.common.model.sanitizer.EntitySanitizer;
import com.netflix.titus.common.runtime.TitusRuntime;
import com.netflix.titus.common.util.Evaluators;
import com.netflix.titus.common.util.ProtobufExt;
import com.netflix.titus.common.util.StringExt;
import com.netflix.titus.common.util.guice.ProxyType;
import com.netflix.titus.common.util.guice.annotation.Activator;
import com.netflix.titus.common.util.guice.annotation.ProxyConfiguration;
import com.netflix.titus.common.util.rx.ObservableExt;
import com.netflix.titus.common.util.rx.ReactorExt;
import com.netflix.titus.common.util.time.Clock;
import com.netflix.titus.common.util.tuple.Pair;
import com.netflix.titus.master.MetricConstants;
import com.netflix.titus.master.jobmanager.service.common.action.JobEntityHolders;
import com.netflix.titus.master.jobmanager.service.common.action.TitusChangeAction;
import com.netflix.titus.master.jobmanager.service.common.action.task.BasicJobActions;
import com.netflix.titus.master.jobmanager.service.common.action.task.BasicTaskActions;
import com.netflix.titus.master.jobmanager.service.common.action.task.KillInitiatedActions;
import com.netflix.titus.master.jobmanager.service.event.JobCheckpointReconcilerEvent;
import com.netflix.titus.master.jobmanager.service.event.JobManagerReconcilerEvent;
import com.netflix.titus.master.jobmanager.service.event.JobModelReconcilerEvent.JobModelUpdateReconcilerEvent;
import com.netflix.titus.master.jobmanager.service.event.JobModelReconcilerEvent.JobNewModelReconcilerEvent;
import com.netflix.titus.master.jobmanager.service.limiter.JobSubmitLimiter;
import com.netflix.titus.master.jobmanager.service.service.action.BasicServiceJobActions;
import com.netflix.titus.master.jobmanager.service.service.action.MoveTaskBetweenJobsAction;
import com.netflix.titus.runtime.endpoint.metadata.CallMetadataUtils;
import com.netflix.titus.runtime.endpoint.v3.grpc.GrpcJobManagementModelConverters;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import reactor.core.publisher.Mono;
import rx.BackpressureOverflow;
import rx.Completable;
import rx.Observable;
import rx.Subscription;
import static com.netflix.titus.api.jobmanager.model.job.sanitizer.JobSanitizerBuilder.JOB_STRICT_SANITIZER;
import static com.netflix.titus.common.util.FunctionExt.alwaysTrue;
@Singleton
@ProxyConfiguration(types = ProxyType.ActiveGuard)
public class DefaultV3JobOperations implements V3JobOperations {
private static final Logger logger = LoggerFactory.getLogger(DefaultV3JobOperations.class);
private static final int OBSERVE_JOBS_BACKPRESSURE_BUFFER_SIZE = 1024;
private static final String METRIC_EVENT_STREAM_LAST_ERROR = MetricConstants.METRIC_ROOT + "jobManager.eventStreamLastError";
enum IndexKind {StatusCreationTime}
private static final long RECONCILER_SHUTDOWN_TIMEOUT_MS = 30_000;
private final JobStore store;
private final JobManagerConfiguration jobManagerConfiguration;
private final JobServiceRuntime runtime;
private final FeatureActivationConfiguration featureActivationConfiguration;
private final JobReconciliationFrameworkFactory jobReconciliationFrameworkFactory;
private final JobSubmitLimiter jobSubmitLimiter;
private final TitusRuntime titusRuntime;
private final EntitySanitizer entitySanitizer;
private final VersionSupplier versionSupplier;
private ReconciliationFramework<JobManagerReconcilerEvent> reconciliationFramework;
private Subscription transactionLoggerSubscription;
private Subscription reconcilerEventSubscription;
@Inject
public DefaultV3JobOperations(JobManagerConfiguration jobManagerConfiguration,
FeatureActivationConfiguration featureActivationConfiguration,
JobStore store,
JobServiceRuntime runtime,
JobReconciliationFrameworkFactory jobReconciliationFrameworkFactory,
JobSubmitLimiter jobSubmitLimiter,
TitusRuntime titusRuntime,
@Named(JOB_STRICT_SANITIZER) EntitySanitizer entitySanitizer,
VersionSupplier versionSupplier) {
this.featureActivationConfiguration = featureActivationConfiguration;
this.store = store;
this.jobManagerConfiguration = jobManagerConfiguration;
this.runtime = runtime;
this.jobReconciliationFrameworkFactory = jobReconciliationFrameworkFactory;
this.jobSubmitLimiter = jobSubmitLimiter;
this.titusRuntime = titusRuntime;
this.entitySanitizer = entitySanitizer;
this.versionSupplier = versionSupplier;
}
@Activator
public void enterActiveMode() {
this.reconciliationFramework = jobReconciliationFrameworkFactory.newInstance();
// BUG: event stream breaks permanently, and cannot be retried.
// As we cannot fix the underlying issue yet, we have to be able to discover when it happens.
AtomicLong eventStreamLastError = new AtomicLong();
Clock clock = titusRuntime.getClock();
this.transactionLoggerSubscription = JobTransactionLogger.logEvents(reconciliationFramework, eventStreamLastError, clock);
PolledMeter.using(titusRuntime.getRegistry())
.withName(METRIC_EVENT_STREAM_LAST_ERROR)
.monitorValue(eventStreamLastError, value -> value.get() <= 0 ? 0 : clock.wallTime() - value.get());
// Remove finished jobs from the reconciliation framework.
Observable<JobManagerReconcilerEvent> reconciliationEventsObservable = reconciliationFramework.events()
.onBackpressureBuffer(
OBSERVE_JOBS_BACKPRESSURE_BUFFER_SIZE,
() -> logger.warn("Overflowed the buffer size: " + OBSERVE_JOBS_BACKPRESSURE_BUFFER_SIZE),
BackpressureOverflow.ON_OVERFLOW_ERROR
).doOnSubscribe(() -> {
List<EntityHolder> entityHolders = reconciliationFramework.orderedView(IndexKind.StatusCreationTime);
for (EntityHolder entityHolder : entityHolders) {
handleJobCompletedEvent(entityHolder);
}
});
this.reconcilerEventSubscription = titusRuntime.persistentStream(reconciliationEventsObservable)
.subscribe(
event -> {
if (event instanceof JobModelUpdateReconcilerEvent) {
JobModelUpdateReconcilerEvent jobUpdateEvent = (JobModelUpdateReconcilerEvent) event;
handleJobCompletedEvent(jobUpdateEvent.getChangedEntityHolder());
}
},
e -> logger.error("Event stream terminated with an error", e),
() -> logger.info("Event stream completed")
);
reconciliationFramework.start();
}
private void handleJobCompletedEvent(EntityHolder changedEntityHolder) {
if (changedEntityHolder.getEntity() instanceof Job) {
Job<?> job = changedEntityHolder.getEntity();
if (job.getStatus().getState() == JobState.Finished) {
boolean isClosed = BasicJobActions.isClosed(changedEntityHolder);
if (isClosed) {
String jobId = job.getId();
reconciliationFramework.findEngineByRootId(jobId).ifPresent(engine ->
reconciliationFramework.removeEngine(engine).subscribe(
() -> logger.info("Removed reconciliation engine of job {}", jobId),
e -> logger.warn("Could not remove reconciliation engine of job {}", jobId, e)
)
);
}
}
}
}
@PreDestroy
public void shutdown() {
PolledMeter.remove(titusRuntime.getRegistry(), titusRuntime.getRegistry().createId(METRIC_EVENT_STREAM_LAST_ERROR));
ObservableExt.safeUnsubscribe(transactionLoggerSubscription, reconcilerEventSubscription);
if (reconciliationFramework != null) {
reconciliationFramework.stop(RECONCILER_SHUTDOWN_TIMEOUT_MS);
}
}
@Override
public Observable<String> createJob(JobDescriptor<?> jobDescriptor, CallMetadata callMetadata) {
String callerId = callMetadata.getCallers().isEmpty()
? "unknown"
: callMetadata.getCallers().get(0).getId();
JobDescriptor<?> jobDescriptorWithCallerId = JobFunctions.appendJobDescriptorAttributes(jobDescriptor,
ImmutableMap.of(JobAttributes.JOB_ATTRIBUTES_CREATED_BY, callerId,
JobAttributes.JOB_ATTRIBUTES_CALL_REASON, callMetadata.getCallReason())
);
return Observable.fromCallable(() -> jobSubmitLimiter.reserveId(jobDescriptorWithCallerId))
.flatMap(reservationFailure -> {
if (reservationFailure.isPresent()) {
return Observable.error(JobManagerException.jobCreateLimited(reservationFailure.get()));
}
Optional<JobManagerException> jobLimitError = jobSubmitLimiter.checkIfAllowed(jobDescriptorWithCallerId);
if (jobLimitError.isPresent()) {
jobSubmitLimiter.releaseId(jobDescriptorWithCallerId);
return Observable.error(jobLimitError.get());
}
Job<?> job = newJob(jobDescriptorWithCallerId);
String jobId = job.getId();
return store.storeJob(job).toObservable()
.concatWith(reconciliationFramework.newEngine(EntityHolder.newRoot(jobId, job).addTag(JobManagerConstants.JOB_MANAGER_ATTRIBUTE_CALLMETADATA, callMetadata)))
.map(engine -> jobId)
.doOnTerminate(() -> jobSubmitLimiter.releaseId(jobDescriptorWithCallerId))
.doOnCompleted(() -> logger.info("Created job {} call metadata {}", jobId, callMetadata.getCallerId()))
.doOnError(e -> logger.info("Job {} creation failure", jobId, e));
});
}
@Override
public List<Job> getJobs() {
return reconciliationFramework.orderedView(IndexKind.StatusCreationTime).stream()
.map(entityHolder -> (Job) entityHolder.getEntity())
.collect(Collectors.toList());
}
@Override
public Optional<Job<?>> getJob(String jobId) {
return reconciliationFramework.findEngineByRootId(jobId).map(engine -> engine.getReferenceView().getEntity());
}
@Override
public List<Task> getTasks() {
return reconciliationFramework.orderedView(IndexKind.StatusCreationTime).stream()
.flatMap(entityHolder ->
reconciliationFramework.findEngineByRootId(entityHolder.getId())
.map(engine -> engine.orderedView(IndexKind.StatusCreationTime).stream().map(h -> (Task) h.getEntity()))
.orElse(Stream.empty())
).collect(Collectors.toList());
}
@Override
public List<Task> getTasks(String jobId) {
ReconciliationEngine<JobManagerReconcilerEvent> engine = reconciliationFramework.findEngineByRootId(jobId).orElseThrow(() -> JobManagerException.jobNotFound(jobId));
return engine.orderedView(IndexKind.StatusCreationTime).stream().map(h -> (Task) h.getEntity()).collect(Collectors.toList());
}
@Override
public List<Pair<Job, List<Task>>> getJobsAndTasks() {
return reconciliationFramework.orderedView(IndexKind.StatusCreationTime).stream()
.map(entityHolder -> {
Job job = entityHolder.getEntity();
List<Task> tasks = entityHolder.getChildren().stream().map(h -> (Task) h.getEntity()).collect(Collectors.toList());
return Pair.of(job, tasks);
})
.collect(Collectors.toList());
}
@Override
public List<Job<?>> findJobs(Predicate<Pair<Job<?>, List<Task>>> queryPredicate, int offset, int limit) {
if (limit <= 0) {
return Collections.emptyList();
}
List<EntityHolder> jobHolders = reconciliationFramework.orderedView(IndexKind.StatusCreationTime);
List<Job<?>> result = new ArrayList<>();
int toDrop = offset;
int toTake = limit;
for (EntityHolder holder : jobHolders) {
Pair<Job<?>, List<Task>> jobTasksPair = toJobTasksPair(holder);
if (queryPredicate.test(jobTasksPair)) {
if (toDrop > 0) {
toDrop--;
} else {
result.add(jobTasksPair.getLeft());
toTake--;
if (toTake <= 0) {
break;
}
}
}
}
return result;
}
@Override
public List<Pair<Job<?>, Task>> findTasks(Predicate<Pair<Job<?>, Task>> queryPredicate, int offset, int limit) {
if (limit <= 0) {
return Collections.emptyList();
}
List<EntityHolder> jobHolders = reconciliationFramework.orderedView(IndexKind.StatusCreationTime);
List<Pair<Job<?>, Task>> result = new ArrayList<>();
long toDrop = offset;
long toTake = limit;
OUTER:
for (EntityHolder jobHolder : jobHolders) {
if (!jobHolder.getChildren().isEmpty()) {
for (EntityHolder taskHolder : jobHolder.getChildren()) {
Pair<Job<?>, Task> jobTaskPair = Pair.of(jobHolder.getEntity(), taskHolder.getEntity());
if (queryPredicate.test(jobTaskPair)) {
if (toDrop > 0) {
toDrop--;
} else {
result.add(jobTaskPair);
toTake--;
if (toTake <= 0) {
break OUTER;
}
}
}
}
}
}
return result;
}
@Override
public Optional<Pair<Job<?>, Task>> findTaskById(String taskId) {
return reconciliationFramework.findEngineByChildId(taskId)
.map(pair -> {
Job<?> job = pair.getLeft().getReferenceView().getEntity();
Task task = pair.getRight().getEntity();
return Pair.of(job, task);
});
}
@Override
public Completable updateTask(String taskId, Function<Task, Optional<Task>> changeFunction, Trigger trigger, String reason, CallMetadata callMetadata) {
Optional<ReconciliationEngine<JobManagerReconcilerEvent>> engineOpt = reconciliationFramework.findEngineByChildId(taskId).map(Pair::getLeft);
if (!engineOpt.isPresent()) {
return Completable.error(JobManagerException.taskNotFound(taskId));
}
ReconciliationEngine<JobManagerReconcilerEvent> engine = engineOpt.get();
TitusChangeAction changeAction = BasicTaskActions.updateTaskInRunningModel(taskId, trigger, jobManagerConfiguration, engine, changeFunction, reason, versionSupplier, titusRuntime, callMetadata);
return engine.changeReferenceModel(changeAction, taskId).toCompletable();
}
@Override
public Observable<Void> updateJobCapacityAttributes(String jobId, CapacityAttributes capacityAttributes, CallMetadata callMetadata) {
logger.info("UpdateJobCapacityAttributes for job {} - {}", jobId, capacityAttributes);
return inServiceJob(jobId).flatMap(engine -> engine.changeReferenceModel(
BasicServiceJobActions.updateJobCapacityAction(engine, capacityAttributes, store, versionSupplier, callMetadata, entitySanitizer)
));
}
@Override
public Observable<Void> updateServiceJobProcesses(String jobId, ServiceJobProcesses serviceJobProcesses, CallMetadata callMetadata) {
return inServiceJob(jobId).flatMap(engine -> {
Job<?> job = engine.getReferenceView().getEntity();
if (!(job.getJobDescriptor().getExtensions() instanceof ServiceJobExt)) {
return Observable.error(JobManagerException.notServiceJob(jobId));
}
return engine.changeReferenceModel(BasicServiceJobActions.updateServiceJobProcesses(engine, serviceJobProcesses, store, versionSupplier, callMetadata));
}
);
}
@Override
public Observable<Void> updateJobStatus(String jobId, boolean enabled, CallMetadata callMetadata) {
return inServiceJob(jobId).flatMap(engine -> {
Job<ServiceJobExt> serviceJob = engine.getReferenceView().getEntity();
if (serviceJob.getJobDescriptor().getExtensions().isEnabled() == enabled) {
return Observable.empty();
}
return engine.changeReferenceModel(BasicServiceJobActions.updateJobEnableStatus(engine, enabled, store, versionSupplier, callMetadata));
});
}
@Override
public Mono<Void> updateJobDisruptionBudget(String jobId, DisruptionBudget disruptionBudget, CallMetadata callMetadata) {
return Mono.fromCallable(() ->
reconciliationFramework.findEngineByRootId(jobId).orElseThrow(() -> JobManagerException.jobNotFound(jobId))
).flatMap(engine -> {
Observable<Void> observableAction = engine.changeReferenceModel(
BasicJobActions.updateJobDisruptionBudget(engine, disruptionBudget, store, versionSupplier, callMetadata)
);
return ReactorExt.toMono(observableAction);
});
}
@Override
public Mono<Void> updateJobAttributes(String jobId, Map<String, String> attributes, CallMetadata callMetadata) {
return Mono.fromCallable(() ->
reconciliationFramework.findEngineByRootId(jobId).orElseThrow(() -> JobManagerException.jobNotFound(jobId))
).flatMap(engine -> {
Observable<Void> observableAction = engine.changeReferenceModel(
BasicJobActions.updateJobAttributes(engine, attributes, store, versionSupplier, callMetadata)
);
return ReactorExt.toMono(observableAction);
});
}
@Override
public Mono<Void> deleteJobAttributes(String jobId, Set<String> keys, CallMetadata callMetadata) {
return Mono.fromCallable(() ->
reconciliationFramework.findEngineByRootId(jobId).orElseThrow(() -> JobManagerException.jobNotFound(jobId))
).flatMap(engine -> {
Observable<Void> observableAction = engine.changeReferenceModel(
BasicJobActions.deleteJobAttributes(engine, keys, store, versionSupplier, callMetadata)
);
return ReactorExt.toMono(observableAction);
});
}
@Override
public Observable<Void> killJob(String jobId, String reason, CallMetadata callMetadata) {
return reconciliationFramework.findEngineByRootId(jobId)
.map(engine -> {
Job<?> job = engine.getReferenceView().getEntity();
JobState jobState = job.getStatus().getState();
if (jobState == JobState.KillInitiated || jobState == JobState.Finished) {
return Observable.<Void>error(JobManagerException.jobTerminating(job));
}
return engine.changeReferenceModel(KillInitiatedActions.initiateJobKillAction(engine, store, versionSupplier, reason, callMetadata));
})
.orElse(Observable.error(JobManagerException.jobNotFound(jobId)));
}
@Override
public Mono<Void> killTask(String taskId, boolean shrink, boolean preventMinSizeUpdate, Trigger trigger, CallMetadata callMetadata) {
Observable<Void> action = reconciliationFramework.findEngineByChildId(taskId)
.map(engineChildPair -> {
Task task = engineChildPair.getRight().getEntity();
TaskState taskState = task.getStatus().getState();
if (taskState == TaskState.KillInitiated || taskState == TaskState.Finished) {
return Observable.<Void>error(JobManagerException.taskTerminating(task));
}
String reasonCode;
if (trigger == Trigger.Eviction) {
reasonCode = TaskStatus.REASON_TASK_EVICTED;
} else if (trigger == Trigger.Scheduler) {
reasonCode = TaskStatus.REASON_TRANSIENT_SYSTEM_ERROR;
} else {
reasonCode = TaskStatus.REASON_TASK_KILLED;
}
if (shrink) {
Job<?> job = engineChildPair.getLeft().getReferenceView().getEntity();
if (!(job.getJobDescriptor().getExtensions() instanceof ServiceJobExt)) {
return Observable.<Void>error(JobManagerException.notServiceJob(job.getId()));
}
reasonCode = TaskStatus.REASON_SCALED_DOWN;
}
String reason = String.format("%s %s(shrink=%s)", Evaluators.getOrDefault(CallMetadataUtils.getFirstCallerId(callMetadata), "<no_caller>"),
Evaluators.getOrDefault(callMetadata.getCallReason(), "<no_reason>"), shrink);
ChangeAction killAction = KillInitiatedActions.userInitiateTaskKillAction(
engineChildPair.getLeft(), runtime, store, versionSupplier, task.getId(), shrink, preventMinSizeUpdate, reasonCode, reason, titusRuntime, callMetadata
);
return engineChildPair.getLeft().changeReferenceModel(killAction);
})
.orElse(Observable.error(JobManagerException.taskNotFound(taskId)));
return ReactorExt.toMono(action);
}
@Override
public Observable<Void> moveServiceTask(String sourceJobId, String targetJobId, String taskId, CallMetadata callMetadata) {
return Observable.defer(() -> {
Pair<ReconciliationEngine<JobManagerReconcilerEvent>, EntityHolder> fromEngineTaskPair =
reconciliationFramework.findEngineByChildId(taskId).orElseThrow(() -> JobManagerException.taskNotFound(taskId));
ReconciliationEngine<JobManagerReconcilerEvent> engineFrom = fromEngineTaskPair.getLeft();
Job<ServiceJobExt> jobFrom = engineFrom.getReferenceView().getEntity();
if (!JobFunctions.isServiceJob(jobFrom)) {
throw JobManagerException.notServiceJob(jobFrom.getId());
}
if (!jobFrom.getId().equals(sourceJobId)) {
throw JobManagerException.taskJobMismatch(taskId, sourceJobId);
}
if (jobFrom.getId().equals(targetJobId)) {
throw JobManagerException.sameJobs(jobFrom.getId());
}
ReconciliationEngine<JobManagerReconcilerEvent> engineTo =
reconciliationFramework.findEngineByRootId(targetJobId).orElseThrow(() -> JobManagerException.jobNotFound(targetJobId));
Job<ServiceJobExt> jobTo = engineTo.getReferenceView().getEntity();
if (!JobFunctions.isServiceJob(jobTo)) {
throw JobManagerException.notServiceJob(jobTo.getId());
}
JobCompatibility compatibility = JobCompatibility.of(jobFrom, jobTo);
if (featureActivationConfiguration.isMoveTaskValidationEnabled() && !compatibility.isCompatible()) {
Optional<String> diffReport = ProtobufExt.diffReport(
GrpcJobManagementModelConverters.toGrpcJobDescriptor(compatibility.getNormalizedDescriptorFrom()),
GrpcJobManagementModelConverters.toGrpcJobDescriptor(compatibility.getNormalizedDescriptorTo())
);
throw JobManagerException.notCompatible(jobFrom, jobTo, diffReport.orElse(""));
}
return reconciliationFramework.changeReferenceModel(
new MoveTaskBetweenJobsAction(engineFrom, engineTo, taskId, store, callMetadata, versionSupplier),
(rootId, modelUpdatesObservable) -> {
String name;
String summary;
if (targetJobId.equals(rootId)) {
name = "moveTask(to)";
summary = "Moving a task to this job from job " + jobFrom.getId();
} else {
name = "moveTask(from)";
summary = "Moving a task out of this job to job " + jobTo.getId();
}
return new TitusChangeAction(Trigger.API, rootId, null, name, summary, callMetadata) {
@Override
public Observable<List<ModelActionHolder>> apply() {
return modelUpdatesObservable;
}
};
},
jobFrom.getId(),
jobTo.getId()
);
});
}
@Override
public Observable<JobManagerEvent<?>> observeJobs(Predicate<Pair<Job<?>, List<Task>>> jobsPredicate,
Predicate<Pair<Job<?>, Task>> tasksPredicate,
boolean withCheckpoints) {
Observable<JobManagerReconcilerEvent> events = reconciliationFramework.events().onBackpressureBuffer(
OBSERVE_JOBS_BACKPRESSURE_BUFFER_SIZE,
() -> logger.warn("Overflowed the buffer size: " + OBSERVE_JOBS_BACKPRESSURE_BUFFER_SIZE),
BackpressureOverflow.ON_OVERFLOW_ERROR
);
return toJobManagerEvents(events, jobsPredicate, tasksPredicate, withCheckpoints);
}
@Override
public Observable<JobManagerEvent<?>> observeJob(String jobId) {
return Observable.fromCallable(() -> reconciliationFramework.findEngineByRootId(jobId))
.flatMap(engineOpt ->
engineOpt.map(engine ->
toJobManagerEvents(engine.events(), alwaysTrue(), alwaysTrue(), false)
).orElseGet(() ->
Observable.error(JobManagerException.jobNotFound(jobId))
));
}
private <E extends JobDescriptor.JobDescriptorExt> Job<E> newJob(JobDescriptor<E> jobDescriptor) {
String federatedJobId = jobDescriptor.getAttributes().get(JobAttributes.JOB_ATTRIBUTES_FEDERATED_JOB_ID);
String jobId;
if (StringExt.isNotEmpty(federatedJobId)) {
jobId = federatedJobId;
jobDescriptor = JobFunctions.deleteJobAttributes(jobDescriptor, ImmutableSet.of(JobAttributes.JOB_ATTRIBUTES_FEDERATED_JOB_ID));
jobDescriptor = JobFunctions.appendJobDescriptorAttribute(jobDescriptor, JobAttributes.JOB_ATTRIBUTES_ORIGINAL_FEDERATED_JOB_ID, federatedJobId);
} else {
jobId = UUID.randomUUID().toString();
}
return Job.<E>newBuilder()
.withId(jobId)
.withJobDescriptor(jobDescriptor)
.withStatus(JobStatus.newBuilder()
.withState(JobState.Accepted)
.withReasonMessage("New Job created. Next tasks will be launched.")
.build())
.withVersion(versionSupplier.nextVersion())
.build();
}
private Observable<ReconciliationEngine<JobManagerReconcilerEvent>> inServiceJob(String jobId) {
return Observable.fromCallable(() ->
reconciliationFramework.findEngineByRootId(jobId).orElseThrow(() -> JobManagerException.jobNotFound(jobId))
).flatMap(engine -> {
Job<?> job = engine.getReferenceView().getEntity();
if (!(job.getJobDescriptor().getExtensions() instanceof ServiceJobExt)) {
return Observable.error(JobManagerException.notServiceJob(jobId));
}
return Observable.just(engine);
});
}
private Pair<Job<?>, List<Task>> toJobTasksPair(EntityHolder jobHolder) {
List<Task> tasks = new ArrayList<>();
for (EntityHolder childHolder : jobHolder.getChildren()) {
tasks.add(childHolder.getEntity());
}
return Pair.of(jobHolder.getEntity(), tasks);
}
private Observable<JobManagerEvent<?>> toJobManagerEvents(Observable<JobManagerReconcilerEvent> events,
Predicate<Pair<Job<?>, List<Task>>> jobsPredicate,
Predicate<Pair<Job<?>, Task>> tasksPredicate,
boolean withCheckpoints) {
return events.flatMap(event -> Observable.from(toJobManagerEvent(jobsPredicate, tasksPredicate, withCheckpoints, event)));
}
private List<JobManagerEvent<?>> toJobManagerEvent(
Predicate<Pair<Job<?>, List<Task>>> jobsPredicate,
Predicate<Pair<Job<?>, Task>> tasksPredicate,
boolean withCheckpoints,
JobManagerReconcilerEvent event) {
if (event instanceof JobCheckpointReconcilerEvent) {
if (withCheckpoints) {
JobCheckpointReconcilerEvent checkpoint = (JobCheckpointReconcilerEvent) event;
return Collections.singletonList(JobManagerEvent.keepAliveEvent(checkpoint.getTimestampNano()));
}
return Collections.emptyList();
}
if (event instanceof JobNewModelReconcilerEvent) {
JobNewModelReconcilerEvent newModelEvent = (JobNewModelReconcilerEvent) event;
return toNewJobUpdateEvent(newModelEvent, jobsPredicate);
}
if (!(event instanceof JobModelUpdateReconcilerEvent)) {
return Collections.emptyList();
}
JobModelUpdateReconcilerEvent modelUpdateEvent = (JobModelUpdateReconcilerEvent) event;
if (modelUpdateEvent.getModelActionHolder().getModel() != Model.Reference) {
return Collections.emptyList();
}
if (modelUpdateEvent.getChangedEntityHolder().getEntity() instanceof Job) {
// A special job event emitted when a task was removed from a job, and a replacement was not created.
// We have to emit for this case both task archived event followed by job update event.
if (modelUpdateEvent.getChangeAction().getTrigger() == Trigger.ReconcilerServiceTaskRemoved) {
Task archivedTask = modelUpdateEvent.getChangeAction().getTask().orElse(null);
if (archivedTask != null) {
Job<?> job = modelUpdateEvent.getJob();
TaskUpdateEvent archiveEvent = TaskUpdateEvent.taskArchived(job, archivedTask, modelUpdateEvent.getCallMetadata());
List<JobManagerEvent<?>> events = new ArrayList<>();
events.add(archiveEvent);
events.addAll(toJobUpdateEvent(modelUpdateEvent, jobsPredicate));
return events;
}
}
return toJobUpdateEvent(modelUpdateEvent, jobsPredicate);
}
return toTaskUpdateEvent(modelUpdateEvent, tasksPredicate);
}
private List<JobManagerEvent<?>> toNewJobUpdateEvent(JobNewModelReconcilerEvent newModelEvent,
Predicate<Pair<Job<?>, List<Task>>> jobsPredicate) {
Job<?> job = newModelEvent.getNewRoot().getEntity();
List<Task> tasks = newModelEvent.getNewRoot().getChildren()
.stream()
.map(EntityHolder::<Task>getEntity)
.collect(Collectors.toList());
return jobsPredicate.test(Pair.of(job, tasks))
? Collections.singletonList(JobUpdateEvent.newJob(job, newModelEvent.getCallMetadata()))
: Collections.emptyList();
}
private List<JobManagerEvent<?>> toJobUpdateEvent(JobModelUpdateReconcilerEvent modelUpdateEvent,
Predicate<Pair<Job<?>, List<Task>>> jobsPredicate) {
Job<?> changed = modelUpdateEvent.getChangedEntityHolder().getEntity();
List<Task> tasks = modelUpdateEvent.getChangedEntityHolder().getChildren()
.stream()
.map(EntityHolder::<Task>getEntity)
.collect(Collectors.toList());
// Archived event is emitted as a very last one, so no need to check for anything extra.
if (modelUpdateEvent.isArchived()) {
return jobsPredicate.test(Pair.of(changed, tasks))
? Collections.singletonList(JobUpdateEvent.jobArchived(changed, modelUpdateEvent.getCallMetadata()))
: Collections.emptyList();
}
if (!modelUpdateEvent.getPreviousEntityHolder().isPresent()) {
return jobsPredicate.test(Pair.of(changed, tasks))
? Collections.singletonList(JobUpdateEvent.jobChange(changed, changed, modelUpdateEvent.getCallMetadata()))
: Collections.emptyList();
}
Job<?> previous = modelUpdateEvent.getPreviousEntityHolder().get().getEntity();
if (changed.equals(previous)) {
return Collections.emptyList();
}
return jobsPredicate.test(Pair.of(changed, tasks))
? Collections.singletonList(JobUpdateEvent.jobChange(changed, previous, modelUpdateEvent.getCallMetadata()))
: Collections.emptyList();
}
private List<JobManagerEvent<?>> toTaskUpdateEvent(JobModelUpdateReconcilerEvent modelUpdateEvent,
Predicate<Pair<Job<?>, Task>> tasksPredicate) {
Job<?> job = modelUpdateEvent.getJob();
Task changed = modelUpdateEvent.getChangedEntityHolder().getEntity();
if (!modelUpdateEvent.getPreviousEntityHolder().isPresent()) {
if (!tasksPredicate.test(Pair.of(job, changed))) {
return Collections.emptyList();
}
// A task is archived at the same time as its replacement is created. We store the finished task which the
// new one replaces in the EntityHolder attribute `JobEntityHolders.ATTR_REPLACEMENT_OF`.
Task archivedTask = (Task) modelUpdateEvent.getChangedEntityHolder().getAttributes().get(JobEntityHolders.ATTR_REPLACEMENT_OF);
if (archivedTask == null) {
return Collections.singletonList(toNewTaskUpdateEvent(job, changed, modelUpdateEvent.getCallMetadata()));
}
return Arrays.asList(
TaskUpdateEvent.taskArchived(job, archivedTask, modelUpdateEvent.getCallMetadata()),
toNewTaskUpdateEvent(job, changed, modelUpdateEvent.getCallMetadata())
);
}
Task previous = modelUpdateEvent.getPreviousEntityHolder().get().getEntity();
if (changed.equals(previous)) {
return Collections.emptyList();
}
return tasksPredicate.test(Pair.of(job, changed))
? Collections.singletonList(TaskUpdateEvent.taskChange(job, changed, previous, modelUpdateEvent.getCallMetadata()))
: Collections.emptyList();
}
/**
* Check if it really is a new task, or if it existed before and was moved from another Job.
*
* @return an event indicating if the task was moved from another job
*/
private TaskUpdateEvent toNewTaskUpdateEvent(Job<?> job, Task newTask, CallMetadata callMetadata) {
if (newTask.getTaskContext().containsKey(TaskAttributes.TASK_ATTRIBUTES_MOVED_FROM_JOB)) {
return TaskUpdateEvent.newTaskFromAnotherJob(job, newTask, callMetadata);
}
return TaskUpdateEvent.newTask(job, newTask, callMetadata);
}
}
| 55 |
0 | Create_ds/titus-control-plane/titus-server-master/src/main/java/com/netflix/titus/master/jobmanager | Create_ds/titus-control-plane/titus-server-master/src/main/java/com/netflix/titus/master/jobmanager/service/JobAndTaskMetrics.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.master.jobmanager.service;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.Set;
import java.util.concurrent.TimeUnit;
import java.util.stream.Collectors;
import javax.annotation.PreDestroy;
import javax.inject.Inject;
import javax.inject.Singleton;
import com.netflix.spectator.api.Gauge;
import com.netflix.spectator.api.Id;
import com.netflix.spectator.api.Registry;
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.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.TaskUpdateEvent;
import com.netflix.titus.api.jobmanager.service.V3JobOperations;
import com.netflix.titus.api.model.ApplicationSLA;
import com.netflix.titus.api.model.Tier;
import com.netflix.titus.common.util.CollectionsExt;
import com.netflix.titus.common.util.DateTimeExt;
import com.netflix.titus.common.util.StringExt;
import com.netflix.titus.common.util.guice.annotation.Activator;
import com.netflix.titus.common.util.histogram.Histogram;
import com.netflix.titus.common.util.histogram.HistogramDescriptor;
import com.netflix.titus.common.util.rx.ObservableExt;
import com.netflix.titus.common.util.tuple.Pair;
import com.netflix.titus.master.MetricConstants;
import com.netflix.titus.master.service.management.ApplicationSlaManagementService;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import rx.Completable;
import rx.Subscription;
import rx.schedulers.Schedulers;
/**
* Supplementary metrics based on both job/task state, and elapsed time. These metrics cannot be computed only
* in response to system state change events. Instead, they are recomputed at regular interval.
* <p>
*/
@Singleton
public class JobAndTaskMetrics {
private static final Logger logger = LoggerFactory.getLogger(JobAndTaskMetrics.class);
private static final String JOBS_LIMIT_METRIC_NAME = MetricConstants.METRIC_ROOT + "jobManager.jobs.limit";
private static final String JOBS_METRIC_NAME = MetricConstants.METRIC_ROOT + "jobManager.jobs";
private static final String TASKS_METRIC_NAME = MetricConstants.METRIC_ROOT + "jobManager.tasks";
private static final String TASK_IN_STATE_ROOT_METRIC_NAME = MetricConstants.METRIC_ROOT + "jobManager.taskLiveness.";
private static final String TASK_IN_STATE_METRIC_NAME = TASK_IN_STATE_ROOT_METRIC_NAME + "duration";
private static final String TASK_STATE_CHANGE_METRIC_NAME = MetricConstants.METRIC_ROOT + "jobManager.taskStateUpdates";
private static final List<String> TRACKED_STATES = Arrays.asList(
TaskState.Accepted.name(),
TaskState.Launched.name(),
TaskState.StartInitiated.name(),
TaskState.Started.name(),
TaskState.KillInitiated.name()
);
private static final HistogramDescriptor HISTOGRAM_DESCRIPTOR = HistogramDescriptor.histogramOf(
TimeUnit.MINUTES.toMillis(1),
TimeUnit.MINUTES.toMillis(15),
TimeUnit.MINUTES.toMillis(30),
TimeUnit.HOURS.toMillis(1),
TimeUnit.HOURS.toMillis(6),
TimeUnit.HOURS.toMillis(12),
TimeUnit.HOURS.toMillis(24),
TimeUnit.DAYS.toMillis(2),
TimeUnit.DAYS.toMillis(3),
TimeUnit.DAYS.toMillis(4),
TimeUnit.DAYS.toMillis(5)
);
private final ApplicationSlaManagementService applicationSlaManagementService;
private final V3JobOperations v3JobOperations;
private final JobManagerConfiguration configuration;
private final Registry registry;
private final Map<String, Map<String, List<Gauge>>> capacityGroupsMetrics = new HashMap<>();
private final Id jobCountLimitId;
private final Id jobCountId;
private final Id taskCountId;
private Subscription taskLivenessRefreshSubscription;
private Subscription taskStateUpdateSubscription;
@Inject
public JobAndTaskMetrics(ApplicationSlaManagementService applicationSlaManagementService,
V3JobOperations v3JobOperations,
JobManagerConfiguration configuration,
Registry registry) {
this.applicationSlaManagementService = applicationSlaManagementService;
this.v3JobOperations = v3JobOperations;
this.configuration = configuration;
this.registry = registry;
this.jobCountLimitId = registry.createId(JOBS_LIMIT_METRIC_NAME);
this.jobCountId = registry.createId(JOBS_METRIC_NAME);
this.taskCountId = registry.createId(TASKS_METRIC_NAME);
}
@Activator
public void enterActiveMode() {
long intervalMs = Math.max(1_000, configuration.getTaskLivenessPollerIntervalMs());
this.taskStateUpdateSubscription = v3JobOperations.observeJobs().subscribe(
event -> {
if (event instanceof TaskUpdateEvent) {
updateTaskMetrics((TaskUpdateEvent) event);
}
},
e -> logger.error("Event stream terminated with an error", e),
() -> logger.info("Event stream completed")
);
this.taskLivenessRefreshSubscription = ObservableExt.schedule(
TASK_IN_STATE_ROOT_METRIC_NAME + "scheduler", registry, "TaskLivenessRefreshAction",
Completable.fromAction(this::refresh), intervalMs, intervalMs, TimeUnit.MILLISECONDS, Schedulers.computation()
).subscribe(result ->
result.ifPresent(error -> logger.warn("Task liveness metrics refresh error", error))
);
}
@PreDestroy
public void shutdown() {
ObservableExt.safeUnsubscribe(taskStateUpdateSubscription, taskLivenessRefreshSubscription);
registry.gauge(jobCountLimitId).set(0);
}
private void updateTaskMetrics(TaskUpdateEvent event) {
Job<?> job = event.getCurrentJob();
Task task = event.getCurrentTask();
Pair<Tier, String> assignment = JobManagerUtil.getTierAssignment(job, applicationSlaManagementService);
registry.counter(
TASK_STATE_CHANGE_METRIC_NAME,
"tier", assignment.getLeft().name(),
"capacityGroup", assignment.getRight(),
"applicationName", job.getJobDescriptor().getApplicationName(),
"state", task.getStatus().getState().name(),
"kubeScheduler", "true"
).increment();
}
private void refresh() {
Map<String, Tier> tierMap = buildTierMap();
List<Pair<Job, List<Task>>> jobsAndTasks = v3JobOperations.getJobsAndTasks();
List<Job> jobs = v3JobOperations.getJobs();
List<Task> tasks = v3JobOperations.getTasks();
registry.gauge(jobCountLimitId).set(configuration.getMaxActiveJobs());
updateJobCounts(jobsAndTasks);
updateTaskCounts(tasks);
Map<String, Map<String, Histogram.Builder>> capacityGroupsHistograms = buildCapacityGroupsHistograms(tierMap.keySet(), jobs);
resetDroppedCapacityGroups(capacityGroupsHistograms.keySet());
updateCapacityGroupCounters(capacityGroupsHistograms, tierMap);
}
private void resetDroppedCapacityGroups(Set<String> knownCapacityGroups) {
CollectionsExt.copyAndRemove(capacityGroupsMetrics.keySet(), knownCapacityGroups).forEach(absent -> {
Map<String, List<Gauge>> removed = capacityGroupsMetrics.remove(absent);
removed.values().forEach(gauges -> gauges.forEach(gauge -> gauge.set(0)));
});
}
private void updateCapacityGroupCounters(Map<String, Map<String, Histogram.Builder>> capacityGroupsHistograms, Map<String, Tier> tierMap) {
capacityGroupsHistograms.forEach((capacityGroup, histograms) -> {
Id baseId = registry.createId(
TASK_IN_STATE_METRIC_NAME,
"tier", tierMap.get(capacityGroup).name(),
"capacityGroup", capacityGroup
);
Map<String, List<Gauge>> capacityMetricsByState = capacityGroupsMetrics.computeIfAbsent(capacityGroup, k -> new HashMap<>());
for (String state : TRACKED_STATES) {
List<Gauge> updatedGauges = updateStateCounters(baseId, state, histograms.get(state), capacityMetricsByState.get(state));
if (updatedGauges.isEmpty()) {
capacityMetricsByState.remove(capacityGroup);
} else {
capacityMetricsByState.put(state, updatedGauges);
}
}
});
}
private List<Gauge> updateStateCounters(Id baseId, String state, Histogram.Builder histogramBuilder, List<Gauge> gauges) {
if (histogramBuilder == null) {
// Nothing running for this state, reset gauges
if (gauges != null) {
gauges.forEach(g -> g.set(0));
}
return Collections.emptyList();
}
List<Long> counters = histogramBuilder.build().getCounters();
// First time we have data for this capacity group.
if (gauges == null) {
Id id = baseId.withTag("state", state);
List<Long> valueBounds = HISTOGRAM_DESCRIPTOR.getValueBounds();
List<Gauge> newGauges = new ArrayList<>();
for (int i = 0; i <= valueBounds.size(); i++) {
Gauge newGauge;
if (i < valueBounds.size()) {
long delayMs = valueBounds.get(i);
newGauge = registry.gauge(id.withTag("delay", DateTimeExt.toTimeUnitString(delayMs)));
} else {
newGauge = registry.gauge(id.withTag("delay", "Unlimited"));
}
newGauge.set(counters.get(i));
newGauges.add(newGauge);
}
return newGauges;
}
// Update gauges
for (int i = 0; i < counters.size(); i++) {
gauges.get(i).set(counters.get(i));
}
return gauges;
}
/**
* Traverse all active jobs and update the count metrics
*/
private void updateJobCounts(List<Pair<Job, List<Task>>> jobsAndTasks) {
int emptyJobs = 0;
int serviceJobsOwnedByKubeScheduler = 0;
int batchJobsOwnedByKubeScheduler = 0;
for (Pair<Job, List<Task>> jobAndTasks : jobsAndTasks) {
Job job = jobAndTasks.getLeft();
List<Task> tasks = jobAndTasks.getRight();
if (JobFunctions.getJobDesiredSize(job) == 0) {
emptyJobs++;
} else {
boolean serviceJob = JobFunctions.isServiceJob(job);
if (serviceJob) {
serviceJobsOwnedByKubeScheduler++;
} else {
batchJobsOwnedByKubeScheduler++;
}
}
}
registry.gauge(jobCountId.withTag("emptyJobs", "true")).set(emptyJobs);
registry.gauge(jobCountId.withTags(
"jobType", "service",
"kubeScheduler", "true"
)).set(serviceJobsOwnedByKubeScheduler);
registry.gauge(jobCountId.withTags(
"jobType", "batch",
"kubeScheduler", "true"
)).set(batchJobsOwnedByKubeScheduler);
}
/**
* Traverse all tasks and update the count metrics
*/
private void updateTaskCounts(List<Task> tasks) {
int tasksOwnedByKubeScheduler = 0;
int tasksWithPodCreated = 0;
for (Task task : tasks) {
tasksOwnedByKubeScheduler++;
if (TaskStatus.hasPod(task)) {
tasksWithPodCreated++;
}
}
registry.gauge(taskCountId.withTags(
"kubeScheduler", "true",
"podCreated", "true"
)).set(tasksWithPodCreated);
registry.gauge(taskCountId.withTags(
"kubeScheduler", "true",
"podCreated", "false"
)).set(tasksOwnedByKubeScheduler - tasksWithPodCreated);
registry.gauge(taskCountId.withTag("kubeScheduler", "false")).set(tasks.size() - tasksOwnedByKubeScheduler);
}
/**
* Traverse all active tasks and collect their state and the time they stayed in this state (the latter in form of histogram).
*
* @return mapOf(capacityGroupName - > mapOf ( taskState, histogram))
*/
private Map<String, Map<String, Histogram.Builder>> buildCapacityGroupsHistograms(Set<String> capacityGroups, List<Job> jobs) {
Map<String, Map<String, Histogram.Builder>> capacityGroupsHistograms = newCapacityHistograms(capacityGroups);
jobs.forEach(job -> resolveCapacityGroup(job, capacityGroupsHistograms).ifPresent(capacityGroup ->
buildCapacityGroupHistogram(job, capacityGroup, capacityGroupsHistograms)
));
return capacityGroupsHistograms;
}
private void buildCapacityGroupHistogram(Job<?> job, String capacityGroup, Map<String, Map<String, Histogram.Builder>> capacityGroupsHistograms) {
// 'capacityGroupsHistograms' is pre-initialized, but to avoid race condition we make extra check here.
Map<String, Histogram.Builder> capacityGroupHistograms = capacityGroupsHistograms.computeIfAbsent(capacityGroup, k -> new HashMap<>());
List<Task> tasks;
try {
tasks = v3JobOperations.getTasks(job.getId());
} catch (Exception e) {
// We work on live data, which may be removed at any point in time.
return;
}
tasks.forEach(task -> {
long timestamp = task.getStatus().getTimestamp();
if (timestamp > 0) {
long durationMs = System.currentTimeMillis() - timestamp;
capacityGroupHistograms.computeIfAbsent(
task.getStatus().getState().name(),
name -> Histogram.newBuilder(HISTOGRAM_DESCRIPTOR)
).increment(durationMs);
}
});
}
private Optional<String> resolveCapacityGroup(Job<?> job, Map<String, Map<String, Histogram.Builder>> capacityHistograms) {
String capacityGroup = job.getJobDescriptor().getCapacityGroup();
if (StringExt.isEmpty(capacityGroup)) {
capacityGroup = job.getJobDescriptor().getApplicationName();
}
if (StringExt.isEmpty(capacityGroup)) {
return Optional.of(ApplicationSlaManagementService.DEFAULT_APPLICATION);
}
return Optional.of(capacityHistograms.containsKey(capacityGroup) ? capacityGroup : ApplicationSlaManagementService.DEFAULT_APPLICATION);
}
private Map<String, Tier> buildTierMap() {
return applicationSlaManagementService.getApplicationSLAs().stream()
.collect(Collectors.toMap(ApplicationSLA::getAppName, ApplicationSLA::getTier));
}
private Map<String, Map<String, Histogram.Builder>> newCapacityHistograms(Set<String> capacityGroups) {
return capacityGroups.stream().collect(Collectors.toMap(name -> name, name -> new HashMap<>()));
}
}
| 56 |
0 | Create_ds/titus-control-plane/titus-server-master/src/main/java/com/netflix/titus/master/jobmanager | Create_ds/titus-control-plane/titus-server-master/src/main/java/com/netflix/titus/master/jobmanager/service/InitializationErrorCollector.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.master.jobmanager.service;
import java.util.List;
import java.util.concurrent.CopyOnWriteArrayList;
import java.util.concurrent.atomic.AtomicInteger;
import com.netflix.spectator.api.Gauge;
import com.netflix.spectator.api.Registry;
import com.netflix.titus.common.runtime.SystemAbortEvent;
import com.netflix.titus.common.runtime.TitusRuntime;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
/**
* Helper class that tracks errors during jobs loading, and initialization process.
*/
class InitializationErrorCollector {
private static final Logger logger = LoggerFactory.getLogger(InitializationErrorCollector.class);
private final JobManagerConfiguration jobManagerConfiguration;
private final TitusRuntime titusRuntime;
private final AtomicInteger corruptedJobRecords = new AtomicInteger();
private final AtomicInteger corruptedTaskRecords = new AtomicInteger();
private final List<String> invalidJobs = new CopyOnWriteArrayList<>();
private final List<String> strictlyInvalidJobs = new CopyOnWriteArrayList<>();
private final List<String> invalidTasks = new CopyOnWriteArrayList<>();
private final List<String> strictlyInvalidTasks = new CopyOnWriteArrayList<>();
private final List<String> inconsistentTasks = new CopyOnWriteArrayList<>();
private final List<String> launchedTasksWithUnidentifiedAgents = new CopyOnWriteArrayList<>();
private final Gauge corruptedJobRecordsGauge;
private final Gauge corruptedTaskRecordsGauge;
private final Gauge invalidJobsGauge;
private final Gauge strictlyInvalidJobsGauge;
private final Gauge invalidTasksGauge;
private final Gauge strictlyInvalidTasksGauge;
private final Gauge launchedTasksWithUnidentifiedAgentsGauge;
InitializationErrorCollector(JobManagerConfiguration jobManagerConfiguration, TitusRuntime titusRuntime) {
this.jobManagerConfiguration = jobManagerConfiguration;
this.titusRuntime = titusRuntime;
Registry registry = titusRuntime.getRegistry();
this.corruptedJobRecordsGauge = registry.gauge(JobReconciliationFrameworkFactory.ROOT_METRIC_NAME + "corruptedJobRecords");
this.corruptedTaskRecordsGauge = registry.gauge(JobReconciliationFrameworkFactory.ROOT_METRIC_NAME + "corruptedTaskRecords");
this.invalidJobsGauge = registry.gauge(JobReconciliationFrameworkFactory.ROOT_METRIC_NAME + "invalidJobs");
this.strictlyInvalidJobsGauge = registry.gauge(JobReconciliationFrameworkFactory.ROOT_METRIC_NAME + "strictlyInvalidJobs");
this.invalidTasksGauge = registry.gauge(JobReconciliationFrameworkFactory.ROOT_METRIC_NAME + "invalidTasks");
this.strictlyInvalidTasksGauge = registry.gauge(JobReconciliationFrameworkFactory.ROOT_METRIC_NAME + "strictlyInvalidTasks");
this.launchedTasksWithUnidentifiedAgentsGauge = registry.gauge(JobReconciliationFrameworkFactory.ROOT_METRIC_NAME + "launchedTasksWithUnidentifiedAgents");
}
void corruptedJobRecords(int count) {
corruptedJobRecords.addAndGet(count);
}
void invalidJob(String jobId) {
invalidJobs.add(jobId);
}
public void strictlyInvalidJob(String jobId) {
strictlyInvalidJobs.add(jobId);
}
void corruptedTaskRecords(int count) {
corruptedTaskRecords.addAndGet(count);
}
void invalidTaskRecord(String taskId) {
invalidTasks.add(taskId);
}
public void strictlyInvalidTask(String taskId) {
strictlyInvalidTasks.add(taskId);
}
void failIfTooManyBadRecords() {
writeStateToLog();
createSpectatorMetrics();
int allFailedJobs = corruptedJobRecords.get() + invalidJobs.size();
int allFailedTasks = corruptedTaskRecords.get() + invalidTasks.size() + inconsistentTasks.size() + launchedTasksWithUnidentifiedAgents.size();
boolean failOnJobs = allFailedJobs > jobManagerConfiguration.getMaxFailedJobs();
boolean failOnTasks = allFailedTasks > jobManagerConfiguration.getMaxFailedTasks();
String jobErrorMessage = String.format("Exiting because the number of failed jobs (%s) was greater than allowed maximum (%s)", allFailedJobs, jobManagerConfiguration.getMaxFailedJobs());
String taskErrorMessage = String.format("Exiting because the number of failed tasks (%s) was greater than allowed maximum (%s)", allFailedTasks, jobManagerConfiguration.getMaxFailedTasks());
if (failOnJobs && failOnTasks) {
logger.error(jobErrorMessage);
logger.error(taskErrorMessage);
doFail(jobErrorMessage + ". " + taskErrorMessage);
}
if (failOnJobs) {
logger.error(jobErrorMessage);
doFail(jobErrorMessage);
}
if (failOnTasks) {
logger.error(taskErrorMessage);
doFail(taskErrorMessage);
}
if (allFailedJobs > 0) {
logger.info("Ok to move on although bad job records found: badRecords={}, threshold={}", allFailedJobs, jobManagerConfiguration.getMaxFailedJobs());
}
if (allFailedTasks > 0) {
logger.info("Ok to move on although bad task records found: badRecords={}, threshold={}", allFailedTasks, jobManagerConfiguration.getMaxFailedTasks());
}
}
private void doFail(String reason) {
titusRuntime.beforeAbort(SystemAbortEvent.newBuilder()
.withFailureId(JobReconciliationFrameworkFactory.INCONSISTENT_DATA_FAILURE_ID)
.withFailureType(SystemAbortEvent.FailureType.Nonrecoverable)
.withReason(reason)
.withTimestamp(titusRuntime.getClock().wallTime())
.build());
throw new IllegalStateException(reason);
}
private void writeStateToLog() {
if (corruptedJobRecords.get() > 0) {
logger.info("Found corrupted job records: {}", corruptedJobRecords.get());
}
if (corruptedTaskRecords.get() > 0) {
logger.info("Found corrupted task records: {}", corruptedTaskRecords.get());
}
if (!invalidJobs.isEmpty()) {
logger.info("Found {} jobs with invalid state: {}", invalidJobs.size(), invalidJobs);
}
if (!strictlyInvalidJobs.isEmpty()) {
logger.info("Found {} jobs with strictly invalid state: {}", strictlyInvalidJobs.size(), strictlyInvalidJobs);
}
if (!invalidTasks.isEmpty()) {
logger.info("Found {} task with invalid state: {}", invalidTasks.size(), invalidTasks);
}
if (!strictlyInvalidTasks.isEmpty()) {
logger.info("Found {} task with strictly invalid state: {}", strictlyInvalidTasks.size(), strictlyInvalidTasks);
}
if (!launchedTasksWithUnidentifiedAgents.isEmpty()) {
logger.info("Found {} launched task with no agent assignment: {}", launchedTasksWithUnidentifiedAgents.size(), launchedTasksWithUnidentifiedAgents);
}
if (!inconsistentTasks.isEmpty()) {
logger.info("Found {} task with inconsistent state: {}", inconsistentTasks.size(), inconsistentTasks);
}
}
private void createSpectatorMetrics() {
corruptedJobRecordsGauge.set(corruptedJobRecords.get());
corruptedTaskRecordsGauge.set(corruptedTaskRecords.get());
invalidJobsGauge.set(invalidJobs.size());
strictlyInvalidJobsGauge.set(strictlyInvalidJobs.size());
invalidTasksGauge.set(invalidTasks.size());
strictlyInvalidTasksGauge.set(strictlyInvalidTasks.size());
launchedTasksWithUnidentifiedAgentsGauge.set(launchedTasksWithUnidentifiedAgents.size());
}
}
| 57 |
0 | Create_ds/titus-control-plane/titus-server-master/src/main/java/com/netflix/titus/master/jobmanager | Create_ds/titus-control-plane/titus-server-master/src/main/java/com/netflix/titus/master/jobmanager/service/ComputeProvider.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.master.jobmanager.service;
import com.netflix.titus.api.jobmanager.model.job.Job;
import com.netflix.titus.api.jobmanager.model.job.Task;
import reactor.core.publisher.Mono;
public interface ComputeProvider {
Mono<Void> launchTask(Job<?> job, Task task);
/**
* TODO {@link com.netflix.titus.master.kubernetes.client.DefaultDirectKubeApiServerIntegrator} contract is vague, and could be improved.
*/
Mono<Void> terminateTask(Task task);
default boolean isReadyForScheduling() {
return true;
}
/**
* Given a platform provider create error, resolve it to a reason code defined in {@link com.netflix.titus.api.jobmanager.model.job.TaskStatus}.
*/
String resolveReasonCode(Throwable error);
}
| 58 |
0 | Create_ds/titus-control-plane/titus-server-master/src/main/java/com/netflix/titus/master/jobmanager | Create_ds/titus-control-plane/titus-server-master/src/main/java/com/netflix/titus/master/jobmanager/service/JobManagerConfiguration.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.master.jobmanager.service;
import com.netflix.archaius.api.annotations.Configuration;
import com.netflix.archaius.api.annotations.DefaultValue;
import com.netflix.titus.api.jobmanager.model.job.JobState;
/**
*
*/
@Configuration(prefix = "titusMaster.jobManager")
public interface JobManagerConfiguration {
String STUCK_IN_STATE_TOKEN_BUCKET = "stuckInState";
@DefaultValue("100")
long getReconcilerIdleTimeoutMs();
@DefaultValue("1")
long getReconcilerActiveTimeoutMs();
@DefaultValue("10")
long getCheckpointIntervalMs();
/**
* How many active tasks in the transient state (in other words not Started and not Finished) are allowed in a job.
* If the number of active tasks in the transient state goes above this limit, no new tasks are created.
*/
@DefaultValue("300")
int getActiveNotStartedTasksLimit();
/**
* Maximum number of concurrent store updates per job within the reconciliation loop. Currently only task kill
* operations are accounted for when a job moves to {@link JobState#KillInitiated} state.
*/
@DefaultValue("300")
int getConcurrentReconcilerStoreUpdateLimit();
@DefaultValue("300000")
long getTaskInLaunchedStateTimeoutMs();
@DefaultValue("720000")
long getBatchTaskInStartInitiatedStateTimeoutMs();
@DefaultValue("300000")
long getServiceTaskInStartInitiatedStateTimeoutMs();
@DefaultValue("600000")
long getTaskInKillInitiatedStateTimeoutMs();
/**
* Minimum amount of time a task should stay in Started state, before the retryer that is associated with it is
* restarted.
*/
@DefaultValue("300000")
long getTaskRetryerResetTimeMs();
/**
* A lower bound on the retry interval.
*/
@DefaultValue("1000")
long getMinRetryIntervalMs();
@DefaultValue("2")
long getTaskKillAttempts();
@DefaultValue("20000")
long getMaxActiveJobs();
/**
* @return the maximum allowed number of jobs that could not be loaded from the database (corrupted records, inconsistent data, etc)
*/
@DefaultValue("0")
long getMaxFailedJobs();
/**
* @return the maximum allowed number of tasks that could not be loaded from the database (corrupted records, inconsistent data, etc)
*/
@DefaultValue("0")
long getMaxFailedTasks();
@DefaultValue("10000")
long getTaskLivenessPollerIntervalMs();
/**
* Feature flag controlling job/task validation process.
*/
@DefaultValue("false")
boolean isFailOnDataValidation();
@DefaultValue("1000")
long getSystemRetryerMinDelayMs();
@DefaultValue("30000")
long getSystemRetryerMaxDelayMs();
}
| 59 |
0 | Create_ds/titus-control-plane/titus-server-master/src/main/java/com/netflix/titus/master/jobmanager/service | Create_ds/titus-control-plane/titus-server-master/src/main/java/com/netflix/titus/master/jobmanager/service/limiter/DefaultJobSubmitLimiter.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.master.jobmanager.service.limiter;
import java.util.Optional;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;
import javax.inject.Inject;
import javax.inject.Singleton;
import com.google.common.base.Preconditions;
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.service.JobManagerException;
import com.netflix.titus.api.jobmanager.service.V3JobOperations;
import com.netflix.titus.master.jobmanager.service.JobManagerConfiguration;
@Singleton
public class DefaultJobSubmitLimiter implements JobSubmitLimiter {
private final JobManagerConfiguration configuration;
private final V3JobOperations v3JobOperations;
private final ConcurrentMap<String, Boolean> reservedJobIdSequences = new ConcurrentHashMap<>();
@Inject
public DefaultJobSubmitLimiter(JobManagerConfiguration configuration,
V3JobOperations v3JobOperations) {
this.configuration = configuration;
this.v3JobOperations = v3JobOperations;
}
@Override
public <JOB_DESCR> Optional<JobManagerException> checkIfAllowed(JOB_DESCR jobDescriptor) {
Preconditions.checkArgument(
jobDescriptor instanceof JobDescriptor,
"Not V3 job descriptor"
);
Optional<String> activeJobLimit = checkActiveJobLimit();
if (activeJobLimit.isPresent()) {
return Optional.of(JobManagerException.jobCreateLimited(activeJobLimit.get()));
}
Optional<String> idSequenceError = checkJobIdSequence(jobDescriptor);
if (idSequenceError.isPresent()) {
return Optional.of(JobManagerException.invalidSequenceId(idSequenceError.get()));
}
return Optional.empty();
}
@Override
public <JOB_DESCR> Optional<String> reserveId(JOB_DESCR jobDescriptor) {
String idSeq = createJobIdSequenceFrom(jobDescriptor);
if (idSeq == null) {
return Optional.empty();
}
if (reservedJobIdSequences.putIfAbsent(idSeq, true) == null) {
return Optional.empty();
}
return Optional.of("Job sequence id reserved by another pending job create request: " + idSeq);
}
@Override
public <JOB_DESCR> void releaseId(JOB_DESCR jobDescriptor) {
String idSeq = createJobIdSequenceFrom(jobDescriptor);
if (idSeq != null) {
reservedJobIdSequences.remove(idSeq);
}
}
private Optional<String> checkActiveJobLimit() {
int totalJobs = v3JobOperations.getJobs().size();
long limit = configuration.getMaxActiveJobs();
if (totalJobs >= limit) {
return Optional.of(String.format("Reached a limit of active jobs Titus can run (active=%d, limit=%d)", totalJobs, limit));
}
return Optional.empty();
}
private <JOB_DESCR> Optional<String> checkJobIdSequence(JOB_DESCR jobDescriptor) {
String jobIdSequence = createJobIdSequenceFrom(jobDescriptor);
if (jobIdSequence == null) {
return Optional.empty();
}
return isJobSequenceUsed(jobIdSequence).map(existingJobId ->
String.format("Constraint violation - job with group sequence %s exists (%s)", jobIdSequence, existingJobId)
);
}
private <JOB_DESCR> String createJobIdSequenceFrom(JOB_DESCR jobDescriptor) {
return formatJobGroupName((JobDescriptor<?>) jobDescriptor);
}
private Optional<String> isJobSequenceUsed(String newJobIdSequence) {
return v3JobOperations.getJobs().stream()
.filter(j -> {
String v3JobIdSequence = formatJobGroupName(j.getJobDescriptor());
return v3JobIdSequence != null && v3JobIdSequence.equals(newJobIdSequence);
})
.map(Job::getId)
.findFirst();
}
private static String formatJobGroupName(JobDescriptor<?> jobDescriptor) {
JobGroupInfo jobGroupInfo = jobDescriptor.getJobGroupInfo();
if (jobGroupInfo.getSequence().isEmpty()) {
return null;
}
return String.join("-",
jobDescriptor.getApplicationName(),
jobGroupInfo.getStack(),
jobGroupInfo.getDetail(),
jobGroupInfo.getSequence()
);
}
}
| 60 |
0 | Create_ds/titus-control-plane/titus-server-master/src/main/java/com/netflix/titus/master/jobmanager/service | Create_ds/titus-control-plane/titus-server-master/src/main/java/com/netflix/titus/master/jobmanager/service/limiter/JobSubmitLimiter.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.master.jobmanager.service.limiter;
import java.util.Optional;
import com.netflix.titus.api.jobmanager.service.JobManagerException;
public interface JobSubmitLimiter {
/**
* Check if it is ok to schedule a given job. If not, the result contains a reason message.
*/
<JOB_DESCR> Optional<JobManagerException> checkIfAllowed(JOB_DESCR jobDescriptor);
/**
* Reserve job id sequence. If reservation fails, the result contains a reason message.
*/
<JOB_DESCR> Optional<String> reserveId(JOB_DESCR jobDescriptor);
/**
* Release job id sequence.
*/
<JOB_DESCR> void releaseId(JOB_DESCR jobDescriptor);
}
| 61 |
0 | Create_ds/titus-control-plane/titus-server-master/src/main/java/com/netflix/titus/master/jobmanager/service | Create_ds/titus-control-plane/titus-server-master/src/main/java/com/netflix/titus/master/jobmanager/service/common/DifferenceResolverUtils.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.master.jobmanager.service.common;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.Set;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.stream.Collectors;
import com.netflix.titus.api.jobmanager.model.job.ExecutableStatus;
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.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.ebs.EbsVolume;
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.service.JobManagerConstants;
import com.netflix.titus.api.jobmanager.service.V3JobOperations;
import com.netflix.titus.api.jobmanager.store.JobStore;
import com.netflix.titus.common.framework.reconciler.ChangeAction;
import com.netflix.titus.common.framework.reconciler.EntityHolder;
import com.netflix.titus.common.framework.reconciler.ReconciliationEngine;
import com.netflix.titus.common.runtime.TitusRuntime;
import com.netflix.titus.common.util.limiter.tokenbucket.TokenBucket;
import com.netflix.titus.common.util.time.Clock;
import com.netflix.titus.master.jobmanager.service.JobManagerConfiguration;
import com.netflix.titus.master.jobmanager.service.JobServiceRuntime;
import com.netflix.titus.master.jobmanager.service.VersionSupplier;
import com.netflix.titus.master.jobmanager.service.common.action.task.BasicTaskActions;
import com.netflix.titus.master.jobmanager.service.common.action.task.KillInitiatedActions;
import com.netflix.titus.master.jobmanager.service.common.action.task.TaskTimeoutChangeActions;
import com.netflix.titus.master.jobmanager.service.event.JobManagerReconcilerEvent;
import static com.netflix.titus.api.jobmanager.TaskAttributes.TASK_ATTRIBUTES_EBS_VOLUME_ID;
import static com.netflix.titus.api.jobmanager.TaskAttributes.TASK_ATTRIBUTES_IP_ALLOCATION_ID;
/**
* Collection of functions useful for batch and service difference resolvers.
*/
public class DifferenceResolverUtils {
public static boolean isDone(Job<?> job, Task task) {
return task.getStatus().getState() == TaskState.Finished && !shouldRetry(job, task);
}
public static boolean allDone(EntityHolder rootHolder) {
return rootHolder.getChildren().stream().allMatch(taskHolder -> isDone(rootHolder.getEntity(), taskHolder.getEntity()));
}
public static boolean shouldRetry(Job<?> job, Task task) {
TaskStatus taskStatus = task.getStatus();
if (taskStatus.getState() != TaskState.Finished || job.getStatus().getState() != JobState.Accepted) {
return false;
}
if (hasReachedRetryLimit(job, task)) {
return false;
}
if (!isBatch(job)) {
return true;
}
// Batch job
String killInitiatedReason = JobFunctions.findTaskStatus(task, TaskState.KillInitiated).map(ExecutableStatus::getReasonCode).orElse("N/A");
if (TaskStatus.REASON_RUNTIME_LIMIT_EXCEEDED.equals(killInitiatedReason)) {
BatchJobExt batchExt = (BatchJobExt) job.getJobDescriptor().getExtensions();
if (!batchExt.isRetryOnRuntimeLimit()) {
return false;
}
}
return !TaskStatus.REASON_NORMAL.equals(taskStatus.getReasonCode());
}
public static boolean hasReachedRetryLimit(Job<?> refJob, Task task) {
int retryLimit = apply(refJob, BatchJobExt::getRetryPolicy, ServiceJobExt::getRetryPolicy).getRetries();
if (task.getStatus().getState() != TaskState.Finished || TaskStatus.hasSystemError(task)) {
return false;
}
int userRetries = task.getResubmitNumber() - task.getSystemResubmitNumber() - task.getEvictionResubmitNumber();
return userRetries >= retryLimit;
}
public static boolean hasJobState(EntityHolder root, JobState state) {
Job job = root.getEntity();
return job.getStatus().getState() == state;
}
public static boolean areEquivalent(EntityHolder storeTask, EntityHolder referenceTask) {
return storeTask.getEntity().equals(referenceTask.getEntity());
}
public static boolean isBatch(Job<?> job) {
return job.getJobDescriptor().getExtensions() instanceof BatchJobExt;
}
public static boolean isTerminating(Task task) {
TaskState state = task.getStatus().getState();
return state == TaskState.KillInitiated || state == TaskState.Finished;
}
public static <T> T apply(Job<?> job, Function<BatchJobExt, T> batch, Function<ServiceJobExt, T> service) {
JobDescriptor.JobDescriptorExt ext = job.getJobDescriptor().getExtensions();
if (ext instanceof BatchJobExt) {
return batch.apply((BatchJobExt) ext);
}
return service.apply((ServiceJobExt) ext);
}
/**
* Find all tasks that are stuck in a specific state. The number of {@link ChangeAction changes} will be limited
* by the {@link TokenBucket stuckInStateRateLimiter}
*/
public static List<ChangeAction> findTaskStateTimeouts(ReconciliationEngine<JobManagerReconcilerEvent> engine,
JobView runningJobView,
JobManagerConfiguration configuration,
JobServiceRuntime runtime,
JobStore jobStore,
VersionSupplier versionSupplier,
TokenBucket stuckInStateRateLimiter,
TitusRuntime titusRuntime) {
Clock clock = titusRuntime.getClock();
List<ChangeAction> actions = new ArrayList<>();
runningJobView.getJobHolder().getChildren().forEach(taskHolder -> {
Task task = taskHolder.getEntity();
TaskState taskState = task.getStatus().getState();
if (JobFunctions.isBatchJob(runningJobView.getJob()) && taskState == TaskState.Started) {
Job<BatchJobExt> batchJob = runningJobView.getJob();
// We expect runtime limit to be always set, so this is just extra safety measure.
long runtimeLimitMs = Math.max(BatchJobExt.RUNTIME_LIMIT_MIN, batchJob.getJobDescriptor().getExtensions().getRuntimeLimitMs());
long deadline = task.getStatus().getTimestamp() + runtimeLimitMs;
if (deadline < clock.wallTime()) {
actions.add(KillInitiatedActions.reconcilerInitiatedTaskKillInitiated(engine, task, runtime,
jobStore, versionSupplier, TaskStatus.REASON_RUNTIME_LIMIT_EXCEEDED,
"Task running too long (runtimeLimit=" + runtimeLimitMs + "ms)", titusRuntime)
);
}
return;
}
TaskTimeoutChangeActions.TimeoutStatus timeoutStatus = TaskTimeoutChangeActions.getTimeoutStatus(taskHolder, clock);
switch (timeoutStatus) {
case Ignore:
case Pending:
break;
case NotSet:
long timeoutMs = -1;
switch (taskState) {
case Launched:
timeoutMs = configuration.getTaskInLaunchedStateTimeoutMs();
break;
case StartInitiated:
timeoutMs = isBatch(runningJobView.getJob())
? configuration.getBatchTaskInStartInitiatedStateTimeoutMs()
: configuration.getServiceTaskInStartInitiatedStateTimeoutMs();
break;
case KillInitiated:
timeoutMs = configuration.getTaskInKillInitiatedStateTimeoutMs();
break;
}
if (timeoutMs > 0) {
actions.add(TaskTimeoutChangeActions.setTimeout(taskHolder.getId(), task.getStatus().getState(), timeoutMs, clock));
}
break;
case TimedOut:
if (!stuckInStateRateLimiter.tryTake()) {
break;
}
if (task.getStatus().getState() == TaskState.KillInitiated) {
int attempts = TaskTimeoutChangeActions.getKillInitiatedAttempts(taskHolder) + 1;
if (attempts >= configuration.getTaskKillAttempts()) {
actions.add(
BasicTaskActions.updateTaskInRunningModel(task.getId(),
V3JobOperations.Trigger.Reconciler,
configuration,
engine,
taskParam -> Optional.of(taskParam.toBuilder()
.withStatus(taskParam.getStatus().toBuilder()
.withState(TaskState.Finished)
.withReasonCode(TaskStatus.REASON_STUCK_IN_KILLING_STATE)
.withReasonMessage("stuck in " + taskState + "state")
.build()
)
.build()
),
"TimedOut in KillInitiated state",
versionSupplier,
titusRuntime,
JobManagerConstants.RECONCILER_CALLMETADATA.toBuilder().withCallReason("Kill initiated").build())
);
} else {
actions.add(TaskTimeoutChangeActions.incrementTaskKillAttempt(task.getId(), configuration.getTaskInKillInitiatedStateTimeoutMs(), clock));
actions.add(KillInitiatedActions.reconcilerInitiatedTaskKillInitiated(engine, task, runtime,
jobStore, versionSupplier, TaskStatus.REASON_STUCK_IN_KILLING_STATE,
"Another kill attempt (" + (attempts + 1) + ')', titusRuntime));
}
} else {
actions.add(KillInitiatedActions.reconcilerInitiatedTaskKillInitiated(engine, task, runtime,
jobStore, versionSupplier, TaskStatus.REASON_STUCK_IN_STATE,
"Task stuck in " + taskState + " state", titusRuntime));
}
break;
}
});
return actions;
}
public static int countActiveNotStartedTasks(EntityHolder refJobHolder, EntityHolder runningJobHolder) {
Set<String> pendingTaskIds = new HashSet<>();
Consumer<EntityHolder> countingFun = jobHolder -> jobHolder.getChildren().forEach(taskHolder -> {
TaskState state = ((Task) taskHolder.getEntity()).getStatus().getState();
if (state != TaskState.Started && state != TaskState.Finished) {
pendingTaskIds.add(taskHolder.getId());
}
});
countingFun.accept(refJobHolder);
countingFun.accept(runningJobHolder);
return pendingTaskIds.size();
}
/**
* Determines unassigned IP allocations based on the current reference view
*/
public static List<String> getUnassignedIpAllocations(JobView refJobView) {
// Get a sorted list of all IP allocations from the job
List<String> unassignedIpAddressIds = refJobView.getJob().getJobDescriptor().getContainer().getContainerResources().getSignedIpAddressAllocations().stream()
.map(signedIpAddressAllocation -> signedIpAddressAllocation.getIpAddressAllocation().getAllocationId())
.collect(Collectors.toList());
// Filter out those that are assigned
for (Task task : (List<Task>) refJobView.getTasks()) {
if (!TaskState.isTerminalState(task.getStatus().getState())) {
unassignedIpAddressIds.remove(task.getTaskContext().getOrDefault(TASK_ATTRIBUTES_IP_ALLOCATION_ID, ""));
}
}
return unassignedIpAddressIds;
}
public static List<String> getUnassignedEbsVolumes(JobView refJobView) {
// Get a sorted list of all ebs values from the job
List<String> unassignedEbsVolumeIds = refJobView.getJob().getJobDescriptor().getContainer().getContainerResources().getEbsVolumes().stream()
.map(EbsVolume::getVolumeId)
.collect(Collectors.toList());
// Filter out those that are assigned
for (Task task : (List<Task>) refJobView.getTasks()) {
if (!TaskState.isTerminalState(task.getStatus().getState())) {
unassignedEbsVolumeIds.remove(task.getTaskContext().getOrDefault(TASK_ATTRIBUTES_EBS_VOLUME_ID, ""));
}
}
return unassignedEbsVolumeIds;
}
/**
* Copies specific task context entries, multiple if needed, from a previous task to a replacement task
*/
private static Map<String, String> getTaskContextFromPreviousTask(Task previousTask) {
Map<String, String> taskContext = new HashMap<>();
// Copy the IP allocation task context to the replacement task
String ipAllocationId = previousTask.getTaskContext().get(TASK_ATTRIBUTES_IP_ALLOCATION_ID);
if (null != ipAllocationId) {
taskContext.put(TASK_ATTRIBUTES_IP_ALLOCATION_ID, ipAllocationId);
}
// Copy the EBS volume ID task context to the replacement task
String ebsVolumeId = previousTask.getTaskContext().get(TASK_ATTRIBUTES_EBS_VOLUME_ID);
if (null != ebsVolumeId) {
taskContext.put(TASK_ATTRIBUTES_EBS_VOLUME_ID, ebsVolumeId);
}
return taskContext;
}
/**
* Sets the task context fields, multiple if needed, for an initial task.
*/
private static Map<String, String> getInitialTaskContext(List<String> unassignedIpAllocations, List<String> unassignedEbsVolumeIds) {
Map<String, String> taskContext = new HashMap<>();
if (!unassignedIpAllocations.isEmpty()) {
String ipAllocationId = unassignedIpAllocations.remove(0);
taskContext.put(TASK_ATTRIBUTES_IP_ALLOCATION_ID, ipAllocationId);
}
if (!unassignedEbsVolumeIds.isEmpty()) {
String ebsVolumeId = unassignedEbsVolumeIds.remove(0);
taskContext.put(TASK_ATTRIBUTES_EBS_VOLUME_ID, ebsVolumeId);
}
return taskContext;
}
/**
* Get task context for a new or replacement task
*/
public static Map<String, String> getTaskContext(Optional<EntityHolder> optionalPreviousTaskEntityHolder,
List<String> unassignedIpAllocations,
List<String> unassignedEbsVolumeIds) {
return optionalPreviousTaskEntityHolder
.map(entityHolder -> (Task) entityHolder.getEntity())
.map(DifferenceResolverUtils::getTaskContextFromPreviousTask)
.orElseGet(() -> getInitialTaskContext(unassignedIpAllocations, unassignedEbsVolumeIds));
}
public static class JobView<EXT extends JobDescriptor.JobDescriptorExt, TASK extends Task> {
private final Job<EXT> job;
private final EntityHolder jobHolder;
private final List<TASK> tasks;
private final int requiredSize;
@SuppressWarnings("unchecked")
public JobView(EntityHolder jobHolder) {
this.job = jobHolder.getEntity();
this.jobHolder = jobHolder;
this.requiredSize = apply(job, BatchJobExt::getSize, service -> service.getCapacity().getDesired());
this.tasks = jobHolder.getChildren().stream().map(h -> (TASK) h.getEntity()).collect(Collectors.toList());
}
public EntityHolder getJobHolder() {
return jobHolder;
}
public Job<EXT> getJob() {
return job;
}
public List<TASK> getTasks() {
return tasks;
}
public TASK getTaskById(String refTaskId) {
return jobHolder.findChildById(refTaskId).map(h -> (TASK) h.getEntity()).orElse(null);
}
public int getRequiredSize() {
return requiredSize;
}
}
}
| 62 |
0 | Create_ds/titus-control-plane/titus-server-master/src/main/java/com/netflix/titus/master/jobmanager/service | Create_ds/titus-control-plane/titus-server-master/src/main/java/com/netflix/titus/master/jobmanager/service/common/SecurityGroupUtils.java | /*
* Copyright 2020 Netflix, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.netflix.titus.master.jobmanager.service.common;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
public final class SecurityGroupUtils {
private static final String SECURITY_GROUP_DELIMITER = ":";
public static String normalizeSecurityGroups(String securityGroups) {
return normalizedSecurityGroupsIdentifier(Arrays.asList(securityGroups.split(SECURITY_GROUP_DELIMITER)));
}
static String normalizedSecurityGroupsIdentifier(List<String> securityGroups) {
// make sure the security groups are sorted when loading two level resources
List<String> sortedSecurityGroups = new ArrayList<>(securityGroups);
Collections.sort(sortedSecurityGroups);
return String.join(SECURITY_GROUP_DELIMITER, sortedSecurityGroups);
}
}
| 63 |
0 | Create_ds/titus-control-plane/titus-server-master/src/main/java/com/netflix/titus/master/jobmanager/service/common | Create_ds/titus-control-plane/titus-server-master/src/main/java/com/netflix/titus/master/jobmanager/service/common/action/TitusModelAction.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.master.jobmanager.service.common.action;
import java.util.Optional;
import java.util.function.Function;
import com.google.common.base.Preconditions;
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.JobManagerConstants;
import com.netflix.titus.api.jobmanager.service.V3JobOperations.Trigger;
import com.netflix.titus.api.model.callmetadata.CallMetadata;
import com.netflix.titus.common.framework.reconciler.EntityHolder;
import com.netflix.titus.common.framework.reconciler.ModelAction;
import com.netflix.titus.common.util.tuple.Pair;
/**
*/
public abstract class TitusModelAction implements ModelAction {
private static final CallMetadata NOT_SET_CALLMETADATA = JobManagerConstants.UNDEFINED_CALL_METADATA.toBuilder()
.withCallReason("WARNING: caller id not set for the model change action")
.build();
private final String name;
private final Trigger trigger;
private final String id;
private final String summary;
private final CallMetadata callMetadata;
protected TitusModelAction(Trigger trigger, String id, String summary, CallMetadata callMetadata) {
this.trigger = trigger;
this.id = id;
this.summary = summary;
this.callMetadata = callMetadata == null ? NOT_SET_CALLMETADATA : callMetadata;
this.name = getClass().getSimpleName();
}
protected TitusModelAction(String name, Trigger trigger, String id, String summary, CallMetadata callMetadata) {
this.name = name;
this.trigger = trigger;
this.id = id;
this.summary = summary;
this.callMetadata = callMetadata == null ? NOT_SET_CALLMETADATA : callMetadata;
}
public String getName() {
return name;
}
public String getId() {
return id;
}
public Trigger getTrigger() {
return trigger;
}
public String getSummary() {
return summary;
}
public CallMetadata getCallMetadata() {
return callMetadata;
}
public static Builder newModelUpdate(String name) {
return new Builder(name);
}
public static Builder newModelUpdate(TitusChangeAction.Builder sourceChangeAction) {
return new Builder(sourceChangeAction.name)
.id(sourceChangeAction.id)
.trigger(sourceChangeAction.trigger)
.summary(sourceChangeAction.summary)
.callMetadata(sourceChangeAction.callMetadata);
}
public static Builder newModelUpdate(String name, TitusChangeAction sourceChangeAction) {
return new Builder(name)
.id(sourceChangeAction.getId())
.trigger(sourceChangeAction.getTrigger())
.summary(sourceChangeAction.getSummary())
.callMetadata(sourceChangeAction.getCallMetadata());
}
public static class Builder {
private final String name;
private String id;
private Trigger trigger;
private String summary = "None";
private CallMetadata callMetadata;
private Builder(String name) {
this.name = name;
}
private Builder id(String id) {
this.id = id;
return this;
}
public Builder job(Job<?> job) {
this.id = job.getId();
return this;
}
public Builder task(Task task) {
this.id = task.getId();
return this;
}
public Builder trigger(Trigger trigger) {
this.trigger = trigger;
return this;
}
public Builder summary(String summary, Object... args) {
this.summary = args.length > 0 ? String.format(summary, args) : summary;
return this;
}
public Builder callMetadata(CallMetadata callMetadata) {
this.callMetadata = callMetadata;
return this;
}
public TitusModelAction jobMaybeUpdate(Function<EntityHolder, Optional<EntityHolder>> jobHolderFun) {
check();
return new TitusModelAction(name, trigger, id, summary, callMetadata) {
@Override
public Optional<Pair<EntityHolder, EntityHolder>> apply(EntityHolder rootHolder) {
Optional<EntityHolder> newRoot = jobHolderFun.apply(rootHolder);
return newRoot.map(value -> verify(Pair.of(value, value)));
}
};
}
public TitusModelAction jobUpdate(Function<EntityHolder, EntityHolder> jobHolderFun) {
return jobMaybeUpdate(eh -> Optional.of(jobHolderFun.apply(eh)));
}
public TitusModelAction taskMaybeUpdate(Function<EntityHolder, Optional<Pair<EntityHolder, EntityHolder>>> taskHolderFun) {
check();
return new TitusModelAction(name, trigger, id, summary, callMetadata) {
@Override
public Optional<Pair<EntityHolder, EntityHolder>> apply(EntityHolder rootHolder) {
return taskHolderFun.apply(rootHolder).map(pair -> verify(pair));
}
};
}
public TitusModelAction taskUpdate(Function<EntityHolder, Pair<EntityHolder, EntityHolder>> taskHolderFun) {
return taskMaybeUpdate(eh -> Optional.of(taskHolderFun.apply(eh)));
}
public TitusModelAction taskUpdate(Task newTask) {
return taskUpdate(jobHolder -> JobEntityHolders.addTask(jobHolder, newTask));
}
public TitusModelAction addTaskHolder(EntityHolder taskHolder) {
return taskUpdate(jobHolder -> Pair.of(jobHolder.addChild(taskHolder), taskHolder));
}
public TitusModelAction removeTask(Task task) {
this.id = task.getId();
return jobMaybeUpdate(jobHolder -> {
Pair<EntityHolder, Optional<EntityHolder>> result = jobHolder.removeChild(id);
return result.getRight().map(removed -> result.getLeft());
});
}
private Pair<EntityHolder, EntityHolder> verify(Pair<EntityHolder, EntityHolder> modelUpdate) {
Object root = modelUpdate.getLeft().getEntity();
Preconditions.checkArgument(root instanceof Job, "Root entity not Job instance, but %s", root.getClass());
if (modelUpdate.getLeft() == modelUpdate.getRight()) {
return modelUpdate;
}
Object child = modelUpdate.getRight().getEntity();
Preconditions.checkArgument(child instanceof Job || child instanceof Task, "Root entity not Job or Task instance, but %s", root.getClass());
return modelUpdate;
}
private void check() {
Preconditions.checkState(id != null, "Job or task id not defined");
Preconditions.checkState(trigger != null, "Trigger not defined");
}
}
}
| 64 |
0 | Create_ds/titus-control-plane/titus-server-master/src/main/java/com/netflix/titus/master/jobmanager/service/common | Create_ds/titus-control-plane/titus-server-master/src/main/java/com/netflix/titus/master/jobmanager/service/common/action/TaskRetryers.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.master.jobmanager.service.common.action;
import java.util.Optional;
import java.util.function.Supplier;
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.Task;
import com.netflix.titus.api.jobmanager.model.job.TaskState;
import com.netflix.titus.common.framework.reconciler.EntityHolder;
import com.netflix.titus.common.util.retry.Retryer;
import com.netflix.titus.common.util.retry.Retryers;
import com.netflix.titus.common.util.time.Clock;
/**
* A set of primitive functions for dealing with task retry rules. Each task is associated at its creation time
* with a {@link Retryer} instance. This instance determines the retry delay time in case the current task fails.
* The delay is measured from the time when the task moved to Finished state.
* The resubmit delay time is computed and added to the task reference model, at the very same moment as the task
* state change is recorded in it. Resubmit delay is also added to task context, as a hint to external clients why
* the resubmit process is delayed.
*/
public class TaskRetryers {
public static final String ATTR_TASK_RETRY = "retryer";
public static final String ATTR_TASK_RETRY_DELAY_MS = "retryDelayMs";
public static Optional<Retryer> getCurrentTaskRetryer(EntityHolder taskHolder) {
return Optional.ofNullable((Retryer) taskHolder.getAttributes().get(ATTR_TASK_RETRY));
}
public static Retryer getNextTaskRetryer(Supplier<Retryer> systemRetryer, Job<?> job, EntityHolder taskHolder) {
return getCurrentTaskRetryer(taskHolder)
.map(Retryer::retry)
.orElseGet(() -> Retryers.max(systemRetryer.get(), JobFunctions.retryer(job)));
}
public static long getCurrentRetryerDelayMs(EntityHolder taskHolder, long minRetryIntervalMs, long taskRetryerResetTimeMs, Clock clock) {
return getCurrentTaskRetryer(taskHolder).map(retryer -> {
long timeInStartedState = JobFunctions.getTimeInState(taskHolder.getEntity(), TaskState.Started, clock).orElse(0L);
return timeInStartedState >= taskRetryerResetTimeMs ? 0L : Math.max(minRetryIntervalMs, retryer.getDelayMs().orElse(minRetryIntervalMs));
}).orElse(minRetryIntervalMs);
}
public static boolean shouldRetryNow(EntityHolder taskHolder, Clock clock) {
long delayMs = (long) taskHolder.getAttributes().getOrDefault(ATTR_TASK_RETRY_DELAY_MS, 0L);
if (delayMs == 0) {
return true;
}
Task task = taskHolder.getEntity();
long delayUntil = task.getStatus().getTimestamp() + delayMs;
return delayUntil <= clock.wallTime();
}
}
| 65 |
0 | Create_ds/titus-control-plane/titus-server-master/src/main/java/com/netflix/titus/master/jobmanager/service/common | Create_ds/titus-control-plane/titus-server-master/src/main/java/com/netflix/titus/master/jobmanager/service/common/action/TitusChangeAction.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.master.jobmanager.service.common.action;
import java.util.Collections;
import java.util.List;
import java.util.Optional;
import java.util.function.Function;
import com.google.common.base.Preconditions;
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.JobManagerConstants;
import com.netflix.titus.api.jobmanager.service.V3JobOperations;
import com.netflix.titus.api.jobmanager.service.V3JobOperations.Trigger;
import com.netflix.titus.api.model.callmetadata.CallMetadata;
import com.netflix.titus.common.framework.reconciler.ChangeAction;
import com.netflix.titus.common.framework.reconciler.ModelActionHolder;
import rx.Observable;
/**
*
*/
public abstract class TitusChangeAction implements ChangeAction {
private static final CallMetadata NOT_SET_CALLMETADATA = JobManagerConstants.UNDEFINED_CALL_METADATA.toBuilder()
.withCallReason("WARNING: caller id not set for the change action")
.build();
private final V3JobOperations.Trigger trigger;
private final String id;
private final Optional<Task> task;
private final String name;
private final String summary;
private final CallMetadata callMetadata;
protected TitusChangeAction(TitusChangeAction delegate) {
this.trigger = delegate.getTrigger();
this.id = delegate.getId();
this.task = delegate.getTask();
this.name = delegate.getName();
this.summary = delegate.getSummary();
this.callMetadata = delegate.getCallMetadata();
}
public TitusChangeAction(Trigger trigger, String id, Task task, String name, String summary, CallMetadata callMetadata) {
this.trigger = trigger;
this.id = id;
this.task = Optional.ofNullable(task);
this.name = name;
this.summary = summary;
this.callMetadata = callMetadata == null ? NOT_SET_CALLMETADATA : callMetadata;
}
public Trigger getTrigger() {
return trigger;
}
public String getId() {
return id;
}
public Optional<Task> getTask() {
return task;
}
public String getName() {
return name;
}
public String getSummary() {
return summary;
}
public CallMetadata getCallMetadata() {
return callMetadata;
}
public static Builder newAction(String name) {
return new Builder(name);
}
public static Builder newInterceptor(String name, TitusChangeAction changeAction) {
return new Builder(name + '(' + changeAction.getName() + ')')
.id(changeAction.getId())
.trigger(changeAction.getTrigger())
.summary(name + ": " + changeAction.getSummary())
.callMetadata(changeAction.getCallMetadata());
}
public static class Builder {
final String name;
String id;
Task task;
String summary = "None";
Trigger trigger;
CallMetadata callMetadata;
private Builder(String name) {
this.name = name;
}
public Builder id(String id) {
this.id = id;
return this;
}
public Builder job(Job<?> job) {
this.id = job.getId();
return this;
}
public Builder task(Task task) {
this.id = task.getId();
this.task = task;
return this;
}
public Builder trigger(Trigger trigger) {
this.trigger = trigger;
return this;
}
public Builder summary(String summary, Object... args) {
this.summary = args.length > 0 ? String.format(summary, args) : summary;
return this;
}
public Builder callMetadata(CallMetadata callMetadata) {
this.callMetadata = callMetadata;
return this;
}
public TitusChangeAction changeWithModelUpdate(Function<Builder, Observable<ModelActionHolder>> actionFun) {
check();
return new TitusChangeAction(trigger, id, task, name, summary, callMetadata) {
@Override
public Observable<List<ModelActionHolder>> apply() {
return actionFun.apply(Builder.this).map(Collections::singletonList);
}
};
}
public TitusChangeAction changeWithModelUpdates(Function<Builder, Observable<List<ModelActionHolder>>> actionFun) {
check();
return new TitusChangeAction(trigger, id, task, name, summary, callMetadata) {
@Override
public Observable<List<ModelActionHolder>> apply() {
return actionFun.apply(Builder.this);
}
};
}
public TitusChangeAction applyModelUpdate(Function<Builder, ModelActionHolder> actionFun) {
check();
return new TitusChangeAction(trigger, id, task, name, summary, callMetadata) {
@Override
public Observable<List<ModelActionHolder>> apply() {
return Observable.fromCallable(() -> actionFun.apply(Builder.this)).map(Collections::singletonList);
}
};
}
public TitusChangeAction applyModelUpdates(Function<Builder, List<ModelActionHolder>> actionFun) {
check();
return new TitusChangeAction(trigger, id, task, name, summary, callMetadata) {
@Override
public Observable<List<ModelActionHolder>> apply() {
return Observable.fromCallable(() -> actionFun.apply(Builder.this));
}
};
}
private void check() {
Preconditions.checkState(id != null, "Job or task id not defined");
Preconditions.checkState(trigger != null, "Trigger not defined");
}
}
}
| 66 |
0 | Create_ds/titus-control-plane/titus-server-master/src/main/java/com/netflix/titus/master/jobmanager/service/common | Create_ds/titus-control-plane/titus-server-master/src/main/java/com/netflix/titus/master/jobmanager/service/common/action/JobEntityHolders.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.master.jobmanager.service.common.action;
import java.util.Objects;
import java.util.Optional;
import com.netflix.titus.api.jobmanager.model.job.Task;
import com.netflix.titus.common.framework.reconciler.EntityHolder;
import com.netflix.titus.common.framework.reconciler.ReconciliationEngine;
import com.netflix.titus.common.runtime.TitusRuntime;
import com.netflix.titus.common.util.tuple.Pair;
import com.netflix.titus.master.jobmanager.service.event.JobManagerReconcilerEvent;
import rx.Observable;
/**
* Functions for processing job manager {@link EntityHolder} instances.
*/
public final class JobEntityHolders {
public static final String ATTR_REPLACEMENT_OF = "replacementOf";
public static Optional<EntityHolder> expectTaskHolder(ReconciliationEngine<JobManagerReconcilerEvent> engine, String taskId, TitusRuntime titusRuntime) {
Optional<EntityHolder> taskHolder = engine.getReferenceView().findById(taskId);
if (taskHolder.isPresent()) {
return Optional.of(taskHolder.get());
}
titusRuntime.getCodeInvariants().inconsistent("Expected to find task %s owned by job %s", taskId, engine.getReferenceView().getId());
return Optional.empty();
}
public static Optional<Task> expectTask(ReconciliationEngine<JobManagerReconcilerEvent> engine, String taskId, TitusRuntime titusRuntime) {
return expectTaskHolder(engine, taskId, titusRuntime).map(EntityHolder::getEntity);
}
public static Observable<Task> toTaskObservable(ReconciliationEngine<JobManagerReconcilerEvent> engine, String taskId, TitusRuntime titusRuntime) {
return Observable.fromCallable(() -> expectTask(engine, taskId, titusRuntime).orElse(null)).filter(Objects::nonNull);
}
public static Pair<EntityHolder, EntityHolder> addTask(EntityHolder rootHolder, Task newTask) {
EntityHolder newTaskHolder = rootHolder.findById(newTask.getId())
.map(taskHolder -> taskHolder.setEntity(newTask))
.orElseGet(() -> EntityHolder.newRoot(newTask.getId(), newTask));
return Pair.of(rootHolder.addChild(newTaskHolder), newTaskHolder);
}
}
| 67 |
0 | Create_ds/titus-control-plane/titus-server-master/src/main/java/com/netflix/titus/master/jobmanager/service/common/action | Create_ds/titus-control-plane/titus-server-master/src/main/java/com/netflix/titus/master/jobmanager/service/common/action/task/BasicJobActions.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.master.jobmanager.service.common.action.task;
import java.util.Map;
import java.util.Optional;
import java.util.Set;
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.TaskStatus;
import com.netflix.titus.api.jobmanager.model.job.disruptionbudget.DisruptionBudget;
import com.netflix.titus.api.jobmanager.service.V3JobOperations;
import com.netflix.titus.api.jobmanager.store.JobStore;
import com.netflix.titus.api.model.callmetadata.CallMetadata;
import com.netflix.titus.common.framework.reconciler.ChangeAction;
import com.netflix.titus.common.framework.reconciler.EntityHolder;
import com.netflix.titus.common.framework.reconciler.ModelActionHolder;
import com.netflix.titus.common.framework.reconciler.ReconciliationEngine;
import com.netflix.titus.master.jobmanager.service.VersionSupplier;
import com.netflix.titus.master.jobmanager.service.VersionSuppliers;
import com.netflix.titus.master.jobmanager.service.common.action.TitusChangeAction;
import com.netflix.titus.master.jobmanager.service.common.action.TitusModelAction;
import com.netflix.titus.master.jobmanager.service.event.JobManagerReconcilerEvent;
import rx.Observable;
public class BasicJobActions {
public static final String ATTR_JOB_CLOSED = "job.closed";
/**
* Write an updated job record to a store. This command calls {@link JobStore#updateJob(Job)}, which assumes
* that the job record was created already.
*/
public static TitusChangeAction updateJobInStore(ReconciliationEngine<JobManagerReconcilerEvent> engine, JobStore titusStore) {
return TitusChangeAction.newAction("updateJobInStore")
.id(engine.getReferenceView().getId())
.trigger(V3JobOperations.Trigger.Reconciler)
.summary("Updating job record in store")
.changeWithModelUpdate(self -> {
Job<?> referenceJob = engine.getReferenceView().getEntity();
TitusModelAction modelUpdateAction = TitusModelAction.newModelUpdate(self)
.jobMaybeUpdate(storeJobHolder -> Optional.of(storeJobHolder.setEntity(referenceJob)));
return titusStore.updateJob(referenceJob).andThen(Observable.just(ModelActionHolder.store(modelUpdateAction)));
});
}
/**
* Update job disruption budet.
*/
public static ChangeAction updateJobDisruptionBudget(ReconciliationEngine<JobManagerReconcilerEvent> engine, DisruptionBudget disruptionBudget,
JobStore jobStore, VersionSupplier versionSupplier, CallMetadata callMetadata) {
return TitusChangeAction.newAction("updateDisruptionBudget")
.id(engine.getReferenceView().getId())
.trigger(V3JobOperations.Trigger.API)
.summary("Job disruption budget update")
.callMetadata(callMetadata)
.changeWithModelUpdates(self -> {
Job<?> job = engine.getReferenceView().getEntity();
Job<?> updatedJob = VersionSuppliers.nextVersion(JobFunctions.changeDisruptionBudget(job, disruptionBudget), versionSupplier);
TitusModelAction modelAction = TitusModelAction.newModelUpdate(self).jobUpdate(jobHolder -> jobHolder.setEntity(updatedJob));
return jobStore.updateJob(updatedJob).andThen(Observable.just(ModelActionHolder.referenceAndStore(modelAction)));
});
}
/**
* Update the attributes of a job. This will either create new attributes or replacing an existing ones with the same key.
*/
public static ChangeAction updateJobAttributes(ReconciliationEngine<JobManagerReconcilerEvent> engine, Map<String, String> attributes,
JobStore jobStore, VersionSupplier versionSupplier, CallMetadata callMetadata) {
return TitusChangeAction.newAction("updateJobAttributes")
.id(engine.getReferenceView().getId())
.trigger(V3JobOperations.Trigger.API)
.summary("Update job attributes")
.callMetadata(callMetadata)
.changeWithModelUpdates(self -> {
Job<?> job = engine.getReferenceView().getEntity();
Job<?> updatedJob = VersionSuppliers.nextVersion(JobFunctions.updateJobAttributes(job, attributes), versionSupplier);
TitusModelAction modelAction = TitusModelAction.newModelUpdate(self).jobUpdate(jobHolder -> jobHolder.setEntity(updatedJob));
return jobStore.updateJob(updatedJob).andThen(Observable.just(ModelActionHolder.referenceAndStore(modelAction)));
});
}
/**
* Delete the attributes of a job with the specified key names.
*/
public static ChangeAction deleteJobAttributes(ReconciliationEngine<JobManagerReconcilerEvent> engine, Set<String> keys,
JobStore jobStore, VersionSupplier versionSupplier, CallMetadata callMetadata) {
return TitusChangeAction.newAction("updateJobAttributes")
.id(engine.getReferenceView().getId())
.trigger(V3JobOperations.Trigger.API)
.summary("Delete job attributes")
.callMetadata(callMetadata)
.changeWithModelUpdates(self -> {
Job<?> job = engine.getReferenceView().getEntity();
Job<?> updatedJob = VersionSuppliers.nextVersion(JobFunctions.deleteJobAttributes(job, keys), versionSupplier);
TitusModelAction modelAction = TitusModelAction.newModelUpdate(self).jobUpdate(jobHolder -> jobHolder.setEntity(updatedJob));
return jobStore.updateJob(updatedJob).andThen(Observable.just(ModelActionHolder.referenceAndStore(modelAction)));
});
}
/**
* Move job to {@link JobState#Finished} state in reference and running models.
*/
public static TitusChangeAction completeJob(String jobId, VersionSupplier versionSupplier) {
return TitusChangeAction.newAction("closeJob")
.id(jobId)
.trigger(V3JobOperations.Trigger.Reconciler)
.summary("Moving job to Finished state")
.applyModelUpdates(self -> {
TitusModelAction modelUpdateAction = TitusModelAction.newModelUpdate(self)
.jobMaybeUpdate(entityHolder -> {
Job job = entityHolder.getEntity();
if (job.getStatus().getState() != JobState.Finished) {
Job newJob = JobFunctions.changeJobStatus(job, JobState.Finished, TaskStatus.REASON_NORMAL);
newJob = VersionSuppliers.nextVersion(newJob, versionSupplier);
return Optional.of(entityHolder.setEntity(newJob));
}
return Optional.empty();
});
return ModelActionHolder.referenceAndRunning(modelUpdateAction);
});
}
/**
* Delete a job from store, and mark it as closed in the reference model. {@link #ATTR_JOB_CLOSED} attribute
* is used to identify closed jobs, which can be removed from the reconciliation engine.
*/
public static TitusChangeAction removeJobFromStore(Job job, JobStore store) {
return TitusChangeAction.newAction("removeJobFromStore")
.job(job)
.trigger(V3JobOperations.Trigger.Reconciler)
.summary("Removing job from the storage")
.changeWithModelUpdate(self -> {
TitusModelAction modelUpdateAction = TitusModelAction.newModelUpdate(self)
.jobMaybeUpdate(entityHolder -> Optional.of(entityHolder.addTag(ATTR_JOB_CLOSED, true)));
return store.deleteJob(job).andThen(Observable.just(ModelActionHolder.reference(modelUpdateAction)));
});
}
public static boolean isClosed(EntityHolder model) {
return (Boolean) model.getAttributes().getOrDefault(ATTR_JOB_CLOSED, Boolean.FALSE);
}
}
| 68 |
0 | Create_ds/titus-control-plane/titus-server-master/src/main/java/com/netflix/titus/master/jobmanager/service/common/action | Create_ds/titus-control-plane/titus-server-master/src/main/java/com/netflix/titus/master/jobmanager/service/common/action/task/TaskTimeoutChangeActions.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.master.jobmanager.service.common.action.task;
import java.util.Map;
import com.google.common.base.Preconditions;
import com.google.common.collect.ImmutableMap;
import com.netflix.titus.api.jobmanager.model.job.JobFunctions;
import com.netflix.titus.api.jobmanager.model.job.Task;
import com.netflix.titus.api.jobmanager.model.job.TaskState;
import com.netflix.titus.api.jobmanager.service.JobManagerConstants;
import com.netflix.titus.api.jobmanager.service.V3JobOperations.Trigger;
import com.netflix.titus.common.framework.reconciler.EntityHolder;
import com.netflix.titus.common.framework.reconciler.ModelActionHolder;
import com.netflix.titus.common.util.DateTimeExt;
import com.netflix.titus.common.util.time.Clock;
import com.netflix.titus.common.util.tuple.Pair;
import com.netflix.titus.master.jobmanager.service.JobManagerConfiguration;
import com.netflix.titus.master.jobmanager.service.common.action.TitusChangeAction;
import com.netflix.titus.master.jobmanager.service.common.action.TitusModelAction;
/**
* Associates a timeout with transient task states (Launched|StartInitiated). If task does not move out of this state
* within an expected amount of time, it is killed.
* <p>
* <h1>Why cannot use task state timestamp?</h1>
* Due to TitusMaster failover process, and delayed Kubernetes state reconciliation. If we would do this, we might
* kill tasks that progressed their state, but we are not aware of this, due to a delay in the reconciliation process.
* This could be solved by doing Kubernetes reconciliation during system bootstrap, before job reconciliation process starts
* (a possible improvement in the future).
*/
public class TaskTimeoutChangeActions {
public enum TimeoutStatus {Ignore, NotSet, Pending, TimedOut}
private static final String KILL_INITIATED_ATTEMPT_TAG = "timeout.killInitiatedAttempt";
private static final String LAUNCHED_STATE_TIMEOUT_TAG = "timeout.launched";
private static final String START_INITIATED_TIMEOUT_TAG = "timeout.startInitiated";
private static final String KILL_INITIATED_TIMEOUT_TAG = "timeout.killInitiated";
private static final Map<TaskState, String> STATE_TAGS = ImmutableMap.of(
TaskState.Launched, LAUNCHED_STATE_TIMEOUT_TAG,
TaskState.StartInitiated, START_INITIATED_TIMEOUT_TAG,
TaskState.KillInitiated, KILL_INITIATED_TIMEOUT_TAG
);
public static TitusChangeAction setTimeout(String taskId, TaskState taskState, long timeoutMs, Clock clock) {
String tagName = STATE_TAGS.get(taskState);
Preconditions.checkArgument(tagName != null, "Timeout not tracked for state %s", taskState);
return TitusChangeAction.newAction("setTimeout")
.id(taskId)
.trigger(Trigger.Reconciler)
.summary("Setting timeout for task in state %s: %s", taskState, DateTimeExt.toTimeUnitString(timeoutMs))
.callMetadata(JobManagerConstants.RECONCILER_CALLMETADATA.toBuilder().withCallReason("configure timeout").build())
.applyModelUpdate(self -> {
TitusModelAction modelAction = TitusModelAction.newModelUpdate(self)
.taskMaybeUpdate(jobHolder ->
jobHolder.findById(taskId).map(taskHolder -> {
EntityHolder newTaskHolder = taskHolder.addTag(tagName, clock.wallTime() + timeoutMs);
if (taskState == TaskState.KillInitiated) {
newTaskHolder = newTaskHolder.addTag(KILL_INITIATED_ATTEMPT_TAG, 0);
}
return Pair.of(jobHolder.addChild(newTaskHolder), newTaskHolder);
}));
return ModelActionHolder.running(modelAction);
});
}
public static EntityHolder setTimeoutOnRestoreFromStore(JobManagerConfiguration configuration, EntityHolder taskHolder, Clock clock) {
Task task = taskHolder.getEntity();
switch (task.getStatus().getState()) {
case Launched:
return taskHolder.addTag(LAUNCHED_STATE_TIMEOUT_TAG, clock.wallTime() + configuration.getTaskInLaunchedStateTimeoutMs());
case StartInitiated:
long timeoutMs = JobFunctions.isServiceTask(task)
? configuration.getServiceTaskInStartInitiatedStateTimeoutMs()
: configuration.getBatchTaskInStartInitiatedStateTimeoutMs();
return taskHolder.addTag(START_INITIATED_TIMEOUT_TAG, clock.wallTime() + timeoutMs);
case KillInitiated:
return taskHolder
.addTag(KILL_INITIATED_TIMEOUT_TAG, clock.wallTime() + configuration.getTaskInKillInitiatedStateTimeoutMs())
.addTag(KILL_INITIATED_ATTEMPT_TAG, 0);
}
return taskHolder;
}
public static TitusChangeAction incrementTaskKillAttempt(String taskId, long deadlineMs, Clock clock) {
return TitusChangeAction.newAction("anotherKillAttempt")
.id(taskId)
.trigger(Trigger.Reconciler)
.summary("Registering another task kill attempt due to timeout in KillInitiated state")
.applyModelUpdate(self -> {
TitusModelAction modelAction = TitusModelAction.newModelUpdate(self)
.taskMaybeUpdate(jobHolder ->
jobHolder.findById(taskId).map(taskHolder -> {
int attempt = (int) taskHolder.getAttributes().getOrDefault(KILL_INITIATED_ATTEMPT_TAG, 0);
EntityHolder newTaskHolder = taskHolder
.addTag(KILL_INITIATED_TIMEOUT_TAG, clock.wallTime() + deadlineMs)
.addTag(KILL_INITIATED_ATTEMPT_TAG, attempt + 1);
return Pair.of(jobHolder.addChild(newTaskHolder), newTaskHolder);
}));
return ModelActionHolder.running(modelAction);
});
}
public static TimeoutStatus getTimeoutStatus(EntityHolder taskHolder, Clock clock) {
Task task = taskHolder.getEntity();
TaskState state = task.getStatus().getState();
if (state != TaskState.Launched && state != TaskState.StartInitiated && state != TaskState.KillInitiated) {
return TimeoutStatus.Ignore;
}
Long deadline = (Long) taskHolder.getAttributes().get(STATE_TAGS.get(state));
if (deadline == null) {
return TimeoutStatus.NotSet;
}
return clock.wallTime() < deadline ? TimeoutStatus.Pending : TimeoutStatus.TimedOut;
}
public static int getKillInitiatedAttempts(EntityHolder taskHolder) {
return (int) taskHolder.getAttributes().getOrDefault(KILL_INITIATED_ATTEMPT_TAG, 0);
}
}
| 69 |
0 | Create_ds/titus-control-plane/titus-server-master/src/main/java/com/netflix/titus/master/jobmanager/service/common/action | Create_ds/titus-control-plane/titus-server-master/src/main/java/com/netflix/titus/master/jobmanager/service/common/action/task/BasicTaskActions.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.master.jobmanager.service.common.action.task;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Optional;
import java.util.function.Function;
import com.netflix.titus.api.jobmanager.TaskAttributes;
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.JobModel;
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.service.JobManagerException;
import com.netflix.titus.api.jobmanager.service.V3JobOperations;
import com.netflix.titus.api.jobmanager.service.V3JobOperations.Trigger;
import com.netflix.titus.api.jobmanager.store.JobStore;
import com.netflix.titus.api.model.callmetadata.CallMetadata;
import com.netflix.titus.common.framework.reconciler.EntityHolder;
import com.netflix.titus.common.framework.reconciler.ModelActionHolder;
import com.netflix.titus.common.framework.reconciler.ReconciliationEngine;
import com.netflix.titus.common.runtime.TitusRuntime;
import com.netflix.titus.common.util.CollectionsExt;
import com.netflix.titus.common.util.DateTimeExt;
import com.netflix.titus.common.util.ExceptionExt;
import com.netflix.titus.common.util.rx.ReactorExt;
import com.netflix.titus.common.util.tuple.Pair;
import com.netflix.titus.master.jobmanager.service.JobManagerConfiguration;
import com.netflix.titus.master.jobmanager.service.JobServiceRuntime;
import com.netflix.titus.master.jobmanager.service.VersionSupplier;
import com.netflix.titus.master.jobmanager.service.VersionSuppliers;
import com.netflix.titus.master.jobmanager.service.common.action.JobEntityHolders;
import com.netflix.titus.master.jobmanager.service.common.action.TaskRetryers;
import com.netflix.titus.master.jobmanager.service.common.action.TitusChangeAction;
import com.netflix.titus.master.jobmanager.service.common.action.TitusModelAction;
import com.netflix.titus.master.jobmanager.service.event.JobManagerReconcilerEvent;
import rx.Observable;
public class BasicTaskActions {
/**
* Update a task, and write it to store before updating reference and store models.
* This action is used when handling user initiated updates.
*/
public static TitusChangeAction updateTaskAndWriteItToStore(String taskId,
ReconciliationEngine<JobManagerReconcilerEvent> engine,
Function<Task, Task> changeFunction,
JobStore jobStore,
Trigger trigger,
String reason,
VersionSupplier versionSupplier,
TitusRuntime titusRuntime,
CallMetadata callMetadata) {
return TitusChangeAction.newAction("updateTaskAndWriteItToStore")
.id(taskId)
.trigger(trigger)
.summary(reason)
.callMetadata(callMetadata)
.changeWithModelUpdates(self ->
JobEntityHolders.expectTask(engine, taskId, titusRuntime)
.map(task -> {
Task newTask = VersionSuppliers.nextVersion(changeFunction.apply(task), versionSupplier);
TitusModelAction modelUpdate = TitusModelAction.newModelUpdate(self).taskUpdate(newTask);
return jobStore.updateTask(newTask).andThen(Observable.just(ModelActionHolder.referenceAndStore(modelUpdate)));
})
.orElseGet(() -> Observable.error(JobManagerException.taskNotFound(taskId)))
);
}
/**
* Write updated task record to a store. If a task is completed, remove it from the scheduling service.
* This command calls {@link JobStore#updateTask(Task)}, which assumes that the task record was created already.
*/
public static TitusChangeAction writeReferenceTaskToStore(JobStore titusStore,
ReconciliationEngine<JobManagerReconcilerEvent> engine,
String taskId,
CallMetadata callMetadata,
TitusRuntime titusRuntime) {
return TitusChangeAction.newAction("writeReferenceTaskToStore")
.trigger(V3JobOperations.Trigger.Reconciler)
.id(taskId)
.summary("Persisting task to the store")
.callMetadata(callMetadata)
.changeWithModelUpdate(self -> {
Optional<EntityHolder> taskHolder = engine.getReferenceView().findById(taskId);
if (!taskHolder.isPresent()) {
// Should never happen
titusRuntime.getCodeInvariants().inconsistent("Reference task with id %s not found.", taskId);
return Observable.empty();
}
Task referenceTask = taskHolder.get().getEntity();
return titusStore.updateTask(referenceTask)
.andThen(Observable.fromCallable(() -> {
TitusModelAction modelUpdateAction = TitusModelAction.newModelUpdate(self)
.taskUpdate(storeRoot -> {
EntityHolder storedHolder = EntityHolder.newRoot(referenceTask.getId(), referenceTask);
return Pair.of(storeRoot.addChild(storedHolder), storedHolder);
}
);
return ModelActionHolder.store(modelUpdateAction);
}));
});
}
/**
* Update a task in the reference and running models. If a task moves to Finished state, add retry delay information
* to the task, and to task entity holder (see {@link TaskRetryers}).
*/
public static TitusChangeAction updateTaskInRunningModel(String taskId,
Trigger trigger,
JobManagerConfiguration configuration,
ReconciliationEngine<JobManagerReconcilerEvent> engine,
Function<Task, Optional<Task>> changeFunction,
String reason,
VersionSupplier versionSupplier,
TitusRuntime titusRuntime,
CallMetadata callMetadata) {
return TitusChangeAction.newAction("updateTaskInRunningModel")
.id(taskId)
.trigger(trigger)
.summary(reason)
.callMetadata(callMetadata)
.applyModelUpdates(self -> {
Optional<EntityHolder> taskOptional = JobEntityHolders.expectTaskHolder(engine, taskId, titusRuntime);
if (!taskOptional.isPresent()) {
return Collections.emptyList();
}
EntityHolder taskHolder = taskOptional.get();
Task oldTask = taskHolder.getEntity();
Optional<Task> maybeNewTask = changeFunction.apply(oldTask);
if (!maybeNewTask.isPresent()) {
return Collections.emptyList();
}
Task newTask = VersionSuppliers.nextVersion(maybeNewTask.get(), versionSupplier);
// Handle separately reference and runtime models, as only reference model gets retry attributes.
List<ModelActionHolder> modelActionHolders = new ArrayList<>();
// Add retryer data to task context.
if (newTask.getStatus().getState() == TaskState.Finished) {
modelActionHolders.add(ModelActionHolder.reference(attachRetryer(self, taskHolder, newTask, callMetadata, configuration, titusRuntime)));
} else {
modelActionHolders.add(ModelActionHolder.reference(TitusModelAction.newModelUpdate(self).taskUpdate(newTask)));
}
modelActionHolders.add(ModelActionHolder.running(TitusModelAction.newModelUpdate(self).taskUpdate(newTask)));
return modelActionHolders;
}
);
}
/**
* Create pod for a task.
*/
public static TitusChangeAction launchTaskInKube(JobManagerConfiguration configuration,
JobServiceRuntime runtime,
ReconciliationEngine<JobManagerReconcilerEvent> engine,
Job<?> job,
Task task,
CallMetadata callMetadata,
VersionSupplier versionSupplier,
TitusRuntime titusRuntime) {
return TitusChangeAction.newAction("launchTaskInKube")
.task(task)
.trigger(V3JobOperations.Trigger.Reconciler)
.summary("Adding task to Kube")
.callMetadata(callMetadata)
.changeWithModelUpdates(self -> {
EntityHolder taskHolder = JobEntityHolders.expectTaskHolder(engine, task.getId(), titusRuntime).orElse(null);
if (taskHolder == null) {
// This should never happen.
return Observable.just(Collections.emptyList());
}
return ReactorExt.toCompletable(runtime.getComputeProvider().launchTask(job, task).then())
.andThen(Observable.fromCallable(() -> {
TaskStatus taskStatus = JobModel.newTaskStatus()
.withState(TaskState.Accepted)
.withReasonCode(TaskStatus.REASON_POD_CREATED)
.withReasonMessage("Created pod in Kubernetes via KubeScheduler. Needs to be scheduled on a node.")
.withTimestamp(titusRuntime.getClock().wallTime())
.build();
Task taskWithPod = task.toBuilder()
.withTaskContext(CollectionsExt.copyAndAdd(task.getTaskContext(), TaskAttributes.TASK_ATTRIBUTES_POD_CREATED, "true"))
.withStatus(taskStatus)
.withStatusHistory(CollectionsExt.copyAndAdd(task.getStatusHistory(), task.getStatus()))
.build();
taskWithPod = VersionSuppliers.nextVersion(taskWithPod, versionSupplier);
TitusModelAction modelUpdateAction = TitusModelAction.newModelUpdate(self).taskUpdate(taskWithPod);
return ModelActionHolder.referenceAndRunning(modelUpdateAction);
}))
.onErrorReturn(error -> {
// Move task to the finished state after we failed to create a pod object for it.
String reasonCode = runtime.getComputeProvider().resolveReasonCode(error);
Task finishedTask = JobFunctions.changeTaskStatus(task, JobModel.newTaskStatus()
.withState(TaskState.Finished)
.withReasonCode(reasonCode)
.withReasonMessage("Failed to create pod: " + ExceptionExt.toMessageChain(error))
.withTimestamp(titusRuntime.getClock().wallTime())
.build()
);
finishedTask = VersionSuppliers.nextVersion(finishedTask, versionSupplier);
List<ModelActionHolder> modelActionHolders = new ArrayList<>();
modelActionHolders.add(ModelActionHolder.reference(attachRetryer(self, taskHolder, finishedTask, callMetadata, configuration, titusRuntime)));
modelActionHolders.add(ModelActionHolder.running(TitusModelAction.newModelUpdate(self).taskUpdate(finishedTask)));
return modelActionHolders;
});
});
}
private static TitusModelAction attachRetryer(TitusChangeAction.Builder self,
EntityHolder taskHolder,
Task updatedTask,
CallMetadata callMetadata,
JobManagerConfiguration configuration,
TitusRuntime titusRuntime) {
long retryDelayMs = TaskRetryers.getCurrentRetryerDelayMs(
taskHolder, configuration.getMinRetryIntervalMs(), configuration.getTaskRetryerResetTimeMs(), titusRuntime.getClock()
);
String retryDelayString = DateTimeExt.toTimeUnitString(retryDelayMs);
updatedTask = updatedTask.toBuilder()
.addToTaskContext(TaskAttributes.TASK_ATTRIBUTES_RETRY_DELAY, retryDelayString)
.build();
EntityHolder newTaskHolder = taskHolder.
setEntity(updatedTask)
.addTag(TaskRetryers.ATTR_TASK_RETRY_DELAY_MS, retryDelayMs);
return TitusModelAction.newModelUpdate(self)
.summary("Setting retry delay on task in Finished state: %s", retryDelayString)
.callMetadata(callMetadata)
.addTaskHolder(newTaskHolder);
}
}
| 70 |
0 | Create_ds/titus-control-plane/titus-server-master/src/main/java/com/netflix/titus/master/jobmanager/service/common/action | Create_ds/titus-control-plane/titus-server-master/src/main/java/com/netflix/titus/master/jobmanager/service/common/action/task/KillInitiatedActions.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.master.jobmanager.service.common.action.task;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashSet;
import java.util.List;
import java.util.Optional;
import java.util.Set;
import java.util.concurrent.Callable;
import com.netflix.titus.api.jobmanager.model.job.Capacity;
import com.netflix.titus.api.jobmanager.model.job.Job;
import com.netflix.titus.api.jobmanager.model.job.JobFunctions;
import com.netflix.titus.api.jobmanager.model.job.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.api.jobmanager.service.JobManagerConstants;
import com.netflix.titus.api.jobmanager.service.JobManagerException;
import com.netflix.titus.api.jobmanager.service.V3JobOperations;
import com.netflix.titus.api.jobmanager.store.JobStore;
import com.netflix.titus.api.model.callmetadata.CallMetadata;
import com.netflix.titus.common.framework.reconciler.ChangeAction;
import com.netflix.titus.common.framework.reconciler.EntityHolder;
import com.netflix.titus.common.framework.reconciler.ModelActionHolder;
import com.netflix.titus.common.framework.reconciler.ReconciliationEngine;
import com.netflix.titus.common.runtime.TitusRuntime;
import com.netflix.titus.common.util.rx.ReactorExt;
import com.netflix.titus.master.jobmanager.service.JobServiceRuntime;
import com.netflix.titus.master.jobmanager.service.VersionSupplier;
import com.netflix.titus.master.jobmanager.service.VersionSuppliers;
import com.netflix.titus.master.jobmanager.service.common.action.JobEntityHolders;
import com.netflix.titus.master.jobmanager.service.common.action.TitusChangeAction;
import com.netflix.titus.master.jobmanager.service.common.action.TitusModelAction;
import com.netflix.titus.master.jobmanager.service.event.JobManagerReconcilerEvent;
import rx.Completable;
import rx.Observable;
/**
* A collection of {@link ChangeAction}s for task termination.
*/
public class KillInitiatedActions {
/**
* Move job to {@link JobState#KillInitiated} state in reference, running and store models.
*/
public static TitusChangeAction initiateJobKillAction(ReconciliationEngine<JobManagerReconcilerEvent> engine, JobStore titusStore,
VersionSupplier versionSupplier, String reason, CallMetadata callMetadata) {
String reasonMessage = String.format("Changing job state to KillInitiated (reason:%s)", reason);
return TitusChangeAction.newAction("initiateJobKillAction")
.id(engine.getReferenceView().getId())
.trigger(V3JobOperations.Trigger.API)
.summary(reasonMessage)
.callMetadata(callMetadata)
.changeWithModelUpdates(self -> {
Job job = engine.getReferenceView().getEntity();
JobStatus newStatus = JobStatus.newBuilder()
.withState(JobState.KillInitiated)
.withReasonCode(TaskStatus.REASON_JOB_KILLED).withReasonMessage(reasonMessage)
.build();
Job jobWithKillInitiated = VersionSuppliers.nextVersion(JobFunctions.changeJobStatus(job, newStatus), versionSupplier);
TitusModelAction modelUpdateAction = TitusModelAction.newModelUpdate(self)
.jobMaybeUpdate(entityHolder -> Optional.of(entityHolder.setEntity(jobWithKillInitiated)));
return titusStore.updateJob(jobWithKillInitiated).andThen(Observable.just(ModelActionHolder.allModels(modelUpdateAction)));
});
}
/**
* Change a task to {@link TaskState#KillInitiated} state, store it, and send the kill command to the compute provider.
* All models are updated when both operations complete.
* This method is used for user initiated kill operations, so the store operation happens before response is sent back to the user.
*/
public static ChangeAction userInitiateTaskKillAction(ReconciliationEngine<JobManagerReconcilerEvent> engine,
JobServiceRuntime executionContext,
JobStore jobStore,
VersionSupplier versionSupplier,
String taskId,
boolean shrink,
boolean preventMinSizeUpdate,
String reasonCode,
String reason,
TitusRuntime titusRuntime,
CallMetadata callMetadata) {
return TitusChangeAction.newAction("userInitiateTaskKill")
.id(taskId)
.trigger(V3JobOperations.Trigger.API)
.summary(reason)
.callMetadata(callMetadata)
.changeWithModelUpdates(self ->
JobEntityHolders.toTaskObservable(engine, taskId, titusRuntime).flatMap(task -> {
TaskState taskState = task.getStatus().getState();
if (taskState == TaskState.KillInitiated || taskState == TaskState.Finished) {
return Observable.just(Collections.<ModelActionHolder>emptyList());
}
if (shrink) {
Job<ServiceJobExt> job = engine.getReferenceView().getEntity();
Capacity capacity = job.getJobDescriptor().getExtensions().getCapacity();
if (preventMinSizeUpdate && capacity.getDesired() <= capacity.getMin()) {
return Observable.<List<ModelActionHolder>>error(JobManagerException.terminateAndShrinkNotAllowed(job, task));
}
}
Task taskWithKillInitiated = VersionSuppliers.nextVersion(
JobFunctions.changeTaskStatus(task, TaskState.KillInitiated, reasonCode, reason, titusRuntime.getClock()),
versionSupplier);
Callable<List<ModelActionHolder>> modelUpdateActions = () -> JobEntityHolders.expectTask(engine, task.getId(), titusRuntime).map(current -> {
List<ModelActionHolder> updateActions = new ArrayList<>();
TitusModelAction stateUpdateAction = TitusModelAction.newModelUpdate(self).taskUpdate(taskWithKillInitiated);
updateActions.addAll(ModelActionHolder.allModels(stateUpdateAction));
if (shrink) {
TitusModelAction shrinkAction = createShrinkAction(self, versionSupplier);
updateActions.add(ModelActionHolder.reference(shrinkAction));
}
return updateActions;
}).orElse(Collections.emptyList());
return jobStore.updateTask(taskWithKillInitiated)
.andThen(createKillAction(executionContext, task))
.andThen(Observable.fromCallable(modelUpdateActions));
}));
}
/**
* For an active task send kill command to the compute provider, and change its state to {@link TaskState#KillInitiated}.
* This method is used for internal state reconciliation.
*/
public static ChangeAction reconcilerInitiatedTaskKillInitiated(ReconciliationEngine<JobManagerReconcilerEvent> engine,
Task task,
JobServiceRuntime runtime,
JobStore jobStore,
VersionSupplier versionSupplier,
String reasonCode,
String reason,
TitusRuntime titusRuntime) {
return TitusChangeAction.newAction("reconcilerInitiatedTaskKill")
.task(task)
.trigger(V3JobOperations.Trigger.Reconciler)
.summary(reason)
.callMetadata(JobManagerConstants.RECONCILER_CALLMETADATA.toBuilder().withCallReason(reason).build())
.changeWithModelUpdates(self ->
JobEntityHolders.toTaskObservable(engine, task.getId(), titusRuntime).flatMap(currentTask -> {
TaskState taskState = currentTask.getStatus().getState();
if (taskState == TaskState.Finished) {
return Observable.just(Collections.<ModelActionHolder>emptyList());
}
Task taskWithKillInitiated = VersionSuppliers.nextVersion(
JobFunctions.changeTaskStatus(currentTask, TaskState.KillInitiated, reasonCode, reason, titusRuntime.getClock()),
versionSupplier);
TitusModelAction taskUpdateAction = TitusModelAction.newModelUpdate(self).taskUpdate(taskWithKillInitiated);
// If already in KillInitiated state, do not store eagerly, just call the compute provider terminate again.
if (taskState == TaskState.KillInitiated) {
return createKillAction(runtime, currentTask).andThen(
Observable.just(ModelActionHolder.referenceAndRunning(taskUpdateAction))
);
}
return jobStore.updateTask(taskWithKillInitiated)
.andThen(createKillAction(runtime, currentTask))
.andThen(Observable.fromCallable(() -> ModelActionHolder.allModels(taskUpdateAction)));
}));
}
/**
* For all active tasks, send terminate command to the compute provider, and change their state to {@link TaskState#KillInitiated}.
* This method is used for internal state reconciliation.
*/
public static List<ChangeAction> reconcilerInitiatedAllTasksKillInitiated(ReconciliationEngine<JobManagerReconcilerEvent> engine,
JobServiceRuntime runtime,
JobStore jobStore,
String reasonCode,
String reason,
int concurrencyLimit,
VersionSupplier versionSupplier,
TitusRuntime titusRuntime) {
List<ChangeAction> result = new ArrayList<>();
EntityHolder runningView = engine.getRunningView();
Set<String> runningTaskIds = new HashSet<>();
runningView.getChildren().forEach(taskHolder -> runningTaskIds.add(taskHolder.<Task>getEntity().getId()));
// Immediately finish Accepted tasks, which are not yet in the running model.
for (EntityHolder entityHolder : engine.getReferenceView().getChildren()) {
if (result.size() >= concurrencyLimit) {
return result;
}
Task task = entityHolder.getEntity();
TaskState state = task.getStatus().getState();
if (state == TaskState.Accepted && !runningTaskIds.contains(task.getId())) {
result.add(BasicTaskActions.updateTaskAndWriteItToStore(
task.getId(),
engine,
taskRef -> JobFunctions.changeTaskStatus(taskRef, TaskState.Finished, reasonCode, reason, titusRuntime.getClock()),
jobStore,
V3JobOperations.Trigger.Reconciler,
reason,
versionSupplier,
titusRuntime,
JobManagerConstants.RECONCILER_CALLMETADATA.toBuilder().withCallReason(reason).build()
));
}
}
// Move running tasks to KillInitiated state
for (EntityHolder taskHolder : runningView.getChildren()) {
if (result.size() >= concurrencyLimit) {
return result;
}
Task task = taskHolder.getEntity();
TaskState state = task.getStatus().getState();
if (state != TaskState.KillInitiated && state != TaskState.Finished) {
result.add(reconcilerInitiatedTaskKillInitiated(engine, task, runtime, jobStore, versionSupplier, reasonCode, reason, titusRuntime));
}
}
return result;
}
private static Completable createKillAction(JobServiceRuntime executionContext, Task task) {
return ReactorExt.toCompletable(executionContext.getComputeProvider().terminateTask(task));
}
private static TitusModelAction createShrinkAction(TitusChangeAction.Builder changeActionBuilder, VersionSupplier versionSupplier) {
return TitusModelAction.newModelUpdate(changeActionBuilder)
.summary("Shrinking job as a result of terminate and shrink request")
.jobUpdate(jobHolder -> {
Job<ServiceJobExt> serviceJob = jobHolder.getEntity();
ServiceJobExt oldExt = serviceJob.getJobDescriptor().getExtensions();
Capacity oldCapacity = oldExt.getCapacity();
// A job of size 0 may still have some tasks running just after job scale-down request.
// We must make sure that we do not decrement the job size if it is already 0.
int newDesired = Math.max(0, oldCapacity.getDesired() - 1);
Capacity newCapacity = oldCapacity.toBuilder()
.withMin(Math.min(oldCapacity.getMin(), newDesired))
.withDesired(newDesired)
.build();
Job<ServiceJobExt> newJob = serviceJob.toBuilder()
.withJobDescriptor(
serviceJob.getJobDescriptor().toBuilder()
.withExtensions(oldExt.toBuilder().withCapacity(newCapacity).build())
.build())
.build();
newJob = VersionSuppliers.nextVersion(newJob, versionSupplier);
return jobHolder.setEntity(newJob);
});
}
}
| 71 |
0 | Create_ds/titus-control-plane/titus-server-master/src/main/java/com/netflix/titus/master/jobmanager/service/common | Create_ds/titus-control-plane/titus-server-master/src/main/java/com/netflix/titus/master/jobmanager/service/common/interceptor/TitusChangeActionInterceptor.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.master.jobmanager.service.common.interceptor;
import java.util.function.Function;
import com.netflix.titus.common.framework.reconciler.EntityHolder;
import com.netflix.titus.master.jobmanager.service.common.action.TitusChangeAction;
/**
*/
public interface TitusChangeActionInterceptor<S> extends Function<TitusChangeAction, TitusChangeAction> {
S executionLimits(EntityHolder rooHolder);
}
| 72 |
0 | Create_ds/titus-control-plane/titus-server-master/src/main/java/com/netflix/titus/master/jobmanager/service/common | Create_ds/titus-control-plane/titus-server-master/src/main/java/com/netflix/titus/master/jobmanager/service/common/interceptor/RetryActionInterceptor.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.master.jobmanager.service.common.interceptor;
import java.util.Collections;
import java.util.List;
import java.util.Optional;
import com.netflix.titus.common.framework.reconciler.ChangeAction;
import com.netflix.titus.common.framework.reconciler.EntityHolder;
import com.netflix.titus.common.framework.reconciler.ModelActionHolder;
import com.netflix.titus.common.framework.reconciler.ReconciliationEngine.DifferenceResolver;
import com.netflix.titus.common.util.CollectionsExt;
import com.netflix.titus.common.util.retry.Retryer;
import com.netflix.titus.common.util.tuple.Pair;
import com.netflix.titus.master.jobmanager.service.common.action.TitusChangeAction;
import com.netflix.titus.master.jobmanager.service.common.action.TitusModelAction;
import rx.Observable;
import rx.Scheduler;
/**
* {@link ChangeAction} interceptor that intercepts errors, and records them in a model. It also provides
* {@link RetryActionInterceptor#executionLimits(EntityHolder)} method that can be used in {@link DifferenceResolver}
* evaluator to check if an action should be created, or the creation should be postponed.
* <p>
* TODO Current implementation operates on store model.
*/
public class RetryActionInterceptor implements TitusChangeActionInterceptor<Boolean> {
private static final String ATTR_RETRY_RECORD_PREFIX = "interceptor.retry.record.";
private final String attrName;
private final Retryer initialRetryPolicy;
private final Scheduler scheduler;
public RetryActionInterceptor(String name,
Retryer initialRetryPolicy,
Scheduler scheduler) {
this.attrName = ATTR_RETRY_RECORD_PREFIX + name;
this.initialRetryPolicy = initialRetryPolicy;
this.scheduler = scheduler;
}
@Override
public TitusChangeAction apply(TitusChangeAction changeAction) {
return new RetryChangeAction(changeAction);
}
@Override
public Boolean executionLimits(EntityHolder rootHolder) {
RetryRecord retryRecord = (RetryRecord) rootHolder.getAttributes().get(attrName);
if (retryRecord == null) {
return true;
}
long delayMs = retryRecord.getRetryPolicy().getDelayMs().orElse(-1L);
if (delayMs < 0) {
return true;
}
long pauseTime = retryRecord.getLastFailureTime() + delayMs;
return scheduler.now() >= pauseTime;
}
class RetryChangeAction extends TitusChangeAction {
private final TitusChangeAction delegate;
RetryChangeAction(TitusChangeAction delegate) {
super(delegate);
this.delegate = delegate;
}
@Override
public Observable<List<ModelActionHolder>> apply() {
return delegate.apply().map(modelActionHolders -> CollectionsExt.copyAndAdd(modelActionHolders, ModelActionHolder.store(new RemoveRetryRecord(delegate)))
).onErrorReturn(e -> Collections.singletonList(ModelActionHolder.store(new RetryModelUpdateAction(delegate, e))));
}
}
class RetryModelUpdateAction extends TitusModelAction {
RetryModelUpdateAction(TitusChangeAction delegate, Throwable e) {
super(
delegate.getTrigger(),
delegate.getId(),
"Report failure of: " + delegate.getSummary() + '(' + e.getMessage() + ')',
delegate.getCallMetadata()
);
}
@Override
public Optional<Pair<EntityHolder, EntityHolder>> apply(EntityHolder rootHolder) {
RetryRecord retryRecord = (RetryRecord) rootHolder.getAttributes().get(attrName);
RetryRecord newRecord;
long now = scheduler.now();
if (retryRecord == null) {
newRecord = new RetryRecord(initialRetryPolicy, now, 1);
} else if (!retryRecord.getRetryPolicy().getDelayMs().isPresent()) { // Retry limit reached
return Optional.empty();
} else {
// Only increment retry for actions that happened after the last failure time
long nextRetryTime = retryRecord.getLastFailureTime() + retryRecord.getRetryPolicy().getDelayMs().get();
int failureCount = nextRetryTime >= now ? retryRecord.getFailureCount() : retryRecord.getFailureCount() + 1;
newRecord = new RetryRecord(retryRecord.getRetryPolicy().retry(), now, failureCount);
}
EntityHolder newRoot = rootHolder.addTag(attrName, newRecord);
return Optional.of(Pair.of(newRoot, newRoot));
}
}
class RemoveRetryRecord extends TitusModelAction {
RemoveRetryRecord(TitusChangeAction delegate) {
super(
delegate.getTrigger(),
delegate.getId(),
"Cleaning up after successful action execution",
delegate.getCallMetadata()
);
}
@Override
public Optional<Pair<EntityHolder, EntityHolder>> apply(EntityHolder rootHolder) {
if (rootHolder.getAttributes().containsKey(attrName)) {
EntityHolder newRoot = rootHolder.removeTag(attrName);
return Optional.of(Pair.of(newRoot, newRoot));
}
return Optional.empty();
}
}
static class RetryRecord {
private final Retryer retryPolicy;
private final long lastFailureTime;
private final int failureCount;
RetryRecord(Retryer retryPolicy, long lastFailureTime, int failureCount) {
this.retryPolicy = retryPolicy;
this.lastFailureTime = lastFailureTime;
this.failureCount = failureCount;
}
Retryer getRetryPolicy() {
return retryPolicy;
}
long getLastFailureTime() {
return lastFailureTime;
}
int getFailureCount() {
return failureCount;
}
}
}
| 73 |
0 | Create_ds/titus-control-plane/titus-server-master/src/main/java/com/netflix/titus/master/jobmanager/service/common | Create_ds/titus-control-plane/titus-server-master/src/main/java/com/netflix/titus/master/jobmanager/service/common/interceptor/RateLimiterInterceptor.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.master.jobmanager.service.common.interceptor;
import java.util.Collections;
import java.util.List;
import com.netflix.titus.common.framework.reconciler.ChangeAction;
import com.netflix.titus.common.framework.reconciler.EntityHolder;
import com.netflix.titus.common.framework.reconciler.ModelActionHolder;
import com.netflix.titus.common.util.CollectionsExt;
import com.netflix.titus.common.util.limiter.tokenbucket.ImmutableTokenBucket;
import com.netflix.titus.common.util.tuple.Pair;
import com.netflix.titus.master.jobmanager.service.common.action.TitusChangeAction;
import com.netflix.titus.master.jobmanager.service.common.action.TitusModelAction;
/**
* {@link ChangeAction} interceptor that tracks and limits execution rate of an action. Rate limiting is controlled by
* the provided token bucket.
*/
public class RateLimiterInterceptor implements TitusChangeActionInterceptor<Long> {
private static final String ATTR_RATE_LIMITER_PREFIX = "interceptor.rateLimiter.";
private final String attrName;
private final ImmutableTokenBucket initialTokenBucket;
public RateLimiterInterceptor(String name, ImmutableTokenBucket tokenBucket) {
this.attrName = ATTR_RATE_LIMITER_PREFIX + name;
this.initialTokenBucket = tokenBucket;
}
@Override
public TitusChangeAction apply(TitusChangeAction delegate) {
return TitusChangeAction.newInterceptor("rateLimited", delegate)
.changeWithModelUpdates(self ->
delegate.apply().map(result -> handleSuccess(delegate, result)).onErrorReturn(e -> handleError(delegate, e))
);
}
private List<ModelActionHolder> handleSuccess(TitusChangeAction delegate, List<ModelActionHolder> result) {
return CollectionsExt.copyAndAdd(result, createRateLimiterModelAction(delegate));
}
private List<ModelActionHolder> handleError(TitusChangeAction delegate, Throwable error) {
return Collections.singletonList(createRateLimiterModelAction(delegate));
}
private ModelActionHolder createRateLimiterModelAction(TitusChangeAction delegate) {
TitusModelAction modelAction = TitusModelAction.newModelUpdate("rateLimiter(" + delegate.getName() + ')', delegate)
.summary("Acquire rate limiter token from its tokenBucket")
.jobMaybeUpdate(rootHolder -> {
ImmutableTokenBucket lastTokenBucket = (ImmutableTokenBucket) rootHolder.getAttributes().getOrDefault(attrName, initialTokenBucket);
return lastTokenBucket.tryTake().map(newBucket -> rootHolder.addTag(attrName, newBucket));
});
return ModelActionHolder.reference(modelAction);
}
@Override
public Long executionLimits(EntityHolder rootHolder) {
ImmutableTokenBucket lastTokenBucket = (ImmutableTokenBucket) rootHolder.getAttributes().getOrDefault(attrName, initialTokenBucket);
return lastTokenBucket.tryTake(0, Long.MAX_VALUE).map(Pair::getLeft).orElse(0L);
}
}
| 74 |
0 | Create_ds/titus-control-plane/titus-server-master/src/main/java/com/netflix/titus/master/jobmanager/service | Create_ds/titus-control-plane/titus-server-master/src/main/java/com/netflix/titus/master/jobmanager/service/batch/BatchDifferenceResolver.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.master.jobmanager.service.batch;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.Set;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;
import javax.inject.Inject;
import javax.inject.Named;
import javax.inject.Singleton;
import com.google.common.collect.ImmutableMap;
import com.netflix.titus.api.FeatureActivationConfiguration;
import com.netflix.titus.api.jobmanager.TaskAttributes;
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.JobDescriptor;
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.TaskState;
import com.netflix.titus.api.jobmanager.model.job.TaskStatus;
import com.netflix.titus.api.jobmanager.model.job.ext.BatchJobExt;
import com.netflix.titus.api.jobmanager.store.JobStore;
import com.netflix.titus.api.model.ApplicationSLA;
import com.netflix.titus.api.model.callmetadata.CallMetadata;
import com.netflix.titus.common.framework.reconciler.ChangeAction;
import com.netflix.titus.common.framework.reconciler.EntityHolder;
import com.netflix.titus.common.framework.reconciler.ReconciliationEngine;
import com.netflix.titus.common.runtime.TitusRuntime;
import com.netflix.titus.common.util.CollectionsExt;
import com.netflix.titus.common.util.limiter.tokenbucket.TokenBucket;
import com.netflix.titus.common.util.retry.Retryers;
import com.netflix.titus.common.util.time.Clock;
import com.netflix.titus.master.jobmanager.service.JobManagerConfiguration;
import com.netflix.titus.master.jobmanager.service.JobManagerUtil;
import com.netflix.titus.master.jobmanager.service.JobServiceRuntime;
import com.netflix.titus.master.jobmanager.service.VersionSupplier;
import com.netflix.titus.master.jobmanager.service.common.DifferenceResolverUtils;
import com.netflix.titus.master.jobmanager.service.common.action.TaskRetryers;
import com.netflix.titus.master.jobmanager.service.common.action.TitusChangeAction;
import com.netflix.titus.master.jobmanager.service.common.action.task.BasicJobActions;
import com.netflix.titus.master.jobmanager.service.common.action.task.BasicTaskActions;
import com.netflix.titus.master.jobmanager.service.common.action.task.KillInitiatedActions;
import com.netflix.titus.master.jobmanager.service.common.interceptor.RetryActionInterceptor;
import com.netflix.titus.master.jobmanager.service.event.JobManagerReconcilerEvent;
import com.netflix.titus.master.service.management.ApplicationSlaManagementService;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import rx.Scheduler;
import rx.schedulers.Schedulers;
import static com.netflix.titus.api.jobmanager.service.JobManagerConstants.RECONCILER_CALLMETADATA;
import static com.netflix.titus.master.jobmanager.service.batch.action.CreateOrReplaceBatchTaskActions.createOrReplaceTaskAction;
import static com.netflix.titus.master.jobmanager.service.common.DifferenceResolverUtils.getTaskContext;
import static com.netflix.titus.master.jobmanager.service.common.DifferenceResolverUtils.getUnassignedEbsVolumes;
import static com.netflix.titus.master.jobmanager.service.common.DifferenceResolverUtils.getUnassignedIpAllocations;
@Singleton
public class BatchDifferenceResolver implements ReconciliationEngine.DifferenceResolver<JobManagerReconcilerEvent> {
private static final Logger logger = LoggerFactory.getLogger(BatchDifferenceResolver.class);
private final JobManagerConfiguration configuration;
private final FeatureActivationConfiguration featureConfiguration;
private final ApplicationSlaManagementService capacityGroupService;
private final JobStore jobStore;
private final VersionSupplier versionSupplier;
private final RetryActionInterceptor storeWriteRetryInterceptor;
private final TokenBucket stuckInStateRateLimiter;
private final TitusRuntime titusRuntime;
private final Clock clock;
private final JobServiceRuntime runtime;
@Inject
public BatchDifferenceResolver(
JobManagerConfiguration configuration,
JobServiceRuntime runtime,
FeatureActivationConfiguration featureConfiguration,
ApplicationSlaManagementService capacityGroupService,
JobStore jobStore,
VersionSupplier versionSupplier,
@Named(JobManagerConfiguration.STUCK_IN_STATE_TOKEN_BUCKET) TokenBucket stuckInStateRateLimiter,
TitusRuntime titusRuntime) {
this(configuration, runtime, featureConfiguration,
capacityGroupService, jobStore, versionSupplier,
stuckInStateRateLimiter,
titusRuntime, Schedulers.computation()
);
}
public BatchDifferenceResolver(
JobManagerConfiguration configuration,
JobServiceRuntime runtime,
FeatureActivationConfiguration featureConfiguration,
ApplicationSlaManagementService capacityGroupService,
JobStore jobStore,
VersionSupplier versionSupplier,
@Named(JobManagerConfiguration.STUCK_IN_STATE_TOKEN_BUCKET) TokenBucket stuckInStateRateLimiter,
TitusRuntime titusRuntime,
Scheduler scheduler) {
this.configuration = configuration;
this.runtime = runtime;
this.featureConfiguration = featureConfiguration;
this.capacityGroupService = capacityGroupService;
this.jobStore = jobStore;
this.versionSupplier = versionSupplier;
this.stuckInStateRateLimiter = stuckInStateRateLimiter;
this.titusRuntime = titusRuntime;
this.clock = titusRuntime.getClock();
this.storeWriteRetryInterceptor = new RetryActionInterceptor(
"storeWrite",
Retryers.exponentialBackoff(500, 5000, TimeUnit.MILLISECONDS),
scheduler
);
}
@Override
public List<ChangeAction> apply(ReconciliationEngine<JobManagerReconcilerEvent> engine) {
List<ChangeAction> actions = new ArrayList<>();
BatchJobView refJobView = new BatchJobView(engine.getReferenceView());
EntityHolder storeModel = engine.getStoreView();
int activeNotStartedTasks = DifferenceResolverUtils.countActiveNotStartedTasks(refJobView.getJobHolder(), engine.getRunningView());
AtomicInteger allowedNewTasks = new AtomicInteger(Math.max(0, configuration.getActiveNotStartedTasksLimit() - activeNotStartedTasks));
actions.addAll(applyStore(engine, refJobView, storeModel, allowedNewTasks));
actions.addAll(applyRuntime(engine, refJobView, engine.getRunningView(), storeModel, allowedNewTasks));
if (actions.isEmpty()) {
actions.addAll(removeCompletedJob(refJobView, engine.getReferenceView(), storeModel, jobStore, versionSupplier));
}
return actions;
}
private List<ChangeAction> applyRuntime(ReconciliationEngine<JobManagerReconcilerEvent> engine, BatchJobView refJobView, EntityHolder runningModel, EntityHolder storeModel, AtomicInteger allowedNewTasks) {
List<ChangeAction> actions = new ArrayList<>();
EntityHolder referenceModel = refJobView.getJobHolder();
BatchJobView runningJobView = new BatchJobView(runningModel);
if (DifferenceResolverUtils.hasJobState(referenceModel, JobState.KillInitiated)) {
List<ChangeAction> killInitiatedActions = KillInitiatedActions.reconcilerInitiatedAllTasksKillInitiated(
engine, runtime, jobStore, TaskStatus.REASON_TASK_KILLED,
"Killing task as its job is in KillInitiated state", configuration.getConcurrentReconcilerStoreUpdateLimit(),
versionSupplier,
titusRuntime
);
if (killInitiatedActions.isEmpty()) {
return DifferenceResolverUtils.findTaskStateTimeouts(engine, runningJobView, configuration, runtime, jobStore, versionSupplier, stuckInStateRateLimiter, titusRuntime);
}
return killInitiatedActions;
} else if (DifferenceResolverUtils.hasJobState(referenceModel, JobState.Finished)) {
return Collections.emptyList();
}
List<ChangeAction> numberOfTaskAdjustingActions = findJobSizeInconsistencies(refJobView, storeModel, allowedNewTasks);
actions.addAll(numberOfTaskAdjustingActions);
if (numberOfTaskAdjustingActions.isEmpty()) {
actions.addAll(findMissingRunningTasks(engine, refJobView, runningJobView));
}
actions.addAll(DifferenceResolverUtils.findTaskStateTimeouts(engine, runningJobView, configuration, runtime, jobStore, versionSupplier, stuckInStateRateLimiter, titusRuntime));
return actions;
}
/**
* Check that the reference job has the required number of tasks.
*/
private List<ChangeAction> findJobSizeInconsistencies(BatchJobView refJobView, EntityHolder storeModel, AtomicInteger allowedNewTasks) {
boolean canUpdateStore = storeWriteRetryInterceptor.executionLimits(storeModel);
List<String> unassignedIpAllocations = getUnassignedIpAllocations(refJobView);
List<String> unassignedEbsVolumeIds = getUnassignedEbsVolumes(refJobView);
if (canUpdateStore && refJobView.getTasks().size() < refJobView.getRequiredSize()) {
List<ChangeAction> missingTasks = new ArrayList<>();
for (int i = 0; i < refJobView.getRequiredSize() && allowedNewTasks.get() > 0; i++) {
if (!refJobView.getIndexes().contains(i)) {
allowedNewTasks.decrementAndGet();
logger.info("Adding missing task: jobId={}, index={}, requiredSize={}, currentSize={}", refJobView.getJob().getId(), i, refJobView.getRequiredSize(), refJobView.getTasks().size());
createNewTaskAction(refJobView, i, Optional.empty(), unassignedIpAllocations, unassignedEbsVolumeIds).ifPresent(missingTasks::add);
}
}
return missingTasks;
}
return Collections.emptyList();
}
private Optional<TitusChangeAction> createNewTaskAction(BatchJobView refJobView, int taskIndex, Optional<EntityHolder> previousTask, List<String> unassignedIpAllocations, List<String> ebsVolumeIds) {
// Safety check
long numberOfNotFinishedTasks = refJobView.getJobHolder().getChildren().stream()
.filter(holder -> TaskState.isRunning(((Task) holder.getEntity()).getStatus().getState()))
.count();
if (numberOfNotFinishedTasks >= refJobView.getRequiredSize()) {
titusRuntime.getCodeInvariants().inconsistent(
"Batch job reconciler attempts to create too many tasks: jobId=%s, requiredSize=%s, current=%s",
refJobView.getJob().getId(), refJobView.getRequiredSize(), numberOfNotFinishedTasks
);
return Optional.empty();
}
Map<String, String> taskContext = getTaskContext(previousTask, unassignedIpAllocations, ebsVolumeIds);
JobDescriptor jobDescriptor = refJobView.getJob().getJobDescriptor();
ApplicationSLA capacityGroupDescriptor = JobManagerUtil.getCapacityGroupDescriptor(jobDescriptor, capacityGroupService);
String resourcePool = capacityGroupDescriptor.getResourcePool();
taskContext = CollectionsExt.copyAndAdd(taskContext, ImmutableMap.of(
TaskAttributes.TASK_ATTRIBUTES_RESOURCE_POOL, resourcePool,
TaskAttributes.TASK_ATTRIBUTES_TIER, capacityGroupDescriptor.getTier().name()));
TitusChangeAction storeAction = storeWriteRetryInterceptor.apply(
createOrReplaceTaskAction(runtime, jobStore, refJobView.getJobHolder(), taskIndex, versionSupplier, clock, taskContext)
);
return Optional.of(storeAction);
}
/**
* Check that for each reference job task, there is a corresponding running task.
*/
private List<ChangeAction> findMissingRunningTasks(ReconciliationEngine<JobManagerReconcilerEvent> engine, BatchJobView refJobView, BatchJobView runningJobView) {
List<ChangeAction> missingTasks = new ArrayList<>();
List<BatchJobTask> tasks = refJobView.getTasks();
for (BatchJobTask refTask : tasks) {
BatchJobTask runningTask = runningJobView.getTaskById(refTask.getId());
if (runtime.getComputeProvider().isReadyForScheduling()) {
// TODO This complexity exists due to the way Fenzo is initialized on bootstrap. This code can be simplified one we move off Fenzo.
if (runningTask == null || (refTask.getStatus().getState() == TaskState.Accepted && !TaskStatus.hasPod(refTask))) {
missingTasks.add(BasicTaskActions.launchTaskInKube(
configuration,
runtime,
engine,
runningJobView.getJob(),
refTask,
RECONCILER_CALLMETADATA.toBuilder().withCallReason("Launching task in Kube").build(),
versionSupplier,
titusRuntime
));
}
}
}
return missingTasks;
}
private List<ChangeAction> applyStore(ReconciliationEngine<JobManagerReconcilerEvent> engine, BatchJobView refJobView, EntityHolder storeJob, AtomicInteger allowedNewTasks) {
if (!storeWriteRetryInterceptor.executionLimits(storeJob)) {
return Collections.emptyList();
}
List<ChangeAction> actions = new ArrayList<>();
EntityHolder refJobHolder = refJobView.getJobHolder();
Job<BatchJobExt> refJob = refJobHolder.getEntity();
if (!refJobHolder.getEntity().equals(storeJob.getEntity())) {
actions.add(storeWriteRetryInterceptor.apply(BasicJobActions.updateJobInStore(engine, jobStore)));
}
boolean isJobTerminating = refJob.getStatus().getState() == JobState.KillInitiated;
for (EntityHolder referenceTask : refJobHolder.getChildren()) {
Optional<EntityHolder> storeHolder = storeJob.findById(referenceTask.getId());
boolean refAndStoreInSync = storeHolder.isPresent() && DifferenceResolverUtils.areEquivalent(storeHolder.get(), referenceTask);
boolean shouldRetry = !isJobTerminating && DifferenceResolverUtils.shouldRetry(refJob, referenceTask.getEntity()) && allowedNewTasks.get() > 0;
if (refAndStoreInSync) {
BatchJobTask storeTask = storeHolder.get().getEntity();
if (shouldRetry && TaskRetryers.shouldRetryNow(referenceTask, clock)) {
logger.info("Retrying task: oldTaskId={}, index={}", referenceTask.getId(), storeTask.getIndex());
createNewTaskAction(refJobView, storeTask.getIndex(), Optional.of(referenceTask), Collections.emptyList(), Collections.emptyList()).ifPresent(actions::add);
}
} else {
Task task = referenceTask.getEntity();
CallMetadata callMetadata = RECONCILER_CALLMETADATA.toBuilder().withCallReason("Writing runtime state changes to store").build();
actions.add(storeWriteRetryInterceptor.apply(BasicTaskActions.writeReferenceTaskToStore(jobStore, engine, task.getId(), callMetadata, titusRuntime)));
}
// Both current and delayed retries are counted
if (shouldRetry) {
allowedNewTasks.decrementAndGet();
}
}
return actions;
}
private static List<ChangeAction> removeCompletedJob(BatchJobView refJobView,
EntityHolder referenceModel,
EntityHolder storeModel,
JobStore titusStore, VersionSupplier versionSupplier) {
// Finished: do the final cleanup
if (DifferenceResolverUtils.hasJobState(referenceModel, JobState.Finished)) {
if (!BasicJobActions.isClosed(referenceModel)) {
return Collections.singletonList(BasicJobActions.removeJobFromStore(referenceModel.getEntity(), titusStore));
}
return Collections.emptyList();
}
// All tasks executed or KillInitiated
int notStartedTasks = refJobView.getRequiredSize() - refJobView.getTasks().size();
if (notStartedTasks <= 0 || DifferenceResolverUtils.hasJobState(referenceModel, JobState.KillInitiated)) {
if (DifferenceResolverUtils.allDone(storeModel)) {
return Collections.singletonList(BasicJobActions.completeJob(referenceModel.getId(), versionSupplier));
}
}
return Collections.emptyList();
}
static class BatchJobView extends DifferenceResolverUtils.JobView<BatchJobExt, BatchJobTask> {
private final Set<Integer> indexes;
BatchJobView(EntityHolder jobHolder) {
super(jobHolder);
this.indexes = collectIndexes();
}
Set<Integer> getIndexes() {
return indexes;
}
private Set<Integer> collectIndexes() {
Set<Integer> indexes = new HashSet<>();
for (BatchJobTask task : getTasks()) {
indexes.add(task.getIndex());
}
return indexes;
}
}
}
| 75 |
0 | Create_ds/titus-control-plane/titus-server-master/src/main/java/com/netflix/titus/master/jobmanager/service/batch | Create_ds/titus-control-plane/titus-server-master/src/main/java/com/netflix/titus/master/jobmanager/service/batch/action/CreateOrReplaceBatchTaskActions.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.master.jobmanager.service.batch.action;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.UUID;
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.JobFunctions;
import com.netflix.titus.api.jobmanager.model.job.LogStorageInfos;
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.api.jobmanager.service.V3JobOperations.Trigger;
import com.netflix.titus.api.jobmanager.store.JobStore;
import com.netflix.titus.common.framework.reconciler.EntityHolder;
import com.netflix.titus.common.framework.reconciler.ModelActionHolder;
import com.netflix.titus.common.util.CollectionsExt;
import com.netflix.titus.common.util.retry.Retryer;
import com.netflix.titus.common.util.time.Clock;
import com.netflix.titus.master.jobmanager.service.JobServiceRuntime;
import com.netflix.titus.master.jobmanager.service.VersionSupplier;
import com.netflix.titus.master.jobmanager.service.common.action.JobEntityHolders;
import com.netflix.titus.master.jobmanager.service.common.action.TaskRetryers;
import com.netflix.titus.master.jobmanager.service.common.action.TitusChangeAction;
import com.netflix.titus.master.jobmanager.service.common.action.TitusModelAction;
import rx.Observable;
/**
* Create a new task or replace a completed task, and persist it into the store. Update reference/store models.
*/
public class CreateOrReplaceBatchTaskActions {
public static TitusChangeAction createOrReplaceTaskAction(JobServiceRuntime context,
JobStore jobStore,
EntityHolder jobHolder,
int index,
VersionSupplier versionSupplier,
Clock clock,
Map<String, String> taskContext) {
return jobHolder.getChildren().stream()
.filter(taskHolder -> {
BatchJobTask task = taskHolder.getEntity();
return task.getIndex() == index;
})
.findFirst()
.map(taskHolder -> createResubmittedTaskChangeAction(jobHolder, taskHolder, context, jobStore, versionSupplier, clock, taskContext))
.orElseGet(() -> createOriginalTaskChangeAction(jobHolder.getEntity(), index, jobStore, versionSupplier, clock, taskContext));
}
private static TitusChangeAction createOriginalTaskChangeAction(Job<BatchJobExt> job, int index, JobStore jobStore, VersionSupplier versionSupplier,
Clock clock, Map<String, String> taskContext) {
Retryer newRetryer = JobFunctions.retryer(job);
BatchJobTask newTask = createNewBatchTask(job, index, clock.wallTime(), versionSupplier, taskContext);
return TitusChangeAction.newAction("createOrReplaceTask")
.id(newTask.getId())
.trigger(Trigger.Reconciler)
.summary(
String.format("Creating new task at index %d in DB store: %s", newTask.getIndex(), newTask.getId())
)
.changeWithModelUpdates(self -> jobStore.storeTask(newTask).andThen(Observable.just(createNewTaskModelAction(self, newTask, Optional.empty(), newRetryer))));
}
private static TitusChangeAction createResubmittedTaskChangeAction(EntityHolder jobHolder,
EntityHolder taskHolder,
JobServiceRuntime context,
JobStore jobStore,
VersionSupplier versionSupplier,
Clock clock,
Map<String, String> taskContext) {
BatchJobTask oldTask = taskHolder.getEntity();
long timeInStartedState = JobFunctions.getTimeInState(oldTask, TaskState.Started, clock).orElse(0L);
Retryer nextTaskRetryer = timeInStartedState >= context.getConfiguration().getTaskRetryerResetTimeMs()
? JobFunctions.retryer(jobHolder.getEntity())
: TaskRetryers.getNextTaskRetryer(context::getSystemRetryer, jobHolder.getEntity(), taskHolder);
BatchJobTask newTask = createBatchTaskReplacement(jobHolder.getEntity(), oldTask, versionSupplier, clock, taskContext);
String summary = String.format(
"Replacing task at index %d (resubmit=%d) in DB store: old=%s, new=%s",
oldTask.getIndex(),
newTask.getResubmitNumber(),
oldTask.getId(),
newTask.getId()
);
return TitusChangeAction.newAction("createOrReplaceTask")
.id(newTask.getId())
.trigger(Trigger.Reconciler)
.summary(summary)
.changeWithModelUpdates(self -> jobStore.replaceTask(oldTask, newTask).andThen(Observable.just(createTaskResubmitModelActions(self, oldTask, newTask, nextTaskRetryer))));
}
private static List<ModelActionHolder> createNewTaskModelAction(TitusChangeAction.Builder changeActionBuilder,
BatchJobTask newTask,
Optional<BatchJobTask> replacementOf,
Retryer nextTaskRetryer) {
List<ModelActionHolder> actions = new ArrayList<>();
TitusModelAction.Builder modelBuilder = TitusModelAction.newModelUpdate(changeActionBuilder).summary("Creating new task entity holder");
EntityHolder taskHolder = EntityHolder.newRoot(newTask.getId(), newTask).addTag(TaskRetryers.ATTR_TASK_RETRY, nextTaskRetryer);
if (replacementOf.isPresent()) {
taskHolder = taskHolder.addTag(JobEntityHolders.ATTR_REPLACEMENT_OF, replacementOf.get());
}
actions.add(ModelActionHolder.reference(modelBuilder.addTaskHolder(taskHolder)));
actions.add(ModelActionHolder.store(modelBuilder.taskUpdate(newTask)));
return actions;
}
private static List<ModelActionHolder> createTaskResubmitModelActions(TitusChangeAction.Builder changeActionBuilder, BatchJobTask oldTask, BatchJobTask newTask, Retryer nextTaskRetryer) {
List<ModelActionHolder> actions = new ArrayList<>();
TitusModelAction removeTaskAction = TitusModelAction.newModelUpdate(changeActionBuilder)
.summary("Removing replaced task: " + oldTask.getId())
.removeTask(oldTask);
actions.addAll(ModelActionHolder.allModels(removeTaskAction));
boolean shouldRetry = !TaskStatus.REASON_NORMAL.equals(oldTask.getStatus().getReasonCode());
if (shouldRetry) {
actions.addAll(createNewTaskModelAction(changeActionBuilder, newTask, Optional.of(oldTask), nextTaskRetryer));
}
return actions;
}
private static BatchJobTask createNewBatchTask(Job<?> job, int index, long timestamp, VersionSupplier versionSupplier,
Map<String, String> taskContext) {
String taskId = UUID.randomUUID().toString();
return BatchJobTask.newBuilder()
.withId(taskId)
.withJobId(job.getId())
.withIndex(index)
.withStatus(TaskStatus.newBuilder().withState(TaskState.Accepted).withReasonCode(TaskStatus.REASON_NORMAL).withTimestamp(timestamp).build())
.withOriginalId(taskId)
.withCellInfo(job)
.addAllToTaskContext(CollectionsExt.merge(taskContext, LogStorageInfos.toS3LogLocationTaskContext(job)))
.withVersion(versionSupplier.nextVersion())
.build();
}
private static BatchJobTask createBatchTaskReplacement(Job<?> job, BatchJobTask oldTask, VersionSupplier versionSupplier,
Clock clock, Map<String, String> taskContext) {
String taskId = UUID.randomUUID().toString();
return BatchJobTask.newBuilder()
.withId(taskId)
.withJobId(oldTask.getJobId())
.withIndex(oldTask.getIndex())
.withStatus(TaskStatus.newBuilder().withState(TaskState.Accepted).withReasonCode(TaskStatus.REASON_NORMAL).withTimestamp(clock.wallTime()).build())
.withOriginalId(oldTask.getOriginalId())
.withCellInfo(oldTask)
.withResubmitOf(oldTask.getId())
.withResubmitNumber(oldTask.getResubmitNumber() + 1)
.withSystemResubmitNumber(TaskStatus.hasSystemError(oldTask) ? oldTask.getSystemResubmitNumber() + 1 : oldTask.getSystemResubmitNumber())
.withEvictionResubmitNumber(TaskStatus.isEvicted(oldTask) ? oldTask.getEvictionResubmitNumber() + 1 : oldTask.getEvictionResubmitNumber())
.addAllToTaskContext(CollectionsExt.merge(taskContext, LogStorageInfos.toS3LogLocationTaskContext(job)))
.withVersion(versionSupplier.nextVersion())
.build();
}
}
| 76 |
0 | Create_ds/titus-control-plane/titus-server-master/src/main/java/com/netflix/titus/master/jobmanager/service | Create_ds/titus-control-plane/titus-server-master/src/main/java/com/netflix/titus/master/jobmanager/service/service/ScaleDownEvaluator.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.master.jobmanager.service.service;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.stream.Collectors;
import com.netflix.titus.api.jobmanager.TaskAttributes;
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.common.runtime.TitusRuntime;
import com.netflix.titus.common.util.CollectionsExt;
import com.netflix.titus.common.util.tuple.Pair;
/**
* Helper class for evaluating which tasks from a job active task set should be terminated during scale down process.
* Terminating tasks in random order might result in an undesired task setup, like having all tasks running on one agent
* instance (availability issue) or in a single zone.
* <p>
* As Titus does not support scale down polices that would allow a user to define explicitly the termination rules, we
* provide here a set of reasonable rules, that should give much better behavior than blind task termination.
*
* <h1>Termination steps</h1>
* An active task can be in one of the following states: Active, Launched, StartInitiated, Started and KillInitiated.
* To maximize system availability, we consider for termination tasks in Started state only if there are no tasks in other
* states.
*
* <h2>Step 1: scale down task in KillInitiated state</h2>
* As tasks in this state are in the termination process already, scaling them down means they should not be restarted after
* they move to Finished state.
*
* <h2>Step 2: scale down tasks in Accepted state</h2>
* These task have no resources allocated yet, and it is not guaranteed that they can be successfully started.
* Tasks in Accepted state are not yet associated with any agent, so no additional rules must be applied here.
*
* <h2>Step 3: scale down tasks in Launched and StartInitiated states</h2>
* These states can be considered as equivalent. The group of tasks with these states should be evaluated according
* to rules defined in 'Equivalent group termination rules' in section below.
*
* <h2>Step 4: scale down tasks in Started state</h2>
* As in step 3, this task set should be evaluated according to rules defined in 'Equivalent group termination rules'.
*
* <h1>Equivalent group termination rules</h1>
* <p>
* The selection process described below is applied repeatedly until the desired number of tasks is terminated. At each
* step a subset of tasks is selected. The last step ('Terminate oldest task first'), makes final selection.
*
* <h2>Scale down largest groups of tasks on an agent</h2>
* To maximize availability we should eliminate large groups of tasks running on the same agent.
*
* <h2>Enforce zone balancing</h2>
* We want our tasks to be zone balanced (if applicable), If one zone runs more tasks than the other, we should terminate
* tasks in this zone first.
*
* <h2>Terminate oldest task first</h2>
* From the given collection of tasks, select the task with the oldest creation timestamp and terminate it.
* If there are more tasks to terminate, restart the evaluation process.
*/
class ScaleDownEvaluator {
static List<ServiceJobTask> selectTasksToTerminate(List<ServiceJobTask> allTasks, int expectedSize, TitusRuntime titusRuntime) {
int targetTerminateCount = allTasks.size() - expectedSize;
if (targetTerminateCount <= 0) {
return Collections.emptyList();
}
List<ServiceJobTask> tasksToKill = new ArrayList<>();
// Step 1: scale down task in KillInitiated state
Pair<List<ServiceJobTask>, List<ServiceJobTask>> killInitiatedAndRunnableGroups = splitIntoKillInitiatedAndRunnableGroups(allTasks);
if (appendCandidatesToTerminate(tasksToKill, killInitiatedAndRunnableGroups.getLeft(), targetTerminateCount)) {
return tasksToKill;
}
List<ServiceJobTask> runnableTasks = killInitiatedAndRunnableGroups.getRight();
// Step 2: scale down tasks in Accepted state
Pair<List<ServiceJobTask>, List<ServiceJobTask>> acceptedAndPlacedOnAgentsGroup = splitIntoAcceptedAndPlacedOnAgentsGroup(runnableTasks);
if (appendCandidatesToTerminate(tasksToKill, acceptedAndPlacedOnAgentsGroup.getLeft(), targetTerminateCount)) {
return tasksToKill;
}
List<ServiceJobTask> tasksOnAgent = acceptedAndPlacedOnAgentsGroup.getRight();
// Step 3: scale down tasks in Launched and StartInitiated states
Pair<List<ServiceJobTask>, List<ServiceJobTask>> notStartedAndStartedTaskGroups = splitIntoNotStartedAndStartedTaskGroups(tasksOnAgent);
List<ServiceJobTask> notStartedToRemove = selectTasksToTerminateInEquivalenceGroup(notStartedAndStartedTaskGroups.getLeft(), targetTerminateCount - tasksToKill.size(), titusRuntime);
if (appendCandidatesToTerminate(tasksToKill, notStartedToRemove, targetTerminateCount)) {
return tasksToKill;
}
List<ServiceJobTask> startedTasks = notStartedAndStartedTaskGroups.getRight();
// Step 4: scale down tasks in Started state
List<ServiceJobTask> startedToRemove = selectTasksToTerminateInEquivalenceGroup(startedTasks, targetTerminateCount - tasksToKill.size(), titusRuntime);
appendCandidatesToTerminate(tasksToKill, startedToRemove, targetTerminateCount);
// Extra check in case we messed up somewhere.
if (tasksToKill.size() != targetTerminateCount) {
titusRuntime.getCodeInvariants().inconsistent("Wrong number of tasks to terminate %s (expected) != %s (actual). Got list: %s", targetTerminateCount, tasksToKill.size(), tasksToKill);
if (tasksToKill.size() > targetTerminateCount) {
tasksToKill = tasksToKill.subList(0, targetTerminateCount);
}
}
return tasksToKill;
}
/**
* Add candidate tasks to the provided accumulator, up to the request number of tasks to terminate.
*
* @return true if the accumulator (tasks to terminate list) reached its maximum size, false otherwise
*/
private static boolean appendCandidatesToTerminate(List<ServiceJobTask> accumulator, List<ServiceJobTask> candidates, int targetTerminateCount) {
if (accumulator.size() + candidates.size() >= targetTerminateCount) {
accumulator.addAll(candidates.subList(0, targetTerminateCount - accumulator.size()));
return true;
}
accumulator.addAll(candidates);
return false;
}
private static Pair<List<ServiceJobTask>, List<ServiceJobTask>> splitIntoKillInitiatedAndRunnableGroups(List<ServiceJobTask> tasks) {
return CollectionsExt.split(tasks, t -> t.getStatus().getState() == TaskState.KillInitiated);
}
private static Pair<List<ServiceJobTask>, List<ServiceJobTask>> splitIntoAcceptedAndPlacedOnAgentsGroup(List<ServiceJobTask> tasks) {
return CollectionsExt.split(tasks, t -> t.getStatus().getState() == TaskState.Accepted);
}
private static Pair<List<ServiceJobTask>, List<ServiceJobTask>> splitIntoNotStartedAndStartedTaskGroups(List<ServiceJobTask> tasks) {
return CollectionsExt.split(tasks, t -> t.getStatus().getState() != TaskState.Started);
}
private static List<ServiceJobTask> selectTasksToTerminateInEquivalenceGroup(List<ServiceJobTask> allTasks, int targetTerminateCount, TitusRuntime titusRuntime) {
List<ServiceJobTask> tasksToKill = new ArrayList<>();
Region region = new Region(allTasks);
while (tasksToKill.size() < targetTerminateCount && region.hasMoreTasks()) {
// Step 1: select largest groups of tasks to scale down
int largestGroup = region.getLargestTaskGroup();
// Step 2: kill tasks from the largest groups, trying to maintain zone balancing
boolean hasMore = true;
while (tasksToKill.size() < targetTerminateCount && hasMore) {
Optional<Zone> zoneOpt = region.getLargestZoneWithTaskGroupSize(largestGroup);
if (hasMore = zoneOpt.isPresent()) {
// Step 3: remove oldest task
Optional<ServiceJobTask> removedTask = zoneOpt.get().removeOldestTaskFromLargestTaskGroup();
removedTask.ifPresent(tasksToKill::add);
if (!removedTask.isPresent()) {
titusRuntime.getCodeInvariants().inconsistent("Expected task, but found nothing. Terminating evaluation loop of job %s", allTasks.get(0).getJobId());
return tasksToKill;
}
}
}
}
return tasksToKill;
}
static class Region {
private final Map<String, Zone> zones;
Region(List<ServiceJobTask> allTasks) {
Map<String, List<ServiceJobTask>> byZone = new HashMap<>();
allTasks.forEach(task -> byZone.computeIfAbsent(toZoneId(task), t -> new ArrayList<>()).add(task));
this.zones = byZone.entrySet().stream().collect(Collectors.toMap(Map.Entry::getKey, e -> new Zone(e.getValue())));
}
String toZoneId(Task task) {
return task.getTaskContext().getOrDefault(TaskAttributes.TASK_ATTRIBUTES_AGENT_ZONE, "default");
}
int getLargestTaskGroup() {
return zones.values().stream().mapToInt(Zone::getLargestTaskGroupSize).max().orElse(0);
}
Optional<Zone> getLargestZoneWithTaskGroupSize(int largestGroup) {
Zone selectedZone = null;
for (Zone zone : zones.values()) {
if (zone.getLargestTaskGroupSize() >= largestGroup) {
if (selectedZone == null) {
selectedZone = zone;
} else {
if (selectedZone.getTaskCount() < zone.getTaskCount()) {
selectedZone = zone;
}
}
}
}
return Optional.ofNullable(selectedZone);
}
boolean hasMoreTasks() {
return zones.values().stream().anyMatch(z -> z.getTaskCount() > 0);
}
}
static class Zone {
private final Map<String, List<ServiceJobTask>> tasksByAgentId;
private int taskCount;
Zone(List<ServiceJobTask> tasks) {
this.taskCount = tasks.size();
this.tasksByAgentId = new HashMap<>();
tasks.forEach(task -> tasksByAgentId.computeIfAbsent(toAgentId(task), t -> new ArrayList<>()).add(task));
}
String toAgentId(Task task) {
return task.getTaskContext().getOrDefault(TaskAttributes.TASK_ATTRIBUTES_AGENT_INSTANCE_ID, "default");
}
int getLargestTaskGroupSize() {
return tasksByAgentId.values().stream().mapToInt(List::size).max().orElse(0);
}
Optional<ServiceJobTask> removeOldestTaskFromLargestTaskGroup() {
if (taskCount == 0) {
return Optional.empty();
}
return tasksByAgentId.entrySet().stream()
.max(Comparator.comparingInt(l -> l.getValue().size()))
.map(largestGroupEntry -> {
List<ServiceJobTask> tasks = largestGroupEntry.getValue();
int bestIdx = 0;
long bestTimestamp = tasks.get(0).getStatus().getTimestamp();
for (int i = 1; i < tasks.size(); i++) {
long currentTimestamp = tasks.get(i).getStatus().getTimestamp();
if (currentTimestamp < bestTimestamp) {
bestIdx = i;
bestTimestamp = currentTimestamp;
}
}
taskCount--;
return tasks.remove(bestIdx);
}
);
}
int getTaskCount() {
return taskCount;
}
}
}
| 77 |
0 | Create_ds/titus-control-plane/titus-server-master/src/main/java/com/netflix/titus/master/jobmanager/service | Create_ds/titus-control-plane/titus-server-master/src/main/java/com/netflix/titus/master/jobmanager/service/service/ServiceDifferenceResolver.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.master.jobmanager.service.service;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.stream.Collectors;
import javax.inject.Inject;
import javax.inject.Named;
import javax.inject.Singleton;
import com.google.common.collect.ImmutableMap;
import com.netflix.titus.api.FeatureActivationConfiguration;
import com.netflix.titus.api.jobmanager.TaskAttributes;
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.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.ext.ServiceJobExt;
import com.netflix.titus.api.jobmanager.store.JobStore;
import com.netflix.titus.api.model.ApplicationSLA;
import com.netflix.titus.api.model.callmetadata.CallMetadata;
import com.netflix.titus.common.framework.reconciler.ChangeAction;
import com.netflix.titus.common.framework.reconciler.EntityHolder;
import com.netflix.titus.common.framework.reconciler.ReconciliationEngine;
import com.netflix.titus.common.runtime.TitusRuntime;
import com.netflix.titus.common.util.CollectionsExt;
import com.netflix.titus.common.util.limiter.tokenbucket.TokenBucket;
import com.netflix.titus.common.util.retry.Retryers;
import com.netflix.titus.common.util.time.Clock;
import com.netflix.titus.master.jobmanager.service.JobManagerConfiguration;
import com.netflix.titus.master.jobmanager.service.JobManagerUtil;
import com.netflix.titus.master.jobmanager.service.JobServiceRuntime;
import com.netflix.titus.master.jobmanager.service.VersionSupplier;
import com.netflix.titus.master.jobmanager.service.common.DifferenceResolverUtils;
import com.netflix.titus.master.jobmanager.service.common.action.TaskRetryers;
import com.netflix.titus.master.jobmanager.service.common.action.TitusChangeAction;
import com.netflix.titus.master.jobmanager.service.common.action.task.BasicJobActions;
import com.netflix.titus.master.jobmanager.service.common.action.task.BasicTaskActions;
import com.netflix.titus.master.jobmanager.service.common.action.task.KillInitiatedActions;
import com.netflix.titus.master.jobmanager.service.common.interceptor.RetryActionInterceptor;
import com.netflix.titus.master.jobmanager.service.event.JobManagerReconcilerEvent;
import com.netflix.titus.master.service.management.ApplicationSlaManagementService;
import rx.Scheduler;
import rx.schedulers.Schedulers;
import static com.netflix.titus.api.jobmanager.service.JobManagerConstants.RECONCILER_CALLMETADATA;
import static com.netflix.titus.master.jobmanager.service.common.DifferenceResolverUtils.areEquivalent;
import static com.netflix.titus.master.jobmanager.service.common.DifferenceResolverUtils.findTaskStateTimeouts;
import static com.netflix.titus.master.jobmanager.service.common.DifferenceResolverUtils.getTaskContext;
import static com.netflix.titus.master.jobmanager.service.common.DifferenceResolverUtils.getUnassignedEbsVolumes;
import static com.netflix.titus.master.jobmanager.service.common.DifferenceResolverUtils.getUnassignedIpAllocations;
import static com.netflix.titus.master.jobmanager.service.common.DifferenceResolverUtils.hasJobState;
import static com.netflix.titus.master.jobmanager.service.common.DifferenceResolverUtils.isTerminating;
import static com.netflix.titus.master.jobmanager.service.service.action.BasicServiceTaskActions.removeFinishedServiceTaskAction;
import static com.netflix.titus.master.jobmanager.service.service.action.CreateOrReplaceServiceTaskActions.createOrReplaceTaskAction;
@Singleton
public class ServiceDifferenceResolver implements ReconciliationEngine.DifferenceResolver<JobManagerReconcilerEvent> {
private final JobManagerConfiguration configuration;
private final FeatureActivationConfiguration featureConfiguration;
private final ApplicationSlaManagementService capacityGroupService;
private final JobStore jobStore;
private final VersionSupplier versionSupplier;
private final RetryActionInterceptor storeWriteRetryInterceptor;
private final TokenBucket stuckInStateRateLimiter;
private final TitusRuntime titusRuntime;
private final Clock clock;
private final JobServiceRuntime runtime;
@Inject
public ServiceDifferenceResolver(
JobManagerConfiguration configuration,
JobServiceRuntime runtime,
FeatureActivationConfiguration featureConfiguration,
ApplicationSlaManagementService capacityGroupService,
JobStore jobStore,
VersionSupplier versionSupplier,
@Named(JobManagerConfiguration.STUCK_IN_STATE_TOKEN_BUCKET) TokenBucket stuckInStateRateLimiter,
TitusRuntime titusRuntime) {
this(configuration, runtime, featureConfiguration,
capacityGroupService, jobStore, versionSupplier,
stuckInStateRateLimiter,
titusRuntime, Schedulers.computation()
);
}
public ServiceDifferenceResolver(
JobManagerConfiguration configuration,
JobServiceRuntime runtime,
FeatureActivationConfiguration featureConfiguration,
ApplicationSlaManagementService capacityGroupService,
JobStore jobStore,
VersionSupplier versionSupplier,
@Named(JobManagerConfiguration.STUCK_IN_STATE_TOKEN_BUCKET) TokenBucket stuckInStateRateLimiter,
TitusRuntime titusRuntime,
Scheduler scheduler) {
this.runtime = runtime;
this.configuration = configuration;
this.featureConfiguration = featureConfiguration;
this.capacityGroupService = capacityGroupService;
this.jobStore = jobStore;
this.versionSupplier = versionSupplier;
this.stuckInStateRateLimiter = stuckInStateRateLimiter;
this.titusRuntime = titusRuntime;
this.clock = titusRuntime.getClock();
this.storeWriteRetryInterceptor = new RetryActionInterceptor(
"storeWrite",
Retryers.exponentialBackoff(5000, 5000, TimeUnit.MILLISECONDS),
scheduler
);
}
@Override
public List<ChangeAction> apply(ReconciliationEngine<JobManagerReconcilerEvent> engine) {
List<ChangeAction> actions = new ArrayList<>();
ServiceJobView refJobView = new ServiceJobView(engine.getReferenceView());
int activeNotStartedTasks = DifferenceResolverUtils.countActiveNotStartedTasks(refJobView.getJobHolder(), engine.getRunningView());
AtomicInteger allowedNewTasks = new AtomicInteger(Math.max(0, configuration.getActiveNotStartedTasksLimit() - activeNotStartedTasks));
AtomicInteger allowedTaskKills = new AtomicInteger(configuration.getConcurrentReconcilerStoreUpdateLimit());
actions.addAll(applyStore(engine, refJobView, engine.getStoreView(), allowedNewTasks));
actions.addAll(applyRuntime(engine, refJobView, engine.getRunningView(), engine.getStoreView(), allowedNewTasks, allowedTaskKills));
if (actions.isEmpty()) {
actions.addAll(removeCompletedJob(engine.getReferenceView(), engine.getStoreView(), jobStore, versionSupplier));
}
return actions;
}
private List<ChangeAction> applyRuntime(ReconciliationEngine<JobManagerReconcilerEvent> engine,
ServiceJobView refJobView,
EntityHolder runningModel,
EntityHolder storeModel,
AtomicInteger allowedNewTasks,
AtomicInteger allowedTaskKills) {
EntityHolder referenceModel = refJobView.getJobHolder();
ServiceJobView runningJobView = new ServiceJobView(runningModel);
if (hasJobState(referenceModel, JobState.KillInitiated)) {
List<ChangeAction> killInitiatedActions = KillInitiatedActions.reconcilerInitiatedAllTasksKillInitiated(
engine, runtime, jobStore, TaskStatus.REASON_TASK_KILLED,
"Killing task as its job is in KillInitiated state", allowedTaskKills.get(),
versionSupplier,
titusRuntime
);
if (killInitiatedActions.isEmpty()) {
return findTaskStateTimeouts(engine, runningJobView, configuration, runtime, jobStore, versionSupplier, stuckInStateRateLimiter, titusRuntime);
}
allowedTaskKills.set(allowedTaskKills.get() - killInitiatedActions.size());
return killInitiatedActions;
} else if (hasJobState(referenceModel, JobState.Finished)) {
return Collections.emptyList();
}
List<ChangeAction> actions = new ArrayList<>();
List<ChangeAction> numberOfTaskAdjustingActions = findJobSizeInconsistencies(engine, refJobView, storeModel, allowedNewTasks, allowedTaskKills);
actions.addAll(numberOfTaskAdjustingActions);
if (numberOfTaskAdjustingActions.isEmpty()) {
actions.addAll(findMissingRunningTasks(engine, refJobView, runningJobView));
}
actions.addAll(findTaskStateTimeouts(engine, runningJobView, configuration, runtime, jobStore, versionSupplier, stuckInStateRateLimiter, titusRuntime));
return actions;
}
/**
* Check that the reference job has the required number of tasks.
*/
private List<ChangeAction> findJobSizeInconsistencies(ReconciliationEngine<JobManagerReconcilerEvent> engine,
ServiceJobView refJobView,
EntityHolder storeModel,
AtomicInteger allowedNewTasks,
AtomicInteger allowedTaskKills) {
boolean canUpdateStore = storeWriteRetryInterceptor.executionLimits(storeModel);
List<ServiceJobTask> tasks = refJobView.getTasks();
int missing = refJobView.getRequiredSize() - tasks.size();
List<String> unassignedIpAllocations = getUnassignedIpAllocations(refJobView);
List<String> unassignedEbsVolumeIds = getUnassignedEbsVolumes(refJobView);
if (canUpdateStore && missing > 0) {
List<ChangeAction> missingTasks = new ArrayList<>();
for (int i = 0; i < missing && allowedNewTasks.get() > 0; i++) {
allowedNewTasks.decrementAndGet();
createNewTaskAction(refJobView, Optional.empty(), unassignedIpAllocations, unassignedEbsVolumeIds).ifPresent(missingTasks::add);
}
return missingTasks;
} else if (missing < 0) {
// Too many tasks (job was scaled down)
int finishedCount = (int) tasks.stream().filter(t -> t.getStatus().getState() == TaskState.Finished).count();
int toRemoveCount = Math.min(allowedTaskKills.get(), -missing - finishedCount);
if (toRemoveCount > 0) {
List<ServiceJobTask> tasksToRemove = ScaleDownEvaluator.selectTasksToTerminate(tasks, tasks.size() - toRemoveCount, titusRuntime);
List<ChangeAction> killActions = tasksToRemove.stream()
.filter(t -> !isTerminating(t))
.map(t -> KillInitiatedActions.reconcilerInitiatedTaskKillInitiated(engine, t, runtime,
jobStore, versionSupplier, TaskStatus.REASON_SCALED_DOWN, "Terminating excessive service job task", titusRuntime)
)
.collect(Collectors.toList());
allowedTaskKills.set(allowedTaskKills.get() - killActions.size());
return killActions;
}
}
return Collections.emptyList();
}
private Optional<TitusChangeAction> createNewTaskAction(ServiceJobView refJobView, Optional<EntityHolder> previousTask, List<String> unassignedIpAllocations, List<String> unassignedEbsVolumeIds) {
// Safety check
long numberOfNotFinishedTasks = getNumberOfNotFinishedTasks(refJobView);
if (numberOfNotFinishedTasks >= refJobView.getRequiredSize()) {
titusRuntime.getCodeInvariants().inconsistent(
"Service job reconciler attempts to create too many tasks: jobId=%s, requiredSize=%s, current=%s",
refJobView.getJob().getId(), refJobView.getRequiredSize(), numberOfNotFinishedTasks
);
return Optional.empty();
}
Map<String, String> taskContext = getTaskContext(previousTask, unassignedIpAllocations, unassignedEbsVolumeIds);
JobDescriptor jobDescriptor = refJobView.getJob().getJobDescriptor();
ApplicationSLA capacityGroupDescriptor = JobManagerUtil.getCapacityGroupDescriptor(jobDescriptor, capacityGroupService);
String resourcePool = capacityGroupDescriptor.getResourcePool();
taskContext = CollectionsExt.copyAndAdd(taskContext, ImmutableMap.of(
TaskAttributes.TASK_ATTRIBUTES_RESOURCE_POOL, resourcePool,
TaskAttributes.TASK_ATTRIBUTES_TIER, capacityGroupDescriptor.getTier().name()));
TitusChangeAction storeAction = storeWriteRetryInterceptor.apply(
createOrReplaceTaskAction(runtime, jobStore, versionSupplier, refJobView.getJobHolder(), previousTask, clock, taskContext)
);
return Optional.of(storeAction);
}
/**
* Check that for each reference job task, there is a corresponding running task.
*/
private List<ChangeAction> findMissingRunningTasks(ReconciliationEngine<JobManagerReconcilerEvent> engine, ServiceJobView refJobView, ServiceJobView runningJobView) {
List<ChangeAction> missingTasks = new ArrayList<>();
List<ServiceJobTask> tasks = refJobView.getTasks();
for (ServiceJobTask refTask : tasks) {
ServiceJobTask runningTask = runningJobView.getTaskById(refTask.getId());
if (runtime.getComputeProvider().isReadyForScheduling()) {
// TODO This complexity exists due to the way Fenzo is initialized on bootstrap. This code can be simplified one we move off Fenzo.
if (runningTask == null || (refTask.getStatus().getState() == TaskState.Accepted && !TaskStatus.hasPod(refTask))) {
missingTasks.add(BasicTaskActions.launchTaskInKube(
configuration,
runtime,
engine,
refJobView.getJob(),
refTask,
RECONCILER_CALLMETADATA.toBuilder().withCallReason("Launching task in Kube").build(),
versionSupplier,
titusRuntime
));
}
}
}
return missingTasks;
}
private List<ChangeAction> applyStore(ReconciliationEngine<JobManagerReconcilerEvent> engine,
ServiceJobView refJobView,
EntityHolder storeJob,
AtomicInteger allowedNewTasks) {
if (!storeWriteRetryInterceptor.executionLimits(storeJob)) {
return Collections.emptyList();
}
List<ChangeAction> actions = new ArrayList<>();
EntityHolder refJobHolder = refJobView.getJobHolder();
Job<ServiceJobExt> refJob = refJobHolder.getEntity();
if (!refJobHolder.getEntity().equals(storeJob.getEntity())) {
actions.add(storeWriteRetryInterceptor.apply(BasicJobActions.updateJobInStore(engine, jobStore)));
}
boolean isJobTerminating = refJob.getStatus().getState() == JobState.KillInitiated;
for (EntityHolder referenceTaskHolder : refJobHolder.getChildren()) {
ServiceJobTask refTask = referenceTaskHolder.getEntity();
Optional<EntityHolder> storeHolder = storeJob.findById(referenceTaskHolder.getId());
ServiceJobTask storeTask = storeHolder.get().getEntity();
boolean refAndStoreInSync = areEquivalent(storeHolder.get(), referenceTaskHolder);
boolean shouldRetry = !isJobTerminating
&& refTask.getStatus().getState() == TaskState.Finished
&& !refTask.getStatus().getReasonCode().equals(TaskStatus.REASON_SCALED_DOWN)
&& allowedNewTasks.get() > 0;
if (refAndStoreInSync) {
TaskState currentTaskState = refTask.getStatus().getState();
if (currentTaskState == TaskState.Finished) {
if (isJobTerminating || isScaledDown(storeTask) || hasEnoughTasksRunning(refJobView)) {
actions.add(removeFinishedServiceTaskAction(jobStore, storeTask));
} else if (shouldRetry && TaskRetryers.shouldRetryNow(referenceTaskHolder, clock)) {
createNewTaskAction(refJobView, Optional.of(referenceTaskHolder), Collections.emptyList(), Collections.emptyList()).ifPresent(actions::add);
}
}
} else {
Task task = referenceTaskHolder.getEntity();
CallMetadata callMetadata = RECONCILER_CALLMETADATA.toBuilder().withCallReason("Writing runtime state changes to store").build();
actions.add(storeWriteRetryInterceptor.apply(BasicTaskActions.writeReferenceTaskToStore(jobStore, engine, task.getId(), callMetadata, titusRuntime)));
}
// Both current and delayed retries are counted
if (shouldRetry) {
allowedNewTasks.decrementAndGet();
}
}
return actions;
}
private long getNumberOfNotFinishedTasks(ServiceJobView refJobView) {
long count = 0L;
for (EntityHolder holder : refJobView.getJobHolder().getChildren()) {
if (TaskState.isRunning(((Task) holder.getEntity()).getStatus().getState())) {
count++;
}
}
return count;
}
private boolean hasEnoughTasksRunning(ServiceJobView refJobView) {
return getNumberOfNotFinishedTasks(refJobView) >= refJobView.getRequiredSize();
}
private boolean isScaledDown(ServiceJobTask task) {
return JobFunctions.findTaskStatus(task, TaskState.KillInitiated)
.map(status -> TaskStatus.REASON_SCALED_DOWN.equals(status.getReasonCode()))
.orElse(false);
}
private List<ChangeAction> removeCompletedJob(EntityHolder referenceModel, EntityHolder storeModel,
JobStore titusStore, VersionSupplier versionSupplier) {
if (!hasJobState(referenceModel, JobState.Finished)) {
if (hasJobState(referenceModel, JobState.KillInitiated) && DifferenceResolverUtils.allDone(storeModel)) {
return Collections.singletonList(BasicJobActions.completeJob(referenceModel.getId(), versionSupplier));
}
} else {
if (!BasicJobActions.isClosed(referenceModel)) {
return Collections.singletonList(BasicJobActions.removeJobFromStore(referenceModel.getEntity(), titusStore));
}
}
return Collections.emptyList();
}
private static class ServiceJobView extends DifferenceResolverUtils.JobView<ServiceJobExt, ServiceJobTask> {
ServiceJobView(EntityHolder jobHolder) {
super(jobHolder);
}
}
}
| 78 |
0 | Create_ds/titus-control-plane/titus-server-master/src/main/java/com/netflix/titus/master/jobmanager/service/service | Create_ds/titus-control-plane/titus-server-master/src/main/java/com/netflix/titus/master/jobmanager/service/service/action/MoveTaskBetweenJobsAction.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.master.jobmanager.service.service.action;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import com.google.common.collect.ImmutableMap;
import com.netflix.titus.api.jobmanager.model.job.Capacity;
import com.netflix.titus.api.jobmanager.model.job.Job;
import com.netflix.titus.api.jobmanager.model.job.JobFunctions;
import com.netflix.titus.api.jobmanager.model.job.JobState;
import com.netflix.titus.api.jobmanager.model.job.Task;
import com.netflix.titus.api.jobmanager.model.job.ext.ServiceJobExt;
import com.netflix.titus.api.jobmanager.service.JobManagerException;
import com.netflix.titus.api.jobmanager.service.V3JobOperations.Trigger;
import com.netflix.titus.api.jobmanager.store.JobStore;
import com.netflix.titus.api.model.callmetadata.CallMetadata;
import com.netflix.titus.common.framework.reconciler.EntityHolder;
import com.netflix.titus.common.framework.reconciler.ModelActionHolder;
import com.netflix.titus.common.framework.reconciler.MultiEngineChangeAction;
import com.netflix.titus.common.framework.reconciler.ReconciliationEngine;
import com.netflix.titus.master.jobmanager.service.VersionSupplier;
import com.netflix.titus.master.jobmanager.service.VersionSuppliers;
import com.netflix.titus.master.jobmanager.service.common.action.TitusModelAction;
import com.netflix.titus.master.jobmanager.service.event.JobManagerReconcilerEvent;
import rx.Observable;
import static com.netflix.titus.master.jobmanager.service.VersionSuppliers.nextVersion;
public class MoveTaskBetweenJobsAction implements MultiEngineChangeAction {
private final ReconciliationEngine<JobManagerReconcilerEvent> engineFrom;
private final ReconciliationEngine<JobManagerReconcilerEvent> engineTo;
private final String taskId;
private final JobStore titusStore;
private final CallMetadata callMetadata;
private final VersionSupplier versionSupplier;
public MoveTaskBetweenJobsAction(ReconciliationEngine<JobManagerReconcilerEvent> engineFrom,
ReconciliationEngine<JobManagerReconcilerEvent> engineTo,
String taskId,
JobStore titusStore,
CallMetadata callMetadata,
VersionSupplier versionSupplier) {
this.engineFrom = engineFrom;
this.engineTo = engineTo;
this.taskId = taskId;
this.titusStore = titusStore;
this.callMetadata = callMetadata;
this.versionSupplier = versionSupplier;
}
@Override
public Observable<Map<String, List<ModelActionHolder>>> apply() {
return Observable.defer(() -> {
// Validate data
Job<ServiceJobExt> jobFrom = engineFrom.getReferenceView().getEntity();
Job<ServiceJobExt> jobTo = engineTo.getReferenceView().getEntity();
EntityHolder taskFromReferenceHolder = engineFrom.getReferenceView().findChildById(taskId)
.orElseThrow(() -> JobManagerException.taskJobMismatch(taskId, jobFrom.getId()));
if (jobFrom.getStatus().getState() != JobState.Accepted) {
throw JobManagerException.unexpectedJobState(jobTo, JobState.Accepted);
}
Capacity capacityFrom = jobFrom.getJobDescriptor().getExtensions().getCapacity();
if (capacityFrom.getMin() >= capacityFrom.getDesired()) {
throw JobManagerException.belowMinCapacity(jobFrom, 1);
}
if (jobTo.getStatus().getState() != JobState.Accepted) {
throw JobManagerException.unexpectedJobState(jobTo, JobState.Accepted);
}
Capacity capacityTo = jobTo.getJobDescriptor().getExtensions().getCapacity();
if (capacityTo.getDesired() >= capacityTo.getMax()) {
throw JobManagerException.aboveMaxCapacity(jobTo, 1);
}
Task taskFromReference = taskFromReferenceHolder.getEntity();
Optional<EntityHolder> taskFromRunningHolder = engineFrom.getRunningView().findChildById(taskId);
// Compute new model entities
// Decrement job size by 1
Job<ServiceJobExt> updatedJobFrom = nextVersion(JobFunctions.incrementJobSize(jobFrom, -1), versionSupplier);
Job<ServiceJobExt> updatedJobTo = nextVersion(JobFunctions.incrementJobSize(jobTo, 1), versionSupplier);
Task updatedReferenceTaskTo = VersionSuppliers.nextVersion(
JobFunctions.moveTask(jobFrom.getId(), jobTo.getId(), taskFromReference), versionSupplier);
// Move the task
return titusStore.moveTask(updatedJobFrom, updatedJobTo, updatedReferenceTaskTo).andThen(
Observable.fromCallable(() -> ImmutableMap.of(
jobFrom.getId(), createModelUpdateActionsFrom(updatedJobFrom, updatedJobTo, taskFromReference, callMetadata),
jobTo.getId(), createModelUpdateActionsTo(updatedJobFrom, updatedJobTo, updatedReferenceTaskTo, taskFromRunningHolder, callMetadata)
))
);
});
}
private List<ModelActionHolder> createModelUpdateActionsFrom(Job<ServiceJobExt> updatedJobFrom, Job<ServiceJobExt> updatedJobTo,
Task taskFrom, CallMetadata callMetadata) {
List<ModelActionHolder> actions = new ArrayList<>();
// Remove task from all models.
TitusModelAction removeTaskAction = TitusModelAction.newModelUpdate("moveTask")
.job(updatedJobFrom)
.trigger(Trigger.API)
.summary("Task moved to another job: jobTo=" + updatedJobTo.getId())
.callMetadata(callMetadata)
.removeTask(taskFrom);
actions.addAll(ModelActionHolder.allModels(removeTaskAction));
String summary = "Decremented the desired job size by one, as its task was moved to another job: jobTo=" + updatedJobTo.getId();
// Change job size
TitusModelAction modelAction = TitusModelAction.newModelUpdate("decrementJobSize")
.job(updatedJobFrom)
.trigger(Trigger.API)
.summary(summary)
.jobUpdate(jobHolder -> jobHolder.setEntity(updatedJobFrom));
actions.addAll(ModelActionHolder.referenceAndStore(modelAction));
return actions;
}
private List<ModelActionHolder> createModelUpdateActionsTo(Job<ServiceJobExt> updatedJobFrom, Job<?> updatedJobTo, Task taskToUpdated, Optional<EntityHolder> taskFromRunningHolder, CallMetadata callMetadata) {
List<ModelActionHolder> actions = new ArrayList<>();
String summary = "Received task from another job: jobFrom=" + updatedJobFrom.getId();
// Add task
TitusModelAction addTaskAction = TitusModelAction.newModelUpdate("moveTask")
.job(updatedJobTo)
.trigger(Trigger.API)
.summary(summary)
.callMetadata(callMetadata)
.taskUpdate(taskToUpdated);
if (taskFromRunningHolder.isPresent()) {
actions.addAll(ModelActionHolder.allModels(addTaskAction));
} else {
actions.addAll(ModelActionHolder.referenceAndStore(addTaskAction));
}
// Change job size
TitusModelAction modelAction = TitusModelAction.newModelUpdate("incrementJobSize")
.job(updatedJobTo)
.trigger(Trigger.API)
.summary("Incremented the desired job size by one, as it got a task from another job: jobFrom=" + updatedJobFrom.getId())
.jobUpdate(jobHolder -> jobHolder.setEntity(updatedJobTo));
actions.addAll(ModelActionHolder.referenceAndStore(modelAction));
return actions;
}
}
| 79 |
0 | Create_ds/titus-control-plane/titus-server-master/src/main/java/com/netflix/titus/master/jobmanager/service/service | Create_ds/titus-control-plane/titus-server-master/src/main/java/com/netflix/titus/master/jobmanager/service/service/action/BasicServiceTaskActions.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.master.jobmanager.service.service.action;
import com.netflix.titus.api.jobmanager.model.job.ServiceJobTask;
import com.netflix.titus.api.jobmanager.service.V3JobOperations.Trigger;
import com.netflix.titus.api.jobmanager.store.JobStore;
import com.netflix.titus.common.framework.reconciler.ModelActionHolder;
import com.netflix.titus.master.jobmanager.service.common.action.TitusChangeAction;
import com.netflix.titus.master.jobmanager.service.common.action.TitusModelAction;
import rx.Observable;
public final class BasicServiceTaskActions {
/**
* Remove completed task from reconciler.
*/
public static TitusChangeAction removeFinishedServiceTaskAction(JobStore jobStore, ServiceJobTask task) {
return TitusChangeAction.newAction("removeFinishedServiceTaskAction")
.task(task)
.trigger(Trigger.ReconcilerServiceTaskRemoved)
.summary("Removing completed task from reconciler")
.changeWithModelUpdates(self ->
jobStore.deleteTask(task).andThen(
Observable.just(ModelActionHolder.allModels(TitusModelAction.newModelUpdate(self).removeTask(task)))
));
}
}
| 80 |
0 | Create_ds/titus-control-plane/titus-server-master/src/main/java/com/netflix/titus/master/jobmanager/service/service | Create_ds/titus-control-plane/titus-server-master/src/main/java/com/netflix/titus/master/jobmanager/service/service/action/BasicServiceJobActions.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.master.jobmanager.service.service.action;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
import com.netflix.titus.api.jobmanager.JobAttributes;
import com.netflix.titus.api.jobmanager.model.job.Capacity;
import com.netflix.titus.api.jobmanager.model.job.CapacityAttributes;
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.ServiceJobProcesses;
import com.netflix.titus.api.jobmanager.model.job.ext.ServiceJobExt;
import com.netflix.titus.api.jobmanager.service.JobManagerException;
import com.netflix.titus.api.jobmanager.service.V3JobOperations;
import com.netflix.titus.api.jobmanager.store.JobStore;
import com.netflix.titus.api.model.callmetadata.CallMetadata;
import com.netflix.titus.api.service.TitusServiceException;
import com.netflix.titus.common.framework.reconciler.ModelActionHolder;
import com.netflix.titus.common.framework.reconciler.ReconciliationEngine;
import com.netflix.titus.common.model.sanitizer.EntitySanitizer;
import com.netflix.titus.common.model.sanitizer.ValidationError;
import com.netflix.titus.master.jobmanager.service.VersionSupplier;
import com.netflix.titus.master.jobmanager.service.VersionSuppliers;
import com.netflix.titus.master.jobmanager.service.common.action.TitusChangeAction;
import com.netflix.titus.master.jobmanager.service.common.action.TitusModelAction;
import com.netflix.titus.master.jobmanager.service.event.JobManagerReconcilerEvent;
import rx.Observable;
public class BasicServiceJobActions {
/**
* Update job capacity.
*/
public static TitusChangeAction updateJobCapacityAction(ReconciliationEngine<JobManagerReconcilerEvent> engine,
CapacityAttributes capacityAttributes,
JobStore jobStore,
VersionSupplier versionSupplier,
CallMetadata callMetadata,
EntitySanitizer entitySanitizer) {
return TitusChangeAction.newAction("updateJobCapacityAction")
.id(engine.getReferenceView().getId())
.trigger(V3JobOperations.Trigger.API)
.summary("Changing job capacity to: %s", capacityAttributes)
.callMetadata(callMetadata)
.changeWithModelUpdates(self -> {
Job<ServiceJobExt> serviceJob = engine.getReferenceView().getEntity();
if (serviceJob.getStatus().getState() != JobState.Accepted) {
return Observable.error(JobManagerException.jobTerminating(serviceJob));
}
Capacity currentCapacity = serviceJob.getJobDescriptor().getExtensions().getCapacity();
Capacity.Builder newCapacityBuilder = currentCapacity.toBuilder();
capacityAttributes.getDesired().ifPresent(newCapacityBuilder::withDesired);
capacityAttributes.getMax().ifPresent(newCapacityBuilder::withMax);
capacityAttributes.getMin().ifPresent(newCapacityBuilder::withMin);
if (capacityAttributes.getDesired().isPresent()) {
newCapacityBuilder.withDesired(capacityAttributes.getDesired().get());
} else {
setDesiredBasedOnMinMax(newCapacityBuilder, currentCapacity, capacityAttributes);
}
Capacity newCapacity = newCapacityBuilder.build();
if (currentCapacity.equals(newCapacity)) {
return Observable.empty();
}
// model validation for capacity
Set<ValidationError> violations = entitySanitizer.validate(newCapacity);
if (!violations.isEmpty()) {
return Observable.error(TitusServiceException.invalidArgument(
String.format("Current %s", currentCapacity),
violations
));
}
// checking if service job processes allow changes to desired capacity
if (isDesiredCapacityInvalid(newCapacity, serviceJob)) {
return Observable.error(JobManagerException.invalidDesiredCapacity(serviceJob.getId(), newCapacity.getDesired(),
serviceJob.getJobDescriptor().getExtensions().getServiceJobProcesses()));
}
// append callmetadata job attributes
Job<ServiceJobExt> serviceJobExtCallMetadata = JobFunctions.appendCallMetadataJobAttributes(serviceJob, callMetadata);
// ready to update job capacity
Job<ServiceJobExt> updatedJob = VersionSuppliers.nextVersion(
JobFunctions.changeServiceJobCapacity(serviceJobExtCallMetadata, newCapacity), versionSupplier
);
TitusModelAction modelAction = TitusModelAction.newModelUpdate(self).jobUpdate(jobHolder -> jobHolder.setEntity(updatedJob));
return jobStore.updateJob(updatedJob).andThen(Observable.just(ModelActionHolder.referenceAndStore(modelAction)));
});
}
/**
* Change job 'enable' status.
*/
public static TitusChangeAction updateJobEnableStatus(ReconciliationEngine<JobManagerReconcilerEvent> engine, boolean enabled,
JobStore jobStore, VersionSupplier versionSupplier, CallMetadata callMetadata) {
return TitusChangeAction.newAction("updateJobCapacityAction")
.id(engine.getReferenceView().getId())
.trigger(V3JobOperations.Trigger.API)
.summary("Changing job enable status to: %s", enabled)
.callMetadata(callMetadata)
.changeWithModelUpdates(self -> {
Job<ServiceJobExt> serviceJob = engine.getReferenceView().getEntity();
if (serviceJob.getStatus().getState() != JobState.Accepted) {
return Observable.error(JobManagerException.jobTerminating(serviceJob));
}
Job<ServiceJobExt> updatedJob = VersionSuppliers.nextVersion(
JobFunctions.changeJobEnabledStatus(serviceJob, enabled), versionSupplier
);
TitusModelAction modelAction = TitusModelAction.newModelUpdate(self).jobUpdate(jobHolder -> jobHolder.setEntity(updatedJob));
return jobStore.updateJob(updatedJob).andThen(Observable.just(ModelActionHolder.referenceAndStore(modelAction)));
});
}
/**
* Change job service processes configuration.
*/
public static TitusChangeAction updateServiceJobProcesses(ReconciliationEngine<JobManagerReconcilerEvent> engine, ServiceJobProcesses processes,
JobStore jobStore, VersionSupplier versionSupplier, CallMetadata callMetadata) {
return TitusChangeAction.newAction("updateServiceJobProcesses")
.id(engine.getReferenceView().getId())
.trigger(V3JobOperations.Trigger.API)
.summary("Changing job service processes to: %s", processes)
.callMetadata(callMetadata)
.changeWithModelUpdates(self -> {
Job<ServiceJobExt> serviceJob = engine.getReferenceView().getEntity();
if (serviceJob.getStatus().getState() != JobState.Accepted) {
return Observable.error(JobManagerException.jobTerminating(serviceJob));
}
Job<ServiceJobExt> updatedJob = VersionSuppliers.nextVersion(
JobFunctions.changeServiceJobProcesses(serviceJob, processes), versionSupplier
);
TitusModelAction modelAction = TitusModelAction.newModelUpdate(self).jobUpdate(jobHolder -> jobHolder.setEntity(updatedJob));
return jobStore.updateJob(updatedJob).andThen(Observable.just(ModelActionHolder.referenceAndStore(modelAction)));
});
}
/**
* Automatically adjust the desired size to be within the bounds of (min,max). This method assumes min <= max.
*/
private static void setDesiredBasedOnMinMax(Capacity.Builder builder, Capacity current, CapacityAttributes update) {
update.getMin().ifPresent(min -> {
if (min > current.getDesired()) {
builder.withDesired(min);
}
});
update.getMax().ifPresent(max -> {
if (max < current.getDesired()) {
builder.withDesired(max);
}
});
}
private static boolean isDesiredCapacityInvalid(Capacity targetCapacity, Job<ServiceJobExt> serviceJob) {
ServiceJobProcesses serviceJobProcesses = serviceJob.getJobDescriptor().getExtensions().getServiceJobProcesses();
Capacity currentCapacity = serviceJob.getJobDescriptor().getExtensions().getCapacity();
return (serviceJobProcesses.isDisableIncreaseDesired() && targetCapacity.getDesired() > currentCapacity.getDesired()) ||
(serviceJobProcesses.isDisableDecreaseDesired() && targetCapacity.getDesired() < currentCapacity.getDesired());
}
}
| 81 |
0 | Create_ds/titus-control-plane/titus-server-master/src/main/java/com/netflix/titus/master/jobmanager/service/service | Create_ds/titus-control-plane/titus-server-master/src/main/java/com/netflix/titus/master/jobmanager/service/service/action/CreateOrReplaceServiceTaskActions.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.master.jobmanager.service.service.action;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.UUID;
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.LogStorageInfos;
import com.netflix.titus.api.jobmanager.model.job.ServiceJobTask;
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.api.jobmanager.service.V3JobOperations;
import com.netflix.titus.api.jobmanager.store.JobStore;
import com.netflix.titus.common.framework.reconciler.EntityHolder;
import com.netflix.titus.common.framework.reconciler.ModelActionHolder;
import com.netflix.titus.common.util.CollectionsExt;
import com.netflix.titus.common.util.retry.Retryer;
import com.netflix.titus.common.util.time.Clock;
import com.netflix.titus.master.jobmanager.service.JobServiceRuntime;
import com.netflix.titus.master.jobmanager.service.VersionSupplier;
import com.netflix.titus.master.jobmanager.service.common.action.TaskRetryers;
import com.netflix.titus.master.jobmanager.service.common.action.TitusChangeAction;
import com.netflix.titus.master.jobmanager.service.common.action.TitusModelAction;
import rx.Observable;
import static com.netflix.titus.master.jobmanager.service.common.action.JobEntityHolders.ATTR_REPLACEMENT_OF;
/**
* Create a new task or replace a completed task, and persist it into the store. Update reference/store models.
*/
public class CreateOrReplaceServiceTaskActions {
public static TitusChangeAction createOrReplaceTaskAction(JobServiceRuntime context,
JobStore jobStore,
VersionSupplier versionSupplier,
EntityHolder jobHolder,
Optional<EntityHolder> previousTaskHolder,
Clock clock,
Map<String, String> taskContext) {
Job<ServiceJobExt> job = jobHolder.getEntity();
return previousTaskHolder
.map(previous -> createResubmittedTaskChangeAction(jobHolder, previous, context, jobStore, versionSupplier, clock, taskContext))
.orElseGet(() -> createOriginalTaskChangeAction(job, jobStore, versionSupplier, clock, taskContext));
}
private static TitusChangeAction createOriginalTaskChangeAction(Job<ServiceJobExt> job, JobStore jobStore,
VersionSupplier versionSupplier, Clock clock, Map<String, String> taskContext) {
Retryer newRetryer = JobFunctions.retryer(job);
ServiceJobTask newTask = createNewServiceTask(job, clock.wallTime(), taskContext, versionSupplier);
String summary = String.format("Creating new service task in DB store: %s", newTask.getId());
return TitusChangeAction.newAction("createOrReplaceTask")
.id(newTask.getId())
.trigger(V3JobOperations.Trigger.Reconciler)
.summary(summary)
.changeWithModelUpdates(self -> jobStore.storeTask(newTask).andThen(Observable.just(createNewTaskModelAction(self, newTask, Optional.empty(), newRetryer))));
}
private static TitusChangeAction createResubmittedTaskChangeAction(EntityHolder jobHolder,
EntityHolder taskHolder,
JobServiceRuntime context,
JobStore jobStore,
VersionSupplier versionSupplier,
Clock clock,
Map<String, String> taskContext) {
ServiceJobTask oldTask = taskHolder.getEntity();
long timeInStartedState = JobFunctions.getTimeInState(oldTask, TaskState.Started, clock).orElse(0L);
Retryer nextTaskRetryer = timeInStartedState >= context.getConfiguration().getTaskRetryerResetTimeMs()
? JobFunctions.retryer(jobHolder.getEntity())
: TaskRetryers.getNextTaskRetryer(context::getSystemRetryer, jobHolder.getEntity(), taskHolder);
ServiceJobTask newTask = createServiceTaskReplacement(jobHolder.getEntity(), oldTask, clock.wallTime(), taskContext, versionSupplier);
String summary = String.format(
"Replacing service task in DB store: resubmit=%d, originalId=%s, previousId=%s, newId=%s",
newTask.getResubmitNumber(),
oldTask.getOriginalId(),
oldTask.getId(),
newTask.getId()
);
return TitusChangeAction.newAction("createOrReplaceTask")
.id(newTask.getId())
.trigger(V3JobOperations.Trigger.Reconciler)
.summary(summary)
.changeWithModelUpdates(self -> jobStore.replaceTask(oldTask, newTask).andThen(Observable.just(createTaskResubmitModelActions(self, oldTask, newTask, nextTaskRetryer))));
}
private static List<ModelActionHolder> createNewTaskModelAction(TitusChangeAction.Builder changeActionBuilder,
ServiceJobTask newTask,
Optional<ServiceJobTask> replacementOf,
Retryer newRetryer) {
List<ModelActionHolder> actions = new ArrayList<>();
String summary = "Creating new task entity holder";
TitusModelAction.Builder modelBuilder = TitusModelAction.newModelUpdate(changeActionBuilder).summary(summary);
EntityHolder taskHolder = EntityHolder.newRoot(newTask.getId(), newTask).addTag(TaskRetryers.ATTR_TASK_RETRY, newRetryer);
if (replacementOf.isPresent()) {
taskHolder = taskHolder.addTag(ATTR_REPLACEMENT_OF, replacementOf.get());
}
actions.add(ModelActionHolder.reference(modelBuilder.addTaskHolder(taskHolder)));
actions.add(ModelActionHolder.store(modelBuilder.taskUpdate(newTask)));
return actions;
}
private static List<ModelActionHolder> createTaskResubmitModelActions(TitusChangeAction.Builder changeActionBuilder, ServiceJobTask oldTask, ServiceJobTask newTask, Retryer nextTaskRetryer) {
List<ModelActionHolder> actions = new ArrayList<>();
TitusModelAction removeTaskAction = TitusModelAction.newModelUpdate(changeActionBuilder)
.summary("Removing replaced task")
.removeTask(oldTask);
actions.addAll(ModelActionHolder.allModels(removeTaskAction));
actions.addAll(createNewTaskModelAction(changeActionBuilder, newTask, Optional.of(oldTask), nextTaskRetryer));
return actions;
}
private static ServiceJobTask createNewServiceTask(Job<?> job, long timestamp, Map<String, String> taskContext, VersionSupplier versionSupplier) {
String taskId = UUID.randomUUID().toString();
return ServiceJobTask.newBuilder()
.withId(taskId)
.withJobId(job.getId())
.withStatus(TaskStatus.newBuilder().withState(TaskState.Accepted).withReasonCode(TaskStatus.REASON_NORMAL).withTimestamp(timestamp).build())
.withOriginalId(taskId)
.withCellInfo(job)
.addAllToTaskContext(CollectionsExt.merge(taskContext, LogStorageInfos.toS3LogLocationTaskContext(job)))
.withVersion(versionSupplier.nextVersion())
.build();
}
private static ServiceJobTask createServiceTaskReplacement(Job<?> job, ServiceJobTask oldTask, long timestamp,
Map<String, String> taskContext, VersionSupplier versionSupplier) {
String taskId = UUID.randomUUID().toString();
return ServiceJobTask.newBuilder()
.withId(taskId)
.withJobId(oldTask.getJobId())
.withStatus(TaskStatus.newBuilder().withState(TaskState.Accepted).withReasonCode(TaskStatus.REASON_NORMAL).withTimestamp(timestamp).build())
.withOriginalId(oldTask.getOriginalId())
.withCellInfo(oldTask)
.withResubmitOf(oldTask.getId())
.withResubmitNumber(oldTask.getResubmitNumber() + 1)
.withSystemResubmitNumber(TaskStatus.hasSystemError(oldTask) ? oldTask.getSystemResubmitNumber() + 1 : oldTask.getSystemResubmitNumber())
.withEvictionResubmitNumber(TaskStatus.isEvicted(oldTask
) ? oldTask.getEvictionResubmitNumber() + 1 : oldTask.getEvictionResubmitNumber())
.addAllToTaskContext(CollectionsExt.merge(taskContext, LogStorageInfos.toS3LogLocationTaskContext(job)))
.withVersion(versionSupplier.nextVersion())
.build();
}
}
| 82 |
0 | Create_ds/titus-control-plane/titus-server-master/src/main/java/com/netflix/titus/master/jobmanager/service | Create_ds/titus-control-plane/titus-server-master/src/main/java/com/netflix/titus/master/jobmanager/service/event/JobCheckpointReconcilerEvent.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.master.jobmanager.service.event;
import java.util.Collections;
import com.netflix.titus.api.jobmanager.model.job.Job;
import com.netflix.titus.api.model.callmetadata.CallMetadata;
import com.netflix.titus.api.model.callmetadata.Caller;
import com.netflix.titus.api.model.callmetadata.CallerType;
public class JobCheckpointReconcilerEvent extends JobManagerReconcilerEvent {
private static final Job<?> SENTINEL_JOB = Job.newBuilder().build();
private static final CallMetadata CHECKPOINT_CALL_METADATA = CallMetadata.newBuilder()
.withCallers(Collections.singletonList(
Caller.newBuilder()
.withId("reconciler")
.withCallerType(CallerType.Application)
.build()
))
.withCallReason("Job event stream checkpoint")
.build();
private final long timestampNano;
public JobCheckpointReconcilerEvent(long timestampNano) {
super(SENTINEL_JOB, "no-trx:checkpoint", CHECKPOINT_CALL_METADATA);
this.timestampNano = timestampNano;
}
public long getTimestampNano() {
return timestampNano;
}
@Override
public String toString() {
return "JobCheckpointReconcilerEvent{" +
"timestampNano=" + timestampNano +
'}';
}
}
| 83 |
0 | Create_ds/titus-control-plane/titus-server-master/src/main/java/com/netflix/titus/master/jobmanager/service | Create_ds/titus-control-plane/titus-server-master/src/main/java/com/netflix/titus/master/jobmanager/service/event/JobEventFactory.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.master.jobmanager.service.event;
import java.util.Optional;
import com.netflix.titus.api.jobmanager.model.job.Job;
import com.netflix.titus.common.framework.reconciler.ChangeAction;
import com.netflix.titus.common.framework.reconciler.EntityHolder;
import com.netflix.titus.common.framework.reconciler.ModelActionHolder;
import com.netflix.titus.common.framework.reconciler.ReconcileEventFactory;
import com.netflix.titus.common.framework.reconciler.ReconciliationEngine;
import com.netflix.titus.master.jobmanager.service.common.action.TitusChangeAction;
import com.netflix.titus.master.jobmanager.service.event.JobChangeReconcilerEvent.JobAfterChangeReconcilerEvent;
import com.netflix.titus.master.jobmanager.service.event.JobChangeReconcilerEvent.JobBeforeChangeReconcilerEvent;
import com.netflix.titus.master.jobmanager.service.event.JobChangeReconcilerEvent.JobChangeErrorReconcilerEvent;
/**
*
*/
public class JobEventFactory implements ReconcileEventFactory<JobManagerReconcilerEvent> {
@Override
public JobManagerReconcilerEvent newCheckpointEvent(long timestampNano) {
return new JobCheckpointReconcilerEvent(timestampNano);
}
@Override
public JobManagerReconcilerEvent newBeforeChangeEvent(ReconciliationEngine<JobManagerReconcilerEvent> engine,
ChangeAction changeAction,
String transactionId) {
return new JobBeforeChangeReconcilerEvent(engine.getReferenceView().getEntity(), (TitusChangeAction) changeAction, transactionId);
}
@Override
public JobManagerReconcilerEvent newAfterChangeEvent(ReconciliationEngine<JobManagerReconcilerEvent> engine,
ChangeAction changeAction,
long waitTimeMs,
long executionTimeMs,
String transactionId) {
return new JobAfterChangeReconcilerEvent(engine.getReferenceView().getEntity(), (TitusChangeAction) changeAction, waitTimeMs, executionTimeMs, transactionId);
}
@Override
public JobManagerReconcilerEvent newChangeErrorEvent(ReconciliationEngine<JobManagerReconcilerEvent> engine,
ChangeAction changeAction,
Throwable error,
long waitTimeMs,
long executionTimeMs,
String transactionId) {
return new JobChangeErrorReconcilerEvent(engine.getReferenceView().getEntity(), (TitusChangeAction) changeAction, error, waitTimeMs, executionTimeMs, transactionId);
}
@Override
public JobManagerReconcilerEvent newModelEvent(ReconciliationEngine<JobManagerReconcilerEvent> engine,
EntityHolder newRoot) {
return new JobModelReconcilerEvent.JobNewModelReconcilerEvent(newRoot);
}
@Override
public JobManagerReconcilerEvent newModelUpdateEvent(ReconciliationEngine<JobManagerReconcilerEvent> engine,
ChangeAction changeAction,
ModelActionHolder modelActionHolder,
EntityHolder changedEntityHolder,
Optional<EntityHolder> previousEntityHolder,
String transactionId) {
return new JobModelReconcilerEvent.JobModelUpdateReconcilerEvent(getJob(engine, modelActionHolder), (TitusChangeAction) changeAction, modelActionHolder, changedEntityHolder, previousEntityHolder,
transactionId);
}
@Override
public JobManagerReconcilerEvent newModelUpdateErrorEvent(ReconciliationEngine<JobManagerReconcilerEvent> engine,
ChangeAction changeAction,
ModelActionHolder modelActionHolder,
EntityHolder previousEntityHolder,
Throwable error,
String transactionId) {
return new JobModelReconcilerEvent.JobModelUpdateErrorReconcilerEvent(getJob(engine, modelActionHolder), (TitusChangeAction) changeAction, modelActionHolder, previousEntityHolder, error, transactionId,
((TitusChangeAction) changeAction).getCallMetadata());
}
private Job<?> getJob(ReconciliationEngine<JobManagerReconcilerEvent> engine, ModelActionHolder modelActionHolder) {
switch (modelActionHolder.getModel()) {
case Running:
return engine.getRunningView().getEntity();
case Store:
return engine.getStoreView().getEntity();
case Reference:
default:
return engine.getReferenceView().getEntity();
}
}
}
| 84 |
0 | Create_ds/titus-control-plane/titus-server-master/src/main/java/com/netflix/titus/master/jobmanager/service | Create_ds/titus-control-plane/titus-server-master/src/main/java/com/netflix/titus/master/jobmanager/service/event/JobModelReconcilerEvent.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.master.jobmanager.service.event;
import java.util.Optional;
import com.netflix.titus.api.jobmanager.model.job.Job;
import com.netflix.titus.api.jobmanager.service.JobManagerConstants;
import com.netflix.titus.api.model.callmetadata.CallMetadata;
import com.netflix.titus.common.framework.reconciler.EntityHolder;
import com.netflix.titus.common.framework.reconciler.ModelActionHolder;
import com.netflix.titus.master.jobmanager.service.common.action.TitusChangeAction;
import static com.netflix.titus.master.jobmanager.service.common.action.task.BasicJobActions.ATTR_JOB_CLOSED;
public abstract class JobModelReconcilerEvent extends JobManagerReconcilerEvent {
protected JobModelReconcilerEvent(Job<?> job, String transactionId, CallMetadata callMetadata) {
super(job, transactionId, callMetadata);
}
public static class JobNewModelReconcilerEvent extends JobModelReconcilerEvent {
private final EntityHolder newRoot;
public JobNewModelReconcilerEvent(EntityHolder newRoot) {
super(newRoot.getEntity(), "-1", (CallMetadata) newRoot.getAttributes().get(JobManagerConstants.JOB_MANAGER_ATTRIBUTE_CALLMETADATA));
this.newRoot = newRoot;
}
public EntityHolder getNewRoot() {
return newRoot;
}
}
public static class JobModelUpdateReconcilerEvent extends JobModelReconcilerEvent {
private final TitusChangeAction changeAction;
private final ModelActionHolder modelActionHolder;
private final EntityHolder changedEntityHolder;
private final Optional<EntityHolder> previousEntityHolder;
private final boolean archived;
public JobModelUpdateReconcilerEvent(Job<?> job,
TitusChangeAction changeAction,
ModelActionHolder modelActionHolder,
EntityHolder changedEntityHolder,
Optional<EntityHolder> previousEntityHolder,
String transactionId) {
super(job, transactionId, changeAction.getCallMetadata());
this.changeAction = changeAction;
this.modelActionHolder = modelActionHolder;
this.changedEntityHolder = changedEntityHolder;
this.previousEntityHolder = previousEntityHolder;
if (changedEntityHolder.getEntity() instanceof Job) {
Boolean closed = (Boolean) changedEntityHolder.getAttributes().get(ATTR_JOB_CLOSED);
this.archived = closed != null && closed;
} else {
this.archived = false;
}
}
public TitusChangeAction getChangeAction() {
return changeAction;
}
public ModelActionHolder getModelActionHolder() {
return modelActionHolder;
}
public EntityHolder getChangedEntityHolder() {
return changedEntityHolder;
}
public Optional<EntityHolder> getPreviousEntityHolder() {
return previousEntityHolder;
}
public boolean isArchived() {
return archived;
}
}
public static class JobModelUpdateErrorReconcilerEvent extends JobModelReconcilerEvent {
private final TitusChangeAction changeAction;
private final ModelActionHolder modelActionHolder;
private final EntityHolder previousEntityHolder;
private final Throwable error;
public JobModelUpdateErrorReconcilerEvent(Job<?> job,
TitusChangeAction changeAction,
ModelActionHolder modelActionHolder,
EntityHolder previousEntityHolder,
Throwable error,
String transactionId,
CallMetadata callMetadata) {
super(job, transactionId, callMetadata);
this.changeAction = changeAction;
this.modelActionHolder = modelActionHolder;
this.previousEntityHolder = previousEntityHolder;
this.error = error;
}
public TitusChangeAction getChangeAction() {
return changeAction;
}
public ModelActionHolder getModelActionHolder() {
return modelActionHolder;
}
public EntityHolder getPreviousEntityHolder() {
return previousEntityHolder;
}
public Throwable getError() {
return error;
}
}
}
| 85 |
0 | Create_ds/titus-control-plane/titus-server-master/src/main/java/com/netflix/titus/master/jobmanager/service | Create_ds/titus-control-plane/titus-server-master/src/main/java/com/netflix/titus/master/jobmanager/service/event/JobManagerReconcilerEvent.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.master.jobmanager.service.event;
import com.netflix.titus.api.model.callmetadata.CallMetadata;
import com.netflix.titus.api.jobmanager.model.job.Job;
import com.netflix.titus.api.jobmanager.service.JobManagerConstants;
/**
*/
public abstract class JobManagerReconcilerEvent {
private final Job<?> job;
private final String transactionId;
private final CallMetadata callMetadata;
JobManagerReconcilerEvent(Job<?> job, String transactionId, CallMetadata callMetadata) {
this.job = job;
this.transactionId = transactionId;
this.callMetadata = callMetadata;
}
public Job<?> getJob() {
return job;
}
public String getTransactionId() {
return transactionId;
}
public CallMetadata getCallMetadata() {
if(callMetadata == null) {
return JobManagerConstants.UNDEFINED_CALL_METADATA;
}
return callMetadata;
}
}
| 86 |
0 | Create_ds/titus-control-plane/titus-server-master/src/main/java/com/netflix/titus/master/jobmanager/service | Create_ds/titus-control-plane/titus-server-master/src/main/java/com/netflix/titus/master/jobmanager/service/event/JobChangeReconcilerEvent.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.master.jobmanager.service.event;
import com.netflix.titus.api.jobmanager.model.job.Job;
import com.netflix.titus.master.jobmanager.service.common.action.TitusChangeAction;
/**
*/
public abstract class JobChangeReconcilerEvent extends JobManagerReconcilerEvent {
private final TitusChangeAction changeAction;
JobChangeReconcilerEvent(Job<?> job, TitusChangeAction changeAction, String transactionId) {
super(job, transactionId, changeAction.getCallMetadata());
this.changeAction = changeAction;
}
public TitusChangeAction getChangeAction() {
return changeAction;
}
public static class JobBeforeChangeReconcilerEvent extends JobChangeReconcilerEvent {
JobBeforeChangeReconcilerEvent(Job<?> job, TitusChangeAction changeAction, String transactionId) {
super(job, changeAction, transactionId);
}
}
public static class JobAfterChangeReconcilerEvent extends JobChangeReconcilerEvent {
private final long waitTimeMs;
private final long executionTimeMs;
JobAfterChangeReconcilerEvent(Job<?> job, TitusChangeAction changeAction, long waitTimeMs, long executionTimeMs, String transactionId) {
super(job, changeAction, transactionId);
this.waitTimeMs = waitTimeMs;
this.executionTimeMs = executionTimeMs;
}
public long getWaitTimeMs() {
return waitTimeMs;
}
public long getExecutionTimeMs() {
return executionTimeMs;
}
}
public static class JobChangeErrorReconcilerEvent extends JobChangeReconcilerEvent {
private final Throwable error;
private final long waitTimeMs;
private final long executionTimeMs;
JobChangeErrorReconcilerEvent(Job<?> job, TitusChangeAction changeAction, Throwable error, long waitTimeMs, long executionTimeMs, String transactionId) {
super(job, changeAction, transactionId);
this.error = error;
this.waitTimeMs = waitTimeMs;
this.executionTimeMs = executionTimeMs;
}
public long getWaitTimeMs() {
return waitTimeMs;
}
public long getExecutionTimeMs() {
return executionTimeMs;
}
public Throwable getError() {
return error;
}
}
}
| 87 |
0 | Create_ds/titus-control-plane/titus-server-master/src/main/java/com/netflix/titus/master/jobmanager | Create_ds/titus-control-plane/titus-server-master/src/main/java/com/netflix/titus/master/jobmanager/store/ArchivedTasksGcConfiguration.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.master.jobmanager.store;
import com.netflix.archaius.api.annotations.Configuration;
import com.netflix.archaius.api.annotations.DefaultValue;
@Configuration(prefix = "titus.jobManager.archivedTasksGc")
public interface ArchivedTasksGcConfiguration {
/**
* @return whether or not the gc is enabled
*/
@DefaultValue("true")
boolean isGcEnabled();
/**
* @return the initial delay in milliseconds before the execution runs after process startup.
*/
@DefaultValue("60000")
long getGcInitialDelayMs();
/**
* @return the interval in milliseconds of how often the gc runs.
*/
@DefaultValue("900000")
long getGcIntervalMs();
/**
* @return the timeout of the gc's execution loop.
*/
@DefaultValue("600000")
long getGcTimeoutMs();
/**
* @return the the max number of archived tasks a job can have before tasks are gc'ed.
*/
@DefaultValue("10000")
long getMaxNumberOfArchivedTasksPerJob();
/**
* @return the the max number of archived tasks to GC per iteration.
*/
@DefaultValue("10000")
int getMaxNumberOfArchivedTasksToGcPerIteration();
/**
* Maximum number of Cassandra operations executed concurrently.
*/
@DefaultValue("100")
int getMaxRxConcurrency();
}
| 88 |
0 | Create_ds/titus-control-plane/titus-server-master/src/main/java/com/netflix/titus/master/jobmanager | Create_ds/titus-control-plane/titus-server-master/src/main/java/com/netflix/titus/master/jobmanager/store/ArchivedTasksGc.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.master.jobmanager.store;
import java.time.Duration;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
import java.util.stream.Collectors;
import javax.annotation.PreDestroy;
import javax.inject.Inject;
import javax.inject.Singleton;
import com.google.common.annotations.VisibleForTesting;
import com.netflix.spectator.api.Gauge;
import com.netflix.spectator.api.Registry;
import com.netflix.titus.api.jobmanager.model.job.ExecutableStatus;
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.Task;
import com.netflix.titus.api.jobmanager.model.job.TaskState;
import com.netflix.titus.api.jobmanager.service.V3JobOperations;
import com.netflix.titus.api.jobmanager.store.JobStore;
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.Evaluators;
import com.netflix.titus.common.util.ExecutorsExt;
import com.netflix.titus.common.util.guice.annotation.Activator;
import com.netflix.titus.common.util.guice.annotation.Deactivator;
import com.netflix.titus.common.util.tuple.Pair;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import rx.Completable;
import rx.Observable;
import static com.netflix.titus.master.MetricConstants.METRIC_JOB_MANAGER;
@Singleton
public class ArchivedTasksGc {
private static final Logger logger = LoggerFactory.getLogger(ArchivedTasksGc.class);
private final V3JobOperations jobOperations;
private final JobStore jobStore;
private final TitusRuntime titusRuntime;
private final ArchivedTasksGcConfiguration configuration;
private final Gauge jobsEvaluatedGauge;
private final Gauge jobsNeedingGcGauge;
private final Gauge tasksNeedingGcGauge;
private final Gauge tasksToGcGauge;
private ScheduleReference schedulerRef;
@Inject
public ArchivedTasksGc(ArchivedTasksGcConfiguration configuration,
V3JobOperations jobOperations,
JobStore jobStore,
TitusRuntime titusRuntime) {
this.configuration = configuration;
this.jobOperations = jobOperations;
this.jobStore = jobStore;
this.titusRuntime = titusRuntime;
Registry registry = titusRuntime.getRegistry();
String metricNamePrefix = METRIC_JOB_MANAGER + "archivedTasksGc.";
jobsEvaluatedGauge = registry.gauge(metricNamePrefix + "jobsEvaluated");
jobsNeedingGcGauge = registry.gauge(metricNamePrefix + "jobsNeedingGc");
tasksNeedingGcGauge = registry.gauge(metricNamePrefix + "tasksNeedingGc");
tasksToGcGauge = registry.gauge(metricNamePrefix + "tasksToGc");
}
@Activator
public void enterActiveMode() {
ScheduleDescriptor scheduleDescriptor = ScheduleDescriptor.newBuilder()
.withName("gcArchivedTasks")
.withDescription("GC oldest archived pasts once the criteria is met")
.withInitialDelay(Duration.ofMillis(configuration.getGcInitialDelayMs()))
.withInterval(Duration.ofMillis(configuration.getGcIntervalMs()))
.withTimeout(Duration.ofMillis(configuration.getGcTimeoutMs()))
.build();
this.schedulerRef = titusRuntime.getLocalScheduler().schedule(
scheduleDescriptor,
e -> gc(),
ExecutorsExt.namedSingleThreadExecutor(ArchivedTasksGc.class.getSimpleName())
);
}
@Deactivator
@PreDestroy
public void shutdown() {
Evaluators.acceptNotNull(schedulerRef, ScheduleReference::cancel);
}
@VisibleForTesting
void gc() {
if (!configuration.isGcEnabled()) {
logger.info("GC is not enabled");
return;
}
long maxNumberOfArchivedTasksPerJob = configuration.getMaxNumberOfArchivedTasksPerJob();
List<String> jobIds = jobOperations.getJobs().stream().map(Job::getId).collect(Collectors.toList());
logger.info("Evaluating {} jobs for GC", jobIds.size());
jobsEvaluatedGauge.set(jobIds.size());
List<Observable<Pair<String, Long>>> archivedTaskCountObservables = jobIds.stream()
.map(jobId -> jobStore.retrieveArchivedTaskCountForJob(jobId).map(count -> Pair.of(jobId, count)))
.collect(Collectors.toList());
List<Pair<String, Long>> archivedTaskCountsPerJob = Observable.merge(archivedTaskCountObservables, configuration.getMaxRxConcurrency())
.toList().toBlocking().singleOrDefault(Collections.emptyList());
logger.debug("archivedTaskCountsPerJob: {}", archivedTaskCountsPerJob);
List<String> jobsNeedingGc = new ArrayList<>();
for (Pair<String, Long> archivedTaskCountPair : archivedTaskCountsPerJob) {
if (archivedTaskCountPair.getRight() > maxNumberOfArchivedTasksPerJob) {
jobsNeedingGc.add(archivedTaskCountPair.getLeft());
}
}
logger.info("{} jobs need GC: {}", jobsNeedingGc.size(), jobsNeedingGc);
jobsNeedingGcGauge.set(jobsNeedingGc.size());
List<Observable<Pair<String, List<Task>>>> archivedTaskObservables = jobsNeedingGc.stream()
.map(jobId -> jobStore.retrieveArchivedTasksForJob(jobId).toList().map(l -> Pair.of(jobId, l)))
.collect(Collectors.toList());
List<Pair<String, List<Task>>> archivedTasksPerJob = Observable.merge(archivedTaskObservables, configuration.getMaxRxConcurrency())
.toList().toBlocking().singleOrDefault(Collections.emptyList());
List<Task> archivedTasksNeedingGc = new ArrayList<>();
for (Pair<String, List<Task>> archivedTasksPair : archivedTasksPerJob) {
List<Task> archivedTasksToGc = getArchivedTasksToGc(archivedTasksPair.getRight(), maxNumberOfArchivedTasksPerJob);
archivedTasksNeedingGc.addAll(archivedTasksToGc);
}
logger.info("{} tasks need GC", archivedTasksNeedingGc.size());
tasksNeedingGcGauge.set(archivedTasksNeedingGc.size());
List<Task> archivedTasksToGc = archivedTasksNeedingGc.stream()
.limit(configuration.getMaxNumberOfArchivedTasksToGcPerIteration())
.collect(Collectors.toList());
List<String> archivedTasksToGcIds = archivedTasksToGc.stream().map(Task::getId).collect(Collectors.toList());
logger.info("Starting to GC {} tasks: {}", archivedTasksToGc.size(), archivedTasksToGcIds);
tasksToGcGauge.set(archivedTasksToGc.size());
List<Completable> deleteArchivedTaskCompletables = archivedTasksToGc.stream()
.map(t -> jobStore.deleteArchivedTask(t.getJobId(), t.getId())).collect(Collectors.toList());
Completable.merge(Observable.from(deleteArchivedTaskCompletables), configuration.getMaxRxConcurrency()).await();
logger.info("Finished GC");
}
static List<Task> getArchivedTasksToGc(List<Task> tasks, long maxNumberOfArchivedTasksPerJob) {
int total = tasks.size();
if (total > maxNumberOfArchivedTasksPerJob) {
tasks.sort(Comparator.comparing(t -> JobFunctions.findTaskStatus(t, TaskState.Accepted).map(ExecutableStatus::getTimestamp).orElse(0L)));
int numberOfTasksToGc = (int) (total - maxNumberOfArchivedTasksPerJob);
return tasks.subList(0, numberOfTasksToGc);
}
return Collections.emptyList();
}
}
| 89 |
0 | Create_ds/titus-control-plane/titus-server-master/src/main/java/com/netflix/titus/master | Create_ds/titus-control-plane/titus-server-master/src/main/java/com/netflix/titus/master/config/ConfigurableCellInfoResolver.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.master.config;
import javax.inject.Inject;
import javax.inject.Singleton;
@Singleton
public class ConfigurableCellInfoResolver implements CellInfoResolver {
private final MasterConfiguration configuration;
@Inject
public ConfigurableCellInfoResolver(MasterConfiguration configuration) {
this.configuration = configuration;
}
@Override
public String getCellName() {
return configuration.getCellName();
}
}
| 90 |
0 | Create_ds/titus-control-plane/titus-server-master/src/main/java/com/netflix/titus/master | Create_ds/titus-control-plane/titus-server-master/src/main/java/com/netflix/titus/master/config/CellInfoResolver.java | /*
* Copyright 2018 Netflix, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.netflix.titus.master.config;
public interface CellInfoResolver {
String getCellName();
}
| 91 |
0 | Create_ds/titus-control-plane/titus-server-master/src/main/java/com/netflix/titus/master | Create_ds/titus-control-plane/titus-server-master/src/main/java/com/netflix/titus/master/config/MasterConfiguration.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.master.config;
import com.netflix.archaius.api.annotations.DefaultValue;
import com.netflix.archaius.api.annotations.PropertyName;
public interface MasterConfiguration {
@PropertyName(name = "titus.localmode")
@DefaultValue("false")
boolean isLocalMode();
@PropertyName(name = "titus.master.cellName")
@DefaultValue("dev")
String getCellName();
@PropertyName(name = "titus.master.apiProxyPort")
@DefaultValue("7001")
int getApiProxyPort();
@PropertyName(name = "titus.master.api.status.path")
@DefaultValue("/api/v2/jobs/heartbeat")
String getApiStatusUri();
@PropertyName(name = "titus.master.host")
@DefaultValue("")
String getMasterHost();
@PropertyName(name = "titus.master.ip")
@DefaultValue("")
String getMasterIP();
} | 92 |
0 | Create_ds/titus-control-plane/titus-server-master/src/main/java/com/netflix/titus/master | Create_ds/titus-control-plane/titus-server-master/src/main/java/com/netflix/titus/master/config/ConfigurationConstants.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.master.config;
/**
* Compile time constants used by configuration interfaces.
*/
public final class ConfigurationConstants {
public static final String ONE_HOUR = "" + (60 * 60 * 1000);
public static final String ONE_MINUTE = "" + (60 * 1000);
public static final String TEN_MINUTES = "" + (10 * 60 * 1000);
private ConfigurationConstants() {
}
}
| 93 |
0 | Create_ds/titus-control-plane/titus-server-master/src/main/java/com/netflix/titus/master | Create_ds/titus-control-plane/titus-server-master/src/main/java/com/netflix/titus/master/health/HealthModule.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.master.health;
import com.google.inject.AbstractModule;
import com.netflix.titus.grpc.protogen.HealthGrpc.HealthImplBase;
import com.netflix.titus.master.health.endpoint.grpc.DefaultHealthServiceGrpc;
import com.netflix.titus.master.health.service.DefaultHealthService;
import com.netflix.titus.master.health.service.HealthService;
public class HealthModule extends AbstractModule {
@Override
protected void configure() {
install(new com.netflix.runtime.health.guice.HealthModule());
bind(HealthImplBase.class).to(DefaultHealthServiceGrpc.class);
bind(HealthService.class).to(DefaultHealthService.class);
}
}
| 94 |
0 | Create_ds/titus-control-plane/titus-server-master/src/main/java/com/netflix/titus/master/health/endpoint | Create_ds/titus-control-plane/titus-server-master/src/main/java/com/netflix/titus/master/health/endpoint/grpc/DefaultHealthServiceGrpc.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.master.health.endpoint.grpc;
import javax.inject.Inject;
import javax.inject.Singleton;
import com.netflix.titus.grpc.protogen.HealthCheckRequest;
import com.netflix.titus.grpc.protogen.HealthCheckResponse;
import com.netflix.titus.grpc.protogen.HealthCheckResponse.Details;
import com.netflix.titus.grpc.protogen.HealthGrpc;
import com.netflix.titus.master.health.service.HealthService;
import io.grpc.stub.StreamObserver;
@Singleton
public class DefaultHealthServiceGrpc extends HealthGrpc.HealthImplBase {
private final HealthService healthService;
@Inject
public DefaultHealthServiceGrpc(HealthService healthService) {
this.healthService = healthService;
}
@Override
public void check(HealthCheckRequest request, StreamObserver<HealthCheckResponse> responseObserver) {
Details details = healthService.getServerStatus();
responseObserver.onNext(HealthCheckResponse.newBuilder()
.setStatus(details.getStatus())
.addDetails(HealthCheckResponse.ServerStatus.newBuilder()
.setDetails(details)
.build())
.build());
responseObserver.onCompleted();
}
}
| 95 |
0 | Create_ds/titus-control-plane/titus-server-master/src/main/java/com/netflix/titus/master/health | Create_ds/titus-control-plane/titus-server-master/src/main/java/com/netflix/titus/master/health/service/DefaultHealthService.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.master.health.service;
import java.lang.management.ManagementFactory;
import java.lang.management.RuntimeMXBean;
import java.util.Comparator;
import java.util.List;
import java.util.stream.Collectors;
import javax.inject.Inject;
import javax.inject.Singleton;
import com.google.protobuf.Duration;
import com.google.protobuf.util.Durations;
import com.google.protobuf.util.Timestamps;
import com.netflix.titus.common.util.guice.ActivationLifecycle;
import com.netflix.titus.common.util.tuple.Pair;
import com.netflix.titus.grpc.protogen.HealthCheckResponse.Details;
import com.netflix.titus.grpc.protogen.ServiceActivation;
import com.netflix.titus.api.supervisor.service.LeaderActivator;
import com.netflix.titus.master.config.CellInfoResolver;
import static com.netflix.titus.grpc.protogen.HealthCheckResponse.ServingStatus.NOT_SERVING;
import static com.netflix.titus.grpc.protogen.HealthCheckResponse.ServingStatus.SERVING;
@Singleton
public class DefaultHealthService implements HealthService {
private final CellInfoResolver cellInfoResolver;
private final ActivationLifecycle activationLifecycle;
private final LeaderActivator leaderActivator;
@Inject
public DefaultHealthService(CellInfoResolver cellInfoResolver,
ActivationLifecycle activationLifecycle,
LeaderActivator leaderActivator) {
this.cellInfoResolver = cellInfoResolver;
this.activationLifecycle = activationLifecycle;
this.leaderActivator = leaderActivator;
}
public Details getServerStatus() {
RuntimeMXBean rb = ManagementFactory.getRuntimeMXBean();
Duration uptime = Durations.fromMillis(rb.getUptime());
if (!leaderActivator.isLeader()) {
return Details.newBuilder()
.setStatus(NOT_SERVING)
.setLeader(false)
.setActive(false)
.setUptime(uptime)
.build();
}
boolean active = leaderActivator.isActivated();
List<ServiceActivation> serviceActivations = activationLifecycle.getServiceActionTimesMs().stream()
.sorted(Comparator.comparing(Pair::getRight))
.map(pair -> ServiceActivation.newBuilder()
.setName(pair.getLeft())
.setActivationTime(Durations.fromMillis(pair.getRight()))
.build())
.collect(Collectors.toList());
Details.Builder details = Details.newBuilder()
.setStatus(SERVING)
.setCell(cellInfoResolver.getCellName())
.setLeader(true)
.setActive(active)
.setUptime(uptime)
.setElectionTimestamp(Timestamps.fromMillis(leaderActivator.getElectionTimestamp()))
.setActivationTimestamp(Timestamps.fromMillis(leaderActivator.getActivationEndTimestamp()))
.addAllServiceActivationTimes(serviceActivations);
if (active) {
details.setActivationTime(Durations.fromMillis(leaderActivator.getActivationTime()));
}
return details.build();
}
}
| 96 |
0 | Create_ds/titus-control-plane/titus-server-master/src/main/java/com/netflix/titus/master/health | Create_ds/titus-control-plane/titus-server-master/src/main/java/com/netflix/titus/master/health/service/HealthService.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.master.health.service;
import com.netflix.titus.grpc.protogen.HealthCheckResponse;
public interface HealthService {
public HealthCheckResponse.Details getServerStatus();
}
| 97 |
0 | Create_ds/titus-control-plane/titus-server-master/src/main/java/com/netflix/titus/master | Create_ds/titus-control-plane/titus-server-master/src/main/java/com/netflix/titus/master/scheduler/SchedulerModule.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.master.scheduler;
import javax.inject.Singleton;
import com.google.inject.AbstractModule;
import com.google.inject.Provides;
import com.netflix.archaius.ConfigProxyFactory;
import com.netflix.titus.grpc.protogen.SchedulerServiceGrpc;
import com.netflix.titus.master.scheduler.endpoint.grpc.DefaultSchedulerServiceGrpc;
public final class SchedulerModule extends AbstractModule {
@Override
protected void configure() {
bind(SchedulerServiceGrpc.SchedulerServiceImplBase.class).to(DefaultSchedulerServiceGrpc.class);
}
@Provides
@Singleton
public SchedulerConfiguration getSchedulerConfiguration(ConfigProxyFactory factory) {
return factory.newProxy(SchedulerConfiguration.class);
}
}
| 98 |
0 | Create_ds/titus-control-plane/titus-server-master/src/main/java/com/netflix/titus/master | Create_ds/titus-control-plane/titus-server-master/src/main/java/com/netflix/titus/master/scheduler/SchedulerConfiguration.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.master.scheduler;
import com.netflix.archaius.api.annotations.Configuration;
import com.netflix.archaius.api.annotations.DefaultValue;
/**
* Configuration used by the regional failover.
*/
@Configuration(prefix = "titus.scheduler")
public interface SchedulerConfiguration {
/**
* An option to enable spreading for service jobs in the critical tier.
*
* @return whether or not to prefer spreading for service jobs in the critical tier.
*/
@DefaultValue("true")
boolean isCriticalServiceJobSpreadingEnabled();
} | 99 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.