HADOOP-19161. Add ability to list all enabled capabilities

+use in BucketInfo

Change-Id: I737dd7fe261b3a52e9c9d0df77edc2938c0c457d

Author: steveloughran

hadoop-common-project/hadoop-common/src/main/java/org/apache/hadoop/fs/impl/FlagSet.java

@@ -20,6 +20,7 @@
 
 import java.util.Arrays;
 import java.util.EnumSet;
+import java.util.List;
 import java.util.Map;
 import java.util.Objects;
 import java.util.Set;
@@ -169,6 +170,18 @@ public String toString() {
         + '}';
   }
 
+
+  /**
+   * Generate the list of capabilities.
+   * @return a possibly empty list.
+   */
+  public List<String> pathCapabilities() {
+    return namesToValues.keySet().stream()
+        .filter(this::hasCapability)
+        .collect(Collectors.toList());
+  }
+
+
   /**
    * Equality is based on the set.
    * @param o other object

hadoop-common-project/hadoop-common/src/test/java/org/apache/hadoop/fs/impl/TestFlagSet.java

@@ -39,6 +39,12 @@ public final class TestFlagSet extends AbstractHadoopTestBase {
 
   private static final String KEY = "key";
 
+  public static final String CAPABILITY_B = KEY + ".b";
+
+  public static final String CAPABILITY_C = KEY + ".c";
+
+  public static final String CAPABILITY_A = KEY + ".a";
+
   private static final String KEYDOT = KEY + ".";
 
   /**
@@ -48,7 +54,7 @@ public final class TestFlagSet extends AbstractHadoopTestBase {
       createFlagSet(SimpleEnum.class, KEYDOT, noneOf(SimpleEnum.class));
 
   /**
-   * Simple Enums.
+   * Simple Enums for the tests.
    */
   private enum SimpleEnum { a, b, c }
 
