Java tutorial
/* * 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(); } }