LocalVirtualFileSystem.java

/*******************************************************************************
 * Copyright (c) 2012-2017 Codenvy, S.A.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *   Codenvy, S.A. - initial API and implementation
 *******************************************************************************/
package org.eclipse.che.api.vfs.impl.file;

import com.google.common.cache.CacheBuilder;
import com.google.common.cache.CacheLoader;
import com.google.common.cache.LoadingCache;
import com.google.common.collect.ImmutableMap;
import com.google.common.hash.Hashing;
import com.google.common.io.ByteStreams;
import com.google.common.io.Files;

import org.eclipse.che.api.core.ConflictException;
import org.eclipse.che.api.core.ForbiddenException;
import org.eclipse.che.api.core.ServerException;
import org.eclipse.che.api.core.util.FileCleaner;
import org.eclipse.che.api.vfs.AbstractVirtualFileSystemProvider;
import org.eclipse.che.api.vfs.Archiver;
import org.eclipse.che.api.vfs.ArchiverFactory;
import org.eclipse.che.api.vfs.HashSumsCounter;
import org.eclipse.che.api.vfs.LockedFileFinder;
import org.eclipse.che.api.vfs.Path;
import org.eclipse.che.api.vfs.PathLockFactory;
import org.eclipse.che.api.vfs.VirtualFile;
import org.eclipse.che.api.vfs.VirtualFileFilter;
import org.eclipse.che.api.vfs.VirtualFileSystem;
import org.eclipse.che.api.vfs.search.Searcher;
import org.eclipse.che.api.vfs.search.SearcherProvider;
import org.eclipse.che.api.vfs.util.DeleteOnCloseFileInputStream;
import org.eclipse.che.commons.lang.IoUtil;
import org.eclipse.che.commons.lang.NameGenerator;
import org.eclipse.che.commons.lang.Pair;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.ByteArrayInputStream;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.FilenameFilter;
import java.io.IOException;
import java.io.InputStream;
import java.util.Collections;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.concurrent.ExecutionException;

import static com.google.common.base.Strings.isNullOrEmpty;
import static com.google.common.collect.Lists.newArrayList;
import static com.google.common.collect.Lists.newArrayListWithCapacity;
import static com.google.common.collect.Maps.newLinkedHashMap;
import static java.util.Collections.emptyList;
import static java.util.Collections.emptyMap;
import static java.util.Collections.singletonMap;
import static java.util.concurrent.TimeUnit.MINUTES;
import static org.eclipse.che.api.vfs.VirtualFileFilters.dotGitFilter;
import static org.eclipse.che.commons.lang.IoUtil.deleteRecursive;

/**
 * Local filesystem implementation of VirtualFileSystem.
 *
 * @author andrew00x
 */
public class LocalVirtualFileSystem implements VirtualFileSystem {
    private static final Logger LOG = LoggerFactory.getLogger(LocalVirtualFileSystem.class);

    static final int MAX_BUFFER_SIZE = 200 * 1024; // 200k

    private static final long WAIT_FOR_FILE_LOCK_TIMEOUT = 60000; // 60 seconds
    private static final int  FILE_LOCK_MAX_THREADS      = 1024;

    private static final String   VFS_SERVICE_DIR        = ".vfs";
    private static final String   FILE_LOCKS_DIR         = VFS_SERVICE_DIR + File.separatorChar + "locks";
    private static final String   LOCK_FILE_SUFFIX       = "_lock";
    private static final FileLock NO_LOCK                = new FileLock("no_lock", 0);
    private static final String   FILE_PROPERTIES_DIR    = VFS_SERVICE_DIR + File.separatorChar + "props";
    private static final String   PROPERTIES_FILE_SUFFIX = "_props";

    private static final FilenameFilter DOT_VFS_DIR_FILTER = (dir, name) -> !(VFS_SERVICE_DIR.equals(name));

    private static final FilenameFilter VFS_LOCK_FILTER =
            (dir, name) -> !(dir.getAbsolutePath().endsWith(FILE_LOCKS_DIR) || name.endsWith(LOCK_FILE_SUFFIX));

    private class LockTokenCacheLoader extends CacheLoader<Path, FileLock> {
        @Override
        public FileLock load(Path path) throws Exception {
            final File lockIoFile = getFileLockIoFile(path);
            if (lockIoFile.exists()) {
                try (DataInputStream dis = new DataInputStream(new BufferedInputStream(new FileInputStream(lockIoFile)))) {
                    return locksSerializer.read(dis);
                }
            }
            return NO_LOCK;
        }
    }

