FileStorage.java

/*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You 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 org.cyclop.service.common;

import java.io.File;
import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.CharBuffer;
import java.nio.channels.FileChannel;
import java.nio.channels.FileLock;
import java.nio.channels.FileLockInterruptionException;
import java.nio.channels.OverlappingFileLockException;
import java.nio.charset.Charset;
import java.nio.charset.CharsetDecoder;
import java.nio.charset.CharsetEncoder;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.nio.file.StandardOpenOption;
import java.util.Optional;
import java.util.concurrent.atomic.AtomicInteger;

import javax.annotation.PostConstruct;
import javax.inject.Inject;
import javax.inject.Named;
import javax.validation.Valid;
import javax.validation.constraints.NotNull;

import net.jcip.annotations.NotThreadSafe;

import org.apache.commons.lang3.StringUtils;
import org.cyclop.common.AppConfig;
import org.cyclop.model.UserIdentifier;
import org.cyclop.model.exception.ServiceException;
import org.cyclop.service.converter.JsonMarshaller;
import org.cyclop.validation.EnableValidation;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/** @author Maciej Miklas */
@Named
@NotThreadSafe
@EnableValidation
public class FileStorage {
	private final static Logger LOG = LoggerFactory.getLogger(FileStorage.class);

	private ThreadLocal<CharsetEncoder> encoder;

	private ThreadLocal<CharsetDecoder> decoder;

	@Inject
	private AppConfig config;

	@Inject
	private JsonMarshaller jsonMarshaller;

	private boolean supported;

	private final AtomicInteger lockRetryCount = new AtomicInteger(0);

	@PostConstruct
	protected void init() {
		supported = checkSupported();

		encoder = new ThreadLocal<CharsetEncoder>() {
			@Override
			protected CharsetEncoder initialValue() {
				Charset charset = Charset.forName("UTF-8");
				CharsetEncoder decoder = charset.newEncoder();
				return decoder;
			}
		};

		decoder = new ThreadLocal<CharsetDecoder>() {
			@Override
			protected CharsetDecoder initialValue() {
				Charset charset = Charset.forName("UTF-8");
				CharsetDecoder decoder = charset.newDecoder();
				return decoder;
			}
		};
	}

	public boolean supported() {
		return supported;
	}

	protected boolean checkSupported() {
		if (!config.history.enabled) {
			LOG.info("Query history is disabled");
			return false;
		}

		File histFolder = new File(config.fileStore.folder);
		if (!histFolder.exists()) {
			LOG.warn("Query history is enabled, but configured folder does not exists:{}", histFolder);
			return false;
		}

		if (!histFolder.canWrite()) {
			LOG.warn("Query history is enabled, but configured folder is read-only:{}", histFolder);
			return false;
		}

		return true;
	}

	public void store(@NotNull UserIdentifier userId, @NotNull Object entity) throws ServiceException {
		LOG.debug("Storing file for {}", userId);
		Path histPath = getPath(userId, entity.getClass());
		try (FileChannel channel = openForWrite(histPath)) {
			String jsonText = jsonMarshaller.marshal(entity);
			ByteBuffer buf = encoder.get().encode(CharBuffer.wrap(jsonText));
			int written = channel.write(buf);
			channel.truncate(written);
		} catch (IOException | SecurityException | IllegalStateException e) {
			throw new ServiceException("Error storing query history in:" + histPath + " - " + e.getClass() + " - "
					+ e.getMessage(), e);
		}
		LOG.trace("File has been sotred {}", entity);
	}

	public @Valid <T> Optional<T> read(@NotNull UserIdentifier userId, @NotNull Class<T> clazz) throws ServiceException {
		Path filePath = getPath(userId, clazz);
		LOG.debug("Reading file {} for {}", filePath, userId);
		try (FileChannel channel = openForRead(filePath)) {
			if (channel == null) {
				LOG.debug("File not found: {}", filePath);
				return Optional.empty();
			}
			int fileSize = (int) channel.size();
			if (fileSize > config.fileStore.maxFileSize) {
				LOG.info("File: {} too large: {} - skipping it", filePath, fileSize);
				return Optional.empty();
			}
			ByteBuffer buf = ByteBuffer.allocate(fileSize);
			channel.read(buf);
			buf.flip();
			String decoded = decoder.get().decode(buf).toString();
			decoded = StringUtils.trimToNull(decoded);
			if(decoded == null) {
				return Optional.empty();
			}
			T content = jsonMarshaller.unmarshal(clazz, decoded);

			LOG.debug("File read");
			return Optional.ofNullable(content);
		} catch (IOException | SecurityException | IllegalStateException e) {
			throw new ServiceException("Error reading filr from:" + filePath + " - " + e.getMessage(), e);
		}

	}

	private FileChannel openForWrite(Path histPath) throws IOException {
		FileChannel byteChannel = FileChannel.open(histPath, StandardOpenOption.CREATE,
				StandardOpenOption.TRUNCATE_EXISTING, StandardOpenOption.WRITE);
		byteChannel.force(true);
		FileChannel lockChannel = lock(histPath, byteChannel);
		return lockChannel;
	}

	private FileChannel openForRead(Path histPath) throws IOException {
		File file = histPath.toFile();
		if (!file.exists() || !file.canRead()) {
			LOG.debug("History file not found: " + histPath);
			return null;
		}
		FileChannel byteChannel = FileChannel.open(histPath, StandardOpenOption.READ, StandardOpenOption.WRITE);
		FileChannel lockChannel = lock(histPath, byteChannel);
		return lockChannel;
	}

	private FileChannel lock(Path histPath, FileChannel channel) throws IOException {
		LOG.debug("Trying to log file: {}", histPath);
		long start = System.currentTimeMillis();
		String lastExMessage = null;
		FileChannel lockChannel = null;
		while (lockChannel == null && System.currentTimeMillis() - start < config.fileStore.lockWaitTimeoutMillis) {
			try {
				FileLock lock = channel.lock();
				lockChannel = lock.channel();
			} catch (FileLockInterruptionException | OverlappingFileLockException e) {
				lockRetryCount.incrementAndGet();
				lastExMessage = e.getMessage();
				LOG.debug("File lock on '{}' cannot be obtained (retrying operation): {}", histPath, lastExMessage);
				try {
					Thread.sleep(100);
				} catch (InterruptedException e1) {
					Thread.interrupted();
				}
			}
		}
		if (lockChannel == null) {
			throw new ServiceException("File lock on '" + histPath + "' cannot be obtained: " + lastExMessage);
		}

		return lockChannel;
	}

	private Path getPath(UserIdentifier userId, Class<?> entity) {
		String fileName = entity.getSimpleName() + "-" + userId.id + ".json";
		Path histPath = Paths.get(config.fileStore.folder, fileName);
		return histPath;
	}

	public int getLockRetryCount() {
		return lockRetryCount.get();
	}

}