Add namespace filter option in config file

api/src/main/java/marquez/MarquezApp.java

@@ -26,6 +26,8 @@
 import lombok.NonNull;
 import lombok.extern.slf4j.Slf4j;
 import marquez.api.filter.JobRedirectFilter;
+import marquez.api.filter.exclusions.ExclusionsConfig;
+import marquez.api.filter.exclusions.ExclusionsFilter;
 import marquez.cli.DbMigrationCommand;
 import marquez.cli.DbRetentionCommand;
 import marquez.cli.MetadataCommand;
@@ -139,6 +141,15 @@ public void run(@NonNull MarquezConfig config, @NonNull Environment env) {
       // Add job to apply retention policy to database.
       env.lifecycle().manage(new DbRetentionJob(jdbi, config.getDbRetention()));
     }
+
+    // set namespaceFilter
+    if (config.hasExcludingPatterns()) {
+      ExclusionsConfig exclusions = config.getExclude();
+      if (exclusions.namespaces.onRead) {
+        ExclusionsFilter.setNamespacesReadFilter(exclusions.namespaces.patterns);
+      }
+      ;
+    }
   }
 
   private boolean isSentryEnabled(MarquezConfig config) {

api/src/main/java/marquez/MarquezConfig.java

@@ -12,6 +12,7 @@
 import lombok.Getter;
 import lombok.NoArgsConstructor;
 import lombok.Setter;
+import marquez.api.filter.exclusions.ExclusionsConfig;
 import marquez.db.FlywayFactory;
 import marquez.graphql.GraphqlConfig;
 import marquez.jobs.DbRetentionConfig;
@@ -48,8 +49,17 @@ public class MarquezConfig extends Configuration {
   @JsonProperty("dbRetention")
   private DbRetentionConfig dbRetention; // OPTIONAL
 
+  @Getter
+  @JsonProperty("exclude")
+  private ExclusionsConfig exclude; // OPTIONAL
+
   /** Returns {@code true} if a data retention policy has been configured. */
   public boolean hasDbRetentionPolicy() {
     return (dbRetention != null);
   }
+
+  /** Returns {@code true} if an exclude pattern has been configured. */
+  public boolean hasExcludingPatterns() {
+    return (exclude != null);
+  }
 }

api/src/main/java/marquez/api/NamespaceResource.java

@@ -27,6 +27,7 @@
 import lombok.NonNull;
 import lombok.Value;
 import marquez.api.exceptions.NamespaceNotFoundException;
+import marquez.api.filter.exclusions.ExclusionsFilter;
 import marquez.common.models.NamespaceName;
 import marquez.service.ServiceFactory;
 import marquez.service.models.Namespace;
@@ -74,8 +75,16 @@ public Response get(@PathParam("namespace") NamespaceName name) {
   public Response list(
       @QueryParam("limit") @DefaultValue("100") @Min(value = 0) int limit,
       @QueryParam("offset") @DefaultValue("0") @Min(value = 0) int offset) {
-    final List<Namespace> namespaces = namespaceService.findAll(limit, offset);
-    return Response.ok(new Namespaces(namespaces)).build();
+    final String namespaceFilter = ExclusionsFilter.getNamespacesReadFilter();
+    final List<Namespace> allNamespaces = namespaceService.findAll(limit, offset);
+
+    if (namespaceFilter != null) {
+      final List<Namespace> FilterNamespaces =
+          namespaceService.findAllFilter(namespaceFilter, limit, offset);
+      return Response.ok(new Namespaces(FilterNamespaces)).build();
+    } else {
+      return Response.ok(new Namespaces(allNamespaces)).build();
+    }
   }
 
   @Timed

api/src/main/java/marquez/api/filter/exclusions/ExclusionsConfig.java

@@ -0,0 +1,15 @@
+package marquez.api.filter.exclusions;
+
+import com.fasterxml.jackson.annotation.JsonProperty;
+import lombok.Getter;
+
+public class ExclusionsConfig {
+  @Getter @JsonProperty public NamespaceExclusion namespaces;
+
+  public static class NamespaceExclusion {
+    @Getter @JsonProperty public boolean onRead;
+    @Getter @JsonProperty public boolean onWrite;
+    @Getter @JsonProperty public String patterns;
+  }
+  ;
+}

api/src/main/java/marquez/api/filter/exclusions/ExclusionsFilter.java

@@ -0,0 +1,13 @@
+package marquez.api.filter.exclusions;
+
+public class ExclusionsFilter {
+  private static String namespacesFilter;
+
+  public static void setNamespacesReadFilter(String filter) {
+    namespacesFilter = filter;
+  }
+
+  public static String getNamespacesReadFilter() {
+    return namespacesFilter;
+  }
+}

api/src/main/java/marquez/db/NamespaceDao.java

@@ -78,6 +78,10 @@ default Namespace upsertNamespaceMeta(
   @SqlQuery("SELECT * FROM namespaces ORDER BY name LIMIT :limit OFFSET :offset")
   List<Namespace> findAll(int limit, int offset);
 
+  @SqlQuery(
+      "SELECT * FROM namespaces WHERE name !~ :excluded ORDER BY name LIMIT :limit OFFSET :offset")
+  List<Namespace> findAllFilter(String excluded, int limit, int offset);
+
   @SqlQuery("UPDATE namespaces SET is_hidden=false WHERE name = :name RETURNING *")
   NamespaceRow undelete(String name);
 

api/src/test/java/marquez/api/NamespaceResourceTest.java

@@ -0,0 +1,97 @@
+package marquez.api;
+
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.mockito.ArgumentMatchers.anyInt;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.Mockito.doCallRealMethod;
+import static org.mockito.Mockito.spy;
+import static org.mockito.Mockito.when;
+
+import java.util.List;
+import javax.ws.rs.core.Response;
+import marquez.api.NamespaceResource.Namespaces;
+import marquez.api.filter.exclusions.ExclusionsFilter;
+import marquez.common.models.NamespaceName;
+import marquez.common.models.OwnerName;
+import marquez.db.BaseDao;
+import marquez.db.NamespaceDao;
+import marquez.jdbi.MarquezJdbiExternalPostgresExtension;
+import marquez.service.NamespaceService;
+import marquez.service.ServiceFactory;
+import marquez.service.models.Namespace;
+import marquez.service.models.NamespaceMeta;
+import org.jdbi.v3.core.Jdbi;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.mockito.Mock;
+import org.mockito.MockitoAnnotations;
+
+@ExtendWith(MarquezJdbiExternalPostgresExtension.class)
+public class NamespaceResourceTest {
+
+  @Mock private ServiceFactory serviceFactory;
+
+  @Mock private BaseDao baseDao;
+
+  private static NamespaceDao namespaceDao;
+  private NamespaceService namespaceService;
+  private NamespaceResource namespaceResource;
+
+  @BeforeEach
+  public void setUp(Jdbi jdbi) {
+    MockitoAnnotations.openMocks(this);
+
+    namespaceDao = jdbi.onDemand(NamespaceDao.class);
+    when(baseDao.createNamespaceDao()).thenReturn(namespaceDao);
+    namespaceService = new NamespaceService(baseDao);
+
+    when(serviceFactory.getNamespaceService()).thenReturn(namespaceService);
+    namespaceResource = new NamespaceResource(serviceFactory);
+  }
+
+  @Test
+  void testFindAllFilter() {
+    var namespaceName1 = NamespaceName.of("postgres://localhost:5432");
+    var namespaceMeta1 = new NamespaceMeta(new OwnerName("marquez"), null);
+    namespaceDao.upsertNamespaceMeta(namespaceName1, namespaceMeta1);
+
+    var namespaceName2 = NamespaceName.of("excluded_namespace");
+    var namespaceMeta2 = new NamespaceMeta(new OwnerName("yannick"), null);
+    namespaceDao.upsertNamespaceMeta(namespaceName2, namespaceMeta2);
+
+    List<Namespace> namespaces = namespaceDao.findAllFilter("excluded.*", 10, 0);
+
+    // Assert that the namespaces list does not contain the excluded namespace
+    assertFalse(
+        namespaces.stream().anyMatch(namespace -> namespace.getName().equals(namespaceName2)));
+  }
+
+  @Test
+  public void testListWithFilter() {
+    String filter = "excluded_.*";
+    ExclusionsFilter.setNamespacesReadFilter(filter);
+
+    NamespaceName namespaceName = NamespaceName.of("excluded_namespace");
+    OwnerName owner = new OwnerName("yannick");
+    NamespaceMeta namespaceMeta = new NamespaceMeta(owner, "description");
+
+    namespaceDao.upsertNamespaceMeta(namespaceName, namespaceMeta);
+
+    NamespaceService namespaceServiceSpy = spy(namespaceService);
+    doCallRealMethod().when(namespaceServiceSpy).findAllFilter(eq(filter), anyInt(), anyInt());
+
+    Response response = namespaceResource.list(10, 0);
+    Namespaces namespaces = (Namespaces) response.getEntity();
+
+    // Check if the returned namespaces contain a namespace with the name
+    // "excluded_namespace"
+    boolean containsExcludedNamespace =
+        namespaces.getValue().stream()
+            .anyMatch(namespace -> namespace.getName().getValue().equals("excluded_namespace"));
+
+    // Assert that the returned namespaces do not contain a namespace with the name
+    // "excluded_namespace"
+    assertFalse(containsExcludedNamespace);
+  }
+}

api/src/test/java/marquez/api/filter/exclusions/ExclusionsConfigTest.java

@@ -0,0 +1,46 @@
+package marquez.api.filter.exclusions;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+
+import marquez.api.filter.exclusions.ExclusionsConfig.NamespaceExclusion;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+class ExclusionsConfigTest {
+
+  private ExclusionsConfig exclusionsConfig;
+  private NamespaceExclusion namespaceExclusion;
+
+  @BeforeEach
+  void setUp() {
+    exclusionsConfig = new ExclusionsConfig();
+    namespaceExclusion = new NamespaceExclusion();
+  }
+
+  @Test
+  void testNamespaceExclusionOnRead() {
+    namespaceExclusion.onRead = true;
+    assertEquals(true, namespaceExclusion.isOnRead());
+  }
+
+  @Test
+  void testNamespaceExclusionOnWrite() {
+    namespaceExclusion.onWrite = true;
+    assertEquals(true, namespaceExclusion.isOnWrite());
+  }
+
+  @Test
+  void testNamespaceExclusionPatterns() {
+    String patterns = "test-pattern";
+    namespaceExclusion.patterns = patterns;
+    assertEquals(patterns, namespaceExclusion.getPatterns());
+  }
+
+  @Test
+  void testExclusionsConfigNamespaces() {
+    exclusionsConfig.namespaces = namespaceExclusion;
+    assertNotNull(exclusionsConfig.getNamespaces());
+    assertEquals(namespaceExclusion, exclusionsConfig.getNamespaces());
+  }
+}

api/src/test/java/marquez/api/filter/exclusions/ExclusionsFilterTest.java

@@ -0,0 +1,23 @@
+package marquez.api.filter.exclusions;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+public class ExclusionsFilterTest {
+
+  private static final String TEST_FILTER = "test-filter";
+
+  @BeforeEach
+  public void setUp() {
+    ExclusionsFilter.setNamespacesReadFilter(null);
+  }
+
+  @Test
+  public void testSetAndGetNamespacesReadFilter() {
+    ExclusionsFilter.setNamespacesReadFilter(TEST_FILTER);
+    String result = ExclusionsFilter.getNamespacesReadFilter();
+    assertEquals(TEST_FILTER, result);
+  }
+}