    private class FilePropertiesCacheLoader extends CacheLoader<Path, Map<String, String>> {
        @Override
        public Map<String, String> load(Path path) throws Exception {
            final File metadataIoFile = getMetadataIoFile(path);
            if (metadataIoFile.exists()) {
                try (DataInputStream dis = new DataInputStream(new BufferedInputStream(new FileInputStream(metadataIoFile)))) {
                    return ImmutableMap.copyOf(metadataSerializer.read(dis));
                }
            }
            return emptyMap();
        }
    }

    private final File                                            ioRoot;
    private final ArchiverFactory                                 archiverFactory;
    private final SearcherProvider                                searcherProvider;
    private final AbstractVirtualFileSystemProvider.CloseCallback closeCallback;

    /* NOTE -- This does not related to virtual file system locking in any kind. -- */
    private final PathLockFactory pathLockFactory;

    private final LocalVirtualFile root;

    private final FileLockSerializer           locksSerializer;
    private final LoadingCache<Path, FileLock> lockTokensCache;

    private final FileMetadataSerializer                  metadataSerializer;
    private final LoadingCache<Path, Map<String, String>> metadataCache;

    @SuppressWarnings("unchecked")
    public LocalVirtualFileSystem(File ioRoot,
                                  ArchiverFactory archiverFactory,
                                  SearcherProvider searcherProvider,
                                  AbstractVirtualFileSystemProvider.CloseCallback closeCallback) {
        this.ioRoot = ioRoot;
        this.archiverFactory = archiverFactory;
        this.searcherProvider = searcherProvider;
        this.closeCallback = closeCallback;

        root = new LocalVirtualFile(ioRoot, Path.ROOT, this);
        pathLockFactory = new PathLockFactory(FILE_LOCK_MAX_THREADS);

        locksSerializer = new FileLockSerializer();
        lockTokensCache = CacheBuilder.newBuilder()
                                      .concurrencyLevel(8)
                                      .maximumSize(256)
                                      .expireAfterAccess(10, MINUTES)
                                      .build(new LockTokenCacheLoader());

        metadataSerializer = new FileMetadataSerializer();
        metadataCache = CacheBuilder.newBuilder()
                                    .concurrencyLevel(8)
                                    .maximumSize(256)
                                    .expireAfterAccess(10, MINUTES)
                                    .build(new FilePropertiesCacheLoader());
    }

    @Override
    public LocalVirtualFile getRoot() {
        return root;
    }

    @Override
    public SearcherProvider getSearcherProvider() {
        return searcherProvider;
    }

