def loadPrelude(config, recorder, vat): scope = safeScope() # For the prelude (and only the prelude), permit the boot scope. scope.update(bootScope(config.libraryPaths, recorder)) registerGlobals({u"Bool": scope[u"Bool"], u"Bytes": scope[u"Bytes"], u"Char": scope[u"Char"], u"Double": scope[u"Double"], u"Int": scope[u"Int"], u"Str": scope[u"Str"], u"Void": scope[u"Void"]}) module = obtainModule(config.libraryPaths, recorder, "prelude") with recorder.context("Time spent in prelude"): result = module.eval(scope)[0] assert result is not None, "Prelude returned None" assert isinstance(result, ConstMap), "Prelude returned non-Map" prelude = {} for key, value in unwrapMap(result).items(): s = unwrapStr(key) assert s.startswith(u"&&"), "Prelude key doesn't start with &&" prelude[s[2:]] = value log(["info", "prelude"], u"Loaded the prelude") return prelude
def stash(uv_t, obj): # uv_t = rffi.cast(struct, uv_t) index = theStash.put(obj) uv_t.c_data = rffi.cast(rffi.VOIDP, index) log(["uv"], u"Stash %s: Storing 0x%x to %d (0x%x)" % (name.decode("utf-8"), current_object_addr_as_int(obj), intmask(index), current_object_addr_as_int(uv_t)))
def stash(uv_t, obj): # uv_t = rffi.cast(struct, uv_t) index = theStash.put(obj) uv_t.c_data = rffi.cast(rffi.VOIDP, index) log(["uv"], u"Stash %s: Storing %s to %d (0x%x)" % (name.decode("utf-8"), formatTuple(obj), intmask(index), current_object_addr_as_int(uv_t)))
def check(message, rv): rv = intmask(rv) if rv < 0: uve = UVError(rv, message) log(["uv", "error"], u"libuv API error: %s" % uve.repr().decode("utf-8")) raise uve return rv
def unstash(uv_t): # uv_t = rffi.cast(struct, uv_t) index = rffi.cast(rffi.INT, uv_t.c_data) obj = theStash.get(index) log(["uv"], u"Stash %s: Getting %s from %d (0x%x)" % (name.decode("utf-8"), formatTuple(obj), intmask(index), current_object_addr_as_int(uv_t))) return obj
def cleanup(self): if not self.streams: return log(["uv"], u"Janitor closing %d streams" % len(self.streams)) for stream in self.streams: closeAndFree(stream) self.streams = []
def unstash(uv_t): # uv_t = rffi.cast(struct, uv_t) index = rffi.cast(rffi.INT, uv_t.c_data) obj = theStash.get(index) log(["uv"], u"Stash %s: Getting 0x%x from %d (0x%x)" % (name.decode("utf-8"), current_object_addr_as_int(obj), intmask(index), current_object_addr_as_int(uv_t))) return obj
def makeFileResource(path): """ Make a file Resource. """ path = unwrapStr(path) segments = [segment.encode("utf-8") for segment in path.split(u'/')] if not path.startswith(u'/'): # Relative path. segments = os.getcwd().split('/') + segments log.log(["fs"], u"makeFileResource.run/1: Relative path '%s'" % path) return FileResource(segments)
def packLocalRef(obj, objVat, originVat): assert objVat is not None, "Vat cannot be None" assert originVat is not None, "Vat cannot be None" if objVat is originVat: log(["ref"], u"Eliding ref from (and to) vat %s" % objVat.name) return obj elif (isinstance(obj, LocalVatRef) and obj.originVat is objVat and obj.targetVat is originVat): log(["ref"], u"Short-circuiting round-trip ref for vat %s" % objVat.name) return obj.target return LocalVatRef(obj, objVat, originVat)
def open(self, callback, flags=None, mode=None): # Always call this as .open(callback, flags=..., mode=...) assert flags is not None assert mode is not None p, r = makePromise() vat = currentVat.get() uv_loop = vat.uv_loop fs = ruv.alloc_fs() path = self.asBytes() log.log(["fs"], u"makeFileResource: Opening file '%s'" % path.decode("utf-8")) ruv.stashFS(fs, (vat, r)) ruv.fsOpen(uv_loop, fs, path, flags, mode, callback) return p
def recv(self, atom, args): if atom is ASBYTES_0: # XXX should figure this out log.log(["sodium"], u"asBytes/0: Revealing secret key") return BytesObject(self.secretKey) if atom is PAIRWITH_1: public = args[0] if not isinstance(public, PublicKey): raise WrongType(u"Not a public key!") return KeyPair(public.publicKey, self.secretKey) if atom is PUBLICKEY_0: publicKey = rsodium.regenerateKey(self.secretKey) return PublicKey(publicKey) raise Refused(self, atom, args)
def getContents(self): p, r = makePromise() vat = currentVat.get() buf = ruv.allocBuf(16384) path = self.asBytes() log.log(["fs"], u"makeFileResource: Opening file '%s'" % path.decode("utf-8")) with io: f = 0 try: f = ruv.magic_fsOpen(vat, path, os.O_RDONLY, 0000) except object as err: smash(r, StrObject(u"Couldn't open file fount: %s" % err)) else: try: contents = readLoop(f, buf) except object as err: ruv.magic_fsClose(vat, f) smash(r, StrObject(u"libuv error: %s" % err)) else: ruv.magic_fsClose(vat, f) resolve(r, BytesObject(contents)) return p
def obtainModule(libraryPaths, recorder, filePath): for libraryPath in libraryPaths: path = rjoin(libraryPath, filePath) if path in moduleCache.cache: log.log(["import"], u"Importing %s (cached)" % path.decode("utf-8")) return moduleCache.cache[path] log.log(["import"], u"Importing %s" % path.decode("utf-8")) code = tryExtensions(path, recorder) if code is None: continue # Cache. moduleCache.cache[path] = code return code else: log.log(["import", "error"], u"Failed to import from %s" % filePath.decode("utf-8")) debugPrint("Failed to import:", filePath) raise userError(u"Module '%s' couldn't be found" % filePath.decode("utf-8"))
def log(self, message, tags=[]): log(["audit"] + tags, u"Auditor for %s: %s" % (self.fqn, message))
def log(self, message, tags=[]): log.log(["vat"] + tags, u"Vat %s: %s" % (self.name, message))
def asBytes(self): # XXX should figure this out log.log(["sodium"], u"asBytes/0: Revealing secret key") return self.secretKey