danmuzi commented on code in PR #15864:
URL: https://github.com/apache/lucene/pull/15864#discussion_r2976456870


##########
lucene/core/src/java/org/apache/lucene/internal/tests/TestSecrets.java:
##########
@@ -71,72 +51,114 @@ private TestSecrets() {}
 
   /** Return the accessor to internal secrets for an {@link IndexReader}. */
   public static IndexPackageAccess getIndexPackageAccess() {
-    ensureCaller();
+    ensureCallerForGetter();
+    if (indexWriterAccess == null) {
+      ensureInitialized(IndexWriter.class);
+    }
     return Objects.requireNonNull(indexPackageAccess);
   }
 
   /** Return the accessor to internal secrets for an {@link 
ConcurrentMergeScheduler}. */
   public static ConcurrentMergeSchedulerAccess 
getConcurrentMergeSchedulerAccess() {
-    ensureCaller();
+    ensureCallerForGetter();
+    if (cmsAccess == null) {
+      ensureInitialized(ConcurrentMergeScheduler.class);
+    }
     return Objects.requireNonNull(cmsAccess);
   }
 
   /** Return the accessor to internal secrets for an {@link SegmentReader}. */
   public static SegmentReaderAccess getSegmentReaderAccess() {
-    ensureCaller();
+    ensureCallerForGetter();
+    if (segmentReaderAccess == null) {
+      ensureInitialized(SegmentReader.class);
+    }
     return Objects.requireNonNull(segmentReaderAccess);
   }
 
   /** Return the accessor to internal secrets for an {@link IndexWriter}. */
   public static IndexWriterAccess getIndexWriterAccess() {
-    ensureCaller();
+    ensureCallerForGetter();
+    if (indexWriterAccess == null) {
+      ensureInitialized(IndexWriter.class);
+    }
     return Objects.requireNonNull(indexWriterAccess);
   }
 
   /** Return the accessor to internal secrets for an {@link FilterIndexInput}. 
*/
   public static FilterIndexInputAccess getFilterInputIndexAccess() {
-    ensureCaller();
+    ensureCallerForGetter();
+    if (filterIndexInputAccess == null) {
+      ensureInitialized(FilterIndexInput.class);
+    }
     return Objects.requireNonNull(filterIndexInputAccess);
   }
 
   /** For internal initialization only. */
   public static void setIndexWriterAccess(IndexWriterAccess indexWriterAccess) 
{
+    ensureCallerForSetter(IndexWriter.class);
     ensureNull(TestSecrets.indexWriterAccess);
     TestSecrets.indexWriterAccess = indexWriterAccess;
   }
 
   /** For internal initialization only. */
   public static void setIndexPackageAccess(IndexPackageAccess 
indexPackageAccess) {
+    ensureCallerForSetter(IndexWriter.class);
     ensureNull(TestSecrets.indexPackageAccess);
     TestSecrets.indexPackageAccess = indexPackageAccess;
   }
 
   /** For internal initialization only. */
   public static void 
setConcurrentMergeSchedulerAccess(ConcurrentMergeSchedulerAccess cmsAccess) {
+    ensureCallerForSetter(ConcurrentMergeScheduler.class);
     ensureNull(TestSecrets.cmsAccess);
     TestSecrets.cmsAccess = cmsAccess;
   }
 
   /** For internal initialization only. */
   public static void setSegmentReaderAccess(SegmentReaderAccess 
segmentReaderAccess) {
+    ensureCallerForSetter(SegmentReader.class);
     ensureNull(TestSecrets.segmentReaderAccess);
     TestSecrets.segmentReaderAccess = segmentReaderAccess;
   }
 
   /** For internal initialization only. */
   public static void setFilterInputIndexAccess(FilterIndexInputAccess 
filterIndexInputAccess) {
+    ensureCallerForSetter(FilterIndexInput.class);
     ensureNull(TestSecrets.filterIndexInputAccess);
     TestSecrets.filterIndexInputAccess = filterIndexInputAccess;
   }
 
+  private static void ensureInitialized(Class<?> clazz) {
+    try {
+      MethodHandles.lookup().ensureInitialized(clazz);
+    } catch (IllegalAccessException e) {
+      throw new RuntimeException(e);
+    }
+  }
+
   private static void ensureNull(Object ob) {
     if (ob != null) {
       throw new AssertionError(
           "The accessor is already set. It can only be called from inside 
Lucene Core.");
     }
   }
 
-  private static void ensureCaller() {
+  private static void ensureCallerForSetter(Class<?> allowedCaller) {
+    final boolean validCaller =
+        StackWalker.getInstance()
+            .walk(
+                s ->
+                    s.skip(2)
+                        .limit(1)
+                        .map(StackFrame::getClassName)
+                        .allMatch(c -> Objects.equals(c, 
allowedCaller.getName())));
+    if (!validCaller) {
+      throw new AssertionError("The accessor can only be set by " + 
allowedCaller.getName() + ".");

Review Comment:
   Done



-- 
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.

To unsubscribe, e-mail: [email protected]

For queries about this service, please contact Infrastructure at:
[email protected]


---------------------------------------------------------------------
To unsubscribe, e-mail: [email protected]
For additional commands, e-mail: [email protected]

Reply via email to