    @Override
    public void close() throws ServerException {
        cleanUpCaches();
        if (searcherProvider != null) {
            Searcher searcher = searcherProvider.getSearcher(this, false);
            if (searcher != null) {
                searcher.close();
            }
        }
        if (closeCallback != null) {
            closeCallback.onClose();
        }
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) {
            return true;
        }
        if ((o instanceof LocalVirtualFileSystem)) {
            LocalVirtualFileSystem other = (LocalVirtualFileSystem)o;
            return Objects.equals(ioRoot, other.ioRoot);
        }
        return false;
    }

    @Override
    public int hashCode() {
        return Objects.hashCode(ioRoot);
    }

    private void cleanUpCaches() {
        lockTokensCache.invalidateAll();
        metadataCache.invalidateAll();
    }

    /** Used in tests. Need this to check state of PathLockFactory. All locks MUST be released at the end of request lifecycle. */
    PathLockFactory getPathLockFactory() {
        return pathLockFactory;
    }


    LocalVirtualFile getParent(LocalVirtualFile virtualFile) {
        if (virtualFile.isRoot()) {
            return null;
        }
        final Path parentPath = virtualFile.getPath().getParent();
        return new LocalVirtualFile(new File(ioRoot, toIoPath(parentPath)), parentPath, this);
    }


    LocalVirtualFile getChild(LocalVirtualFile parent, Path path) {
        if (isVfsServicePath(path)) {
            return null;
        }
        if (parent.isFolder()) {
            final Path childPath = parent.getPath().newPath(path);
            final LocalVirtualFile child = new LocalVirtualFile(new File(ioRoot, toIoPath(childPath)), childPath, this);
            if (child.exists()) {
                return child;
            }
        }
        return null;
    }

    private boolean isVfsServicePath(Path path) {
        return newArrayList(path.elements()).contains(".vfs");
    }

    synchronized List<VirtualFile> getChildren(LocalVirtualFile parent, VirtualFileFilter filter) throws ServerException {
        if (parent.isFolder()) {
            final List<VirtualFile> children = doGetChildren(parent, DOT_VFS_DIR_FILTER, filter);
            Collections.sort(children);
            return children;
        }
        return emptyList();
    }


    private List<VirtualFile> doGetChildren(LocalVirtualFile parent, FilenameFilter ioFileFilter, VirtualFileFilter vfsFilter)
            throws ServerException {
        if (ioFileFilter == null) {
            ioFileFilter = IoUtil.ANY_FILTER;
        }

        final String[] names = parent.toIoFile().list(ioFileFilter);
        if (names == null) {
            throw new ServerException(String.format("Unable get children of '%s'", parent.getPath()));
        }

        if (vfsFilter == null) {
            vfsFilter = VirtualFileFilter.ACCEPT_ALL;
        }

        final List<VirtualFile> children = newArrayListWithCapacity(names.length);
        for (String name : names) {
            final Path childPath = parent.getPath().newPath(name);
            final LocalVirtualFile child = new LocalVirtualFile(new File(ioRoot, toIoPath(childPath)), childPath, this);
            if (vfsFilter.accept(child)) {
                children.add(child);
            }
        }

        return children;
    }


    LocalVirtualFile createFile(LocalVirtualFile parent, String name, InputStream content)
            throws ForbiddenException, ConflictException, ServerException {
        checkName(name);

        if (Path.of(name).length() > 1) {
            throw new ServerException(String.format("Invalid name '%s'", name));
        }

        if (parent.isFolder()) {
            final Path newPath = parent.getPath().newPath(name);
            final File newIoFile = new File(ioRoot, toIoPath(newPath));

            try {
                if (!newIoFile.createNewFile()) {
                    throw new ConflictException(String.format("Item '%s' already exists", newPath));
                }
            } catch (IOException e) {
                String errorMessage = String.format("Unable create new file '%s'", newPath);
                LOG.error(errorMessage + "\n" + e.getMessage(), e);
                throw new ServerException(errorMessage);
            }

            final LocalVirtualFile newVirtualFile = new LocalVirtualFile(newIoFile, newPath, this);

            if (content != null) {
                doUpdateContent(newVirtualFile, content);
            }

            addInSearcher(newVirtualFile);

            return newVirtualFile;
        } else {
            throw new ForbiddenException("Unable create new file. Item specified as parent is not a folder");
        }
    }


    LocalVirtualFile createFolder(LocalVirtualFile parent, String name)
            throws ForbiddenException, ConflictException, ServerException {
        checkName(name);

        if (parent.isFolder()) {
            final Path newPath = parent.getPath().newPath(name);
            final File newIoFile = new File(ioRoot, toIoPath(newPath));
            if (!newIoFile.mkdirs()) {
                if (newIoFile.exists()) {
                    throw new ConflictException(String.format("Item '%s' already exists", newPath));
                }
            }

            return new LocalVirtualFile(newIoFile, newPath, this);
        } else {
            throw new ForbiddenException("Unable create folder. Item specified as parent is not a folder");
        }
    }


    LocalVirtualFile copy(LocalVirtualFile source, LocalVirtualFile parent, String name, boolean overwrite)
            throws ForbiddenException, ConflictException, ServerException {
        if (source.getPath().equals(parent.getPath())) {
            throw new ForbiddenException("Item cannot be copied to itself");
        }
        if (parent.isFolder()) {
            final String newName = isNullOrEmpty(name) ? source.getName() : name;
            LocalVirtualFile destination = (LocalVirtualFile)parent.getChild(Path.of(newName));
            if (destination != null) {
                if (overwrite) {
                    delete(destination, null);
                } else {
                    throw new ConflictException(String.format("Item '%s' already exists", destination.getPath()));
                }
            } else {
                final Path newPath = parent.getPath().newPath(newName);
                final File newIoFile = new File(ioRoot, toIoPath(newPath));
                destination = new LocalVirtualFile(newIoFile, newPath, this);
            }

            doCopy(source, destination);

            addInSearcher(destination);

            return destination;
        } else {
            throw new ForbiddenException("Unable copy item. Item specified as parent is not a folder");
        }
    }


    private void doCopy(LocalVirtualFile from, LocalVirtualFile to) throws ServerException {
        try {
            // First copy metadata (properties) for source. If we do in this way and fail cause to any i/o or other error client
            // will see error and may try to copy again. But if we successfully copy tree (or single file) and then fail to copy
            // metadata client may not try to copy again because copy destination already exists.

            final File fromMetadataFile = getMetadataIoFile(from.getPath());
            final File toMetadataFile = getMetadataIoFile(to.getPath());
            if (fromMetadataFile.exists()) {
                IoUtil.copy(fromMetadataFile, toMetadataFile, null);
            }

            IoUtil.copy(from.toIoFile(), to.toIoFile(), VFS_LOCK_FILTER);
        } catch (IOException e) {
            String errorMessage = String.format("Unable copy '%s' to '%s'", from, to);
            LOG.error(errorMessage + "\n" + e.getMessage(), e);
            throw new ServerException(errorMessage);
        }
    }


    LocalVirtualFile rename(LocalVirtualFile virtualFile, String newName, String lockToken)
            throws ForbiddenException, ConflictException, ServerException {
        checkName(newName);

        if (virtualFile.isRoot()) {
            throw new ForbiddenException("Unable rename root folder");
        }

        if (virtualFile.isFile()) {
            if (fileIsLockedAndLockTokenIsInvalid(virtualFile, lockToken)) {
                throw new ForbiddenException(String.format("Unable rename file '%s'. File is locked", virtualFile.getPath()));
            }
        } else {
            final List<VirtualFile> lockedFiles = new LockedFileFinder(virtualFile).findLockedFiles();
            if (!lockedFiles.isEmpty()) {
                throw new ForbiddenException(
                        String.format("Unable rename folder '%s'. Child items '%s' are locked", virtualFile.getPath(), lockedFiles));
            }
        }

        if (newName.equals(virtualFile.getName())) {
            return virtualFile;
        } else {
            final Path newPath = virtualFile.getPath().getParent().newPath(newName);
            final LocalVirtualFile
                    newVirtualFile = new LocalVirtualFile(new File(ioRoot, toIoPath(newPath)), newPath, this);
            if (newVirtualFile.exists()) {
                throw new ConflictException(String.format("Item '%s' already exists", newVirtualFile.getName()));
            }

            doCopy(virtualFile, newVirtualFile);
            addInSearcher(newVirtualFile);

            final Path path = virtualFile.getPath();
            final boolean isFile = virtualFile.isFile();
            doDelete(virtualFile, lockToken);
            deleteInSearcher(path, isFile);

            return newVirtualFile;
        }
    }


    LocalVirtualFile move(LocalVirtualFile virtualFile, LocalVirtualFile parent, String name,
                          boolean overwrite, String lockToken)
            throws ForbiddenException, ConflictException, ServerException {
        if (virtualFile.isRoot()) {
            throw new ForbiddenException("Unable move root folder");
        }
        if (virtualFile.getPath().equals(parent.getPath())) {
            throw new ForbiddenException("Item cannot be moved to itself");
        }
        if (!parent.isFolder()) {
            throw new ForbiddenException("Unable move. Item specified as parent is not a folder");
        }
        final Path sourcePath = virtualFile.getPath();
        final Path parentPath = parent.getPath();
        if (virtualFile.isFolder() && parent.getPath().isChild(virtualFile.getPath())) {
            throw new ForbiddenException(String.format("Unable move item '%s' to '%s'. Item may not have itself as parent",
                                                       sourcePath, parentPath));
        }

        if (virtualFile.isFile()) {
            if (fileIsLockedAndLockTokenIsInvalid(virtualFile, lockToken)) {
                throw new ForbiddenException(String.format("Unable move file '%s'. File is locked", sourcePath));
            }
        } else {
            final List<VirtualFile> lockedFiles = new LockedFileFinder(virtualFile).findLockedFiles();
            if (!lockedFiles.isEmpty()) {
                throw new ForbiddenException(
                        String.format("Unable move folder '%s'. Child items '%s' are locked", virtualFile, lockedFiles));
            }
        }

        String newName = isNullOrEmpty(name) ? virtualFile.getName() : name;
        final Path newPath = parent.getPath().newPath(newName);
        LocalVirtualFile newVirtualFile = new LocalVirtualFile(new File(ioRoot, toIoPath(newPath)), newPath, this);

        if (newVirtualFile.exists()) {
            if (overwrite) {
                delete(newVirtualFile, null);
            } else {
                throw new ConflictException(String.format("Item '%s' already exists", newPath));
            }
        }

        doCopy(virtualFile, newVirtualFile);
        addInSearcher(newVirtualFile);

        final Path path = virtualFile.getPath();
        final boolean isFile = virtualFile.isFile();
        doDelete(virtualFile, lockToken);
        deleteInSearcher(path, isFile);

        return newVirtualFile;
    }


    InputStream getContent(LocalVirtualFile virtualFile) throws ForbiddenException, ServerException {
        if (virtualFile.isFile()) {
            final PathLockFactory.PathLock lock = pathLockFactory.getLock(virtualFile.getPath(), false).acquire(WAIT_FOR_FILE_LOCK_TIMEOUT);
            File spoolFile = null;
            try {
                final File ioFile = virtualFile.toIoFile();
                final long fileLength = ioFile.length();
                if (fileLength <= MAX_BUFFER_SIZE) {
                    return new ByteArrayInputStream(Files.toByteArray(ioFile));
                }
                // Copy this file to be able release the file lock before leave this method.
                spoolFile = File.createTempFile("spool_file", null);
                Files.copy(ioFile, spoolFile);
                return new DeleteOnCloseFileInputStream(spoolFile);
            } catch (IOException e) {
                if (spoolFile != null) {
                    FileCleaner.addFile(spoolFile);
                }
                String errorMessage = String.format("Unable get content of '%s'", virtualFile.getPath());
                LOG.error(errorMessage + "\n" + e.getMessage(), e);
                throw new ServerException(errorMessage);
            } finally {
                lock.release();
            }
        } else {
            throw new ForbiddenException(String.format("Unable get content. Item '%s' is not a file", virtualFile.getPath()));
        }
    }


    void updateContent(LocalVirtualFile virtualFile, InputStream content, String lockToken)
            throws ForbiddenException, ServerException {
        if (virtualFile.isFile()) {
            if (fileIsLockedAndLockTokenIsInvalid(virtualFile, lockToken)) {
                throw new ForbiddenException(String.format("Unable update content of file '%s'. File is locked", virtualFile.getPath()));
            }
            final PathLockFactory.PathLock lock = pathLockFactory.getLock(virtualFile.getPath(), true).acquire(WAIT_FOR_FILE_LOCK_TIMEOUT);
            try {
                doUpdateContent(virtualFile, content);
            } finally {
                lock.release();
            }
            updateInSearcher(virtualFile);
        } else {
            throw new ForbiddenException(String.format("Unable update content. Item '%s' is not file", virtualFile.getPath()));
        }
    }


    private void doUpdateContent(LocalVirtualFile virtualFile, InputStream content) throws ServerException {
        try (FileOutputStream fileOut = new FileOutputStream(virtualFile.toIoFile())) {
            ByteStreams.copy(content, fileOut);
        } catch (IOException e) {
            String errorMessage = String.format("Unable set content of '%s'", virtualFile.getPath());
            LOG.error(errorMessage + "\n" + e.getMessage(), e);
            throw new ServerException(errorMessage);
        }
    }

    void delete(LocalVirtualFile virtualFile, String lockToken) throws ForbiddenException, ServerException {
        if (virtualFile.isRoot()) {
            throw new ForbiddenException("Unable delete root folder");
        }

        final Path path = virtualFile.getPath();
        final boolean isFile = virtualFile.isFile();

        doDelete(virtualFile, lockToken);

        deleteInSearcher(path, isFile);
    }

    private void doDelete(LocalVirtualFile virtualFile, String lockToken) throws ForbiddenException, ServerException {
        if (virtualFile.isFolder()) {
            final List<VirtualFile> lockedFiles = new LockedFileFinder(virtualFile).findLockedFiles();
            if (!lockedFiles.isEmpty()) {
                throw new ForbiddenException(
                        String.format("Unable delete folder '%s'. Child items '%s' are locked", virtualFile.getPath(), lockedFiles));
            }
        } else if (fileIsLockedAndLockTokenIsInvalid(virtualFile, lockToken)) {
            throw new ForbiddenException(String.format("Unable delete file '%s'. File is locked", virtualFile.getPath()));
        }

        cleanUpCaches();

        final File fileLockIoFile = getFileLockIoFile(virtualFile.getPath());
        if (fileLockIoFile.delete()) {
            if (fileLockIoFile.exists()) {
                LOG.error("Unable delete lock file {}", fileLockIoFile);
                throw new ServerException(String.format("Unable delete item '%s'", virtualFile.getPath()));
            }
        }

        final File metadataIoFile = getMetadataIoFile(virtualFile.getPath());
        if (metadataIoFile.delete()) {
            if (metadataIoFile.exists()) {
                LOG.error("Unable delete metadata file {}", metadataIoFile);
                throw new ServerException(String.format("Unable delete item '%s'", virtualFile.getPath()));
            }
        }

        if (!deleteRecursive(virtualFile.toIoFile())) {
            LOG.error("Unable delete file {}", virtualFile.toIoFile());
            throw new ServerException(String.format("Unable delete item '%s'", virtualFile.getPath()));
        }
    }


    InputStream zip(LocalVirtualFile folder) throws ForbiddenException, ServerException {
        if(archiverFactory == null)
            throw new ServerException("VFS: Could not create zip archiver. Archiver Factory is not properly configured (is null)");

        if (folder.isFolder()) {
            return compress(archiverFactory.createArchiver(folder, "zip"));
        } else {
            throw new ForbiddenException(String.format("Unable export to zip. Item '%s' is not a folder", folder.getPath()));
        }
    }


    void unzip(LocalVirtualFile parent, InputStream zipped, boolean overwrite, int stripNumber)
            throws ForbiddenException, ConflictException, ServerException {
        if(archiverFactory == null)
            throw new ServerException("VFS: Could not create zip archiver. Archiver Factory is not properly configured (is null)");

        if (parent.isFolder()) {
            extract(archiverFactory.createArchiver(parent, "zip"), zipped, overwrite, stripNumber);
            addInSearcher(parent);
        } else {
            throw new ForbiddenException(String.format("Unable import zip content. Item '%s' is not a folder", parent.getPath()));
        }
    }


    InputStream tar(LocalVirtualFile folder) throws ForbiddenException, ServerException {
        if(archiverFactory == null)
            throw new ServerException("VFS: Could not create tar archiver. Archiver Factory is not properly configured (is null)");

        if (folder.isFolder()) {
            return compress(archiverFactory.createArchiver(folder, "tar"));
        } else {
            throw new ForbiddenException(String.format("Unable export to tar archive. Item '%s' is not a folder", folder.getPath()));
        }
    }

    void untar(LocalVirtualFile parent, InputStream tarArchive, boolean overwrite, int stripNumber)
            throws ForbiddenException, ConflictException, ServerException {
        if(archiverFactory == null)
            throw new ServerException("VFS: Could not create tar archiver. Archiver Factory is not properly configured (is null)");

        if (parent.isFolder()) {
            extract(archiverFactory.createArchiver(parent, "tar"), tarArchive, overwrite, stripNumber);
            addInSearcher(parent);
        } else {
            throw new ForbiddenException(String.format("Unable import tar archive. Item '%s' is not a folder", parent.getPath()));
        }
    }

    private InputStream compress(Archiver archiver) throws ForbiddenException, ServerException {
        File archive = null;
        try {
            archive = File.createTempFile("export", ".arc");
            try (FileOutputStream fileOut = new FileOutputStream(archive)) {
                archiver.compress(fileOut, dotGitFilter());
            }
            return new DeleteOnCloseFileInputStream(archive);
        } catch (IOException e) {
            if (archive != null) {
                FileCleaner.addFile(archive);
            }
            throw new ServerException(e.getMessage(), e);
        }
    }

    private void extract(Archiver archiver, InputStream compressed, boolean overwrite, int stripNumber)
            throws ConflictException, ServerException, ForbiddenException {
        try {
            archiver.extract(compressed, overwrite, stripNumber);
        } catch (IOException e) {
            throw new ServerException(e.getMessage(), e);
        }
    }

    String lock(LocalVirtualFile virtualFile, long timeout) throws ForbiddenException, ConflictException, ServerException {
        if (virtualFile.isFile()) {
            final PathLockFactory.PathLock pathLock = pathLockFactory.getLock(virtualFile.getPath(), true).acquire(WAIT_FOR_FILE_LOCK_TIMEOUT);
            try {
                return doLock(virtualFile, timeout);
            } finally {
                pathLock.release();
            }
        } else {
            throw new ForbiddenException(String.format("Unable lock '%s'. Locking allowed for files only", virtualFile.getPath()));
        }
    }

    private String doLock(LocalVirtualFile virtualFile, long timeout) throws ConflictException, ServerException {
        try {
            if (NO_LOCK == lockTokensCache.get(virtualFile.getPath())) {
                final FileLock lock = createLock(timeout);
                final File fileLockIoFile = getFileLockIoFile(virtualFile.getPath());
                fileLockIoFile.getParentFile().mkdirs();
                try (DataOutputStream dos = new DataOutputStream(new BufferedOutputStream(new FileOutputStream(fileLockIoFile)))) {
                    locksSerializer.write(dos, lock);
                }
                lockTokensCache.put(virtualFile.getPath(), lock);
                return lock.getLockToken();
            }
            throw new ConflictException(String.format("Unable lock file '%s'. File already locked", virtualFile.getPath()));
        } catch (IOException | ExecutionException e) {
            String errorMessage = String.format("Unable lock file '%s'", virtualFile.getPath());
            if (e instanceof ExecutionException) {
                LOG.error(errorMessage + "\n" + e.getCause().getMessage(), e.getCause());
            } else {
                LOG.error(errorMessage + "\n" + e.getMessage(), e);
            }
            throw new ServerException(errorMessage);
        }
    }

    private FileLock createLock(long timeout) {
        final long expired = timeout > 0 ? (System.currentTimeMillis() + timeout) : Long.MAX_VALUE;
        return new FileLock(generateLockToken(), expired);
    }

    private String generateLockToken() {
        return NameGenerator.generate(null, 16);
    }

    void unlock(LocalVirtualFile virtualFile, String lockToken) throws ForbiddenException, ConflictException, ServerException {
        if (lockToken == null) {
            throw new ForbiddenException("Null lock token");
        }
        if (!virtualFile.isFile()) {
            throw new ConflictException(String.format("Item '%s' is not locked", virtualFile.getPath()));
        }
        final FileLock fileLock = getFileLock(virtualFile);
        if (NO_LOCK == fileLock) {
            throw new ConflictException(String.format("File '%s' is not locked", virtualFile.getPath()));
        }
        if (!fileLock.getLockToken().equals(lockToken)) {
            throw new ForbiddenException(String.format("Unable unlock file '%s'. Lock token does not match", virtualFile.getPath()));
        }

        final PathLockFactory.PathLock lockFilePathLock = pathLockFactory.getLock(virtualFile.getPath(), true).acquire(
                WAIT_FOR_FILE_LOCK_TIMEOUT);
        try {
            doUnlock(virtualFile);
        } finally {
            lockFilePathLock.release();
        }
    }

    private void doUnlock(LocalVirtualFile virtualFile) throws ForbiddenException, ServerException {
        try {
            final File fileLockIoFile = getFileLockIoFile(virtualFile.getPath());
            if (!fileLockIoFile.delete()) {
                if (fileLockIoFile.exists()) {
                    throw new IOException(String.format("Unable delete lock file %s", fileLockIoFile));
                }
            }
            lockTokensCache.put(virtualFile.getPath(), NO_LOCK);
        } catch (IOException e) {
            String errorMessage = String.format("Unable unlock file '%s'", virtualFile.getPath());
            LOG.error(errorMessage + "\n" + e.getMessage(), e);
            throw new ServerException(errorMessage);
        }
    }


    boolean isLocked(LocalVirtualFile virtualFile) throws ServerException {
        return virtualFile.isFile() && NO_LOCK != getFileLock(virtualFile);
    }


    private boolean fileIsLockedAndLockTokenIsInvalid(LocalVirtualFile virtualFile, String checkLockToken)
            throws ServerException {
        final FileLock lock = getFileLock(virtualFile);
        return !(NO_LOCK == lock || lock.getLockToken().equals(checkLockToken));
    }

    private FileLock getFileLock(LocalVirtualFile virtualFile) throws ServerException {
        final PathLockFactory.PathLock lockFilePathLock =
                pathLockFactory.getLock(virtualFile.getPath(), true).acquire(WAIT_FOR_FILE_LOCK_TIMEOUT);
        try {
            final FileLock lock;
            try {
                lock = lockTokensCache.get(virtualFile.getPath());
            } catch (ExecutionException e) {
                String errorMessage = String.format("Unable get lock of file '%s'", virtualFile.getPath());
                LOG.error(errorMessage + "\n" + e.getCause().getMessage(), e.getCause());
                throw new ServerException(errorMessage);
            }
            if (NO_LOCK == lock) {
                return lock;
            }
            if (lock.getExpired() < System.currentTimeMillis()) {
                final File fileLockIoFile = getFileLockIoFile(virtualFile.getPath());
                if (!fileLockIoFile.delete()) {
                    if (fileLockIoFile.exists()) {
                        FileCleaner.addFile(fileLockIoFile);
                        LOG.warn("Unable delete lock file %s", fileLockIoFile);
                    }
                }
                lockTokensCache.put(virtualFile.getPath(), NO_LOCK);
                return NO_LOCK;
            }
            return lock;
        } finally {
            lockFilePathLock.release();
        }
    }

    private File getFileLockIoFile(Path virtualFilePath) {
        final String fileLockFileName = virtualFilePath.getName() + LOCK_FILE_SUFFIX;
        final Path metadataFilePath;
        if (virtualFilePath.isRoot()) {
            metadataFilePath = virtualFilePath.newPath(FILE_LOCKS_DIR, fileLockFileName);
        } else {
            metadataFilePath = virtualFilePath.getParent().newPath(FILE_LOCKS_DIR, fileLockFileName);
        }
        return new File(ioRoot, toIoPath(metadataFilePath));
    }


    Map<String, String> getProperties(LocalVirtualFile virtualFile) throws ServerException {
        final PathLockFactory.PathLock metadataFilePathLock =
                pathLockFactory.getLock(virtualFile.getPath(), false).acquire(WAIT_FOR_FILE_LOCK_TIMEOUT);
        try {
            return newLinkedHashMap(metadataCache.get(virtualFile.getPath()));
        } catch (ExecutionException e) {
            String errorMessage = String.format("Unable read properties of file '%s'", virtualFile.getPath());
            LOG.error(errorMessage + "\n" + e.getCause().getMessage(), e.getCause());
            throw new ServerException(errorMessage);
        } finally {
            metadataFilePathLock.release();
        }
    }


    String getPropertyValue(LocalVirtualFile virtualFile, String name) throws ServerException {
        return getProperties(virtualFile).get(name);
    }


    void updateProperties(LocalVirtualFile virtualFile, Map<String, String> updates, String lockToken)
            throws ForbiddenException, ServerException {
        if (virtualFile.isFile() && fileIsLockedAndLockTokenIsInvalid(virtualFile, lockToken)) {
            throw new ForbiddenException(
                    String.format("Unable update properties of item '%s'. Item is locked", virtualFile.getPath()));
        }
        final PathLockFactory.PathLock pathLock = pathLockFactory.getLock(virtualFile.getPath(), true).acquire(WAIT_FOR_FILE_LOCK_TIMEOUT);
        try {
            doUpdateProperties(virtualFile, updates);
        } finally {
            pathLock.release();
        }
    }

    private void doUpdateProperties(LocalVirtualFile virtualFile, Map<String, String> updates) throws ServerException {
        try {
            final Map<String, String> properties = getProperties(virtualFile);
            for (Map.Entry<String, String> entry : updates.entrySet()) {
                if (entry.getValue() == null) {
                    properties.remove(entry.getKey());
                } else {
                    properties.put(entry.getKey(), entry.getValue());
                }
            }

            final File metadataIoFile = getMetadataIoFile(virtualFile.getPath());
            if (properties.isEmpty()) {
                if (!metadataIoFile.delete()) {
                    if (metadataIoFile.exists()) {
                        LOG.error("Unable delete metadata file {}", metadataIoFile);
                        throw new IOException(String.format("Unable update properties of item '%s'", virtualFile.getPath()));
                    }
                }
            } else {
                metadataIoFile.getParentFile().mkdirs();
                try (DataOutputStream dos = new DataOutputStream(new BufferedOutputStream(new FileOutputStream(metadataIoFile)))) {
                    metadataSerializer.write(dos, properties);
                }
            }

            metadataCache.put(virtualFile.getPath(), properties);

            if (!virtualFile.toIoFile().setLastModified(System.currentTimeMillis())) {
                LOG.warn("Unable to set timestamp to '{}'", virtualFile.toIoFile());
            }
        } catch (IOException e) {
            String errorMessage = String.format("Unable lock file '%s'", virtualFile.getPath());
            LOG.error(errorMessage + "\n" + e.getMessage(), e);
            throw new ServerException(errorMessage);
        }
    }


    void setProperty(LocalVirtualFile virtualFile, String name, String value, String lockToken)
            throws ForbiddenException, ServerException {
        updateProperties(virtualFile, singletonMap(name, value), lockToken);
    }


    private File getMetadataIoFile(Path virtualFilePath) {
        final String metadataFileName = virtualFilePath.getName() + PROPERTIES_FILE_SUFFIX;
        final Path metadataFilePath;
        if (virtualFilePath.isRoot()) {
            metadataFilePath = virtualFilePath.newPath(FILE_PROPERTIES_DIR, metadataFileName);
        } else {
            metadataFilePath = virtualFilePath.getParent().newPath(FILE_PROPERTIES_DIR, metadataFileName);
        }
        return new File(ioRoot, toIoPath(metadataFilePath));
    }


    List<Pair<String, String>> countMd5Sums(LocalVirtualFile virtualFile) throws ServerException {
        if (virtualFile.isFile()) {
            return emptyList();
        }
        return new HashSumsCounter(virtualFile, Hashing.md5()).countHashSums();
    }


    private String toIoPath(Path vfsPath) {
        if (vfsPath.isRoot()) {
            return "";
        }
        if ('/' == File.separatorChar) {
            return vfsPath.toString();
        }
        return vfsPath.join(File.separatorChar);
    }


    private void checkName(String name) throws ServerException {
        if (name == null || name.trim().isEmpty()) {
            throw new ServerException("Item's name is not set");
        }
    }


    private void addInSearcher(LocalVirtualFile newVirtualFile) {
        if (searcherProvider != null) {
            try {
                searcherProvider.getSearcher(this).add(newVirtualFile);
            } catch (ServerException e) {
                LOG.error(e.getMessage(), e);
            }
        }
    }

    private void updateInSearcher(LocalVirtualFile virtualFile) {
        if (searcherProvider != null) {
            try {
                searcherProvider.getSearcher(this).update(virtualFile);
            } catch (ServerException e) {
                LOG.error(e.getMessage(), e);
            }
        }
    }

    private void deleteInSearcher(Path path, boolean isFile) {
        if (searcherProvider != null) {
            try {
                searcherProvider.getSearcher(this).delete(path.toString(), isFile);
            } catch (ServerException e) {
                LOG.error(e.getMessage(), e);
            }
        }
    }
}