/*
* 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.apache.lucene.mockfile;
import java.io.IOException;
import java.io.OutputStream;
import java.nio.channels.AsynchronousFileChannel;
import java.nio.channels.FileChannel;
import java.nio.channels.SeekableByteChannel;
import java.nio.file.CopyOption;
import java.nio.file.FileSystem;
import java.nio.file.LinkOption;
import java.nio.file.OpenOption;
import java.nio.file.Path;
import java.nio.file.StandardOpenOption;
import java.nio.file.attribute.FileAttribute;
import java.util.Arrays;
import java.util.Set;
import java.util.concurrent.ExecutorService;
import org.apache.lucene.util.IOUtils;
import org.apache.lucene.util.InfoStream;
/**
* FileSystem that records all major destructive filesystem activities.
*/
public class VerboseFS extends FilterFileSystemProvider {
final InfoStream infoStream;
final Path root;
/**
* Create a new instance, recording major filesystem write activities
* (create, delete, etc) to the specified {@code InfoStream}.
* @param delegate delegate filesystem to wrap.
* @param infoStream infoStream to send messages to. The component for
* messages is named "FS".
*/
public VerboseFS(FileSystem delegate, InfoStream infoStream) {
super("verbose://", delegate);
this.infoStream = infoStream;
this.root = this.getFileSystem(null).getPath(".").toAbsolutePath().normalize();
}
/** Records message, and rethrows exception if not null */
private void sop(String text, Throwable exception) throws IOException {
if (exception == null) {
if (infoStream.isEnabled("FS")) {
infoStream.message("FS", text);
}
} else {
if (infoStream.isEnabled("FS")) {
infoStream.message("FS", text + " (FAILED: " + exception + ")");
}
throw IOUtils.rethrowAlways(exception);
}
}
private String path(Path path) {
path = root.relativize(path.toAbsolutePath().normalize());
return path.toString();
}
@Override
public void createDirectory(Path dir, FileAttribute<?>... attrs) throws IOException {
Throwable exception = null;
try {
super.createDirectory(dir, attrs);
} catch (Throwable t) {
exception = t;
} finally {
sop("createDirectory: " + path(dir), exception);
}
}
@Override
public void delete(Path path) throws IOException {
Throwable exception = null;
try {
super.delete(path);
} catch (Throwable t) {
exception = t;
} finally {
sop("delete: " + path(path), exception);
}
}
@Override
public void copy(Path source, Path target, CopyOption... options) throws IOException {
Throwable exception = null;
try {
super.copy(source, target, options);
} catch (Throwable t) {
exception = t;
} finally {
sop("copy" + Arrays.toString(options) + ": " + path(source) + " -> " + path(target), exception);
}
}
@Override
public void move(Path source, Path target, CopyOption... options) throws IOException {
Throwable exception = null;
try {
super.move(source, target, options);
} catch (Throwable t) {
exception = t;
} finally {
sop("move" + Arrays.toString(options) + ": " + path(source) + " -> " + path(target), exception);
}
}
@Override
public void setAttribute(Path path, String attribute, Object value, LinkOption... options) throws IOException {
Throwable exception = null;
try {
super.setAttribute(path, attribute, value, options);
} catch (Throwable t) {
exception = t;
} finally {
sop("setAttribute[" + attribute + "=" + value + "]: " + path(path), exception);
}
}
@Override
public OutputStream newOutputStream(Path path, OpenOption... options) throws IOException {
Throwable exception = null;
try {
return super.newOutputStream(path, options);
} catch (Throwable t) {
exception = t;
} finally {
sop("newOutputStream" + Arrays.toString(options) + ": " + path(path), exception);
}
throw new AssertionError();
}
private boolean containsDestructive(Set<? extends OpenOption> options) {
return (options.contains(StandardOpenOption.APPEND) ||
options.contains(StandardOpenOption.WRITE) ||
options.contains(StandardOpenOption.DELETE_ON_CLOSE));
}
@Override
public FileChannel newFileChannel(Path path, Set<? extends OpenOption> options, FileAttribute<?>... attrs) throws IOException {
Throwable exception = null;
try {
return super.newFileChannel(path, options, attrs);
} catch (Throwable t) {
exception = t;
} finally {
if (containsDestructive(options)) {
sop("newFileChannel" + options + ": " + path(path), exception);
} else {
if (exception != null) {
throw IOUtils.rethrowAlways(exception);
}
}
}
throw new AssertionError();
}
@Override
public AsynchronousFileChannel newAsynchronousFileChannel(Path path, Set<? extends OpenOption> options, ExecutorService executor, FileAttribute<?>... attrs) throws IOException {
Throwable exception = null;
try {
return super.newAsynchronousFileChannel(path, options, executor, attrs);
} catch (Throwable t) {
exception = t;
} finally {
if (containsDestructive(options)) {
sop("newAsynchronousFileChannel" + options + ": " + path(path), exception);
} else {
if (exception != null) {
throw IOUtils.rethrowAlways(exception);
}
}
}
throw new AssertionError();
}
@Override
public SeekableByteChannel newByteChannel(Path path, Set<? extends OpenOption> options, FileAttribute<?>... attrs) throws IOException {
Throwable exception = null;
try {
return super.newByteChannel(path, options, attrs);
} catch (Throwable t) {
exception = t;
} finally {
if (containsDestructive(options)) {
sop("newByteChannel" + options + ": " + path(path), exception);
} else {
if (exception != null) {
throw IOUtils.rethrowAlways(exception);
}
}
}
throw new AssertionError();
}
@Override
public void createSymbolicLink(Path link, Path target, FileAttribute<?>... attrs) throws IOException {
Throwable exception = null;
try {
super.createSymbolicLink(link, target, attrs);
} catch (Throwable t) {
exception = t;
} finally {
sop("createSymbolicLink: " + path(link) + " -> " + path(target), exception);
}
}
@Override
public void createLink(Path link, Path existing) throws IOException {
Throwable exception = null;
try {
super.createLink(link, existing);
} catch (Throwable t) {
exception = t;
} finally {
sop("createLink: " + path(link) + " -> " + path(existing), exception);
}
}
@Override
public boolean deleteIfExists(Path path) throws IOException {
Throwable exception = null;
try {
return super.deleteIfExists(path);
} catch (Throwable t) {
exception = t;
} finally {
sop("deleteIfExists: " + path(path), exception);
}
throw new AssertionError();
}
}