allow app-id as context for secret decryption

tidbyt · Nov 3, 2023 · a18977c · a18977c
1 parent f03e6bf
commit a18977c
Show file tree

Hide file tree

Showing 38 changed files with 124 additions and 82 deletions.
diff --git a/cmd/community/loadapp.go b/cmd/community/loadapp.go
@@ -43,7 +43,7 @@ func LoadApp(cmd *cobra.Command, args []string) error {
 	})
 
 	applet := runtime.Applet{}
-	err = applet.LoadWithInitializers(script, src, nil, initializers...)
+	err = applet.LoadWithInitializers("", script, src, nil, initializers...)
 	if err != nil {
 		return fmt.Errorf("failed to load applet: %w", err)
 	}

diff --git a/cmd/community/validateicons.go b/cmd/community/validateicons.go
@@ -47,7 +47,7 @@ func ValidateIcons(cmd *cobra.Command, args []string) error {
 	})
 
 	applet := runtime.Applet{}
-	err = applet.LoadWithInitializers(args[0], src, nil, initializers...)
+	err = applet.LoadWithInitializers("", args[0], src, nil, initializers...)
 	if err != nil {
 		return fmt.Errorf("failed to load applet: %w", err)
 	}

diff --git a/cmd/profile.go b/cmd/profile.go
@@ -114,7 +114,7 @@ func ProfileApp(script string, config map[string]string) (*pprof_profile.Profile
 	})
 
 	applet := runtime.Applet{}
-	err = applet.LoadWithInitializers(script, src, nil, initializers...)
+	err = applet.LoadWithInitializers("", script, src, nil, initializers...)
 	if err != nil {
 		return nil, fmt.Errorf("failed to load applet: %w", err)
 	}

diff --git a/cmd/render.go b/cmd/render.go
@@ -139,7 +139,7 @@ func render(cmd *cobra.Command, args []string) error {
 	runtime.InitCache(cache)
 
 	applet := runtime.Applet{}
-	err = applet.LoadWithInitializers(script, src, nil, initializers...)
+	err = applet.LoadWithInitializers("", script, src, nil, initializers...)
 	if err != nil {
 		return fmt.Errorf("failed to load applet: %w", err)
 	}

diff --git a/docs/gen_widget_imgs.go b/docs/gen_widget_imgs.go
@@ -68,7 +68,7 @@ def main():
 `, snippet)
 
 		app := runtime.Applet{}
-		err = app.Load(name, []byte(src), nil)
+		err = app.Load(fmt.Sprintf("id-%s", name), name, []byte(src), nil)
 		if err != nil {
 			panic(err)
 		}

diff --git a/encode/encode_bench_test.go b/encode/encode_bench_test.go
@@ -72,7 +72,7 @@ def main(config):
 
 func BenchmarkRunAndRender(b *testing.B) {
 	app := &runtime.Applet{}
-	err := app.Load("benchmark.star", []byte(BenchmarkDotStar), nil)
+	err := app.Load("benchid", "benchmark.star", []byte(BenchmarkDotStar), nil)
 	if err != nil {
 		b.Error(err)
 	}

diff --git a/encode/encode_test.go b/encode/encode_test.go
@@ -145,7 +145,7 @@ def main():
 
 func TestFile(t *testing.T) {
 	app := runtime.Applet{}
-	err := app.Load("test.star", []byte(TestDotStar), nil)
+	err := app.Load("testid", "test.star", []byte(TestDotStar), nil)
 	assert.NoError(t, err)
 
 	roots, err := app.Run(map[string]string{})
@@ -158,7 +158,7 @@ func TestFile(t *testing.T) {
 
 func TestHash(t *testing.T) {
 	app := runtime.Applet{}
-	err := app.Load("test.star", []byte(TestDotStar), nil)
+	err := app.Load("testid", "test.star", []byte(TestDotStar), nil)
 	require.NoError(t, err)
 
 	roots, err := app.Run(map[string]string{})
@@ -179,7 +179,7 @@ func TestHash(t *testing.T) {
 	// change the app slightly
 	modifiedSource := strings.Replace(TestDotStar, "foo bar", "bar foo", 1)
 	app2 := runtime.Applet{}
-	err = app2.Load("test.star", []byte(modifiedSource), nil)
+	err = app2.Load("testid2", "test.star", []byte(modifiedSource), nil)
 	require.NoError(t, err)
 
 	roots2, err := app2.Run(map[string]string{})
@@ -238,7 +238,7 @@ def main():
     return render.Root(show_full_animation=True, child=render.Box())
 `
 	app := runtime.Applet{}
-	require.NoError(t, app.Load("test.star", []byte(requestFull), nil))
+	require.NoError(t, app.Load("testid", "test.star", []byte(requestFull), nil))
 	roots, err := app.Run(map[string]string{})
 	assert.NoError(t, err)
 	assert.True(t, ScreensFromRoots(roots).ShowFullAnimation)
@@ -249,7 +249,7 @@ def main():
     return render.Root(child=render.Box())
 `
 	app = runtime.Applet{}
-	require.NoError(t, app.Load("test.star", []byte(dontRequestFull), nil))
+	require.NoError(t, app.Load("testid", "test.star", []byte(dontRequestFull), nil))
 	roots, err = app.Run(map[string]string{})
 	assert.NoError(t, err)
 	assert.False(t, ScreensFromRoots(roots).ShowFullAnimation)
@@ -276,7 +276,7 @@ def main():
 `)
 
 	app := runtime.Applet{}
