[GR-12240] Add an option --python.OpaqueFilesystem that always returns a TruffleObject from os.reads. These objects work for compilation (and thus imports), but nothing else.

timfel · timfel · commit 98555b9e6a88 · 2018-10-26T09:53:18.000+02:00
diff --git a/graalpython/com.oracle.graal.python/src/com/oracle/graal/python/builtins/modules/BuiltinFunctions.java b/graalpython/com.oracle.graal.python/src/com/oracle/graal/python/builtins/modules/BuiltinFunctions.java
@@ -82,6 +82,7 @@
 import com.oracle.graal.python.builtins.objects.PNone;
 import com.oracle.graal.python.builtins.objects.PNotImplemented;
 import com.oracle.graal.python.builtins.objects.bytes.BytesNodes;
+import com.oracle.graal.python.builtins.objects.bytes.OpaqueBytes;
 import com.oracle.graal.python.builtins.objects.bytes.PBytes;
 import com.oracle.graal.python.builtins.objects.bytes.PIBytesLike;
 import com.oracle.graal.python.builtins.objects.cell.PCell;
@@ -601,6 +602,12 @@ Object compile(PBytes source, String filename, String mode, Object kwFlags, Obje
             return compile(new String(toBytesNode.execute(source)), filename, mode, kwFlags, kwDontInherit, kwOptimize);
         }
 
+        @Specialization
+        @TruffleBoundary
+        Object compile(OpaqueBytes source, String filename, String mode, Object kwFlags, Object kwDontInherit, Object kwOptimize) {
+            return compile(new String(source.getBytes()), filename, mode, kwFlags, kwDontInherit, kwOptimize);
+        }
+
         @SuppressWarnings("unused")
         @Specialization
         @TruffleBoundary
diff --git a/graalpython/com.oracle.graal.python/src/com/oracle/graal/python/builtins/modules/PosixModuleBuiltins.java b/graalpython/com.oracle.graal.python/src/com/oracle/graal/python/builtins/modules/PosixModuleBuiltins.java
@@ -66,6 +66,7 @@
 import com.oracle.graal.python.builtins.modules.PosixModuleBuiltinsFactory.ConvertPathlikeObjectNodeGen;
 import com.oracle.graal.python.builtins.modules.PosixModuleBuiltinsFactory.StatNodeFactory;
 import com.oracle.graal.python.builtins.objects.PNone;
+import com.oracle.graal.python.builtins.objects.bytes.OpaqueBytes;
 import com.oracle.graal.python.builtins.objects.bytes.PByteArray;
 import com.oracle.graal.python.builtins.objects.bytes.PBytes;
 import com.oracle.graal.python.builtins.objects.bytes.PIBytesLike;
