This is an automated email from the ASF dual-hosted git repository.

github-actions[bot] pushed a commit to branch cherry-pick-f55399f4-to-branch-1.3
in repository https://gitbox.apache.org/repos/asf/gravitino.git

commit 18d050a1b3ef49694e84cb70fcb236ac3d2dd108
Author: MaSai <[email protected]>
AuthorDate: Wed Nov 4 10:07:01 2026 +0800

    [#14431,#14443] fix(core): Reject dotted names before store write (#14519)
    
    ### What changes were proposed in this pull request?
    
    Call `NameIdentifierUtil.checkMetadataObjectName` before writing to the
    entity store:
    
    - create: policy / tag / role / job template
    - rename: policy / tag / job template
    
    so a name containing `.` is rejected with
    `IllegalNameIdentifierException` and nothing is stored.
    
    ### Why are the changes needed?
    
    `.` is reserved as the qualified-name separator. Create (#14443) stored
    the object before the owner-path name check failed, and rename paths
    (#14431 for policy; the same gap for tag and job template) never checked
    the new name, so dotted names could brick load/delete/list under
    authorization.
    
    Fixes #14431
    Fixes #14443
    
    ### Does this PR introduce _any_ user-facing change?
    
    Yes. Create/rename with a dotted name for these object types returns 400
    before anything is stored (create no longer leaves a 409-able orphan).
    
    ### How was this patch tested?
    
    ```
    ./gradlew :core:test -PskipITs \
      --tests 
org.apache.gravitino.policy.TestPolicyManager.testCreateAndRenameRejectDottedName
 \
      --tests 
org.apache.gravitino.tag.TestTagManager.testCreateAndRenameRejectDottedName \
      --tests 
org.apache.gravitino.authorization.TestAccessControlManager.testCreateRole \
      --tests 
org.apache.gravitino.job.TestJobManager.testRegisterJobTemplateRejectsDottedName
 \
      --tests 
org.apache.gravitino.job.TestJobManager.testAlterJobTemplateRejectsDottedRename
    ```
    
    ---------
    
    Co-authored-by: Cursor <[email protected]>
---
 .../gravitino/server/web/rest/JobOperations.java   | 11 ++++++
 .../server/web/rest/PolicyOperations.java          | 11 +++++-
 .../gravitino/server/web/rest/RoleOperations.java  |  2 ++
 .../gravitino/server/web/rest/TagOperations.java   | 10 +++++-
 .../server/web/rest/TestJobOperations.java         | 39 ++++++++++++++++++++
 .../server/web/rest/TestPolicyOperations.java      | 41 ++++++++++++++++++++++
 .../server/web/rest/TestRoleOperations.java        | 27 ++++++++++++++
 .../server/web/rest/TestTagOperations.java         | 37 +++++++++++++++++++
 8 files changed, 176 insertions(+), 2 deletions(-)

diff --git 
a/server/src/main/java/org/apache/gravitino/server/web/rest/JobOperations.java 
b/server/src/main/java/org/apache/gravitino/server/web/rest/JobOperations.java
index 6545a3c558..2dab65236e 100644
--- 
a/server/src/main/java/org/apache/gravitino/server/web/rest/JobOperations.java
+++ 
b/server/src/main/java/org/apache/gravitino/server/web/rest/JobOperations.java
@@ -169,6 +169,9 @@ public class JobOperations {
           httpRequest,
           () -> {
             request.validate();
+            NameIdentifierUtil.checkMetadataObjectName(
+                NameIdentifierUtil.ofJobTemplate(metalake, 
request.getJobTemplate().name()),
+                Entity.EntityType.JOB_TEMPLATE);
 
             jobOperationDispatcher.registerJobTemplate(
                 metalake, toEntity(metalake, request.getJobTemplate()));
@@ -279,6 +282,14 @@ public class JobOperations {
                 request.getUpdates().stream()
                     .map(JobTemplateUpdateRequest::jobTemplateChange)
                     .toArray(JobTemplateChange[]::new);
+            for (JobTemplateChange change : changes) {
+              if (change instanceof JobTemplateChange.RenameJobTemplate) {
+                NameIdentifierUtil.checkMetadataObjectName(
+                    NameIdentifierUtil.ofJobTemplate(
+                        metalake, ((JobTemplateChange.RenameJobTemplate) 
change).getNewName()),
+                    Entity.EntityType.JOB_TEMPLATE);
+              }
+            }
 
             JobTemplateEntity updatedEntity =
                 jobOperationDispatcher.alterJobTemplate(metalake, 
jobTemplateName, changes);
diff --git 
a/server/src/main/java/org/apache/gravitino/server/web/rest/PolicyOperations.java
 
b/server/src/main/java/org/apache/gravitino/server/web/rest/PolicyOperations.java
index 1816356524..c1ad6c2766 100644
--- 
a/server/src/main/java/org/apache/gravitino/server/web/rest/PolicyOperations.java
+++ 
b/server/src/main/java/org/apache/gravitino/server/web/rest/PolicyOperations.java
@@ -158,6 +158,8 @@ public class PolicyOperations {
           httpRequest,
           () -> {
             request.validate();
+            NameIdentifierUtil.checkMetadataObjectName(
+                NameIdentifierUtil.ofPolicy(metalake, request.getName()), 
Entity.EntityType.POLICY);
             validateCreatePolicyType(request.getPolicyType());
             PolicyEntity policy =
                 policyDispatcher.createPolicy(
@@ -227,11 +229,18 @@ public class PolicyOperations {
           httpRequest,
           () -> {
             request.validate();
-
             PolicyChange[] changes =
                 request.getUpdates().stream()
                     .map(PolicyUpdateRequest::policyChange)
                     .toArray(PolicyChange[]::new);
+            for (PolicyChange change : changes) {
+              if (change instanceof PolicyChange.RenamePolicy) {
+                NameIdentifierUtil.checkMetadataObjectName(
+                    NameIdentifierUtil.ofPolicy(
+                        metalake, ((PolicyChange.RenamePolicy) 
change).getNewName()),
+                    Entity.EntityType.POLICY);
+              }
+            }
             PolicyEntity policy = policyDispatcher.alterPolicy(metalake, name, 
changes);
 
             LOG.info("Altered policy: {} under metalake: {}", name, metalake);
diff --git 
a/server/src/main/java/org/apache/gravitino/server/web/rest/RoleOperations.java 
b/server/src/main/java/org/apache/gravitino/server/web/rest/RoleOperations.java
index 37a81ba8b9..4b93754db7 100644
--- 
a/server/src/main/java/org/apache/gravitino/server/web/rest/RoleOperations.java
+++ 
b/server/src/main/java/org/apache/gravitino/server/web/rest/RoleOperations.java
@@ -156,6 +156,8 @@ public class RoleOperations {
           httpRequest,
           () -> {
             request.validate();
+            NameIdentifierUtil.checkMetadataObjectName(
+                NameIdentifierUtil.ofRole(metalake, request.getName()), 
Entity.EntityType.ROLE);
             MetalakeManager.checkMetalakeInUse(metalake);
             Set<MetadataObject> metadataObjects = Sets.newHashSet();
             for (SecurableObjectDTO object : request.getSecurableObjects()) {
diff --git 
a/server/src/main/java/org/apache/gravitino/server/web/rest/TagOperations.java 
b/server/src/main/java/org/apache/gravitino/server/web/rest/TagOperations.java
index dba148fd80..334627b5ca 100644
--- 
a/server/src/main/java/org/apache/gravitino/server/web/rest/TagOperations.java
+++ 
b/server/src/main/java/org/apache/gravitino/server/web/rest/TagOperations.java
@@ -165,6 +165,8 @@ public class TagOperations {
           httpRequest,
           () -> {
             request.validate();
+            NameIdentifierUtil.checkMetadataObjectName(
+                NameIdentifierUtil.ofTag(metalake, request.getName()), 
Entity.EntityType.TAG);
             Tag tag =
                 tagDispatcher.createTag(
                     metalake, request.getName(), request.getComment(), 
request.getProperties());
@@ -229,11 +231,17 @@ public class TagOperations {
           httpRequest,
           () -> {
             request.validate();
-
             TagChange[] changes =
                 request.getUpdates().stream()
                     .map(TagUpdateRequest::tagChange)
                     .toArray(TagChange[]::new);
+            for (TagChange change : changes) {
+              if (change instanceof TagChange.RenameTag) {
+                NameIdentifierUtil.checkMetadataObjectName(
+                    NameIdentifierUtil.ofTag(metalake, ((TagChange.RenameTag) 
change).getNewName()),
+                    Entity.EntityType.TAG);
+              }
+            }
             Tag tag = tagDispatcher.alterTag(metalake, name, changes);
 
             LOG.info("Altered tag: {} under metalake: {}", name, metalake);
diff --git 
a/server/src/test/java/org/apache/gravitino/server/web/rest/TestJobOperations.java
 
b/server/src/test/java/org/apache/gravitino/server/web/rest/TestJobOperations.java
index 49790d5655..04e1938490 100644
--- 
a/server/src/test/java/org/apache/gravitino/server/web/rest/TestJobOperations.java
+++ 
b/server/src/test/java/org/apache/gravitino/server/web/rest/TestJobOperations.java
@@ -345,6 +345,25 @@ public class TestJobOperations extends JerseyTest {
     Assertions.assertEquals(RuntimeException.class.getSimpleName(), 
errorResp4.getType());
   }
 
+  @Test
+  public void testRegisterJobTemplateRejectsDottedName() {
+    JobTemplateEntity template = newShellJobTemplateEntity("a.b", "dotted 
name");
+    JobTemplateRegisterRequest request =
+        new JobTemplateRegisterRequest(JobOperations.toDTO(template));
+
+    try (Response response =
+        target(jobTemplatePath())
+            .request(APPLICATION_JSON_TYPE)
+            .accept("application/vnd.gravitino.v1+json")
+            .post(Entity.json(request))) {
+      Assertions.assertEquals(Response.Status.BAD_REQUEST.getStatusCode(), 
response.getStatus());
+      ErrorResponse error = response.readEntity(ErrorResponse.class);
+      Assertions.assertEquals(ErrorConstants.ILLEGAL_ARGUMENTS_CODE, 
error.getCode());
+      Assertions.assertTrue(error.getMessage().contains("a.b"));
+    }
+    verify(jobOperationDispatcher, never()).registerJobTemplate(any(), any());
+  }
+
   @Test
   public void testGetJobTemplate() {
     JobTemplateEntity template =
@@ -685,6 +704,26 @@ public class TestJobOperations extends JerseyTest {
     Assertions.assertEquals(RuntimeException.class.getSimpleName(), 
errorResp5.getType());
   }
 
+  @Test
+  public void testRenameJobTemplateRejectsDottedName() {
+    JobTemplateUpdatesRequest request =
+        new JobTemplateUpdatesRequest(
+            Lists.newArrayList(new 
JobTemplateUpdateRequest.RenameJobTemplateRequest("a.b")));
+
+    try (Response response =
+        target(jobTemplatePath())
+            .path("shell_template_1")
+            .request(APPLICATION_JSON_TYPE)
+            .accept("application/vnd.gravitino.v1+json")
+            .put(Entity.entity(request, APPLICATION_JSON_TYPE))) {
+      Assertions.assertEquals(Response.Status.BAD_REQUEST.getStatusCode(), 
response.getStatus());
+      ErrorResponse error = response.readEntity(ErrorResponse.class);
+      Assertions.assertEquals(ErrorConstants.ILLEGAL_ARGUMENTS_CODE, 
error.getCode());
+      Assertions.assertTrue(error.getMessage().contains("a.b"));
+    }
+    verify(jobOperationDispatcher, never()).alterJobTemplate(any(), any(), 
any());
+  }
+
   @Test
   public void testListJobs() {
     String templateName = "shell_template_1";
diff --git 
a/server/src/test/java/org/apache/gravitino/server/web/rest/TestPolicyOperations.java
 
b/server/src/test/java/org/apache/gravitino/server/web/rest/TestPolicyOperations.java
index 72d25bf287..91232fc7a9 100644
--- 
a/server/src/test/java/org/apache/gravitino/server/web/rest/TestPolicyOperations.java
+++ 
b/server/src/test/java/org/apache/gravitino/server/web/rest/TestPolicyOperations.java
@@ -446,6 +446,47 @@ public class TestPolicyOperations extends 
BaseOperationsTest {
     Assertions.assertEquals(Response.Status.BAD_REQUEST.getStatusCode(), 
resp.getStatus());
   }
 
+  @Test
+  public void testCreatePolicyRejectsDottedName() {
+    PolicyContent content =
+        PolicyContents.custom(
+            ImmutableMap.of("k", "v"), 
ImmutableSet.of(MetadataObject.Type.TABLE), null);
+    PolicyCreateRequest request =
+        new PolicyCreateRequest("a.b", "custom", null, false, toDTO(content));
+
+    try (Response response =
+        target(policyPath(metalake))
+            .request(MediaType.APPLICATION_JSON_TYPE)
+            .accept("application/vnd.gravitino.v1+json")
+            .post(Entity.entity(request, MediaType.APPLICATION_JSON_TYPE))) {
+      Assertions.assertEquals(Response.Status.BAD_REQUEST.getStatusCode(), 
response.getStatus());
+      ErrorResponse error = response.readEntity(ErrorResponse.class);
+      Assertions.assertEquals(ErrorConstants.ILLEGAL_ARGUMENTS_CODE, 
error.getCode());
+      Assertions.assertTrue(error.getMessage().contains("a.b"));
+    }
+    Mockito.verify(policyManager, Mockito.never())
+        .createPolicy(any(), any(), any(), any(), anyBoolean(), any());
+  }
+
+  @Test
+  public void testRenamePolicyRejectsDottedName() {
+    PolicyUpdatesRequest request =
+        new PolicyUpdatesRequest(
+            Collections.singletonList(new 
PolicyUpdateRequest.RenamePolicyRequest("a.b")));
+
+    try (Response response =
+        target(policyPath(metalake) + "/policy1")
+            .request(MediaType.APPLICATION_JSON_TYPE)
+            .accept("application/vnd.gravitino.v1+json")
+            .put(Entity.entity(request, MediaType.APPLICATION_JSON_TYPE))) {
+      Assertions.assertEquals(Response.Status.BAD_REQUEST.getStatusCode(), 
response.getStatus());
+      ErrorResponse error = response.readEntity(ErrorResponse.class);
+      Assertions.assertEquals(ErrorConstants.ILLEGAL_ARGUMENTS_CODE, 
error.getCode());
+      Assertions.assertTrue(error.getMessage().contains("a.b"));
+    }
+    Mockito.verify(policyManager, Mockito.never()).alterPolicy(any(), any(), 
any());
+  }
+
   @Test
   public void testGetPolicy() {
     ImmutableMap<String, Object> contentFields = 
ImmutableMap.of("target_file_size_bytes", 1000);
diff --git 
a/server/src/test/java/org/apache/gravitino/server/web/rest/TestRoleOperations.java
 
b/server/src/test/java/org/apache/gravitino/server/web/rest/TestRoleOperations.java
index 23cba9d104..16409e6c45 100644
--- 
a/server/src/test/java/org/apache/gravitino/server/web/rest/TestRoleOperations.java
+++ 
b/server/src/test/java/org/apache/gravitino/server/web/rest/TestRoleOperations.java
@@ -22,9 +22,12 @@ import static 
org.apache.gravitino.Configs.TREE_LOCK_CLEAN_INTERVAL;
 import static org.apache.gravitino.Configs.TREE_LOCK_MAX_NODE_IN_MEMORY;
 import static org.apache.gravitino.Configs.TREE_LOCK_MIN_NODE_IN_MEMORY;
 import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.Mockito.clearInvocations;
 import static org.mockito.Mockito.doThrow;
 import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.never;
 import static org.mockito.Mockito.reset;
+import static org.mockito.Mockito.verify;
 import static org.mockito.Mockito.when;
 
 import com.google.common.collect.Lists;
@@ -166,6 +169,30 @@ public class TestRoleOperations extends BaseOperationsTest 
{
     assertNullRequestBodyRejected(resp);
   }
 
+  @Test
+  public void testCreateRoleRejectsDottedName() {
+    clearInvocations(manager);
+    SecurableObject securableObject =
+        SecurableObjects.ofCatalog("catalog", 
Lists.newArrayList(Privileges.UseCatalog.allow()));
+    RoleCreateRequest request =
+        new RoleCreateRequest(
+            "a.b",
+            Collections.emptyMap(),
+            new SecurableObjectDTO[] {DTOConverters.toDTO(securableObject)});
+
+    try (Response response =
+        target("/metalakes/metalake1/roles")
+            .request(MediaType.APPLICATION_JSON_TYPE)
+            .accept("application/vnd.gravitino.v1+json")
+            .post(Entity.entity(request, MediaType.APPLICATION_JSON_TYPE))) {
+      Assertions.assertEquals(Response.Status.BAD_REQUEST.getStatusCode(), 
response.getStatus());
+      ErrorResponse error = response.readEntity(ErrorResponse.class);
+      Assertions.assertEquals(ErrorConstants.ILLEGAL_ARGUMENTS_CODE, 
error.getCode());
+      Assertions.assertTrue(error.getMessage().contains("a.b"));
+    }
+    verify(manager, never()).createRole(any(), any(), any(), any());
+  }
+
   @Test
   public void testCreateRole() throws IllegalAccessException, 
NoSuchFieldException, IOException {
     SecurableObject securableObject =
diff --git 
a/server/src/test/java/org/apache/gravitino/server/web/rest/TestTagOperations.java
 
b/server/src/test/java/org/apache/gravitino/server/web/rest/TestTagOperations.java
index ae15334359..53c54e72b3 100644
--- 
a/server/src/test/java/org/apache/gravitino/server/web/rest/TestTagOperations.java
+++ 
b/server/src/test/java/org/apache/gravitino/server/web/rest/TestTagOperations.java
@@ -282,6 +282,23 @@ public class TestTagOperations extends BaseOperationsTest {
     assertNullRequestBodyRejected(resp);
   }
 
+  @Test
+  public void testCreateTagRejectsDottedName() {
+    TagCreateRequest request = new TagCreateRequest("a.b", "comment", null);
+
+    try (Response response =
+        target(tagPath(metalake))
+            .request(MediaType.APPLICATION_JSON_TYPE)
+            .accept("application/vnd.gravitino.v1+json")
+            .post(Entity.entity(request, MediaType.APPLICATION_JSON_TYPE))) {
+      Assertions.assertEquals(Response.Status.BAD_REQUEST.getStatusCode(), 
response.getStatus());
+      ErrorResponse error = response.readEntity(ErrorResponse.class);
+      Assertions.assertEquals(ErrorConstants.ILLEGAL_ARGUMENTS_CODE, 
error.getCode());
+      Assertions.assertTrue(error.getMessage().contains("a.b"));
+    }
+    Mockito.verify(tagManager, Mockito.never()).createTag(any(), any(), any(), 
any(), any());
+  }
+
   @Test
   public void testCreateTag() {
     TagEntity tag1 =
@@ -421,6 +438,26 @@ public class TestTagOperations extends BaseOperationsTest {
     assertNullRequestBodyRejected(resp);
   }
 
+  @Test
+  public void testRenameTagRejectsDottedName() {
+    TagUpdatesRequest request =
+        new TagUpdatesRequest(
+            Collections.singletonList(new 
TagUpdateRequest.RenameTagRequest("a.b")));
+
+    try (Response response =
+        target(tagPath(metalake))
+            .path("tag1")
+            .request(MediaType.APPLICATION_JSON_TYPE)
+            .accept("application/vnd.gravitino.v1+json")
+            .put(Entity.entity(request, MediaType.APPLICATION_JSON_TYPE))) {
+      Assertions.assertEquals(Response.Status.BAD_REQUEST.getStatusCode(), 
response.getStatus());
+      ErrorResponse error = response.readEntity(ErrorResponse.class);
+      Assertions.assertEquals(ErrorConstants.ILLEGAL_ARGUMENTS_CODE, 
error.getCode());
+      Assertions.assertTrue(error.getMessage().contains("a.b"));
+    }
+    Mockito.verify(tagManager, Mockito.never()).alterTag(any(), any(), any());
+  }
+
   @Test
   public void testAlterTag() {
     TagEntity newTag =

Reply via email to