-	err := app.Load("test.star", src, nil)
+	err := app.Load("testid", "test.star", src, nil)
 	assert.NoError(t, err)
 
 	roots, err := app.Run(map[string]string{})

diff --git a/runtime/applet.go b/runtime/applet.go
@@ -53,7 +53,8 @@ func init() {
 
 type Applet struct {
 	Filename            string
-	Id                  string
+	ThreadID            string
+	AppID               string
 	Globals             starlark.StringDict
 	SecretDecryptionKey *SecretDecryptionKey
 
@@ -69,7 +70,7 @@ type Applet struct {
 
 func (a *Applet) thread(initializers ...ThreadInitializer) *starlark.Thread {
 	t := &starlark.Thread{
-		Name: a.Id,
+		Name: a.ThreadID,
 		Load: a.loadModule,
 		Print: func(thread *starlark.Thread, msg string) {
 			fmt.Printf("[%s] %s\n", a.Filename, msg)
@@ -92,23 +93,24 @@ func (a *Applet) thread(initializers ...ThreadInitializer) *starlark.Thread {
 // Loads an applet. The script filename is used as a descriptor only,
 // and the actual code should be passed in src. Optionally also pass
 // loader to make additional starlark modules available to the script.
-func (a *Applet) Load(filename string, src []byte, loader ModuleLoader) (err error) {
-	return a.LoadWithInitializers(filename, src, loader)
+func (a *Applet) Load(appID string, filename string, src []byte, loader ModuleLoader) (err error) {
+	return a.LoadWithInitializers(appID, filename, src, loader)
 }
 
-func (a *Applet) LoadWithInitializers(filename string, src []byte, loader ModuleLoader, initializers ...ThreadInitializer) (err error) {
+func (a *Applet) LoadWithInitializers(appID string, filename string, src []byte, loader ModuleLoader, initializers ...ThreadInitializer) (err error) {
 	defer func() {
 		if r := recover(); r != nil {
 			err = fmt.Errorf("panic while executing %s: %v", a.Filename, r)
 		}
 	}()
 
+	a.AppID = appID
 	a.Filename = filename
 	a.loader = loader
 
 	a.src = src
 
-	a.Id = fmt.Sprintf("%s/%x", filename, md5.Sum(src))
+	a.ThreadID = fmt.Sprintf("%s/%x", filename, md5.Sum(src))
 
 	if a.SecretDecryptionKey != nil {
 		a.decrypter, err = a.SecretDecryptionKey.decrypterForApp(a)

diff --git a/runtime/applet_test.go b/runtime/applet_test.go
@@ -14,14 +14,14 @@ import (
 
 func TestLoadEmptySrc(t *testing.T) {
 	app := &Applet{}
-	err := app.Load("test.star", []byte{}, nil)
+	err := app.Load("testid", "test.star", []byte{}, nil)
 	assert.Error(t, err)
 }
 
 func TestLoadMalformed(t *testing.T) {
 	src := "this is not valid starlark"
 	app := &Applet{}
-	err := app.Load("test.star", []byte(src), nil)
+	err := app.Load("testid", "test.star", []byte(src), nil)
 	assert.Error(t, err)
 }
 
@@ -33,7 +33,7 @@ def main():
     return render.Root(child=render.Box())
 `
 	app := &Applet{}
-	err := app.Load("test.star", []byte(src), nil)
+	err := app.Load("testid", "test.star", []byte(src), nil)
 	assert.NoError(t, err)
 
 	// As is this
@@ -45,7 +45,7 @@ def main2():
 main = main2
 `
 	app = &Applet{}
-	err = app.Load("test.star", []byte(src), nil)
+	err = app.Load("testid", "test.star", []byte(src), nil)
 	assert.NoError(t, err)
 
 	// And this (a lambda is a function)
@@ -57,7 +57,7 @@ def main2():
 main = lambda: main2()
 `
 	app = &Applet{}
-	err = app.Load("test.star", []byte(src), nil)
+	err = app.Load("testid", "test.star", []byte(src), nil)
 	assert.NoError(t, err)
 
 	// But not this, because a string is not a function
@@ -69,7 +69,7 @@ def main2():
 main = "main2"
 `
 	app = &Applet{}
-	err = app.Load("test.star", []byte(src), nil)
+	err = app.Load("testid", "test.star", []byte(src), nil)
 	assert.Error(t, err)
 
 	// And not this either, because here main is gone
@@ -79,7 +79,7 @@ def main2():
     return render.Root(child=render.Box())
 `
 	app = &Applet{}
-	err = app.Load("test.star", []byte(src), nil)
+	err = app.Load("testid", "test.star", []byte(src), nil)
 	assert.Error(t, err)
 
 }
@@ -92,7 +92,7 @@ def main():
     return [render.Box()]
 `
 	app := &Applet{}
-	err := app.Load("test.star", []byte(src), nil)
+	err := app.Load("testid", "test.star", []byte(src), nil)
 	assert.NoError(t, err)
 	screens, err := app.Run(map[string]string{})
 	assert.Error(t, err)
@@ -106,7 +106,7 @@ def main():
 `
 
 	app = &Applet{}
-	err = app.Load("test.star", []byte(src), nil)
+	err = app.Load("testid", "test.star", []byte(src), nil)
 	assert.NoError(t, err)
 	screens, err = app.Run(map[string]string{})
 	assert.NoError(t, err)
@@ -119,7 +119,7 @@ def main():
     return [render.Root(child=render.Box()), render.Root(child=render.Text("hi"))]
 `
 	app = &Applet{}
-	err = app.Load("test.star", []byte(src), nil)
+	err = app.Load("testid", "test.star", []byte(src), nil)
 	assert.NoError(t, err)
 	screens, err = app.Run(map[string]string{})
 	assert.NoError(t, err)
@@ -141,7 +141,7 @@ def main():
     return render.Root(child=render.Box())
 `
 	app := &Applet{}
-	err := app.Load("test.star", []byte(src), nil)
+	err := app.Load("testid", "test.star", []byte(src), nil)
 	assert.NoError(t, err)
 	roots, err := app.Run(config)
 	assert.NoError(t, err)
@@ -170,7 +170,7 @@ def main(config):
 	return [render.Root(child=render.Box()) for _ in range(int(config["one"]) + int(config["two"]))]
 `
 	app = &Applet{}
-	err = app.Load("test.star", []byte(src), nil)
+	err = app.Load("testid", "test.star", []byte(src), nil)
 	require.NoError(t, err)
 	roots, err = app.Run(config)
 	require.NoError(t, err)
@@ -208,7 +208,7 @@ def main():
     return render.Root(child=render.Box())
 `
 	app := &Applet{}
-	err := app.Load("test.star", []byte(src), nil)
+	err := app.Load("testid", "test.star", []byte(src), nil)
 	assert.NoError(t, err)
 	roots, err := app.Run(map[string]string{})
 	assert.NoError(t, err)
@@ -230,7 +230,7 @@ def main():
     return render.Root(child=render.Box())
 `
 	app = &Applet{}
-	err = app.Load("test.star", []byte(src), loader)
+	err = app.Load("testid", "test.star", []byte(src), loader)
 	assert.NoError(t, err)
 	roots, err = app.Run(map[string]string{})
 	assert.NoError(t, err)
@@ -255,7 +255,7 @@ def main():
 	}
 
 	app := &Applet{}
-	err := app.Load("test.star", []byte(src), nil)
+	err := app.Load("testid", "test.star", []byte(src), nil)
 	assert.NoError(t, err)
 	_, err = app.Run(map[string]string{}, initializer)
 	assert.NoError(t, err)
@@ -275,7 +275,7 @@ def main():
 `
 
 	app := &Applet{}
-	err := app.Load("test.star", []byte(src), nil)
+	err := app.Load("testid", "test.star", []byte(src), nil)
 	assert.NoError(t, err)
 	_, err = app.Run(map[string]string{})
 	assert.NoError(t, err)
@@ -323,7 +323,7 @@ def main(config):
 `
 
 	app := &Applet{}
-	err = app.Load("test.star", []byte(src), nil)
+	err = app.Load("testid", "test.star", []byte(src), nil)
 	_, err = app.Run(map[string]string{"ZIP_BYTES": buf.String()}, initializer)
 	assert.NoError(t, err)
 

diff --git a/runtime/cache_test.go b/runtime/cache_test.go
@@ -33,7 +33,7 @@ def main():
 `
 	InitCache(NewInMemoryCache())
 	app := &Applet{}
-	err := app.Load("test.star", []byte(src), nil)
+	err := app.Load("testid", "test.star", []byte(src), nil)
 	assert.NoError(t, err)
 	roots, err := app.Run(map[string]string{})
 	assert.NoError(t, err)
@@ -54,7 +54,7 @@ def main():
 `
 	InitCache(NewInMemoryCache())
 	app := &Applet{}
-	err := app.Load("test.star", []byte(src), nil)
+	err := app.Load("testid", "test.star", []byte(src), nil)
 	assert.NoError(t, err)
 
 	// first time, i == 1
@@ -72,7 +72,7 @@ def main():
 	// but run the same code using different filename, and cached
 	// data ends up in a different namespace
 	app = &Applet{}
-	err = app.Load("test2.star", []byte(src), nil)
+	err = app.Load("testid", "test2.star", []byte(src), nil)
 	assert.NoError(t, err)
 
 	roots, _ = app.Run(map[string]string{})
@@ -103,7 +103,7 @@ def main():
 `
 	InitCache(nil)
 	app := &Applet{}
-	err := app.Load("test.star", []byte(src), nil)
+	err := app.Load("testid", "test.star", []byte(src), nil)
 	assert.NoError(t, err)
 	screens, err := app.Run(map[string]string{})
 	assert.NoError(t, err)
@@ -121,7 +121,7 @@ def main():
 `
 	InitCache(nil)
 	app := &Applet{}
-	err := app.Load("test.star", []byte(src), nil)
+	err := app.Load("testid", "test.star", []byte(src), nil)
 	assert.NoError(t, err)
 	screens, err := app.Run(map[string]string{})
 	assert.Error(t, err)

diff --git a/runtime/httpcache_test.go b/runtime/httpcache_test.go
@@ -19,7 +19,7 @@ func TestInitHTTP(t *testing.T) {
 	assert.NoError(t, err)
 
 	app := &Applet{}
-	err = app.Load("httpcache.star", b, nil)
+	err = app.Load("httpid", "httpcache.star", b, nil)
 	assert.NoError(t, err)
 
 	screens, err := app.Run(map[string]string{})

diff --git a/runtime/modules/hmac/hmac_test.go b/runtime/modules/hmac/hmac_test.go
@@ -26,7 +26,7 @@ def main():
 
 func TestHmac(t *testing.T) {
 	app := &runtime.Applet{}
-	err := app.Load("hmac_test.star", []byte(hmacSource), nil)
+	err := app.Load("hmacid", "hmac_test.star", []byte(hmacSource), nil)
 	assert.NoError(t, err)
 
 	screens, err := app.Run(map[string]string{})

diff --git a/runtime/modules/humanize/humanize_test.go b/runtime/modules/humanize/humanize_test.go
@@ -80,7 +80,7 @@ def main():
 
 func TestHumanize(t *testing.T) {
 	app := &runtime.Applet{}
-	err := app.Load("human.star", []byte(humanSource), nil)
+	err := app.Load("humanid", "human.star", []byte(humanSource), nil)
 	assert.NoError(t, err)
 
 	screens, err := app.Run(map[string]string{})

diff --git a/runtime/modules/qrcode/qrcode_test.go b/runtime/modules/qrcode/qrcode_test.go
@@ -29,7 +29,7 @@ def main():
 
 func TestQRCode(t *testing.T) {
 	app := &runtime.Applet{}
-	err := app.Load("test.star", []byte(qrCodeSource), nil)
+	err := app.Load("testid", "test.star", []byte(qrCodeSource), nil)
 	assert.NoError(t, err)
 
 	screens, err := app.Run(map[string]string{})

diff --git a/runtime/modules/random/random_test.go b/runtime/modules/random/random_test.go
@@ -48,7 +48,7 @@ def main():
 
 func TestRandom(t *testing.T) {
 	app := &runtime.Applet{}
-	err := app.Load("random_test.star", []byte(randomSrc), nil)
+	err := app.Load("randomid", "random_test.star", []byte(randomSrc), nil)
 	require.NoError(t, err)
 
 	screens, err := app.Run(map[string]string{})