Java tutorial
/* * Copyright 2013 Google Inc. * * 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 com.google.jimfs; import static com.google.common.base.Preconditions.checkNotNull; import static com.google.jimfs.UserLookupService.createGroupPrincipal; import com.google.common.collect.ImmutableMap; import com.google.common.collect.ImmutableSet; import com.google.common.collect.Sets; import java.io.IOException; import java.nio.file.attribute.BasicFileAttributeView; import java.nio.file.attribute.FileAttributeView; import java.nio.file.attribute.FileOwnerAttributeView; import java.nio.file.attribute.FileTime; import java.nio.file.attribute.GroupPrincipal; import java.nio.file.attribute.PosixFileAttributeView; import java.nio.file.attribute.PosixFileAttributes; import java.nio.file.attribute.PosixFilePermission; import java.nio.file.attribute.PosixFilePermissions; import java.nio.file.attribute.UserPrincipal; import java.util.Map; import java.util.Set; import javax.annotation.Nullable; /** * Attribute provider that provides the {@link PosixFileAttributeView} ("posix") and allows reading * of {@link PosixFileAttributes}. * * @author Colin Decker */ final class PosixAttributeProvider extends AttributeProvider { private static final ImmutableSet<String> ATTRIBUTES = ImmutableSet.of("group", "permissions"); private static final ImmutableSet<String> INHERITED_VIEWS = ImmutableSet.of("basic", "owner"); private static final GroupPrincipal DEFAULT_GROUP = createGroupPrincipal("group"); private static final ImmutableSet<PosixFilePermission> DEFAULT_PERMISSIONS = Sets .immutableEnumSet(PosixFilePermissions.fromString("rw-r--r--")); @Override public String name() { return "posix"; } @Override public ImmutableSet<String> inherits() { return INHERITED_VIEWS; } @Override public ImmutableSet<String> fixedAttributes() { return ATTRIBUTES; } @SuppressWarnings("unchecked") @Override public ImmutableMap<String, ?> defaultValues(Map<String, ?> userProvidedDefaults) { Object userProvidedGroup = userProvidedDefaults.get("posix:group"); UserPrincipal group = DEFAULT_GROUP; if (userProvidedGroup != null) { if (userProvidedGroup instanceof String) { group = createGroupPrincipal((String) userProvidedGroup); } else { throw new IllegalArgumentException("invalid type " + userProvidedGroup.getClass() + " for attribute 'posix:group': should be one of " + String.class + " or " + GroupPrincipal.class); } } Object userProvidedPermissions = userProvidedDefaults.get("posix:permissions"); Set<PosixFilePermission> permissions = DEFAULT_PERMISSIONS; if (userProvidedPermissions != null) { if (userProvidedPermissions instanceof String) { permissions = Sets .immutableEnumSet(PosixFilePermissions.fromString((String) userProvidedPermissions)); } else if (userProvidedPermissions instanceof Set) { permissions = toPermissions((Set<?>) userProvidedPermissions); } else { throw new IllegalArgumentException("invalid type " + userProvidedPermissions.getClass() + " for attribute 'posix:permissions': should be one of " + String.class + " or " + Set.class); } } return ImmutableMap.of("posix:group", group, "posix:permissions", permissions); } @Nullable @Override public Object get(File file, String attribute) { switch (attribute) { case "group": return file.getAttribute("posix", "group"); case "permissions": return file.getAttribute("posix", "permissions"); default: return null; } } @Override public void set(File file, String view, String attribute, Object value, boolean create) { switch (attribute) { case "group": checkNotCreate(view, attribute, create); GroupPrincipal group = checkType(view, attribute, value, GroupPrincipal.class); if (!(group instanceof UserLookupService.JimfsGroupPrincipal)) { group = createGroupPrincipal(group.getName()); } file.setAttribute("posix", "group", group); break; case "permissions": file.setAttribute("posix", "permissions", toPermissions(checkType(view, attribute, value, Set.class))); break; default: } } @SuppressWarnings("unchecked") // only cast after checking each element's type private static ImmutableSet<PosixFilePermission> toPermissions(Set<?> set) { ImmutableSet<?> copy = ImmutableSet.copyOf(set); for (Object obj : copy) { if (!(obj instanceof PosixFilePermission)) { throw new IllegalArgumentException("invalid element for attribute 'posix:permissions': " + "should be Set<PosixFilePermission>, found element of type " + obj.getClass()); } } return Sets.immutableEnumSet((ImmutableSet<PosixFilePermission>) copy); } @Override public Class<PosixFileAttributeView> viewType() { return PosixFileAttributeView.class; } @Override public PosixFileAttributeView view(FileLookup lookup, ImmutableMap<String, FileAttributeView> inheritedViews) { return new View(lookup, (BasicFileAttributeView) inheritedViews.get("basic"), (FileOwnerAttributeView) inheritedViews.get("owner")); } @Override public Class<PosixFileAttributes> attributesType() { return PosixFileAttributes.class; } @Override public PosixFileAttributes readAttributes(File file) { return new Attributes(file); } /** * Implementation of {@link PosixFileAttributeView}. */ private static class View extends AbstractAttributeView implements PosixFileAttributeView { private final BasicFileAttributeView basicView; private final FileOwnerAttributeView ownerView; protected View(FileLookup lookup, BasicFileAttributeView basicView, FileOwnerAttributeView ownerView) { super(lookup); this.basicView = checkNotNull(basicView); this.ownerView = checkNotNull(ownerView); } @Override public String name() { return "posix"; } @Override public PosixFileAttributes readAttributes() throws IOException { return new Attributes(lookupFile()); } @Override public void setTimes(FileTime lastModifiedTime, FileTime lastAccessTime, FileTime createTime) throws IOException { basicView.setTimes(lastModifiedTime, lastAccessTime, createTime); } @Override public void setPermissions(Set<PosixFilePermission> perms) throws IOException { lookupFile().setAttribute("posix", "permissions", ImmutableSet.copyOf(perms)); } @Override public void setGroup(GroupPrincipal group) throws IOException { lookupFile().setAttribute("posix", "group", checkNotNull(group)); } @Override public UserPrincipal getOwner() throws IOException { return ownerView.getOwner(); } @Override public void setOwner(UserPrincipal owner) throws IOException { ownerView.setOwner(owner); } } /** * Implementation of {@link PosixFileAttributes}. */ static class Attributes extends BasicAttributeProvider.Attributes implements PosixFileAttributes { private final UserPrincipal owner; private final GroupPrincipal group; private final ImmutableSet<PosixFilePermission> permissions; @SuppressWarnings("unchecked") protected Attributes(File file) { super(file); this.owner = (UserPrincipal) file.getAttribute("owner", "owner"); this.group = (GroupPrincipal) file.getAttribute("posix", "group"); this.permissions = (ImmutableSet<PosixFilePermission>) file.getAttribute("posix", "permissions"); } @Override public UserPrincipal owner() { return owner; } @Override public GroupPrincipal group() { return group; } @Override public ImmutableSet<PosixFilePermission> permissions() { return permissions; } } }