@@ -146,9 +152,10 @@ public void assertConfigurationStringMatches(final String expected) {
   public void testConfEntry() {
     flagSet = flagSetFromConfig("a\t,\nc ", true);
     assertFlagSetMatches(flagSet, SimpleEnum.a, SimpleEnum.c);
-    assertHasCapability(KEY + ".a");
-    assertHasCapability(KEY + ".c");
-    assertLacksCapability(KEY + ".b");
+    assertHasCapability(CAPABILITY_A);
+    assertHasCapability(CAPABILITY_C);
+    assertLacksCapability(CAPABILITY_B);
+    assertPathCapabilitiesMatch(flagSet, CAPABILITY_A, CAPABILITY_C);
   }
 
   /**
@@ -160,8 +167,7 @@ public void testConfEntry() {
   private static FlagSet<SimpleEnum> flagSetFromConfig(final String string,
       final boolean ignoreUnknown) {
     final Configuration conf = mkConf(string);
-    final FlagSet<SimpleEnum> fs = buildFlagSet(SimpleEnum.class, conf, KEY, ignoreUnknown);
-    return fs;
+    return buildFlagSet(SimpleEnum.class, conf, KEY, ignoreUnknown);
   }
 
   /**
@@ -172,8 +178,8 @@ private static FlagSet<SimpleEnum> flagSetFromConfig(final String string,
   public void testConfEntryWithUnknownIgnored() {
     flagSet = flagSetFromConfig("a, unknown", true);
     assertFlagSetMatches(flagSet, SimpleEnum.a);
-    assertHasCapability(KEY + ".a");
-    assertLacksCapability(KEY + ".b");
+    assertHasCapability(CAPABILITY_A);
+    assertLacksCapability(CAPABILITY_B);
   }
 
   /**
@@ -184,7 +190,7 @@ public void testConfEntryWithUnknownIgnored() {
   public void testDuplicateConfEntry() {
     flagSet = flagSetFromConfig("a,\ta,\na\"", true);
     assertFlagSetMatches(flagSet, SimpleEnum.a);
-    assertHasCapability(KEY + ".a");
+    assertHasCapability(CAPABILITY_A);
   }
 
   /**
@@ -231,16 +237,21 @@ private void assertLacksCapability(final String capability) {
    * Test the * binding.
    */
   @Test
-  public void testFlagSetStarEntry() {
+  public void testStarEntry() {
     flagSet = flagSetFromConfig("*", false);
     assertFlags(SimpleEnum.a, SimpleEnum.b, SimpleEnum.c);
-    assertHasCapability(KEY + ".a");
-    assertHasCapability(KEY + ".b");
+    assertHasCapability(CAPABILITY_A);
+    assertHasCapability(CAPABILITY_B);
+    Assertions.assertThat(flagSet.pathCapabilities())
+        .describedAs("path capabilities of %s", flagSet)
+        .containsExactlyInAnyOrder(CAPABILITY_A, CAPABILITY_B, CAPABILITY_C);
   }
 
   @Test
   public void testRoundTrip() {
-    final FlagSet<SimpleEnum> s1 = createFlagSet(SimpleEnum.class, KEYDOT, allOf(SimpleEnum.class));
+    final FlagSet<SimpleEnum> s1 = createFlagSet(SimpleEnum.class,
+        KEYDOT,
+        allOf(SimpleEnum.class));
     final FlagSet<SimpleEnum> s2 = roundTrip(s1);
     Assertions.assertThat(s1.flags()).isEqualTo(s2.flags());
     assertFlagSetMatches(s2, SimpleEnum.a, SimpleEnum.b, SimpleEnum.c);
@@ -257,6 +268,9 @@ public void testEmptyRoundTrip() {
         .describedAs("empty flagset %s", s2)
         .isTrue();
     assertFlagSetMatches(flagSet);
+    Assertions.assertThat(flagSet.pathCapabilities())
+        .describedAs("path capabilities of %s", flagSet)
+        .isEmpty();
   }
 
   @Test
@@ -323,8 +337,8 @@ private void assertEnabled(final SimpleEnum flag) {
    * @param flag flag to check
    */
   private void assertDisabled(final SimpleEnum flag) {
-    Assertions.assertThat(flagSet.enabled(flag)).
-        describedAs("status of flag %s in %s", flag, flagSet)
+    Assertions.assertThat(flagSet.enabled(flag))
+        .describedAs("status of flag %s in %s", flag, flagSet)
         .isFalse();
   }
 
@@ -345,7 +359,23 @@ private void assertFlags(final SimpleEnum... flags) {
   private void assertFlagSetMatches(
       FlagSet<SimpleEnum> fs,
       SimpleEnum... flags) {
-    Assertions.assertThat(fs.flags()).containsExactly(flags);
+    Assertions.assertThat(fs.flags())
+        .describedAs("path capabilities of %s", fs)
+        .containsExactly(flags);
   }
 
+  /**
+   * Assert that a flagset contains exactly the capabilities.
+   * This is calculated by getting the list of active capabilities
+   * and asserting on the list.
+   * @param fs flagset
+   * @param capabilities capabilities
+   */
+  private void assertPathCapabilitiesMatch(
+      FlagSet<SimpleEnum> fs,
+      String... capabilities) {
+    Assertions.assertThat(fs.pathCapabilities())
+        .describedAs("path capabilities of %s", fs)
+        .containsExactlyInAnyOrder(capabilities);
+  }
 }

hadoop-tools/hadoop-aws/src/main/java/org/apache/hadoop/fs/s3a/s3guard/S3GuardTool.java

@@ -392,6 +392,8 @@ public static class BucketInfo extends S3GuardTool {
         "\tThe S3A connector is compatible with buckets where"
             + " directory markers are not deleted";
 
+    public static final String CAPABILITY_FORMAT = "\t%s %s%n";
+
     public BucketInfo(Configuration conf) {
       super(conf, GUARDED_FLAG, UNGUARDED_FLAG, FIPS_FLAG, MAGIC_FLAG);
       CommandFormat format = getCommandFormat();
@@ -560,9 +562,14 @@ public int run(String[] args, PrintStream out)
       // and check for capabilities
       println(out, "%nStore Capabilities");
       for (String capability : S3A_DYNAMIC_CAPABILITIES) {
-        out.printf("\t%s %s%n", capability,
+        out.printf(CAPABILITY_FORMAT, capability,
             fs.hasPathCapability(root, capability));
       }
+      // the performance flags are dynamically generated
+      fs.createStoreContext().getPerformanceFlags().pathCapabilities()
+          .forEach(capability -> out.printf(CAPABILITY_FORMAT, capability));
+
+      // finish with a newline
       println(out, "");
 
       if (commands.getOpt(FIPS_FLAG) && !fs.hasPathCapability(root, FIPS_ENDPOINT)) {