io.datakernel.trigger.TriggersModule Maven / Gradle / Ivy

Go to download
/*
 * Copyright (C) 2015-2018 SoftIndex LLC.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package io.datakernel.trigger;

import io.datakernel.di.annotation.Provides;
import io.datakernel.di.annotation.ProvidesIntoSet;
import io.datakernel.di.core.Injector;
import io.datakernel.di.core.Key;
import io.datakernel.di.core.Multibinder;
import io.datakernel.di.module.AbstractModule;
import io.datakernel.jmx.KeyWithWorkerData;
import io.datakernel.launcher.LauncherService;
import io.datakernel.util.DIUtils;
import io.datakernel.util.Initializable;
import io.datakernel.util.Initializer;
import io.datakernel.worker.WorkerPool;
import io.datakernel.worker.WorkerPools;

import java.util.*;
import java.util.concurrent.CompletableFuture;
import java.util.function.Function;
import java.util.function.Supplier;

import static io.datakernel.util.DIUtils.prettyPrintSimpleKeyName;
import static java.util.Collections.emptyList;
import static java.util.Collections.emptySet;
import static java.util.concurrent.CompletableFuture.completedFuture;

public final class TriggersModule extends AbstractModule implements Initializable {
	private Function, String> keyToString = DIUtils::prettyPrintSimpleKeyName;

	private final Map, Set>> classSettings = new LinkedHashMap<>();
	private final Map, Set>> keySettings = new LinkedHashMap<>();

	private static final class TriggerConfig {
		private final Severity severity;
		private final String name;
		private final Function triggerFunction;

		TriggerConfig(Severity severity, String name,
				Function triggerFunction) {
			this.severity = severity;
			this.name = name;
			this.triggerFunction = triggerFunction;
		}

		@Override
		public boolean equals(Object o) {
			if (this == o) return true;
			if (o == null || getClass() != o.getClass()) return false;
			TriggerConfig that = (TriggerConfig) o;
			return severity == that.severity &&
					Objects.equals(name, that.name);
		}

		@Override
		public int hashCode() {
			return Objects.hash(severity, name);
		}
	}

	private static final class TriggerRegistryRecord {
		private final Severity severity;
		private final String name;
		private final Supplier triggerFunction;

		private TriggerRegistryRecord(Severity severity, String name, Supplier triggerFunction) {
			this.severity = severity;
			this.name = name;
			this.triggerFunction = triggerFunction;
		}
	}

	private TriggersModule() {
	}

	public static TriggersModule create() {
		return new TriggersModule();
	}

	public TriggersModule withNaming(Function, String> keyToString) {
		this.keyToString = keyToString;
		return this;
	}

	public  TriggersModule with(Class type, Severity severity, String name, Function triggerFunction) {
		Set> triggerConfigs = classSettings.computeIfAbsent(type, $ -> new LinkedHashSet<>());

		if (!triggerConfigs.add(new TriggerConfig<>(severity, name, triggerFunction))) {
			throw new IllegalArgumentException("Cannot assign duplicate triggers");
		}

		return this;
	}

	public  TriggersModule with(Key key, Severity severity, String name, Function triggerFunction) {
		Set> triggerConfigs = keySettings.computeIfAbsent(key, $ -> new LinkedHashSet<>());

		if (!triggerConfigs.add(new TriggerConfig<>(severity, name, triggerFunction))) {
			throw new IllegalArgumentException("Cannot assign duplicate triggers");
		}

		return this;
	}

	@Provides
	Triggers triggersWatcher(Injector injector) {
		return Triggers.create();
	}

	@ProvidesIntoSet
	LauncherService start(Injector injector, Triggers triggers) {
		return new LauncherService() {
			@Override
			public CompletableFuture start() {
				initialize(injector);
				return completedFuture(null);
			}

			@Override
			public CompletableFuture stop() {
				return completedFuture(null);
			}
		};
	}

	@SuppressWarnings("unchecked")
	private void initialize(Injector injector) {
		Triggers triggers = injector.getInstance(Triggers.class);

		Map> triggersMap = new LinkedHashMap<>();

		// register singletons
		for (Map.Entry, Object> entry : injector.peekInstances().entrySet()) {
			Key