Java tutorial
/* * Copyright [2014] [Christian Loehnert, krampenschiesser@gmail.com] * 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 de.ks.file; import com.google.common.net.MediaType; import de.ks.activity.executor.ActivityExecutor; import de.ks.idnadrev.entity.FileReference; import de.ks.option.Options; import de.ks.persistence.PersistentWork; import de.ks.persistence.transaction.TransactionProvider; import de.ks.reflection.PropertyPath; import org.apache.commons.codec.digest.DigestUtils; import org.apache.commons.lang3.StringUtils; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import javax.inject.Inject; import javax.persistence.criteria.Predicate; import java.io.File; import java.io.FileInputStream; import java.io.IOException; import java.nio.file.Files; import java.nio.file.Path; import java.nio.file.Paths; import java.nio.file.StandardCopyOption; import java.util.List; import java.util.concurrent.CompletableFuture; public class FileStore { private static final Logger log = LoggerFactory.getLogger(FileStore.class); private static final String KEY_MIMETYPE = PropertyPath.property(FileReference.class, r -> r.getMimeType()); private final FileOptions options; @Inject ActivityExecutor executorService; public FileStore() { options = Options.get(FileOptions.class); } public CompletableFuture<FileReference> getReference(File file) { if (!file.exists()) { throw new IllegalArgumentException("File " + file + " does not exist"); } CompletableFuture<String> md5Sum = CompletableFuture.supplyAsync(() -> getMd5(file), executorService); return md5Sum.thenApply(md5 -> resolveReference(md5, file)); } protected FileReference resolveReference(String md5, File file) { String mimeType = getMimeType(file); long size = getFileSize(file); FileReference fileReference = PersistentWork.forName(FileReference.class, file.getName()); if (fileReference != null) { String originalMd5 = fileReference.getMd5Sum(); if (!originalMd5.equals(md5)) { log.info("MD5Sum of file {} has changed from {} to {}", file.getName(), originalMd5, md5); } fileReference.setMd5Sum(md5); fileReference.setMimeType(mimeType); fileReference.setSizeInBytes(size); return fileReference; } else { FileReference reference = new FileReference(file.getName(), md5); reference.setSizeInBytes(size); reference.setMimeType(mimeType); return reference; } } private long getFileSize(File file) { try { return Files.size(file.toPath()); } catch (IOException e) { log.error("Could not get filesize from {}", file, e); return -1; } } private String getMimeType(File file) { Path path = file.toPath(); try { return Files.probeContentType(path); } catch (IOException e) { log.error("Could not get mime type from ", file, e); return null; } } protected String getMd5(File file) { try { return DigestUtils.md5Hex(new FileInputStream(file)); } catch (IOException e) { log.error("Could not read md5 from file {}", file, e); throw new RuntimeException(e); } } public File getFile(FileReference fileReference) { Path path = Paths.get(getFileStoreDir(), fileReference.getMd5Sum(), fileReference.getName()); return path.toFile(); } public void scheduleCopy(FileReference reference, File file) { CopyFileAfterCommit synchronization = new CopyFileAfterCommit(() -> { saveInFileStore(reference, file); }); TransactionProvider.instance.getCurrentTransaction().ifPresent(tx -> { tx.registerSynchronization(synchronization); }); } public void saveInFileStore(FileReference ref, File file) { if (!file.exists()) { throw new IllegalArgumentException("File " + file + " has to exist"); } if (ref.getMd5Sum() == null) { throw new IllegalArgumentException("MD5 sum has to be calculated"); } Path dir = Paths.get(getFileStoreDir(), ref.getMd5Sum()); try { Files.createDirectories(dir); } catch (IOException e) { log.error("Could not store create parent directory {}", dir, e); return; } Path targetPath = Paths.get(getFileStoreDir(), ref.getMd5Sum(), ref.getName()); if (options.shouldCopy()) { try { Files.copy(file.toPath(), targetPath, StandardCopyOption.REPLACE_EXISTING); } catch (IOException e) { log.error("could not copy {} to {}", file.toPath(), targetPath); throw new RuntimeException(e); } } else { try { Files.move(file.toPath(), targetPath, StandardCopyOption.REPLACE_EXISTING); } catch (IOException e) { log.error("could not move {} to {}", file.toPath(), targetPath); throw new RuntimeException(e); } } } public String getFileStoreDir() { return Options.get(FileOptions.class).getFileStoreDir(); } public String replaceFileStoreDir(String description) { String replacement = "file://" + getFileStoreDir(); if (!replacement.endsWith(File.separator)) { replacement = replacement + File.separator; } String newDescription = StringUtils.replace(description, FileReference.FILESTORE_VAR, replacement); return newDescription; } public List<FileReference> getFilesByMimeType(MediaType mediaType) { assert mediaType != null; List<FileReference> references = PersistentWork.from(FileReference.class, (root, query, builder) -> { javax.persistence.criteria.Path<String> mimeType = root.get(KEY_MIMETYPE); if (!mediaType.type().equals("*")) { String pattern = mediaType.type() + "%"; Predicate like = builder.like(mimeType, pattern); query.where(like); } }, null); log.info("Found {} references for mimeType {}", references.size(), mediaType.type()); return references; } }