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 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 %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 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 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 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 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 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 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 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 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 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 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
def log(self, message, tags=[]):
log(["audit"] + tags, u"Auditor for %s: %s" % (self.fqn, message))
