org.springframework.cloud.deployer.spi.scheduler.Scheduler Java Examples

@Override
public Launcher createLauncher(String account) {
	KubernetesDeployerProperties kubernetesProperties = this.platformProperties.accountProperties(account);
	ContainerFactory containerFactory = new DefaultContainerFactory(
			this.platformProperties.accountProperties(account));
	KubernetesClient kubernetesClient =
			KubernetesClientFactory.getKubernetesClient(this.platformProperties.accountProperties(account));

	KubernetesTaskLauncher kubernetesTaskLauncher = new KubernetesTaskLauncher(
			kubernetesProperties, kubernetesClient, containerFactory);

	Scheduler scheduler = getScheduler(schedulerProperties, kubernetesClient);
	Launcher launcher = new Launcher(account, KUBERNETES_PLATFORM_TYPE, kubernetesTaskLauncher, scheduler);

	launcher.setDescription(
			String.format("master url = [%s], namespace = [%s], api version = [%s]",
					kubernetesClient.getMasterUrl(), kubernetesClient.getNamespace(),
					kubernetesClient.getApiVersion()));

	return launcher;
}
 

@Bean
public Scheduler localScheduler() {
	// This is in auto-config package and we can depend on that, use same
	// dummy no-op impl here.
	return new Scheduler() {
		@Override
		public void schedule(ScheduleRequest scheduleRequest) {
			throw new UnsupportedOperationException("Scheduling is not implemented for local platform.");
		}

		@Override
		public void unschedule(String scheduleName) {
			throw new UnsupportedOperationException("Scheduling is not implemented for local platform.");
		}

		@Override
		public List<ScheduleInfo> list(String taskDefinitionName) {
			return Collections.emptyList();
		}

		@Override
		public List<ScheduleInfo> list() {
			return Collections.emptyList();
		}
	};
}
 

@Bean
@ConditionalOnMissingBean
public Scheduler localScheduler() {
	return new Scheduler() {
		@Override
		public void schedule(ScheduleRequest scheduleRequest) {
			throw new UnsupportedOperationException("Interface is not implemented for schedule method.");
		}

		@Override
		public void unschedule(String scheduleName) {
			throw new UnsupportedOperationException("Interface is not implemented for unschedule method.");
		}

		@Override
		public List<ScheduleInfo> list(String taskDefinitionName) {
			throw new UnsupportedOperationException("Interface is not implemented for list method.");
		}

		@Override
		public List<ScheduleInfo> list() {
			throw new UnsupportedOperationException("Interface is not implemented for list method.");
		}
	};
}
 

public Scheduler localTestScheduler() {
	return new Scheduler() {
		@Override
		public void schedule(ScheduleRequest scheduleRequest) {
			throw new UnsupportedOperationException("Interface is not implemented for schedule method.");
		}

		@Override
		public void unschedule(String scheduleName) {
			throw new UnsupportedOperationException("Interface is not implemented for unschedule method.");
		}

		@Override
		public List<ScheduleInfo> list(String taskDefinitionName) {
			throw new UnsupportedOperationException("Interface is not implemented for list method.");
		}

		@Override
		public List<ScheduleInfo> list() {
			return getSampleList();
		}
	};
}
 

@Bean
@ConditionalOnMissingBean
public Scheduler localScheduler() {
	return new Scheduler() {
		@Override
		public void schedule(ScheduleRequest scheduleRequest) {
			throw new UnsupportedOperationException("Scheduling is not implemented for local platform.");
		}

		@Override
		public void unschedule(String scheduleName) {
			throw new UnsupportedOperationException("Scheduling is not implemented for local platform.");
		}

		@Override
		public List<ScheduleInfo> list(String taskDefinitionName) {
			return Collections.emptyList();
		}

		@Override
		public List<ScheduleInfo> list() {
			return Collections.emptyList();
		}
	};
}
 

