status
stringclasses 1
value | repo_name
stringclasses 31
values | repo_url
stringclasses 31
values | issue_id
int64 1
104k
| title
stringlengths 4
233
| body
stringlengths 0
186k
⌀ | issue_url
stringlengths 38
56
| pull_url
stringlengths 37
54
| before_fix_sha
stringlengths 40
40
| after_fix_sha
stringlengths 40
40
| report_datetime
timestamp[us, tz=UTC] | language
stringclasses 5
values | commit_datetime
timestamp[us, tz=UTC] | updated_file
stringlengths 7
188
| chunk_content
stringlengths 1
1.03M
|
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
closed | dagger/dagger | https://github.com/dagger/dagger | 6,659 | Error running `dagger init`: `package name is empty` | To reproduce this, try initializing a dagger module in a directory that already contains a `go.work`. For example:
```
$ git clone https://github.com/dagger/dagger.git
$ go work init
$ dagger init --sdk=go
✘ ModuleSource.asModule: Module! 2.0s
✘ Module.withSource(
source: ✔ ModuleSource.resolveFromCaller: ModuleSource! 0.0s
): Module! 2.0s
✘ Container.directory(path: "/src"): Directory! 1.4s
✔ rm /dagger/dagger.gen.go 0.4s
✘ exec /usr/local/bin/codegen --module-context /src --module-name dagger --propagate-logs=true --introspection-json-path /schema.json 0.9s
┃ Error: load package ".": package name is empty
✘ generating go module: dagger 0.4s
┃ writing dagger.gen.go
┃ writing go.mod
┃ writing go.sum
┃ writing main.go
┃ creating directory querybuilder
┃ writing querybuilder/marshal.go
┃ writing querybuilder/querybuilder.go
┃ needs another pass...
Error: failed to generate code: input: resolve: moduleSource: withName: withSDK: withSourceSubpath: resolveFromCaller: asModule: failed to create module: failed to update codegen and runtime: failed to generate code: failed to get modified source directory for go module sdk codegen: process "/usr/local/bin/codegen --module-context /src --module-name dagger --propagate-logs=true --introspection-json-path /schema.json" did not complete successfully: exit code: 1
Stderr:
Error: load package ".": package name is empty
```
Originally reported by @nipuna-perera on discord: <https://discord.com/channels/707636530424053791/1206727343918293042>
(reproduced in dagger v0.9.10) | https://github.com/dagger/dagger/issues/6659 | https://github.com/dagger/dagger/pull/6678 | b1afa431038bc0a96e4783b30d34b5c8f67f6488 | 31ddf2787ec1e05fb4ad00c33df767796063705f | 2024-02-13T13:35:20Z | go | 2024-02-18T23:23:31Z | core/integration/module_test.go | async scan(): Promise<ScanResult> {
return new ScanResult(
[
dag.container().from("` + alpineImage + `").withExec(["echo", "hello world"])
],
new ScanReport("hello world", ["foo", "bar"])
)
}
}
`,
},
} {
tc := tc
t.Run(tc.sdk, func(t *testing.T) {
t.Parallel()
c, ctx := connect(t)
modGen := c.Container().From(golangImage).
WithMountedFile(testCLIBinPath, daggerCliFile(t, c)).
WithWorkdir("/work").
With(daggerExec("init", "--name=playground", "--sdk="+tc.sdk)).
With(sdkSource(tc.sdk, tc.source))
out, err := modGen.With(daggerQuery(`{playground{scan{targets{stdout},report{contents,authors}}}}`)).Stdout(ctx)
require.NoError(t, err)
require.JSONEq(t, `{"playground":{"scan":{"targets":[{"stdout":"hello world\n"}],"report":{"contents":"hello world","authors":["foo","bar"]}}}}`, out)
})
}
}
func TestModuleGlobalVarDAG(t *testing.T) {
t.Parallel()
type testCase struct { |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,659 | Error running `dagger init`: `package name is empty` | To reproduce this, try initializing a dagger module in a directory that already contains a `go.work`. For example:
```
$ git clone https://github.com/dagger/dagger.git
$ go work init
$ dagger init --sdk=go
✘ ModuleSource.asModule: Module! 2.0s
✘ Module.withSource(
source: ✔ ModuleSource.resolveFromCaller: ModuleSource! 0.0s
): Module! 2.0s
✘ Container.directory(path: "/src"): Directory! 1.4s
✔ rm /dagger/dagger.gen.go 0.4s
✘ exec /usr/local/bin/codegen --module-context /src --module-name dagger --propagate-logs=true --introspection-json-path /schema.json 0.9s
┃ Error: load package ".": package name is empty
✘ generating go module: dagger 0.4s
┃ writing dagger.gen.go
┃ writing go.mod
┃ writing go.sum
┃ writing main.go
┃ creating directory querybuilder
┃ writing querybuilder/marshal.go
┃ writing querybuilder/querybuilder.go
┃ needs another pass...
Error: failed to generate code: input: resolve: moduleSource: withName: withSDK: withSourceSubpath: resolveFromCaller: asModule: failed to create module: failed to update codegen and runtime: failed to generate code: failed to get modified source directory for go module sdk codegen: process "/usr/local/bin/codegen --module-context /src --module-name dagger --propagate-logs=true --introspection-json-path /schema.json" did not complete successfully: exit code: 1
Stderr:
Error: load package ".": package name is empty
```
Originally reported by @nipuna-perera on discord: <https://discord.com/channels/707636530424053791/1206727343918293042>
(reproduced in dagger v0.9.10) | https://github.com/dagger/dagger/issues/6659 | https://github.com/dagger/dagger/pull/6678 | b1afa431038bc0a96e4783b30d34b5c8f67f6488 | 31ddf2787ec1e05fb4ad00c33df767796063705f | 2024-02-13T13:35:20Z | go | 2024-02-18T23:23:31Z | core/integration/module_test.go | sdk string
source string
}
for _, tc := range []testCase{
{
sdk: "go",
source: `package main
import "context"
type Foo struct {}
var someDefault = dag.Container().From("` + alpineImage + `")
func (m *Foo) Fn(ctx context.Context) (string, error) {
return someDefault.WithExec([]string{"echo", "foo"}).Stdout(ctx)
}
`,
},
{
sdk: "python",
source: `from dagger import dag, function, object_type
SOME_DEFAULT = dag.container().from_("` + alpineImage + `")
@object_type
class Foo:
@function
async def fn(self) -> str:
return await SOME_DEFAULT.with_exec(["echo", "foo"]).stdout()
`,
},
{
sdk: "typescript",
source: ` |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,659 | Error running `dagger init`: `package name is empty` | To reproduce this, try initializing a dagger module in a directory that already contains a `go.work`. For example:
```
$ git clone https://github.com/dagger/dagger.git
$ go work init
$ dagger init --sdk=go
✘ ModuleSource.asModule: Module! 2.0s
✘ Module.withSource(
source: ✔ ModuleSource.resolveFromCaller: ModuleSource! 0.0s
): Module! 2.0s
✘ Container.directory(path: "/src"): Directory! 1.4s
✔ rm /dagger/dagger.gen.go 0.4s
✘ exec /usr/local/bin/codegen --module-context /src --module-name dagger --propagate-logs=true --introspection-json-path /schema.json 0.9s
┃ Error: load package ".": package name is empty
✘ generating go module: dagger 0.4s
┃ writing dagger.gen.go
┃ writing go.mod
┃ writing go.sum
┃ writing main.go
┃ creating directory querybuilder
┃ writing querybuilder/marshal.go
┃ writing querybuilder/querybuilder.go
┃ needs another pass...
Error: failed to generate code: input: resolve: moduleSource: withName: withSDK: withSourceSubpath: resolveFromCaller: asModule: failed to create module: failed to update codegen and runtime: failed to generate code: failed to get modified source directory for go module sdk codegen: process "/usr/local/bin/codegen --module-context /src --module-name dagger --propagate-logs=true --introspection-json-path /schema.json" did not complete successfully: exit code: 1
Stderr:
Error: load package ".": package name is empty
```
Originally reported by @nipuna-perera on discord: <https://discord.com/channels/707636530424053791/1206727343918293042>
(reproduced in dagger v0.9.10) | https://github.com/dagger/dagger/issues/6659 | https://github.com/dagger/dagger/pull/6678 | b1afa431038bc0a96e4783b30d34b5c8f67f6488 | 31ddf2787ec1e05fb4ad00c33df767796063705f | 2024-02-13T13:35:20Z | go | 2024-02-18T23:23:31Z | core/integration/module_test.go | import { dag, object, func } from "@dagger.io/dagger"
var someDefault = dag.container().from("` + alpineImage + `")
@object()
class Foo {
@func()
async fn(): Promise<string> {
return someDefault.withExec(["echo", "foo"]).stdout()
}
}
`,
},
} {
tc := tc
t.Run(tc.sdk, func(t *testing.T) {
t.Parallel()
c, ctx := connect(t)
modGen := c.Container().From(golangImage).
WithMountedFile(testCLIBinPath, daggerCliFile(t, c)).
WithWorkdir("/work").
With(daggerExec("init", "--name=foo", "--sdk="+tc.sdk)).
With(sdkSource(tc.sdk, tc.source))
out, err := modGen.With(daggerQuery(`{foo{fn}}`)).Stdout(ctx)
require.NoError(t, err)
require.JSONEq(t, `{"foo":{"fn":"foo\n"}}`, out)
})
}
}
func TestModuleIDableType(t *testing.T) {
t.Parallel()
type testCase struct { |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,659 | Error running `dagger init`: `package name is empty` | To reproduce this, try initializing a dagger module in a directory that already contains a `go.work`. For example:
```
$ git clone https://github.com/dagger/dagger.git
$ go work init
$ dagger init --sdk=go
✘ ModuleSource.asModule: Module! 2.0s
✘ Module.withSource(
source: ✔ ModuleSource.resolveFromCaller: ModuleSource! 0.0s
): Module! 2.0s
✘ Container.directory(path: "/src"): Directory! 1.4s
✔ rm /dagger/dagger.gen.go 0.4s
✘ exec /usr/local/bin/codegen --module-context /src --module-name dagger --propagate-logs=true --introspection-json-path /schema.json 0.9s
┃ Error: load package ".": package name is empty
✘ generating go module: dagger 0.4s
┃ writing dagger.gen.go
┃ writing go.mod
┃ writing go.sum
┃ writing main.go
┃ creating directory querybuilder
┃ writing querybuilder/marshal.go
┃ writing querybuilder/querybuilder.go
┃ needs another pass...
Error: failed to generate code: input: resolve: moduleSource: withName: withSDK: withSourceSubpath: resolveFromCaller: asModule: failed to create module: failed to update codegen and runtime: failed to generate code: failed to get modified source directory for go module sdk codegen: process "/usr/local/bin/codegen --module-context /src --module-name dagger --propagate-logs=true --introspection-json-path /schema.json" did not complete successfully: exit code: 1
Stderr:
Error: load package ".": package name is empty
```
Originally reported by @nipuna-perera on discord: <https://discord.com/channels/707636530424053791/1206727343918293042>
(reproduced in dagger v0.9.10) | https://github.com/dagger/dagger/issues/6659 | https://github.com/dagger/dagger/pull/6678 | b1afa431038bc0a96e4783b30d34b5c8f67f6488 | 31ddf2787ec1e05fb4ad00c33df767796063705f | 2024-02-13T13:35:20Z | go | 2024-02-18T23:23:31Z | core/integration/module_test.go | sdk string
source string
}
for _, tc := range []testCase{
{
sdk: "go",
source: `package main
type Foo struct {
Data string
}
func (m *Foo) Set(data string) *Foo {
m.Data = data
return m
}
func (m *Foo) Get() string {
return m.Data
}
`,
},
{
sdk: "python",
source: `from typing import Self
from dagger import field, function, object_type
@object_type
class Foo:
data: str = ""
@function |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,659 | Error running `dagger init`: `package name is empty` | To reproduce this, try initializing a dagger module in a directory that already contains a `go.work`. For example:
```
$ git clone https://github.com/dagger/dagger.git
$ go work init
$ dagger init --sdk=go
✘ ModuleSource.asModule: Module! 2.0s
✘ Module.withSource(
source: ✔ ModuleSource.resolveFromCaller: ModuleSource! 0.0s
): Module! 2.0s
✘ Container.directory(path: "/src"): Directory! 1.4s
✔ rm /dagger/dagger.gen.go 0.4s
✘ exec /usr/local/bin/codegen --module-context /src --module-name dagger --propagate-logs=true --introspection-json-path /schema.json 0.9s
┃ Error: load package ".": package name is empty
✘ generating go module: dagger 0.4s
┃ writing dagger.gen.go
┃ writing go.mod
┃ writing go.sum
┃ writing main.go
┃ creating directory querybuilder
┃ writing querybuilder/marshal.go
┃ writing querybuilder/querybuilder.go
┃ needs another pass...
Error: failed to generate code: input: resolve: moduleSource: withName: withSDK: withSourceSubpath: resolveFromCaller: asModule: failed to create module: failed to update codegen and runtime: failed to generate code: failed to get modified source directory for go module sdk codegen: process "/usr/local/bin/codegen --module-context /src --module-name dagger --propagate-logs=true --introspection-json-path /schema.json" did not complete successfully: exit code: 1
Stderr:
Error: load package ".": package name is empty
```
Originally reported by @nipuna-perera on discord: <https://discord.com/channels/707636530424053791/1206727343918293042>
(reproduced in dagger v0.9.10) | https://github.com/dagger/dagger/issues/6659 | https://github.com/dagger/dagger/pull/6678 | b1afa431038bc0a96e4783b30d34b5c8f67f6488 | 31ddf2787ec1e05fb4ad00c33df767796063705f | 2024-02-13T13:35:20Z | go | 2024-02-18T23:23:31Z | core/integration/module_test.go | def set(self, data: str) -> Self:
self.data = data
return self
@function
def get(self) -> str:
return self.data
`,
},
{
sdk: "typescript",
source: `
import { object, func } from "@dagger.io/dagger"
@object()
class Foo {
data: string = ""
@func()
set(data: string): Foo {
this.data = data
return this
}
@func()
get(): string {
return this.data
}
}
`,
},
} {
tc := tc
t.Run(tc.sdk, func(t *testing.T) { |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,659 | Error running `dagger init`: `package name is empty` | To reproduce this, try initializing a dagger module in a directory that already contains a `go.work`. For example:
```
$ git clone https://github.com/dagger/dagger.git
$ go work init
$ dagger init --sdk=go
✘ ModuleSource.asModule: Module! 2.0s
✘ Module.withSource(
source: ✔ ModuleSource.resolveFromCaller: ModuleSource! 0.0s
): Module! 2.0s
✘ Container.directory(path: "/src"): Directory! 1.4s
✔ rm /dagger/dagger.gen.go 0.4s
✘ exec /usr/local/bin/codegen --module-context /src --module-name dagger --propagate-logs=true --introspection-json-path /schema.json 0.9s
┃ Error: load package ".": package name is empty
✘ generating go module: dagger 0.4s
┃ writing dagger.gen.go
┃ writing go.mod
┃ writing go.sum
┃ writing main.go
┃ creating directory querybuilder
┃ writing querybuilder/marshal.go
┃ writing querybuilder/querybuilder.go
┃ needs another pass...
Error: failed to generate code: input: resolve: moduleSource: withName: withSDK: withSourceSubpath: resolveFromCaller: asModule: failed to create module: failed to update codegen and runtime: failed to generate code: failed to get modified source directory for go module sdk codegen: process "/usr/local/bin/codegen --module-context /src --module-name dagger --propagate-logs=true --introspection-json-path /schema.json" did not complete successfully: exit code: 1
Stderr:
Error: load package ".": package name is empty
```
Originally reported by @nipuna-perera on discord: <https://discord.com/channels/707636530424053791/1206727343918293042>
(reproduced in dagger v0.9.10) | https://github.com/dagger/dagger/issues/6659 | https://github.com/dagger/dagger/pull/6678 | b1afa431038bc0a96e4783b30d34b5c8f67f6488 | 31ddf2787ec1e05fb4ad00c33df767796063705f | 2024-02-13T13:35:20Z | go | 2024-02-18T23:23:31Z | core/integration/module_test.go | t.Parallel()
c, ctx := connect(t)
modGen := c.Container().From(golangImage).
WithMountedFile(testCLIBinPath, daggerCliFile(t, c)).
WithWorkdir("/work").
With(daggerExec("init", "--name=foo", "--sdk="+tc.sdk)).
With(sdkSource(tc.sdk, tc.source))
out, err := modGen.With(daggerQuery(`{foo{set(data: "abc"){get}}}`)).Stdout(ctx)
require.NoError(t, err)
require.JSONEq(t, `{"foo":{"set":{"get": "abc"}}}`, out)
out, err = modGen.With(daggerQuery(`{foo{set(data: "abc"){id}}}`)).Stdout(ctx)
require.NoError(t, err)
id := gjson.Get(out, "foo.set.id").String()
var idp idproto.ID
err = idp.Decode(id)
require.NoError(t, err)
require.Equal(t, idp.Display(), `foo.set(data: "abc"): Foo!`)
out, err = modGen.With(daggerQuery(`{loadFooFromID(id: "%s"){get}}`, id)).Stdout(ctx)
require.NoError(t, err)
require.JSONEq(t, `{"loadFooFromID":{"get": "abc"}}`, out)
})
}
}
func TestModuleArgOwnType(t *testing.T) {
t.Parallel()
type testCase struct { |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,659 | Error running `dagger init`: `package name is empty` | To reproduce this, try initializing a dagger module in a directory that already contains a `go.work`. For example:
```
$ git clone https://github.com/dagger/dagger.git
$ go work init
$ dagger init --sdk=go
✘ ModuleSource.asModule: Module! 2.0s
✘ Module.withSource(
source: ✔ ModuleSource.resolveFromCaller: ModuleSource! 0.0s
): Module! 2.0s
✘ Container.directory(path: "/src"): Directory! 1.4s
✔ rm /dagger/dagger.gen.go 0.4s
✘ exec /usr/local/bin/codegen --module-context /src --module-name dagger --propagate-logs=true --introspection-json-path /schema.json 0.9s
┃ Error: load package ".": package name is empty
✘ generating go module: dagger 0.4s
┃ writing dagger.gen.go
┃ writing go.mod
┃ writing go.sum
┃ writing main.go
┃ creating directory querybuilder
┃ writing querybuilder/marshal.go
┃ writing querybuilder/querybuilder.go
┃ needs another pass...
Error: failed to generate code: input: resolve: moduleSource: withName: withSDK: withSourceSubpath: resolveFromCaller: asModule: failed to create module: failed to update codegen and runtime: failed to generate code: failed to get modified source directory for go module sdk codegen: process "/usr/local/bin/codegen --module-context /src --module-name dagger --propagate-logs=true --introspection-json-path /schema.json" did not complete successfully: exit code: 1
Stderr:
Error: load package ".": package name is empty
```
Originally reported by @nipuna-perera on discord: <https://discord.com/channels/707636530424053791/1206727343918293042>
(reproduced in dagger v0.9.10) | https://github.com/dagger/dagger/issues/6659 | https://github.com/dagger/dagger/pull/6678 | b1afa431038bc0a96e4783b30d34b5c8f67f6488 | 31ddf2787ec1e05fb4ad00c33df767796063705f | 2024-02-13T13:35:20Z | go | 2024-02-18T23:23:31Z | core/integration/module_test.go | sdk string
source string
}
for _, tc := range []testCase{
{
sdk: "go",
source: `package main
import "strings"
type Foo struct{}
type Message struct {
Content string
}
func (m *Foo) SayHello(name string) Message {
return Message{Content: "hello " + name}
}
func (m *Foo) Upper(msg Message) Message {
msg.Content = strings.ToUpper(msg.Content)
return msg |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,659 | Error running `dagger init`: `package name is empty` | To reproduce this, try initializing a dagger module in a directory that already contains a `go.work`. For example:
```
$ git clone https://github.com/dagger/dagger.git
$ go work init
$ dagger init --sdk=go
✘ ModuleSource.asModule: Module! 2.0s
✘ Module.withSource(
source: ✔ ModuleSource.resolveFromCaller: ModuleSource! 0.0s
): Module! 2.0s
✘ Container.directory(path: "/src"): Directory! 1.4s
✔ rm /dagger/dagger.gen.go 0.4s
✘ exec /usr/local/bin/codegen --module-context /src --module-name dagger --propagate-logs=true --introspection-json-path /schema.json 0.9s
┃ Error: load package ".": package name is empty
✘ generating go module: dagger 0.4s
┃ writing dagger.gen.go
┃ writing go.mod
┃ writing go.sum
┃ writing main.go
┃ creating directory querybuilder
┃ writing querybuilder/marshal.go
┃ writing querybuilder/querybuilder.go
┃ needs another pass...
Error: failed to generate code: input: resolve: moduleSource: withName: withSDK: withSourceSubpath: resolveFromCaller: asModule: failed to create module: failed to update codegen and runtime: failed to generate code: failed to get modified source directory for go module sdk codegen: process "/usr/local/bin/codegen --module-context /src --module-name dagger --propagate-logs=true --introspection-json-path /schema.json" did not complete successfully: exit code: 1
Stderr:
Error: load package ".": package name is empty
```
Originally reported by @nipuna-perera on discord: <https://discord.com/channels/707636530424053791/1206727343918293042>
(reproduced in dagger v0.9.10) | https://github.com/dagger/dagger/issues/6659 | https://github.com/dagger/dagger/pull/6678 | b1afa431038bc0a96e4783b30d34b5c8f67f6488 | 31ddf2787ec1e05fb4ad00c33df767796063705f | 2024-02-13T13:35:20Z | go | 2024-02-18T23:23:31Z | core/integration/module_test.go | }
func (m *Foo) Uppers(msg []Message) []Message {
for i := range msg {
msg[i].Content = strings.ToUpper(msg[i].Content)
}
return msg
}`,
},
{
sdk: "python",
source: `from dagger import field, function, object_type
@object_type
class Message:
content: str = field()
@object_type
class Foo:
@function
def say_hello(self, name: str) -> Message:
return Message(content=f"hello {name}")
@function
def upper(self, msg: Message) -> Message:
msg.content = msg.content.upper()
return msg
@function
def uppers(self, msg: list[Message]) -> list[Message]:
for m in msg:
m.content = m.content.upper()
return msg
`,
}, |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,659 | Error running `dagger init`: `package name is empty` | To reproduce this, try initializing a dagger module in a directory that already contains a `go.work`. For example:
```
$ git clone https://github.com/dagger/dagger.git
$ go work init
$ dagger init --sdk=go
✘ ModuleSource.asModule: Module! 2.0s
✘ Module.withSource(
source: ✔ ModuleSource.resolveFromCaller: ModuleSource! 0.0s
): Module! 2.0s
✘ Container.directory(path: "/src"): Directory! 1.4s
✔ rm /dagger/dagger.gen.go 0.4s
✘ exec /usr/local/bin/codegen --module-context /src --module-name dagger --propagate-logs=true --introspection-json-path /schema.json 0.9s
┃ Error: load package ".": package name is empty
✘ generating go module: dagger 0.4s
┃ writing dagger.gen.go
┃ writing go.mod
┃ writing go.sum
┃ writing main.go
┃ creating directory querybuilder
┃ writing querybuilder/marshal.go
┃ writing querybuilder/querybuilder.go
┃ needs another pass...
Error: failed to generate code: input: resolve: moduleSource: withName: withSDK: withSourceSubpath: resolveFromCaller: asModule: failed to create module: failed to update codegen and runtime: failed to generate code: failed to get modified source directory for go module sdk codegen: process "/usr/local/bin/codegen --module-context /src --module-name dagger --propagate-logs=true --introspection-json-path /schema.json" did not complete successfully: exit code: 1
Stderr:
Error: load package ".": package name is empty
```
Originally reported by @nipuna-perera on discord: <https://discord.com/channels/707636530424053791/1206727343918293042>
(reproduced in dagger v0.9.10) | https://github.com/dagger/dagger/issues/6659 | https://github.com/dagger/dagger/pull/6678 | b1afa431038bc0a96e4783b30d34b5c8f67f6488 | 31ddf2787ec1e05fb4ad00c33df767796063705f | 2024-02-13T13:35:20Z | go | 2024-02-18T23:23:31Z | core/integration/module_test.go | {
sdk: "typescript",
source: `
import { object, func, field } from "@dagger.io/dagger"
@object()
class Message {
@field()
content: string
constructor(content: string) {
this.content = content
}
}
@object()
class Foo {
@func()
sayHello(name: string): Message {
return new Message("hello " + name)
}
@func()
upper(msg: Message): Message {
msg.content = msg.content.toUpperCase()
return msg
}
@func()
uppers(msg: Message[]): Message[] {
for (let i = 0; i < msg.length; i++) {
msg[i].content = msg[i].content.toUpperCase()
}
return msg
} |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,659 | Error running `dagger init`: `package name is empty` | To reproduce this, try initializing a dagger module in a directory that already contains a `go.work`. For example:
```
$ git clone https://github.com/dagger/dagger.git
$ go work init
$ dagger init --sdk=go
✘ ModuleSource.asModule: Module! 2.0s
✘ Module.withSource(
source: ✔ ModuleSource.resolveFromCaller: ModuleSource! 0.0s
): Module! 2.0s
✘ Container.directory(path: "/src"): Directory! 1.4s
✔ rm /dagger/dagger.gen.go 0.4s
✘ exec /usr/local/bin/codegen --module-context /src --module-name dagger --propagate-logs=true --introspection-json-path /schema.json 0.9s
┃ Error: load package ".": package name is empty
✘ generating go module: dagger 0.4s
┃ writing dagger.gen.go
┃ writing go.mod
┃ writing go.sum
┃ writing main.go
┃ creating directory querybuilder
┃ writing querybuilder/marshal.go
┃ writing querybuilder/querybuilder.go
┃ needs another pass...
Error: failed to generate code: input: resolve: moduleSource: withName: withSDK: withSourceSubpath: resolveFromCaller: asModule: failed to create module: failed to update codegen and runtime: failed to generate code: failed to get modified source directory for go module sdk codegen: process "/usr/local/bin/codegen --module-context /src --module-name dagger --propagate-logs=true --introspection-json-path /schema.json" did not complete successfully: exit code: 1
Stderr:
Error: load package ".": package name is empty
```
Originally reported by @nipuna-perera on discord: <https://discord.com/channels/707636530424053791/1206727343918293042>
(reproduced in dagger v0.9.10) | https://github.com/dagger/dagger/issues/6659 | https://github.com/dagger/dagger/pull/6678 | b1afa431038bc0a96e4783b30d34b5c8f67f6488 | 31ddf2787ec1e05fb4ad00c33df767796063705f | 2024-02-13T13:35:20Z | go | 2024-02-18T23:23:31Z | core/integration/module_test.go | }
`,
},
} {
tc := tc
t.Run(tc.sdk, func(t *testing.T) {
t.Parallel()
c, ctx := connect(t)
modGen := c.Container().From(golangImage).
WithMountedFile(testCLIBinPath, daggerCliFile(t, c)).
WithWorkdir("/work").
With(daggerExec("init", "--name=foo", "--sdk="+tc.sdk)).
With(sdkSource(tc.sdk, tc.source))
out, err := modGen.With(daggerQuery(`{foo{sayHello(name: "world"){id}}}`)).Stdout(ctx)
require.NoError(t, err)
id := gjson.Get(out, "foo.sayHello.id").String()
var idp idproto.ID
err = idp.Decode(id)
require.NoError(t, err)
require.Equal(t, idp.Display(), `foo.sayHello(name: "world"): FooMessage!`)
out, err = modGen.With(daggerQuery(`{foo{upper(msg:"%s"){content}}}`, id)).Stdout(ctx)
require.NoError(t, err)
require.JSONEq(t, `{"foo":{"upper":{"content": "HELLO WORLD"}}}`, out)
out, err = modGen.With(daggerQuery(`{foo{uppers(msg:["%s", "%s"]){content}}}`, id, id)).Stdout(ctx)
require.NoError(t, err)
require.JSONEq(t, `{"foo":{"uppers":[{"content": "HELLO WORLD"}, {"content": "HELLO WORLD"}]}}`, out)
})
}
}
func TestModuleConflictingSameNameDeps(t *testing.T) { |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,659 | Error running `dagger init`: `package name is empty` | To reproduce this, try initializing a dagger module in a directory that already contains a `go.work`. For example:
```
$ git clone https://github.com/dagger/dagger.git
$ go work init
$ dagger init --sdk=go
✘ ModuleSource.asModule: Module! 2.0s
✘ Module.withSource(
source: ✔ ModuleSource.resolveFromCaller: ModuleSource! 0.0s
): Module! 2.0s
✘ Container.directory(path: "/src"): Directory! 1.4s
✔ rm /dagger/dagger.gen.go 0.4s
✘ exec /usr/local/bin/codegen --module-context /src --module-name dagger --propagate-logs=true --introspection-json-path /schema.json 0.9s
┃ Error: load package ".": package name is empty
✘ generating go module: dagger 0.4s
┃ writing dagger.gen.go
┃ writing go.mod
┃ writing go.sum
┃ writing main.go
┃ creating directory querybuilder
┃ writing querybuilder/marshal.go
┃ writing querybuilder/querybuilder.go
┃ needs another pass...
Error: failed to generate code: input: resolve: moduleSource: withName: withSDK: withSourceSubpath: resolveFromCaller: asModule: failed to create module: failed to update codegen and runtime: failed to generate code: failed to get modified source directory for go module sdk codegen: process "/usr/local/bin/codegen --module-context /src --module-name dagger --propagate-logs=true --introspection-json-path /schema.json" did not complete successfully: exit code: 1
Stderr:
Error: load package ".": package name is empty
```
Originally reported by @nipuna-perera on discord: <https://discord.com/channels/707636530424053791/1206727343918293042>
(reproduced in dagger v0.9.10) | https://github.com/dagger/dagger/issues/6659 | https://github.com/dagger/dagger/pull/6678 | b1afa431038bc0a96e4783b30d34b5c8f67f6488 | 31ddf2787ec1e05fb4ad00c33df767796063705f | 2024-02-13T13:35:20Z | go | 2024-02-18T23:23:31Z | core/integration/module_test.go | t.Parallel()
c, ctx := connect(t)
ctr := goGitBase(t, c).
WithMountedFile(testCLIBinPath, daggerCliFile(t, c)).
WithWorkdir("/work/dstr").
With(daggerExec("init", "--source=.", "--name=d", "--sdk=go")).
WithNewFile("main.go", dagger.ContainerWithNewFileOpts{
Contents: `package main
type D struct{}
type Obj struct { |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,659 | Error running `dagger init`: `package name is empty` | To reproduce this, try initializing a dagger module in a directory that already contains a `go.work`. For example:
```
$ git clone https://github.com/dagger/dagger.git
$ go work init
$ dagger init --sdk=go
✘ ModuleSource.asModule: Module! 2.0s
✘ Module.withSource(
source: ✔ ModuleSource.resolveFromCaller: ModuleSource! 0.0s
): Module! 2.0s
✘ Container.directory(path: "/src"): Directory! 1.4s
✔ rm /dagger/dagger.gen.go 0.4s
✘ exec /usr/local/bin/codegen --module-context /src --module-name dagger --propagate-logs=true --introspection-json-path /schema.json 0.9s
┃ Error: load package ".": package name is empty
✘ generating go module: dagger 0.4s
┃ writing dagger.gen.go
┃ writing go.mod
┃ writing go.sum
┃ writing main.go
┃ creating directory querybuilder
┃ writing querybuilder/marshal.go
┃ writing querybuilder/querybuilder.go
┃ needs another pass...
Error: failed to generate code: input: resolve: moduleSource: withName: withSDK: withSourceSubpath: resolveFromCaller: asModule: failed to create module: failed to update codegen and runtime: failed to generate code: failed to get modified source directory for go module sdk codegen: process "/usr/local/bin/codegen --module-context /src --module-name dagger --propagate-logs=true --introspection-json-path /schema.json" did not complete successfully: exit code: 1
Stderr:
Error: load package ".": package name is empty
```
Originally reported by @nipuna-perera on discord: <https://discord.com/channels/707636530424053791/1206727343918293042>
(reproduced in dagger v0.9.10) | https://github.com/dagger/dagger/issues/6659 | https://github.com/dagger/dagger/pull/6678 | b1afa431038bc0a96e4783b30d34b5c8f67f6488 | 31ddf2787ec1e05fb4ad00c33df767796063705f | 2024-02-13T13:35:20Z | go | 2024-02-18T23:23:31Z | core/integration/module_test.go | Foo string
}
func (m *D) Fn(foo string) Obj {
return Obj{Foo: foo}
}
`,
})
ctr = ctr.
WithMountedFile(testCLIBinPath, daggerCliFile(t, c)).
WithWorkdir("/work/dint").
With(daggerExec("init", "--source=.", "--name=d", "--sdk=go")).
WithNewFile("main.go", dagger.ContainerWithNewFileOpts{
Contents: `package main
type D struct{}
type Obj struct {
Foo int
}
func (m *D) Fn(foo int) Obj {
return Obj{Foo: foo}
}
`,
})
ctr = ctr.
WithWorkdir("/work").
With(daggerExec("init", "--source=c", "--name=c", "--sdk=go", "c")).
WithWorkdir("/work/c").
With(daggerExec("install", "../dstr")).
WithNewFile("main.go", dagger.ContainerWithNewFileOpts{
Contents: `package main
import ( |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,659 | Error running `dagger init`: `package name is empty` | To reproduce this, try initializing a dagger module in a directory that already contains a `go.work`. For example:
```
$ git clone https://github.com/dagger/dagger.git
$ go work init
$ dagger init --sdk=go
✘ ModuleSource.asModule: Module! 2.0s
✘ Module.withSource(
source: ✔ ModuleSource.resolveFromCaller: ModuleSource! 0.0s
): Module! 2.0s
✘ Container.directory(path: "/src"): Directory! 1.4s
✔ rm /dagger/dagger.gen.go 0.4s
✘ exec /usr/local/bin/codegen --module-context /src --module-name dagger --propagate-logs=true --introspection-json-path /schema.json 0.9s
┃ Error: load package ".": package name is empty
✘ generating go module: dagger 0.4s
┃ writing dagger.gen.go
┃ writing go.mod
┃ writing go.sum
┃ writing main.go
┃ creating directory querybuilder
┃ writing querybuilder/marshal.go
┃ writing querybuilder/querybuilder.go
┃ needs another pass...
Error: failed to generate code: input: resolve: moduleSource: withName: withSDK: withSourceSubpath: resolveFromCaller: asModule: failed to create module: failed to update codegen and runtime: failed to generate code: failed to get modified source directory for go module sdk codegen: process "/usr/local/bin/codegen --module-context /src --module-name dagger --propagate-logs=true --introspection-json-path /schema.json" did not complete successfully: exit code: 1
Stderr:
Error: load package ".": package name is empty
```
Originally reported by @nipuna-perera on discord: <https://discord.com/channels/707636530424053791/1206727343918293042>
(reproduced in dagger v0.9.10) | https://github.com/dagger/dagger/issues/6659 | https://github.com/dagger/dagger/pull/6678 | b1afa431038bc0a96e4783b30d34b5c8f67f6488 | 31ddf2787ec1e05fb4ad00c33df767796063705f | 2024-02-13T13:35:20Z | go | 2024-02-18T23:23:31Z | core/integration/module_test.go | "context"
)
type C struct{}
func (m *C) Fn(ctx context.Context, foo string) (string, error) {
return dag.D().Fn(foo).Foo(ctx)
}
`,
})
ctr = ctr.
WithWorkdir("/work").
With(daggerExec("init", "--source=b", "--name=b", "--sdk=go", "b")).
With(daggerExec("install", "-m=b", "./dint")).
WithNewFile("/work/b/main.go", dagger.ContainerWithNewFileOpts{
Contents: `package main
import (
"context"
)
type B struct{}
func (m *B) Fn(ctx context.Context, foo int) (int, error) {
return dag.D().Fn(foo).Foo(ctx)
}
`,
})
ctr = ctr.
WithWorkdir("/work").
With(daggerExec("init", "--source=a", "--name=a", "--sdk=go", "a")).
WithWorkdir("/work/a").
With(daggerExec("install", "../b")).
With(daggerExec("install", "../c")).
WithNewFile("main.go", dagger.ContainerWithNewFileOpts{ |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,659 | Error running `dagger init`: `package name is empty` | To reproduce this, try initializing a dagger module in a directory that already contains a `go.work`. For example:
```
$ git clone https://github.com/dagger/dagger.git
$ go work init
$ dagger init --sdk=go
✘ ModuleSource.asModule: Module! 2.0s
✘ Module.withSource(
source: ✔ ModuleSource.resolveFromCaller: ModuleSource! 0.0s
): Module! 2.0s
✘ Container.directory(path: "/src"): Directory! 1.4s
✔ rm /dagger/dagger.gen.go 0.4s
✘ exec /usr/local/bin/codegen --module-context /src --module-name dagger --propagate-logs=true --introspection-json-path /schema.json 0.9s
┃ Error: load package ".": package name is empty
✘ generating go module: dagger 0.4s
┃ writing dagger.gen.go
┃ writing go.mod
┃ writing go.sum
┃ writing main.go
┃ creating directory querybuilder
┃ writing querybuilder/marshal.go
┃ writing querybuilder/querybuilder.go
┃ needs another pass...
Error: failed to generate code: input: resolve: moduleSource: withName: withSDK: withSourceSubpath: resolveFromCaller: asModule: failed to create module: failed to update codegen and runtime: failed to generate code: failed to get modified source directory for go module sdk codegen: process "/usr/local/bin/codegen --module-context /src --module-name dagger --propagate-logs=true --introspection-json-path /schema.json" did not complete successfully: exit code: 1
Stderr:
Error: load package ".": package name is empty
```
Originally reported by @nipuna-perera on discord: <https://discord.com/channels/707636530424053791/1206727343918293042>
(reproduced in dagger v0.9.10) | https://github.com/dagger/dagger/issues/6659 | https://github.com/dagger/dagger/pull/6678 | b1afa431038bc0a96e4783b30d34b5c8f67f6488 | 31ddf2787ec1e05fb4ad00c33df767796063705f | 2024-02-13T13:35:20Z | go | 2024-02-18T23:23:31Z | core/integration/module_test.go | Contents: `package main
import (
"context"
"strconv"
)
type A struct{}
func (m *A) Fn(ctx context.Context) (string, error) {
fooStr, err := dag.C().Fn(ctx, "foo")
if err != nil {
return "", err
}
fooInt, err := dag.B().Fn(ctx, 123)
if err != nil {
return "", err
}
return fooStr + strconv.Itoa(fooInt), nil
}
`,
})
out, err := ctr.With(daggerQuery(`{a{fn}}`)).Stdout(ctx)
require.NoError(t, err)
require.JSONEq(t, `{"a":{"fn": "foo123"}}`, out)
types := currentSchema(ctx, t, ctr).Types
require.NotNil(t, types.Get("A"))
require.Nil(t, types.Get("B"))
require.Nil(t, types.Get("C"))
require.Nil(t, types.Get("D"))
}
func TestModuleSelfAPICall(t *testing.T) { |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,659 | Error running `dagger init`: `package name is empty` | To reproduce this, try initializing a dagger module in a directory that already contains a `go.work`. For example:
```
$ git clone https://github.com/dagger/dagger.git
$ go work init
$ dagger init --sdk=go
✘ ModuleSource.asModule: Module! 2.0s
✘ Module.withSource(
source: ✔ ModuleSource.resolveFromCaller: ModuleSource! 0.0s
): Module! 2.0s
✘ Container.directory(path: "/src"): Directory! 1.4s
✔ rm /dagger/dagger.gen.go 0.4s
✘ exec /usr/local/bin/codegen --module-context /src --module-name dagger --propagate-logs=true --introspection-json-path /schema.json 0.9s
┃ Error: load package ".": package name is empty
✘ generating go module: dagger 0.4s
┃ writing dagger.gen.go
┃ writing go.mod
┃ writing go.sum
┃ writing main.go
┃ creating directory querybuilder
┃ writing querybuilder/marshal.go
┃ writing querybuilder/querybuilder.go
┃ needs another pass...
Error: failed to generate code: input: resolve: moduleSource: withName: withSDK: withSourceSubpath: resolveFromCaller: asModule: failed to create module: failed to update codegen and runtime: failed to generate code: failed to get modified source directory for go module sdk codegen: process "/usr/local/bin/codegen --module-context /src --module-name dagger --propagate-logs=true --introspection-json-path /schema.json" did not complete successfully: exit code: 1
Stderr:
Error: load package ".": package name is empty
```
Originally reported by @nipuna-perera on discord: <https://discord.com/channels/707636530424053791/1206727343918293042>
(reproduced in dagger v0.9.10) | https://github.com/dagger/dagger/issues/6659 | https://github.com/dagger/dagger/pull/6678 | b1afa431038bc0a96e4783b30d34b5c8f67f6488 | 31ddf2787ec1e05fb4ad00c33df767796063705f | 2024-02-13T13:35:20Z | go | 2024-02-18T23:23:31Z | core/integration/module_test.go | t.Parallel()
c, ctx := connect(t)
out, err := c.Container().From(golangImage).
WithMountedFile(testCLIBinPath, daggerCliFile(t, c)).
WithWorkdir("/work").
With(daggerExec("init", "--source=.", "--name=test", "--sdk=go")).
WithNewFile("main.go", dagger.ContainerWithNewFileOpts{
Contents: `package main
import (
"context"
"github.com/Khan/genqlient/graphql"
)
type Test struct{}
func (m *Test) FnA(ctx context.Context) (string, error) {
resp := &graphql.Response{}
err := dag.c.MakeRequest(ctx, &graphql.Request{
Query: "{test{fnB}}",
}, resp)
if err != nil {
return "", err
}
return resp.Data.(map[string]any)["test"].(map[string]any)["fnB"].(string), nil
}
func (m *Test) FnB() string {
return "hi from b" |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,659 | Error running `dagger init`: `package name is empty` | To reproduce this, try initializing a dagger module in a directory that already contains a `go.work`. For example:
```
$ git clone https://github.com/dagger/dagger.git
$ go work init
$ dagger init --sdk=go
✘ ModuleSource.asModule: Module! 2.0s
✘ Module.withSource(
source: ✔ ModuleSource.resolveFromCaller: ModuleSource! 0.0s
): Module! 2.0s
✘ Container.directory(path: "/src"): Directory! 1.4s
✔ rm /dagger/dagger.gen.go 0.4s
✘ exec /usr/local/bin/codegen --module-context /src --module-name dagger --propagate-logs=true --introspection-json-path /schema.json 0.9s
┃ Error: load package ".": package name is empty
✘ generating go module: dagger 0.4s
┃ writing dagger.gen.go
┃ writing go.mod
┃ writing go.sum
┃ writing main.go
┃ creating directory querybuilder
┃ writing querybuilder/marshal.go
┃ writing querybuilder/querybuilder.go
┃ needs another pass...
Error: failed to generate code: input: resolve: moduleSource: withName: withSDK: withSourceSubpath: resolveFromCaller: asModule: failed to create module: failed to update codegen and runtime: failed to generate code: failed to get modified source directory for go module sdk codegen: process "/usr/local/bin/codegen --module-context /src --module-name dagger --propagate-logs=true --introspection-json-path /schema.json" did not complete successfully: exit code: 1
Stderr:
Error: load package ".": package name is empty
```
Originally reported by @nipuna-perera on discord: <https://discord.com/channels/707636530424053791/1206727343918293042>
(reproduced in dagger v0.9.10) | https://github.com/dagger/dagger/issues/6659 | https://github.com/dagger/dagger/pull/6678 | b1afa431038bc0a96e4783b30d34b5c8f67f6488 | 31ddf2787ec1e05fb4ad00c33df767796063705f | 2024-02-13T13:35:20Z | go | 2024-02-18T23:23:31Z | core/integration/module_test.go | }
`,
}).
With(daggerQuery(`{test{fnA}}`)).
Stdout(ctx)
require.NoError(t, err)
require.JSONEq(t, `{"test":{"fnA": "hi from b"}}`, out)
}
func TestModuleGoWithOtherModuleTypes(t *testing.T) {
t.Parallel()
c, ctx := connect(t)
ctr := goGitBase(t, c).
WithMountedFile(testCLIBinPath, daggerCliFile(t, c)).
WithWorkdir("/work/dep").
With(daggerExec("init", "--source=.", "--name=dep", "--sdk=go")).
WithNewFile("main.go", dagger.ContainerWithNewFileOpts{
Contents: `package main
type Dep struct{}
type Obj struct {
Foo string
}
func (m *Dep) Fn() Obj {
return Obj{Foo: "foo"}
}
`,
}).
WithWorkdir("/work").
With(daggerExec("init", "--source=test", "--name=test", "--sdk=go", "test")).
With(daggerExec("install", "-m=test", "./dep")).
WithWorkdir("/work/test") |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,659 | Error running `dagger init`: `package name is empty` | To reproduce this, try initializing a dagger module in a directory that already contains a `go.work`. For example:
```
$ git clone https://github.com/dagger/dagger.git
$ go work init
$ dagger init --sdk=go
✘ ModuleSource.asModule: Module! 2.0s
✘ Module.withSource(
source: ✔ ModuleSource.resolveFromCaller: ModuleSource! 0.0s
): Module! 2.0s
✘ Container.directory(path: "/src"): Directory! 1.4s
✔ rm /dagger/dagger.gen.go 0.4s
✘ exec /usr/local/bin/codegen --module-context /src --module-name dagger --propagate-logs=true --introspection-json-path /schema.json 0.9s
┃ Error: load package ".": package name is empty
✘ generating go module: dagger 0.4s
┃ writing dagger.gen.go
┃ writing go.mod
┃ writing go.sum
┃ writing main.go
┃ creating directory querybuilder
┃ writing querybuilder/marshal.go
┃ writing querybuilder/querybuilder.go
┃ needs another pass...
Error: failed to generate code: input: resolve: moduleSource: withName: withSDK: withSourceSubpath: resolveFromCaller: asModule: failed to create module: failed to update codegen and runtime: failed to generate code: failed to get modified source directory for go module sdk codegen: process "/usr/local/bin/codegen --module-context /src --module-name dagger --propagate-logs=true --introspection-json-path /schema.json" did not complete successfully: exit code: 1
Stderr:
Error: load package ".": package name is empty
```
Originally reported by @nipuna-perera on discord: <https://discord.com/channels/707636530424053791/1206727343918293042>
(reproduced in dagger v0.9.10) | https://github.com/dagger/dagger/issues/6659 | https://github.com/dagger/dagger/pull/6678 | b1afa431038bc0a96e4783b30d34b5c8f67f6488 | 31ddf2787ec1e05fb4ad00c33df767796063705f | 2024-02-13T13:35:20Z | go | 2024-02-18T23:23:31Z | core/integration/module_test.go | t.Run("return as other module object", func(t *testing.T) {
t.Run("direct", func(t *testing.T) {
_, err := ctr.
WithNewFile("main.go", dagger.ContainerWithNewFileOpts{
Contents: `package main
type Test struct{}
func (m *Test) Fn() (*DepObj, error) {
return nil, nil
}
`,
}).
With(daggerFunctions()).
Stdout(ctx)
require.Error(t, err)
require.ErrorContains(t, err, fmt.Sprintf(
"object %q function %q cannot return external type from dependency module %q",
"Test", "Fn", "dep",
))
})
t.Run("list", func(t *testing.T) {
_, err := ctr.
WithNewFile("main.go", dagger.ContainerWithNewFileOpts{
Contents: `package main
type Test struct{}
func (m *Test) Fn() ([]*DepObj, error) {
return nil, nil
}
`,
}).
With(daggerFunctions()). |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,659 | Error running `dagger init`: `package name is empty` | To reproduce this, try initializing a dagger module in a directory that already contains a `go.work`. For example:
```
$ git clone https://github.com/dagger/dagger.git
$ go work init
$ dagger init --sdk=go
✘ ModuleSource.asModule: Module! 2.0s
✘ Module.withSource(
source: ✔ ModuleSource.resolveFromCaller: ModuleSource! 0.0s
): Module! 2.0s
✘ Container.directory(path: "/src"): Directory! 1.4s
✔ rm /dagger/dagger.gen.go 0.4s
✘ exec /usr/local/bin/codegen --module-context /src --module-name dagger --propagate-logs=true --introspection-json-path /schema.json 0.9s
┃ Error: load package ".": package name is empty
✘ generating go module: dagger 0.4s
┃ writing dagger.gen.go
┃ writing go.mod
┃ writing go.sum
┃ writing main.go
┃ creating directory querybuilder
┃ writing querybuilder/marshal.go
┃ writing querybuilder/querybuilder.go
┃ needs another pass...
Error: failed to generate code: input: resolve: moduleSource: withName: withSDK: withSourceSubpath: resolveFromCaller: asModule: failed to create module: failed to update codegen and runtime: failed to generate code: failed to get modified source directory for go module sdk codegen: process "/usr/local/bin/codegen --module-context /src --module-name dagger --propagate-logs=true --introspection-json-path /schema.json" did not complete successfully: exit code: 1
Stderr:
Error: load package ".": package name is empty
```
Originally reported by @nipuna-perera on discord: <https://discord.com/channels/707636530424053791/1206727343918293042>
(reproduced in dagger v0.9.10) | https://github.com/dagger/dagger/issues/6659 | https://github.com/dagger/dagger/pull/6678 | b1afa431038bc0a96e4783b30d34b5c8f67f6488 | 31ddf2787ec1e05fb4ad00c33df767796063705f | 2024-02-13T13:35:20Z | go | 2024-02-18T23:23:31Z | core/integration/module_test.go | Stdout(ctx)
require.Error(t, err)
require.ErrorContains(t, err, fmt.Sprintf(
"object %q function %q cannot return external type from dependency module %q",
"Test", "Fn", "dep",
))
})
})
t.Run("arg as other module object", func(t *testing.T) {
t.Run("direct", func(t *testing.T) {
_, err := ctr.WithNewFile("main.go", dagger.ContainerWithNewFileOpts{
Contents: `package main
type Test struct{}
func (m *Test) Fn(obj *DepObj) error {
return nil
}
`,
}).
With(daggerFunctions()).
Stdout(ctx)
require.Error(t, err)
require.ErrorContains(t, err, fmt.Sprintf(
"object %q function %q arg %q cannot reference external type from dependency module %q",
"Test", "Fn", "obj", "dep",
))
})
t.Run("list", func(t *testing.T) {
_, err := ctr.WithNewFile("main.go", dagger.ContainerWithNewFileOpts{
Contents: `package main
type Test struct{} |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,659 | Error running `dagger init`: `package name is empty` | To reproduce this, try initializing a dagger module in a directory that already contains a `go.work`. For example:
```
$ git clone https://github.com/dagger/dagger.git
$ go work init
$ dagger init --sdk=go
✘ ModuleSource.asModule: Module! 2.0s
✘ Module.withSource(
source: ✔ ModuleSource.resolveFromCaller: ModuleSource! 0.0s
): Module! 2.0s
✘ Container.directory(path: "/src"): Directory! 1.4s
✔ rm /dagger/dagger.gen.go 0.4s
✘ exec /usr/local/bin/codegen --module-context /src --module-name dagger --propagate-logs=true --introspection-json-path /schema.json 0.9s
┃ Error: load package ".": package name is empty
✘ generating go module: dagger 0.4s
┃ writing dagger.gen.go
┃ writing go.mod
┃ writing go.sum
┃ writing main.go
┃ creating directory querybuilder
┃ writing querybuilder/marshal.go
┃ writing querybuilder/querybuilder.go
┃ needs another pass...
Error: failed to generate code: input: resolve: moduleSource: withName: withSDK: withSourceSubpath: resolveFromCaller: asModule: failed to create module: failed to update codegen and runtime: failed to generate code: failed to get modified source directory for go module sdk codegen: process "/usr/local/bin/codegen --module-context /src --module-name dagger --propagate-logs=true --introspection-json-path /schema.json" did not complete successfully: exit code: 1
Stderr:
Error: load package ".": package name is empty
```
Originally reported by @nipuna-perera on discord: <https://discord.com/channels/707636530424053791/1206727343918293042>
(reproduced in dagger v0.9.10) | https://github.com/dagger/dagger/issues/6659 | https://github.com/dagger/dagger/pull/6678 | b1afa431038bc0a96e4783b30d34b5c8f67f6488 | 31ddf2787ec1e05fb4ad00c33df767796063705f | 2024-02-13T13:35:20Z | go | 2024-02-18T23:23:31Z | core/integration/module_test.go | func (m *Test) Fn(obj []*DepObj) error {
return nil
}
`,
}).
With(daggerFunctions()).
Stdout(ctx)
require.Error(t, err)
require.ErrorContains(t, err, fmt.Sprintf(
"object %q function %q arg %q cannot reference external type from dependency module %q",
"Test", "Fn", "obj", "dep",
))
})
})
t.Run("field as other module object", func(t *testing.T) {
t.Run("direct", func(t *testing.T) {
_, err := ctr.
WithNewFile("main.go", dagger.ContainerWithNewFileOpts{
Contents: `package main
type Test struct{}
type Obj struct {
Foo *DepObj
}
func (m *Test) Fn() (*Obj, error) {
return nil, nil
}
`,
}).
With(daggerFunctions()).
Stdout(ctx) |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,659 | Error running `dagger init`: `package name is empty` | To reproduce this, try initializing a dagger module in a directory that already contains a `go.work`. For example:
```
$ git clone https://github.com/dagger/dagger.git
$ go work init
$ dagger init --sdk=go
✘ ModuleSource.asModule: Module! 2.0s
✘ Module.withSource(
source: ✔ ModuleSource.resolveFromCaller: ModuleSource! 0.0s
): Module! 2.0s
✘ Container.directory(path: "/src"): Directory! 1.4s
✔ rm /dagger/dagger.gen.go 0.4s
✘ exec /usr/local/bin/codegen --module-context /src --module-name dagger --propagate-logs=true --introspection-json-path /schema.json 0.9s
┃ Error: load package ".": package name is empty
✘ generating go module: dagger 0.4s
┃ writing dagger.gen.go
┃ writing go.mod
┃ writing go.sum
┃ writing main.go
┃ creating directory querybuilder
┃ writing querybuilder/marshal.go
┃ writing querybuilder/querybuilder.go
┃ needs another pass...
Error: failed to generate code: input: resolve: moduleSource: withName: withSDK: withSourceSubpath: resolveFromCaller: asModule: failed to create module: failed to update codegen and runtime: failed to generate code: failed to get modified source directory for go module sdk codegen: process "/usr/local/bin/codegen --module-context /src --module-name dagger --propagate-logs=true --introspection-json-path /schema.json" did not complete successfully: exit code: 1
Stderr:
Error: load package ".": package name is empty
```
Originally reported by @nipuna-perera on discord: <https://discord.com/channels/707636530424053791/1206727343918293042>
(reproduced in dagger v0.9.10) | https://github.com/dagger/dagger/issues/6659 | https://github.com/dagger/dagger/pull/6678 | b1afa431038bc0a96e4783b30d34b5c8f67f6488 | 31ddf2787ec1e05fb4ad00c33df767796063705f | 2024-02-13T13:35:20Z | go | 2024-02-18T23:23:31Z | core/integration/module_test.go | require.Error(t, err)
require.ErrorContains(t, err, fmt.Sprintf(
"object %q field %q cannot reference external type from dependency module %q",
"Obj", "Foo", "dep",
))
})
t.Run("list", func(t *testing.T) {
_, err := ctr.
WithNewFile("main.go", dagger.ContainerWithNewFileOpts{
Contents: `package main
type Test struct{}
type Obj struct {
Foo []*DepObj
}
func (m *Test) Fn() (*Obj, error) {
return nil, nil
}
`,
}).
With(daggerFunctions()).
Stdout(ctx)
require.Error(t, err)
require.ErrorContains(t, err, fmt.Sprintf(
"object %q field %q cannot reference external type from dependency module %q",
"Obj", "Foo", "dep",
))
})
})
}
var useInner = `package main |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,659 | Error running `dagger init`: `package name is empty` | To reproduce this, try initializing a dagger module in a directory that already contains a `go.work`. For example:
```
$ git clone https://github.com/dagger/dagger.git
$ go work init
$ dagger init --sdk=go
✘ ModuleSource.asModule: Module! 2.0s
✘ Module.withSource(
source: ✔ ModuleSource.resolveFromCaller: ModuleSource! 0.0s
): Module! 2.0s
✘ Container.directory(path: "/src"): Directory! 1.4s
✔ rm /dagger/dagger.gen.go 0.4s
✘ exec /usr/local/bin/codegen --module-context /src --module-name dagger --propagate-logs=true --introspection-json-path /schema.json 0.9s
┃ Error: load package ".": package name is empty
✘ generating go module: dagger 0.4s
┃ writing dagger.gen.go
┃ writing go.mod
┃ writing go.sum
┃ writing main.go
┃ creating directory querybuilder
┃ writing querybuilder/marshal.go
┃ writing querybuilder/querybuilder.go
┃ needs another pass...
Error: failed to generate code: input: resolve: moduleSource: withName: withSDK: withSourceSubpath: resolveFromCaller: asModule: failed to create module: failed to update codegen and runtime: failed to generate code: failed to get modified source directory for go module sdk codegen: process "/usr/local/bin/codegen --module-context /src --module-name dagger --propagate-logs=true --introspection-json-path /schema.json" did not complete successfully: exit code: 1
Stderr:
Error: load package ".": package name is empty
```
Originally reported by @nipuna-perera on discord: <https://discord.com/channels/707636530424053791/1206727343918293042>
(reproduced in dagger v0.9.10) | https://github.com/dagger/dagger/issues/6659 | https://github.com/dagger/dagger/pull/6678 | b1afa431038bc0a96e4783b30d34b5c8f67f6488 | 31ddf2787ec1e05fb4ad00c33df767796063705f | 2024-02-13T13:35:20Z | go | 2024-02-18T23:23:31Z | core/integration/module_test.go | type Dep struct{}
func (m *Dep) Hello() string {
return "hello"
}
`
var useGoOuter = `package main
import "context"
type Use struct{}
func (m *Use) UseHello(ctx context.Context) (string, error) {
return dag.Dep().Hello(ctx)
}
`
var usePythonOuter = `from dagger import dag, function
@function
def use_hello() -> str:
return dag.dep().hello()
`
var useTSOuter = `
import { dag, object, func } from '@dagger.io/dagger'
@object()
class Use {
@func()
async useHello(): Promise<string> {
return dag.dep().hello()
}
}
`
func TestModuleUseLocal(t *testing.T) {
t.Parallel()
type testCase struct { |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,659 | Error running `dagger init`: `package name is empty` | To reproduce this, try initializing a dagger module in a directory that already contains a `go.work`. For example:
```
$ git clone https://github.com/dagger/dagger.git
$ go work init
$ dagger init --sdk=go
✘ ModuleSource.asModule: Module! 2.0s
✘ Module.withSource(
source: ✔ ModuleSource.resolveFromCaller: ModuleSource! 0.0s
): Module! 2.0s
✘ Container.directory(path: "/src"): Directory! 1.4s
✔ rm /dagger/dagger.gen.go 0.4s
✘ exec /usr/local/bin/codegen --module-context /src --module-name dagger --propagate-logs=true --introspection-json-path /schema.json 0.9s
┃ Error: load package ".": package name is empty
✘ generating go module: dagger 0.4s
┃ writing dagger.gen.go
┃ writing go.mod
┃ writing go.sum
┃ writing main.go
┃ creating directory querybuilder
┃ writing querybuilder/marshal.go
┃ writing querybuilder/querybuilder.go
┃ needs another pass...
Error: failed to generate code: input: resolve: moduleSource: withName: withSDK: withSourceSubpath: resolveFromCaller: asModule: failed to create module: failed to update codegen and runtime: failed to generate code: failed to get modified source directory for go module sdk codegen: process "/usr/local/bin/codegen --module-context /src --module-name dagger --propagate-logs=true --introspection-json-path /schema.json" did not complete successfully: exit code: 1
Stderr:
Error: load package ".": package name is empty
```
Originally reported by @nipuna-perera on discord: <https://discord.com/channels/707636530424053791/1206727343918293042>
(reproduced in dagger v0.9.10) | https://github.com/dagger/dagger/issues/6659 | https://github.com/dagger/dagger/pull/6678 | b1afa431038bc0a96e4783b30d34b5c8f67f6488 | 31ddf2787ec1e05fb4ad00c33df767796063705f | 2024-02-13T13:35:20Z | go | 2024-02-18T23:23:31Z | core/integration/module_test.go | sdk string
source string
}
for _, tc := range []testCase{
{
sdk: "go",
source: useGoOuter,
},
{
sdk: "python",
source: usePythonOuter,
},
{ |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,659 | Error running `dagger init`: `package name is empty` | To reproduce this, try initializing a dagger module in a directory that already contains a `go.work`. For example:
```
$ git clone https://github.com/dagger/dagger.git
$ go work init
$ dagger init --sdk=go
✘ ModuleSource.asModule: Module! 2.0s
✘ Module.withSource(
source: ✔ ModuleSource.resolveFromCaller: ModuleSource! 0.0s
): Module! 2.0s
✘ Container.directory(path: "/src"): Directory! 1.4s
✔ rm /dagger/dagger.gen.go 0.4s
✘ exec /usr/local/bin/codegen --module-context /src --module-name dagger --propagate-logs=true --introspection-json-path /schema.json 0.9s
┃ Error: load package ".": package name is empty
✘ generating go module: dagger 0.4s
┃ writing dagger.gen.go
┃ writing go.mod
┃ writing go.sum
┃ writing main.go
┃ creating directory querybuilder
┃ writing querybuilder/marshal.go
┃ writing querybuilder/querybuilder.go
┃ needs another pass...
Error: failed to generate code: input: resolve: moduleSource: withName: withSDK: withSourceSubpath: resolveFromCaller: asModule: failed to create module: failed to update codegen and runtime: failed to generate code: failed to get modified source directory for go module sdk codegen: process "/usr/local/bin/codegen --module-context /src --module-name dagger --propagate-logs=true --introspection-json-path /schema.json" did not complete successfully: exit code: 1
Stderr:
Error: load package ".": package name is empty
```
Originally reported by @nipuna-perera on discord: <https://discord.com/channels/707636530424053791/1206727343918293042>
(reproduced in dagger v0.9.10) | https://github.com/dagger/dagger/issues/6659 | https://github.com/dagger/dagger/pull/6678 | b1afa431038bc0a96e4783b30d34b5c8f67f6488 | 31ddf2787ec1e05fb4ad00c33df767796063705f | 2024-02-13T13:35:20Z | go | 2024-02-18T23:23:31Z | core/integration/module_test.go | sdk: "typescript",
source: useTSOuter,
},
} {
tc := tc
t.Run(fmt.Sprintf("%s uses go", tc.sdk), func(t *testing.T) {
t.Parallel()
c, ctx := connect(t)
modGen := goGitBase(t, c).
WithMountedFile(testCLIBinPath, daggerCliFile(t, c)).
WithWorkdir("/work/dep").
With(daggerExec("init", "--name=dep", "--sdk=go")).
With(sdkSource("go", useInner)).
WithWorkdir("/work").
With(daggerExec("init", "--name=use", "--sdk="+tc.sdk)).
With(sdkSource(tc.sdk, tc.source)).
With(daggerExec("install", "./dep"))
out, err := modGen.With(daggerQuery(`{use{useHello}}`)).Stdout(ctx)
require.NoError(t, err)
require.JSONEq(t, `{"use":{"useHello":"hello"}}`, out)
_, err = modGen.With(daggerQuery(`{dep{hello}}`)).Stdout(ctx)
require.Error(t, err)
require.ErrorContains(t, err, `Query has no such field: "dep"`)
})
}
}
func TestModuleCodegenOnDepChange(t *testing.T) {
t.Parallel()
type testCase struct { |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,659 | Error running `dagger init`: `package name is empty` | To reproduce this, try initializing a dagger module in a directory that already contains a `go.work`. For example:
```
$ git clone https://github.com/dagger/dagger.git
$ go work init
$ dagger init --sdk=go
✘ ModuleSource.asModule: Module! 2.0s
✘ Module.withSource(
source: ✔ ModuleSource.resolveFromCaller: ModuleSource! 0.0s
): Module! 2.0s
✘ Container.directory(path: "/src"): Directory! 1.4s
✔ rm /dagger/dagger.gen.go 0.4s
✘ exec /usr/local/bin/codegen --module-context /src --module-name dagger --propagate-logs=true --introspection-json-path /schema.json 0.9s
┃ Error: load package ".": package name is empty
✘ generating go module: dagger 0.4s
┃ writing dagger.gen.go
┃ writing go.mod
┃ writing go.sum
┃ writing main.go
┃ creating directory querybuilder
┃ writing querybuilder/marshal.go
┃ writing querybuilder/querybuilder.go
┃ needs another pass...
Error: failed to generate code: input: resolve: moduleSource: withName: withSDK: withSourceSubpath: resolveFromCaller: asModule: failed to create module: failed to update codegen and runtime: failed to generate code: failed to get modified source directory for go module sdk codegen: process "/usr/local/bin/codegen --module-context /src --module-name dagger --propagate-logs=true --introspection-json-path /schema.json" did not complete successfully: exit code: 1
Stderr:
Error: load package ".": package name is empty
```
Originally reported by @nipuna-perera on discord: <https://discord.com/channels/707636530424053791/1206727343918293042>
(reproduced in dagger v0.9.10) | https://github.com/dagger/dagger/issues/6659 | https://github.com/dagger/dagger/pull/6678 | b1afa431038bc0a96e4783b30d34b5c8f67f6488 | 31ddf2787ec1e05fb4ad00c33df767796063705f | 2024-02-13T13:35:20Z | go | 2024-02-18T23:23:31Z | core/integration/module_test.go | sdk string
source string
changed string
expected string
}
for _, tc := range []testCase{
{
sdk: "go",
source: useGoOuter,
expected: "Hellov2",
changed: strings.ReplaceAll(useGoOuter, `Hello(ctx)`, `Hellov2(ctx)`),
},
{
sdk: "python",
source: usePythonOuter,
expected: "hellov2",
changed: strings.ReplaceAll(usePythonOuter, `.hello()`, `.hellov2()`),
},
{
sdk: "typescript",
source: useTSOuter,
expected: "hellov2",
changed: strings.ReplaceAll(useTSOuter, `.hello()`, `.hellov2()`),
},
} {
tc := tc
t.Run(fmt.Sprintf("%s uses go", tc.sdk), func(t *testing.T) {
t.Parallel()
c, ctx := connect(t) |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,659 | Error running `dagger init`: `package name is empty` | To reproduce this, try initializing a dagger module in a directory that already contains a `go.work`. For example:
```
$ git clone https://github.com/dagger/dagger.git
$ go work init
$ dagger init --sdk=go
✘ ModuleSource.asModule: Module! 2.0s
✘ Module.withSource(
source: ✔ ModuleSource.resolveFromCaller: ModuleSource! 0.0s
): Module! 2.0s
✘ Container.directory(path: "/src"): Directory! 1.4s
✔ rm /dagger/dagger.gen.go 0.4s
✘ exec /usr/local/bin/codegen --module-context /src --module-name dagger --propagate-logs=true --introspection-json-path /schema.json 0.9s
┃ Error: load package ".": package name is empty
✘ generating go module: dagger 0.4s
┃ writing dagger.gen.go
┃ writing go.mod
┃ writing go.sum
┃ writing main.go
┃ creating directory querybuilder
┃ writing querybuilder/marshal.go
┃ writing querybuilder/querybuilder.go
┃ needs another pass...
Error: failed to generate code: input: resolve: moduleSource: withName: withSDK: withSourceSubpath: resolveFromCaller: asModule: failed to create module: failed to update codegen and runtime: failed to generate code: failed to get modified source directory for go module sdk codegen: process "/usr/local/bin/codegen --module-context /src --module-name dagger --propagate-logs=true --introspection-json-path /schema.json" did not complete successfully: exit code: 1
Stderr:
Error: load package ".": package name is empty
```
Originally reported by @nipuna-perera on discord: <https://discord.com/channels/707636530424053791/1206727343918293042>
(reproduced in dagger v0.9.10) | https://github.com/dagger/dagger/issues/6659 | https://github.com/dagger/dagger/pull/6678 | b1afa431038bc0a96e4783b30d34b5c8f67f6488 | 31ddf2787ec1e05fb4ad00c33df767796063705f | 2024-02-13T13:35:20Z | go | 2024-02-18T23:23:31Z | core/integration/module_test.go | modGen := goGitBase(t, c).
WithMountedFile(testCLIBinPath, daggerCliFile(t, c)).
WithWorkdir("/work/dep").
With(daggerExec("init", "--name=dep", "--sdk=go")).
With(sdkSource("go", useInner)).
WithWorkdir("/work").
With(daggerExec("init", "--name=use", "--sdk="+tc.sdk)).
With(sdkSource(tc.sdk, tc.source)).
With(daggerExec("install", "./dep"))
out, err := modGen.With(daggerQuery(`{use{useHello}}`)).Stdout(ctx)
require.NoError(t, err)
require.JSONEq(t, `{"use":{"useHello":"hello"}}`, out)
newInner := strings.ReplaceAll(useInner, `Hello()`, `Hellov2()`)
modGen = modGen.
WithWorkdir("/work/dep").
With(sdkSource("go", newInner)).
WithWorkdir("/work").
With(daggerExec("develop"))
codegenContents, err := modGen.File(sdkCodegenFile(t, tc.sdk)).Contents(ctx)
require.NoError(t, err)
require.Contains(t, codegenContents, tc.expected)
modGen = modGen.With(sdkSource(tc.sdk, tc.changed))
out, err = modGen.With(daggerQuery(`{use{useHello}}`)).Stdout(ctx)
require.NoError(t, err)
require.JSONEq(t, `{"use":{"useHello":"hello"}}`, out)
})
}
}
func TestModuleSyncDeps(t *testing.T) { |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,659 | Error running `dagger init`: `package name is empty` | To reproduce this, try initializing a dagger module in a directory that already contains a `go.work`. For example:
```
$ git clone https://github.com/dagger/dagger.git
$ go work init
$ dagger init --sdk=go
✘ ModuleSource.asModule: Module! 2.0s
✘ Module.withSource(
source: ✔ ModuleSource.resolveFromCaller: ModuleSource! 0.0s
): Module! 2.0s
✘ Container.directory(path: "/src"): Directory! 1.4s
✔ rm /dagger/dagger.gen.go 0.4s
✘ exec /usr/local/bin/codegen --module-context /src --module-name dagger --propagate-logs=true --introspection-json-path /schema.json 0.9s
┃ Error: load package ".": package name is empty
✘ generating go module: dagger 0.4s
┃ writing dagger.gen.go
┃ writing go.mod
┃ writing go.sum
┃ writing main.go
┃ creating directory querybuilder
┃ writing querybuilder/marshal.go
┃ writing querybuilder/querybuilder.go
┃ needs another pass...
Error: failed to generate code: input: resolve: moduleSource: withName: withSDK: withSourceSubpath: resolveFromCaller: asModule: failed to create module: failed to update codegen and runtime: failed to generate code: failed to get modified source directory for go module sdk codegen: process "/usr/local/bin/codegen --module-context /src --module-name dagger --propagate-logs=true --introspection-json-path /schema.json" did not complete successfully: exit code: 1
Stderr:
Error: load package ".": package name is empty
```
Originally reported by @nipuna-perera on discord: <https://discord.com/channels/707636530424053791/1206727343918293042>
(reproduced in dagger v0.9.10) | https://github.com/dagger/dagger/issues/6659 | https://github.com/dagger/dagger/pull/6678 | b1afa431038bc0a96e4783b30d34b5c8f67f6488 | 31ddf2787ec1e05fb4ad00c33df767796063705f | 2024-02-13T13:35:20Z | go | 2024-02-18T23:23:31Z | core/integration/module_test.go | t.Parallel()
type testCase struct {
sdk string
source string
}
for _, tc := range []testCase{
{
sdk: "go",
source: useGoOuter,
},
{
sdk: "python",
source: usePythonOuter,
},
{
sdk: "typescript",
source: useTSOuter,
},
} {
tc := tc
t.Run(fmt.Sprintf("%s uses go", tc.sdk), func(t *testing.T) { |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,659 | Error running `dagger init`: `package name is empty` | To reproduce this, try initializing a dagger module in a directory that already contains a `go.work`. For example:
```
$ git clone https://github.com/dagger/dagger.git
$ go work init
$ dagger init --sdk=go
✘ ModuleSource.asModule: Module! 2.0s
✘ Module.withSource(
source: ✔ ModuleSource.resolveFromCaller: ModuleSource! 0.0s
): Module! 2.0s
✘ Container.directory(path: "/src"): Directory! 1.4s
✔ rm /dagger/dagger.gen.go 0.4s
✘ exec /usr/local/bin/codegen --module-context /src --module-name dagger --propagate-logs=true --introspection-json-path /schema.json 0.9s
┃ Error: load package ".": package name is empty
✘ generating go module: dagger 0.4s
┃ writing dagger.gen.go
┃ writing go.mod
┃ writing go.sum
┃ writing main.go
┃ creating directory querybuilder
┃ writing querybuilder/marshal.go
┃ writing querybuilder/querybuilder.go
┃ needs another pass...
Error: failed to generate code: input: resolve: moduleSource: withName: withSDK: withSourceSubpath: resolveFromCaller: asModule: failed to create module: failed to update codegen and runtime: failed to generate code: failed to get modified source directory for go module sdk codegen: process "/usr/local/bin/codegen --module-context /src --module-name dagger --propagate-logs=true --introspection-json-path /schema.json" did not complete successfully: exit code: 1
Stderr:
Error: load package ".": package name is empty
```
Originally reported by @nipuna-perera on discord: <https://discord.com/channels/707636530424053791/1206727343918293042>
(reproduced in dagger v0.9.10) | https://github.com/dagger/dagger/issues/6659 | https://github.com/dagger/dagger/pull/6678 | b1afa431038bc0a96e4783b30d34b5c8f67f6488 | 31ddf2787ec1e05fb4ad00c33df767796063705f | 2024-02-13T13:35:20Z | go | 2024-02-18T23:23:31Z | core/integration/module_test.go | t.Parallel()
c, ctx := connect(t)
modGen := goGitBase(t, c).
WithMountedFile(testCLIBinPath, daggerCliFile(t, c)).
WithWorkdir("/work/dep").
With(daggerExec("init", "--name=dep", "--sdk=go")).
With(sdkSource("go", useInner)).
WithWorkdir("/work").
With(daggerExec("init", "--name=use", "--sdk="+tc.sdk)).
With(sdkSource(tc.sdk, tc.source)).
With(daggerExec("install", "./dep"))
modGen = modGen.With(daggerQuery(`{use{useHello}}`))
out, err := modGen.Stdout(ctx)
require.NoError(t, err)
require.JSONEq(t, `{"use":{"useHello":"hello"}}`, out)
newInner := strings.ReplaceAll(useInner, `"hello"`, `"goodbye"`)
modGen = modGen.
WithWorkdir("/work/dep").
With(sdkSource("go", newInner)).
WithWorkdir("/work").
With(daggerExec("develop"))
out, err = modGen.With(daggerQuery(`{use{useHello}}`)).Stdout(ctx)
require.NoError(t, err)
require.JSONEq(t, `{"use":{"useHello":"goodbye"}}`, out)
})
}
}
func TestModuleUseLocalMulti(t *testing.T) {
t.Parallel()
type testCase struct { |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,659 | Error running `dagger init`: `package name is empty` | To reproduce this, try initializing a dagger module in a directory that already contains a `go.work`. For example:
```
$ git clone https://github.com/dagger/dagger.git
$ go work init
$ dagger init --sdk=go
✘ ModuleSource.asModule: Module! 2.0s
✘ Module.withSource(
source: ✔ ModuleSource.resolveFromCaller: ModuleSource! 0.0s
): Module! 2.0s
✘ Container.directory(path: "/src"): Directory! 1.4s
✔ rm /dagger/dagger.gen.go 0.4s
✘ exec /usr/local/bin/codegen --module-context /src --module-name dagger --propagate-logs=true --introspection-json-path /schema.json 0.9s
┃ Error: load package ".": package name is empty
✘ generating go module: dagger 0.4s
┃ writing dagger.gen.go
┃ writing go.mod
┃ writing go.sum
┃ writing main.go
┃ creating directory querybuilder
┃ writing querybuilder/marshal.go
┃ writing querybuilder/querybuilder.go
┃ needs another pass...
Error: failed to generate code: input: resolve: moduleSource: withName: withSDK: withSourceSubpath: resolveFromCaller: asModule: failed to create module: failed to update codegen and runtime: failed to generate code: failed to get modified source directory for go module sdk codegen: process "/usr/local/bin/codegen --module-context /src --module-name dagger --propagate-logs=true --introspection-json-path /schema.json" did not complete successfully: exit code: 1
Stderr:
Error: load package ".": package name is empty
```
Originally reported by @nipuna-perera on discord: <https://discord.com/channels/707636530424053791/1206727343918293042>
(reproduced in dagger v0.9.10) | https://github.com/dagger/dagger/issues/6659 | https://github.com/dagger/dagger/pull/6678 | b1afa431038bc0a96e4783b30d34b5c8f67f6488 | 31ddf2787ec1e05fb4ad00c33df767796063705f | 2024-02-13T13:35:20Z | go | 2024-02-18T23:23:31Z | core/integration/module_test.go | sdk string
source string
}
for _, tc := range []testCase{
{
sdk: "go",
source: `package main
import "context"
import "fmt"
type Use struct {}
func (m *Use) Names(ctx context.Context) ([]string, error) {
fooName, err := dag.Foo().Name(ctx)
if err != nil {
return nil, fmt.Errorf("foo.name: %w", err)
}
barName, err := dag.Bar().Name(ctx)
if err != nil {
return nil, fmt.Errorf("bar.name: %w", err)
}
return []string{fooName, barName}, nil
}
`,
},
{
sdk: "python", |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,659 | Error running `dagger init`: `package name is empty` | To reproduce this, try initializing a dagger module in a directory that already contains a `go.work`. For example:
```
$ git clone https://github.com/dagger/dagger.git
$ go work init
$ dagger init --sdk=go
✘ ModuleSource.asModule: Module! 2.0s
✘ Module.withSource(
source: ✔ ModuleSource.resolveFromCaller: ModuleSource! 0.0s
): Module! 2.0s
✘ Container.directory(path: "/src"): Directory! 1.4s
✔ rm /dagger/dagger.gen.go 0.4s
✘ exec /usr/local/bin/codegen --module-context /src --module-name dagger --propagate-logs=true --introspection-json-path /schema.json 0.9s
┃ Error: load package ".": package name is empty
✘ generating go module: dagger 0.4s
┃ writing dagger.gen.go
┃ writing go.mod
┃ writing go.sum
┃ writing main.go
┃ creating directory querybuilder
┃ writing querybuilder/marshal.go
┃ writing querybuilder/querybuilder.go
┃ needs another pass...
Error: failed to generate code: input: resolve: moduleSource: withName: withSDK: withSourceSubpath: resolveFromCaller: asModule: failed to create module: failed to update codegen and runtime: failed to generate code: failed to get modified source directory for go module sdk codegen: process "/usr/local/bin/codegen --module-context /src --module-name dagger --propagate-logs=true --introspection-json-path /schema.json" did not complete successfully: exit code: 1
Stderr:
Error: load package ".": package name is empty
```
Originally reported by @nipuna-perera on discord: <https://discord.com/channels/707636530424053791/1206727343918293042>
(reproduced in dagger v0.9.10) | https://github.com/dagger/dagger/issues/6659 | https://github.com/dagger/dagger/pull/6678 | b1afa431038bc0a96e4783b30d34b5c8f67f6488 | 31ddf2787ec1e05fb4ad00c33df767796063705f | 2024-02-13T13:35:20Z | go | 2024-02-18T23:23:31Z | core/integration/module_test.go | source: `from dagger import dag, function
@function
async def names() -> list[str]:
return [
await dag.foo().name(),
await dag.bar().name(),
]
`,
},
{
sdk: "typescript",
source: `
import { dag, object, func } from '@dagger.io/dagger'
@object()
class Use {
@func()
async names(): Promise<string[]> {
return [await dag.foo().name(), await dag.bar().name()]
}
}
`,
},
} {
tc := tc
t.Run(fmt.Sprintf("%s uses go", tc.sdk), func(t *testing.T) {
t.Parallel()
c, ctx := connect(t)
modGen := goGitBase(t, c).
WithMountedFile(testCLIBinPath, daggerCliFile(t, c)).
WithWorkdir("/work/foo"). |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,659 | Error running `dagger init`: `package name is empty` | To reproduce this, try initializing a dagger module in a directory that already contains a `go.work`. For example:
```
$ git clone https://github.com/dagger/dagger.git
$ go work init
$ dagger init --sdk=go
✘ ModuleSource.asModule: Module! 2.0s
✘ Module.withSource(
source: ✔ ModuleSource.resolveFromCaller: ModuleSource! 0.0s
): Module! 2.0s
✘ Container.directory(path: "/src"): Directory! 1.4s
✔ rm /dagger/dagger.gen.go 0.4s
✘ exec /usr/local/bin/codegen --module-context /src --module-name dagger --propagate-logs=true --introspection-json-path /schema.json 0.9s
┃ Error: load package ".": package name is empty
✘ generating go module: dagger 0.4s
┃ writing dagger.gen.go
┃ writing go.mod
┃ writing go.sum
┃ writing main.go
┃ creating directory querybuilder
┃ writing querybuilder/marshal.go
┃ writing querybuilder/querybuilder.go
┃ needs another pass...
Error: failed to generate code: input: resolve: moduleSource: withName: withSDK: withSourceSubpath: resolveFromCaller: asModule: failed to create module: failed to update codegen and runtime: failed to generate code: failed to get modified source directory for go module sdk codegen: process "/usr/local/bin/codegen --module-context /src --module-name dagger --propagate-logs=true --introspection-json-path /schema.json" did not complete successfully: exit code: 1
Stderr:
Error: load package ".": package name is empty
```
Originally reported by @nipuna-perera on discord: <https://discord.com/channels/707636530424053791/1206727343918293042>
(reproduced in dagger v0.9.10) | https://github.com/dagger/dagger/issues/6659 | https://github.com/dagger/dagger/pull/6678 | b1afa431038bc0a96e4783b30d34b5c8f67f6488 | 31ddf2787ec1e05fb4ad00c33df767796063705f | 2024-02-13T13:35:20Z | go | 2024-02-18T23:23:31Z | core/integration/module_test.go | WithNewFile("/work/foo/main.go", dagger.ContainerWithNewFileOpts{
Contents: `package main
type Foo struct {}
func (m *Foo) Name() string { return "foo" }
`,
}).
With(daggerExec("init", "--source=.", "--name=foo", "--sdk=go")).
WithWorkdir("/work/bar").
WithNewFile("/work/bar/main.go", dagger.ContainerWithNewFileOpts{
Contents: `package main
type Bar struct {}
func (m *Bar) Name() string { return "bar" }
`,
}).
With(daggerExec("init", "--source=.", "--name=bar", "--sdk=go")).
WithWorkdir("/work").
With(daggerExec("init", "--name=use", "--sdk="+tc.sdk)).
With(daggerExec("install", "./foo")).
With(daggerExec("install", "./bar")).
With(sdkSource(tc.sdk, tc.source)).
WithEnvVariable("BUST", identity.NewID())
out, err := modGen.With(daggerQuery(`{use{names}}`)).Stdout(ctx)
require.NoError(t, err)
require.JSONEq(t, `{"use":{"names":["foo", "bar"]}}`, out)
})
}
}
func TestModuleConstructor(t *testing.T) {
t.Parallel()
type testCase struct { |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,659 | Error running `dagger init`: `package name is empty` | To reproduce this, try initializing a dagger module in a directory that already contains a `go.work`. For example:
```
$ git clone https://github.com/dagger/dagger.git
$ go work init
$ dagger init --sdk=go
✘ ModuleSource.asModule: Module! 2.0s
✘ Module.withSource(
source: ✔ ModuleSource.resolveFromCaller: ModuleSource! 0.0s
): Module! 2.0s
✘ Container.directory(path: "/src"): Directory! 1.4s
✔ rm /dagger/dagger.gen.go 0.4s
✘ exec /usr/local/bin/codegen --module-context /src --module-name dagger --propagate-logs=true --introspection-json-path /schema.json 0.9s
┃ Error: load package ".": package name is empty
✘ generating go module: dagger 0.4s
┃ writing dagger.gen.go
┃ writing go.mod
┃ writing go.sum
┃ writing main.go
┃ creating directory querybuilder
┃ writing querybuilder/marshal.go
┃ writing querybuilder/querybuilder.go
┃ needs another pass...
Error: failed to generate code: input: resolve: moduleSource: withName: withSDK: withSourceSubpath: resolveFromCaller: asModule: failed to create module: failed to update codegen and runtime: failed to generate code: failed to get modified source directory for go module sdk codegen: process "/usr/local/bin/codegen --module-context /src --module-name dagger --propagate-logs=true --introspection-json-path /schema.json" did not complete successfully: exit code: 1
Stderr:
Error: load package ".": package name is empty
```
Originally reported by @nipuna-perera on discord: <https://discord.com/channels/707636530424053791/1206727343918293042>
(reproduced in dagger v0.9.10) | https://github.com/dagger/dagger/issues/6659 | https://github.com/dagger/dagger/pull/6678 | b1afa431038bc0a96e4783b30d34b5c8f67f6488 | 31ddf2787ec1e05fb4ad00c33df767796063705f | 2024-02-13T13:35:20Z | go | 2024-02-18T23:23:31Z | core/integration/module_test.go | sdk string
source string
}
t.Run("basic", func(t *testing.T) {
t.Parallel()
for _, tc := range []testCase{
{
sdk: "go",
source: `package main
import (
"context"
)
func New(
ctx context.Context,
foo string,
bar *int, // +optional
baz []string,
dir *Directory,
) *Test {
bar2 := 42
if bar != nil {
bar2 = *bar
}
return &Test{ |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,659 | Error running `dagger init`: `package name is empty` | To reproduce this, try initializing a dagger module in a directory that already contains a `go.work`. For example:
```
$ git clone https://github.com/dagger/dagger.git
$ go work init
$ dagger init --sdk=go
✘ ModuleSource.asModule: Module! 2.0s
✘ Module.withSource(
source: ✔ ModuleSource.resolveFromCaller: ModuleSource! 0.0s
): Module! 2.0s
✘ Container.directory(path: "/src"): Directory! 1.4s
✔ rm /dagger/dagger.gen.go 0.4s
✘ exec /usr/local/bin/codegen --module-context /src --module-name dagger --propagate-logs=true --introspection-json-path /schema.json 0.9s
┃ Error: load package ".": package name is empty
✘ generating go module: dagger 0.4s
┃ writing dagger.gen.go
┃ writing go.mod
┃ writing go.sum
┃ writing main.go
┃ creating directory querybuilder
┃ writing querybuilder/marshal.go
┃ writing querybuilder/querybuilder.go
┃ needs another pass...
Error: failed to generate code: input: resolve: moduleSource: withName: withSDK: withSourceSubpath: resolveFromCaller: asModule: failed to create module: failed to update codegen and runtime: failed to generate code: failed to get modified source directory for go module sdk codegen: process "/usr/local/bin/codegen --module-context /src --module-name dagger --propagate-logs=true --introspection-json-path /schema.json" did not complete successfully: exit code: 1
Stderr:
Error: load package ".": package name is empty
```
Originally reported by @nipuna-perera on discord: <https://discord.com/channels/707636530424053791/1206727343918293042>
(reproduced in dagger v0.9.10) | https://github.com/dagger/dagger/issues/6659 | https://github.com/dagger/dagger/pull/6678 | b1afa431038bc0a96e4783b30d34b5c8f67f6488 | 31ddf2787ec1e05fb4ad00c33df767796063705f | 2024-02-13T13:35:20Z | go | 2024-02-18T23:23:31Z | core/integration/module_test.go | Foo: foo,
Bar: bar2,
Baz: baz,
Dir: dir,
}
}
type Test struct {
Foo string
Bar int
Baz []string
Dir *Directory
NeverSetDir *Directory
}
func (m *Test) GimmeFoo() string {
return m.Foo
}
func (m *Test) GimmeBar() int {
return m.Bar
}
func (m *Test) GimmeBaz() []string {
return m.Baz
}
func (m *Test) GimmeDirEnts(ctx context.Context) ([]string, error) {
return m.Dir.Entries(ctx)
}
`,
},
{
sdk: "python",
source: `import dagger |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,659 | Error running `dagger init`: `package name is empty` | To reproduce this, try initializing a dagger module in a directory that already contains a `go.work`. For example:
```
$ git clone https://github.com/dagger/dagger.git
$ go work init
$ dagger init --sdk=go
✘ ModuleSource.asModule: Module! 2.0s
✘ Module.withSource(
source: ✔ ModuleSource.resolveFromCaller: ModuleSource! 0.0s
): Module! 2.0s
✘ Container.directory(path: "/src"): Directory! 1.4s
✔ rm /dagger/dagger.gen.go 0.4s
✘ exec /usr/local/bin/codegen --module-context /src --module-name dagger --propagate-logs=true --introspection-json-path /schema.json 0.9s
┃ Error: load package ".": package name is empty
✘ generating go module: dagger 0.4s
┃ writing dagger.gen.go
┃ writing go.mod
┃ writing go.sum
┃ writing main.go
┃ creating directory querybuilder
┃ writing querybuilder/marshal.go
┃ writing querybuilder/querybuilder.go
┃ needs another pass...
Error: failed to generate code: input: resolve: moduleSource: withName: withSDK: withSourceSubpath: resolveFromCaller: asModule: failed to create module: failed to update codegen and runtime: failed to generate code: failed to get modified source directory for go module sdk codegen: process "/usr/local/bin/codegen --module-context /src --module-name dagger --propagate-logs=true --introspection-json-path /schema.json" did not complete successfully: exit code: 1
Stderr:
Error: load package ".": package name is empty
```
Originally reported by @nipuna-perera on discord: <https://discord.com/channels/707636530424053791/1206727343918293042>
(reproduced in dagger v0.9.10) | https://github.com/dagger/dagger/issues/6659 | https://github.com/dagger/dagger/pull/6678 | b1afa431038bc0a96e4783b30d34b5c8f67f6488 | 31ddf2787ec1e05fb4ad00c33df767796063705f | 2024-02-13T13:35:20Z | go | 2024-02-18T23:23:31Z | core/integration/module_test.go | from dagger import field, function, object_type
@object_type
class Test:
foo: str = field()
dir: dagger.Directory = field()
bar: int = field(default=42)
baz: list[str] = field(default=list)
never_set_dir: dagger.Directory | None = field(default=None)
@function
def gimme_foo(self) -> str:
return self.foo
@function
def gimme_bar(self) -> int:
return self.bar
@function
def gimme_baz(self) -> list[str]:
return self.baz
@function
async def gimme_dir_ents(self) -> list[str]:
return await self.dir.entries()
`,
},
{
sdk: "typescript",
source: `
import { Directory, object, func, field } from '@dagger.io/dagger';
@object()
class Test {
@field()
foo: string |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,659 | Error running `dagger init`: `package name is empty` | To reproduce this, try initializing a dagger module in a directory that already contains a `go.work`. For example:
```
$ git clone https://github.com/dagger/dagger.git
$ go work init
$ dagger init --sdk=go
✘ ModuleSource.asModule: Module! 2.0s
✘ Module.withSource(
source: ✔ ModuleSource.resolveFromCaller: ModuleSource! 0.0s
): Module! 2.0s
✘ Container.directory(path: "/src"): Directory! 1.4s
✔ rm /dagger/dagger.gen.go 0.4s
✘ exec /usr/local/bin/codegen --module-context /src --module-name dagger --propagate-logs=true --introspection-json-path /schema.json 0.9s
┃ Error: load package ".": package name is empty
✘ generating go module: dagger 0.4s
┃ writing dagger.gen.go
┃ writing go.mod
┃ writing go.sum
┃ writing main.go
┃ creating directory querybuilder
┃ writing querybuilder/marshal.go
┃ writing querybuilder/querybuilder.go
┃ needs another pass...
Error: failed to generate code: input: resolve: moduleSource: withName: withSDK: withSourceSubpath: resolveFromCaller: asModule: failed to create module: failed to update codegen and runtime: failed to generate code: failed to get modified source directory for go module sdk codegen: process "/usr/local/bin/codegen --module-context /src --module-name dagger --propagate-logs=true --introspection-json-path /schema.json" did not complete successfully: exit code: 1
Stderr:
Error: load package ".": package name is empty
```
Originally reported by @nipuna-perera on discord: <https://discord.com/channels/707636530424053791/1206727343918293042>
(reproduced in dagger v0.9.10) | https://github.com/dagger/dagger/issues/6659 | https://github.com/dagger/dagger/pull/6678 | b1afa431038bc0a96e4783b30d34b5c8f67f6488 | 31ddf2787ec1e05fb4ad00c33df767796063705f | 2024-02-13T13:35:20Z | go | 2024-02-18T23:23:31Z | core/integration/module_test.go | @field()
dir: Directory
@field()
bar: number
@field()
baz: string[]
@field()
neverSetDir?: Directory
constructor(foo: string, dir: Directory, bar = 42, baz: string[] = []) {
this.foo = foo;
this.dir = dir;
this.bar = bar;
this.baz = baz;
}
@func()
gimmeFoo(): string {
return this.foo;
}
@func()
gimmeBar(): number {
return this.bar;
}
@func()
gimmeBaz(): string[] {
return this.baz;
}
@func()
async gimmeDirEnts(): Promise<string[]> {
return this.dir.entries();
} |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,659 | Error running `dagger init`: `package name is empty` | To reproduce this, try initializing a dagger module in a directory that already contains a `go.work`. For example:
```
$ git clone https://github.com/dagger/dagger.git
$ go work init
$ dagger init --sdk=go
✘ ModuleSource.asModule: Module! 2.0s
✘ Module.withSource(
source: ✔ ModuleSource.resolveFromCaller: ModuleSource! 0.0s
): Module! 2.0s
✘ Container.directory(path: "/src"): Directory! 1.4s
✔ rm /dagger/dagger.gen.go 0.4s
✘ exec /usr/local/bin/codegen --module-context /src --module-name dagger --propagate-logs=true --introspection-json-path /schema.json 0.9s
┃ Error: load package ".": package name is empty
✘ generating go module: dagger 0.4s
┃ writing dagger.gen.go
┃ writing go.mod
┃ writing go.sum
┃ writing main.go
┃ creating directory querybuilder
┃ writing querybuilder/marshal.go
┃ writing querybuilder/querybuilder.go
┃ needs another pass...
Error: failed to generate code: input: resolve: moduleSource: withName: withSDK: withSourceSubpath: resolveFromCaller: asModule: failed to create module: failed to update codegen and runtime: failed to generate code: failed to get modified source directory for go module sdk codegen: process "/usr/local/bin/codegen --module-context /src --module-name dagger --propagate-logs=true --introspection-json-path /schema.json" did not complete successfully: exit code: 1
Stderr:
Error: load package ".": package name is empty
```
Originally reported by @nipuna-perera on discord: <https://discord.com/channels/707636530424053791/1206727343918293042>
(reproduced in dagger v0.9.10) | https://github.com/dagger/dagger/issues/6659 | https://github.com/dagger/dagger/pull/6678 | b1afa431038bc0a96e4783b30d34b5c8f67f6488 | 31ddf2787ec1e05fb4ad00c33df767796063705f | 2024-02-13T13:35:20Z | go | 2024-02-18T23:23:31Z | core/integration/module_test.go | }
`,
},
} {
tc := tc
t.Run(tc.sdk, func(t *testing.T) {
t.Parallel()
c, ctx := connect(t)
ctr := modInit(ctx, t, c, tc.sdk, tc.source)
out, err := ctr.With(daggerCall("--foo=abc", "--baz=x,y,z", "--dir=.", "foo")).Stdout(ctx)
require.NoError(t, err)
require.Equal(t, strings.TrimSpace(out), "abc")
out, err = ctr.With(daggerCall("--foo=abc", "--baz=x,y,z", "--dir=.", "gimme-foo")).Stdout(ctx)
require.NoError(t, err)
require.Equal(t, strings.TrimSpace(out), "abc")
out, err = ctr.With(daggerCall("--foo=abc", "--baz=x,y,z", "--dir=.", "bar")).Stdout(ctx)
require.NoError(t, err)
require.Equal(t, strings.TrimSpace(out), "42")
out, err = ctr.With(daggerCall("--foo=abc", "--baz=x,y,z", "--dir=.", "gimme-bar")).Stdout(ctx)
require.NoError(t, err)
require.Equal(t, strings.TrimSpace(out), "42")
out, err = ctr.With(daggerCall("--foo=abc", "--bar=123", "--baz=x,y,z", "--dir=.", "bar")).Stdout(ctx)
require.NoError(t, err)
require.Equal(t, strings.TrimSpace(out), "123")
out, err = ctr.With(daggerCall("--foo=abc", "--bar=123", "--baz=x,y,z", "--dir=.", "gimme-bar")).Stdout(ctx)
require.NoError(t, err)
require.Equal(t, strings.TrimSpace(out), "123")
out, err = ctr.With(daggerCall("--foo=abc", "--bar=123", "--baz=x,y,z", "--dir=.", "baz")).Stdout(ctx)
require.NoError(t, err)
require.Equal(t, strings.TrimSpace(out), "x\ny\nz") |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,659 | Error running `dagger init`: `package name is empty` | To reproduce this, try initializing a dagger module in a directory that already contains a `go.work`. For example:
```
$ git clone https://github.com/dagger/dagger.git
$ go work init
$ dagger init --sdk=go
✘ ModuleSource.asModule: Module! 2.0s
✘ Module.withSource(
source: ✔ ModuleSource.resolveFromCaller: ModuleSource! 0.0s
): Module! 2.0s
✘ Container.directory(path: "/src"): Directory! 1.4s
✔ rm /dagger/dagger.gen.go 0.4s
✘ exec /usr/local/bin/codegen --module-context /src --module-name dagger --propagate-logs=true --introspection-json-path /schema.json 0.9s
┃ Error: load package ".": package name is empty
✘ generating go module: dagger 0.4s
┃ writing dagger.gen.go
┃ writing go.mod
┃ writing go.sum
┃ writing main.go
┃ creating directory querybuilder
┃ writing querybuilder/marshal.go
┃ writing querybuilder/querybuilder.go
┃ needs another pass...
Error: failed to generate code: input: resolve: moduleSource: withName: withSDK: withSourceSubpath: resolveFromCaller: asModule: failed to create module: failed to update codegen and runtime: failed to generate code: failed to get modified source directory for go module sdk codegen: process "/usr/local/bin/codegen --module-context /src --module-name dagger --propagate-logs=true --introspection-json-path /schema.json" did not complete successfully: exit code: 1
Stderr:
Error: load package ".": package name is empty
```
Originally reported by @nipuna-perera on discord: <https://discord.com/channels/707636530424053791/1206727343918293042>
(reproduced in dagger v0.9.10) | https://github.com/dagger/dagger/issues/6659 | https://github.com/dagger/dagger/pull/6678 | b1afa431038bc0a96e4783b30d34b5c8f67f6488 | 31ddf2787ec1e05fb4ad00c33df767796063705f | 2024-02-13T13:35:20Z | go | 2024-02-18T23:23:31Z | core/integration/module_test.go | out, err = ctr.With(daggerCall("--foo=abc", "--bar=123", "--baz=x,y,z", "--dir=.", "gimme-baz")).Stdout(ctx)
require.NoError(t, err)
require.Equal(t, strings.TrimSpace(out), "x\ny\nz")
out, err = ctr.With(daggerCall("--foo=abc", "--bar=123", "--baz=x,y,z", "--dir=.", "gimme-dir-ents")).Stdout(ctx)
require.NoError(t, err)
require.Contains(t, strings.TrimSpace(out), "dagger.json")
})
}
})
t.Run("fields only", func(t *testing.T) {
t.Parallel()
for _, tc := range []testCase{
{
sdk: "go",
source: `package main
import (
"context"
)
func New(ctx context.Context) (Test, error) {
v, err := dag.Container().From("alpine:3.18.4").File("/etc/alpine-release").Contents(ctx)
if err != nil {
return Test{}, err
}
return Test{
AlpineVersion: v,
}, nil
}
type Test struct {
AlpineVersion string
} |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,659 | Error running `dagger init`: `package name is empty` | To reproduce this, try initializing a dagger module in a directory that already contains a `go.work`. For example:
```
$ git clone https://github.com/dagger/dagger.git
$ go work init
$ dagger init --sdk=go
✘ ModuleSource.asModule: Module! 2.0s
✘ Module.withSource(
source: ✔ ModuleSource.resolveFromCaller: ModuleSource! 0.0s
): Module! 2.0s
✘ Container.directory(path: "/src"): Directory! 1.4s
✔ rm /dagger/dagger.gen.go 0.4s
✘ exec /usr/local/bin/codegen --module-context /src --module-name dagger --propagate-logs=true --introspection-json-path /schema.json 0.9s
┃ Error: load package ".": package name is empty
✘ generating go module: dagger 0.4s
┃ writing dagger.gen.go
┃ writing go.mod
┃ writing go.sum
┃ writing main.go
┃ creating directory querybuilder
┃ writing querybuilder/marshal.go
┃ writing querybuilder/querybuilder.go
┃ needs another pass...
Error: failed to generate code: input: resolve: moduleSource: withName: withSDK: withSourceSubpath: resolveFromCaller: asModule: failed to create module: failed to update codegen and runtime: failed to generate code: failed to get modified source directory for go module sdk codegen: process "/usr/local/bin/codegen --module-context /src --module-name dagger --propagate-logs=true --introspection-json-path /schema.json" did not complete successfully: exit code: 1
Stderr:
Error: load package ".": package name is empty
```
Originally reported by @nipuna-perera on discord: <https://discord.com/channels/707636530424053791/1206727343918293042>
(reproduced in dagger v0.9.10) | https://github.com/dagger/dagger/issues/6659 | https://github.com/dagger/dagger/pull/6678 | b1afa431038bc0a96e4783b30d34b5c8f67f6488 | 31ddf2787ec1e05fb4ad00c33df767796063705f | 2024-02-13T13:35:20Z | go | 2024-02-18T23:23:31Z | core/integration/module_test.go | `,
},
{
sdk: "python",
source: `from dagger import dag, field, function, object_type
@object_type
class Test:
alpine_version: str = field()
@classmethod
async def create(cls) -> "Test":
return cls(alpine_version=await (
dag.container()
.from_("alpine:3.18.4")
.file("/etc/alpine-release")
.contents()
))
`,
},
{
sdk: "typescript",
source: `
import { dag, object, field } from "@dagger.io/dagger"
@object()
class Test {
@field()
alpineVersion: string
// NOTE: this is not standard to do async operations in the constructor.
// This is only for testing purpose but it shouldn't be done in real usage.
constructor() {
return (async () => { |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,659 | Error running `dagger init`: `package name is empty` | To reproduce this, try initializing a dagger module in a directory that already contains a `go.work`. For example:
```
$ git clone https://github.com/dagger/dagger.git
$ go work init
$ dagger init --sdk=go
✘ ModuleSource.asModule: Module! 2.0s
✘ Module.withSource(
source: ✔ ModuleSource.resolveFromCaller: ModuleSource! 0.0s
): Module! 2.0s
✘ Container.directory(path: "/src"): Directory! 1.4s
✔ rm /dagger/dagger.gen.go 0.4s
✘ exec /usr/local/bin/codegen --module-context /src --module-name dagger --propagate-logs=true --introspection-json-path /schema.json 0.9s
┃ Error: load package ".": package name is empty
✘ generating go module: dagger 0.4s
┃ writing dagger.gen.go
┃ writing go.mod
┃ writing go.sum
┃ writing main.go
┃ creating directory querybuilder
┃ writing querybuilder/marshal.go
┃ writing querybuilder/querybuilder.go
┃ needs another pass...
Error: failed to generate code: input: resolve: moduleSource: withName: withSDK: withSourceSubpath: resolveFromCaller: asModule: failed to create module: failed to update codegen and runtime: failed to generate code: failed to get modified source directory for go module sdk codegen: process "/usr/local/bin/codegen --module-context /src --module-name dagger --propagate-logs=true --introspection-json-path /schema.json" did not complete successfully: exit code: 1
Stderr:
Error: load package ".": package name is empty
```
Originally reported by @nipuna-perera on discord: <https://discord.com/channels/707636530424053791/1206727343918293042>
(reproduced in dagger v0.9.10) | https://github.com/dagger/dagger/issues/6659 | https://github.com/dagger/dagger/pull/6678 | b1afa431038bc0a96e4783b30d34b5c8f67f6488 | 31ddf2787ec1e05fb4ad00c33df767796063705f | 2024-02-13T13:35:20Z | go | 2024-02-18T23:23:31Z | core/integration/module_test.go | this.alpineVersion = await dag.container().from("alpine:3.18.4").file("/etc/alpine-release").contents()
return this; // Return the newly-created instance
})();
}
}
`,
},
} {
tc := tc
t.Run(tc.sdk, func(t *testing.T) {
t.Parallel()
c, ctx := connect(t)
ctr := c.Container().From(golangImage).
WithMountedFile(testCLIBinPath, daggerCliFile(t, c)).
WithWorkdir("/work/test").
With(daggerExec("init", "--name=test", "--sdk="+tc.sdk)).
With(sdkSource(tc.sdk, tc.source))
out, err := ctr.With(daggerCall("alpine-version")).Stdout(ctx)
require.NoError(t, err)
require.Equal(t, strings.TrimSpace(out), "3.18.4")
})
}
})
t.Run("return error", func(t *testing.T) {
t.Parallel()
for _, tc := range []testCase{
{
sdk: "go",
source: `package main
import ( |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,659 | Error running `dagger init`: `package name is empty` | To reproduce this, try initializing a dagger module in a directory that already contains a `go.work`. For example:
```
$ git clone https://github.com/dagger/dagger.git
$ go work init
$ dagger init --sdk=go
✘ ModuleSource.asModule: Module! 2.0s
✘ Module.withSource(
source: ✔ ModuleSource.resolveFromCaller: ModuleSource! 0.0s
): Module! 2.0s
✘ Container.directory(path: "/src"): Directory! 1.4s
✔ rm /dagger/dagger.gen.go 0.4s
✘ exec /usr/local/bin/codegen --module-context /src --module-name dagger --propagate-logs=true --introspection-json-path /schema.json 0.9s
┃ Error: load package ".": package name is empty
✘ generating go module: dagger 0.4s
┃ writing dagger.gen.go
┃ writing go.mod
┃ writing go.sum
┃ writing main.go
┃ creating directory querybuilder
┃ writing querybuilder/marshal.go
┃ writing querybuilder/querybuilder.go
┃ needs another pass...
Error: failed to generate code: input: resolve: moduleSource: withName: withSDK: withSourceSubpath: resolveFromCaller: asModule: failed to create module: failed to update codegen and runtime: failed to generate code: failed to get modified source directory for go module sdk codegen: process "/usr/local/bin/codegen --module-context /src --module-name dagger --propagate-logs=true --introspection-json-path /schema.json" did not complete successfully: exit code: 1
Stderr:
Error: load package ".": package name is empty
```
Originally reported by @nipuna-perera on discord: <https://discord.com/channels/707636530424053791/1206727343918293042>
(reproduced in dagger v0.9.10) | https://github.com/dagger/dagger/issues/6659 | https://github.com/dagger/dagger/pull/6678 | b1afa431038bc0a96e4783b30d34b5c8f67f6488 | 31ddf2787ec1e05fb4ad00c33df767796063705f | 2024-02-13T13:35:20Z | go | 2024-02-18T23:23:31Z | core/integration/module_test.go | "fmt"
)
func New() (*Test, error) {
return nil, fmt.Errorf("too bad")
}
type Test struct {
Foo string
}
`,
},
{
sdk: "python",
source: `from dagger import object_type, field
@object_type
class Test:
foo: str = field()
def __init__(self):
raise ValueError("too bad")
`,
},
{
sdk: "typescript",
source: `
import { object, field } from "@dagger.io/dagger"
@object()
class Test {
@field()
foo: string
constructor() {
throw new Error("too bad") |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,659 | Error running `dagger init`: `package name is empty` | To reproduce this, try initializing a dagger module in a directory that already contains a `go.work`. For example:
```
$ git clone https://github.com/dagger/dagger.git
$ go work init
$ dagger init --sdk=go
✘ ModuleSource.asModule: Module! 2.0s
✘ Module.withSource(
source: ✔ ModuleSource.resolveFromCaller: ModuleSource! 0.0s
): Module! 2.0s
✘ Container.directory(path: "/src"): Directory! 1.4s
✔ rm /dagger/dagger.gen.go 0.4s
✘ exec /usr/local/bin/codegen --module-context /src --module-name dagger --propagate-logs=true --introspection-json-path /schema.json 0.9s
┃ Error: load package ".": package name is empty
✘ generating go module: dagger 0.4s
┃ writing dagger.gen.go
┃ writing go.mod
┃ writing go.sum
┃ writing main.go
┃ creating directory querybuilder
┃ writing querybuilder/marshal.go
┃ writing querybuilder/querybuilder.go
┃ needs another pass...
Error: failed to generate code: input: resolve: moduleSource: withName: withSDK: withSourceSubpath: resolveFromCaller: asModule: failed to create module: failed to update codegen and runtime: failed to generate code: failed to get modified source directory for go module sdk codegen: process "/usr/local/bin/codegen --module-context /src --module-name dagger --propagate-logs=true --introspection-json-path /schema.json" did not complete successfully: exit code: 1
Stderr:
Error: load package ".": package name is empty
```
Originally reported by @nipuna-perera on discord: <https://discord.com/channels/707636530424053791/1206727343918293042>
(reproduced in dagger v0.9.10) | https://github.com/dagger/dagger/issues/6659 | https://github.com/dagger/dagger/pull/6678 | b1afa431038bc0a96e4783b30d34b5c8f67f6488 | 31ddf2787ec1e05fb4ad00c33df767796063705f | 2024-02-13T13:35:20Z | go | 2024-02-18T23:23:31Z | core/integration/module_test.go | }
}
`,
},
} {
tc := tc
t.Run(tc.sdk, func(t *testing.T) {
t.Parallel()
var logs safeBuffer
c, ctx := connect(t, dagger.WithLogOutput(&logs))
ctr := c.Container().From(golangImage).
WithMountedFile(testCLIBinPath, daggerCliFile(t, c)).
WithWorkdir("/work/test").
With(daggerExec("init", "--name=test", "--sdk="+tc.sdk)).
With(sdkSource(tc.sdk, tc.source))
_, err := ctr.With(daggerCall("foo")).Stdout(ctx)
require.Error(t, err)
require.NoError(t, c.Close())
t.Log(logs.String())
require.Contains(t, logs.String(), "too bad")
})
}
})
t.Run("python: with default factory", func(t *testing.T) {
t.Parallel()
c, ctx := connect(t)
content := identity.NewID()
ctr := c.Container().From(golangImage).
WithMountedFile(testCLIBinPath, daggerCliFile(t, c)).
WithWorkdir("/work/test"). |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,659 | Error running `dagger init`: `package name is empty` | To reproduce this, try initializing a dagger module in a directory that already contains a `go.work`. For example:
```
$ git clone https://github.com/dagger/dagger.git
$ go work init
$ dagger init --sdk=go
✘ ModuleSource.asModule: Module! 2.0s
✘ Module.withSource(
source: ✔ ModuleSource.resolveFromCaller: ModuleSource! 0.0s
): Module! 2.0s
✘ Container.directory(path: "/src"): Directory! 1.4s
✔ rm /dagger/dagger.gen.go 0.4s
✘ exec /usr/local/bin/codegen --module-context /src --module-name dagger --propagate-logs=true --introspection-json-path /schema.json 0.9s
┃ Error: load package ".": package name is empty
✘ generating go module: dagger 0.4s
┃ writing dagger.gen.go
┃ writing go.mod
┃ writing go.sum
┃ writing main.go
┃ creating directory querybuilder
┃ writing querybuilder/marshal.go
┃ writing querybuilder/querybuilder.go
┃ needs another pass...
Error: failed to generate code: input: resolve: moduleSource: withName: withSDK: withSourceSubpath: resolveFromCaller: asModule: failed to create module: failed to update codegen and runtime: failed to generate code: failed to get modified source directory for go module sdk codegen: process "/usr/local/bin/codegen --module-context /src --module-name dagger --propagate-logs=true --introspection-json-path /schema.json" did not complete successfully: exit code: 1
Stderr:
Error: load package ".": package name is empty
```
Originally reported by @nipuna-perera on discord: <https://discord.com/channels/707636530424053791/1206727343918293042>
(reproduced in dagger v0.9.10) | https://github.com/dagger/dagger/issues/6659 | https://github.com/dagger/dagger/pull/6678 | b1afa431038bc0a96e4783b30d34b5c8f67f6488 | 31ddf2787ec1e05fb4ad00c33df767796063705f | 2024-02-13T13:35:20Z | go | 2024-02-18T23:23:31Z | core/integration/module_test.go | With(daggerExec("init", "--name=test", "--sdk=python")).
With(sdkSource("python", fmt.Sprintf(`import dagger
from dagger import dag, object_type, field
@object_type
class Test:
foo: dagger.File = field(default=lambda: (
dag.directory()
.with_new_file("foo.txt", contents="%s")
.file("foo.txt")
))
bar: list[str] = field(default=list)
`, content),
))
out, err := ctr.With(daggerCall("foo", "contents")).Stdout(ctx)
require.NoError(t, err)
require.Equal(t, content, strings.TrimSpace(out))
out, err = ctr.With(daggerCall("--foo=dagger.json", "foo", "contents")).Stdout(ctx)
require.NoError(t, err)
require.Contains(t, out, `"sdk": "python"`)
_, err = ctr.With(daggerCall("bar")).Sync(ctx)
require.NoError(t, err)
})
t.Run("typescript: with default factory", func(t *testing.T) {
t.Parallel()
c, ctx := connect(t)
content := identity.NewID()
ctr := c.Container().From(golangImage).
WithMountedFile(testCLIBinPath, daggerCliFile(t, c)).
WithWorkdir("/work/test").
With(daggerExec("init", "--name=test", "--sdk=typescript")). |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,659 | Error running `dagger init`: `package name is empty` | To reproduce this, try initializing a dagger module in a directory that already contains a `go.work`. For example:
```
$ git clone https://github.com/dagger/dagger.git
$ go work init
$ dagger init --sdk=go
✘ ModuleSource.asModule: Module! 2.0s
✘ Module.withSource(
source: ✔ ModuleSource.resolveFromCaller: ModuleSource! 0.0s
): Module! 2.0s
✘ Container.directory(path: "/src"): Directory! 1.4s
✔ rm /dagger/dagger.gen.go 0.4s
✘ exec /usr/local/bin/codegen --module-context /src --module-name dagger --propagate-logs=true --introspection-json-path /schema.json 0.9s
┃ Error: load package ".": package name is empty
✘ generating go module: dagger 0.4s
┃ writing dagger.gen.go
┃ writing go.mod
┃ writing go.sum
┃ writing main.go
┃ creating directory querybuilder
┃ writing querybuilder/marshal.go
┃ writing querybuilder/querybuilder.go
┃ needs another pass...
Error: failed to generate code: input: resolve: moduleSource: withName: withSDK: withSourceSubpath: resolveFromCaller: asModule: failed to create module: failed to update codegen and runtime: failed to generate code: failed to get modified source directory for go module sdk codegen: process "/usr/local/bin/codegen --module-context /src --module-name dagger --propagate-logs=true --introspection-json-path /schema.json" did not complete successfully: exit code: 1
Stderr:
Error: load package ".": package name is empty
```
Originally reported by @nipuna-perera on discord: <https://discord.com/channels/707636530424053791/1206727343918293042>
(reproduced in dagger v0.9.10) | https://github.com/dagger/dagger/issues/6659 | https://github.com/dagger/dagger/pull/6678 | b1afa431038bc0a96e4783b30d34b5c8f67f6488 | 31ddf2787ec1e05fb4ad00c33df767796063705f | 2024-02-13T13:35:20Z | go | 2024-02-18T23:23:31Z | core/integration/module_test.go | With(sdkSource("typescript", fmt.Sprintf(`
import { dag, File, object, field } from "@dagger.io/dagger"
@object()
class Test {
@field()
foo: File = dag.directory().withNewFile("foo.txt", "%s").file("foo.txt")
@field()
bar: string[] = []
// Allow foo to be set through the constructor
constructor(foo?: File) {
if (foo) {
this.foo = foo
}
}
}
`, content),
))
out, err := ctr.With(daggerCall("foo", "contents")).Stdout(ctx)
require.NoError(t, err)
require.Equal(t, content, strings.TrimSpace(out))
out, err = ctr.With(daggerCall("--foo=dagger.json", "foo", "contents")).Stdout(ctx)
require.NoError(t, err)
require.Contains(t, out, `"sdk": "typescript"`)
_, err = ctr.With(daggerCall("bar")).Sync(ctx)
require.NoError(t, err)
})
}
func TestModuleWrapping(t *testing.T) {
t.Parallel()
type testCase struct { |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,659 | Error running `dagger init`: `package name is empty` | To reproduce this, try initializing a dagger module in a directory that already contains a `go.work`. For example:
```
$ git clone https://github.com/dagger/dagger.git
$ go work init
$ dagger init --sdk=go
✘ ModuleSource.asModule: Module! 2.0s
✘ Module.withSource(
source: ✔ ModuleSource.resolveFromCaller: ModuleSource! 0.0s
): Module! 2.0s
✘ Container.directory(path: "/src"): Directory! 1.4s
✔ rm /dagger/dagger.gen.go 0.4s
✘ exec /usr/local/bin/codegen --module-context /src --module-name dagger --propagate-logs=true --introspection-json-path /schema.json 0.9s
┃ Error: load package ".": package name is empty
✘ generating go module: dagger 0.4s
┃ writing dagger.gen.go
┃ writing go.mod
┃ writing go.sum
┃ writing main.go
┃ creating directory querybuilder
┃ writing querybuilder/marshal.go
┃ writing querybuilder/querybuilder.go
┃ needs another pass...
Error: failed to generate code: input: resolve: moduleSource: withName: withSDK: withSourceSubpath: resolveFromCaller: asModule: failed to create module: failed to update codegen and runtime: failed to generate code: failed to get modified source directory for go module sdk codegen: process "/usr/local/bin/codegen --module-context /src --module-name dagger --propagate-logs=true --introspection-json-path /schema.json" did not complete successfully: exit code: 1
Stderr:
Error: load package ".": package name is empty
```
Originally reported by @nipuna-perera on discord: <https://discord.com/channels/707636530424053791/1206727343918293042>
(reproduced in dagger v0.9.10) | https://github.com/dagger/dagger/issues/6659 | https://github.com/dagger/dagger/pull/6678 | b1afa431038bc0a96e4783b30d34b5c8f67f6488 | 31ddf2787ec1e05fb4ad00c33df767796063705f | 2024-02-13T13:35:20Z | go | 2024-02-18T23:23:31Z | core/integration/module_test.go | sdk string
source string
}
for _, tc := range []testCase{
{
sdk: "go",
source: `package main
type Wrapper struct{}
func (m *Wrapper) Container() *WrappedContainer {
return &WrappedContainer{
dag.Container().From("` + alpineImage + `"),
}
}
type WrappedContainer struct {
Unwrap *Container` + "`" + `json:"unwrap"` + "`" + `
}
func (c *WrappedContainer) Echo(msg string) *WrappedContainer {
return &WrappedContainer{
c.Unwrap.WithExec([]string{"echo", "-n", msg}),
}
}
`,
},
{
sdk: "python",
source: `from typing import Self
import dagger
from dagger import dag, field, function, object_type |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,659 | Error running `dagger init`: `package name is empty` | To reproduce this, try initializing a dagger module in a directory that already contains a `go.work`. For example:
```
$ git clone https://github.com/dagger/dagger.git
$ go work init
$ dagger init --sdk=go
✘ ModuleSource.asModule: Module! 2.0s
✘ Module.withSource(
source: ✔ ModuleSource.resolveFromCaller: ModuleSource! 0.0s
): Module! 2.0s
✘ Container.directory(path: "/src"): Directory! 1.4s
✔ rm /dagger/dagger.gen.go 0.4s
✘ exec /usr/local/bin/codegen --module-context /src --module-name dagger --propagate-logs=true --introspection-json-path /schema.json 0.9s
┃ Error: load package ".": package name is empty
✘ generating go module: dagger 0.4s
┃ writing dagger.gen.go
┃ writing go.mod
┃ writing go.sum
┃ writing main.go
┃ creating directory querybuilder
┃ writing querybuilder/marshal.go
┃ writing querybuilder/querybuilder.go
┃ needs another pass...
Error: failed to generate code: input: resolve: moduleSource: withName: withSDK: withSourceSubpath: resolveFromCaller: asModule: failed to create module: failed to update codegen and runtime: failed to generate code: failed to get modified source directory for go module sdk codegen: process "/usr/local/bin/codegen --module-context /src --module-name dagger --propagate-logs=true --introspection-json-path /schema.json" did not complete successfully: exit code: 1
Stderr:
Error: load package ".": package name is empty
```
Originally reported by @nipuna-perera on discord: <https://discord.com/channels/707636530424053791/1206727343918293042>
(reproduced in dagger v0.9.10) | https://github.com/dagger/dagger/issues/6659 | https://github.com/dagger/dagger/pull/6678 | b1afa431038bc0a96e4783b30d34b5c8f67f6488 | 31ddf2787ec1e05fb4ad00c33df767796063705f | 2024-02-13T13:35:20Z | go | 2024-02-18T23:23:31Z | core/integration/module_test.go | @object_type
class WrappedContainer:
unwrap: dagger.Container = field()
@function
def echo(self, msg: str) -> Self:
return WrappedContainer(unwrap=self.unwrap.with_exec(["echo", "-n", msg]))
@object_type
class Wrapper:
@function
def container(self) -> WrappedContainer:
return WrappedContainer(unwrap=dag.container().from_("` + alpineImage + `"))
`,
},
{
sdk: "typescript",
source: `
import { dag, Container, object, func, field } from "@dagger.io/dagger"
@object()
class WrappedContainer {
@field()
unwrap: Container
constructor(unwrap: Container) {
this.unwrap = unwrap
}
@func()
echo(msg: string): WrappedContainer {
return new WrappedContainer(this.unwrap.withExec(["echo", "-n", msg]))
}
}
@object() |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,659 | Error running `dagger init`: `package name is empty` | To reproduce this, try initializing a dagger module in a directory that already contains a `go.work`. For example:
```
$ git clone https://github.com/dagger/dagger.git
$ go work init
$ dagger init --sdk=go
✘ ModuleSource.asModule: Module! 2.0s
✘ Module.withSource(
source: ✔ ModuleSource.resolveFromCaller: ModuleSource! 0.0s
): Module! 2.0s
✘ Container.directory(path: "/src"): Directory! 1.4s
✔ rm /dagger/dagger.gen.go 0.4s
✘ exec /usr/local/bin/codegen --module-context /src --module-name dagger --propagate-logs=true --introspection-json-path /schema.json 0.9s
┃ Error: load package ".": package name is empty
✘ generating go module: dagger 0.4s
┃ writing dagger.gen.go
┃ writing go.mod
┃ writing go.sum
┃ writing main.go
┃ creating directory querybuilder
┃ writing querybuilder/marshal.go
┃ writing querybuilder/querybuilder.go
┃ needs another pass...
Error: failed to generate code: input: resolve: moduleSource: withName: withSDK: withSourceSubpath: resolveFromCaller: asModule: failed to create module: failed to update codegen and runtime: failed to generate code: failed to get modified source directory for go module sdk codegen: process "/usr/local/bin/codegen --module-context /src --module-name dagger --propagate-logs=true --introspection-json-path /schema.json" did not complete successfully: exit code: 1
Stderr:
Error: load package ".": package name is empty
```
Originally reported by @nipuna-perera on discord: <https://discord.com/channels/707636530424053791/1206727343918293042>
(reproduced in dagger v0.9.10) | https://github.com/dagger/dagger/issues/6659 | https://github.com/dagger/dagger/pull/6678 | b1afa431038bc0a96e4783b30d34b5c8f67f6488 | 31ddf2787ec1e05fb4ad00c33df767796063705f | 2024-02-13T13:35:20Z | go | 2024-02-18T23:23:31Z | core/integration/module_test.go | class Wrapper {
@func()
container(): WrappedContainer {
return new WrappedContainer(dag.container().from("` + alpineImage + `"))
}
}
`,
},
} {
tc := tc
t.Run(tc.sdk, func(t *testing.T) {
t.Parallel()
c, ctx := connect(t)
modGen := c.Container().From(golangImage).
WithMountedFile(testCLIBinPath, daggerCliFile(t, c)).
WithWorkdir("/work").
With(daggerExec("init", "--name=wrapper", "--sdk="+tc.sdk)).
With(sdkSource(tc.sdk, tc.source))
id := identity.NewID()
out, err := modGen.With(daggerQuery(
fmt.Sprintf(`{wrapper{container{echo(msg:%q){unwrap{stdout}}}}}`, id),
)).Stdout(ctx)
require.NoError(t, err)
require.JSONEq(t,
fmt.Sprintf(`{"wrapper":{"container":{"echo":{"unwrap":{"stdout":%q}}}}}`, id),
out)
})
}
}
func TestModuleLotsOfFunctions(t *testing.T) { |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,659 | Error running `dagger init`: `package name is empty` | To reproduce this, try initializing a dagger module in a directory that already contains a `go.work`. For example:
```
$ git clone https://github.com/dagger/dagger.git
$ go work init
$ dagger init --sdk=go
✘ ModuleSource.asModule: Module! 2.0s
✘ Module.withSource(
source: ✔ ModuleSource.resolveFromCaller: ModuleSource! 0.0s
): Module! 2.0s
✘ Container.directory(path: "/src"): Directory! 1.4s
✔ rm /dagger/dagger.gen.go 0.4s
✘ exec /usr/local/bin/codegen --module-context /src --module-name dagger --propagate-logs=true --introspection-json-path /schema.json 0.9s
┃ Error: load package ".": package name is empty
✘ generating go module: dagger 0.4s
┃ writing dagger.gen.go
┃ writing go.mod
┃ writing go.sum
┃ writing main.go
┃ creating directory querybuilder
┃ writing querybuilder/marshal.go
┃ writing querybuilder/querybuilder.go
┃ needs another pass...
Error: failed to generate code: input: resolve: moduleSource: withName: withSDK: withSourceSubpath: resolveFromCaller: asModule: failed to create module: failed to update codegen and runtime: failed to generate code: failed to get modified source directory for go module sdk codegen: process "/usr/local/bin/codegen --module-context /src --module-name dagger --propagate-logs=true --introspection-json-path /schema.json" did not complete successfully: exit code: 1
Stderr:
Error: load package ".": package name is empty
```
Originally reported by @nipuna-perera on discord: <https://discord.com/channels/707636530424053791/1206727343918293042>
(reproduced in dagger v0.9.10) | https://github.com/dagger/dagger/issues/6659 | https://github.com/dagger/dagger/pull/6678 | b1afa431038bc0a96e4783b30d34b5c8f67f6488 | 31ddf2787ec1e05fb4ad00c33df767796063705f | 2024-02-13T13:35:20Z | go | 2024-02-18T23:23:31Z | core/integration/module_test.go | t.Parallel()
const funcCount = 100
t.Run("go sdk", func(t *testing.T) {
t.Parallel()
c, ctx := connect(t)
mainSrc := `
package main
type PotatoSack struct {}
`
for i := 0; i < funcCount; i++ {
mainSrc += fmt.Sprintf(`
func (m *PotatoSack) Potato%d() string {
return "potato #%d"
}
`, i, i)
}
modGen := c.Container().From(golangImage).
WithMountedFile(testCLIBinPath, daggerCliFile(t, c)).
WithWorkdir("/work").
WithNewFile("/work/main.go", dagger.ContainerWithNewFileOpts{
Contents: mainSrc,
}).
With(daggerExec("init", "--source=.", "--name=potatoSack", "--sdk=go"))
var eg errgroup.Group
for i := 0; i < funcCount; i++ {
i := i |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,659 | Error running `dagger init`: `package name is empty` | To reproduce this, try initializing a dagger module in a directory that already contains a `go.work`. For example:
```
$ git clone https://github.com/dagger/dagger.git
$ go work init
$ dagger init --sdk=go
✘ ModuleSource.asModule: Module! 2.0s
✘ Module.withSource(
source: ✔ ModuleSource.resolveFromCaller: ModuleSource! 0.0s
): Module! 2.0s
✘ Container.directory(path: "/src"): Directory! 1.4s
✔ rm /dagger/dagger.gen.go 0.4s
✘ exec /usr/local/bin/codegen --module-context /src --module-name dagger --propagate-logs=true --introspection-json-path /schema.json 0.9s
┃ Error: load package ".": package name is empty
✘ generating go module: dagger 0.4s
┃ writing dagger.gen.go
┃ writing go.mod
┃ writing go.sum
┃ writing main.go
┃ creating directory querybuilder
┃ writing querybuilder/marshal.go
┃ writing querybuilder/querybuilder.go
┃ needs another pass...
Error: failed to generate code: input: resolve: moduleSource: withName: withSDK: withSourceSubpath: resolveFromCaller: asModule: failed to create module: failed to update codegen and runtime: failed to generate code: failed to get modified source directory for go module sdk codegen: process "/usr/local/bin/codegen --module-context /src --module-name dagger --propagate-logs=true --introspection-json-path /schema.json" did not complete successfully: exit code: 1
Stderr:
Error: load package ".": package name is empty
```
Originally reported by @nipuna-perera on discord: <https://discord.com/channels/707636530424053791/1206727343918293042>
(reproduced in dagger v0.9.10) | https://github.com/dagger/dagger/issues/6659 | https://github.com/dagger/dagger/pull/6678 | b1afa431038bc0a96e4783b30d34b5c8f67f6488 | 31ddf2787ec1e05fb4ad00c33df767796063705f | 2024-02-13T13:35:20Z | go | 2024-02-18T23:23:31Z | core/integration/module_test.go | if i%10 != 0 {
continue
}
eg.Go(func() error {
_, err := modGen.
With(daggerCall(fmt.Sprintf("potato%d", i))).
Sync(ctx)
return err
})
}
require.NoError(t, eg.Wait())
})
t.Run("python sdk", func(t *testing.T) {
t.Parallel()
c, ctx := connect(t)
mainSrc := `from dagger import function
`
for i := 0; i < funcCount; i++ {
mainSrc += fmt.Sprintf(`
@function
def potato_%d() -> str:
return "potato #%d"
`, i, i)
}
modGen := c.Container().From(golangImage).
WithMountedFile(testCLIBinPath, daggerCliFile(t, c)).
WithWorkdir("/work").
WithNewFile("./src/main.py", dagger.ContainerWithNewFileOpts{
Contents: mainSrc, |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,659 | Error running `dagger init`: `package name is empty` | To reproduce this, try initializing a dagger module in a directory that already contains a `go.work`. For example:
```
$ git clone https://github.com/dagger/dagger.git
$ go work init
$ dagger init --sdk=go
✘ ModuleSource.asModule: Module! 2.0s
✘ Module.withSource(
source: ✔ ModuleSource.resolveFromCaller: ModuleSource! 0.0s
): Module! 2.0s
✘ Container.directory(path: "/src"): Directory! 1.4s
✔ rm /dagger/dagger.gen.go 0.4s
✘ exec /usr/local/bin/codegen --module-context /src --module-name dagger --propagate-logs=true --introspection-json-path /schema.json 0.9s
┃ Error: load package ".": package name is empty
✘ generating go module: dagger 0.4s
┃ writing dagger.gen.go
┃ writing go.mod
┃ writing go.sum
┃ writing main.go
┃ creating directory querybuilder
┃ writing querybuilder/marshal.go
┃ writing querybuilder/querybuilder.go
┃ needs another pass...
Error: failed to generate code: input: resolve: moduleSource: withName: withSDK: withSourceSubpath: resolveFromCaller: asModule: failed to create module: failed to update codegen and runtime: failed to generate code: failed to get modified source directory for go module sdk codegen: process "/usr/local/bin/codegen --module-context /src --module-name dagger --propagate-logs=true --introspection-json-path /schema.json" did not complete successfully: exit code: 1
Stderr:
Error: load package ".": package name is empty
```
Originally reported by @nipuna-perera on discord: <https://discord.com/channels/707636530424053791/1206727343918293042>
(reproduced in dagger v0.9.10) | https://github.com/dagger/dagger/issues/6659 | https://github.com/dagger/dagger/pull/6678 | b1afa431038bc0a96e4783b30d34b5c8f67f6488 | 31ddf2787ec1e05fb4ad00c33df767796063705f | 2024-02-13T13:35:20Z | go | 2024-02-18T23:23:31Z | core/integration/module_test.go | }).
With(daggerExec("init", "--source=.", "--name=potatoSack", "--sdk=python"))
var eg errgroup.Group
for i := 0; i < funcCount; i++ {
i := i
if i%10 != 0 {
continue
}
eg.Go(func() error {
_, err := modGen.
With(daggerCall(fmt.Sprintf("potato%d", i))).
Sync(ctx)
return err
})
}
require.NoError(t, eg.Wait())
})
t.Run("typescript sdk", func(t *testing.T) {
t.Parallel()
c, ctx := connect(t)
mainSrc := `
import { object, func } from "@dagger.io/dagger"
@object()
class PotatoSack {
`
for i := 0; i < funcCount; i++ {
mainSrc += fmt.Sprintf(`
@func()
potato_%d(): string { |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,659 | Error running `dagger init`: `package name is empty` | To reproduce this, try initializing a dagger module in a directory that already contains a `go.work`. For example:
```
$ git clone https://github.com/dagger/dagger.git
$ go work init
$ dagger init --sdk=go
✘ ModuleSource.asModule: Module! 2.0s
✘ Module.withSource(
source: ✔ ModuleSource.resolveFromCaller: ModuleSource! 0.0s
): Module! 2.0s
✘ Container.directory(path: "/src"): Directory! 1.4s
✔ rm /dagger/dagger.gen.go 0.4s
✘ exec /usr/local/bin/codegen --module-context /src --module-name dagger --propagate-logs=true --introspection-json-path /schema.json 0.9s
┃ Error: load package ".": package name is empty
✘ generating go module: dagger 0.4s
┃ writing dagger.gen.go
┃ writing go.mod
┃ writing go.sum
┃ writing main.go
┃ creating directory querybuilder
┃ writing querybuilder/marshal.go
┃ writing querybuilder/querybuilder.go
┃ needs another pass...
Error: failed to generate code: input: resolve: moduleSource: withName: withSDK: withSourceSubpath: resolveFromCaller: asModule: failed to create module: failed to update codegen and runtime: failed to generate code: failed to get modified source directory for go module sdk codegen: process "/usr/local/bin/codegen --module-context /src --module-name dagger --propagate-logs=true --introspection-json-path /schema.json" did not complete successfully: exit code: 1
Stderr:
Error: load package ".": package name is empty
```
Originally reported by @nipuna-perera on discord: <https://discord.com/channels/707636530424053791/1206727343918293042>
(reproduced in dagger v0.9.10) | https://github.com/dagger/dagger/issues/6659 | https://github.com/dagger/dagger/pull/6678 | b1afa431038bc0a96e4783b30d34b5c8f67f6488 | 31ddf2787ec1e05fb4ad00c33df767796063705f | 2024-02-13T13:35:20Z | go | 2024-02-18T23:23:31Z | core/integration/module_test.go | return "potato #%d"
}
`, i, i)
}
mainSrc += "\n}"
modGen := c.
Container().
From(golangImage).
WithMountedFile(testCLIBinPath, daggerCliFile(t, c)).
WithWorkdir("/work").
With(sdkSource("typescript", mainSrc)).
With(daggerExec("init", "--name=potatoSack", "--sdk=typescript"))
var eg errgroup.Group
for i := 0; i < funcCount; i++ {
i := i
if i%10 != 0 {
continue
}
eg.Go(func() error {
_, err := modGen.
With(daggerCall(fmt.Sprintf("potato%d", i))).
Sync(ctx)
return err
})
}
require.NoError(t, eg.Wait())
})
}
func TestModuleLotsOfDeps(t *testing.T) { |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,659 | Error running `dagger init`: `package name is empty` | To reproduce this, try initializing a dagger module in a directory that already contains a `go.work`. For example:
```
$ git clone https://github.com/dagger/dagger.git
$ go work init
$ dagger init --sdk=go
✘ ModuleSource.asModule: Module! 2.0s
✘ Module.withSource(
source: ✔ ModuleSource.resolveFromCaller: ModuleSource! 0.0s
): Module! 2.0s
✘ Container.directory(path: "/src"): Directory! 1.4s
✔ rm /dagger/dagger.gen.go 0.4s
✘ exec /usr/local/bin/codegen --module-context /src --module-name dagger --propagate-logs=true --introspection-json-path /schema.json 0.9s
┃ Error: load package ".": package name is empty
✘ generating go module: dagger 0.4s
┃ writing dagger.gen.go
┃ writing go.mod
┃ writing go.sum
┃ writing main.go
┃ creating directory querybuilder
┃ writing querybuilder/marshal.go
┃ writing querybuilder/querybuilder.go
┃ needs another pass...
Error: failed to generate code: input: resolve: moduleSource: withName: withSDK: withSourceSubpath: resolveFromCaller: asModule: failed to create module: failed to update codegen and runtime: failed to generate code: failed to get modified source directory for go module sdk codegen: process "/usr/local/bin/codegen --module-context /src --module-name dagger --propagate-logs=true --introspection-json-path /schema.json" did not complete successfully: exit code: 1
Stderr:
Error: load package ".": package name is empty
```
Originally reported by @nipuna-perera on discord: <https://discord.com/channels/707636530424053791/1206727343918293042>
(reproduced in dagger v0.9.10) | https://github.com/dagger/dagger/issues/6659 | https://github.com/dagger/dagger/pull/6678 | b1afa431038bc0a96e4783b30d34b5c8f67f6488 | 31ddf2787ec1e05fb4ad00c33df767796063705f | 2024-02-13T13:35:20Z | go | 2024-02-18T23:23:31Z | core/integration/module_test.go | t.Parallel()
c, ctx := connect(t)
modGen := goGitBase(t, c).
WithMountedFile(testCLIBinPath, daggerCliFile(t, c)).
WithWorkdir("/work")
modCount := 0
getModMainSrc := func(name string, depNames []string) string {
t.Helper()
mainSrc := fmt.Sprintf(`package main
import "context"
type %s struct {}
func (m *%s) Fn(ctx context.Context) (string, error) {
s := "%s"
var depS string
_ = depS
var err error
_ = err
`, strcase.ToCamel(name), strcase.ToCamel(name), name) |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,659 | Error running `dagger init`: `package name is empty` | To reproduce this, try initializing a dagger module in a directory that already contains a `go.work`. For example:
```
$ git clone https://github.com/dagger/dagger.git
$ go work init
$ dagger init --sdk=go
✘ ModuleSource.asModule: Module! 2.0s
✘ Module.withSource(
source: ✔ ModuleSource.resolveFromCaller: ModuleSource! 0.0s
): Module! 2.0s
✘ Container.directory(path: "/src"): Directory! 1.4s
✔ rm /dagger/dagger.gen.go 0.4s
✘ exec /usr/local/bin/codegen --module-context /src --module-name dagger --propagate-logs=true --introspection-json-path /schema.json 0.9s
┃ Error: load package ".": package name is empty
✘ generating go module: dagger 0.4s
┃ writing dagger.gen.go
┃ writing go.mod
┃ writing go.sum
┃ writing main.go
┃ creating directory querybuilder
┃ writing querybuilder/marshal.go
┃ writing querybuilder/querybuilder.go
┃ needs another pass...
Error: failed to generate code: input: resolve: moduleSource: withName: withSDK: withSourceSubpath: resolveFromCaller: asModule: failed to create module: failed to update codegen and runtime: failed to generate code: failed to get modified source directory for go module sdk codegen: process "/usr/local/bin/codegen --module-context /src --module-name dagger --propagate-logs=true --introspection-json-path /schema.json" did not complete successfully: exit code: 1
Stderr:
Error: load package ".": package name is empty
```
Originally reported by @nipuna-perera on discord: <https://discord.com/channels/707636530424053791/1206727343918293042>
(reproduced in dagger v0.9.10) | https://github.com/dagger/dagger/issues/6659 | https://github.com/dagger/dagger/pull/6678 | b1afa431038bc0a96e4783b30d34b5c8f67f6488 | 31ddf2787ec1e05fb4ad00c33df767796063705f | 2024-02-13T13:35:20Z | go | 2024-02-18T23:23:31Z | core/integration/module_test.go | for _, depName := range depNames {
mainSrc += fmt.Sprintf(`
depS, err = dag.%s().Fn(ctx)
if err != nil {
return "", err
}
s += depS
`, strcase.ToCamel(depName))
}
mainSrc += "return s, nil\n}\n"
fmted, err := format.Source([]byte(mainSrc))
require.NoError(t, err)
return string(fmted)
}
var rootCfg modules.ModuleConfig
addModulesWithDeps := func(newMods int, depNames []string) []string {
t.Helper()
var newModNames []string
for i := 0; i < newMods; i++ {
name := fmt.Sprintf("mod%d", modCount)
modCount++
newModNames = append(newModNames, name)
modGen = modGen.
WithWorkdir("/work/"+name).
WithNewFile("./main.go", dagger.ContainerWithNewFileOpts{
Contents: getModMainSrc(name, depNames),
})
var depCfgs []*modules.ModuleConfigDependency |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,659 | Error running `dagger init`: `package name is empty` | To reproduce this, try initializing a dagger module in a directory that already contains a `go.work`. For example:
```
$ git clone https://github.com/dagger/dagger.git
$ go work init
$ dagger init --sdk=go
✘ ModuleSource.asModule: Module! 2.0s
✘ Module.withSource(
source: ✔ ModuleSource.resolveFromCaller: ModuleSource! 0.0s
): Module! 2.0s
✘ Container.directory(path: "/src"): Directory! 1.4s
✔ rm /dagger/dagger.gen.go 0.4s
✘ exec /usr/local/bin/codegen --module-context /src --module-name dagger --propagate-logs=true --introspection-json-path /schema.json 0.9s
┃ Error: load package ".": package name is empty
✘ generating go module: dagger 0.4s
┃ writing dagger.gen.go
┃ writing go.mod
┃ writing go.sum
┃ writing main.go
┃ creating directory querybuilder
┃ writing querybuilder/marshal.go
┃ writing querybuilder/querybuilder.go
┃ needs another pass...
Error: failed to generate code: input: resolve: moduleSource: withName: withSDK: withSourceSubpath: resolveFromCaller: asModule: failed to create module: failed to update codegen and runtime: failed to generate code: failed to get modified source directory for go module sdk codegen: process "/usr/local/bin/codegen --module-context /src --module-name dagger --propagate-logs=true --introspection-json-path /schema.json" did not complete successfully: exit code: 1
Stderr:
Error: load package ".": package name is empty
```
Originally reported by @nipuna-perera on discord: <https://discord.com/channels/707636530424053791/1206727343918293042>
(reproduced in dagger v0.9.10) | https://github.com/dagger/dagger/issues/6659 | https://github.com/dagger/dagger/pull/6678 | b1afa431038bc0a96e4783b30d34b5c8f67f6488 | 31ddf2787ec1e05fb4ad00c33df767796063705f | 2024-02-13T13:35:20Z | go | 2024-02-18T23:23:31Z | core/integration/module_test.go | for _, depName := range depNames {
depCfgs = append(depCfgs, &modules.ModuleConfigDependency{
Name: depName,
Source: filepath.Join("..", depName),
})
}
modGen = modGen.With(configFile(".", &modules.ModuleConfig{
Name: name,
SDK: "go",
Dependencies: depCfgs,
}))
}
return newModNames
}
curDeps := addModulesWithDeps(1, nil)
for i := 0; i < 6; i++ {
curDeps = addModulesWithDeps(len(curDeps)+1, curDeps)
}
addModulesWithDeps(1, curDeps)
modGen = modGen.With(configFile("..", &rootCfg))
_, err := modGen.With(daggerCall("fn")).Sync(ctx)
require.NoError(t, err)
}
func TestModuleNamespacing(t *testing.T) { |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,659 | Error running `dagger init`: `package name is empty` | To reproduce this, try initializing a dagger module in a directory that already contains a `go.work`. For example:
```
$ git clone https://github.com/dagger/dagger.git
$ go work init
$ dagger init --sdk=go
✘ ModuleSource.asModule: Module! 2.0s
✘ Module.withSource(
source: ✔ ModuleSource.resolveFromCaller: ModuleSource! 0.0s
): Module! 2.0s
✘ Container.directory(path: "/src"): Directory! 1.4s
✔ rm /dagger/dagger.gen.go 0.4s
✘ exec /usr/local/bin/codegen --module-context /src --module-name dagger --propagate-logs=true --introspection-json-path /schema.json 0.9s
┃ Error: load package ".": package name is empty
✘ generating go module: dagger 0.4s
┃ writing dagger.gen.go
┃ writing go.mod
┃ writing go.sum
┃ writing main.go
┃ creating directory querybuilder
┃ writing querybuilder/marshal.go
┃ writing querybuilder/querybuilder.go
┃ needs another pass...
Error: failed to generate code: input: resolve: moduleSource: withName: withSDK: withSourceSubpath: resolveFromCaller: asModule: failed to create module: failed to update codegen and runtime: failed to generate code: failed to get modified source directory for go module sdk codegen: process "/usr/local/bin/codegen --module-context /src --module-name dagger --propagate-logs=true --introspection-json-path /schema.json" did not complete successfully: exit code: 1
Stderr:
Error: load package ".": package name is empty
```
Originally reported by @nipuna-perera on discord: <https://discord.com/channels/707636530424053791/1206727343918293042>
(reproduced in dagger v0.9.10) | https://github.com/dagger/dagger/issues/6659 | https://github.com/dagger/dagger/pull/6678 | b1afa431038bc0a96e4783b30d34b5c8f67f6488 | 31ddf2787ec1e05fb4ad00c33df767796063705f | 2024-02-13T13:35:20Z | go | 2024-02-18T23:23:31Z | core/integration/module_test.go | t.Parallel()
c, ctx := connect(t)
moduleSrcPath, err := filepath.Abs("./testdata/modules/go/namespacing")
require.NoError(t, err)
ctr := c.Container().From(alpineImage).
WithMountedFile(testCLIBinPath, daggerCliFile(t, c)).
WithMountedDirectory("/work", c.Host().Directory(moduleSrcPath)).
WithWorkdir("/work")
out, err := ctr.
With(daggerQuery(`{test{fn(s:"yo")}}`)).
Stdout(ctx)
require.NoError(t, err)
require.JSONEq(t, `{"test":{"fn":["*main.Sub1Obj made 1:yo", "*main.Sub2Obj made 2:yo"]}}`, out)
}
func TestModuleLoops(t *testing.T) { |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,659 | Error running `dagger init`: `package name is empty` | To reproduce this, try initializing a dagger module in a directory that already contains a `go.work`. For example:
```
$ git clone https://github.com/dagger/dagger.git
$ go work init
$ dagger init --sdk=go
✘ ModuleSource.asModule: Module! 2.0s
✘ Module.withSource(
source: ✔ ModuleSource.resolveFromCaller: ModuleSource! 0.0s
): Module! 2.0s
✘ Container.directory(path: "/src"): Directory! 1.4s
✔ rm /dagger/dagger.gen.go 0.4s
✘ exec /usr/local/bin/codegen --module-context /src --module-name dagger --propagate-logs=true --introspection-json-path /schema.json 0.9s
┃ Error: load package ".": package name is empty
✘ generating go module: dagger 0.4s
┃ writing dagger.gen.go
┃ writing go.mod
┃ writing go.sum
┃ writing main.go
┃ creating directory querybuilder
┃ writing querybuilder/marshal.go
┃ writing querybuilder/querybuilder.go
┃ needs another pass...
Error: failed to generate code: input: resolve: moduleSource: withName: withSDK: withSourceSubpath: resolveFromCaller: asModule: failed to create module: failed to update codegen and runtime: failed to generate code: failed to get modified source directory for go module sdk codegen: process "/usr/local/bin/codegen --module-context /src --module-name dagger --propagate-logs=true --introspection-json-path /schema.json" did not complete successfully: exit code: 1
Stderr:
Error: load package ".": package name is empty
```
Originally reported by @nipuna-perera on discord: <https://discord.com/channels/707636530424053791/1206727343918293042>
(reproduced in dagger v0.9.10) | https://github.com/dagger/dagger/issues/6659 | https://github.com/dagger/dagger/pull/6678 | b1afa431038bc0a96e4783b30d34b5c8f67f6488 | 31ddf2787ec1e05fb4ad00c33df767796063705f | 2024-02-13T13:35:20Z | go | 2024-02-18T23:23:31Z | core/integration/module_test.go | t.Parallel()
c, ctx := connect(t)
_, err := goGitBase(t, c).
WithMountedFile(testCLIBinPath, daggerCliFile(t, c)).
With(daggerExec("init", "--name=depA", "--sdk=go", "depA")).
With(daggerExec("init", "--name=depB", "--sdk=go", "depB")).
With(daggerExec("init", "--name=depC", "--sdk=go", "depC")).
With(daggerExec("install", "-m=depC", "./depB")).
With(daggerExec("install", "-m=depB", "./depA")).
With(daggerExec("install", "-m=depA", "./depC")).
Sync(ctx)
require.ErrorContains(t, err, `local module at "/work/depA" has a circular dependency`)
}
var badIDArgGoSrc string
var badIDArgPySrc string
var badIDArgTSSrc string
var badIDFieldGoSrc string
var badIDFieldTSSrc string
var badIDFnGoSrc string
var badIDFnPySrc string
var badIDFnTSSrc string
func TestModuleReservedWords(t *testing.T) {
t.Parallel()
type testCase struct { |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,659 | Error running `dagger init`: `package name is empty` | To reproduce this, try initializing a dagger module in a directory that already contains a `go.work`. For example:
```
$ git clone https://github.com/dagger/dagger.git
$ go work init
$ dagger init --sdk=go
✘ ModuleSource.asModule: Module! 2.0s
✘ Module.withSource(
source: ✔ ModuleSource.resolveFromCaller: ModuleSource! 0.0s
): Module! 2.0s
✘ Container.directory(path: "/src"): Directory! 1.4s
✔ rm /dagger/dagger.gen.go 0.4s
✘ exec /usr/local/bin/codegen --module-context /src --module-name dagger --propagate-logs=true --introspection-json-path /schema.json 0.9s
┃ Error: load package ".": package name is empty
✘ generating go module: dagger 0.4s
┃ writing dagger.gen.go
┃ writing go.mod
┃ writing go.sum
┃ writing main.go
┃ creating directory querybuilder
┃ writing querybuilder/marshal.go
┃ writing querybuilder/querybuilder.go
┃ needs another pass...
Error: failed to generate code: input: resolve: moduleSource: withName: withSDK: withSourceSubpath: resolveFromCaller: asModule: failed to create module: failed to update codegen and runtime: failed to generate code: failed to get modified source directory for go module sdk codegen: process "/usr/local/bin/codegen --module-context /src --module-name dagger --propagate-logs=true --introspection-json-path /schema.json" did not complete successfully: exit code: 1
Stderr:
Error: load package ".": package name is empty
```
Originally reported by @nipuna-perera on discord: <https://discord.com/channels/707636530424053791/1206727343918293042>
(reproduced in dagger v0.9.10) | https://github.com/dagger/dagger/issues/6659 | https://github.com/dagger/dagger/pull/6678 | b1afa431038bc0a96e4783b30d34b5c8f67f6488 | 31ddf2787ec1e05fb4ad00c33df767796063705f | 2024-02-13T13:35:20Z | go | 2024-02-18T23:23:31Z | core/integration/module_test.go | sdk string
source string
}
t.Run("id", func(t *testing.T) {
t.Parallel()
t.Run("arg", func(t *testing.T) {
t.Parallel()
for _, tc := range []testCase{
{
sdk: "go",
source: badIDArgGoSrc,
},
{
sdk: "python",
source: badIDArgPySrc,
},
{
sdk: "typescript",
source: badIDArgTSSrc,
},
} {
tc := tc |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,659 | Error running `dagger init`: `package name is empty` | To reproduce this, try initializing a dagger module in a directory that already contains a `go.work`. For example:
```
$ git clone https://github.com/dagger/dagger.git
$ go work init
$ dagger init --sdk=go
✘ ModuleSource.asModule: Module! 2.0s
✘ Module.withSource(
source: ✔ ModuleSource.resolveFromCaller: ModuleSource! 0.0s
): Module! 2.0s
✘ Container.directory(path: "/src"): Directory! 1.4s
✔ rm /dagger/dagger.gen.go 0.4s
✘ exec /usr/local/bin/codegen --module-context /src --module-name dagger --propagate-logs=true --introspection-json-path /schema.json 0.9s
┃ Error: load package ".": package name is empty
✘ generating go module: dagger 0.4s
┃ writing dagger.gen.go
┃ writing go.mod
┃ writing go.sum
┃ writing main.go
┃ creating directory querybuilder
┃ writing querybuilder/marshal.go
┃ writing querybuilder/querybuilder.go
┃ needs another pass...
Error: failed to generate code: input: resolve: moduleSource: withName: withSDK: withSourceSubpath: resolveFromCaller: asModule: failed to create module: failed to update codegen and runtime: failed to generate code: failed to get modified source directory for go module sdk codegen: process "/usr/local/bin/codegen --module-context /src --module-name dagger --propagate-logs=true --introspection-json-path /schema.json" did not complete successfully: exit code: 1
Stderr:
Error: load package ".": package name is empty
```
Originally reported by @nipuna-perera on discord: <https://discord.com/channels/707636530424053791/1206727343918293042>
(reproduced in dagger v0.9.10) | https://github.com/dagger/dagger/issues/6659 | https://github.com/dagger/dagger/pull/6678 | b1afa431038bc0a96e4783b30d34b5c8f67f6488 | 31ddf2787ec1e05fb4ad00c33df767796063705f | 2024-02-13T13:35:20Z | go | 2024-02-18T23:23:31Z | core/integration/module_test.go | t.Run(tc.sdk, func(t *testing.T) {
t.Parallel()
c, ctx := connect(t)
_, err := modInit(ctx, t, c, tc.sdk, tc.source).
With(daggerQuery(`{test{fn(id:"no")}}`)).
Sync(ctx)
require.ErrorContains(t, err, "cannot define argument with reserved name \"id\"")
})
}
})
t.Run("field", func(t *testing.T) {
t.Parallel()
for _, tc := range []testCase{
{
sdk: "go",
source: badIDFieldGoSrc,
},
{
sdk: "typescript",
source: badIDFieldTSSrc,
},
} {
tc := tc
t.Run(tc.sdk, func(t *testing.T) {
t.Parallel()
c, ctx := connect(t)
_, err := c.Container().From(golangImage).
WithMountedFile(testCLIBinPath, daggerCliFile(t, c)).
WithWorkdir("/work").
With(daggerExec("init", "--name=test", "--sdk="+tc.sdk)). |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,659 | Error running `dagger init`: `package name is empty` | To reproduce this, try initializing a dagger module in a directory that already contains a `go.work`. For example:
```
$ git clone https://github.com/dagger/dagger.git
$ go work init
$ dagger init --sdk=go
✘ ModuleSource.asModule: Module! 2.0s
✘ Module.withSource(
source: ✔ ModuleSource.resolveFromCaller: ModuleSource! 0.0s
): Module! 2.0s
✘ Container.directory(path: "/src"): Directory! 1.4s
✔ rm /dagger/dagger.gen.go 0.4s
✘ exec /usr/local/bin/codegen --module-context /src --module-name dagger --propagate-logs=true --introspection-json-path /schema.json 0.9s
┃ Error: load package ".": package name is empty
✘ generating go module: dagger 0.4s
┃ writing dagger.gen.go
┃ writing go.mod
┃ writing go.sum
┃ writing main.go
┃ creating directory querybuilder
┃ writing querybuilder/marshal.go
┃ writing querybuilder/querybuilder.go
┃ needs another pass...
Error: failed to generate code: input: resolve: moduleSource: withName: withSDK: withSourceSubpath: resolveFromCaller: asModule: failed to create module: failed to update codegen and runtime: failed to generate code: failed to get modified source directory for go module sdk codegen: process "/usr/local/bin/codegen --module-context /src --module-name dagger --propagate-logs=true --introspection-json-path /schema.json" did not complete successfully: exit code: 1
Stderr:
Error: load package ".": package name is empty
```
Originally reported by @nipuna-perera on discord: <https://discord.com/channels/707636530424053791/1206727343918293042>
(reproduced in dagger v0.9.10) | https://github.com/dagger/dagger/issues/6659 | https://github.com/dagger/dagger/pull/6678 | b1afa431038bc0a96e4783b30d34b5c8f67f6488 | 31ddf2787ec1e05fb4ad00c33df767796063705f | 2024-02-13T13:35:20Z | go | 2024-02-18T23:23:31Z | core/integration/module_test.go | With(sdkSource(tc.sdk, tc.source)).
With(daggerQuery(`{test{fn{id}}}`)).
Sync(ctx)
require.ErrorContains(t, err, "cannot define field with reserved name \"id\"")
})
}
})
t.Run("fn", func(t *testing.T) {
t.Parallel()
for _, tc := range []testCase{
{
sdk: "go",
source: badIDFnGoSrc,
},
{
sdk: "python",
source: badIDFnPySrc,
},
{
sdk: "typescript",
source: badIDFnTSSrc,
},
} {
tc := tc
t.Run(tc.sdk, func(t *testing.T) {
t.Parallel()
c, ctx := connect(t)
_, err := c.Container().From(golangImage).
WithMountedFile(testCLIBinPath, daggerCliFile(t, c)).
WithWorkdir("/work"). |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,659 | Error running `dagger init`: `package name is empty` | To reproduce this, try initializing a dagger module in a directory that already contains a `go.work`. For example:
```
$ git clone https://github.com/dagger/dagger.git
$ go work init
$ dagger init --sdk=go
✘ ModuleSource.asModule: Module! 2.0s
✘ Module.withSource(
source: ✔ ModuleSource.resolveFromCaller: ModuleSource! 0.0s
): Module! 2.0s
✘ Container.directory(path: "/src"): Directory! 1.4s
✔ rm /dagger/dagger.gen.go 0.4s
✘ exec /usr/local/bin/codegen --module-context /src --module-name dagger --propagate-logs=true --introspection-json-path /schema.json 0.9s
┃ Error: load package ".": package name is empty
✘ generating go module: dagger 0.4s
┃ writing dagger.gen.go
┃ writing go.mod
┃ writing go.sum
┃ writing main.go
┃ creating directory querybuilder
┃ writing querybuilder/marshal.go
┃ writing querybuilder/querybuilder.go
┃ needs another pass...
Error: failed to generate code: input: resolve: moduleSource: withName: withSDK: withSourceSubpath: resolveFromCaller: asModule: failed to create module: failed to update codegen and runtime: failed to generate code: failed to get modified source directory for go module sdk codegen: process "/usr/local/bin/codegen --module-context /src --module-name dagger --propagate-logs=true --introspection-json-path /schema.json" did not complete successfully: exit code: 1
Stderr:
Error: load package ".": package name is empty
```
Originally reported by @nipuna-perera on discord: <https://discord.com/channels/707636530424053791/1206727343918293042>
(reproduced in dagger v0.9.10) | https://github.com/dagger/dagger/issues/6659 | https://github.com/dagger/dagger/pull/6678 | b1afa431038bc0a96e4783b30d34b5c8f67f6488 | 31ddf2787ec1e05fb4ad00c33df767796063705f | 2024-02-13T13:35:20Z | go | 2024-02-18T23:23:31Z | core/integration/module_test.go | With(daggerExec("init", "--name=test", "--sdk="+tc.sdk)).
With(sdkSource(tc.sdk, tc.source)).
With(daggerQuery(`{test{id}}`)).
Sync(ctx)
require.ErrorContains(t, err, "cannot define function with reserved name \"id\"")
})
}
})
})
}
func TestModuleExecError(t *testing.T) {
t.Parallel()
c, ctx := connect(t)
modGen := c.Container().From(alpineImage).
WithMountedFile(testCLIBinPath, daggerCliFile(t, c)).
WithWorkdir("/work").
With(daggerExec("init", "--source=.", "--name=playground", "--sdk=go")).
WithNewFile("main.go", dagger.ContainerWithNewFileOpts{
Contents: `
package main
import (
"context"
"errors"
)
type Playground struct{}
func (p *Playground) DoThing(ctx context.Context) error {
_, err := dag.Container().From("` + alpineImage + `").WithExec([]string{"sh", "-c", "exit 5"}).Sync(ctx)
var e *ExecError
if errors.As(err, &e) {
if e.ExitCode == 5 { |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,659 | Error running `dagger init`: `package name is empty` | To reproduce this, try initializing a dagger module in a directory that already contains a `go.work`. For example:
```
$ git clone https://github.com/dagger/dagger.git
$ go work init
$ dagger init --sdk=go
✘ ModuleSource.asModule: Module! 2.0s
✘ Module.withSource(
source: ✔ ModuleSource.resolveFromCaller: ModuleSource! 0.0s
): Module! 2.0s
✘ Container.directory(path: "/src"): Directory! 1.4s
✔ rm /dagger/dagger.gen.go 0.4s
✘ exec /usr/local/bin/codegen --module-context /src --module-name dagger --propagate-logs=true --introspection-json-path /schema.json 0.9s
┃ Error: load package ".": package name is empty
✘ generating go module: dagger 0.4s
┃ writing dagger.gen.go
┃ writing go.mod
┃ writing go.sum
┃ writing main.go
┃ creating directory querybuilder
┃ writing querybuilder/marshal.go
┃ writing querybuilder/querybuilder.go
┃ needs another pass...
Error: failed to generate code: input: resolve: moduleSource: withName: withSDK: withSourceSubpath: resolveFromCaller: asModule: failed to create module: failed to update codegen and runtime: failed to generate code: failed to get modified source directory for go module sdk codegen: process "/usr/local/bin/codegen --module-context /src --module-name dagger --propagate-logs=true --introspection-json-path /schema.json" did not complete successfully: exit code: 1
Stderr:
Error: load package ".": package name is empty
```
Originally reported by @nipuna-perera on discord: <https://discord.com/channels/707636530424053791/1206727343918293042>
(reproduced in dagger v0.9.10) | https://github.com/dagger/dagger/issues/6659 | https://github.com/dagger/dagger/pull/6678 | b1afa431038bc0a96e4783b30d34b5c8f67f6488 | 31ddf2787ec1e05fb4ad00c33df767796063705f | 2024-02-13T13:35:20Z | go | 2024-02-18T23:23:31Z | core/integration/module_test.go | return nil
}
}
panic("yikes")
}
`})
_, err := modGen.
With(daggerQuery(`{playground{doThing}}`)).
Stdout(ctx)
require.NoError(t, err)
}
func TestModuleCurrentModuleAPI(t *testing.T) {
t.Parallel()
t.Run("name", func(t *testing.T) {
t.Parallel()
c, ctx := connect(t)
out, err := c.Container().From(golangImage).
WithMountedFile(testCLIBinPath, daggerCliFile(t, c)).
WithWorkdir("/work").
With(daggerExec("init", "--source=.", "--name=WaCkY", "--sdk=go")).
WithNewFile("/work/main.go", dagger.ContainerWithNewFileOpts{
Contents: `package main
import "context"
type WaCkY struct {}
func (m *WaCkY) Fn(ctx context.Context) (string, error) {
return dag.CurrentModule().Name(ctx)
}
`,
}).
With(daggerCall("fn")). |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,659 | Error running `dagger init`: `package name is empty` | To reproduce this, try initializing a dagger module in a directory that already contains a `go.work`. For example:
```
$ git clone https://github.com/dagger/dagger.git
$ go work init
$ dagger init --sdk=go
✘ ModuleSource.asModule: Module! 2.0s
✘ Module.withSource(
source: ✔ ModuleSource.resolveFromCaller: ModuleSource! 0.0s
): Module! 2.0s
✘ Container.directory(path: "/src"): Directory! 1.4s
✔ rm /dagger/dagger.gen.go 0.4s
✘ exec /usr/local/bin/codegen --module-context /src --module-name dagger --propagate-logs=true --introspection-json-path /schema.json 0.9s
┃ Error: load package ".": package name is empty
✘ generating go module: dagger 0.4s
┃ writing dagger.gen.go
┃ writing go.mod
┃ writing go.sum
┃ writing main.go
┃ creating directory querybuilder
┃ writing querybuilder/marshal.go
┃ writing querybuilder/querybuilder.go
┃ needs another pass...
Error: failed to generate code: input: resolve: moduleSource: withName: withSDK: withSourceSubpath: resolveFromCaller: asModule: failed to create module: failed to update codegen and runtime: failed to generate code: failed to get modified source directory for go module sdk codegen: process "/usr/local/bin/codegen --module-context /src --module-name dagger --propagate-logs=true --introspection-json-path /schema.json" did not complete successfully: exit code: 1
Stderr:
Error: load package ".": package name is empty
```
Originally reported by @nipuna-perera on discord: <https://discord.com/channels/707636530424053791/1206727343918293042>
(reproduced in dagger v0.9.10) | https://github.com/dagger/dagger/issues/6659 | https://github.com/dagger/dagger/pull/6678 | b1afa431038bc0a96e4783b30d34b5c8f67f6488 | 31ddf2787ec1e05fb4ad00c33df767796063705f | 2024-02-13T13:35:20Z | go | 2024-02-18T23:23:31Z | core/integration/module_test.go | Stdout(ctx)
require.NoError(t, err)
require.Equal(t, "WaCkY", strings.TrimSpace(out))
})
t.Run("source", func(t *testing.T) {
t.Parallel()
c, ctx := connect(t)
out, err := c.Container().From(golangImage).
WithMountedFile(testCLIBinPath, daggerCliFile(t, c)).
WithWorkdir("/work").
With(daggerExec("init", "--source=.", "--name=test", "--sdk=go")).
WithNewFile("/work/subdir/coolfile.txt", dagger.ContainerWithNewFileOpts{
Contents: "nice",
}).
WithNewFile("/work/main.go", dagger.ContainerWithNewFileOpts{
Contents: `package main
import "context"
type Test struct {}
func (m *Test) Fn(ctx context.Context) *File {
return dag.CurrentModule().Source().File("subdir/coolfile.txt")
}
`,
}).
With(daggerCall("fn", "contents")).
Stdout(ctx)
require.NoError(t, err)
require.Equal(t, "nice", strings.TrimSpace(out))
})
t.Run("workdir", func(t *testing.T) {
t.Parallel() |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,659 | Error running `dagger init`: `package name is empty` | To reproduce this, try initializing a dagger module in a directory that already contains a `go.work`. For example:
```
$ git clone https://github.com/dagger/dagger.git
$ go work init
$ dagger init --sdk=go
✘ ModuleSource.asModule: Module! 2.0s
✘ Module.withSource(
source: ✔ ModuleSource.resolveFromCaller: ModuleSource! 0.0s
): Module! 2.0s
✘ Container.directory(path: "/src"): Directory! 1.4s
✔ rm /dagger/dagger.gen.go 0.4s
✘ exec /usr/local/bin/codegen --module-context /src --module-name dagger --propagate-logs=true --introspection-json-path /schema.json 0.9s
┃ Error: load package ".": package name is empty
✘ generating go module: dagger 0.4s
┃ writing dagger.gen.go
┃ writing go.mod
┃ writing go.sum
┃ writing main.go
┃ creating directory querybuilder
┃ writing querybuilder/marshal.go
┃ writing querybuilder/querybuilder.go
┃ needs another pass...
Error: failed to generate code: input: resolve: moduleSource: withName: withSDK: withSourceSubpath: resolveFromCaller: asModule: failed to create module: failed to update codegen and runtime: failed to generate code: failed to get modified source directory for go module sdk codegen: process "/usr/local/bin/codegen --module-context /src --module-name dagger --propagate-logs=true --introspection-json-path /schema.json" did not complete successfully: exit code: 1
Stderr:
Error: load package ".": package name is empty
```
Originally reported by @nipuna-perera on discord: <https://discord.com/channels/707636530424053791/1206727343918293042>
(reproduced in dagger v0.9.10) | https://github.com/dagger/dagger/issues/6659 | https://github.com/dagger/dagger/pull/6678 | b1afa431038bc0a96e4783b30d34b5c8f67f6488 | 31ddf2787ec1e05fb4ad00c33df767796063705f | 2024-02-13T13:35:20Z | go | 2024-02-18T23:23:31Z | core/integration/module_test.go | t.Run("dir", func(t *testing.T) {
t.Parallel()
c, ctx := connect(t)
out, err := c.Container().From(golangImage).
WithMountedFile(testCLIBinPath, daggerCliFile(t, c)).
WithWorkdir("/work").
With(daggerExec("init", "--source=.", "--name=test", "--sdk=go")).
WithNewFile("/work/main.go", dagger.ContainerWithNewFileOpts{
Contents: `package main
import (
"context"
"os"
)
type Test struct {}
func (m *Test) Fn(ctx context.Context) (*Directory, error) {
if err := os.MkdirAll("subdir/moresubdir", 0755); err != nil {
return nil, err
}
if err := os.WriteFile("subdir/moresubdir/coolfile.txt", []byte("nice"), 0644); err != nil {
return nil, err
}
return dag.CurrentModule().Workdir("subdir/moresubdir"), nil
}
`,
}).
With(daggerCall("fn", "file", "--path=coolfile.txt", "contents")).
Stdout(ctx)
require.NoError(t, err)
require.Equal(t, "nice", strings.TrimSpace(out))
}) |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,659 | Error running `dagger init`: `package name is empty` | To reproduce this, try initializing a dagger module in a directory that already contains a `go.work`. For example:
```
$ git clone https://github.com/dagger/dagger.git
$ go work init
$ dagger init --sdk=go
✘ ModuleSource.asModule: Module! 2.0s
✘ Module.withSource(
source: ✔ ModuleSource.resolveFromCaller: ModuleSource! 0.0s
): Module! 2.0s
✘ Container.directory(path: "/src"): Directory! 1.4s
✔ rm /dagger/dagger.gen.go 0.4s
✘ exec /usr/local/bin/codegen --module-context /src --module-name dagger --propagate-logs=true --introspection-json-path /schema.json 0.9s
┃ Error: load package ".": package name is empty
✘ generating go module: dagger 0.4s
┃ writing dagger.gen.go
┃ writing go.mod
┃ writing go.sum
┃ writing main.go
┃ creating directory querybuilder
┃ writing querybuilder/marshal.go
┃ writing querybuilder/querybuilder.go
┃ needs another pass...
Error: failed to generate code: input: resolve: moduleSource: withName: withSDK: withSourceSubpath: resolveFromCaller: asModule: failed to create module: failed to update codegen and runtime: failed to generate code: failed to get modified source directory for go module sdk codegen: process "/usr/local/bin/codegen --module-context /src --module-name dagger --propagate-logs=true --introspection-json-path /schema.json" did not complete successfully: exit code: 1
Stderr:
Error: load package ".": package name is empty
```
Originally reported by @nipuna-perera on discord: <https://discord.com/channels/707636530424053791/1206727343918293042>
(reproduced in dagger v0.9.10) | https://github.com/dagger/dagger/issues/6659 | https://github.com/dagger/dagger/pull/6678 | b1afa431038bc0a96e4783b30d34b5c8f67f6488 | 31ddf2787ec1e05fb4ad00c33df767796063705f | 2024-02-13T13:35:20Z | go | 2024-02-18T23:23:31Z | core/integration/module_test.go | t.Run("file", func(t *testing.T) {
t.Parallel()
c, ctx := connect(t)
out, err := c.Container().From(golangImage).
WithMountedFile(testCLIBinPath, daggerCliFile(t, c)).
WithWorkdir("/work").
With(daggerExec("init", "--source=.", "--name=test", "--sdk=go")).
WithNewFile("/work/main.go", dagger.ContainerWithNewFileOpts{
Contents: `package main
import (
"context"
"os"
)
type Test struct {}
func (m *Test) Fn(ctx context.Context) (*File, error) {
if err := os.MkdirAll("subdir/moresubdir", 0755); err != nil {
return nil, err
}
if err := os.WriteFile("subdir/moresubdir/coolfile.txt", []byte("nice"), 0644); err != nil {
return nil, err
}
return dag.CurrentModule().WorkdirFile("subdir/moresubdir/coolfile.txt"), nil
}
`,
}).
With(daggerCall("fn", "contents")).
Stdout(ctx)
require.NoError(t, err)
require.Equal(t, "nice", strings.TrimSpace(out))
}) |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,659 | Error running `dagger init`: `package name is empty` | To reproduce this, try initializing a dagger module in a directory that already contains a `go.work`. For example:
```
$ git clone https://github.com/dagger/dagger.git
$ go work init
$ dagger init --sdk=go
✘ ModuleSource.asModule: Module! 2.0s
✘ Module.withSource(
source: ✔ ModuleSource.resolveFromCaller: ModuleSource! 0.0s
): Module! 2.0s
✘ Container.directory(path: "/src"): Directory! 1.4s
✔ rm /dagger/dagger.gen.go 0.4s
✘ exec /usr/local/bin/codegen --module-context /src --module-name dagger --propagate-logs=true --introspection-json-path /schema.json 0.9s
┃ Error: load package ".": package name is empty
✘ generating go module: dagger 0.4s
┃ writing dagger.gen.go
┃ writing go.mod
┃ writing go.sum
┃ writing main.go
┃ creating directory querybuilder
┃ writing querybuilder/marshal.go
┃ writing querybuilder/querybuilder.go
┃ needs another pass...
Error: failed to generate code: input: resolve: moduleSource: withName: withSDK: withSourceSubpath: resolveFromCaller: asModule: failed to create module: failed to update codegen and runtime: failed to generate code: failed to get modified source directory for go module sdk codegen: process "/usr/local/bin/codegen --module-context /src --module-name dagger --propagate-logs=true --introspection-json-path /schema.json" did not complete successfully: exit code: 1
Stderr:
Error: load package ".": package name is empty
```
Originally reported by @nipuna-perera on discord: <https://discord.com/channels/707636530424053791/1206727343918293042>
(reproduced in dagger v0.9.10) | https://github.com/dagger/dagger/issues/6659 | https://github.com/dagger/dagger/pull/6678 | b1afa431038bc0a96e4783b30d34b5c8f67f6488 | 31ddf2787ec1e05fb4ad00c33df767796063705f | 2024-02-13T13:35:20Z | go | 2024-02-18T23:23:31Z | core/integration/module_test.go | t.Run("error on escape", func(t *testing.T) {
t.Parallel()
c, ctx := connect(t)
ctr := c.Container().From(golangImage).
WithMountedFile(testCLIBinPath, daggerCliFile(t, c)).
WithWorkdir("/work").
With(daggerExec("init", "--source=.", "--name=test", "--sdk=go")).
WithNewFile("/work/main.go", dagger.ContainerWithNewFileOpts{
Contents: `package main
import (
"context"
"os"
)
func New() (*Test, error) {
if err := os.WriteFile("/rootfile.txt", []byte("notnice"), 0644); err != nil {
return nil, err
}
if err := os.MkdirAll("/foo", 0755); err != nil {
return nil, err
}
if err := os.WriteFile("/foo/foofile.txt", []byte("notnice"), 0644); err != nil {
return nil, err
}
return &Test{}, nil
}
type Test struct {}
func (m *Test) EscapeFile(ctx context.Context) *File {
return dag.CurrentModule().WorkdirFile("../rootfile.txt")
}
func (m *Test) EscapeFileAbs(ctx context.Context) *File { |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,659 | Error running `dagger init`: `package name is empty` | To reproduce this, try initializing a dagger module in a directory that already contains a `go.work`. For example:
```
$ git clone https://github.com/dagger/dagger.git
$ go work init
$ dagger init --sdk=go
✘ ModuleSource.asModule: Module! 2.0s
✘ Module.withSource(
source: ✔ ModuleSource.resolveFromCaller: ModuleSource! 0.0s
): Module! 2.0s
✘ Container.directory(path: "/src"): Directory! 1.4s
✔ rm /dagger/dagger.gen.go 0.4s
✘ exec /usr/local/bin/codegen --module-context /src --module-name dagger --propagate-logs=true --introspection-json-path /schema.json 0.9s
┃ Error: load package ".": package name is empty
✘ generating go module: dagger 0.4s
┃ writing dagger.gen.go
┃ writing go.mod
┃ writing go.sum
┃ writing main.go
┃ creating directory querybuilder
┃ writing querybuilder/marshal.go
┃ writing querybuilder/querybuilder.go
┃ needs another pass...
Error: failed to generate code: input: resolve: moduleSource: withName: withSDK: withSourceSubpath: resolveFromCaller: asModule: failed to create module: failed to update codegen and runtime: failed to generate code: failed to get modified source directory for go module sdk codegen: process "/usr/local/bin/codegen --module-context /src --module-name dagger --propagate-logs=true --introspection-json-path /schema.json" did not complete successfully: exit code: 1
Stderr:
Error: load package ".": package name is empty
```
Originally reported by @nipuna-perera on discord: <https://discord.com/channels/707636530424053791/1206727343918293042>
(reproduced in dagger v0.9.10) | https://github.com/dagger/dagger/issues/6659 | https://github.com/dagger/dagger/pull/6678 | b1afa431038bc0a96e4783b30d34b5c8f67f6488 | 31ddf2787ec1e05fb4ad00c33df767796063705f | 2024-02-13T13:35:20Z | go | 2024-02-18T23:23:31Z | core/integration/module_test.go | return dag.CurrentModule().WorkdirFile("/rootfile.txt")
}
func (m *Test) EscapeDir(ctx context.Context) *Directory {
return dag.CurrentModule().Workdir("../foo")
}
func (m *Test) EscapeDirAbs(ctx context.Context) *Directory {
return dag.CurrentModule().Workdir("/foo")
}
`,
})
_, err := ctr.
With(daggerCall("escape-file", "contents")).
Stdout(ctx)
require.ErrorContains(t, err, `workdir path "../rootfile.txt" escapes workdir`)
_, err = ctr.
With(daggerCall("escape-file-abs", "contents")).
Stdout(ctx)
require.ErrorContains(t, err, `workdir path "/rootfile.txt" escapes workdir`)
_, err = ctr.
With(daggerCall("escape-dir", "entries")).
Stdout(ctx)
require.ErrorContains(t, err, `workdir path "../foo" escapes workdir`)
_, err = ctr.
With(daggerCall("escape-dir-abs", "entries")).
Stdout(ctx)
require.ErrorContains(t, err, `workdir path "/foo" escapes workdir`)
})
})
}
func TestModuleCustomSDK(t *testing.T) { |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,659 | Error running `dagger init`: `package name is empty` | To reproduce this, try initializing a dagger module in a directory that already contains a `go.work`. For example:
```
$ git clone https://github.com/dagger/dagger.git
$ go work init
$ dagger init --sdk=go
✘ ModuleSource.asModule: Module! 2.0s
✘ Module.withSource(
source: ✔ ModuleSource.resolveFromCaller: ModuleSource! 0.0s
): Module! 2.0s
✘ Container.directory(path: "/src"): Directory! 1.4s
✔ rm /dagger/dagger.gen.go 0.4s
✘ exec /usr/local/bin/codegen --module-context /src --module-name dagger --propagate-logs=true --introspection-json-path /schema.json 0.9s
┃ Error: load package ".": package name is empty
✘ generating go module: dagger 0.4s
┃ writing dagger.gen.go
┃ writing go.mod
┃ writing go.sum
┃ writing main.go
┃ creating directory querybuilder
┃ writing querybuilder/marshal.go
┃ writing querybuilder/querybuilder.go
┃ needs another pass...
Error: failed to generate code: input: resolve: moduleSource: withName: withSDK: withSourceSubpath: resolveFromCaller: asModule: failed to create module: failed to update codegen and runtime: failed to generate code: failed to get modified source directory for go module sdk codegen: process "/usr/local/bin/codegen --module-context /src --module-name dagger --propagate-logs=true --introspection-json-path /schema.json" did not complete successfully: exit code: 1
Stderr:
Error: load package ".": package name is empty
```
Originally reported by @nipuna-perera on discord: <https://discord.com/channels/707636530424053791/1206727343918293042>
(reproduced in dagger v0.9.10) | https://github.com/dagger/dagger/issues/6659 | https://github.com/dagger/dagger/pull/6678 | b1afa431038bc0a96e4783b30d34b5c8f67f6488 | 31ddf2787ec1e05fb4ad00c33df767796063705f | 2024-02-13T13:35:20Z | go | 2024-02-18T23:23:31Z | core/integration/module_test.go | t.Parallel()
c, ctx := connect(t)
ctr := c.Container().From(golangImage).
WithMountedFile(testCLIBinPath, daggerCliFile(t, c)).
WithWorkdir("/work/coolsdk").
With(daggerExec("init", "--source=.", "--name=cool-sdk", "--sdk=go")).
WithNewFile("main.go", dagger.ContainerWithNewFileOpts{
Contents: `package main
type CoolSdk struct {}
func (m *CoolSdk) ModuleRuntime(modSource *ModuleSource, introspectionJson string) *Container {
return modSource.WithSDK("go").AsModule().Runtime().WithEnvVariable("COOL", "true")
}
func (m *CoolSdk) Codegen(modSource *ModuleSource, introspectionJson string) *GeneratedCode {
return dag.GeneratedCode(modSource.WithSDK("go").AsModule().GeneratedContextDirectory())
} |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,659 | Error running `dagger init`: `package name is empty` | To reproduce this, try initializing a dagger module in a directory that already contains a `go.work`. For example:
```
$ git clone https://github.com/dagger/dagger.git
$ go work init
$ dagger init --sdk=go
✘ ModuleSource.asModule: Module! 2.0s
✘ Module.withSource(
source: ✔ ModuleSource.resolveFromCaller: ModuleSource! 0.0s
): Module! 2.0s
✘ Container.directory(path: "/src"): Directory! 1.4s
✔ rm /dagger/dagger.gen.go 0.4s
✘ exec /usr/local/bin/codegen --module-context /src --module-name dagger --propagate-logs=true --introspection-json-path /schema.json 0.9s
┃ Error: load package ".": package name is empty
✘ generating go module: dagger 0.4s
┃ writing dagger.gen.go
┃ writing go.mod
┃ writing go.sum
┃ writing main.go
┃ creating directory querybuilder
┃ writing querybuilder/marshal.go
┃ writing querybuilder/querybuilder.go
┃ needs another pass...
Error: failed to generate code: input: resolve: moduleSource: withName: withSDK: withSourceSubpath: resolveFromCaller: asModule: failed to create module: failed to update codegen and runtime: failed to generate code: failed to get modified source directory for go module sdk codegen: process "/usr/local/bin/codegen --module-context /src --module-name dagger --propagate-logs=true --introspection-json-path /schema.json" did not complete successfully: exit code: 1
Stderr:
Error: load package ".": package name is empty
```
Originally reported by @nipuna-perera on discord: <https://discord.com/channels/707636530424053791/1206727343918293042>
(reproduced in dagger v0.9.10) | https://github.com/dagger/dagger/issues/6659 | https://github.com/dagger/dagger/pull/6678 | b1afa431038bc0a96e4783b30d34b5c8f67f6488 | 31ddf2787ec1e05fb4ad00c33df767796063705f | 2024-02-13T13:35:20Z | go | 2024-02-18T23:23:31Z | core/integration/module_test.go | func (m *CoolSdk) RequiredPaths() []string {
return []string{
"**/go.mod",
"**/go.sum",
"**/go.work",
"**/go.work.sum",
"**/vendor/",
"**/*.go",
}
}
`,
}).
WithWorkdir("/work").
With(daggerExec("init", "--source=.", "--name=test", "--sdk=coolsdk")).
WithNewFile("main.go", dagger.ContainerWithNewFileOpts{
Contents: `package main
import "os"
type Test struct {}
func (m *Test) Fn() string {
return os.Getenv("COOL")
}
`,
})
out, err := ctr.
With(daggerCall("fn")).
Stdout(ctx)
require.NoError(t, err)
require.Equal(t, "true", strings.TrimSpace(out))
}
func TestModuleHostError(t *testing.T) { |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,659 | Error running `dagger init`: `package name is empty` | To reproduce this, try initializing a dagger module in a directory that already contains a `go.work`. For example:
```
$ git clone https://github.com/dagger/dagger.git
$ go work init
$ dagger init --sdk=go
✘ ModuleSource.asModule: Module! 2.0s
✘ Module.withSource(
source: ✔ ModuleSource.resolveFromCaller: ModuleSource! 0.0s
): Module! 2.0s
✘ Container.directory(path: "/src"): Directory! 1.4s
✔ rm /dagger/dagger.gen.go 0.4s
✘ exec /usr/local/bin/codegen --module-context /src --module-name dagger --propagate-logs=true --introspection-json-path /schema.json 0.9s
┃ Error: load package ".": package name is empty
✘ generating go module: dagger 0.4s
┃ writing dagger.gen.go
┃ writing go.mod
┃ writing go.sum
┃ writing main.go
┃ creating directory querybuilder
┃ writing querybuilder/marshal.go
┃ writing querybuilder/querybuilder.go
┃ needs another pass...
Error: failed to generate code: input: resolve: moduleSource: withName: withSDK: withSourceSubpath: resolveFromCaller: asModule: failed to create module: failed to update codegen and runtime: failed to generate code: failed to get modified source directory for go module sdk codegen: process "/usr/local/bin/codegen --module-context /src --module-name dagger --propagate-logs=true --introspection-json-path /schema.json" did not complete successfully: exit code: 1
Stderr:
Error: load package ".": package name is empty
```
Originally reported by @nipuna-perera on discord: <https://discord.com/channels/707636530424053791/1206727343918293042>
(reproduced in dagger v0.9.10) | https://github.com/dagger/dagger/issues/6659 | https://github.com/dagger/dagger/pull/6678 | b1afa431038bc0a96e4783b30d34b5c8f67f6488 | 31ddf2787ec1e05fb4ad00c33df767796063705f | 2024-02-13T13:35:20Z | go | 2024-02-18T23:23:31Z | core/integration/module_test.go | t.Parallel()
c, ctx := connect(t)
_, err := c.Container().From(golangImage).
WithMountedFile(testCLIBinPath, daggerCliFile(t, c)).
WithWorkdir("/work").
With(daggerExec("init", "--source=.", "--name=test", "--sdk=go")).
WithNewFile("/work/main.go", dagger.ContainerWithNewFileOpts{
Contents: `package main
import (
"context"
)
type Test struct {}
func (m *Test) Fn(ctx context.Context) *Directory {
return dag.Host().Directory(".")
}
`,
}).
With(daggerCall("fn")).
Sync(ctx)
require.ErrorContains(t, err, "dag.Host undefined")
}
func daggerExec(args ...string) dagger.WithContainerFunc { |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,659 | Error running `dagger init`: `package name is empty` | To reproduce this, try initializing a dagger module in a directory that already contains a `go.work`. For example:
```
$ git clone https://github.com/dagger/dagger.git
$ go work init
$ dagger init --sdk=go
✘ ModuleSource.asModule: Module! 2.0s
✘ Module.withSource(
source: ✔ ModuleSource.resolveFromCaller: ModuleSource! 0.0s
): Module! 2.0s
✘ Container.directory(path: "/src"): Directory! 1.4s
✔ rm /dagger/dagger.gen.go 0.4s
✘ exec /usr/local/bin/codegen --module-context /src --module-name dagger --propagate-logs=true --introspection-json-path /schema.json 0.9s
┃ Error: load package ".": package name is empty
✘ generating go module: dagger 0.4s
┃ writing dagger.gen.go
┃ writing go.mod
┃ writing go.sum
┃ writing main.go
┃ creating directory querybuilder
┃ writing querybuilder/marshal.go
┃ writing querybuilder/querybuilder.go
┃ needs another pass...
Error: failed to generate code: input: resolve: moduleSource: withName: withSDK: withSourceSubpath: resolveFromCaller: asModule: failed to create module: failed to update codegen and runtime: failed to generate code: failed to get modified source directory for go module sdk codegen: process "/usr/local/bin/codegen --module-context /src --module-name dagger --propagate-logs=true --introspection-json-path /schema.json" did not complete successfully: exit code: 1
Stderr:
Error: load package ".": package name is empty
```
Originally reported by @nipuna-perera on discord: <https://discord.com/channels/707636530424053791/1206727343918293042>
(reproduced in dagger v0.9.10) | https://github.com/dagger/dagger/issues/6659 | https://github.com/dagger/dagger/pull/6678 | b1afa431038bc0a96e4783b30d34b5c8f67f6488 | 31ddf2787ec1e05fb4ad00c33df767796063705f | 2024-02-13T13:35:20Z | go | 2024-02-18T23:23:31Z | core/integration/module_test.go | return func(c *dagger.Container) *dagger.Container {
return c.WithExec(append([]string{"dagger", "--debug"}, args...), dagger.ContainerWithExecOpts{
ExperimentalPrivilegedNesting: true,
})
}
}
func daggerQuery(query string, args ...any) dagger.WithContainerFunc {
return daggerQueryAt("", query, args...)
}
func daggerQueryAt(modPath string, query string, args ...any) dagger.WithContainerFunc {
query = fmt.Sprintf(query, args...)
return func(c *dagger.Container) *dagger.Container {
execArgs := []string{"dagger", "--debug", "query"}
if modPath != "" {
execArgs = append(execArgs, "-m", modPath)
}
return c.WithExec(execArgs, dagger.ContainerWithExecOpts{
Stdin: query,
ExperimentalPrivilegedNesting: true,
})
}
}
func daggerCall(args ...string) dagger.WithContainerFunc {
return daggerCallAt("", args...)
}
func daggerCallAt(modPath string, args ...string) dagger.WithContainerFunc { |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,659 | Error running `dagger init`: `package name is empty` | To reproduce this, try initializing a dagger module in a directory that already contains a `go.work`. For example:
```
$ git clone https://github.com/dagger/dagger.git
$ go work init
$ dagger init --sdk=go
✘ ModuleSource.asModule: Module! 2.0s
✘ Module.withSource(
source: ✔ ModuleSource.resolveFromCaller: ModuleSource! 0.0s
): Module! 2.0s
✘ Container.directory(path: "/src"): Directory! 1.4s
✔ rm /dagger/dagger.gen.go 0.4s
✘ exec /usr/local/bin/codegen --module-context /src --module-name dagger --propagate-logs=true --introspection-json-path /schema.json 0.9s
┃ Error: load package ".": package name is empty
✘ generating go module: dagger 0.4s
┃ writing dagger.gen.go
┃ writing go.mod
┃ writing go.sum
┃ writing main.go
┃ creating directory querybuilder
┃ writing querybuilder/marshal.go
┃ writing querybuilder/querybuilder.go
┃ needs another pass...
Error: failed to generate code: input: resolve: moduleSource: withName: withSDK: withSourceSubpath: resolveFromCaller: asModule: failed to create module: failed to update codegen and runtime: failed to generate code: failed to get modified source directory for go module sdk codegen: process "/usr/local/bin/codegen --module-context /src --module-name dagger --propagate-logs=true --introspection-json-path /schema.json" did not complete successfully: exit code: 1
Stderr:
Error: load package ".": package name is empty
```
Originally reported by @nipuna-perera on discord: <https://discord.com/channels/707636530424053791/1206727343918293042>
(reproduced in dagger v0.9.10) | https://github.com/dagger/dagger/issues/6659 | https://github.com/dagger/dagger/pull/6678 | b1afa431038bc0a96e4783b30d34b5c8f67f6488 | 31ddf2787ec1e05fb4ad00c33df767796063705f | 2024-02-13T13:35:20Z | go | 2024-02-18T23:23:31Z | core/integration/module_test.go | return func(c *dagger.Container) *dagger.Container {
execArgs := []string{"dagger", "--debug", "call"}
if modPath != "" {
execArgs = append(execArgs, "-m", modPath)
}
return c.WithExec(append(execArgs, args...), dagger.ContainerWithExecOpts{
ExperimentalPrivilegedNesting: true,
})
}
}
func daggerFunctions(args ...string) dagger.WithContainerFunc {
return func(c *dagger.Container) *dagger.Container {
return c.WithExec(append([]string{"dagger", "--debug", "functions"}, args...), dagger.ContainerWithExecOpts{
ExperimentalPrivilegedNesting: true,
})
}
}
func configFile(dirPath string, cfg *modules.ModuleConfig) dagger.WithContainerFunc {
return func(c *dagger.Container) *dagger.Container {
cfgPath := filepath.Join(dirPath, "dagger.json")
cfgBytes, err := json.Marshal(cfg)
if err != nil {
panic(err)
}
return c.WithNewFile(cfgPath, dagger.ContainerWithNewFileOpts{
Contents: string(cfgBytes),
})
}
}
func hostDaggerCommand(ctx context.Context, t testing.TB, workdir string, args ...string) *exec.Cmd { |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,659 | Error running `dagger init`: `package name is empty` | To reproduce this, try initializing a dagger module in a directory that already contains a `go.work`. For example:
```
$ git clone https://github.com/dagger/dagger.git
$ go work init
$ dagger init --sdk=go
✘ ModuleSource.asModule: Module! 2.0s
✘ Module.withSource(
source: ✔ ModuleSource.resolveFromCaller: ModuleSource! 0.0s
): Module! 2.0s
✘ Container.directory(path: "/src"): Directory! 1.4s
✔ rm /dagger/dagger.gen.go 0.4s
✘ exec /usr/local/bin/codegen --module-context /src --module-name dagger --propagate-logs=true --introspection-json-path /schema.json 0.9s
┃ Error: load package ".": package name is empty
✘ generating go module: dagger 0.4s
┃ writing dagger.gen.go
┃ writing go.mod
┃ writing go.sum
┃ writing main.go
┃ creating directory querybuilder
┃ writing querybuilder/marshal.go
┃ writing querybuilder/querybuilder.go
┃ needs another pass...
Error: failed to generate code: input: resolve: moduleSource: withName: withSDK: withSourceSubpath: resolveFromCaller: asModule: failed to create module: failed to update codegen and runtime: failed to generate code: failed to get modified source directory for go module sdk codegen: process "/usr/local/bin/codegen --module-context /src --module-name dagger --propagate-logs=true --introspection-json-path /schema.json" did not complete successfully: exit code: 1
Stderr:
Error: load package ".": package name is empty
```
Originally reported by @nipuna-perera on discord: <https://discord.com/channels/707636530424053791/1206727343918293042>
(reproduced in dagger v0.9.10) | https://github.com/dagger/dagger/issues/6659 | https://github.com/dagger/dagger/pull/6678 | b1afa431038bc0a96e4783b30d34b5c8f67f6488 | 31ddf2787ec1e05fb4ad00c33df767796063705f | 2024-02-13T13:35:20Z | go | 2024-02-18T23:23:31Z | core/integration/module_test.go | t.Helper()
cmd := exec.CommandContext(ctx, daggerCliPath(t), args...)
cmd.Dir = workdir
return cmd
}
func hostDaggerExec(ctx context.Context, t testing.TB, workdir string, args ...string) ([]byte, error) {
t.Helper()
cmd := hostDaggerCommand(ctx, t, workdir, args...)
output, err := cmd.CombinedOutput()
if err != nil {
err = fmt.Errorf("%s: %w", string(output), err)
}
return output, err
}
func sdkSource(sdk, contents string) dagger.WithContainerFunc {
return func(c *dagger.Container) *dagger.Container {
sourcePath := sdkSourceFile(sdk)
if sourcePath == "" {
return c
}
return c.WithNewFile(sourcePath, dagger.ContainerWithNewFileOpts{
Contents: heredoc.Doc(contents),
})
}
}
func sdkSourceFile(sdk string) string { |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,659 | Error running `dagger init`: `package name is empty` | To reproduce this, try initializing a dagger module in a directory that already contains a `go.work`. For example:
```
$ git clone https://github.com/dagger/dagger.git
$ go work init
$ dagger init --sdk=go
✘ ModuleSource.asModule: Module! 2.0s
✘ Module.withSource(
source: ✔ ModuleSource.resolveFromCaller: ModuleSource! 0.0s
): Module! 2.0s
✘ Container.directory(path: "/src"): Directory! 1.4s
✔ rm /dagger/dagger.gen.go 0.4s
✘ exec /usr/local/bin/codegen --module-context /src --module-name dagger --propagate-logs=true --introspection-json-path /schema.json 0.9s
┃ Error: load package ".": package name is empty
✘ generating go module: dagger 0.4s
┃ writing dagger.gen.go
┃ writing go.mod
┃ writing go.sum
┃ writing main.go
┃ creating directory querybuilder
┃ writing querybuilder/marshal.go
┃ writing querybuilder/querybuilder.go
┃ needs another pass...
Error: failed to generate code: input: resolve: moduleSource: withName: withSDK: withSourceSubpath: resolveFromCaller: asModule: failed to create module: failed to update codegen and runtime: failed to generate code: failed to get modified source directory for go module sdk codegen: process "/usr/local/bin/codegen --module-context /src --module-name dagger --propagate-logs=true --introspection-json-path /schema.json" did not complete successfully: exit code: 1
Stderr:
Error: load package ".": package name is empty
```
Originally reported by @nipuna-perera on discord: <https://discord.com/channels/707636530424053791/1206727343918293042>
(reproduced in dagger v0.9.10) | https://github.com/dagger/dagger/issues/6659 | https://github.com/dagger/dagger/pull/6678 | b1afa431038bc0a96e4783b30d34b5c8f67f6488 | 31ddf2787ec1e05fb4ad00c33df767796063705f | 2024-02-13T13:35:20Z | go | 2024-02-18T23:23:31Z | core/integration/module_test.go | switch sdk {
case "go":
return "dagger/main.go"
case "python":
return "dagger/src/main.py"
case "typescript":
return "dagger/src/index.ts"
default:
return ""
}
}
func sdkCodegenFile(t *testing.T, sdk string) string {
t.Helper()
switch sdk {
case "go":
return "dagger/dagger.gen.go"
case "python":
return "dagger/sdk/src/dagger/client/gen.py"
case "typescript":
return "dagger/sdk/api/client.gen.ts"
default:
return ""
}
}
func modInit(ctx context.Context, t *testing.T, c *dagger.Client, sdk, contents string) *dagger.Container { |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,659 | Error running `dagger init`: `package name is empty` | To reproduce this, try initializing a dagger module in a directory that already contains a `go.work`. For example:
```
$ git clone https://github.com/dagger/dagger.git
$ go work init
$ dagger init --sdk=go
✘ ModuleSource.asModule: Module! 2.0s
✘ Module.withSource(
source: ✔ ModuleSource.resolveFromCaller: ModuleSource! 0.0s
): Module! 2.0s
✘ Container.directory(path: "/src"): Directory! 1.4s
✔ rm /dagger/dagger.gen.go 0.4s
✘ exec /usr/local/bin/codegen --module-context /src --module-name dagger --propagate-logs=true --introspection-json-path /schema.json 0.9s
┃ Error: load package ".": package name is empty
✘ generating go module: dagger 0.4s
┃ writing dagger.gen.go
┃ writing go.mod
┃ writing go.sum
┃ writing main.go
┃ creating directory querybuilder
┃ writing querybuilder/marshal.go
┃ writing querybuilder/querybuilder.go
┃ needs another pass...
Error: failed to generate code: input: resolve: moduleSource: withName: withSDK: withSourceSubpath: resolveFromCaller: asModule: failed to create module: failed to update codegen and runtime: failed to generate code: failed to get modified source directory for go module sdk codegen: process "/usr/local/bin/codegen --module-context /src --module-name dagger --propagate-logs=true --introspection-json-path /schema.json" did not complete successfully: exit code: 1
Stderr:
Error: load package ".": package name is empty
```
Originally reported by @nipuna-perera on discord: <https://discord.com/channels/707636530424053791/1206727343918293042>
(reproduced in dagger v0.9.10) | https://github.com/dagger/dagger/issues/6659 | https://github.com/dagger/dagger/pull/6678 | b1afa431038bc0a96e4783b30d34b5c8f67f6488 | 31ddf2787ec1e05fb4ad00c33df767796063705f | 2024-02-13T13:35:20Z | go | 2024-02-18T23:23:31Z | core/integration/module_test.go | t.Helper()
modGen := c.Container().From(golangImage).
WithMountedFile(testCLIBinPath, daggerCliFile(t, c)).
WithWorkdir("/work").
With(daggerExec("init", "--name=test", "--sdk="+sdk)).
With(sdkSource(sdk, contents))
return modGen
}
func currentSchema(ctx context.Context, t *testing.T, ctr *dagger.Container) *introspection.Schema {
t.Helper()
out, err := ctr.With(daggerQuery(introspection.Query)).Stdout(ctx)
require.NoError(t, err)
var schemaResp introspection.Response
err = json.Unmarshal([]byte(out), &schemaResp)
require.NoError(t, err)
return schemaResp.Schema
}
var moduleIntrospection = daggerQuery(`
query { host { directory(path: ".") { asModule { initialize {
description |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,659 | Error running `dagger init`: `package name is empty` | To reproduce this, try initializing a dagger module in a directory that already contains a `go.work`. For example:
```
$ git clone https://github.com/dagger/dagger.git
$ go work init
$ dagger init --sdk=go
✘ ModuleSource.asModule: Module! 2.0s
✘ Module.withSource(
source: ✔ ModuleSource.resolveFromCaller: ModuleSource! 0.0s
): Module! 2.0s
✘ Container.directory(path: "/src"): Directory! 1.4s
✔ rm /dagger/dagger.gen.go 0.4s
✘ exec /usr/local/bin/codegen --module-context /src --module-name dagger --propagate-logs=true --introspection-json-path /schema.json 0.9s
┃ Error: load package ".": package name is empty
✘ generating go module: dagger 0.4s
┃ writing dagger.gen.go
┃ writing go.mod
┃ writing go.sum
┃ writing main.go
┃ creating directory querybuilder
┃ writing querybuilder/marshal.go
┃ writing querybuilder/querybuilder.go
┃ needs another pass...
Error: failed to generate code: input: resolve: moduleSource: withName: withSDK: withSourceSubpath: resolveFromCaller: asModule: failed to create module: failed to update codegen and runtime: failed to generate code: failed to get modified source directory for go module sdk codegen: process "/usr/local/bin/codegen --module-context /src --module-name dagger --propagate-logs=true --introspection-json-path /schema.json" did not complete successfully: exit code: 1
Stderr:
Error: load package ".": package name is empty
```
Originally reported by @nipuna-perera on discord: <https://discord.com/channels/707636530424053791/1206727343918293042>
(reproduced in dagger v0.9.10) | https://github.com/dagger/dagger/issues/6659 | https://github.com/dagger/dagger/pull/6678 | b1afa431038bc0a96e4783b30d34b5c8f67f6488 | 31ddf2787ec1e05fb4ad00c33df767796063705f | 2024-02-13T13:35:20Z | go | 2024-02-18T23:23:31Z | core/integration/module_test.go | objects {
asObject {
name
description
constructor {
description
args {
name
description
defaultValue
}
}
functions {
name
description
args {
name
description
defaultValue
}
}
fields {
name
description
}
}
}
} } } } }
`)
func inspectModule(ctx context.Context, t *testing.T, ctr *dagger.Container) gjson.Result { |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,659 | Error running `dagger init`: `package name is empty` | To reproduce this, try initializing a dagger module in a directory that already contains a `go.work`. For example:
```
$ git clone https://github.com/dagger/dagger.git
$ go work init
$ dagger init --sdk=go
✘ ModuleSource.asModule: Module! 2.0s
✘ Module.withSource(
source: ✔ ModuleSource.resolveFromCaller: ModuleSource! 0.0s
): Module! 2.0s
✘ Container.directory(path: "/src"): Directory! 1.4s
✔ rm /dagger/dagger.gen.go 0.4s
✘ exec /usr/local/bin/codegen --module-context /src --module-name dagger --propagate-logs=true --introspection-json-path /schema.json 0.9s
┃ Error: load package ".": package name is empty
✘ generating go module: dagger 0.4s
┃ writing dagger.gen.go
┃ writing go.mod
┃ writing go.sum
┃ writing main.go
┃ creating directory querybuilder
┃ writing querybuilder/marshal.go
┃ writing querybuilder/querybuilder.go
┃ needs another pass...
Error: failed to generate code: input: resolve: moduleSource: withName: withSDK: withSourceSubpath: resolveFromCaller: asModule: failed to create module: failed to update codegen and runtime: failed to generate code: failed to get modified source directory for go module sdk codegen: process "/usr/local/bin/codegen --module-context /src --module-name dagger --propagate-logs=true --introspection-json-path /schema.json" did not complete successfully: exit code: 1
Stderr:
Error: load package ".": package name is empty
```
Originally reported by @nipuna-perera on discord: <https://discord.com/channels/707636530424053791/1206727343918293042>
(reproduced in dagger v0.9.10) | https://github.com/dagger/dagger/issues/6659 | https://github.com/dagger/dagger/pull/6678 | b1afa431038bc0a96e4783b30d34b5c8f67f6488 | 31ddf2787ec1e05fb4ad00c33df767796063705f | 2024-02-13T13:35:20Z | go | 2024-02-18T23:23:31Z | core/integration/module_test.go | t.Helper()
out, err := ctr.With(moduleIntrospection).Stdout(ctx)
require.NoError(t, err)
result := gjson.Get(out, "host.directory.asModule.initialize")
t.Logf("module introspection:\n%v", result.Raw)
return result
}
func inspectModuleObjects(ctx context.Context, t *testing.T, ctr *dagger.Container) gjson.Result {
t.Helper()
return inspectModule(ctx, t, ctr).Get("objects.#.asObject")
}
func goGitBase(t *testing.T, c *dagger.Client) *dagger.Container {
t.Helper()
return c.Container().From(golangImage).
WithExec([]string{"apk", "add", "git"}).
WithExec([]string{"git", "config", "--global", "user.email", "dagger@example.com"}).
WithExec([]string{"git", "config", "--global", "user.name", "Dagger Tests"}).
WithMountedFile(testCLIBinPath, daggerCliFile(t, c)).
WithWorkdir("/work").
WithExec([]string{"git", "init"})
}
func logGen(ctx context.Context, t *testing.T, modSrc *dagger.Directory) { |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,659 | Error running `dagger init`: `package name is empty` | To reproduce this, try initializing a dagger module in a directory that already contains a `go.work`. For example:
```
$ git clone https://github.com/dagger/dagger.git
$ go work init
$ dagger init --sdk=go
✘ ModuleSource.asModule: Module! 2.0s
✘ Module.withSource(
source: ✔ ModuleSource.resolveFromCaller: ModuleSource! 0.0s
): Module! 2.0s
✘ Container.directory(path: "/src"): Directory! 1.4s
✔ rm /dagger/dagger.gen.go 0.4s
✘ exec /usr/local/bin/codegen --module-context /src --module-name dagger --propagate-logs=true --introspection-json-path /schema.json 0.9s
┃ Error: load package ".": package name is empty
✘ generating go module: dagger 0.4s
┃ writing dagger.gen.go
┃ writing go.mod
┃ writing go.sum
┃ writing main.go
┃ creating directory querybuilder
┃ writing querybuilder/marshal.go
┃ writing querybuilder/querybuilder.go
┃ needs another pass...
Error: failed to generate code: input: resolve: moduleSource: withName: withSDK: withSourceSubpath: resolveFromCaller: asModule: failed to create module: failed to update codegen and runtime: failed to generate code: failed to get modified source directory for go module sdk codegen: process "/usr/local/bin/codegen --module-context /src --module-name dagger --propagate-logs=true --introspection-json-path /schema.json" did not complete successfully: exit code: 1
Stderr:
Error: load package ".": package name is empty
```
Originally reported by @nipuna-perera on discord: <https://discord.com/channels/707636530424053791/1206727343918293042>
(reproduced in dagger v0.9.10) | https://github.com/dagger/dagger/issues/6659 | https://github.com/dagger/dagger/pull/6678 | b1afa431038bc0a96e4783b30d34b5c8f67f6488 | 31ddf2787ec1e05fb4ad00c33df767796063705f | 2024-02-13T13:35:20Z | go | 2024-02-18T23:23:31Z | core/integration/module_test.go | t.Helper()
generated, err := modSrc.File("dagger.gen.go").Contents(ctx)
require.NoError(t, err)
t.Cleanup(func() {
t.Name()
fileName := filepath.Join(
os.TempDir(),
t.Name(),
fmt.Sprintf("dagger.gen.%d.go", time.Now().Unix()),
)
if err := os.MkdirAll(filepath.Dir(fileName), 0o755); err != nil {
t.Logf("failed to create temp dir for generated code: %v", err)
return
}
if err := os.WriteFile(fileName, []byte(generated), 0644); err != nil {
t.Logf("failed to write generated code to %s: %v", fileName, err)
} else {
t.Logf("wrote generated code to %s", fileName)
}
})
} |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,664 | Unable to reference remote modules by short name | Version: 0.9.10
What I expect to work:
```sh
dagger init
dagger install github.com/shykes/daggerverse/hello
dagger -m hello functions
```
What I get:
`Error: failed to get configured module: failed to get local root path: input: resolve: moduleSource: resolveContextPathFromCaller: cannot resolve non-local module source from caller`
Additionally, when I run `dagger -m hello functions`, I get local files created mimicking the module's remote ref:
```sh
$ tree github.com
github.com
└── shykes
└── daggerverse
└── hello@ac880927d5368eaf2e5d94450e587732753df1a6
3 directories, 0 files
``` | https://github.com/dagger/dagger/issues/6664 | https://github.com/dagger/dagger/pull/6668 | 430ea3a7fec9f4e88584e1aa352a7e43c083e518 | 41a311347e4d8539b2206903a5e93acaf1108d34 | 2024-02-13T17:43:20Z | go | 2024-02-19T17:06:53Z | cmd/dagger/module.go | package main
import (
"context"
"encoding/json"
"fmt"
"net/http"
"net/url"
"os"
"path"
"path/filepath"
"strings"
"dagger.io/dagger"
"github.com/dagger/dagger/analytics"
"github.com/dagger/dagger/core/modules"
"github.com/dagger/dagger/dagql/idtui"
"github.com/dagger/dagger/engine/client"
"github.com/go-git/go-git/v5"
"github.com/iancoleman/strcase"
"github.com/juju/ansiterm/tabwriter"
"github.com/moby/buildkit/util/gitutil"
"github.com/spf13/cobra"
"github.com/spf13/pflag"
"github.com/vito/progrock"
)
var (
moduleGroup = &cobra.Group{
ID: "module",
Title: "Dagger Module Commands (Experimental)",
}
moduleURL string |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,664 | Unable to reference remote modules by short name | Version: 0.9.10
What I expect to work:
```sh
dagger init
dagger install github.com/shykes/daggerverse/hello
dagger -m hello functions
```
What I get:
`Error: failed to get configured module: failed to get local root path: input: resolve: moduleSource: resolveContextPathFromCaller: cannot resolve non-local module source from caller`
Additionally, when I run `dagger -m hello functions`, I get local files created mimicking the module's remote ref:
```sh
$ tree github.com
github.com
└── shykes
└── daggerverse
└── hello@ac880927d5368eaf2e5d94450e587732753df1a6
3 directories, 0 files
``` | https://github.com/dagger/dagger/issues/6664 | https://github.com/dagger/dagger/pull/6668 | 430ea3a7fec9f4e88584e1aa352a7e43c083e518 | 41a311347e4d8539b2206903a5e93acaf1108d34 | 2024-02-13T17:43:20Z | go | 2024-02-19T17:06:53Z | cmd/dagger/module.go | moduleFlags = pflag.NewFlagSet("module", pflag.ContinueOnError)
sdk string
licenseID string
moduleName string
moduleSourcePath string
installName string
developSDK string
developSourcePath string
force bool
)
const (
moduleURLDefault = "."
defaultModuleSourceDirName = "dagger"
)
func init() {
moduleFlags.StringVarP(&moduleURL, "mod", "m", "", "Path to dagger.json config file for the module or a directory containing that file. Either local path (e.g. \"/path/to/some/dir\") or a github repo (e.g. \"github.com/dagger/dagger/path/to/some/subdir\")")
moduleFlags.BoolVar(&focus, "focus", true, "Only show output for focused commands")
listenCmd.PersistentFlags().AddFlagSet(moduleFlags)
queryCmd.PersistentFlags().AddFlagSet(moduleFlags)
funcCmds.AddFlagSet(moduleFlags)
moduleInitCmd.Flags().StringVar(&sdk, "sdk", "", "Optionally initialize module for development in the given SDK")
moduleInitCmd.Flags().StringVar(&moduleName, "name", "", "Name of the new module (defaults to parent directory name)")
moduleInitCmd.Flags().StringVar(&moduleSourcePath, "source", "", "Directory to store the module implementation source code in (defaults to \"dagger/ if \"--sdk\" is provided)")
moduleInitCmd.Flags().StringVar(&licenseID, "license", "", "License identifier to generate - see https:spdx.org/licenses/")
modulePublishCmd.Flags().BoolVarP(&force, "force", "f", false, "Force publish even if the git repository is not clean")
modulePublishCmd.Flags().AddFlagSet(moduleFlags)
moduleInstallCmd.Flags().StringVarP(&installName, "name", "n", "", "Name to use for the dependency in the module. Defaults to the name of the module being installed.")
moduleInstallCmd.Flags().AddFlagSet(moduleFlags)
moduleDevelopCmd.Flags().StringVar(&developSDK, "sdk", "", "New SDK for the module")
moduleDevelopCmd.Flags().StringVar(&developSourcePath, "source", "", "Directory to store the module implementation source code in") |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,664 | Unable to reference remote modules by short name | Version: 0.9.10
What I expect to work:
```sh
dagger init
dagger install github.com/shykes/daggerverse/hello
dagger -m hello functions
```
What I get:
`Error: failed to get configured module: failed to get local root path: input: resolve: moduleSource: resolveContextPathFromCaller: cannot resolve non-local module source from caller`
Additionally, when I run `dagger -m hello functions`, I get local files created mimicking the module's remote ref:
```sh
$ tree github.com
github.com
└── shykes
└── daggerverse
└── hello@ac880927d5368eaf2e5d94450e587732753df1a6
3 directories, 0 files
``` | https://github.com/dagger/dagger/issues/6664 | https://github.com/dagger/dagger/pull/6668 | 430ea3a7fec9f4e88584e1aa352a7e43c083e518 | 41a311347e4d8539b2206903a5e93acaf1108d34 | 2024-02-13T17:43:20Z | go | 2024-02-19T17:06:53Z | cmd/dagger/module.go | moduleDevelopCmd.PersistentFlags().AddFlagSet(moduleFlags)
configCmd.PersistentFlags().AddFlagSet(moduleFlags)
configCmd.AddCommand(oldInitCmd, oldInstallCmd, oldSyncCmd)
configCmd.AddGroup(moduleGroup)
}
var oldInitCmd = &cobra.Command{
Use: "init",
Short: "Initialize a new Dagger module",
Hidden: true,
SilenceUsage: true,
DisableFlagParsing: true,
Args: func(cmd *cobra.Command, args []string) error {
return fmt.Errorf(`"dagger mod init" has been replaced by "dagger init"`)
},
Run: func(cmd *cobra.Command, args []string) {
},
}
var oldInstallCmd = &cobra.Command{
Use: "install",
Short: "Add a new dependency to a Dagger module",
Hidden: true,
SilenceUsage: true,
DisableFlagParsing: true,
GroupID: moduleGroup.ID,
Annotations: map[string]string{
"experimental": "true",
},
Args: func(cmd *cobra.Command, args []string) error {
return fmt.Errorf(`"dagger mod install" has been replaced by "dagger install"`) |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,664 | Unable to reference remote modules by short name | Version: 0.9.10
What I expect to work:
```sh
dagger init
dagger install github.com/shykes/daggerverse/hello
dagger -m hello functions
```
What I get:
`Error: failed to get configured module: failed to get local root path: input: resolve: moduleSource: resolveContextPathFromCaller: cannot resolve non-local module source from caller`
Additionally, when I run `dagger -m hello functions`, I get local files created mimicking the module's remote ref:
```sh
$ tree github.com
github.com
└── shykes
└── daggerverse
└── hello@ac880927d5368eaf2e5d94450e587732753df1a6
3 directories, 0 files
``` | https://github.com/dagger/dagger/issues/6664 | https://github.com/dagger/dagger/pull/6668 | 430ea3a7fec9f4e88584e1aa352a7e43c083e518 | 41a311347e4d8539b2206903a5e93acaf1108d34 | 2024-02-13T17:43:20Z | go | 2024-02-19T17:06:53Z | cmd/dagger/module.go | },
Run: func(cmd *cobra.Command, args []string) {
},
}
var oldSyncCmd = &cobra.Command{
Use: "sync",
Short: "Setup or update all the resources needed to develop on a module locally",
Hidden: true,
SilenceUsage: true,
GroupID: moduleGroup.ID,
Annotations: map[string]string{
"experimental": "true",
},
DisableFlagParsing: true,
Args: func(cmd *cobra.Command, args []string) error {
return fmt.Errorf(`"dagger mod sync" has been replaced by "dagger develop"`)
},
Run: func(cmd *cobra.Command, args []string) {
},
}
var configCmd = &cobra.Command{
Use: "config",
Aliases: []string{"mod"},
Short: "Get or set the configuration of a Dagger module",
Long: "Get or set the configuration of a Dagger module. By default, print the configuration of the specified module.",
Example: strings.TrimSpace(`
dagger config -m /path/to/some/dir
dagger config -m github.com/dagger/hello-dagger |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,664 | Unable to reference remote modules by short name | Version: 0.9.10
What I expect to work:
```sh
dagger init
dagger install github.com/shykes/daggerverse/hello
dagger -m hello functions
```
What I get:
`Error: failed to get configured module: failed to get local root path: input: resolve: moduleSource: resolveContextPathFromCaller: cannot resolve non-local module source from caller`
Additionally, when I run `dagger -m hello functions`, I get local files created mimicking the module's remote ref:
```sh
$ tree github.com
github.com
└── shykes
└── daggerverse
└── hello@ac880927d5368eaf2e5d94450e587732753df1a6
3 directories, 0 files
``` | https://github.com/dagger/dagger/issues/6664 | https://github.com/dagger/dagger/pull/6668 | 430ea3a7fec9f4e88584e1aa352a7e43c083e518 | 41a311347e4d8539b2206903a5e93acaf1108d34 | 2024-02-13T17:43:20Z | go | 2024-02-19T17:06:53Z | cmd/dagger/module.go | `,
),
GroupID: moduleGroup.ID,
Annotations: map[string]string{
"experimental": "true",
},
RunE: func(cmd *cobra.Command, args []string) error {
ctx := cmd.Context()
return withEngineAndTUI(ctx, client.Params{}, func(ctx context.Context, engineClient *client.Client) (err error) {
cmd.SetContext(ctx)
vtx := progrock.FromContext(ctx).Vertex(idtui.PrimaryVertex, cmd.CommandPath())
defer func() { vtx.Done(err) }()
setCmdOutput(cmd, vtx)
modConf, err := getDefaultModuleConfiguration(ctx, engineClient.Dagger(), true)
if err != nil {
return fmt.Errorf("failed to load module: %w", err)
}
if !modConf.FullyInitialized() {
return fmt.Errorf("module must be fully initialized")
}
mod := modConf.Source.AsModule()
name, err := mod.Name(ctx)
if err != nil {
return fmt.Errorf("failed to get module name: %w", err)
}
sdk, err := mod.SDK(ctx)
if err != nil {
return fmt.Errorf("failed to get module SDK: %w", err)
}
tw := tabwriter.NewWriter(cmd.OutOrStdout(), 0, 0, 3, ' ', tabwriter.DiscardEmptyColumns) |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,664 | Unable to reference remote modules by short name | Version: 0.9.10
What I expect to work:
```sh
dagger init
dagger install github.com/shykes/daggerverse/hello
dagger -m hello functions
```
What I get:
`Error: failed to get configured module: failed to get local root path: input: resolve: moduleSource: resolveContextPathFromCaller: cannot resolve non-local module source from caller`
Additionally, when I run `dagger -m hello functions`, I get local files created mimicking the module's remote ref:
```sh
$ tree github.com
github.com
└── shykes
└── daggerverse
└── hello@ac880927d5368eaf2e5d94450e587732753df1a6
3 directories, 0 files
``` | https://github.com/dagger/dagger/issues/6664 | https://github.com/dagger/dagger/pull/6668 | 430ea3a7fec9f4e88584e1aa352a7e43c083e518 | 41a311347e4d8539b2206903a5e93acaf1108d34 | 2024-02-13T17:43:20Z | go | 2024-02-19T17:06:53Z | cmd/dagger/module.go | fmt.Fprintf(tw, "%s\t%s\n",
"Name:",
name,
)
fmt.Fprintf(tw, "%s\t%s\n",
"SDK:",
sdk,
)
fmt.Fprintf(tw, "%s\t%s\n",
"Root Directory:",
modConf.LocalContextPath,
)
fmt.Fprintf(tw, "%s\t%s\n",
"Source Directory:",
modConf.LocalRootSourcePath,
)
return tw.Flush()
})
},
}
var moduleInitCmd = &cobra.Command{
Use: "init [flags] [PATH]",
Short: "Initialize a new Dagger module",
Long: `Initialize a new Dagger module in a local directory.
By default, create a new dagger.json configuration in the current working directory. If the positional argument PATH is provided, create the module in that directory instead.
The configuration will default the name of the module to the parent directory name, unless specified with --name.
Any module can be installed to via "dagger install".
A module can only be called once it has been initialized with an SDK though. The "--sdk" flag can be provided to init here, but if it's not the configuration can be updated later via "dagger develop".
The "--source" flag allows controlling the directory in which the actual module source code is stored. By default, it will be stored in a directory named "dagger".
`, |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,664 | Unable to reference remote modules by short name | Version: 0.9.10
What I expect to work:
```sh
dagger init
dagger install github.com/shykes/daggerverse/hello
dagger -m hello functions
```
What I get:
`Error: failed to get configured module: failed to get local root path: input: resolve: moduleSource: resolveContextPathFromCaller: cannot resolve non-local module source from caller`
Additionally, when I run `dagger -m hello functions`, I get local files created mimicking the module's remote ref:
```sh
$ tree github.com
github.com
└── shykes
└── daggerverse
└── hello@ac880927d5368eaf2e5d94450e587732753df1a6
3 directories, 0 files
``` | https://github.com/dagger/dagger/issues/6664 | https://github.com/dagger/dagger/pull/6668 | 430ea3a7fec9f4e88584e1aa352a7e43c083e518 | 41a311347e4d8539b2206903a5e93acaf1108d34 | 2024-02-13T17:43:20Z | go | 2024-02-19T17:06:53Z | cmd/dagger/module.go | Example: "dagger init --name=hello --sdk=python --source=some/subdir",
GroupID: moduleGroup.ID,
Annotations: map[string]string{
"experimental": "true",
},
Args: cobra.MaximumNArgs(1),
RunE: func(cmd *cobra.Command, extraArgs []string) (rerr error) {
ctx := cmd.Context()
return withEngineAndTUI(ctx, client.Params{}, func(ctx context.Context, engineClient *client.Client) (err error) {
dag := engineClient.Dagger()
vtx := progrock.FromContext(ctx).Vertex(idtui.PrimaryVertex, cmd.CommandPath())
defer func() { vtx.Done(err) }()
setCmdOutput(cmd, vtx)
cwd, err := os.Getwd()
if err != nil {
return fmt.Errorf("failed to get current working directory: %w", err)
}
srcRootPath := cwd
if len(extraArgs) > 0 {
srcRootPath = extraArgs[0]
}
if filepath.IsAbs(srcRootPath) {
srcRootPath, err = filepath.Rel(cwd, srcRootPath)
if err != nil {
return fmt.Errorf("failed to get relative path: %w", err)
}
}
modConf, err := getModuleConfigurationForSourceRef(ctx, dag, srcRootPath, false)
if err != nil { |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,664 | Unable to reference remote modules by short name | Version: 0.9.10
What I expect to work:
```sh
dagger init
dagger install github.com/shykes/daggerverse/hello
dagger -m hello functions
```
What I get:
`Error: failed to get configured module: failed to get local root path: input: resolve: moduleSource: resolveContextPathFromCaller: cannot resolve non-local module source from caller`
Additionally, when I run `dagger -m hello functions`, I get local files created mimicking the module's remote ref:
```sh
$ tree github.com
github.com
└── shykes
└── daggerverse
└── hello@ac880927d5368eaf2e5d94450e587732753df1a6
3 directories, 0 files
``` | https://github.com/dagger/dagger/issues/6664 | https://github.com/dagger/dagger/pull/6668 | 430ea3a7fec9f4e88584e1aa352a7e43c083e518 | 41a311347e4d8539b2206903a5e93acaf1108d34 | 2024-02-13T17:43:20Z | go | 2024-02-19T17:06:53Z | cmd/dagger/module.go | return fmt.Errorf("failed to get configured module: %w", err)
}
if modConf.SourceKind != dagger.LocalSource {
return fmt.Errorf("module must be local")
}
if modConf.ModuleSourceConfigExists {
return fmt.Errorf("module already exists")
}
if moduleName == "" {
moduleName = filepath.Base(modConf.LocalRootSourcePath)
}
if sdk != "" {
if moduleSourcePath == "" {
moduleSourcePath = filepath.Join(modConf.LocalRootSourcePath, defaultModuleSourceDirName)
}
sourceAbsPath, err := filepath.Abs(moduleSourcePath)
if err != nil {
return fmt.Errorf("failed to get absolute source path for %s: %w", moduleSourcePath, err)
}
moduleSourcePath, err = filepath.Rel(modConf.LocalRootSourcePath, sourceAbsPath)
if err != nil {
return fmt.Errorf("failed to get relative source path: %w", err)
}
}
_, err = modConf.Source.
WithName(moduleName).
WithSDK(sdk). |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,664 | Unable to reference remote modules by short name | Version: 0.9.10
What I expect to work:
```sh
dagger init
dagger install github.com/shykes/daggerverse/hello
dagger -m hello functions
```
What I get:
`Error: failed to get configured module: failed to get local root path: input: resolve: moduleSource: resolveContextPathFromCaller: cannot resolve non-local module source from caller`
Additionally, when I run `dagger -m hello functions`, I get local files created mimicking the module's remote ref:
```sh
$ tree github.com
github.com
└── shykes
└── daggerverse
└── hello@ac880927d5368eaf2e5d94450e587732753df1a6
3 directories, 0 files
``` | https://github.com/dagger/dagger/issues/6664 | https://github.com/dagger/dagger/pull/6668 | 430ea3a7fec9f4e88584e1aa352a7e43c083e518 | 41a311347e4d8539b2206903a5e93acaf1108d34 | 2024-02-13T17:43:20Z | go | 2024-02-19T17:06:53Z | cmd/dagger/module.go | WithSourceSubpath(moduleSourcePath).
ResolveFromCaller().
AsModule().
GeneratedContextDiff().
Export(ctx, modConf.LocalContextPath)
if err != nil {
return fmt.Errorf("failed to generate code: %w", err)
}
if err := findOrCreateLicense(ctx, modConf.LocalRootSourcePath); err != nil {
return err
}
fmt.Fprintln(cmd.OutOrStdout(), "Initialized module", moduleName, "in", srcRootPath)
return nil
})
},
}
var moduleInstallCmd = &cobra.Command{
Use: "install [flags] MODULE",
Aliases: []string{"use"},
Short: "Add a new dependency to a Dagger module",
Long: "Add a Dagger module as a dependency of a local module.",
Example: "dagger install github.com/shykes/daggerverse/ttlsh@16e40ec244966e55e36a13cb6e1ff8023e1e1473",
GroupID: moduleGroup.ID,
Annotations: map[string]string{
"experimental": "true",
},
Args: cobra.ExactArgs(1),
RunE: func(cmd *cobra.Command, extraArgs []string) (rerr error) {
ctx := cmd.Context() |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,664 | Unable to reference remote modules by short name | Version: 0.9.10
What I expect to work:
```sh
dagger init
dagger install github.com/shykes/daggerverse/hello
dagger -m hello functions
```
What I get:
`Error: failed to get configured module: failed to get local root path: input: resolve: moduleSource: resolveContextPathFromCaller: cannot resolve non-local module source from caller`
Additionally, when I run `dagger -m hello functions`, I get local files created mimicking the module's remote ref:
```sh
$ tree github.com
github.com
└── shykes
└── daggerverse
└── hello@ac880927d5368eaf2e5d94450e587732753df1a6
3 directories, 0 files
``` | https://github.com/dagger/dagger/issues/6664 | https://github.com/dagger/dagger/pull/6668 | 430ea3a7fec9f4e88584e1aa352a7e43c083e518 | 41a311347e4d8539b2206903a5e93acaf1108d34 | 2024-02-13T17:43:20Z | go | 2024-02-19T17:06:53Z | cmd/dagger/module.go | return withEngineAndTUI(ctx, client.Params{}, func(ctx context.Context, engineClient *client.Client) (err error) {
dag := engineClient.Dagger()
modConf, err := getDefaultModuleConfiguration(ctx, dag, false)
if err != nil {
return fmt.Errorf("failed to get configured module: %w", err)
}
if modConf.SourceKind != dagger.LocalSource {
return fmt.Errorf("module must be local")
}
if !modConf.FullyInitialized() {
return fmt.Errorf("module must be fully initialized")
}
depRefStr := extraArgs[0]
depSrc := dag.ModuleSource(depRefStr)
depSrcKind, err := depSrc.Kind(ctx)
if err != nil {
return fmt.Errorf("failed to get module ref kind: %w", err)
}
if depSrcKind == dagger.LocalSource {
depAbsPath, err := filepath.Abs(depRefStr)
if err != nil {
return fmt.Errorf("failed to get dep absolute path for %s: %w", depRefStr, err)
}
depRelPath, err := filepath.Rel(modConf.LocalRootSourcePath, depAbsPath)
if err != nil {
return fmt.Errorf("failed to get dep relative path: %w", err)
}
depSrc = dag.ModuleSource(depRelPath)
} |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,664 | Unable to reference remote modules by short name | Version: 0.9.10
What I expect to work:
```sh
dagger init
dagger install github.com/shykes/daggerverse/hello
dagger -m hello functions
```
What I get:
`Error: failed to get configured module: failed to get local root path: input: resolve: moduleSource: resolveContextPathFromCaller: cannot resolve non-local module source from caller`
Additionally, when I run `dagger -m hello functions`, I get local files created mimicking the module's remote ref:
```sh
$ tree github.com
github.com
└── shykes
└── daggerverse
└── hello@ac880927d5368eaf2e5d94450e587732753df1a6
3 directories, 0 files
``` | https://github.com/dagger/dagger/issues/6664 | https://github.com/dagger/dagger/pull/6668 | 430ea3a7fec9f4e88584e1aa352a7e43c083e518 | 41a311347e4d8539b2206903a5e93acaf1108d34 | 2024-02-13T17:43:20Z | go | 2024-02-19T17:06:53Z | cmd/dagger/module.go | dep := dag.ModuleDependency(depSrc, dagger.ModuleDependencyOpts{
Name: installName,
})
modSrc := modConf.Source.
WithDependencies([]*dagger.ModuleDependency{dep}).
ResolveFromCaller()
_, err = modSrc.
AsModule().
GeneratedContextDiff().
Export(ctx, modConf.LocalContextPath)
if err != nil {
return fmt.Errorf("failed to generate code: %w", err)
}
depSrc = modSrc.ResolveDependency(depSrc)
name, err := depSrc.ModuleName(ctx)
if err != nil {
return err
}
sdk, err := depSrc.AsModule().SDK(ctx)
if err != nil {
return err
}
depRootSubpath, err := depSrc.SourceRootSubpath(ctx)
if err != nil {
return err
}
if depSrcKind == dagger.GitSource {
git := depSrc.AsGitSource()
gitURL, err := git.CloneURL(ctx)
if err != nil { |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,664 | Unable to reference remote modules by short name | Version: 0.9.10
What I expect to work:
```sh
dagger init
dagger install github.com/shykes/daggerverse/hello
dagger -m hello functions
```
What I get:
`Error: failed to get configured module: failed to get local root path: input: resolve: moduleSource: resolveContextPathFromCaller: cannot resolve non-local module source from caller`
Additionally, when I run `dagger -m hello functions`, I get local files created mimicking the module's remote ref:
```sh
$ tree github.com
github.com
└── shykes
└── daggerverse
└── hello@ac880927d5368eaf2e5d94450e587732753df1a6
3 directories, 0 files
``` | https://github.com/dagger/dagger/issues/6664 | https://github.com/dagger/dagger/pull/6668 | 430ea3a7fec9f4e88584e1aa352a7e43c083e518 | 41a311347e4d8539b2206903a5e93acaf1108d34 | 2024-02-13T17:43:20Z | go | 2024-02-19T17:06:53Z | cmd/dagger/module.go | return err
}
gitVersion, err := git.Version(ctx)
if err != nil {
return err
}
gitCommit, err := git.Commit(ctx)
if err != nil {
return err
}
analytics.Ctx(ctx).Capture(ctx, "module_install", map[string]string{
"module_name": name,
"install_name": installName,
"module_sdk": sdk,
"source_kind": "git",
"git_symbolic": filepath.Join(gitURL, depRootSubpath),
"git_clone_url": gitURL,
"git_subpath": depRootSubpath,
"git_version": gitVersion,
"git_commit": gitCommit,
})
} else if depSrcKind == dagger.LocalSource {
analytics.Ctx(ctx).Capture(ctx, "module_install", map[string]string{
"module_name": name,
"install_name": installName,
"module_sdk": sdk,
"source_kind": "local",
"local_subpath": depRootSubpath,
})
} |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,664 | Unable to reference remote modules by short name | Version: 0.9.10
What I expect to work:
```sh
dagger init
dagger install github.com/shykes/daggerverse/hello
dagger -m hello functions
```
What I get:
`Error: failed to get configured module: failed to get local root path: input: resolve: moduleSource: resolveContextPathFromCaller: cannot resolve non-local module source from caller`
Additionally, when I run `dagger -m hello functions`, I get local files created mimicking the module's remote ref:
```sh
$ tree github.com
github.com
└── shykes
└── daggerverse
└── hello@ac880927d5368eaf2e5d94450e587732753df1a6
3 directories, 0 files
``` | https://github.com/dagger/dagger/issues/6664 | https://github.com/dagger/dagger/pull/6668 | 430ea3a7fec9f4e88584e1aa352a7e43c083e518 | 41a311347e4d8539b2206903a5e93acaf1108d34 | 2024-02-13T17:43:20Z | go | 2024-02-19T17:06:53Z | cmd/dagger/module.go | return nil
})
},
}
var moduleDevelopCmd = &cobra.Command{
Use: "develop",
Short: "Setup or update all the resources needed to develop on a module locally",
Long: `Setup or update all the resources needed to develop on a module locally.
This command re-regerates the module's generated code based on dependencies
and the current state of the module's source code.
If --sdk is set, the config file and generated code will be updated with those values reflected. It currently can only be used to set the SDK of a module that does not have one already.
--source allows controlling the directory in which the actual module source code is stored. By default, it will be stored in a directory named "dagger".
:::note
If not updating source or SDK, this is only required for IDE auto-completion/LSP purposes.
:::
`,
GroupID: moduleGroup.ID,
Annotations: map[string]string{
"experimental": "true",
},
RunE: func(cmd *cobra.Command, extraArgs []string) (rerr error) {
ctx := cmd.Context()
return withEngineAndTUI(ctx, client.Params{}, func(ctx context.Context, engineClient *client.Client) (err error) {
dag := engineClient.Dagger()
modConf, err := getDefaultModuleConfiguration(ctx, dag, false)
if err != nil {
return fmt.Errorf("failed to get configured module: %w", err)
}
if modConf.SourceKind != dagger.LocalSource {
return fmt.Errorf("module must be local") |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,664 | Unable to reference remote modules by short name | Version: 0.9.10
What I expect to work:
```sh
dagger init
dagger install github.com/shykes/daggerverse/hello
dagger -m hello functions
```
What I get:
`Error: failed to get configured module: failed to get local root path: input: resolve: moduleSource: resolveContextPathFromCaller: cannot resolve non-local module source from caller`
Additionally, when I run `dagger -m hello functions`, I get local files created mimicking the module's remote ref:
```sh
$ tree github.com
github.com
└── shykes
└── daggerverse
└── hello@ac880927d5368eaf2e5d94450e587732753df1a6
3 directories, 0 files
``` | https://github.com/dagger/dagger/issues/6664 | https://github.com/dagger/dagger/pull/6668 | 430ea3a7fec9f4e88584e1aa352a7e43c083e518 | 41a311347e4d8539b2206903a5e93acaf1108d34 | 2024-02-13T17:43:20Z | go | 2024-02-19T17:06:53Z | cmd/dagger/module.go | }
src := modConf.Source
modConf.Source = modConf.Source.ResolveFromCaller()
modSDK, err := modConf.Source.AsModule().SDK(ctx)
if err != nil {
return fmt.Errorf("failed to get module SDK: %w", err)
}
if developSDK != "" {
if modSDK != "" && modSDK != developSDK {
return fmt.Errorf("cannot update module SDK that has already been set to %q", modSDK)
}
modSDK = developSDK
src = src.WithSDK(modSDK)
}
modSourcePath, err := modConf.Source.SourceSubpath(ctx)
if err != nil {
return fmt.Errorf("failed to get module source subpath: %w", err)
}
if modSDK != "" && modSourcePath == "" && developSourcePath == "" {
developSourcePath = filepath.Join(modConf.LocalRootSourcePath, defaultModuleSourceDirName)
}
if modSDK == "" && developSourcePath == "" {
return fmt.Errorf("dagger develop on a module without an SDK requires either --sdk or --source")
} |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,664 | Unable to reference remote modules by short name | Version: 0.9.10
What I expect to work:
```sh
dagger init
dagger install github.com/shykes/daggerverse/hello
dagger -m hello functions
```
What I get:
`Error: failed to get configured module: failed to get local root path: input: resolve: moduleSource: resolveContextPathFromCaller: cannot resolve non-local module source from caller`
Additionally, when I run `dagger -m hello functions`, I get local files created mimicking the module's remote ref:
```sh
$ tree github.com
github.com
└── shykes
└── daggerverse
└── hello@ac880927d5368eaf2e5d94450e587732753df1a6
3 directories, 0 files
``` | https://github.com/dagger/dagger/issues/6664 | https://github.com/dagger/dagger/pull/6668 | 430ea3a7fec9f4e88584e1aa352a7e43c083e518 | 41a311347e4d8539b2206903a5e93acaf1108d34 | 2024-02-13T17:43:20Z | go | 2024-02-19T17:06:53Z | cmd/dagger/module.go | if developSourcePath != "" {
sourceAbsPath, err := filepath.Abs(developSourcePath)
if err != nil {
return fmt.Errorf("failed to get absolute source path for %s: %w", developSourcePath, err)
}
developSourcePath, err = filepath.Rel(modConf.LocalRootSourcePath, sourceAbsPath)
if err != nil {
return fmt.Errorf("failed to get relative source path: %w", err)
}
if modSourcePath != "" && modSourcePath != developSourcePath {
return fmt.Errorf("cannot update module source path that has already been set to %q", modSourcePath)
}
modSourcePath = developSourcePath
src = src.WithSourceSubpath(modSourcePath)
}
_, err = src.ResolveFromCaller().
AsModule().
GeneratedContextDiff().
Export(ctx, modConf.LocalContextPath)
if err != nil {
return fmt.Errorf("failed to generate code: %w", err)
}
return nil
})
},
}
const daDaggerverse = "https:daggerverse.dev"
var modulePublishCmd = &cobra.Command{
Use: "publish", |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,664 | Unable to reference remote modules by short name | Version: 0.9.10
What I expect to work:
```sh
dagger init
dagger install github.com/shykes/daggerverse/hello
dagger -m hello functions
```
What I get:
`Error: failed to get configured module: failed to get local root path: input: resolve: moduleSource: resolveContextPathFromCaller: cannot resolve non-local module source from caller`
Additionally, when I run `dagger -m hello functions`, I get local files created mimicking the module's remote ref:
```sh
$ tree github.com
github.com
└── shykes
└── daggerverse
└── hello@ac880927d5368eaf2e5d94450e587732753df1a6
3 directories, 0 files
``` | https://github.com/dagger/dagger/issues/6664 | https://github.com/dagger/dagger/pull/6668 | 430ea3a7fec9f4e88584e1aa352a7e43c083e518 | 41a311347e4d8539b2206903a5e93acaf1108d34 | 2024-02-13T17:43:20Z | go | 2024-02-19T17:06:53Z | cmd/dagger/module.go | Hidden: true,
Short: "Publish a Dagger module to the Daggerverse",
Long: fmt.Sprintf(`Publish a local module to the Daggerverse (%s).
The module needs to be committed to a git repository and have a remote
configured with name "origin". The git repository must be clean (unless
forced), to avoid mistakingly depending on uncommitted files.
`,
daDaggerverse,
),
GroupID: moduleGroup.ID,
Annotations: map[string]string{
"experimental": "true",
},
RunE: func(cmd *cobra.Command, extraArgs []string) (rerr error) {
ctx := cmd.Context()
return withEngineAndTUI(ctx, client.Params{}, func(ctx context.Context, engineClient *client.Client) (err error) {
rec := progrock.FromContext(ctx)
vtx := rec.Vertex(idtui.PrimaryVertex, cmd.CommandPath())
defer func() { vtx.Done(err) }()
setCmdOutput(cmd, vtx)
dag := engineClient.Dagger()
modConf, err := getDefaultModuleConfiguration(ctx, dag, true)
if err != nil {
return fmt.Errorf("failed to get configured module: %w", err)
}
if modConf.SourceKind != dagger.LocalSource {
return fmt.Errorf("module must be local")
}
if !modConf.FullyInitialized() {
return fmt.Errorf("module must be fully initialized") |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,664 | Unable to reference remote modules by short name | Version: 0.9.10
What I expect to work:
```sh
dagger init
dagger install github.com/shykes/daggerverse/hello
dagger -m hello functions
```
What I get:
`Error: failed to get configured module: failed to get local root path: input: resolve: moduleSource: resolveContextPathFromCaller: cannot resolve non-local module source from caller`
Additionally, when I run `dagger -m hello functions`, I get local files created mimicking the module's remote ref:
```sh
$ tree github.com
github.com
└── shykes
└── daggerverse
└── hello@ac880927d5368eaf2e5d94450e587732753df1a6
3 directories, 0 files
``` | https://github.com/dagger/dagger/issues/6664 | https://github.com/dagger/dagger/pull/6668 | 430ea3a7fec9f4e88584e1aa352a7e43c083e518 | 41a311347e4d8539b2206903a5e93acaf1108d34 | 2024-02-13T17:43:20Z | go | 2024-02-19T17:06:53Z | cmd/dagger/module.go | }
repo, err := git.PlainOpenWithOptions(modConf.LocalRootSourcePath, &git.PlainOpenOptions{
DetectDotGit: true,
})
if err != nil {
return fmt.Errorf("failed to open git repo: %w", err)
}
wt, err := repo.Worktree()
if err != nil {
return fmt.Errorf("failed to get git worktree: %w", err)
}
st, err := wt.Status()
if err != nil {
return fmt.Errorf("failed to get git status: %w", err)
}
head, err := repo.Head()
if err != nil {
return fmt.Errorf("failed to get git HEAD: %w", err)
}
commit := head.Hash()
rec.Debug("git commit", progrock.Labelf("commit", commit.String()))
orig, err := repo.Remote("origin")
if err != nil {
return fmt.Errorf("failed to get git remote: %w", err)
}
refPath, err := originToPath(orig.Config().URLs[0])
if err != nil {
return fmt.Errorf("failed to get module path: %w", err)
} |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,664 | Unable to reference remote modules by short name | Version: 0.9.10
What I expect to work:
```sh
dagger init
dagger install github.com/shykes/daggerverse/hello
dagger -m hello functions
```
What I get:
`Error: failed to get configured module: failed to get local root path: input: resolve: moduleSource: resolveContextPathFromCaller: cannot resolve non-local module source from caller`
Additionally, when I run `dagger -m hello functions`, I get local files created mimicking the module's remote ref:
```sh
$ tree github.com
github.com
└── shykes
└── daggerverse
└── hello@ac880927d5368eaf2e5d94450e587732753df1a6
3 directories, 0 files
``` | https://github.com/dagger/dagger/issues/6664 | https://github.com/dagger/dagger/pull/6668 | 430ea3a7fec9f4e88584e1aa352a7e43c083e518 | 41a311347e4d8539b2206903a5e93acaf1108d34 | 2024-02-13T17:43:20Z | go | 2024-02-19T17:06:53Z | cmd/dagger/module.go | gitRoot := wt.Filesystem.Root()
pathFromRoot, err := filepath.Rel(gitRoot, modConf.LocalRootSourcePath)
if err != nil {
return fmt.Errorf("failed to get path from git root: %w", err)
}
if !st.IsClean() && !force {
cmd.Println(st)
return fmt.Errorf("git repository is not clean; run with --force to ignore")
}
refStr := fmt.Sprintf("%s@%s", path.Join(refPath, pathFromRoot), commit)
crawlURL, err := url.JoinPath(daDaggerverse, "crawl")
if err != nil {
return fmt.Errorf("failed to get module URL: %w", err)
}
data := url.Values{}
data.Add("ref", refStr)
req, err := http.NewRequest(http.MethodPut, crawlURL, strings.NewReader(data.Encode()))
if err != nil {
return fmt.Errorf("failed to create request: %w", err)
}
req.Header.Add("Content-Type", "application/x-www-form-urlencoded") |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,664 | Unable to reference remote modules by short name | Version: 0.9.10
What I expect to work:
```sh
dagger init
dagger install github.com/shykes/daggerverse/hello
dagger -m hello functions
```
What I get:
`Error: failed to get configured module: failed to get local root path: input: resolve: moduleSource: resolveContextPathFromCaller: cannot resolve non-local module source from caller`
Additionally, when I run `dagger -m hello functions`, I get local files created mimicking the module's remote ref:
```sh
$ tree github.com
github.com
└── shykes
└── daggerverse
└── hello@ac880927d5368eaf2e5d94450e587732753df1a6
3 directories, 0 files
``` | https://github.com/dagger/dagger/issues/6664 | https://github.com/dagger/dagger/pull/6668 | 430ea3a7fec9f4e88584e1aa352a7e43c083e518 | 41a311347e4d8539b2206903a5e93acaf1108d34 | 2024-02-13T17:43:20Z | go | 2024-02-19T17:06:53Z | cmd/dagger/module.go | res, err := http.DefaultClient.Do(req)
if err != nil {
return fmt.Errorf("failed to get module: %w", err)
}
cmd.Println("Publishing", refStr, "to", daDaggerverse+"...")
cmd.Println()
cmd.Println("You can check on the crawling status here:")
cmd.Println()
cmd.Println(" " + res.Request.URL.String())
modURL, err := url.JoinPath(daDaggerverse, "mod", refStr)
if err != nil {
return fmt.Errorf("failed to get module URL: %w", err)
}
cmd.Println()
cmd.Println("Once the crawl is complete, you can view your module here:")
cmd.Println()
cmd.Println(" " + modURL)
return res.Body.Close()
})
},
}
func originToPath(origin string) (string, error) {
url, err := gitutil.ParseURL(origin)
if err != nil {
return "", fmt.Errorf("failed to parse git remote origin URL: %w", err)
}
return strings.TrimSuffix(path.Join(url.Host, url.Path), ".git"), nil
}
type configuredModule struct { |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,664 | Unable to reference remote modules by short name | Version: 0.9.10
What I expect to work:
```sh
dagger init
dagger install github.com/shykes/daggerverse/hello
dagger -m hello functions
```
What I get:
`Error: failed to get configured module: failed to get local root path: input: resolve: moduleSource: resolveContextPathFromCaller: cannot resolve non-local module source from caller`
Additionally, when I run `dagger -m hello functions`, I get local files created mimicking the module's remote ref:
```sh
$ tree github.com
github.com
└── shykes
└── daggerverse
└── hello@ac880927d5368eaf2e5d94450e587732753df1a6
3 directories, 0 files
``` | https://github.com/dagger/dagger/issues/6664 | https://github.com/dagger/dagger/pull/6668 | 430ea3a7fec9f4e88584e1aa352a7e43c083e518 | 41a311347e4d8539b2206903a5e93acaf1108d34 | 2024-02-13T17:43:20Z | go | 2024-02-19T17:06:53Z | cmd/dagger/module.go | Source *dagger.ModuleSource
SourceKind dagger.ModuleSourceKind
LocalContextPath string
LocalRootSourcePath string
ModuleSourceConfigExists bool
}
func (c *configuredModule) FullyInitialized() bool {
return c.ModuleSourceConfigExists
}
func getDefaultModuleConfiguration( |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,664 | Unable to reference remote modules by short name | Version: 0.9.10
What I expect to work:
```sh
dagger init
dagger install github.com/shykes/daggerverse/hello
dagger -m hello functions
```
What I get:
`Error: failed to get configured module: failed to get local root path: input: resolve: moduleSource: resolveContextPathFromCaller: cannot resolve non-local module source from caller`
Additionally, when I run `dagger -m hello functions`, I get local files created mimicking the module's remote ref:
```sh
$ tree github.com
github.com
└── shykes
└── daggerverse
└── hello@ac880927d5368eaf2e5d94450e587732753df1a6
3 directories, 0 files
``` | https://github.com/dagger/dagger/issues/6664 | https://github.com/dagger/dagger/pull/6668 | 430ea3a7fec9f4e88584e1aa352a7e43c083e518 | 41a311347e4d8539b2206903a5e93acaf1108d34 | 2024-02-13T17:43:20Z | go | 2024-02-19T17:06:53Z | cmd/dagger/module.go | ctx context.Context,
dag *dagger.Client,
resolveFromCaller bool,
) (*configuredModule, error) {
srcRefStr := moduleURL
if srcRefStr == "" {
if v, ok := os.LookupEnv("DAGGER_MODULE"); ok {
srcRefStr = v
}
if srcRefStr == "" {
srcRefStr = moduleURLDefault
}
}
return getModuleConfigurationForSourceRef(ctx, dag, srcRefStr, resolveFromCaller)
}
func getModuleConfigurationForSourceRef( |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,664 | Unable to reference remote modules by short name | Version: 0.9.10
What I expect to work:
```sh
dagger init
dagger install github.com/shykes/daggerverse/hello
dagger -m hello functions
```
What I get:
`Error: failed to get configured module: failed to get local root path: input: resolve: moduleSource: resolveContextPathFromCaller: cannot resolve non-local module source from caller`
Additionally, when I run `dagger -m hello functions`, I get local files created mimicking the module's remote ref:
```sh
$ tree github.com
github.com
└── shykes
└── daggerverse
└── hello@ac880927d5368eaf2e5d94450e587732753df1a6
3 directories, 0 files
``` | https://github.com/dagger/dagger/issues/6664 | https://github.com/dagger/dagger/pull/6668 | 430ea3a7fec9f4e88584e1aa352a7e43c083e518 | 41a311347e4d8539b2206903a5e93acaf1108d34 | 2024-02-13T17:43:20Z | go | 2024-02-19T17:06:53Z | cmd/dagger/module.go | ctx context.Context,
dag *dagger.Client,
srcRefStr string,
resolveFromCaller bool,
) (*configuredModule, error) {
conf := &configuredModule{}
conf.Source = dag.ModuleSource(srcRefStr)
var err error
conf.SourceKind, err = conf.Source.Kind(ctx)
if err != nil { |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,664 | Unable to reference remote modules by short name | Version: 0.9.10
What I expect to work:
```sh
dagger init
dagger install github.com/shykes/daggerverse/hello
dagger -m hello functions
```
What I get:
`Error: failed to get configured module: failed to get local root path: input: resolve: moduleSource: resolveContextPathFromCaller: cannot resolve non-local module source from caller`
Additionally, when I run `dagger -m hello functions`, I get local files created mimicking the module's remote ref:
```sh
$ tree github.com
github.com
└── shykes
└── daggerverse
└── hello@ac880927d5368eaf2e5d94450e587732753df1a6
3 directories, 0 files
``` | https://github.com/dagger/dagger/issues/6664 | https://github.com/dagger/dagger/pull/6668 | 430ea3a7fec9f4e88584e1aa352a7e43c083e518 | 41a311347e4d8539b2206903a5e93acaf1108d34 | 2024-02-13T17:43:20Z | go | 2024-02-19T17:06:53Z | cmd/dagger/module.go | return nil, fmt.Errorf("failed to get module ref kind: %w", err)
}
if conf.SourceKind == dagger.LocalSource {
cwd, err := os.Getwd()
if err != nil {
return nil, fmt.Errorf("failed to get current working directory: %w", err)
}
defaultConfigDir, foundDefaultConfig, err := findUp(cwd)
if err != nil {
return nil, fmt.Errorf("error trying to find config path for %s: %s", cwd, err)
}
if foundDefaultConfig {
configPath := filepath.Join(defaultConfigDir, modules.Filename)
contents, err := os.ReadFile(configPath)
if err != nil {
return nil, fmt.Errorf("failed to read %s: %w", configPath, err)
}
var modCfg modules.ModuleConfig
if err := json.Unmarshal(contents, &modCfg); err != nil {
return nil, fmt.Errorf("failed to unmarshal %s: %s", configPath, err)
}
if namedDep, ok := modCfg.DependencyByName(srcRefStr); ok {
depPath := filepath.Join(defaultConfigDir, namedDep.Source)
srcRefStr = depPath
}
}
conf.LocalRootSourcePath, err = filepath.Abs(srcRefStr)
if err != nil { |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,664 | Unable to reference remote modules by short name | Version: 0.9.10
What I expect to work:
```sh
dagger init
dagger install github.com/shykes/daggerverse/hello
dagger -m hello functions
```
What I get:
`Error: failed to get configured module: failed to get local root path: input: resolve: moduleSource: resolveContextPathFromCaller: cannot resolve non-local module source from caller`
Additionally, when I run `dagger -m hello functions`, I get local files created mimicking the module's remote ref:
```sh
$ tree github.com
github.com
└── shykes
└── daggerverse
└── hello@ac880927d5368eaf2e5d94450e587732753df1a6
3 directories, 0 files
``` | https://github.com/dagger/dagger/issues/6664 | https://github.com/dagger/dagger/pull/6668 | 430ea3a7fec9f4e88584e1aa352a7e43c083e518 | 41a311347e4d8539b2206903a5e93acaf1108d34 | 2024-02-13T17:43:20Z | go | 2024-02-19T17:06:53Z | cmd/dagger/module.go | return nil, fmt.Errorf("failed to get absolute path for %s: %w", srcRefStr, err)
}
if filepath.IsAbs(srcRefStr) {
srcRefStr, err = filepath.Rel(cwd, srcRefStr)
if err != nil {
return nil, fmt.Errorf("failed to get relative path for %s: %w", srcRefStr, err)
}
}
if err := os.MkdirAll(srcRefStr, 0755); err != nil {
return nil, fmt.Errorf("failed to create directory for %s: %w", srcRefStr, err)
}
conf.Source = dag.ModuleSource(srcRefStr)
conf.LocalContextPath, err = conf.Source.ResolveContextPathFromCaller(ctx)
if err != nil {
return nil, fmt.Errorf("failed to get local root path: %w", err)
}
_, err = os.Lstat(filepath.Join(conf.LocalRootSourcePath, modules.Filename))
conf.ModuleSourceConfigExists = err == nil
if resolveFromCaller {
conf.Source = conf.Source.ResolveFromCaller()
}
} else {
conf.ModuleSourceConfigExists, err = conf.Source.ConfigExists(ctx)
if err != nil {
return nil, fmt.Errorf("failed to check if module config exists: %w", err)
}
}
return conf, nil
}
func findUp(curDirPath string) (string, bool, error) { |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,664 | Unable to reference remote modules by short name | Version: 0.9.10
What I expect to work:
```sh
dagger init
dagger install github.com/shykes/daggerverse/hello
dagger -m hello functions
```
What I get:
`Error: failed to get configured module: failed to get local root path: input: resolve: moduleSource: resolveContextPathFromCaller: cannot resolve non-local module source from caller`
Additionally, when I run `dagger -m hello functions`, I get local files created mimicking the module's remote ref:
```sh
$ tree github.com
github.com
└── shykes
└── daggerverse
└── hello@ac880927d5368eaf2e5d94450e587732753df1a6
3 directories, 0 files
``` | https://github.com/dagger/dagger/issues/6664 | https://github.com/dagger/dagger/pull/6668 | 430ea3a7fec9f4e88584e1aa352a7e43c083e518 | 41a311347e4d8539b2206903a5e93acaf1108d34 | 2024-02-13T17:43:20Z | go | 2024-02-19T17:06:53Z | cmd/dagger/module.go | if !filepath.IsAbs(curDirPath) {
return "", false, fmt.Errorf("path is not absolute: %s", curDirPath)
}
configPath := filepath.Join(curDirPath, modules.Filename)
stat, err := os.Lstat(configPath)
switch {
case os.IsNotExist(err):
case err == nil:
if !stat.Mode().IsRegular() {
return "", false, fmt.Errorf("expected %s to be a file", configPath)
}
return curDirPath, true, nil
default:
return "", false, fmt.Errorf("failed to lstat %s: %s", configPath, err)
}
if curDirPath == "/" {
return curDirPath, false, nil
}
_, err = os.Lstat(filepath.Join(curDirPath, ".git"))
if err == nil {
return curDirPath, false, nil
}
parentDirPath := filepath.Dir(curDirPath)
return findUp(parentDirPath)
}
func optionalModCmdWrapper( |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.