Java tutorial
/******************************************************************************* * 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.memory; import com.google.common.hash.Hashing; import com.google.common.io.ByteStreams; 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.vfs.Archiver; 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.VirtualFile; import org.eclipse.che.api.vfs.VirtualFileFilter; import org.eclipse.che.api.vfs.VirtualFileSystem; import org.eclipse.che.api.vfs.VirtualFileVisitor; import org.eclipse.che.api.vfs.search.SearcherProvider; 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.ByteArrayInputStream; import java.io.ByteArrayOutputStream; import java.io.IOException; import java.io.InputStream; import java.util.Arrays; import java.util.Collections; import java.util.Iterator; import java.util.List; import java.util.Map; import java.util.Objects; import java.util.stream.Collectors; import static com.google.common.collect.Lists.newArrayList; import static com.google.common.collect.Maps.newHashMap; import static java.util.Collections.singletonMap; /** * In-memory implementation of VirtualFile. * <p/> * NOTE: This implementation is not thread safe. * * @author andrew00x */ public class MemoryVirtualFile implements VirtualFile { private static final Logger LOG = LoggerFactory.getLogger(MemoryVirtualFile.class); private static final boolean FILE = false; private static final boolean FOLDER = true; static MemoryVirtualFile newFile(MemoryVirtualFile parent, String name, InputStream content) throws IOException { return new MemoryVirtualFile(parent, name, content == null ? new byte[0] : ByteStreams.toByteArray(content)); } static MemoryVirtualFile newFile(MemoryVirtualFile parent, String name, byte[] content) { return new MemoryVirtualFile(parent, name, content == null ? new byte[0] : Arrays.copyOf(content, content.length)); } static MemoryVirtualFile newFolder(MemoryVirtualFile parent, String name) { return new MemoryVirtualFile(parent, name); } // private final boolean type; private final Map<String, String> properties; private final Map<String, MemoryVirtualFile> children; private final MemoryVirtualFileSystem fileSystem; private String name; private MemoryVirtualFile parent; private byte[] content; private long lastModificationDate; private LockHolder lock; private boolean exists = true; // --- File --- private MemoryVirtualFile(MemoryVirtualFile parent, String name, byte[] content) { this.fileSystem = (MemoryVirtualFileSystem) parent.getFileSystem(); this.parent = parent; this.type = FILE; this.name = name; this.properties = newHashMap(); this.content = content; children = Collections.emptyMap(); } // --- Folder --- private MemoryVirtualFile(MemoryVirtualFile parent, String name) { this.fileSystem = (MemoryVirtualFileSystem) parent.getFileSystem(); this.parent = parent; this.type = FOLDER; this.name = name; this.properties = newHashMap(); children = newHashMap(); } // --- Root folder --- MemoryVirtualFile(VirtualFileSystem virtualFileSystem) { this.fileSystem = (MemoryVirtualFileSystem) virtualFileSystem; this.type = FOLDER; this.name = ""; this.properties = newHashMap(); children = newHashMap(); } @Override public String getName() { checkExistence(); return name; } @Override public Path getPath() { checkExistence(); MemoryVirtualFile parent = this.parent; if (parent == null) { return Path.ROOT; } Path parentPath = parent.getPath(); return parentPath.newPath(getName()); } @Override public boolean isFile() { checkExistence(); return type == FILE; } @Override public boolean isFolder() { checkExistence(); return type == FOLDER; } @Override public boolean exists() { return exists; } @Override public boolean isRoot() { checkExistence(); return parent == null; } @Override public long getLastModificationDate() { checkExistence(); return lastModificationDate; } @Override public VirtualFile getParent() { checkExistence(); return parent; } @Override public Map<String, String> getProperties() { checkExistence(); return newHashMap(properties); } @Override public String getProperty(String name) { checkExistence(); return properties.get(name); } @Override public VirtualFile updateProperties(Map<String, String> update, String lockToken) throws ForbiddenException { checkExistence(); if (isFile() && fileIsLockedAndLockTokenIsInvalid(lockToken)) { throw new ForbiddenException( String.format("Unable update properties of item '%s'. Item is locked", getPath())); } for (Map.Entry<String, String> entry : update.entrySet()) { if (entry.getValue() == null) { properties.remove(entry.getKey()); } else { properties.put(entry.getKey(), entry.getValue()); } } lastModificationDate = System.currentTimeMillis(); return this; } @Override public VirtualFile updateProperties(Map<String, String> properties) throws ForbiddenException, ServerException { return updateProperties(properties, null); } @Override public VirtualFile setProperty(String name, String value, String lockToken) throws ForbiddenException, ServerException { updateProperties(singletonMap(name, value), lockToken); return this; } @Override public VirtualFile setProperty(String name, String value) throws ForbiddenException, ServerException { return setProperty(name, value, null); } @Override public void accept(VirtualFileVisitor visitor) throws ServerException { checkExistence(); visitor.visit(this); } @Override public List<Pair<String, String>> countMd5Sums() throws ServerException { checkExistence(); if (isFile()) { return newArrayList(); } return new HashSumsCounter(this, Hashing.md5()).countHashSums(); } @Override public List<VirtualFile> getChildren(VirtualFileFilter filter) { checkExistence(); if (isFolder()) { return doGetChildren(this).stream().filter(filter::accept).sorted().collect(Collectors.toList()); } return newArrayList(); } @Override public List<VirtualFile> getChildren() { checkExistence(); if (isFolder()) { List<VirtualFile> children = doGetChildren(this); if (children.size() > 1) { Collections.sort(children); } return children; } return newArrayList(); } private List<VirtualFile> doGetChildren(VirtualFile folder) { return newArrayList(((MemoryVirtualFile) folder).children.values()); } @Override public boolean hasChild(Path path) throws ServerException { return getChild(path) != null; } @Override public VirtualFile getChild(Path path) throws ServerException { checkExistence(); MemoryVirtualFile child = this; Iterator<String> pathSegments = newArrayList(path.elements()).iterator(); while (pathSegments.hasNext() && child != null) { child = child.children.get(pathSegments.next()); } if (pathSegments.hasNext()) { return null; } return child; } boolean addChild(MemoryVirtualFile child) { checkExistence(); final String childName = child.getName(); if (children.get(childName) == null) { children.put(childName, child); return true; } return false; } @Override public InputStream getContent() throws ForbiddenException { return new ByteArrayInputStream(getContentAsBytes()); } @Override public byte[] getContentAsBytes() throws ForbiddenException { checkExistence(); if (isFile()) { if (content == null) { content = new byte[0]; } return Arrays.copyOf(content, content.length); } throw new ForbiddenException( String.format("We were unable to retrieve the content. Item '%s' is not a file", getPath())); } @Override public String getContentAsString() throws ForbiddenException { return new String(getContentAsBytes()); } @Override public VirtualFile updateContent(InputStream content, String lockToken) throws ForbiddenException, ServerException { byte[] bytes; try { bytes = ByteStreams.toByteArray(content); } catch (IOException e) { throw new ServerException(String.format("We were unable to set the content of '%s'. Error: %s", getPath(), e.getMessage())); } doUpdateContent(bytes, lockToken); return this; } @Override public VirtualFile updateContent(byte[] content, String lockToken) throws ForbiddenException, ServerException { doUpdateContent(content, lockToken); return this; } @Override public VirtualFile updateContent(String content, String lockToken) throws ForbiddenException, ServerException { return updateContent(content.getBytes(), lockToken); } @Override public VirtualFile updateContent(byte[] content) throws ForbiddenException, ServerException { return updateContent(content, null); } @Override public VirtualFile updateContent(InputStream content) throws ForbiddenException, ServerException { return updateContent(content, null); } @Override public VirtualFile updateContent(String content) throws ForbiddenException, ServerException { return updateContent(content, null); } private void doUpdateContent(byte[] content, String lockToken) throws ForbiddenException, ServerException { checkExistence(); if (isFile()) { if (fileIsLockedAndLockTokenIsInvalid(lockToken)) { throw new ForbiddenException(String.format( "We were unable to update the content of file '%s'. The file is locked", getPath())); } this.content = Arrays.copyOf(content, content.length); lastModificationDate = System.currentTimeMillis(); updateInSearcher(); } else { throw new ForbiddenException( String.format("We were unable to update the content. Item '%s' is not a file", getPath())); } } @Override public long getLength() { checkExistence(); if (isFile()) { return content.length; } return 0; } @Override public VirtualFile copyTo(VirtualFile parent) throws ForbiddenException, ConflictException, ServerException { return copyTo(parent, null, false); } @Override public VirtualFile copyTo(VirtualFile parent, String newName, boolean overwrite) throws ForbiddenException, ConflictException, ServerException { checkExistence(); ((MemoryVirtualFile) parent).checkExistence(); if (isRoot()) { throw new ServerException("Unable copy root folder"); } if (newName == null || newName.trim().isEmpty()) { newName = this.getName(); } if (parent.isFolder()) { VirtualFile copy = doCopy((MemoryVirtualFile) parent, newName, overwrite); addInSearcher(copy); return copy; } else { throw new ForbiddenException( String.format("Unable create copy of '%s'. Item '%s' specified as parent is not a folder.", getPath(), parent.getPath())); } } private VirtualFile doCopy(MemoryVirtualFile parent, String newName, boolean overwrite) throws ConflictException, ForbiddenException, ServerException { if (overwrite) { MemoryVirtualFile existedItem = parent.children.get(newName); if (existedItem != null) { existedItem.delete(); } } MemoryVirtualFile virtualFile; if (isFile()) { virtualFile = newFile(parent, newName, Arrays.copyOf(content, content.length)); } else { virtualFile = newFolder(parent, newName); for (VirtualFile child : getChildren()) { child.copyTo(virtualFile); } } virtualFile.properties.putAll(this.properties); if (parent.addChild(virtualFile)) { return virtualFile; } throw new ConflictException(String.format("Item '%s' already exists", parent.getPath().newPath(newName))); } @Override public VirtualFile moveTo(VirtualFile parent) throws ForbiddenException, ConflictException, ServerException { return moveTo(parent, null, false, null); } @Override public VirtualFile moveTo(VirtualFile parent, String newName, boolean overwrite, String lockToken) throws ForbiddenException, ConflictException, ServerException { checkExistence(); MemoryVirtualFile memoryParent = (MemoryVirtualFile) parent; memoryParent.checkExistence(); if (isRoot()) { throw new ForbiddenException("Unable move root folder"); } if (!parent.isFolder()) { throw new ForbiddenException("Unable move item. Item specified as parent is not a folder"); } if (newName == null || newName.trim().isEmpty()) { newName = this.getName(); } final boolean isFile = isFile(); final Path myPath = getPath(); final Path newParentPath = parent.getPath(); final boolean folder = isFolder(); if (folder) { if (newParentPath.isChild(myPath)) { throw new ForbiddenException(String.format( "Unable move item %s to %s. Item may not have itself as parent", myPath, newParentPath)); } final List<VirtualFile> lockedFiles = new LockedFileFinder(this).findLockedFiles(); if (!lockedFiles.isEmpty()) { throw new ForbiddenException(String.format("Unable move item '%s'. Child items '%s' are locked", getName(), lockedFiles)); } } else if (fileIsLockedAndLockTokenIsInvalid(lockToken)) { throw new ForbiddenException(String.format("Unable move item %s. Item is locked", myPath)); } if (overwrite) { MemoryVirtualFile existedItem = memoryParent.children.get(newName); if (existedItem != null) { existedItem.delete(); } } if (memoryParent.children.containsKey(newName)) { throw new ConflictException( String.format("Item '%s' already exists", parent.getPath().newPath(newName))); } this.parent.children.remove(name); memoryParent.children.put(newName, this); this.parent = memoryParent; this.name = newName; lock = null; deleteFromSearcher(myPath, isFile); addInSearcher(this); return this; } @Override public VirtualFile rename(String newName, String lockToken) throws ForbiddenException, ConflictException, ServerException { checkExistence(); checkName(newName); boolean isFile = isFile(); if (isRoot()) { throw new ForbiddenException("We were unable to rename a root folder."); } final Path myPath = getPath(); final boolean isFolder = isFolder(); if (isFolder) { final List<VirtualFile> lockedFiles = new LockedFileFinder(this).findLockedFiles(); if (!lockedFiles.isEmpty()) { throw new ForbiddenException(String.format("Unable rename item '%s'. Child items '%s' are locked", getName(), lockedFiles)); } } else { if (fileIsLockedAndLockTokenIsInvalid(lockToken)) { throw new ForbiddenException(String.format( "We were unable to rename an item '%s'." + " The item is currently locked by the system", getPath())); } } if (parent.children.get(newName) != null) { throw new ConflictException(String.format("Item '%s' already exists", newName)); } parent.children.remove(name); parent.children.put(newName, this); name = newName; lock = null; lastModificationDate = System.currentTimeMillis(); deleteFromSearcher(myPath, isFile); addInSearcher(this); return this; } @Override public VirtualFile rename(String newName) throws ForbiddenException, ConflictException, ServerException { return rename(newName, null); } @Override public void delete(String lockToken) throws ForbiddenException, ServerException { checkExistence(); boolean isFile = isFile(); if (isRoot()) { throw new ForbiddenException("Unable delete root folder"); } final Path myPath = getPath(); final boolean folder = isFolder(); if (folder) { final List<VirtualFile> lockedFiles = new LockedFileFinder(this).findLockedFiles(); if (!lockedFiles.isEmpty()) { throw new ForbiddenException(String.format("Unable delete item '%s'. Child items '%s' are locked", getName(), lockedFiles)); } for (VirtualFile virtualFile : getTreeAsList(this)) { ((MemoryVirtualFile) virtualFile).exists = false; } } else { if (fileIsLockedAndLockTokenIsInvalid(lockToken)) { throw new ForbiddenException(String.format("Unable delete item '%s'. Item is locked", getPath())); } } parent.children.remove(name); exists = false; parent = null; deleteFromSearcher(myPath, isFile); } List<VirtualFile> getTreeAsList(VirtualFile folder) throws ServerException { List<VirtualFile> list = newArrayList(); folder.accept(new VirtualFileVisitor() { @Override public void visit(VirtualFile virtualFile) throws ServerException { if (virtualFile.isFolder()) { for (VirtualFile child : virtualFile.getChildren()) { child.accept(this); } } list.add(virtualFile); } }); return list; } @Override public void delete() throws ForbiddenException, ServerException { delete(null); } @Override public InputStream zip() throws ForbiddenException, ServerException { checkExistence(); if (isFolder()) { return compress(fileSystem.getArchiverFactory().createArchiver(this, "zip")); } else { throw new ForbiddenException( String.format("Unable export to zip. Item '%s' is not a folder", getPath())); } } @Override public void unzip(InputStream zipped, boolean overwrite, int stripNumber) throws ForbiddenException, ServerException, ConflictException { checkExistence(); if (isFolder()) { extract(fileSystem.getArchiverFactory().createArchiver(this, "zip"), zipped, overwrite, stripNumber); addInSearcher(this); } else { throw new ForbiddenException(String.format("Unable import zip. Item '%s' is not a folder", getPath())); } } @Override public InputStream tar() throws ForbiddenException, ServerException { checkExistence(); if (isFolder()) { return compress(fileSystem.getArchiverFactory().createArchiver(this, "tar")); } else { throw new ForbiddenException( String.format("Unable export to tar archive. Item '%s' is not a folder", getPath())); } } @Override public void untar(InputStream tarArchive, boolean overwrite, int stripNumber) throws ForbiddenException, ConflictException, ServerException { checkExistence(); if (isFolder()) { extract(fileSystem.getArchiverFactory().createArchiver(this, "tar"), tarArchive, overwrite, stripNumber); addInSearcher(this); } else { throw new ForbiddenException( String.format("Unable import tar archive. Item '%s' is not a folder", getPath())); } } private InputStream compress(Archiver archiver) throws ForbiddenException, ServerException { try { ByteArrayOutputStream byteOut = new ByteArrayOutputStream(); archiver.compress(byteOut); return new ByteArrayInputStream(byteOut.toByteArray()); } catch (IOException e) { 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); } } @Override public String lock(long timeout) throws ForbiddenException, ConflictException { checkExistence(); if (isFile()) { if (this.lock != null) { throw new ConflictException("File already locked"); } final String lockToken = NameGenerator.generate(null, 32); this.lock = new LockHolder(lockToken, timeout); lastModificationDate = System.currentTimeMillis(); return lockToken; } else { throw new ForbiddenException( String.format("Unable lock '%s'. Locking allowed for files only", getPath())); } } @Override public VirtualFile unlock(String lockToken) throws ForbiddenException, ConflictException { checkExistence(); if (isFile()) { final LockHolder theLock = lock; if (theLock == null) { throw new ConflictException("File is not locked"); } else if (isExpired(theLock)) { lock = null; throw new ConflictException("File is not locked"); } if (theLock.lockToken.equals(lockToken)) { lock = null; lastModificationDate = System.currentTimeMillis(); } else { throw new ForbiddenException("Unable remove lock from file. Lock token does not match"); } lastModificationDate = System.currentTimeMillis(); return this; } else { throw new ForbiddenException( String.format("Unable unlock '%s'. Locking allowed for files only", getPath())); } } @Override public boolean isLocked() { checkExistence(); final LockHolder myLock = lock; if (myLock != null) { if (isExpired(myLock)) { lock = null; return false; } return true; } return false; } private boolean isExpired(LockHolder lockHolder) { return lockHolder.expired < System.currentTimeMillis(); } @Override public VirtualFile createFile(String name, InputStream content) throws ForbiddenException, ConflictException, ServerException { checkExistence(); checkName(name); if (Path.of(name).length() > 1) { throw new ServerException(String.format("Invalid name '%s'", name)); } if (isFolder()) { final MemoryVirtualFile newFile; try { newFile = newFile(this, name, content); } catch (IOException e) { throw new ServerException( String.format("Unable set content of '%s'. Error: %s", getPath(), e.getMessage())); } if (!addChild(newFile)) { throw new ConflictException(String.format("Item with the name '%s' already exists", name)); } addInSearcher(newFile); return newFile; } else { throw new ForbiddenException("Unable create new file. Item specified as parent is not a folder"); } } @Override public VirtualFile createFile(String name, byte[] content) throws ForbiddenException, ConflictException, ServerException { return createFile(name, new ByteArrayInputStream(content)); } @Override public VirtualFile createFile(String name, String content) throws ForbiddenException, ConflictException, ServerException { return createFile(name, content.getBytes()); } @Override public VirtualFile createFolder(String name) throws ForbiddenException, ConflictException, ServerException { checkExistence(); checkName(name); if (name.charAt(0) == '/') { name = name.substring(1); } checkName(name); if (isFolder()) { MemoryVirtualFile newFolder = null; MemoryVirtualFile current = this; if (name.indexOf('/') > 0) { final Path internPath = Path.of(name); for (String element : internPath.elements()) { MemoryVirtualFile folder = newFolder(current, element); if (current.addChild(folder)) { newFolder = folder; current = folder; } else { current = current.children.get(element); } } if (newFolder == null) { throw new ConflictException(String.format("Item with the name '%s' already exists", name)); } } else { newFolder = newFolder(this, name); if (!addChild(newFolder)) { throw new ConflictException(String.format("Item with the name '%s' already exists", name)); } } return newFolder; } else { throw new ForbiddenException("Unable create new folder. Item specified as parent is not a folder"); } } @Override public java.io.File toIoFile() { return null; } @Override public VirtualFileSystem getFileSystem() { return fileSystem; } @Override public int compareTo(VirtualFile o) { // To get nice order of items: // 1. Regular folders // 2. Files if (o == null) { throw new NullPointerException(); } if (isFolder()) { return o.isFolder() ? getName().compareTo(o.getName()) : -1; } else if (o.isFolder()) { return 1; } return getName().compareTo(o.getName()); } @Override public String toString() { return getPath().toString(); } @Override public boolean equals(Object o) { if (this == o) { return true; } if (!(o instanceof MemoryVirtualFile)) { return false; } MemoryVirtualFile other = (MemoryVirtualFile) o; return Objects.equals(fileSystem, other.fileSystem) && Objects.equals(getPath(), other.getPath()); } @Override public int hashCode() { return Objects.hash(fileSystem, getPath()); } private void checkExistence() { if (!exists) { throw new RuntimeException(String.format("Item '%s' already removed", name)); } } 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(VirtualFile newFile) { SearcherProvider searcherProvider = fileSystem.getSearcherProvider(); if (searcherProvider != null) { try { searcherProvider.getSearcher(fileSystem).add(newFile); } catch (ServerException e) { LOG.error(e.getMessage(), e); } } } private void updateInSearcher() { SearcherProvider searcherProvider = fileSystem.getSearcherProvider(); if (searcherProvider != null) { try { searcherProvider.getSearcher(fileSystem).update(this); } catch (ServerException e) { LOG.error(e.getMessage(), e); } } } private void deleteFromSearcher(Path path, boolean isFile) { SearcherProvider searcherProvider = fileSystem.getSearcherProvider(); if (searcherProvider != null) { try { searcherProvider.getSearcher(fileSystem).delete(path.toString(), isFile); } catch (ServerException e) { LOG.error(e.getMessage(), e); } } } private boolean fileIsLockedAndLockTokenIsInvalid(String lockToken) { if (isLocked()) { final LockHolder myLock = lock; return myLock != null && !myLock.lockToken.equals(lockToken); } return false; } private static class LockHolder { final String lockToken; final long expired; LockHolder(String lockToken, long timeout) { this.lockToken = lockToken; this.expired = timeout > 0 ? (System.currentTimeMillis() + timeout) : Long.MAX_VALUE; } } }