private List<String> getCommandLineArguments(List<String> commandLineArguments) {
	Scheduler mockScheduler = mock(SimpleTestScheduler.class);
	TaskDefinitionRepository mockTaskDefinitionRepository = mock(TaskDefinitionRepository.class);
	AppRegistryService mockAppRegistryService = mock(AppRegistryService.class);

	Launcher launcher = new Launcher("default", "defaultType", null, mockScheduler);
	List<Launcher> launchers = new ArrayList<>();
	launchers.add(launcher);
	List<TaskPlatform> taskPlatform = Collections.singletonList(new TaskPlatform("testTaskPlatform", launchers));
	SchedulerService mockSchedulerService = new DefaultSchedulerService(mock(CommonApplicationProperties.class),
			taskPlatform, mockTaskDefinitionRepository, mockAppRegistryService, mock(ResourceLoader.class),
			this.taskConfigurationProperties, mock(DataSourceProperties.class), "uri",
			mock(ApplicationConfigurationMetadataResolver.class), mock(SchedulerServiceProperties.class),
			mock(AuditRecordService.class));

	TaskDefinition taskDefinition = new TaskDefinition(BASE_DEFINITION_NAME, "timestamp");

	when(mockTaskDefinitionRepository.findById(BASE_DEFINITION_NAME)).thenReturn(Optional.of(taskDefinition));
	when(mockAppRegistryService.getAppResource(any())).thenReturn(new DockerResource("springcloudtask/timestamp-task:latest"));
	when(mockAppRegistryService.find(taskDefinition.getRegisteredAppName(), ApplicationType.task))
			.thenReturn(new AppRegistration());
	mockSchedulerService.schedule(BASE_SCHEDULE_NAME, BASE_DEFINITION_NAME, this.testProperties,
			commandLineArguments, null);

	ArgumentCaptor<ScheduleRequest> scheduleRequestArgumentCaptor = ArgumentCaptor.forClass(ScheduleRequest.class);
	verify(mockScheduler).schedule(scheduleRequestArgumentCaptor.capture());

	return scheduleRequestArgumentCaptor.getValue().getCommandlineArguments();
}
 

@Bean
public TaskPlatform taskCFPlatform(Scheduler scheduler) {
	Launcher launcher = new Launcher(KUBERNETES_PLATFORM, "Kubernetes", Mockito.mock(TaskLauncher.class), scheduler);
	List<Launcher> launchers = new ArrayList<>();
	launchers.add(launcher);
	TaskPlatform taskPlatform = new TaskPlatform(KUBERNETES_PLATFORM, launchers);
	return taskPlatform;
}
 

private Scheduler getScheduler(Optional<KubernetesSchedulerProperties> kubernetesSchedulerProperties,
		KubernetesClient kubernetesClient) {
	Scheduler scheduler = null;

	if (schedulesEnabled) {
		KubernetesSchedulerProperties schedulerProperties = kubernetesSchedulerProperties
				.orElseGet(KubernetesSchedulerProperties::new);
		scheduler = new KubernetesScheduler(kubernetesClient, schedulerProperties);
	}

	return scheduler;
}
 

@Bean
@ConditionalOnMissingBean
public Scheduler scheduler(ReactorSchedulerClient client,
		CloudFoundryOperations operations,
		CloudFoundryConnectionProperties properties,
		TaskLauncher taskLauncher,
		CloudFoundrySchedulerProperties schedulerProperties) {
	return new CloudFoundryAppScheduler(client, operations, properties,
			(CloudFoundryTaskLauncher) taskLauncher,
			schedulerProperties);
}
 

private List<String> getCommandLineArguments(List<String> commandLineArguments) {
	Scheduler mockScheduler = mock(SimpleTestScheduler.class);
	TaskDefinitionRepository mockTaskDefinitionRepository = mock(TaskDefinitionRepository.class);
	AppRegistryService mockAppRegistryService = mock(AppRegistryService.class);

	Launcher launcher = new Launcher("default", "defaultType", null, mockScheduler);
	List<Launcher> launchers = new ArrayList<>();
	launchers.add(launcher);
	List<TaskPlatform> taskPlatform = Collections.singletonList(new TaskPlatform("testTaskPlatform", launchers));
	SchedulerService mockSchedulerService = new DefaultSchedulerService(mock(CommonApplicationProperties.class),
			taskPlatform, mockTaskDefinitionRepository, mockAppRegistryService, mock(ResourceLoader.class),
			this.taskConfigurationProperties, mock(DataSourceProperties.class), "uri",
			mock(ApplicationConfigurationMetadataResolver.class), mock(SchedulerServiceProperties.class),
			mock(AuditRecordService.class));

	TaskDefinition taskDefinition = new TaskDefinition(BASE_DEFINITION_NAME, "timestamp");

	when(mockTaskDefinitionRepository.findById(BASE_DEFINITION_NAME)).thenReturn(Optional.of(taskDefinition));
	when(mockAppRegistryService.getAppResource(any())).thenReturn(new DockerResource("springcloudtask/timestamp-task:latest"));
	when(mockAppRegistryService.find(taskDefinition.getRegisteredAppName(), ApplicationType.task))
			.thenReturn(new AppRegistration());
	mockSchedulerService.schedule(BASE_SCHEDULE_NAME, BASE_DEFINITION_NAME, this.testProperties,
			commandLineArguments, null);

	ArgumentCaptor<ScheduleRequest> scheduleRequestArgumentCaptor = ArgumentCaptor.forClass(ScheduleRequest.class);
	verify(mockScheduler).schedule(scheduleRequestArgumentCaptor.capture());

	return scheduleRequestArgumentCaptor.getValue().getCommandlineArguments();
}
 

