src/jdk.zipfs/share/classes/jdk/nio/zipfs/ZipFileAttributeView.java

rev 53081 : 8213031: (zipfs) Add support for POSIX file permissions
Reviewed-by: simonis

@@ -27,17 +27,22 @@
 
 import java.io.IOException;
 import java.nio.file.attribute.BasicFileAttributeView;
 import java.nio.file.attribute.FileAttributeView;
 import java.nio.file.attribute.FileTime;
+import java.nio.file.attribute.GroupPrincipal;
+import java.nio.file.attribute.PosixFileAttributeView;
+import java.nio.file.attribute.PosixFilePermission;
+import java.nio.file.attribute.UserPrincipal;
 import java.util.LinkedHashMap;
 import java.util.Map;
+import java.util.Set;
 
 /**
  * @author Xueming Shen, Rajendra Gutupalli, Jaya Hangal
  */
-class ZipFileAttributeView implements BasicFileAttributeView {
+class ZipFileAttributeView implements PosixFileAttributeView {
     private static enum AttrID {
         size,
         creationTime,
         lastAccessTime,
         lastModifiedTime,

@@ -46,45 +51,64 @@
         isSymbolicLink,
         isOther,
         fileKey,
         compressedSize,
         crc,
-        method
+        method,
+        permissions
     };
 
+    private static enum ViewType {
+        zip,
+        posix,
+        basic
+    }
+
     private final ZipPath path;
-    private final boolean isZipView;
+    private final ViewType type;
 
-    private ZipFileAttributeView(ZipPath path, boolean isZipView) {
+    private ZipFileAttributeView(ZipPath path, ViewType type) {
         this.path = path;
-        this.isZipView = isZipView;
+        this.type = type;
     }
 
     @SuppressWarnings("unchecked") // Cast to V
     static <V extends FileAttributeView> V get(ZipPath path, Class<V> type) {
         if (type == null)
             throw new NullPointerException();
         if (type == BasicFileAttributeView.class)
-            return (V)new ZipFileAttributeView(path, false);
+            return (V)new ZipFileAttributeView(path, ViewType.basic);
+        if (type == PosixFileAttributeView.class)
+            return (V)new ZipFileAttributeView(path, ViewType.posix);
         if (type == ZipFileAttributeView.class)
-            return (V)new ZipFileAttributeView(path, true);
+            return (V)new ZipFileAttributeView(path, ViewType.zip);
         return null;
     }
 
     static ZipFileAttributeView get(ZipPath path, String type) {
         if (type == null)
             throw new NullPointerException();
         if (type.equals("basic"))
-            return new ZipFileAttributeView(path, false);
+            return new ZipFileAttributeView(path, ViewType.basic);
+        if (type.equals("posix"))
+            return new ZipFileAttributeView(path, ViewType.posix);
         if (type.equals("zip"))
-            return new ZipFileAttributeView(path, true);
+            return new ZipFileAttributeView(path, ViewType.zip);
         return null;
     }
 
     @Override
     public String name() {
-        return isZipView ? "zip" : "basic";
+        switch (type) {
+        case zip:
+            return "zip";
+        case posix:
+            return "posix";
+        case basic:
+        default:
+            return "basic";
+        }
     }
 
     public ZipFileAttributes readAttributes() throws IOException {
         return path.getAttributes();
     }

@@ -96,24 +120,48 @@
         throws IOException
     {
         path.setTimes(lastModifiedTime, lastAccessTime, createTime);
     }
 
+    @Override
+    public UserPrincipal getOwner() throws IOException {
+        throw new UnsupportedOperationException("ZipFileSystem does not support getOwner.");
+    }
+
+    @Override
+    public void setOwner(UserPrincipal owner) throws IOException {
+        throw new UnsupportedOperationException("ZipFileSystem does not support setOwner.");
+    }
+
+    @Override
+    public void setPermissions(Set<PosixFilePermission> perms) throws IOException {
+        path.setPermissions(perms);
+    }
+
+    @Override
+    public void setGroup(GroupPrincipal group) throws IOException {
+        throw new UnsupportedOperationException("ZipFileSystem does not support setGroup.");
+    }
+
+    @SuppressWarnings("unchecked")
     void setAttribute(String attribute, Object value)
         throws IOException
     {
         try {
             if (AttrID.valueOf(attribute) == AttrID.lastModifiedTime)
                 setTimes((FileTime)value, null, null);
             if (AttrID.valueOf(attribute) == AttrID.lastAccessTime)
                 setTimes(null, (FileTime)value, null);
             if (AttrID.valueOf(attribute) == AttrID.creationTime)
                 setTimes(null, null, (FileTime)value);
+            if (AttrID.valueOf(attribute) == AttrID.permissions)
+                setPermissions((Set<PosixFilePermission>)value);
             return;
-        } catch (IllegalArgumentException x) {}
-        throw new UnsupportedOperationException("'" + attribute +
-            "' is unknown or read-only attribute");
+        } catch (IllegalArgumentException x) {
+            throw new UnsupportedOperationException("'" + attribute +
+                "' is unknown or read-only attribute");
+        }
     }
 
     Map<String, Object> readAttributes(String attributes)
         throws IOException
     {

@@ -134,11 +182,11 @@
             }
         }
         return map;
     }
 
-    Object attribute(AttrID id, ZipFileAttributes zfas) {
+    private Object attribute(AttrID id, ZipFileAttributes zfas) {
         switch (id) {
         case size:
             return zfas.size();
         case creationTime:
             return zfas.creationTime();

@@ -154,21 +202,33 @@
             return zfas.isSymbolicLink();
         case isOther:
             return zfas.isOther();
         case fileKey:
             return zfas.fileKey();
+        case permissions:
+            if (type == ViewType.posix || type == ViewType.zip) {
+                try {
+                   return zfas.permissions();
+                } catch (UnsupportedOperationException e) {
+                    return null;
+                }
+            }
+            break;
         case compressedSize:
-            if (isZipView)
+            if (type == ViewType.zip) {
                 return zfas.compressedSize();
+            }
             break;
         case crc:
-            if (isZipView)
+            if (type == ViewType.zip) {
                 return zfas.crc();
+            }
             break;
         case method:
-            if (isZipView)
+            if (type == ViewType.zip) {
                 return zfas.method();
+            }
             break;
         }
         return null;
     }
 }