@@ -801,7 +802,21 @@ public static WriteNode create() {
     @GenerateNodeFactory
     @TypeSystemReference(PythonArithmeticTypes.class)
     public abstract static class ReadNode extends PythonFileNode {
-        @Specialization
+        @Specialization(guards = "readOpaque()")
+        @TruffleBoundary
+        Object readOpaque(int fd, @SuppressWarnings("unused") Object requestedSize) {
+            SeekableByteChannel channel = getFileChannel(fd);
+            try {
+                long size = channel.size() - channel.position();
+                ByteBuffer dst = ByteBuffer.allocate((int) size);
+                channel.read(dst);
+                return new OpaqueBytes(dst.array());
+            } catch (IOException e) {
+                throw raise(OSError, e.getMessage());
+            }
+        }
+
+        @Specialization(guards = "!readOpaque()")
         @TruffleBoundary
         Object read(int fd, long requestedSize) {
             SeekableByteChannel channel = getFileChannel(fd);
@@ -817,6 +832,10 @@ Object read(int fd, long requestedSize) {
                 throw raise(OSError, e.getMessage());
             }
         }
+
+        protected boolean readOpaque() {
+            return OpaqueBytes.isEnabled(getContext());
+        }
     }
 
     @Builtin(name = "isatty", fixedNumOfPositionalArgs = 1)
diff --git a/graalpython/com.oracle.graal.python/src/com/oracle/graal/python/builtins/objects/bytes/BytesBuiltins.java b/graalpython/com.oracle.graal.python/src/com/oracle/graal/python/builtins/objects/bytes/BytesBuiltins.java
@@ -56,6 +56,7 @@
 import com.oracle.graal.python.builtins.objects.common.SequenceStorageNodes;
 import com.oracle.graal.python.builtins.objects.common.SequenceStorageNodes.NormalizeIndexNode;
 import com.oracle.graal.python.builtins.objects.iterator.PSequenceIterator;
+import com.oracle.graal.python.builtins.objects.list.PList;
 import com.oracle.graal.python.nodes.PNodeWithContext;
 import com.oracle.graal.python.nodes.function.PythonBuiltinBaseNode;
 import com.oracle.graal.python.nodes.function.PythonBuiltinNode;
@@ -295,7 +296,30 @@ public Object repr(PBytes self,
     @Builtin(name = "join", fixedNumOfPositionalArgs = 2)
     @GenerateNodeFactory
     public abstract static class JoinNode extends PythonBinaryBuiltinNode {
-        @Specialization
+        protected boolean readOpaque() {
+            return OpaqueBytes.isEnabled(getContext());
+        }
+
+        @Specialization(guards = {"readOpaque()"})
+        public Object join(PBytes bytes, PList iterable,
+                        @Cached("create()") SequenceStorageNodes.GetItemNode getItemNode,
+                        @Cached("create()") SequenceStorageNodes.LenNode lenNode,
+                        @Cached("create()") SequenceStorageNodes.ToByteArrayNode toByteArrayNode,
+                        @Cached("create()") BytesNodes.BytesJoinNode bytesJoinNode) {
+            int len = lenNode.execute(iterable.getSequenceStorage());
+            if (len == 1) {
+                // branch profiles aren't really needed, because of the specialization
+                // happening in the getItemNode on first execution and the assumption
+                // in OpaqueBytes.isInstance
+                Object firstItem = getItemNode.execute(iterable.getSequenceStorage(), 0);
+                if (OpaqueBytes.isInstance(firstItem)) {
+                    return firstItem;
+                }
+            }
+            return join(bytes, iterable, toByteArrayNode, bytesJoinNode);
+        }
+
+        @Specialization(guards = {"!readOpaque()"})
         public PBytes join(PBytes bytes, Object iterable,
                         @Cached("create()") SequenceStorageNodes.ToByteArrayNode toByteArrayNode,
                         @Cached("create()") BytesNodes.BytesJoinNode bytesJoinNode) {
diff --git a/graalpython/com.oracle.graal.python/src/com/oracle/graal/python/builtins/objects/bytes/OpaqueBytes.java b/graalpython/com.oracle.graal.python/src/com/oracle/graal/python/builtins/objects/bytes/OpaqueBytes.java
@@ -0,0 +1,85 @@
+package com.oracle.graal.python.builtins.objects.bytes;
+
+import com.oracle.graal.python.runtime.PythonContext;
+import com.oracle.graal.python.runtime.PythonOptions;
+import com.oracle.truffle.api.Assumption;
+import com.oracle.truffle.api.CompilerDirectives;
+import com.oracle.truffle.api.Truffle;
+import com.oracle.truffle.api.interop.CanResolve;
+import com.oracle.truffle.api.interop.ForeignAccess;
+import com.oracle.truffle.api.interop.MessageResolution;
+import com.oracle.truffle.api.interop.Resolve;
+import com.oracle.truffle.api.interop.TruffleObject;
+import com.oracle.truffle.api.nodes.Node;
+
+public final class OpaqueBytes implements TruffleObject {
+    private static final Assumption neverOpaqueAssumption = Truffle.getRuntime().createAssumption("all contexts use a readable filesystem");
+    private static final Assumption alwaysOpaqueAssumption = Truffle.getRuntime().createAssumption("no context has a readable filesystem");
+    private final byte[] bytes;
+
+    public OpaqueBytes(byte[] bytes) {
+        assert !neverOpaqueAssumption.isValid();
+        this.bytes = bytes;
+    }
+
+    public ForeignAccess getForeignAccess() {
+        return OpaqueBytesMessageResolutionForeign.ACCESS;
+    }
+
+    public byte[] getBytes() {
+        return bytes;
+    }
+
+    public static boolean isInstance(Object next) {
+        if (neverOpaqueAssumption.isValid()) {
+            return false;
+        }
+        return next instanceof OpaqueBytes;
+    }
+
+    public static boolean isEnabled(PythonContext context) {
+        if (neverOpaqueAssumption.isValid()) {
+            return false;
+        } else if (alwaysOpaqueAssumption.isValid()) {
+            return true;
+        }
+        return checkOption(context);
+    }
+
+    private static Boolean checkOption(PythonContext context) {
+        return PythonOptions.getOption(context, PythonOptions.OpaqueFilesystem);
+    }
+
+    public static void initializeForNewContext(PythonContext context) {
+        CompilerDirectives.transferToInterpreter();
+        if (checkOption(context)) {
+            neverOpaqueAssumption.invalidate();
+        } else {
+            alwaysOpaqueAssumption.invalidate();
+        }
+    }
+
+    @MessageResolution(receiverType = OpaqueBytes.class)
+    static class OpaqueBytesMessageResolution {
+        @Resolve(message = "HAS_SIZE")
+        abstract static class HasSizeNode extends Node {
+            Object access(@SuppressWarnings("unused") OpaqueBytes object) {
+                return true;
+            }
+        }
+
+        @Resolve(message = "GET_SIZE")
+        abstract static class SizeNode extends Node {
+            Object access(OpaqueBytes object) {
+                return object.bytes.length;
+            }
+        }
+
+        @CanResolve
+        abstract static class CheckFunction extends Node {
+            protected static boolean test(TruffleObject receiver) {
+                return receiver instanceof OpaqueBytes;
+            }
+        }
+    }
+}
diff --git a/graalpython/com.oracle.graal.python/src/com/oracle/graal/python/runtime/PythonContext.java b/graalpython/com.oracle.graal.python/src/com/oracle/graal/python/runtime/PythonContext.java
@@ -39,6 +39,7 @@
 import org.graalvm.options.OptionValues;
 
 import com.oracle.graal.python.PythonLanguage;
+import com.oracle.graal.python.builtins.objects.bytes.OpaqueBytes;
 import com.oracle.graal.python.builtins.objects.common.HashingStorage;
 import com.oracle.graal.python.builtins.objects.dict.PDict;
 import com.oracle.graal.python.builtins.objects.module.PythonModule;
@@ -200,6 +201,7 @@ private void setupRuntimeInformation() {
         mainModule = core.factory().createPythonModule(__MAIN__);
         mainModule.setAttribute(__BUILTINS__, builtinsModule);
         sysModules.setItem(__MAIN__, mainModule);
+        OpaqueBytes.initializeForNewContext(this);
         currentException = null;
         isInitialized = true;
     }
diff --git a/graalpython/com.oracle.graal.python/src/com/oracle/graal/python/runtime/PythonOptions.java b/graalpython/com.oracle.graal.python/src/com/oracle/graal/python/runtime/PythonOptions.java
@@ -82,6 +82,10 @@ private PythonOptions() {
     @Option(category = OptionCategory.EXPERT, help = "This option is set by the Python launcher to tell the language it can print exceptions directly") //
     public static final OptionKey<Boolean> AlwaysRunExcepthook = new OptionKey<>(false);
 
+    @Option(category = OptionCategory.USER, help = "This option makes reading from files return opaque objects. Imports can work with such data, " +
+                    "but all other access to the contents of the file is disabled, so the files are kept secret.") //
+    public static final OptionKey<Boolean> OpaqueFilesystem = new OptionKey<>(false);
+
     @Option(category = OptionCategory.USER, help = "") //
     public static final OptionKey<Boolean> InspectFlag = new OptionKey<>(false);
 