@Test
public void testLocalSchedulerEnabled() {
	assertFalse("K8s should be disabled", context.getEnvironment().containsProperty("kubernetes_service_host"));
	assertFalse("CF should be disabled", CloudPlatform.CLOUD_FOUNDRY.isActive(context.getEnvironment()));

	Scheduler scheduler = context.getBean(Scheduler.class);

	assertNotNull(scheduler);
	assertTrue(scheduler.getClass().getName().contains("LocalSchedulerAutoConfiguration"));
}
 

/**
 * The default profile is active when no other profiles are active. This is configured so
 * that several tests will pass without having to explicitly enable the local profile.
 * @param localPlatformProperties the local platform properties
 * @param localScheduler the local scheduler
 *
 * @return the task platform
 */
@Profile({ "local", "default" })
@Bean
public TaskPlatform localTaskPlatform(LocalPlatformProperties localPlatformProperties,
		@Nullable Scheduler localScheduler) {
	TaskPlatform taskPlatform = new LocalTaskPlatformFactory(localPlatformProperties, localScheduler)
			.createTaskPlatform();
	taskPlatform.setPrimary(true);
	return taskPlatform;
}
 

@Before
public void setupMockMVC() {
	this.mockMvc = MockMvcBuilders.webAppContextSetup(wac)
			.defaultRequest(get("/").accept(MediaType.APPLICATION_JSON)).build();
	Launcher launcher = new Launcher("default", "local", taskLauncher);
	Launcher cfLauncher = new Launcher("cf", "Cloud Foundry", mock(TaskLauncher.class));
	Launcher cfLauncherWithScheduler = new Launcher("cfsched", "Cloud Foundry", mock(TaskLauncher.class), mock(Scheduler.class));
	this.launcherRepository.save(launcher);
	this.launcherRepository.save(cfLauncher);
	this.launcherRepository.save(cfLauncherWithScheduler);
}
 

@Bean
public Scheduler scheduler() {
	return new SimpleTestScheduler();
}
 

public LocalTaskPlatformFactory(LocalPlatformProperties platformProperties, Scheduler localScheduler) {
	super(platformProperties, LOCAL_PLATFORM_TYPE);
	this.localScheduler = localScheduler;
}
 

@Bean
public Scheduler scheduler() {
	return mock(Scheduler.class);
}
 

@Bean
public Scheduler scheduler() {
	return mock(Scheduler.class);
}
 

public Launcher(String name, String type, TaskLauncher taskLauncher, Scheduler scheduler) {
	this.name = name;
	this.type = type;
	this.taskLauncher = taskLauncher;
	this.scheduler = scheduler;
}
 

public Scheduler getScheduler() {
	return scheduler;
}
 

public void setScheduler(Scheduler scheduler) {
	this.scheduler = scheduler;
}
 

@Bean
Scheduler scheduler() {
	return new SimpleTestScheduler();
}
 

@Override
protected Scheduler provideScheduler() {
	return this.scheduler;
}
 

@Test(expected = NoSuchBeanDefinitionException.class)
public void testLocalSchedulerEnabled() {
	assertFalse(context.getEnvironment().containsProperty("kubernetes_service_host"));
	assertFalse(CloudPlatform.CLOUD_FOUNDRY.isActive(context.getEnvironment()));
	context.getBean(Scheduler.class);
}
 

@Override
protected Scheduler provideScheduler() {
	return this.scheduler;
}
 

public SchedulerWrapper(Scheduler wrapped) {
	this.wrapped = wrapped;
}
 

@Bean
public Scheduler scheduler(KubernetesClient kubernetesClient) {
	return new KubernetesScheduler(kubernetesClient, kubernetesSchedulerProperties);
}
 

/**
 * To be implemented by subclasses, which should return the instance of Scheduler that needs
 * to be tested. Can be used if subclasses decide to add additional implementation-specific tests.
 */
protected abstract Scheduler provideScheduler();
 

/**
 * Subclasses should call this method to interact with the Scheduler under test.
 * Returns a wrapper around the scheduler returned by {@link #provideScheduler()}, that keeps
 * track of which tasks have been scheduled and unscheduled.
 */
protected Scheduler taskScheduler() {
	return this.schedulerWrapper;
}