kz.greetgo.scheduling.scheduler.SchedulerBuilder Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of greetgo.scheduling Show documentation
Scheduler using in greetgo!
There is a newer version: 3.1.1
package kz.greetgo.scheduling.scheduler;

import kz.greetgo.scheduling.collector.Task;

import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.Set;

import static java.util.stream.Collectors.toMap;

public class SchedulerBuilder {

  private SchedulerBuilder() {}

  public static SchedulerBuilder newSchedulerBuilder() {
    return new SchedulerBuilder();
  }

  private ThrowCatcher throwCatcher = Throwable::printStackTrace;

  public SchedulerBuilder setThrowCatcher(ThrowCatcher throwCatcher) {
    Objects.requireNonNull(throwCatcher);
    this.throwCatcher = throwCatcher;
    return this;
  }

  public int defaultExecutionPoolSize = 170;

  private long pingDelayMillis = 200;

  public SchedulerBuilder setPingDelayMillis(int pingDelayMillis) {
    if (pingDelayMillis < 0) {
      throw new IllegalArgumentException("pingDelayMillis cannot be negative");
    }
    this.pingDelayMillis = pingDelayMillis;
    return this;
  }

  public SchedulerBuilder setDefaultExecutionPoolSize(int defaultExecutionPoolSize) {
    if (defaultExecutionPoolSize < 1) {
      throw new IllegalArgumentException("ExecutionPoolSize can be 1 or more");
    }
    this.defaultExecutionPoolSize = defaultExecutionPoolSize;
    return this;
  }

  private final Map executionPoolSizeMap = new HashMap<>();

  public SchedulerBuilder setExecutionPoolSize(String executionPoolName, int size) {
    executionPoolSizeMap.put(executionPoolName, size);
    return this;
  }

  public int getExecutionPoolSize(String executionPoolName) {
    Integer size = executionPoolSizeMap.get(executionPoolName);
    return size == null ? defaultExecutionPoolSize : size;
  }

  private List taskList = new ArrayList<>();

  public SchedulerBuilder addTask(Task task) {
    taskList.add(task);
    return this;
  }

  public SchedulerBuilder addTasks(Collection task) {
    taskList.addAll(task);
    return this;
  }

  public Scheduler build() {

    Map taskHolderMap = new HashMap<>();
    Set executionNameSet = new HashSet<>();

    for (Task task : taskList) {
      if (taskHolderMap.containsKey(task.id())) {
        throw new RuntimeException("Duplicate task id = `" + task.id() + "`");
      }
      executionNameSet.add(task.executionPoolName());
      taskHolderMap.put(task.id(), new TaskHolder(task, throwCatcher));
    }

    Map executionPoolMap = executionNameSet
      .stream()
      .collect(toMap(name -> name, name -> new ExecutionPool(name, getExecutionPoolSize(name))));

    return new Scheduler(new ArrayList<>(taskHolderMap.values()), executionPoolMap, pingDelayMillis);

  }

}