fixed issue #56 implemented readAttributes(Path, String)

Upplication · May 28, 2016 · ed9da7f · ed9da7f
1 parent 6715d72
commit ed9da7f
Show file tree

Hide file tree

Showing 7 changed files with 283 additions and 26 deletions.
diff --git a/src/main/java/com/upplication/s3fs/S3FileSystemProvider.java b/src/main/java/com/upplication/s3fs/S3FileSystemProvider.java
@@ -41,6 +41,7 @@
 import com.google.common.collect.ImmutableList;
 import com.google.common.collect.ImmutableSet;
 import com.google.common.collect.Sets;
+import com.upplication.s3fs.util.AttributesUtil;
 import com.upplication.s3fs.util.Cache;
 import com.upplication.s3fs.util.S3Utils;
 
@@ -471,6 +472,23 @@ public <A extends BasicFileAttributes> A readAttributes(Path path, Class<A> type
 
 	@Override
 	public Map<String, Object> readAttributes(Path path, String attributes, LinkOption... options) throws IOException {
+		if (attributes == null){
+            throw new IllegalArgumentException("Attributes null");
+        }
+
+        if (attributes.contains(":") && !attributes.contains("basic:")) {
+            throw new UnsupportedOperationException(format("attributes %s are not supported, only basic are supported", attributes));
+        }
+
+        if (attributes.equals("*") || attributes.equals("basic:*")) {
+			BasicFileAttributes attr = readAttributes(path, BasicFileAttributes.class, options);
+            return AttributesUtil.fileAttributeToMap(attr);
+		} else if (attributes.contains(",")) {
+            String[] filters = attributes.split(",");
+            BasicFileAttributes attr = readAttributes(path, BasicFileAttributes.class, options);
+            return AttributesUtil.fileAttributeToMap(attr, filters);
+        }
+
 		throw new UnsupportedOperationException();
 	}
 

diff --git a/src/main/java/com/upplication/s3fs/util/AttributesUtil.java b/src/main/java/com/upplication/s3fs/util/AttributesUtil.java
@@ -0,0 +1,79 @@
+package com.upplication.s3fs.util;
+
+
+import java.nio.file.attribute.BasicFileAttributes;
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * Utilities to help transforming BasicFileAttributes to Map
+ */
+public abstract class AttributesUtil {
+
+    /**
+     * Given a BasicFileAttributes not null then return a Map
+     * with the keys as the fields of the BasicFileAttributes and the values
+     * with the content of the fields
+     * @param attr BasicFileAttributes
+     * @return Map String Object never null
+     */
+    public static Map<String, Object> fileAttributeToMap(BasicFileAttributes attr) {
+        Map<String, Object> result = new HashMap<>();
+        result.put("creationTime", attr.creationTime());
+        result.put("fileKey", attr.fileKey());
+        result.put("isDirectory", attr.isDirectory());
+        result.put("isOther", attr.isOther());
+        result.put("isRegularFile", attr.isRegularFile());
+        result.put("isSymbolicLink", attr.isSymbolicLink());
+        result.put("lastAccessTime", attr.lastAccessTime());
+        result.put("lastModifiedTime", attr.lastModifiedTime());
+        result.put("size", attr.size());
+        return result;
+    }
+
+    /**
+     * transform the BasicFileAttributes to Map filtering by the keys
+     * given in the filters param
+     * @param attr BasicFileAttributes not null to tranform to map
+     * @param filters String[] filters
+     * @return Map String Object with the same keys as the filters
+     */
+    public static Map<String, Object> fileAttributeToMap(BasicFileAttributes attr, String[] filters) {
+        Map<String, Object> result = new HashMap<>();
+
+        for (String filter : filters) {
+            filter = filter.replace("basic:", "");
+            switch (filter){
+                case "creationTime":
+                    result.put("creationTime", attr.creationTime());
+                    break;
+                case "fileKey":
+                    result.put("fileKey", attr.fileKey());
+                    break;
+                case "isDirectory":
+                    result.put("isDirectory", attr.isDirectory());
+                    break;
+                case "isOther":
+                    result.put("isOther", attr.isDirectory());
+                    break;
+                case "isRegularFile":
+                    result.put("isRegularFile", attr.isRegularFile());
+                    break;
+                case "isSymbolicLink":
+                    result.put("isSymbolicLink", attr.isSymbolicLink());
+                    break;
+                case "lastAccessTime":
+                    result.put("lastAccessTime", attr.lastAccessTime());
+                    break;
+                case "lastModifiedTime":
+                    result.put("lastModifiedTime", attr.lastModifiedTime());
+                    break;
+                case "size":
+                    result.put("size", attr.size());
+                    break;
+            }
+        }
+
+        return result;
+    }
+}
diff --git a/src/test/java/com/upplication/s3fs/FilesOperationsIT.java b/src/test/java/com/upplication/s3fs/FilesOperationsIT.java
@@ -19,6 +19,7 @@
 import java.nio.file.StandardOpenOption;
 import java.nio.file.attribute.BasicFileAttributes;
 import java.util.EnumSet;
+import java.util.Map;
 import java.util.UUID;
 
 import com.amazonaws.services.s3.AmazonS3;
@@ -169,16 +170,7 @@ public void directoryStreamBaseBucketFindDirectoryTest() throws IOException {
 		final Path fileToFind = Files.createDirectory(bucketPath.resolve(name));
 
 		try (DirectoryStream<Path> dirStream = Files.newDirectoryStream(bucketPath)) {
-			boolean find = false;
-			for (Path path : dirStream) {
-				// only first level
-				assertEquals(bucketPath, path.getParent());
-				if (path.equals(fileToFind)) {
-					find = true;
-					break;
-				}
-			}
-			assertTrue(find);
+			findFileInDirectoryStream(bucketPath, fileToFind, dirStream);
 		}
 	}
 
@@ -189,20 +181,11 @@ public void directoryStreamBaseBucketFindFileTest() throws IOException {
 		final Path fileToFind = Files.createFile(bucketPath.resolve(name));
 
 		try (DirectoryStream<Path> dirStream = Files.newDirectoryStream(bucketPath)) {
-			boolean find = false;
-			for (Path path : dirStream) {
-				// check parent at first level
-				assertEquals(bucketPath, path.getParent());
-				if (path.equals(fileToFind)) {
-					find = true;
-					break;
-				}
-			}
-			assertTrue(find);
+			findFileInDirectoryStream(bucketPath, fileToFind, dirStream);
 		}
 	}
 
-    @Test
+	@Test
 	public void directoryStreamFirstDirTest() throws IOException {
 		Path dir = uploadDir();
 
@@ -450,6 +433,36 @@ public void amazonOutpuStreamDetectContentType() throws IOException {
 		}
 	}
 
+	@Test
+	public void readAttributesFile() throws IOException {
+		final String content = "sample content";
+		Path file = uploadSingleFile(content);
+
+		BasicFileAttributes fileAttributes = Files.readAttributes(file, BasicFileAttributes.class);
+		assertNotNull(fileAttributes);
+		assertEquals(true, fileAttributes.isRegularFile());
+		assertEquals(false, fileAttributes.isDirectory());
+		assertEquals(false, fileAttributes.isSymbolicLink());
+		assertEquals(false, fileAttributes.isOther());
+		assertEquals(content.length(), fileAttributes.size());
+	}
+
+    @Test
+    public void readAttributesString() throws IOException {
+        final String content = "sample content";
+        Path file = uploadSingleFile(content);
+
+        BasicFileAttributes fileAttributes = Files.readAttributes(file, BasicFileAttributes.class);
+        Map<String, Object> fileAttributesMap = Files.readAttributes(file, "*");
+        assertNotNull(fileAttributes);
+        assertNotNull(fileAttributesMap);
+        assertEquals(fileAttributes.isRegularFile(), fileAttributesMap.get("isRegularFile"));
+        assertEquals(fileAttributes.isDirectory(), fileAttributesMap.get("isDirectory"));
+        assertEquals(fileAttributes.creationTime(), fileAttributesMap.get("creationTime"));
+        assertEquals(fileAttributes.lastModifiedTime(), fileAttributesMap.get("lastModifiedTime"));
+        assertEquals(9, fileAttributesMap.size());
+    }
+
     @Test
 	public void readAttributesDirectory() throws IOException {
 		Path dir;
@@ -474,6 +487,7 @@ public void readAttributesDirectory() throws IOException {
 		assertEquals(true, fileAttributes.isDirectory());
 		assertEquals(startPath + "lib/angular/", fileAttributes.fileKey());
 	}
+
     @Test
 	public void seekableCloseTwice() throws IOException {
 		Path file = createEmptyFile();
@@ -547,4 +561,17 @@ private Path uploadDir() throws IOException {
 			return dir;
 		}
 	}
+
+	private void findFileInDirectoryStream(Path bucketPath, Path fileToFind, DirectoryStream<Path> dirStream) {
+		boolean find = false;
+		for (Path path : dirStream) {
+			// check parent at first level
+			assertEquals(bucketPath, path.getParent());
+			if (path.equals(fileToFind)) {
+				find = true;
+				break;
+			}
+		}
+		assertTrue(find);
+	}
 }
diff --git a/src/test/java/com/upplication/s3fs/S3FileStoreTest.java b/src/test/java/com/upplication/s3fs/S3FileStoreTest.java
@@ -96,7 +96,7 @@ public void getRootDirectory() {
 		S3Path rootDirectory = fileStore.getRootDirectory();
 		assertEquals("bucket", rootDirectory.getFileName().toString());
 		assertEquals("/bucket/", rootDirectory.toAbsolutePath().toString());
-		assertEquals("s3://access-mocked@s3.amazonaws.com/bucket/", rootDirectory.toUri().toString());
+		assertEquals("s3://access-mocked@s3.test.amazonaws.com/bucket/", rootDirectory.toUri().toString());
 	}
 
 	@Test

diff --git a/src/test/java/com/upplication/s3fs/S3FileSystemProviderTest.java b/src/test/java/com/upplication/s3fs/S3FileSystemProviderTest.java
@@ -1232,11 +1232,133 @@ public void readAttributesNotAcceptedSubclass() throws IOException {
 		s3fsProvider.readAttributes(dir, DosFileAttributes.class);
 	}
 
-	@Test(expected = UnsupportedOperationException.class)
-	public void readAttributesString() throws IOException {
-		s3fsProvider.readAttributes(null, "");
+	@Test
+	public void readAttributesAll() throws IOException {
+		// fixtures
+		AmazonS3ClientMock client = AmazonS3MockFactory.getAmazonClientMock();
+		final String content = "sample";
+		Path memoryFile = Files.write(client.bucket("bucketA").dir("dir").resolve("dir/file"), content.getBytes());
+
+		BasicFileAttributes expectedAttributes = Files.readAttributes(memoryFile, BasicFileAttributes.class);
+
+		FileSystem fs = createNewS3FileSystem();
+		Path file = fs.getPath("/bucketA/dir/file");
+
+		Map<String, Object> fileAttributes = s3fsProvider.readAttributes(file, "*");
+
+		assertNotNull(fileAttributes);
+		assertEquals(false, fileAttributes.get("isDirectory"));
+		assertEquals(true, fileAttributes.get("isRegularFile"));
+		assertEquals(false, fileAttributes.get("isSymbolicLink"));
+		assertEquals(false, fileAttributes.get("isOther"));
+		assertEquals((long)content.getBytes().length, fileAttributes.get("size"));
+		assertEquals("dir/file", fileAttributes.get("fileKey"));
+		assertEquals(expectedAttributes.lastModifiedTime(), fileAttributes.get("lastModifiedTime"));
+		assertEquals(expectedAttributes.lastModifiedTime(), fileAttributes.get("creationTime"));
+		assertEquals(expectedAttributes.lastModifiedTime(), fileAttributes.get("lastAccessTime"));
 	}
 
+    @Test
+    public void readAttributesAllBasic() throws IOException {
+        // fixtures
+        AmazonS3ClientMock client = AmazonS3MockFactory.getAmazonClientMock();
+        Files.write(client.bucket("bucketA").dir("dir").resolve("dir/file"), "sample".getBytes());
+
+        FileSystem fs = createNewS3FileSystem();
+        Path file = fs.getPath("/bucketA/dir/file");
+
+        Map<String, Object> fileAttributes = s3fsProvider.readAttributes(file, "basic:*");
+        Map<String, Object> fileAttributes2 = s3fsProvider.readAttributes(file, "*");
+
+        assertArrayEquals(fileAttributes.values().toArray(new Object[]{}),
+                fileAttributes2.values().toArray(new Object[]{}));
+        assertArrayEquals(fileAttributes.keySet().toArray(new String[]{}),
+                fileAttributes2.keySet().toArray(new String[]{}));
+    }
+
+    @Test
+    public void readAttributesPartial() throws IOException {
+        // fixtures
+        AmazonS3ClientMock client = AmazonS3MockFactory.getAmazonClientMock();
+        Files.write(client.bucket("bucketA").dir("dir").resolve("dir/file"), "sample".getBytes());
+
+        FileSystem fs = createNewS3FileSystem();
+        Path file = fs.getPath("/bucketA/dir/file");
+
+        Map<String, Object> fileAttributes = s3fsProvider.readAttributes(file, "isDirectory,isRegularFile");
+
+        assertNotNull(fileAttributes);
+        assertEquals(false, fileAttributes.get("isDirectory"));
+        assertEquals(true, fileAttributes.get("isRegularFile"));
+        assertEquals(2, fileAttributes.size());
+    }
+
+    @Test
+    public void readAttributesPartialBasic() throws IOException {
+        // fixtures
+        AmazonS3ClientMock client = AmazonS3MockFactory.getAmazonClientMock();
+        Files.write(client.bucket("bucketA").dir("dir").resolve("dir/file"), "sample".getBytes());
+
+        FileSystem fs = createNewS3FileSystem();
+        Path file = fs.getPath("/bucketA/dir/file");
+
+        Map<String, Object> fileAttributes = s3fsProvider.readAttributes(file, "basic:isOther,basic:creationTime");
+        Map<String, Object> fileAttributes2 = s3fsProvider.readAttributes(file, "isOther,creationTime");
+
+        assertArrayEquals(fileAttributes.values().toArray(new Object[]{}),
+                fileAttributes2.values().toArray(new Object[]{}));
+        assertArrayEquals(fileAttributes.keySet().toArray(new String[]{}),
+                fileAttributes2.keySet().toArray(new String[]{}));
+    }
+
+    @Test(expected = IllegalArgumentException.class)
+    public void readAttributesNullAttrs() throws IOException {
+        // fixtures
+        AmazonS3ClientMock client = AmazonS3MockFactory.getAmazonClientMock();
+        Files.write(client.bucket("bucketA").dir("dir").resolve("dir/file"), "sample".getBytes());
+
+        FileSystem fs = createNewS3FileSystem();
+        Path file = fs.getPath("/bucketA/dir/file");
+
+        s3fsProvider.readAttributes(file, (String)null);
+    }
+
+    @Test(expected = UnsupportedOperationException.class)
+    public void readAttributesPosixNotSupported() throws IOException {
+        // fixtures
+        AmazonS3ClientMock client = AmazonS3MockFactory.getAmazonClientMock();
+        Files.write(client.bucket("bucketA").dir("dir").resolve("dir/file"), "sample".getBytes());
+
+        FileSystem fs = createNewS3FileSystem();
+        Path file = fs.getPath("/bucketA/dir/file");
+
+        s3fsProvider.readAttributes(file, "posix:*");
+    }
+
+    @Test(expected = UnsupportedOperationException.class)
+    public void readAttributesDosNotSupported() throws IOException {
+        // fixtures
+        AmazonS3ClientMock client = AmazonS3MockFactory.getAmazonClientMock();
+        Files.write(client.bucket("bucketA").dir("dir").resolve("dir/file"), "sample".getBytes());
+
+        FileSystem fs = createNewS3FileSystem();
+        Path file = fs.getPath("/bucketA/dir/file");
+
+        s3fsProvider.readAttributes(file, "dos:*");
+    }
+
+    @Test(expected = UnsupportedOperationException.class)
+    public void readAttributesUnknowNotSupported() throws IOException {
+        // fixtures
+        AmazonS3ClientMock client = AmazonS3MockFactory.getAmazonClientMock();
+        Files.write(client.bucket("bucketA").dir("dir").resolve("dir/file"), "sample".getBytes());
+
+        FileSystem fs = createNewS3FileSystem();
+        Path file = fs.getPath("/bucketA/dir/file");
+
+        s3fsProvider.readAttributes(file, "lelel:*");
+    }
+
 	// setAttribute
 
 	@Test(expected = UnsupportedOperationException.class)

diff --git a/src/test/java/com/upplication/s3fs/S3UnitTestBase.java b/src/test/java/com/upplication/s3fs/S3UnitTestBase.java
@@ -14,7 +14,7 @@
 
 public class S3UnitTestBase {
 
-	public static final URI S3_GLOBAL_URI = URI.create("s3://s3.amazonaws.com/");
+	public static final URI S3_GLOBAL_URI = URI.create("s3://s3.test.amazonaws.com/");
 
 	@BeforeClass
 	public static void setProperties() {