io.activej.launchers.crdt.BackupService Maven / Gradle / Ivy

Go to download
/*
 * Copyright (C) 2020 ActiveJ 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.activej.launchers.crdt;

import io.activej.async.service.EventloopService;
import io.activej.crdt.storage.local.CrdtStorageFs;
import io.activej.crdt.storage.local.CrdtStorageMap;
import io.activej.datastream.StreamConsumer;
import io.activej.eventloop.Eventloop;
import io.activej.promise.Promise;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;

public final class BackupService, S> implements EventloopService {
	private final Eventloop eventloop;
	private final CrdtStorageMap inMemory;
	private final CrdtStorageFs localFiles;

	private long lastTimestamp = 0;

	private @Nullable Promise backupPromise = null;

	public BackupService(CrdtStorageMap inMemory, CrdtStorageFs localFiles) {
		this.inMemory = inMemory;
		this.localFiles = localFiles;
		this.eventloop = localFiles.getEventloop();
	}

	@Override
	public @NotNull Eventloop getEventloop() {
		return eventloop;
	}

	public Promise restore() {
		return localFiles.download()
				.then(supplierWithResult ->
						supplierWithResult.streamTo(StreamConsumer.ofPromise(inMemory.upload())));
	}

	public Promise backup() {
		if (backupPromise != null) {
			return backupPromise;
		}
		long lastTimestamp = this.lastTimestamp;
		this.lastTimestamp = eventloop.currentTimeMillis();
		return backupPromise = inMemory.download(lastTimestamp)
				.then(supplierWithResult -> supplierWithResult
						.streamTo(StreamConsumer.ofPromise(localFiles.upload()))
						.whenComplete(() -> backupPromise = null));
	}

	public boolean backupInProgress() {
		return backupPromise != null;
	}

	@Override
	public @NotNull Promise start() {
		return restore().then(localFiles::consolidate);
	}

	@Override
	public @NotNull Promise stop() {
		return backup();
	}
}