status
stringclasses 1
value | repo_name
stringclasses 13
values | repo_url
stringclasses 13
values | issue_id
int64 1
104k
| updated_files
stringlengths 11
1.76k
| title
stringlengths 4
369
| body
stringlengths 0
254k
β | issue_url
stringlengths 38
55
| pull_url
stringlengths 38
53
| before_fix_sha
stringlengths 40
40
| after_fix_sha
stringlengths 40
40
| report_datetime
unknown | language
stringclasses 5
values | commit_datetime
unknown |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
closed | dagger/dagger | https://github.com/dagger/dagger | 2,599 | ["docs/getting-started/1201-ci-environment.md"] | Use wget instead of curl in Gitlab CI example | ### What is the issue?
Hello,
I looked at the Gitlab example [here](https://docs.dagger.io/1201/ci-environment) (which works btw) and wondered why curl is installed for fetching the dagger install.sh instead of just using wget, which is natively available in Linux systems. I am no expert in this matter, but this seems like unnecessary overhead for me.
If using wget, this line could be removed:
`- apk add --no-cache curl`
and the curl line could be replaced with `wget -O - https://dl.dagger.io/dagger/install.sh | sh`
Looking forward for your feedback :) | https://github.com/dagger/dagger/issues/2599 | https://github.com/dagger/dagger/pull/2828 | 8f3ad98eed4efe47a765bb88a614bae2ae4f14f7 | 6f5c3351d017752a24327ad2f92e56b31f4afdfa | "2022-06-09T07:39:12Z" | go | "2022-07-20T22:17:00Z" |
closed | dagger/dagger | https://github.com/dagger/dagger | 2,582 | [".github/workflows/test-experimental-universe.yml", ".github/workflows/test-universe.yml", "ci/bats/bats.cue", "cmd/dagger/cmd/do.go", "pkg/universe.dagger.io/bats_helpers.bash", "tests/helpers.bash", "tests/package.json", "tests/plan.bats", "tests/yarn.lock"] | π `dagger do` help should indicate where to insert action name | ### What is the issue? & Log output
Today if you run `dagger do` or `dagger do --help` you are returned something like
<img width="400" alt="image" src="https://user-images.githubusercontent.com/3187222/172227384-3d9200c2-c2a8-4079-87d5-c1db9293c597.png">
It looks like the proper command syntax is `dagger do [flags]`, but it should be something like:
```
dagger do [action] [flags]
```
Note: `[action]` here could be something like `hello` or something like `hello foo bar` to reference a sub-action.
We should probably note that in the CLI help as well.
```
// Hello world
hello: foo: bar: bash.#Run & {
...
```
<img width="300" alt="image" src="https://user-images.githubusercontent.com/3187222/172233677-3fb84aa8-77e6-4c36-86a2-091488812806.png">
Note: A lot of folks [use conventions for which CLI args are required or optional](https://stackoverflow.com/questions/21503865/how-to-denote-that-a-command-line-argument-is-optional-when-printing-usage). If `[]` means optional, then it's true that it's valid to run `dagger do` _without_ an action name or any flags (i.e. action is optional), but we should show where you'd put those in a valid command by making them both optional, but including them both like suggested above.
### Steps to reproduce
`dagger do`
or
`dagger do -h`
or
`dagger do --help`
### Dagger version
0.2.16
### OS version
macOS 12.3.1[](url) | https://github.com/dagger/dagger/issues/2582 | https://github.com/dagger/dagger/pull/2941 | 8dfbd1956c211ea57d5341b0a12ffb2e8e067c41 | aca2bf927d93ababb22385c1d594e5e204c9d751 | "2022-06-06T18:54:24Z" | go | "2022-08-15T20:47:27Z" |
closed | dagger/dagger | https://github.com/dagger/dagger | 2,580 | ["go.mod", "go.sum"] | show how to use `powershell` package on `arm` machines in test or docs | Today, the `universe.dagger.io/powershell` package's tests employ
`mcr.microsoft.com/powershell` which is only for x86/amd
The Microsoft team has released an image tag for arm32 that works on arm32 and arm64 linux including MacOS: `mcr.microsoft.com/powershell:arm32v7-ubuntu-bionic`
https://github.com/PowerShell/PowerShell-Docker/issues/520#issuecomment-1121468388
| https://github.com/dagger/dagger/issues/2580 | https://github.com/dagger/dagger/pull/1606 | 9641b4254c787b7a297d2e89819b50f4cc00267c | a0395b9340470f267929aba9aa6aab519dea29cc | "2022-06-05T06:38:00Z" | go | "2022-02-14T22:38:59Z" |
closed | dagger/dagger | https://github.com/dagger/dagger | 2,554 | ["docs/core-concepts/1221-action.md"] | How to run single actions within a cue plan | ### What is the issue?
A user has a cue plan with multiple actions, but they want to understand how to run a single actions with the same cue plan. We should clarify how to do this today and provide a real-world example. | https://github.com/dagger/dagger/issues/2554 | https://github.com/dagger/dagger/pull/2870 | b504d40f162a51a7fea6c995a97fec108792e583 | 13e51b25521bc6fe3dfee2a1dad84b36f54fccad | "2022-06-01T22:10:43Z" | go | "2022-08-01T20:47:59Z" |
closed | dagger/dagger | https://github.com/dagger/dagger | 2,512 | ["pkg/universe.dagger.io/docker/build.cue", "pkg/universe.dagger.io/docker/test/build.cue"] | π workdir is ignored in docker.#Copy | ### What is the issue?
After setting a workdir on the image config the #Copy steps writes to '/'. My assumption is that the #Copy and other commands would follow Dockerfile type guidance and respect workdir automatically.
### Log output
4:17PM INF system | installing all packages...
4:17PM INF system | installed/updated package [email protected]
4:17PM INF system | installed/updated package [email protected]
dagger do --plan workdir-copy.cue test --log-format=plain
4:22PM INF actions.test.copyData._build._dag."0"._op | computing
4:22PM INF client.filesystem.".".read | computing
4:22PM INF client.filesystem.".".read | completed duration=100ms
4:22PM INF actions.test.copyData._testFile | computing
4:22PM INF actions.test.copyData._testFile | completed duration=100ms
4:22PM INF actions.test.copyData._build._dag."0"._op | completed duration=15.6s
4:22PM INF actions.test.copyData._build._dag."2"._copy | computing
4:22PM INF actions.test.copyData._build._dag."2"._copy | completed duration=300ms
4:22PM INF actions.test.readFile._test | computing
4:22PM INF actions.test.readFileIncorrect._test | computing
4:22PM INF actions.test.readFileIncorrect._test | completed duration=0s
4:22PM ERR actions.test.readFile._test | failed: ReadFile /opt/testfile.txt: open /tmp/buildkit-mount1037262984/opt/testfile.txt: no such file or directory
duration=0s
4:22PM FTL system | failed to execute plan: task failed: actions.test.readFile._test: ReadFile /opt/testfile.txt: open /tmp/buildkit-mount1037262984/opt/testfile.txt: no such file or directory
### Steps to reproduce
**Steps:**
1. Create a docker.#Build.
2. Add a docker.#Config step setting workdir (`/opt`)
3. Add a docker.#Copy step, copying a file. (`testfile.txt`)
4. Try to read the file from the workdir + path (`/opt/testfile.txt`) of the file by accessing the image #FS.
**Expected outcome:**
File found at `/opt/testfile.txt`
**Actual outcome:**
File cannot be found on the path `/opt/testfile.txt`. It has been written to `/testfile.txt`
Example test:
```
package main
import (
"dagger.io/dagger"
"dagger.io/dagger/core"
"universe.dagger.io/docker"
)
dagger.#Plan & {
client: filesystem: ".": read: contents: dagger.#FS
actions: test: {
copyData: {
_testFile: core.#WriteFile & {
input: client.filesystem.".".read.contents
path: "./testfile.txt"
contents: "test"
}
_build: docker.#Build & {
steps: [
docker.#Pull & {
source: "index.docker.io/debian"
},
docker.#Set & {
config: workdir: "/opt"
},
docker.#Copy & {
contents: _testFile.output
},
]
}
output: _build.output
}
readFileIncorrect: {
_test: core.#ReadFile & {
input: copyData.output.rootfs
path: "/testfile.txt"
}
}
readFile: {
_test: core.#ReadFile & {
input: copyData.output.rootfs
path: "/opt/testfile.txt"
}
}
}
}
```
### Dagger version
dagger 0.2.12 (21a15a84) darwin/amd64
### OS version
macOS 12.3.1 | https://github.com/dagger/dagger/issues/2512 | https://github.com/dagger/dagger/pull/2516 | 38ae483e7f855fcf3395360b0f3687d948656801 | 8df8c30931749b4e063e056e1c643c9346a73a21 | "2022-05-25T20:23:10Z" | go | "2022-06-01T19:14:36Z" |
closed | dagger/dagger | https://github.com/dagger/dagger | 2,493 | ["go.mod", "go.sum"] | Traces from logs | Hello, I have a couple of questions:
1. I have been checking a plan behavior using the tracing.compose.yaml but wanted to see if the span and trace id where logged, so far I can't see them even using the log-level trace, by design those values are not included there?
Why I am trying to do that? I wanted to play around with the grafana stack, in order to correlate the logs with the traces tempo tries to get the both values from the ingested logs.
2. Why dagger output is streamed to stderr? In order to capture the output of dagger and save it to a log, I have to redirect stderr to stdout. | https://github.com/dagger/dagger/issues/2493 | https://github.com/dagger/dagger/pull/1606 | 9641b4254c787b7a297d2e89819b50f4cc00267c | a0395b9340470f267929aba9aa6aab519dea29cc | "2022-05-20T17:14:53Z" | go | "2022-02-14T22:38:59Z" |
closed | dagger/dagger | https://github.com/dagger/dagger | 2,489 | ["go.mod", "go.sum"] | core.#Start Feedback | Saving as a placeholder to collect all the core.#Start feedback in it's current state and future state. It will be tied into the core.#Start Epic #2398 | https://github.com/dagger/dagger/issues/2489 | https://github.com/dagger/dagger/pull/1606 | 9641b4254c787b7a297d2e89819b50f4cc00267c | a0395b9340470f267929aba9aa6aab519dea29cc | "2022-05-19T20:27:09Z" | go | "2022-02-14T22:38:59Z" |
closed | dagger/dagger | https://github.com/dagger/dagger | 2,474 | ["cmd/dagger/cmd/do.go", "tests/plan.bats"] | Output format should be json when stdout is not tty | `dagger do` prints the actions' outputs on standard output.
If I want to pipe the outputs to a tool, like `jq`, I need to explicitly set the output format to json with `--output-format json`. But that format should be the default when I am piping the output. This is already what we do for logging: log format defaults to json when output is not a tty.
| https://github.com/dagger/dagger/issues/2474 | https://github.com/dagger/dagger/pull/2487 | 9e4b0551936d5c9689065ce5e22eb18cc7088f19 | 9ee0a85e6ed190a3868e0c3eba82a373ebb62823 | "2022-05-18T17:54:08Z" | go | "2022-05-20T01:23:40Z" |
closed | dagger/dagger | https://github.com/dagger/dagger | 2,469 | ["go.mod", "go.sum", "pkg/dagger.io/dagger/core/exec.cue", "pkg/dagger.io/dagger/core/start.cue", "plan/task/exec.go", "plan/task/startExec.go", "solver/container.go", "solver/solver.go", "tests/tasks.bats", "tests/tasks/exec/start_stop_exec.cue"] | Include #Start exec output in progress logs | Right now the stdout/stderr of an exec created with `core.#Start` is completely ignored. It needs to at minimum be included in the progress output by default, same as the output of normal `core.#Exec`s, to enable basic debuggability.
Subtask of #2398 | https://github.com/dagger/dagger/issues/2469 | https://github.com/dagger/dagger/pull/2561 | 60813f516a3369d6790e837b209a6da9749853db | df189147a4395654e611d04c2ce47a9975b4b2c8 | "2022-05-17T23:37:30Z" | go | "2022-07-12T19:05:57Z" |
closed | dagger/dagger | https://github.com/dagger/dagger | 2,434 | ["docs/guides/1226-coding-style.md"] | `cue fmt -s` aka `--simplify` in CI linter is confusing for users making PRs | `cue fmt -s` aka `--simplify` in linter is confusing for users making PRs with valid CUE code that doesn't pass.
https://github.com/dagger/dagger/pull/2433#issuecomment-1124550442
If this is important to us, it should be be documented somewhere like https://docs.dagger.io/1226/coding-style and users need better feedback/error messages in GitHub.
cc @samalba | https://github.com/dagger/dagger/issues/2434 | https://github.com/dagger/dagger/pull/2475 | 304c9a3851bbe79960e32f9c831a1e2b8dcb0a9d | 042a10d4b68f54bf7ca6a4f45193cb35c8c648cd | "2022-05-12T05:54:29Z" | go | "2022-05-19T22:20:44Z" |
closed | dagger/dagger | https://github.com/dagger/dagger | 2,428 | ["pkg/universe.dagger.io/docker/run.cue", "pkg/universe.dagger.io/docker/test/run.cue"] | β¨ Allow `docker.#Run` exporting `dagger.#Secret` from `export` | ### What are you trying to do?
Exporting `dagger.#Secret` directly from `export`.
For instance
```cue
cmd1: docker.#Run & {
// Command stuff
export: secrets: "/secrets.txt": dagger.#Secret
}
cm2: docker.#Run & {
// Command Stuff
env: SECRET: cm1.export.secrets."/secrets.txt
}
```
### Why is this important to you?
https://github.com/dagger/dagger/pull/2395 is an experimental package for 1password/.
This package required to export secrets as output.
### How are you currently working around this?
Currently, he's using `core.#NewSecret` in an intermediate `field`.
```cue
_secret: core.#NewSecret & {
input: _container.output.rootfs
path: "/tmp/secret"
}
output: _secret.output
```
[Real example here](https://github.com/dagger/dagger/pull/2395/files#r868125120) | https://github.com/dagger/dagger/issues/2428 | https://github.com/dagger/dagger/pull/2430 | ec824cb18746c4767cf7e9bb7e0f5b9626d2ca57 | 8d451e62e5dffa76b4b3b2941370420df7146b26 | "2022-05-10T23:38:39Z" | go | "2022-05-11T19:51:10Z" |
closed | dagger/dagger | https://github.com/dagger/dagger | 2,413 | ["cmd/dagger/cmd/project/update.go", "mod/file.go", "mod/mod.go", "mod/require.go"] | Make sure project update is handling built-ins and external dependencies | Looking at the code, it appears that `dagger project update` is only vendoring the built-in packages, not making sure the external packages are installed.
As a first step on #2163, we should at least make sure that there's consistency in the `project update` command in regards to built-ins and external dependencies because we're already documenting its usage like this. | https://github.com/dagger/dagger/issues/2413 | https://github.com/dagger/dagger/pull/2423 | 2a679b59c878c5505132bb8f9243658e3303f95c | ed9255e51d3125e2675ffbd24b75b31aea3dc2dc | "2022-05-06T22:50:51Z" | go | "2022-05-12T09:55:51Z" |
closed | dagger/dagger | https://github.com/dagger/dagger | 2,408 | ["pkg/dagger.io/dagger/core/fs.cue", "plan/task/rm.go", "tests/tasks.bats", "tests/tasks/rm/rm.cue"] | β¨ Support for removing files (`core.#Rm`) | ### What are you trying to do?
Remove files, similar to how I can make files and dirs with `core` tasks. `Rm` is a supported FileOp type in Buildkit, so not much effort needed in Dagger.
### Why is this important to you?
Users needed it here, had to resort to workaround (that turned out to have a buildkit bug anyways): https://github.com/dagger/dagger/issues/2401
### How are you currently working around this?
_No response_ | https://github.com/dagger/dagger/issues/2408 | https://github.com/dagger/dagger/pull/2422 | 31d68a65821922e96ebe286ce0fb7412ff4962f5 | a3f005c333da06380692def932b45645fb5636c6 | "2022-05-05T23:58:27Z" | go | "2022-05-16T22:45:55Z" |
closed | dagger/dagger | https://github.com/dagger/dagger | 2,351 | ["docs/core-concepts/1202-plan.md", "docs/getting-started/1200-local-dev.md", "docs/getting-started/1201-ci-environment.md", "docs/guides/buildkit/1237-persistent-cache.md", "website/docusaurus.config.js", "website/plugins/docusaurus-plugin-dagger-version/index.js", "website/src/components/DaggerVersionLatestReleased.js"] | :sparkles: Automatically update dagger versions in docs after a new release | ### What are you trying to do?
We currently have a script that updates our `dagger version` in our docs instructions but it's not part of our release process. We should ideally try to make our docs depend on hardcoded versions as least as possible and, if not possible, make the release process update docs automatically.
### Why is this important to you?
Currently we're having weekly releases and some docs get outdated and cause issues for new users since some instructions are still referencing older versions of dagger.
### How are you currently working around this?
running a script manually each time a release is made.
cc @aluzzardi
## Related
https://github.com/dagger/dagger/issues/2327
https://github.com/dagger/dagger/issues/2317 | https://github.com/dagger/dagger/issues/2351 | https://github.com/dagger/dagger/pull/2369 | be531ffaf911aa4462fa569b8dbac35eedb53aec | 2b0de14e2f3cbf880fceb44ddd9df3cbe08005d4 | "2022-04-28T13:27:50Z" | go | "2022-07-25T14:58:58Z" |
closed | dagger/dagger | https://github.com/dagger/dagger | 2,347 | [".github/workflows/test-gitpod.yml", ".gitpod.Dockerfile", ".gitpod.yml", ".vscode/settings.json", "ci.cue", "ci/gitpod/test.cue"] | β¨ Add Gitpod configuration | ### What are you trying to do?
I'm testing out using Gitpod to write contributions for the Dagger repo, but the default Gitpod environment is general purpose and so isn't tailored for this specific repo. It would be useful to have a fixed Gitpod configuration for this repo for repeatable dev environments on any branch.
### Why is this important to you?
I can easily work on this repo without having to make sure I have my dev environment set up correctly. Additionally every branch I work on will always have a version of Dagger compiled from that branch's head.
### How are you currently working around this?
I have to create new config files for each new branch and make sure I don't commit them if making a pull request. | https://github.com/dagger/dagger/issues/2347 | https://github.com/dagger/dagger/pull/2353 | f45043af34c7bb97f12850f566f4744fc115cc6d | e51ef73a43362f2b63c1485ad890340c1d4e1fef | "2022-04-28T09:52:18Z" | go | "2022-05-10T17:28:02Z" |
closed | dagger/dagger | https://github.com/dagger/dagger | 2,342 | ["docs/faq/1240-core-source.md", "website/sidebars.js"] | Better explain how to use `core.#Source` | ### What is the issue?
confusion today around `core.#Source` and `client: filesystem` for some users.
Can augment existing content and perhaps create blog.
https://docs.dagger.io/1222/core-actions-reference/#core-actions-related-to-filesystem-trees
https://github.com/dagger/dagger/blob/main/pkg/dagger.io/dagger/core/fs.cue#L7-L18
https://docs.dagger.io/1226/coding-style/#dont-inline-scripts
https://github.com/dagger/dagger/issues/1492#issuecomment-1024592441 | https://github.com/dagger/dagger/issues/2342 | https://github.com/dagger/dagger/pull/2525 | 72636792f06c4c62ff306bef5362346910b90c57 | 5956b94229eadbbbcc454b10c63ab1950c5b104d | "2022-04-27T22:12:20Z" | go | "2022-05-27T18:50:11Z" |
closed | dagger/dagger | https://github.com/dagger/dagger | 2,340 | ["docs/guides/1238-project-file-organization.md", "docs/guides/1239-making-reusable-package.md", "website/sidebars.js"] | Show package management hack | ### What is the issue?
| https://github.com/dagger/dagger/issues/2340 | https://github.com/dagger/dagger/pull/2271 | 08a3c52ce7f4d00a5e626ba49e4ceae1b36a80ba | 84f1c231a7fef9e67e125553e49c7bb77532427e | "2022-04-27T21:14:52Z" | go | "2022-05-13T14:14:14Z" |
closed | dagger/dagger | https://github.com/dagger/dagger | 2,339 | ["sdk/python/poetry.lock"] | Make more clear that `universe.dagger.io/x` is experimental | ### What is the issue?
Not everyone will know that `universe.dagger.io/x` (in golang `x` way) means experimental pre-universe packages that are contributed by the community and not yet fully supported by Dagger as a universe package. | https://github.com/dagger/dagger/issues/2339 | https://github.com/dagger/dagger/pull/3869 | 5619f43ffeefff9f406617ad89e77d0c943dd865 | 783f943793b69c19c67eb7ff88abebeb82d77ddc | "2022-04-27T21:12:40Z" | go | "2022-11-16T14:55:16Z" |
closed | dagger/dagger | https://github.com/dagger/dagger | 2,316 | ["go.mod", "go.sum"] | Update settings in GitHub to make rebase default update | <img width="1055" alt="image" src="https://user-images.githubusercontent.com/3187222/165381815-3606e488-9df6-4117-a718-fbb7ef80d045.png">
seems aligned with
https://docs.dagger.io/1227/contributing/#3-update-your-pull-request-with-latest-changes
cc @aluzzardi @helderco @gerhard | https://github.com/dagger/dagger/issues/2316 | https://github.com/dagger/dagger/pull/1084 | ef9feb702aa7d2e375cbb9c4e70f571224759d82 | c200055086139aafd2295babf421dfeb3d516e1c | "2022-04-26T19:58:21Z" | go | "2021-11-09T04:14:16Z" |
closed | dagger/dagger | https://github.com/dagger/dagger | 2,299 | ["cmd/dagger/cmd/do.go", "cmd/dagger/logger/tty.go", "plan/plan.go", "plan/runner.go", "plan/task/task.go"] | `--help` suppressed plan loading errors | ```console
$ dagger do -p ./plan/do/do_flags.cue test --help
Usage:
dagger do [flags]
```
vs
```console
$ dagger do -p ./plan/do/do_flags.cue test
failed to load plan: "actions.test.message" is not set:
./plan/do/do_flags.cue:21:3
./plan/do/do_flags.cue:25:4
Usage:
dagger do [flags]
``` | https://github.com/dagger/dagger/issues/2299 | https://github.com/dagger/dagger/pull/2378 | 453102b5f261c6e9d4b5d5bceee89a2aef55134f | 9fb0313ab2aeb82bcd4367d7c8e4103a386fb873 | "2022-04-25T17:32:14Z" | go | "2022-05-02T19:39:27Z" |
closed | dagger/dagger | https://github.com/dagger/dagger | 2,297 | ["cmd/dagger/cmd/do.go"] | π Fix `dagger do` flag validation | ### What is the issue?
https://github.com/dagger/dagger/pull/2261 broke flag validation for `dagger do` (while fixing another issue created by changing cobra flag parsing). We should work to enforce flag validation again.
### Log output
_No response_
### Steps to reproduce
_No response_
### Dagger version
dagger 0.2.7
### OS version
macOS 12.3 | https://github.com/dagger/dagger/issues/2297 | https://github.com/dagger/dagger/pull/2391 | 7039a1c985438a303e3f9696969d594d8f50188d | 78da07d6cfccc7112b2b493c093ba047a1cd21af | "2022-04-25T16:51:42Z" | go | "2022-05-03T18:41:55Z" |
closed | dagger/dagger | https://github.com/dagger/dagger | 2,285 | ["pkg/universe.dagger.io/bash/bash.cue"] | π bash.#Run does not work with a container image with an `entrypoint` | ### What is the issue?
When there is an entrypoint set on a base image, `bash.#Run` ends up with invalid arguments (bash cmd and arguments are appended to the existing entrypoint).
Instead it should always set an entrypoint to `/bin/bash` to work with all kind of base images.
### Log output
_No response_
### Steps to reproduce
_No response_
### Dagger version
dagger 0.2.7 (18c19174) darwin/arm64
### OS version
macOS 12.13.1 | https://github.com/dagger/dagger/issues/2285 | https://github.com/dagger/dagger/pull/2289 | e724ef6d9d1689a1b28621aaf8ce09441023abe3 | 1c36f8ea99d67bda479a312014eede676f11f49a | "2022-04-22T23:52:20Z" | go | "2022-04-24T17:33:52Z" |
closed | dagger/dagger | https://github.com/dagger/dagger | 2,272 | ["website/package.json", "website/yarn.lock"] | Provide an example for "You can extend your script by wrapping it, as-is, into a DAG. This allows you to start using Dagger right away, and worry about rewrites later." | ### What is the issue?
The statement "[You can extend your script by wrapping it, as-is, into a DAG. This allows you to start using Dagger right away, and worry about rewrites later.](https://docs.dagger.io/1220/vs)" is interesting but there's nothing to back it up. I'm skeptical that wrapping a complex bash script as-is into a DAG would offer benefit but I'd value an example being included in you docs.
As a startup founder building a reasonably complex cloud-native app that's composed mostly of containers and am intrigued by CUE, I'm also intrigued by Dagger.
For what I think are good reasons, my deployment process comprises bash scripts and -- rather reluctantly -- multiple GitHub Actions.I'm intrigued by Dapper because I like the portability promise and I would value more explicit dependencies between tasks in my deployment process.
However, I'm reluctant to (re)do a bunch of work in an aspect of my "thing" that's important but not core to my goal in launching it without clear guidance in how to achieve this with Dapper and proof that there are benefits to this. | https://github.com/dagger/dagger/issues/2272 | https://github.com/dagger/dagger/pull/5267 | 0a5177a8280d32a20a21cf036ae1b0837c8a964d | 0da71ebf5cfe6a5f93fec7b667fc9507027fa571 | "2022-04-22T16:16:53Z" | go | "2023-06-14T15:04:54Z" |
closed | dagger/dagger | https://github.com/dagger/dagger | 2,248 | ["website/package.json", "website/yarn.lock"] | π Error (`grpc: received message larger than max`) when exporting files larger than 16 MB | ### What is the issue?
When exporting a file using [the instructions in our docs](https://docs.dagger.io/1226/handling-outputs/#writing-outputs-to-the-filesystem), if the file is larger than 16 MB than you get an error.
As pointed out by @marcosnils, this appears to be a limit hardcoded by [the Buildkit client here](https://github.com/moby/buildkit/blob/master/client/client.go#L41-L44).
In general, while we could make that limit configurable, it's still problematic in that this approach to exporting a file to a local dir requires loading the entire file into memory as a single byte slice and then writing it to the filesystem. A better approach is to stream the file bytes continuously from the server to the client to the filesystem. I believe (but need to double check) that this is what Buildkit's local exporter does, so I'm wondering if we can switch to using that to implement these use cases.
### Log output
```
FTL failed to execute plan: task failed: actions.test.export._files."/hello.txt"._read: ReadFile /hello.txt: ResourceExhausted: grpc: received message larger than max (16777221 vs. 16777216)
```
### Steps to reproduce
Run this:
```
package main
import (
"dagger.io/dagger"
"universe.dagger.io/alpine"
"universe.dagger.io/bash"
)
dagger.#Plan & {
client: filesystem: "output.txt": write: contents: actions.test.export.files["/hello.txt"]
actions: {
_image: alpine.#Build & {
packages: bash: {}
}
test: bash.#Run & {
input: _image.output
script: contents: "dd if=/dev/zero bs=1M count=16 > /hello.txt"
export: files: "/hello.txt": string
}
}
}
```
### Dagger version
dagger devel (632b89ea) linux/arm64 (built from our main branch)
### OS version
Linux buildkit_dev 5.16.0-6-arm64 #1 SMP Debian 5.16.18-1 (2022-03-29) aarch64 GNU/Linux | https://github.com/dagger/dagger/issues/2248 | https://github.com/dagger/dagger/pull/5267 | 0a5177a8280d32a20a21cf036ae1b0837c8a964d | 0da71ebf5cfe6a5f93fec7b667fc9507027fa571 | "2022-04-20T20:49:17Z" | go | "2023-06-14T15:04:54Z" |
closed | dagger/dagger | https://github.com/dagger/dagger | 2,231 | ["docs/guides/code/1241-field-shadowing.md"] | Guide explaining and showing how to avoid field "shadowing" in Dagger CUE | ### What is the issue?
Users often use field names like `source` and `config` that are the same as fields inside of definitions. Users aren't sure what's going on:
> Whenever you're using the same name as key and value, there's a potential for some weird assignment error I don't quite understand.
This can create an issue...
```
_image: docker.#Dockerfile & {
source: source
}
```
that can be fixed like this:
```
_image: docker.#Dockerfile & {
"source": source
}
```
Demo in pure CUElang:
https://cuelang.org/play/?id=M_GjoAgHlmC#cue@export@cue
Explanations by Dagger staff that I've found:
(for above example)
> For values at the same scope, sometimes Cue has a hard time knowing whether you mean the other value or the key inside a Definition. Putting quotes around the key when it has the same name as the value, you'll make sure Cue doesn't get confused
//
problem:
```
#folders: ["kube2iam", "postgresql"]
lint_all:
{
for folder in #folders {
#Lint & {
source: client.filesystem."./".read.contents
folder: folder
}
}
}
```
fix:
```
#folders: ["kube2iam", "postgresql"]
lint_all: {
for folder in #folders {
"\(folder)": #Lint & { // need a field name otherwise they'll get embedded
source: client.filesystem."./".read.contents
"folder": folder // quote field to avoid shadowing
}
}
}
```
User response:
> thank you. what is shadowing?
Staff followup:
> This is when there's a conflict between scoped variables. If you have
```
input: "hello"
f: input: "world" // input is in scope so instead of the name "input", you end up with a conflict
f: "input": "world" // solution is to quote the field so it doesn't get interpreted as a variable
```
Outside explanation:
- https://cuetorials.com/overview/scope-and-visibility/#reference-lookup | https://github.com/dagger/dagger/issues/2231 | https://github.com/dagger/dagger/pull/2544 | 91216a0e1145c16a425d78b174b5984dab936e8d | eaff2c63d3fd41d85bb6fc6eed4cb515613b7a18 | "2022-04-19T18:06:35Z" | go | "2022-06-09T01:18:33Z" |
closed | dagger/dagger | https://github.com/dagger/dagger | 2,220 | ["docs/guides/1238-project-file-organization.md", "docs/guides/1239-making-reusable-package.md", "website/sidebars.js"] | Document using the package manager and creating your own packages | We need documentation on how to use `dagger project`, including with your own packages.
I was going to do this but got re-prioritized before public launch. @grouville picked it up after.
> What about [Manage packages using the package manager](https://docs.dagger.io/1011/package-manager/)? It's the next logical step to [Create your own package](https://docs.dagger.io/1206/packages/) ([Develop a new CUE package for Dagger](https://docs.dagger.io/1010/dev-cue-package/)).
>
> I'll write both.
>
> **Note**: Using the package manager can be used standalone if you're reusing packages from others, but there's no sense in creating a package for yourself without using the package manager to install/update. I've found before (in Discord) confusion on this. Makes me wonder if it would be best to show the package manager first (we need a simple dagger repo for this, where you can just follow the doc examples and it would work), and then how to create one for yourself. I think this would be clearer.
_Originally posted by @helderco in https://github.com/dagger/dagger/issues/1804#issuecomment-1072403278_ | https://github.com/dagger/dagger/issues/2220 | https://github.com/dagger/dagger/pull/2271 | 08a3c52ce7f4d00a5e626ba49e4ceae1b36a80ba | 84f1c231a7fef9e67e125553e49c7bb77532427e | "2022-04-18T15:11:35Z" | go | "2022-05-13T14:14:14Z" |
closed | dagger/dagger | https://github.com/dagger/dagger | 2,216 | [".devcontainer/Dockerfile", ".devcontainer/devcontainer.json", ".devcontainer/post-install.sh", "docs/guides/1227-contributing.md"] | β¨ Add Github Codespaces configuration | ### What are you trying to do?
I'm using Github Codespaces to write contributions for the Dagger repo, but the default Codespaces environment is general purpose and so isn't tailored for this specific repo. It would be useful to have a fixed Codespaces configuration for this repo for repeatable dev environments on any branch.
### Why is this important to you?
I can easily work on this repo without having to make sure I have my dev environment set up correctly. Additionally every branch I work on will always have a version of Dagger compiled from that branch's head.
### How are you currently working around this?
I have to create new config files for each new branch and make sure I don't commit them if making a pull request. | https://github.com/dagger/dagger/issues/2216 | https://github.com/dagger/dagger/pull/2217 | aaceba273aa84287dcc21f2b5a3dde01d2abb9d1 | 8ea748fa12022233c51626ac62143a9d8cdb97e0 | "2022-04-16T16:08:28Z" | go | "2022-05-15T17:10:54Z" |
closed | dagger/dagger | https://github.com/dagger/dagger | 2,205 | ["docs/core-concepts/1202-plan.md", "docs/getting-started/1200-local-dev.md", "docs/getting-started/1201-ci-environment.md", "docs/guides/buildkit/1237-persistent-cache.md", "website/docusaurus.config.js", "website/plugins/docusaurus-plugin-dagger-version/index.js", "website/src/components/DaggerVersionLatestReleased.js"] | Update examples to latest dagger version (automate this?) | ### What is the issue?
https://docs.dagger.io/1200/local-dev
0.2.4 listed in examples, would be ideal if this was latest release (0.2.6 when this was written).
Could this be automated easily/reliably? | https://github.com/dagger/dagger/issues/2205 | https://github.com/dagger/dagger/pull/2369 | be531ffaf911aa4462fa569b8dbac35eedb53aec | 2b0de14e2f3cbf880fceb44ddd9df3cbe08005d4 | "2022-04-15T07:04:19Z" | go | "2022-07-25T14:58:58Z" |
closed | dagger/dagger | https://github.com/dagger/dagger | 2,186 | ["docs/guides/1238-project-file-organization.md", "docs/guides/1239-making-reusable-package.md", "website/sidebars.js"] | Should document `cue.mod/module.cue` and module vs package | ### What is the issue?
After a `dagger project init` (without args), the created `cue.mod/module.cue` file contains:
```
module: ""
```
It's not clear to a new user what that means (if something is missing/wrong) and if it's related to the package name in their cue files.
https://cuelang.org/docs/concepts/packages/#packages
https://cuelang.org/docs/concepts/packages/#modules
https://cuelang.org/docs/tutorials/tour/packages/packages/
https://cuelang.org/docs/tutorials/tour/packages/imports/
https://github.com/dagger/dagger/pull/1685
It's also probably not clear to new users when they need to create a module name and how it relates to package name when building a dagger package destined to be shared (often via github, etc).
https://github.com/dagger/dagger/issues/2175
```
foo β€ dagger project init --name github.com/jpadams/foo
foo β€ cat cue.mod/module.cue
module: "github.com/jpadams/foo"%
```
| https://github.com/dagger/dagger/issues/2186 | https://github.com/dagger/dagger/pull/2271 | 08a3c52ce7f4d00a5e626ba49e4ceae1b36a80ba | 84f1c231a7fef9e67e125553e49c7bb77532427e | "2022-04-13T19:30:06Z" | go | "2022-05-13T14:14:14Z" |
closed | dagger/dagger | https://github.com/dagger/dagger | 2,175 | ["website/package.json", "website/yarn.lock"] | How can we use our own repo for packages? | ### What is the issue?
@vandlol is wondering how can he use his own repository to store & use dagger packages. This sounds like a great FAQ to me. | https://github.com/dagger/dagger/issues/2175 | https://github.com/dagger/dagger/pull/4661 | 4caeaf16513e2b7de3145b85f23a62fe6b562738 | c65789fe094b5e16bfc28ea10805ae4777b43189 | "2022-04-13T15:10:14Z" | go | "2023-03-27T08:04:42Z" |
closed | dagger/dagger | https://github.com/dagger/dagger | 2,170 | ["website/package.json", "website/yarn.lock"] | π Dagger doenst run with the GitLab CI tempage | ### What is the issue?
When i started to use the Template for Gitlab (we are using GitLab SaaS) Everytime I get the Errors regarding in the Log output.
other Pipelines works with dind but not with the dagger template.
this is my cue file
```
package frontend
import (
"dagger.io/dagger"
"dagger.io/dagger/core"
"universe.dagger.io/alpine"
"universe.dagger.io/bash"
"universe.dagger.io/docker"
"universe.dagger.io/docker/cli"
)
dagger.#Plan & {
_nodeModulesMount: "/node_modules": {
dest: "./node_modules"
type: "cache"
contents: core.#CacheDir & {
id: "omt-frontend-modules-cache"
}
}
client: {
network: "unix:///var/run/docker.sock": connect: dagger.#Socket
filesystem: {
"./": read: {
contents: dagger.#FS
exclude: [
"README.md",
"_build",
"frontend.cue",
"node_modules",
".angular",
]
}
"./_build": write: contents: actions.build.contents.output
}
env: {
ENV: string
PROJECT: string
NAMESPACE: string
ZONE: string
CLUSTER: string
CI_REGISTRY_PASSWORD: string
CI_REGISTRY: string
CI_REGISTRY_USER: string
}
}
actions: {
deps: docker.#Build & {
steps: [
alpine.#Build & {
packages: {
bash: {}
yarn: {}
git: {}
}
},
docker.#Copy & {
contents: client.filesystem."./".read.contents
dest: "/src"
},
bash.#Run & {
workdir: "/src"
mounts: {
"/cache/yarn": {
dest: "/cache/yarn"
type: "cache"
contents: core.#CacheDir & {
id: "frontend-yarn-cache"
}
}
_nodeModulesMount
}
script: contents: #"""
yarn config set cache-folder /cache/yarn
yarn install
"""#
},
]
}
build: {
run: bash.#Run & {
input: deps.output
mounts: _nodeModulesMount
workdir: "/src"
script: contents:"yarn run build:"+{{ client.env.ENV }}
}
}
imageBuild: docker.#Build & {
steps: [
docker.#Pull & {
source: "nginx:1.20-alpine"
},
docker.#Copy & {
contents: actions.build.contents.output
dest: "/usr/share/nginx/html"
},
docker.#Copy & {
contents: client.filesystem."./".read.contents
source: "./nginx.conf"
dest: "/etc/nginx/nginx.conf"
},
]
}
push: docker.#PUSH & {
input: imageBuild.output
dest: client.env.CI_REGISTRY
auth: {
username: client.env.CI_REGISTRY_USER
password: client.env.CI_REGISTRY_PASSWORD
}
}
load: cli.#Load & {
image: imageBuild.output
host: client.network."unix:///var/run/docker.sock".connect
tag: "omt-frontend"
}
}
}
```
### Log output
[0KRunning with gitlab-runner 14.9.0~beta.68.g1283960c (1283960c)[0;m
[0K on green-1.shared.runners-manager.gitlab.com/default JLgUopmM[0;m
section_start:1649841855:resolve_secrets
[0K[0K[36;1mResolving secrets[0;m[0;m
section_end:1649841855:resolve_secrets
[0Ksection_start:1649841855:prepare_executor
[0K[0K[36;1mPreparing the "docker+machine" executor[0;m[0;m
[0KUsing Docker executor with image docker:20.10-git ...[0;m
[0KStarting service docker:20.10-dind ...[0;m
[0KPulling docker image docker:20.10-dind ...[0;m
[0KUsing docker image sha256:a072474332af3e4cf06e349685c4cea8f9e631f0c5cab5b582f3a3ab4cff9b6a for docker:20.10-dind with digest docker@sha256:210076c7772f47831afaf7ff200cf431c6cd191f0d0cb0805b1d9a996e99fb5e ...[0;m
[0KWaiting for services to be up and running...[0;m
[0KPulling docker image docker:20.10-git ...[0;m
[0KUsing docker image sha256:f668d0ecb09af29b085f8e3c1311c8f0ffa2262544158e522a0ebcc3a6756a5b for docker:20.10-git with digest docker@sha256:3f51d0a7ce21a2a66072a212377c8e84b81c823977d1dd327204de362a303ce1 ...[0;m
section_end:1649841876:prepare_executor
[0Ksection_start:1649841876:prepare_script
[0K[0K[36;1mPreparing environment[0;m[0;m
Running on runner-jlguopmm-project-28791315-concurrent-0 via runner-jlguopmm-shared-1649841813-8b1509e5...
section_end:1649841877:prepare_script
[0Ksection_start:1649841877:get_sources
[0K[0K[36;1mGetting source from Git repository[0;m[0;m
[32;1m$ eval "$CI_PRE_CLONE_SCRIPT"[0;m
[32;1mFetching changes with git depth set to 50...[0;m
Initialized empty Git repository in /builds/kerberos-compliance/internals/guestcheckin-frontend/.git/
[32;1mCreated fresh repository.[0;m
[32;1mChecking out b655b437 as develop...[0;m
[32;1mSkipping Git submodules setup[0;m
section_end:1649841879:get_sources
[0Ksection_start:1649841879:restore_cache
[0K[0K[36;1mRestoring cache[0;m[0;m
[32;1mChecking cache for dagger-build...[0;m
Downloading cache.zip from https://storage.googleapis.com/gitlab-com-runners-cache/project/28791315/dagger-build[0;m
[32;1mSuccessfully extracted cache[0;m
section_end:1649841880:restore_cache
[0Ksection_start:1649841880:step_script
[0K[0K[36;1mExecuting "step_script" stage of the job script[0;m[0;m
[0KUsing docker image sha256:f668d0ecb09af29b085f8e3c1311c8f0ffa2262544158e522a0ebcc3a6756a5b for docker:20.10-git with digest docker@sha256:3f51d0a7ce21a2a66072a212377c8e84b81c823977d1dd327204de362a303ce1 ...[0;m
[32;1m$ apk add --no-cache curl[0;m
fetch https://dl-cdn.alpinelinux.org/alpine/v3.15/main/x86_64/APKINDEX.tar.gz
fetch https://dl-cdn.alpinelinux.org/alpine/v3.15/community/x86_64/APKINDEX.tar.gz
(1/1) Installing curl (7.80.0-r0)
Executing busybox-1.34.1-r5.trigger
OK: 24 MiB in 29 packages
[32;1m$ # install dagger # collapsed multi-line command[0;m
% Total % Received % Xferd Average Speed Time Time Time Current
Dload Upload Total Spent Left Speed
0 0 0 0 0 0 0 0 --:--:-- --:--:-- --:--:-- 0
0 0 0 0 0 0 0 0 --:--:-- --:--:-- --:--:-- 0
100 7649 100 7649 0 0 59557 0 --:--:-- --:--:-- --:--:-- 59294
sh debug downloading files into /tmp/tmp.fkIgoL
sh debug http_download https://dagger-io.s3.amazonaws.com/dagger/releases/0.2.6/dagger_v0.2.6_linux_amd64.tar.gz
sh debug http_download https://dagger-io.s3.amazonaws.com/dagger/releases/0.2.6/checksums.txt
sh info installed ./bin/dagger
/builds/kerberos-compliance/internals/guestcheckin-frontend
dagger 0.2.6 (e2c2213a) linux/amd64
[32;1m$ source ${K8S_ENVIRONMENT}[0;m
[32;1m$ dagger project update[0;m
[32;1m$ dagger do ${ARGS}[0;m
time="2022-04-13T09:24:48Z" level=warning msg="commandConn.CloseWrite: commandconn: failed to wait: signal: terminated"
time="2022-04-13T09:24:48Z" level=warning msg="commandConn.CloseRead: commandconn: failed to wait: signal: terminated"
time="2022-04-13T09:24:48Z" level=warning msg="commandConn.CloseWrite: commandconn: failed to wait: signal: terminated"
section_end:1649841890:step_script
[0Ksection_start:1649841890:archive_cache
[0K[0K[36;1mSaving cache for successful job[0;m[0;m
[32;1mCreating cache dagger-build...[0;m
.dagger-cache: found 7 matching files and directories[0;m
Uploading cache.zip to https://storage.googleapis.com/gitlab-com-runners-cache/project/28791315/dagger-build[0;m
[32;1mCreated cache[0;m
section_end:1649841891:archive_cache
[0Ksection_start:1649841891:cleanup_file_variables
[0K[0K[36;1mCleaning up project directory and file based variables[0;m[0;m
section_end:1649841892:cleanup_file_variables
[0K[32;1mJob succeeded[0;m
### Steps to reproduce
_No response_
### Dagger version
dagger 0.2.6 (e2c2213a) linux/amd64
### OS version
Docker 20.10 Image in GitLab | https://github.com/dagger/dagger/issues/2170 | https://github.com/dagger/dagger/pull/4661 | 4caeaf16513e2b7de3145b85f23a62fe6b562738 | c65789fe094b5e16bfc28ea10805ae4777b43189 | "2022-04-13T09:29:24Z" | go | "2023-03-27T08:04:42Z" |
closed | dagger/dagger | https://github.com/dagger/dagger | 2,169 | ["pkg/universe.dagger.io/python/image.cue", "pkg/universe.dagger.io/python/python.cue", "pkg/universe.dagger.io/python/test/test.cue"] | β¨ use official Python image in universe/python | ### What are you trying to do?
Rather than building our own Python image from Alpine, we should use the official Python image produced by Docker https://hub.docker.com/_/python
After discussion on Discord, this seems to be preferred by a majority of responding maintainers. I will contribute a PR.
### Why is this important to you?
Using the official image is the natural thing to do and will be what most Python developers expect. In addition to the DX advantages, using the official image lets us absorb upstream changes quickly and easily. It also gives developers easy access to different Python flavors more quickly and easily than Alpine updating their package manager.
### How are you currently working around this?
_No response_ | https://github.com/dagger/dagger/issues/2169 | https://github.com/dagger/dagger/pull/2171 | 2bce8b0371de22ae2568114fdb3cfb8bcb10e57b | bbfddcbe82f8b19c76af7a3f413e613098ff6c68 | "2022-04-13T07:46:45Z" | go | "2022-05-06T23:13:08Z" |
closed | dagger/dagger | https://github.com/dagger/dagger | 2,168 | ["pkg/dagger.io/dagger/plan.cue", "pkg/dagger.io/dagger/types.cue", "plan/task/clientnetwork.go", "plan/task/exec.go", "plancontext/service.go", "solver/socketprovider.go", "solver/socketprovider_unix.go", "solver/socketprovider_windows.go", "tests/tasks.bats", "tests/tasks/exec/mount_socket.cue"] | cleanup: Finish renaming Service to Socket | `dagger.#Service` was renamed `dagger.#Socket` in #1889 (see #1870)
While the CUE API was updated, there's still bits of Go code using `Service` (due to time constraints at the time).
/cc @helderco | https://github.com/dagger/dagger/issues/2168 | https://github.com/dagger/dagger/pull/2250 | b6afe0106e498bde98c7a552965ee732218b07c8 | fb7bcb48627c15adba8a735c6cfb9809fd601734 | "2022-04-13T01:28:53Z" | go | "2022-04-21T15:57:54Z" |
closed | dagger/dagger | https://github.com/dagger/dagger | 2,130 | ["website/package.json", "website/yarn.lock"] | Docs: improve broken links checking | ### What is the issue?
Dagger documentation is using Docusaurus. By default, it throws an error, to ensure you never ship any broken link, but current configuration has lower this security by displaying a warning message.
The following parameter should be remove to let Docusaurus get back its default behavior.
```
onBrokenLinks: "warn",
``` | https://github.com/dagger/dagger/issues/2130 | https://github.com/dagger/dagger/pull/4345 | 1524d73e7431580a0ffb2601e6e33e8506cefd28 | ee3ecda487ac7997ec05ccc9af9408e59aa6ab0f | "2022-04-11T20:16:26Z" | go | "2023-01-24T09:10:20Z" |
closed | dagger/dagger | https://github.com/dagger/dagger | 2,129 | ["docs/getting-started/1200-local-dev.md", "docs/getting-started/1240-install.md", "website/sidebars.js"] | Docs: dedicated install / downloads page | Our docs don't have a dedicated page for download / install options. Currently they are hidden in the "getting started" tutorial. | https://github.com/dagger/dagger/issues/2129 | https://github.com/dagger/dagger/pull/2522 | 998f5237a8a528db6a377b526e645c2f12d9d171 | 8d69cdf061a8e7a63189fdd46ed94ab620f2fd93 | "2022-04-11T19:56:32Z" | go | "2022-05-27T13:59:51Z" |
closed | dagger/dagger | https://github.com/dagger/dagger | 2,123 | ["docs/current/162770-faq.md", "docs/current/sdk/python/866944-install.md", "website/static/img/current/faq/release-notes.png"] | Uninstall Dagger | ### What is the issue?
I gave Dagger a whirl this weekend and want to uninstall it from my machine, how do I do that? | https://github.com/dagger/dagger/issues/2123 | https://github.com/dagger/dagger/pull/5515 | 4a4ea2423baaaf3d1991b361305f219ccb44a0b4 | d649f2d277ae3610da7c5c22929795694b3d1f19 | "2022-04-11T17:36:02Z" | go | "2023-08-03T13:24:58Z" |
closed | dagger/dagger | https://github.com/dagger/dagger | 2,114 | ["website/package.json", "website/yarn.lock"] | π universe: python cannot support alternate paths to the python interpreter | ### What is the issue?
`docker.#Run` has a concrete definition that the command is always `python3`
I will add a one-line PR to fix this.
### Log output
After changing pkg/universe.dagger.io/python/test/test.cue to add `image: "python3.8":
```
3:37PM FTL system | failed to load plan: 0: conflicting values "python3.8" and "python3":
/d/workspace/github.com/nottheeconomist/dagger/pkg/universe.dagger.io/docker/run.cue:92:11
/d/workspace/github.com/nottheeconomist/dagger/pkg/universe.dagger.io/python/python.cue:45:12
/d/workspace/github.com/nottheeconomist/dagger/pkg/universe.dagger.io/python/test/test.cue:35:20
```
### Steps to reproduce
Call `docker.#Run` while specifying a `command: name:` as anything but `python3`
### Dagger version
dagger 0.2.4 (b32c8732) linux/amd64
### OS version
Ubuntu 20.04.1 LTS (through WSL) | https://github.com/dagger/dagger/issues/2114 | https://github.com/dagger/dagger/pull/5898 | 268c1062a902c8bade88eedde8daee5ed90affdf | b6584895cd339b0ec3684b690dde092f7ba01b17 | "2022-04-10T22:50:17Z" | go | "2023-10-16T15:55:38Z" |
closed | dagger/dagger | https://github.com/dagger/dagger | 2,091 | ["cmd/dagger/cmd/project/init.go", "cmd/dagger/cmd/project/update.go"] | β¨ Explicit `dagger project update` usage | ### What are you trying to do?
There is a lost of users who can't run `hello world` example or any other example in the docs because they forgot to tip `dagger project update`.
It is not explicitly explained in the doc and there is no tip in the CLI.
What would be awesome is that you have a small message after `dagger project init` to remember you to tip `dagger project update` to install dagger dependencies.
Example
```shell
$ dagger project init
Project initialised! To install dagger universe, run : dagger project update
```
### Why is this important to you?
It's a common mistake that break on-boarding flow.
As a user, it should be easier to do a simple plan or copy/paste something from the doc and run it.
### How are you currently working around this?
Explain directly to users what to do | https://github.com/dagger/dagger/issues/2091 | https://github.com/dagger/dagger/pull/2119 | 15176acc9dfcd9294867d427193696bd5572303b | eeb2ef3eab77ef763d672eed0b5a4284fc69978e | "2022-04-08T12:12:34Z" | go | "2022-04-14T08:42:46Z" |
closed | dagger/dagger | https://github.com/dagger/dagger | 2,079 | ["cmd/dagger/logger/plain.go"] | π "FTL" is confusing in error messages | ### What is the issue?
Error messages start with the word "FTL", for example:
```
5:15AM FTL failed to execute plan: task failed: actions.lint.markdown._exec: process "/home/nonroot/entrypoint.sh markdownlint ./docs README.md" did not complete successfully: exit code: 1
```
Several people have asked me "what does FTL mean"? The answer is "fatal error". But clearly that is not at all obvious.
### Log output
-
### Steps to reproduce
Run `dagger do` of an action that fails. Look at output.
### Dagger version
dagger devel (fb3eafb6) linux/amd64
### OS version
Linux ip-172-31-39-148 4.19.0-16-cloud-amd64 #1 SMP Debian 4.19.181-1 (2021-03-19) x86_64 Linux | https://github.com/dagger/dagger/issues/2079 | https://github.com/dagger/dagger/pull/2595 | 19bfa7a0ad719934b46433358d3e5db68f8ca68d | 725b5c2f38f123a10d00411c17e4f2ecd02610c6 | "2022-04-08T05:18:43Z" | go | "2022-06-10T00:01:11Z" |
closed | dagger/dagger | https://github.com/dagger/dagger | 2,059 | [".github/workflows/dagger-ci.yml", ".github/workflows/test-integration.yml", ".github/workflows/test-universe.yml", "cmd/dagger/cmd/common/common.go", "pkg/universe.dagger.io/bats_helpers.bash", "tests/helpers.bash"] | Scope cache by PR | buildkit caching is not additive, e.g., it can only import/export cache off a single `dagger do`.
In our own CI, it means that each PR is overwriting the cache with that PR's content. Which in turn means each PR is invaliding each other's cache. Example:
- `PR 1` has some go changes. Cache is built using that source code and exported
- `PR 2` has different go changes. Cache is re-built using that source code, overwriting `PR 1` cache
- `PR 1` has an update. It will load cache from `PR 2`, resulting in loss of caching from the previous run
I've no idea what a plausible workaround for this might be.
In an ideal world, buildkit would have additive caching and we'd have layers for both `PR 1` and `PR 2`.
In the meantime, I don't know if we could play around with multiple `cache-from` targets, e.g.
- Import cache from `ci-main` and `ci-<PRID>`
- Export cache to `ci-<PRID>`
- When running on `main`, export cache to `ci-main`
/cc @TomChv @gerhard | https://github.com/dagger/dagger/issues/2059 | https://github.com/dagger/dagger/pull/2120 | 58e03969aeac8dd88327ddf4ed9daf4410ff7c1a | c1bc12ae0593735003c9532a2883f657e2fffbc9 | "2022-04-06T18:57:36Z" | go | "2022-04-25T23:30:29Z" |
closed | dagger/dagger | https://github.com/dagger/dagger | 2,053 | ["plan/task/exec.go", "tests/tasks.bats", "tests/tasks/exec/http_proxy.cue"] | β¨ Dagger: set buildkit network proxy | ### What are you trying to do?
I have problem with access github and some domain with my network, when I do some plans it required that resource, It got network error.
### Why is this important to you?
_No response_
### How are you currently working around this?
set global proxy for my PC. | https://github.com/dagger/dagger/issues/2053 | https://github.com/dagger/dagger/pull/2748 | 0fffdc223bb9d6c103538ef2fbbf5ed6fb5f3950 | a12e9f2d5300c0dce379fc327a3e103cea6a01cf | "2022-04-06T05:40:55Z" | go | "2022-07-07T01:40:57Z" |
closed | dagger/dagger | https://github.com/dagger/dagger | 2,044 | ["cmd/dagger/logger/plain.go", "cmd/dagger/logger/tty.go", "plan/runner.go", "plan/task/dockerfile.go", "plan/task/task.go", "plancontext/fs.go", "util/progressui/display.go", "util/progressui/printer.go"] | π dagger do doesn't output stderr | ### What is the issue?
`dagger do <action>` doesn't return useful info from stderr.
When I change the logging format to `--logformat plain` I get the info I need.
### Log output
```
β service-foo git:(master) β dagger do typescript
[β] client.env 0.0s
[β] client.filesystem."./".read 0.5s
[β] actions.typescript 216.1s
209.9s
8:14PM FTL failed to execute plan: task failed: actions.typescript._build: process "/bin/sh -c cp -r $DEPLOYABLE_NAME/build /output" did not complete successfully: exit code: 1
```
```
dagger do typescript --log-format plain
7:51PM INF system | #10 97.11 Failed to compile.
7:51PM INF system | #10 97.11
7:51PM INF system | #10 97.11 src/store/foo.ts
7:51PM INF system | #10 97.11 Line 29:7: Unsafe return of an `any` typed value @typescript-eslint/no-unsafe-return
7:51PM INF system | #10 97.1
7:51PM INF system | #10 97.39 Output:
7:51PM INF system | #10 97.39
7:51PM INF system | #10 97.39 info Visit https://yarnpkg.com/en/docs/cli/workspaces for documentation about this command.
7:51PM INF system | #10 97.42 error Command failed with exit code 1.
7:51PM INF system | #10 97.42 info Visit https://yarnpkg.com/en/docs/cli/run for documentation about this command.
7:51PM ERR actions.typescript._build | failed: process "/bin/sh -c yarn build" did not complete successfully: exit code: 1
```
### Steps to reproduce
_No response_
### Dagger version
dagger 0.2.4 (b32c8732) darwin/amd64
### OS version
osx - 12.01 | https://github.com/dagger/dagger/issues/2044 | https://github.com/dagger/dagger/pull/2188 | 437f4517b68347e16704df57c75bd8d418028c8e | 27d878456f03fb92fd5c62221a279a7ca261926d | "2022-04-05T04:29:38Z" | go | "2022-04-19T00:50:34Z" |
closed | dagger/dagger | https://github.com/dagger/dagger | 2,042 | ["docs/core-concepts/1215-what-is-cue.md"] | Docs: explain CUE embedding vs. CUE wrapping | ### What is the issue?
CUE has a powerful concept called "embedding", similar to Go embedding. This pattern is used extensively in Universe. It makes sense once you're familiar with CUE, but for absolute beginners it can be quite confusing.
There should be a documentation section explaining this concept.
| https://github.com/dagger/dagger/issues/2042 | https://github.com/dagger/dagger/pull/2046 | a3785b2b8092d37b1f8a72bd388dc6ae28e16d28 | 28b5d8e1793bb5110ea5b087e20c6cd99d9260ae | "2022-04-05T01:25:36Z" | go | "2022-04-21T11:14:38Z" |
closed | dagger/dagger | https://github.com/dagger/dagger | 2,014 | ["go.mod", "go.sum", "pkg/buildkitd/buildkitd.go"] | π website renders wrong on mac m1 safari | ### What is the issue?
https://twitter.com/alexellisuk/status/1510880710294396928
### Log output
_No response_
### Steps to reproduce
Visit https://dagger.io on safari on a mac m1.
### Dagger version
should not be required
### OS version
should not be required | https://github.com/dagger/dagger/issues/2014 | https://github.com/dagger/dagger/pull/394 | 2804feb004399b7bd75f0a7e4fa6ddcc63e07837 | 9d421c6c4299f6ab6ea147322199e32e87b82a49 | "2022-04-04T07:41:39Z" | go | "2021-04-30T17:12:49Z" |
closed | dagger/dagger | https://github.com/dagger/dagger | 2,007 | [".goreleaser.yml"] | Requesting a 32-bit ARM build for IoT and Raspberry Pi | ### What are you trying to do?
There's no binary that I could find on the latest release for 32-bit ARM or Raspberry Pi.
### Why is this important to you?
I'm attempting to add dagger support to the arkade marketplace, many people use Raspberry Pis with the default 32-bit ARM OS provided.
### How are you currently working around this?
Perhaps it could be built from source. Or is there a technical reason why this isn't supported? | https://github.com/dagger/dagger/issues/2007 | https://github.com/dagger/dagger/pull/2010 | 67bcb7ca20b9dccb85bfbb569554d450b6babb10 | 05e9943ff9fc9523c1c043766d94559776b51336 | "2022-04-03T09:55:30Z" | go | "2022-04-04T10:55:57Z" |
closed | dagger/dagger | https://github.com/dagger/dagger | 2,003 | ["cmd/dagger/cmd/common/common.go"] | π ~ is not expanded in --cache-to and --cache-from switches | ### What is the issue?
I run this:
```console
dagger do build --cache-from type=local,src=~/cc --cache-to type=local,mode=max,dest=~/cc
```
and in current directory new folder was create that was named `~`.
dagger should expand ~ to current user home folder path.
### Log output
nothing in logs
### Steps to reproduce
```console
dagger do build --cache-from type=local,src=~/cc --cache-to type=local,mode=max,dest=~/cc
```
### Dagger version
0.2.4
### OS version
ubuntu 21.10 | https://github.com/dagger/dagger/issues/2003 | https://github.com/dagger/dagger/pull/2006 | d934522c385a41ed45efe657d4920daf2656aaa2 | e00b3c20680a664bf83fdedb7f126abedc8f4e03 | "2022-04-03T05:35:59Z" | go | "2022-04-12T11:21:11Z" |
closed | dagger/dagger | https://github.com/dagger/dagger | 1,997 | ["docs/references/1222-core-actions-reference.md", "docs/references/1234-dagger-types-reference.md", "pkg/dagger.io/dagger/types.cue", "pkg/dagger.io/dagger/values.cue", "website/sidebars.js"] | Move a few definitions from `dagger` to `core` | The following definitions should be moved from `dagger.io/dagger` to `dagger.io/dagger/core`:
- `#ImageConfig` (tightly coupled to our image-related core actions)
- `#HealthCheck` (same)
- `#Ref` (same)
- `#Scratch` (tightly coupled to our fs-related core actions)
I just hit the issue while developing a plan. I used `core.#Copy` and automatically assumed `core.#Scratch`. This is made worse by #1635 because if a definition doesn't exist (in this case `core.#Scratch`) it's not clear at all from the error. So you waste time debugging. | https://github.com/dagger/dagger/issues/1997 | https://github.com/dagger/dagger/pull/2208 | eea29d530a4eae0c6ccea8f475b680f6d0429e3f | 23af3ab20b9702aef6fcd3ecb765cc47b9a5a3b1 | "2022-04-01T19:38:34Z" | go | "2022-04-15T23:34:41Z" |
closed | dagger/dagger | https://github.com/dagger/dagger | 1,981 | ["docs/getting-started/1220-vs.md", "website/sidebars.js"] | Docs: bring back comparison to other software | ## Problem
Dagger 0.1 had a [documentation page comparing Dagger to other software](https://docs.dagger.io/1002/vs/). This page was removed when the docs were rewritten from scratch from Dagger 0.2. This was not necessary as the page applies to Dagger 0.2 without modification.
Several people have asked how Dagger compared to other software, confirming the value of that page.
## Solution
Include the original page, unmodified, in the Dagger 0.2 navbar.
| https://github.com/dagger/dagger/issues/1981 | https://github.com/dagger/dagger/pull/1986 | 5d4e6e5ddcbefc713446c9be396c8f70effd6ade | c2d9d74c1fc45147a30b26b8c0a15d3321c68a70 | "2022-03-31T23:39:16Z" | go | "2022-04-01T15:22:22Z" |
closed | dagger/dagger | https://github.com/dagger/dagger | 1,965 | ["pkg/universe.dagger.io/go/image.cue", "pkg/universe.dagger.io/go/test/image.cue"] | π `go.#Build` is broken by default with go 1.18 | ### What is the issue?
Doing a standard `go.#Build` fails with the following logs:
This is because of `go` defaulting this flag to `true` and dagger not necessarily send the `.git` in the context (for relatively good reason).
### Log output
4:04PM INF actions.tknlocal.container._exec | #5 0.325 go: missing Git command. See https://golang.org/s/gogetcmd
4:04PM INF actions.tknlocal.container._exec | #5 0.325 error obtaining VCS status: exec: "git": executable file not found in $PATH
4:04PM INF actions.tknlocal.container._exec | #5 0.325 Use -buildvcs=false to disable VCS stamping.
### Steps to reproduce
Create the following plan
```
package foo
import (
"dagger.io/dagger"
"universe.dagger.io/go"
)
dagger.#Plan & {
client: {
filesystem: {
"./.": read: contents: dagger.#FS
}
}
actions: {
build: go.#Build & {
source: client.filesystem."./.".read.contents
}
}
}
```
### Dagger version
dagger devel () linux/amd64 (20220331 build)
### OS version
NixOS unstable | https://github.com/dagger/dagger/issues/1965 | https://github.com/dagger/dagger/pull/1971 | fa2ca105aa088164753d512214ee5b318177ee68 | d79de11fa896e63907e294411e83ea10f07b5e1c | "2022-03-31T14:11:07Z" | go | "2022-04-04T22:31:42Z" |
closed | dagger/dagger | https://github.com/dagger/dagger | 1,960 | ["docs/getting-started/1220-vs.md", "website/sidebars.js"] | docs:add comparison between dagger and other ci/cd tools | ### What are you trying to do?
_No response_
### Why is this important to you?
users want to know the difference between dagger and other ci/cd tools.The below are some tools that I care about:
- tekton
- jenkins
- Drone
- argocd
if someone cares about other tools, please add it in this issue.
### How are you currently working around this?
_No response_ | https://github.com/dagger/dagger/issues/1960 | https://github.com/dagger/dagger/pull/1986 | 5d4e6e5ddcbefc713446c9be396c8f70effd6ade | c2d9d74c1fc45147a30b26b8c0a15d3321c68a70 | "2022-03-31T11:44:09Z" | go | "2022-04-01T15:22:22Z" |
closed | dagger/dagger | https://github.com/dagger/dagger | 1,959 | ["docs/administrator/1013-operator-manual.md"] | π Can't connect to docker daemon when using nerdctl | ### What is the issue?
I use nerdctl with buildkit and containerd (Rancher Desktop) to normally build, tag and push my "docker" images (OCI compatible). If I want to use the docker Dagger step as mentioned in the "quick start" [here](https://docs.dagger.io/), I get the error that it couldn't connect to the docker daemon. I was told to create this issue by helderco#4068 in Discord.
### Log output
`11:09AM ERR failed to run docker: exit status 1 output=Client:
Context: default
11:09AM ERR failed to run docker: exit status 1 output=Client:
Context: default
Debug Mode: falseuildx (Docker Inc., v0.7.1)
Plugins:: Docker Compose (Docker Inc., v2.2.3)
buildx: Docker Buildx (Docker Inc., v0.7.1)
compose: Docker Compose (Docker Inc., v2.2.3)
scan: Docker Scan (Docker Inc., v0.16.0)
ERROR: Cannot connect to the Docker daemon at unix:///var/run/docker.sock. Is the docker daemon running?
Server:pretty printing info
ERROR: Cannot connect to the Docker daemon at unix:///var/run/docker.sock. Is the docker daemon running?
errors pretty printing info`
### Steps to reproduce
1. Use Rancher Desktop and get use nerdctl as your building tool.
2. Alias docker to nerdctl.
3. Try to build with dagger `dagger do build` in https://github.com/dagger/dagger/pkg/universe.dagger.io/examples/todoapp
### Dagger version
0.2.4
### OS version
macOS 11.6.4 | https://github.com/dagger/dagger/issues/1959 | https://github.com/dagger/dagger/pull/2232 | 28b5d8e1793bb5110ea5b087e20c6cd99d9260ae | d4abb2916aa2d5eb3676fbeaa9851c3d935533cc | "2022-03-31T09:53:42Z" | go | "2022-04-21T11:38:46Z" |
closed | dagger/dagger | https://github.com/dagger/dagger | 1,955 | [".github/workflows/ci.yml", "go.mod", "go.sum"] | π Dagger: runtime: out of memory | ### What is the issue?
I have written some of my own CUE Modules, which may go out of memory when run multiple times over a long period of time.
### Log output
### Steps to reproduce
_No response_
### Dagger version
dagger devel (b32c8732) linux/amd64
### OS version
Linux VM-0-6-ubuntu 4.15.0-159-generic #167-Ubuntu SMP Tue Sep 21 08:55:05 UTC 2021 x86_64 x86_64 x86_64 GNU/Linux | https://github.com/dagger/dagger/issues/1955 | https://github.com/dagger/dagger/pull/143 | 6eb3d5afbda9e1ee223069be8a32e750c779edd3 | 50e8b8c07dd39382281dbfb0f8878ebcad637220 | "2022-03-31T07:24:07Z" | go | "2021-03-01T22:03:23Z" |
closed | dagger/dagger | https://github.com/dagger/dagger | 1,946 | ["docs/getting-started/1200-local-dev.md"] | Improvements to Windows installation instructions | From [this comment on Hacker News](https://news.ycombinator.com/item?id=30858740):
> [gregmac](https://news.ycombinator.com/user?id=gregmac) [4 minutes ago](https://news.ycombinator.com/item?id=30858740) | [next](https://news.ycombinator.com/item?id=30857012#30858085) [[β]]()
>
> Your Windows instructions/process needs work.
> > curl https://dl.dagger.io/dagger/install.ps1 -OutFile install.ps1
> This uses the `curl` alias, which is really `Invoke-WebRequest`. It also makes the incorrect assumption I haven't fixed this dumb Microsoft mistake to be an alias to actual curl.exe.
> > [Windows] We try to move the dagger binary under C:\Windows\System32
> Ack, please don't do this! This is similar to installing something under /usr/sbin/. Malware is the only modern thing that would attempt to deploy to that folder.
> > but in case we miss the necessary permissions, we'll save everything under <your home folder>/dagger > C:\<your home folder>\dagger.exe
> I'm glad you have a non-admin fallback, but also: yuck. I don't want this polluting my home folder (more importantly: I don't want 100's of other things like this also polluting my home folder).
> The "Windows way" is to install system-wide to %ProgramFiles%\dagger\ (eg c:\Program files\dagger\dagger.exe), or to install to %LocalAppData%\dagger\ (eg: c:\Users\shykes\AppData\Local\dagger\dagger.exe). The latter is kind of the closest equivalent to $HOME/.dagger on linux. Add whatever folder to the user's PATH environment variable to make it easy to run.
> Honestly, providing just the .zip is better: then Windows users can muck up their own system however they like. Alternatively, package it with something like Scoop [2] which is a fairly popular dev tool, and provides a fairly easy way to get a sane install with updates, versioning and path stuff all handled.
> [1] https://docs.dagger.io/
> [2] https://scoop.sh/ | https://github.com/dagger/dagger/issues/1946 | https://github.com/dagger/dagger/pull/1982 | acc593f3885462ba8f2404a0c931689af03d36b5 | cc4cabb71395bea02e29ed19ff0d6e0f02699b3b | "2022-03-30T18:17:20Z" | go | "2022-04-01T00:09:46Z" |
closed | dagger/dagger | https://github.com/dagger/dagger | 1,924 | ["pkg/universe.dagger.io/netlify/deploy.sh"] | Netlify: use CLI for more things | The `netlify` package uses the official netlify CLI for certain things, but not for others (it uses a curl-based wrapper for those). Since the package was written, the netlify CLI has expanded its features, and we can now remove the curl-based wrappers, simplifying the package in the process.
| https://github.com/dagger/dagger/issues/1924 | https://github.com/dagger/dagger/pull/2181 | 1598ed984133f9d8cca5274a113d971d3b8efcbe | eea29d530a4eae0c6ccea8f475b680f6d0429e3f | "2022-03-29T18:31:53Z" | go | "2022-04-15T23:12:03Z" |
closed | dagger/dagger | https://github.com/dagger/dagger | 1,916 | ["website/package.json", "website/yarn.lock"] | improve todoapp documentation | For now, we just have the documentation giving us a github actions workflow to copy.
The documentation should use as much of the already existing tooling in this repo for reproducing the todoapp in the users' own fork. | https://github.com/dagger/dagger/issues/1916 | https://github.com/dagger/dagger/pull/4769 | 4e6f0804b392be60ac8fc44389570d20518221c3 | d7c9ecf732bb003367440c2177de7f413df8df08 | "2022-03-29T14:25:49Z" | go | "2023-03-17T15:50:04Z" |
closed | dagger/dagger | https://github.com/dagger/dagger | 1,908 | ["docs/core-concepts/1202-plan.md", "docs/core-concepts/1213-dagger-cue.md", "docs/getting-started/1200-local-dev.md", "docs/update-version.sh"] | Install docs should point to the latest version | I noticed the install docs mentions `v0.2.0` on one side and `v0.2.3` right after. Ideally this should not be hardcoded or pointing to the latest one automatically.
<img width="958" alt="Screen Shot 2022-03-28 at 4 46 10 PM" src="https://user-images.githubusercontent.com/216487/160505287-dc7a5eff-fbf1-471e-b5b6-3da615eea1d9.png">
And later:
<img width="934" alt="Screen Shot 2022-03-28 at 4 48 24 PM" src="https://user-images.githubusercontent.com/216487/160505434-74095fea-1d36-4dcc-95f7-4bfc0d7656b5.png">
cc @gerhard | https://github.com/dagger/dagger/issues/1908 | https://github.com/dagger/dagger/pull/1926 | ece37623b2e4089090d22dcee6a3514e6f69493e | b32c8732bc7bd932dbdb5dc42fe2434c53cfeb38 | "2022-03-28T23:48:58Z" | go | "2022-03-29T18:48:38Z" |
closed | dagger/dagger | https://github.com/dagger/dagger | 1,906 | ["website/package.json", "website/yarn.lock"] | I can download just-in-time versions of dagger from get.dagger.io/binary/dagger-$GITREF.tgz | Longer term, we can (and IMO should) host a binary-on-demand service eg. `get.dagger.io/binary/dagger-$GITREF.tgz` that builds the requested version just-in-time for download.
_Originally posted by @shykes in https://github.com/dagger/dagger-for-github/issues/35#issuecomment-1071971420_ | https://github.com/dagger/dagger/issues/1906 | https://github.com/dagger/dagger/pull/4769 | 4e6f0804b392be60ac8fc44389570d20518221c3 | d7c9ecf732bb003367440c2177de7f413df8df08 | "2022-03-28T23:41:12Z" | go | "2023-03-17T15:50:04Z" |
closed | dagger/dagger | https://github.com/dagger/dagger | 1,890 | ["docs/core-concepts/1203-client.md", "docs/tests/core-concepts/client/plans/cmd.cue", "docs/tests/core-concepts/client/plans/cmd_secret.cue", "docs/tests/core-concepts/client/plans/cmd_stderr.cue", "docs/tests/core-concepts/client/plans/cmd_stdin.cue", "docs/tests/core-concepts/client/plans/platform.cue"] | client doc: reference on how to use stdin/stdout | in https://docs.dagger.io/1203/client/#running-commands, we talk about we can use stdin + stderr, but we don't link to any other docs. And it seems we have none. | https://github.com/dagger/dagger/issues/1890 | https://github.com/dagger/dagger/pull/2668 | 4d0730b9cb85807281b5ef813dc9fe3c6f89eaf7 | aa0c649c20d84461bc7449a06fadebcffbadfe39 | "2022-03-28T16:07:10Z" | go | "2022-06-21T03:42:34Z" |
closed | dagger/dagger | https://github.com/dagger/dagger | 1,886 | ["pkg/universe.dagger.io/docker/cli/client.cue"] | Referencing a `#DecodeSecret`'s output key in an action makes it disappear | # Issue
When trying to store some secrets in an encrypted `sops` file, I realized that an action referencing the output of a `#DecodeSecret`becomes unusable
# Repro
**Working config**
```
package main
import (
"dagger.io/dagger"
"universe.dagger.io/docker/cli"
)
dagger.#Plan & {
client: {
filesystem: {
"/Users/home/.ssh/id_rsa": read: contents: dagger.#Secret
"/Users/home/.ssh/known_hosts": read: contents: dagger.#Secret
}
}
actions: {
run: cli.#Run & {
host: "ssh://[email protected]"
ssh: {
key: client.filesystem."/Users/home/.ssh/id_rsa".read.contents
knownHosts: client.filesystem."/Users/home/.ssh/known_hosts".read.contents
}
command: name: "info"
}
}
}
```
**Failing one loading a secret from a `sops` file**
```
package main
import (
"dagger.io/dagger"
"universe.dagger.io/docker/cli"
)
dagger.#Plan & {
client: {
commands: sops: {
name: "sops"
args: ["-d", "./toto.yaml"]
stdout: dagger.#Secret
}
}
actions: {
sopsSecrets: dagger.#DecodeSecret & {
format: "yaml"
input: client.commands.sops.stdout
}
run: cli.#Run & {
host: "ssh://[email protected]"
ssh: {
key: sopsSecrets.output.idRSA.contents
}
command: name: "info"
}
}
}
```
# Root cause
Might be related to #1885: meaning that `sopsSecrets.output.idRSA.contents` is not being considered in the DAG. Furthermore, commenting the `ssh` part of the `run` action makes it visible again
cc @jlongtine | https://github.com/dagger/dagger/issues/1886 | https://github.com/dagger/dagger/pull/2025 | a717ec0734fe2ebf52ff132d7e8452827f61e182 | 85072c500adb581b4a286535366f6cbc95144e51 | "2022-03-28T14:37:44Z" | go | "2022-04-05T09:58:03Z" |
closed | dagger/dagger | https://github.com/dagger/dagger | 1,872 | ["cmd/dagger/cmd/doc.go"] | Bring back `dagger doc` | ## Problem
Dagger 0.1 had a command called `dagger doc`, which was similar to `go doc`. Given the names of a CUE package and definition, it would print information about their API.
Unfortunately, this feature was not compatible with Dagger 0.2, because it relied on concepts such as `@dagger(input)` and `@dagger(output)` which no longer exist. This is also why we currently don't have an API reference in our docs: the generator has not been ported to 0.2.
As a result, there is no easy way to look up available packages and their APIs while developing a Dagger 0.2 plan.
## Solution
Bring back `dagger doc` in a simpler form. Instead of scanning the CUE code and generating documentation, just print the CUE code as is. The output can be refined later - but at least developers get the equivalent of looking up the source file on github, which is what they need to do anyway. It's a strictly better developer experience, achievable in the short term.
| https://github.com/dagger/dagger/issues/1872 | https://github.com/dagger/dagger/pull/2693 | a7d453ea93610431d42ff9c8735e4befbbfdaea2 | 7f87e7bb34547fe814f60cbc09440fef0b4ec103 | "2022-03-27T06:23:01Z" | go | "2022-07-05T17:17:40Z" |
closed | dagger/dagger | https://github.com/dagger/dagger | 1,870 | ["website/package.json", "website/yarn.lock"] | Rename dagger.#Service to dagger.#Socket | ## Problem
`dagger.#Service` is a core type referencing a network service. We chose an intentionnaly broad name to convey the support for multiple backends: unix socket, tcp, udp, websocket, http2, etc. With the benefit of insight, "service" is confusing because it is too broad.
## Solution
Introduce a new core type: `dagger.#Socket`, which represents a network socket endpoint. It is functionally equivalent to `dagger.#Service`, which it deprecates.
"Socket" is a better name because it accurately reflects both the current implementation (unix socket, and soon tcp and udp sockets) and the broader design goal (a standardized CUE API for bi-directional network endpoints).
## Mea Culpa
I am to blame for the choice of "service". "Socket" was the name initially proposed by @aluzzardi, but I insisted on trying something broader. I feared that "socket" would tie us too strongly to a posix socket implementation. What I had forgotten was that before the posix socket API became a relic of the unix wars, frozen in time, it was meant to be a universal interface for network endpoints, *regardless of transport*. They failed in the attempt (most applications wrap their posix sockets in http, http2, grpc and other higher-level APIs). But the intent remains in the word "socket" which wikipedia defines as "a software structure within a network node of a computer network that serves as an endpoint for sending and receiving data across the network". If we focus on the intent of the word rather than its historical implementation, that's a sufficiently broad definition. We can continue the work posix started.
Let's fix my mistake before launch :) | https://github.com/dagger/dagger/issues/1870 | https://github.com/dagger/dagger/pull/4510 | db58d9968da6895ff74c772acd3d3a58b5ffefd5 | 20e0f9741eb66f1eabd00a2c18cc8a5e46f3949e | "2022-03-27T05:26:13Z" | go | "2023-02-06T12:33:50Z" |
closed | dagger/dagger | https://github.com/dagger/dagger | 1,848 | ["pkg/pkg.go"] | `dagger do` on uninitialized plans hang on Windows | # Problem
Uninitialized projects hang on Windows, not on Mac
# Context
While trying to export the improvement of the `todoapp` from @marcosnils', I copied the `todoapp` (and only this one) to another directory. Running `dagger do build` inside this directory made it hang indefinitely in Windows, and errors on Mac:
_Mac_
```
4:21PM FTL failed to load plan: import failed: cannot find package "dagger.io/dagger":
/tmp/todoapp/netlify.cue:4:2
: running `dagger project update` may resolve this
```
_Windows_
```
dagger.exe do build -p .\todoapp\netlify.cue --log-level debug --log-format plain
3:47PM DBG system | detected buildkit config haveHostNetwork=true isActive=true version=v0.10.0
```
# Repro
On windows:
```
git clone https://github.com/dagger/dagger
cd dagger
git checkout v0.2.0
cp pkg/universe.dagger.io/examples/todoapp /tmp
cd /tmp/todoapp
dagger do build
```
Related to:
- https://github.com/dagger/dagger/issues/1796
- https://github.com/dagger/dagger/issues/1820 | https://github.com/dagger/dagger/issues/1848 | https://github.com/dagger/dagger/pull/1910 | f4c9cd663a503740ca1957b85b7ebac96d681c6a | ea59c932bb11da344f4ec0ef387e1d944bc77586 | "2022-03-24T15:31:27Z" | go | "2022-03-29T01:29:38Z" |
closed | dagger/dagger | https://github.com/dagger/dagger | 1,846 | ["docs/core-concepts/1202-plan.md", "docs/getting-started/1200-local-dev.md", "docs/tests/core-concepts/plan/structure.cue.fragment", "pkg/universe.dagger.io/examples/todoapp/.gitignore", "pkg/universe.dagger.io/examples/todoapp/todoapp.cue"] | It all starts with a plan: order of the syntax | in https://docs.dagger.io/1202/plan, we present the main content of the file, the dagger.Plan.
Later, we discuss the `import`, but we didn't see that before, so we don't know what to do about it.
IΒ guess maybe after the first step in the getting started executing locally, we should explain that now we are gonna explain more of the concept of dagger before continuing the original tutorial? | https://github.com/dagger/dagger/issues/1846 | https://github.com/dagger/dagger/pull/1860 | a01fd7297ff738e0bc009fa01480949cef119305 | 9f042800da215a5279dd59861d2a312a1157ac17 | "2022-03-24T14:52:08Z" | go | "2022-03-26T19:45:13Z" |
closed | dagger/dagger | https://github.com/dagger/dagger | 1,820 | ["docs/getting-started/1200-local-dev.md"] | On Windows, todoapp example requires dagger project update before dagger do | Part of https://github.com/dagger/dagger/issues/1796, we have learned with @nabsul that on Windows 11, following the Windows tutorial from https://docs.dagger.io/, `dagger do build` fails with:
I tried to reproduce this on Linux and I am **not** getting the above failure:
```console
root@h11:/tmp# lsb_release -a
No LSB modules are available.
Distributor ID: Debian
Description: Debian GNU/Linux 10 (buster)
Release: 10
Codename: buster
root@h11:/tmp# dagger version
dagger 0.2.0 (e499297e) linux/amd64
root@h11:/tmp# git clone [email protected]:gerhard/dagger.git
# ...
root@h11:/tmp/dagger# cd dagger/
root@h11:/tmp/dagger/# git checkout v0.2.0
# ...
root@h11:/tmp/dagger/# cd pkg/universe.dagger.io/examples/todoapp/
root@h11:/tmp/dagger/pkg/universe.dagger.io/examples/todoapp# dagger do build
[β] actions.build.run.script 0.2s
[β] actions.deps 1.4s
[β] client.filesystem.".".read 0.2s
[β] actions.test.script 0.2s
[β] actions.test 0.0s
[β] actions.build.run 0.0s
[β] actions.build.contents 0.0s
[β] client.filesystem.build.write 0.1s
A new version is available (0.2.1), please go to https://github.com/dagger/dagger/doc/install.md for instructions.
```
Can you please run the equivalent steps on your Windows host @nabsul and share the output?
Knowing this would help:
- Which Windows version are you using?
- How are you running the commands?
- How did you install Dagger?
FTR https://github.com/dagger/dagger/issues/1796#issuecomment-1069124581
---
One question which came up @aluzzardi is whether we should run `dagger project update` inside `pkg/universe.dagger.io/examples` **before** we tag a new release.
The thinking goes: since we vendor packages inside `pkg/universe.dagger.io/cue.mod`, we should make sure that these are in sync with the dagger version that we mention in our docs.
FWIW:
```console
root@h11:/tmp/dagger# git status
HEAD detached at v0.2.0
nothing to commit, working tree clean
root@h11:/tmp/dagger# cd pkg/universe.dagger.io/examples/todoapp/
root@h11:/tmp/dagger/pkg/universe.dagger.io/examples/todoapp# dagger project update
root@h11:/tmp/dagger/pkg/universe.dagger.io/examples/todoapp# git status
HEAD detached at v0.2.0
Changes not staged for commit:
(use "git add/rm <file>..." to update what will be committed)
(use "git checkout -- <file>..." to discard changes in working directory)
deleted: ../../cue.mod/pkg/dagger.io
no changes added to commit (use "git add" and/or "git commit -a")
```
The expectation is that `dagger project update` should **not** result in any updates, since the repository is checked out at `v0.2.0` and the dagger version is also `v0.2.0`. WDYT @aluzzardi?
The reason why I believe that the above is more important for Windows than Linux or macOS is because running `dagger project update` **before** `dagger do build` on @nabsul's Windows host fixed the `cannot find package "dagger.io/dager"` error. This is from memory, I would like him to confirm before we continue digging into this.
By the way, if anyone has a Windows host and wants to reproduce the above for us, that would be highly appreciated. @cdhunt comes to mind first, but I understand if he is not able to do it π
---
FWIW2:
```console
root@h11:/tmp/dagger# dagger version
dagger 0.2.1 (69b4845d) linux/amd64
root@h11:/tmp/dagger# git checkout v0.2.1
root@h11:/tmp/dagger# git status
HEAD detached at v0.2.1
nothing to commit, working tree clean
root@h11:/tmp/dagger# cd pkg/universe.dagger.io/examples/todoapp/
root@h11:/tmp/dagger/pkg/universe.dagger.io/examples/todoapp# dagger do build
[β] actions.build.run.script 0.1s
[β] actions.deps 1.3s
[β] actions.test.script 0.1s
[β] client.filesystem.".".read 0.1s
[β] actions.test 0.0s
[β] actions.build.run 0.0s
[β] actions.build.contents 0.0s
[β] client.filesystem.build.write 0.1s
root@h11:/tmp/dagger/pkg/universe.dagger.io/examples/todoapp# dagger project update
root@h11:/tmp/dagger/pkg/universe.dagger.io/examples/todoapp# git status
HEAD detached at v0.2.1
Changes not staged for commit:
(use "git add/rm <file>..." to update what will be committed)
(use "git checkout -- <file>..." to discard changes in working directory)
deleted: ../../cue.mod/pkg/dagger.io
Untracked files:
(use "git add <file>..." to include in what will be committed)
../../cue.mod/pkg/.gitattributes
../../cue.mod/pkg/universe.dagger.io/
no changes added to commit (use "git add" and/or "git commit -a")
``` | https://github.com/dagger/dagger/issues/1820 | https://github.com/dagger/dagger/pull/2036 | 715fd9225a7abeea4af8c4e94ba8e44e00504a5b | 18f1eae6e83f2b3694a522a8e5408e5b85cd95b2 | "2022-03-18T19:12:01Z" | go | "2022-04-05T18:31:22Z" |
closed | dagger/dagger | https://github.com/dagger/dagger | 1,802 | ["plan/task/push.go"] | Platform unknown for images built with dagger | When building images with dagger, I get a warning when running them:
```
WARNING: The requested image's platform (unknown) does not match the detected host platform (linux/amd64) and no specific platform was requested
```
It still runs though. I'm using Docker Desktop on macOS.
Example inspect from a Dockerfile built in dagger:
```json
[
{
"Comment": "buildkit.exporter.image.v0",
"Architecture": "",
"Os": "linux",
}
]
```
This is the same Dockerfile, but with `docker build`:
```json
[
{
"Comment": "buildkit.dockerfile.v0",
"Architecture": "amd64",
"Os": "linux",
}
]
```
The issue may be in `dagger.#Push`. | https://github.com/dagger/dagger/issues/1802 | https://github.com/dagger/dagger/pull/1827 | 30cbc64d86e8245cdf9edb2079cb610e5a3d68b4 | e484477bf9e640e528e980e47193e8d7908449f8 | "2022-03-14T19:52:06Z" | go | "2022-03-22T17:55:22Z" |
closed | dagger/dagger | https://github.com/dagger/dagger | 1,797 | ["website/package.json", "website/yarn.lock"] | A more sustainable strategy for cache storage | Perhaps a naive question. Given 1) the difficulties encountered with this cache export feature, 2) this is one of the easy ones (users will want to export cache to many various targets, most of which are not supported by buildkit at all)...
Perhaps we should start discussing an alternative design that is more sustainable long term (while we continue working on fixing this).
My observations:
- Buildkit local exporter is very mature, and works everywhere.
- The local exporter produces mostly immutable content-addressed blobs, and a little metadata.
- If dagger always exported its cache locally, then synchronized the local cache to a pluggable storage backend, it would be very easy to export cache in that way, including to GHA cache.
- *importing* cache would be more difficult per @aluzzardi (how do you know which blobs to download) but perhaps tackling that problem, although difficult, is a better tradeoff than climbing a new mountain for each new export target we need buildkit to support? Given the current difficulties with one of the *best-supported* targets, that seems unsustainable. I think we need a plan B.
My 2c.
__Originally posted by @shykes in https://github.com/dagger/dagger/issues/1020#issuecomment-1067072805__ | https://github.com/dagger/dagger/issues/1797 | https://github.com/dagger/dagger/pull/3001 | 8e63dabb803bdaf41175f7bef1799b7c7ed02dae | c81c3dfdfebb3bce4de99b4a6fcc3ad55d81bbda | "2022-03-14T17:09:26Z" | go | "2022-09-12T09:15:30Z" |
closed | dagger/dagger | https://github.com/dagger/dagger | 1,789 | ["pkg/dagger.io/dagger/nop.cue", "plan/task/nop.go"] | Actions with no core buildkit actions don't trigger filesystem write | ## Problem
Some actions don't need to call buildkit. For example a simple string transformation using only CUE builtins. These actions can be called with `dagger do`, but any client filesystem writes that depend on them will *not* be triggered.
## Example
```
import (
"strings"
"dagger.io/dagger"
)
dagger.#Plan & {
client: filesystem: write: "./output": contents: actions.upper.output
actions: upper: {
input: "hello, world"
output: strings.ToUpper(input)
}
}
```
```
$ dagger do upper
$ cat output
cat: can't open 'output': No such file or directory
```
## Workaround
A pure cue action can wrap its output in dagger.#Nop, which will trigger client filesystem writes. Requires merging #1790. | https://github.com/dagger/dagger/issues/1789 | https://github.com/dagger/dagger/pull/1790 | 4b82a3fb4ab9073a8a7705c17b67725da1558b47 | 8b7e591851fd53e4f9252c8d84e67a99440107b6 | "2022-03-12T05:56:07Z" | go | "2022-03-16T20:40:26Z" |
closed | dagger/dagger | https://github.com/dagger/dagger | 1,777 | ["cmd/dagger/cmd/do.go", "compiler/value.go", "plan/action.go", "plan/plan.go"] | `dagger do --help`: cleaner formatting of available action list | ## Problem
When listing available actions with `dagger do --help`, the formatting is messy.
* Multi-line comments are printed as is
* No "Available Options" section header
* Misaligned descriptions
* Easy to miss actions at the end
Example, running from the root of dagger repo:
```
$ dagger version
dagger devel (7b4b5915) linux/amd64
```
```
$ dagger do --help
Execute a dagger action.
Usage:
dagger do [OPTIONS] ACTION [SUBACTION...] [flags]
Flags:
--cache-from stringArray External cache sources (eg. user/app:cache, type=local,src=path/to/dir)
--cache-to stringArray Cache export destinations (eg. user/app:cache, type=local,dest=path/to/dir)
-h, --help help for do
--no-cache Disable caching
-p, --plan string Path to plan (defaults to current directory) (default ".")
-w, --with stringArray
Global Flags:
--log-format string Log format (auto, plain, tty, json) (default "auto")
-l, --log-level string Log level (default "info")
build Go build the dagger binary
depends on goLint and goTest to complete successfully
goTest Go unit tests
goLint Go lint using golangci-lint
cueLint CUE lint
```
## Solution
* Only print first line of comment
* Add "Available Options" section header
* Fix description alignment
* Move actions to the top
Same example:
```
$ dagger do --help
Execute a dagger action.
Usage:
dagger do [OPTIONS] ACTION [SUBACTION...] [flags]
Available Actions:
build Go build the dagger binary
goTest Go unit tests
goLint Go lint using golangci-lint
cueLint CUE lint
Flags:
--cache-from stringArray External cache sources (eg. user/app:cache, type=local,src=path/to/dir)
--cache-to stringArray Cache export destinations (eg. user/app:cache, type=local,dest=path/to/dir)
-h, --help help for do
--no-cache Disable caching
-p, --plan string Path to plan (defaults to current directory) (default ".")
-w, --with stringArray
Global Flags:
--log-format string Log format (auto, plain, tty, json) (default "auto")
-l, --log-level string Log level (default "info")
``` | https://github.com/dagger/dagger/issues/1777 | https://github.com/dagger/dagger/pull/1782 | 35751bc2123174b73715c332c175e8bb63b1ff6f | 21c6af067836ce33d9c1f5bcb06c68ab0448d403 | "2022-03-11T08:21:50Z" | go | "2022-03-14T19:56:43Z" |
closed | dagger/dagger | https://github.com/dagger/dagger | 1,776 | ["go.mod", "go.sum"] | gnu parallel is not always working | Different versions of parallel may not be working / compatible with bats (for example on `debian:bullseye`).
Ideas to work-around it:
* sanity test parallel version and fallback to `--jobs 1` if it does not fit the bill
* make the number of parallelized jobs easy to control (environment) so that one can disable parallel on integration tests if need be
cc @grouville @aluzzardi | https://github.com/dagger/dagger/issues/1776 | https://github.com/dagger/dagger/pull/3541 | 7b0c2f0f8d4a421bd3a06c5c8b31e6272708e902 | 42be78c8f860b9ed2b6803619c9d70353918a4a0 | "2022-03-11T04:10:40Z" | go | "2022-10-25T21:17:24Z" |
closed | dagger/dagger | https://github.com/dagger/dagger | 1,764 | ["go.mod", "go.sum"] | `dagger do --help`: "failed to load plan" with no detail | When calling `dagger do --help` against an invalid plan, the error "failed to load plan" is printed, without details. This makes it difficult to fix the issue with the plan. | https://github.com/dagger/dagger/issues/1764 | https://github.com/dagger/dagger/pull/6569 | e06291a14e7f694ea2b04c1e30c41ebe751f8f21 | 806d6580e5158cad92ea4dcf23c966b225402374 | "2022-03-10T22:19:53Z" | go | "2024-02-06T12:01:33Z" |
closed | dagger/dagger | https://github.com/dagger/dagger | 1,759 | ["docs/knowledge-base/1214-migrate-from-dagger-0.1.md", "website/sidebars.js"] | Docs: "Migrating from Dagger 0.1 to 0.2" | This is a high priority item. We want to help users migrating their plan from 0.1 to 0.2. The first step is to give them a clear entry point. This should be a page in our documentation. We can iterate on this page over time, to include more information, redirect them to the right discussion thread, issue or discord channel, etc. But the page needs to exist first.
| https://github.com/dagger/dagger/issues/1759 | https://github.com/dagger/dagger/pull/1773 | a7d5b366eacdb4753e1f0c9abf68362069959aa5 | e499297e77a370a8e7d18fca923f294bf1722cd6 | "2022-03-10T20:02:57Z" | go | "2022-03-11T02:13:33Z" |
closed | dagger/dagger | https://github.com/dagger/dagger | 1,753 | ["website/package.json", "website/yarn.lock"] | Docs: include "What is CUE" page from 0.1 into 0.2 docs | null | https://github.com/dagger/dagger/issues/1753 | https://github.com/dagger/dagger/pull/2854 | 94a4978910e6628608424088a4bb4d15e4d1b0ee | e1f0e870b80a0b434f9812eb87aee6f259da1546 | "2022-03-10T18:53:48Z" | go | "2022-07-28T08:49:46Z" |
closed | dagger/dagger | https://github.com/dagger/dagger | 1,719 | ["go.mod", "go.sum"] | `dagger do`: expose input fields as command-line flags | ## Overview
A nice improvement of `dagger do` would be to detect incomplete fields in the action, and expose them as part of the action interface, as magical command-line flags. For example:
```
// Say hello
actions: hello: {
// Specify a greeting
greeting: string | *"hello"
// Specify a name
name: string | *"world"
message: "\(greeting), \(name)!"
}
```
```
$ dagger do hello --help
Usage: dagger do hello [--name STRING] [--greeting STRING]
Say hello
Options:
--greeting STRING Specify a greeting. (default: "hello")
--name STRING Specify a name (default: "world")
```
```
$ dagger do hello --message bonjour --name monde
``` | https://github.com/dagger/dagger/issues/1719 | https://github.com/dagger/dagger/pull/2699 | 3127b4aad6f80e7464fbf38d32b984f1d206215e | 0312696a950a239889b27c19c2dc517086bf0f74 | "2022-03-09T00:30:38Z" | go | "2022-06-22T15:23:37Z" |
closed | dagger/dagger | https://github.com/dagger/dagger | 1,716 | ["sdk/nodejs/package.json", "sdk/nodejs/yarn.lock"] | Add template to dagger project init | ### Context
Currently, `dagger project init` only create an empty `cue.mod`.
I think it would be great to also generate template file to facilitate initialisation.
### V1.0 - Simple initialisation
To begin with, `dagger project init` could generate a simple `main.cue` file with a `Hello World`
```cue
// main.cue
package main
import (
"dagger.io/dagger"
"universe.dagger.io/bash"
"universe.dagger.io/alpine"
)
dagger.#Plan & {
actions: {
// Pull and build alpine container with bash
_image: alpine.#Build & {
packages: {
bash: _
}
}
// Hello World Dagger
hello: bash.#Run & {
input: _image.output
script: contents: "echo Hello World"
}
}
}
```
Indeed, I think we can add additional advices or whatever useful to onboard on initialisation
### V2.0 - Template
As a final improvement, we could create a complete library with many useful template for multiple use-cases.
Here a list of possible template :
- Build and push a container
- Deploy a website to vercel
- Golang CI (test, build, lint...)
- Node CI (test, build, lint...)
- Hello world (from v1.0)
- Kubernetes deployment
- AWS configuration
- GCP configuration
Feel free to add any idea in this list. | https://github.com/dagger/dagger/issues/1716 | https://github.com/dagger/dagger/pull/4804 | c56057ff30d9e906680f384c332e8e96ea0d4834 | af8b047ea2407967ba7b18510be81cad8f73afd8 | "2022-03-08T23:23:51Z" | go | "2023-03-27T13:43:04Z" |
closed | dagger/dagger | https://github.com/dagger/dagger | 1,715 | ["go.mod", "go.sum"] | docs: snippets should be outside of markdown | Flagging this for post-europa.
CUE snippets used to be external to markdown files, like so:
```
```cue file=./tests/cloudformation/template.cue title="todoapp/cloudformation/template.cue"
``
```
This allows:
1. CUE linter cleaning up the files / validating them
2. Adding automated tests using the snippets, to make sure the docs work
I think I've seen a couple of embedded CUE snippets in the latest Europa markdowns (/cc @gerhard @helderco) | https://github.com/dagger/dagger/issues/1715 | https://github.com/dagger/dagger/pull/6569 | e06291a14e7f694ea2b04c1e30c41ebe751f8f21 | 806d6580e5158cad92ea4dcf23c966b225402374 | "2022-03-08T23:03:28Z" | go | "2024-02-06T12:01:33Z" |
closed | dagger/dagger | https://github.com/dagger/dagger | 1,699 | ["website/package.json", "website/yarn.lock"] | `dagger do`: suggest `dagger update` on missing dependencies | When running `dagger do` fails because of missing dependencies, the user should be presented with a clear error message that suggests that perhaps there are missing dependencies, and perhaps running `dagger update` would solve the problem.
| https://github.com/dagger/dagger/issues/1699 | https://github.com/dagger/dagger/pull/2500 | 3950440ed87eee5ef42463d99078cd0f2be410fa | dafe1b8b4484789cf73e71fc59e6709c0b1c9e7c | "2022-03-07T22:34:50Z" | go | "2022-05-30T13:02:11Z" |
closed | dagger/dagger | https://github.com/dagger/dagger | 1,698 | ["cmd/dagger/cmd/root.go", "go.mod", "go.sum"] | 0.2: hide `dagger completion` | The `dagger completion` command is useful, especially for automated installers (homebrew etc). But it should not be visible to humans running `dagger help`. It should be hidden. | https://github.com/dagger/dagger/issues/1698 | https://github.com/dagger/dagger/pull/1748 | 45f3121abeaafd1c56b69eb46608a519080a6a94 | 2b30bd027d52f0f633653d85efaa515fc08a1c1d | "2022-03-07T22:33:11Z" | go | "2022-03-10T14:50:10Z" |
closed | dagger/dagger | https://github.com/dagger/dagger | 1,696 | ["sdk/nodejs/package.json", "sdk/nodejs/yarn.lock"] | 0.2: Hide or remove `dagger up` | null | https://github.com/dagger/dagger/issues/1696 | https://github.com/dagger/dagger/pull/4804 | c56057ff30d9e906680f384c332e8e96ea0d4834 | af8b047ea2407967ba7b18510be81cad8f73afd8 | "2022-03-07T22:32:32Z" | go | "2023-03-27T13:43:04Z" |
closed | dagger/dagger | https://github.com/dagger/dagger | 1,689 | ["cmd/dagger/cmd/root.go", "go.mod"] | Do not show commandconn WARN messages on the first dagger run | When `dagger` runs for the first time against a local Docker Engine, it shows the following `WARN` messages:
```
WARN[0002] commandConn.CloseWrite: commandconn: failed to wait: signal: terminated
WARN[0002] commandConn.CloseRead: commandconn: failed to wait: signal: terminated
WARN[0002] commandConn.CloseWrite: commandconn: failed to wait: signal: terminated
```
This is a bad first experience, and we should improve our first impression.
Point-in-time capture of the latest `dagger` dev version behaviour (pre `0.2.0-beta.1`)
<img width="863" alt="image" src="https://user-images.githubusercontent.com/3342/156835873-b3b92bd5-747c-4b24-bc75-3a778ee47435.png">
| https://github.com/dagger/dagger/issues/1689 | https://github.com/dagger/dagger/pull/2161 | 464c7ad708ba93e15df08d71ab3f552539b243f6 | 991c8dc6ff4538b55fe82af42a2d5bd93d5bf256 | "2022-03-04T20:20:02Z" | go | "2022-04-13T01:11:05Z" |
closed | dagger/dagger | https://github.com/dagger/dagger | 1,684 | ["go.mod", "go.sum"] | dagger project init | Comments from discord #dev:dagger project thread:
@shykes says: `dagger project init` is basically a wrapper for cue mod init. Perhaps it has options to add templates, scaffolding, whatever. All optional features we can add later.
As a basic start, `dagger project init` will mimic behavior of `cue mod init`
- create the following folders and files under the path provided by `--project` flag (defaults to `./`)
- `cue.mod`
- `cue.mod/module.cue`
- `cue.mod/pkg`
- `cue.mod/usr`
- fill `module:` name with `[module]` argument
To use: `dagger project init -p path/to/project [module]` where `module` is a valid cue module such as `github.com/foo/bar`
| https://github.com/dagger/dagger/issues/1684 | https://github.com/dagger/dagger/pull/5460 | ff60a9080d7d79cc5180926095b6eeb691215b13 | a57fcd1431bf61911d7adce1ec9b045e8831b38d | "2022-03-03T22:58:48Z" | go | "2023-07-14T18:56:47Z" |
closed | dagger/dagger | https://github.com/dagger/dagger | 1,670 | ["pkg/universe.dagger.io/yarn/test/test.cue", "pkg/universe.dagger.io/yarn/yarn.cue"] | [Bug] universe.dagger.io/yarn cache mount config results in yarn package corruption | ## What is the problem?
Running `yarn.#Build` & `yarn.#Run` in parallel always results in yarn package corruption:
```sh
5:13PM INF actions.test.container._exec | computing
5:13PM INF actions.build.container._exec | computing
5:13PM INF actions.build.container._exec | #9 1.958 yarn install v1.22.17
5:13PM INF actions.build.container._exec | #9 2.751 [1/4] Resolving packages...
5:13PM INF actions.build.container._exec | #9 6.398 [2/4] Fetching packages...
5:13PM INF actions.build.container._exec | #9 9.576 error https://registry.yarnpkg.com/supports-color/-/supports-color-5.5.0.tgz: Integrity check failed for "supports-color" (computed integrity doesn't match our records, got "sha512-z4PhNX7vuL3xVChQ1m2AB9Yg5AULVxXcg/SpIdNs6c5H0NE8XYXysP+DGNKHfuwvY7kxvUdBeoGlODJ6+SfaPg== sha1-2jmj7l5rSw0yVb/vlWAYkK/YBwk=")
5:13PM INF actions.build.container._exec | #9 9.577 info Visit https://yarnpkg.com/en/docs/cli/install for documentation about this command.
5:13PM INF actions.test.container._exec | #8 2.006 yarn install v1.22.17
5:13PM INF actions.test.container._exec | #8 2.784 [1/4] Resolving packages...
5:13PM INF actions.test.container._exec | #8 6.451 [2/4] Fetching packages...
5:13PM INF actions.test.container._exec | #8 9.592 error An unexpected error occurred: "ENOENT: no such file or directory, open '/cache/yarn/v6/npm-supports-color-5.5.0-e2e69a44ac8772f78a1ec0b35b689df6530efc8f-integrity/node_modules/supports-color/.yarn-metadata.json'".
5:13PM INF actions.test.container._exec | #8 9.593 info If you think this is a bug, please open a bug report with the information provided in "/src/yarn-error.log".
5:13PM INF actions.test.container._exec | #8 9.593 info Visit https://yarnpkg.com/en/docs/cli/install for documentation about this command.
5:13PM ERR actions.build.container._exec | failed: process "bash --norc -e -o pipefail /bash/scripts/run.sh" did not complete successfully: exit code: 1 duration=18.1s
5:13PM ERR actions.test.container._exec | canceled duration=18.1s
5:13PM FTL system | failed to up environment: task failed: actions.build.container._exec: process "bash --norc -e -o pipefail /bash/scripts/run.sh" did not complete successfully: exit code: 1
```
## How to reproduce it?
Follow https://deploy-preview-1586--devel-docs-dagger-io.netlify.app/1200/local-dev/ with a dev version of `dagger`.
## Did this use to work?
Yes, [11 days ago](https://github.com/dagger/examples/pull/54#issuecomment-1045298941), with `v0.2.0-alpha.5`.
I suspect [buildkit v0.10.0-rc.2](https://github.com/moby/buildkit/releases/tag/v0.10.0-rc2) may have something to do with it, but it's just a guess.
## What should happen next?
Find the simplest fix.
By the way, trying to fix this problem by setting the `name` property triggers other bugs. I time-boxed it to 30 mins and having gone in circles, I moved it to out of scope.
cc @samalba @aluzzardi @shykes
---
This was discovered part of https://github.com/dagger/dagger/pull/1586.
It is blocking the most important Europa doc: **Getting Started - CI/CD in your local dev** | https://github.com/dagger/dagger/issues/1670 | https://github.com/dagger/dagger/pull/1673 | d8af79166e06364f9217320b553f6f2bf963a60b | 5267d72b1da65213120748a5ad50b5d808fb82d6 | "2022-03-01T17:26:51Z" | go | "2022-03-04T18:48:06Z" |
closed | dagger/dagger | https://github.com/dagger/dagger | 1,659 | ["pkg/dagger.io/dagger/core/exec.cue", "pkg/universe.dagger.io/docker/run.cue", "tests/tasks/exec/user.cue"] | Strange buildkit error on yarn test | ## Problem
When running the standard integration tests for `universe.dagger.io/yarn`, on `main`, the test fails with a cryptic buildkit/docker error. As far as I know, this test is not failing in CI. There is no recent change to this package that seems relevant.
## Steps to reproduce
### 1. Check current commit:
```
$ git show
commit 1135398beec4965f095ca70917908a06d804ff22 (HEAD -> main, origin/main, origin/HEAD)
Merge: 47a8bbc3 f6cee7f3
Author: Solomon Hykes <[email protected]>
Date: Wed Feb 23 14:05:13 2022 -0800
Merge pull request #1644 from shykes/go-fix
go.#Build: small improvements
```
### 2. Run yarn test
```
$ dagger up ./pkg/universe.dagger.io/yarn/test
...
```
### 3. Observe cryptic error
```
...
$ dagger up
[β] inputs.directories.testdata 0.0s
[β] actions.tests.customImage.buildImage 0.8s
[β] actions.tests.customImage.build 0.6s
[β] actions.tests.customName.build.container.script 0.0s
[β] inputs.directories.testdata2 0.0s
[β] actions.tests.simple.build 0.7s
[β] actions.tests.customName.build 0.8s
[β] actions.tests.customImage.build.container.script 0.0s
[β] actions.tests.simple.build.container.script 0.0s
[β] actions.tests.simple.build.container 0.1s
[β] actions.tests.customImage.build.container 0.1s
[β] actions.tests.customName.build.container 0.0s
7:27AM FTL failed to up environment: task failed: actions.tests.simple.build.container._exec:
process "bash --norc -e -o pipefail /bash/scripts/run.sh" did not complete successfully: unable to find user root: invalid argument
```
## Speculation on root cause
* Perhaps the recent upgrade to buildkit 0.10rc1 is to blame?
* I suspected an apparmor configuration error, because of https://github.com/portainer/portainer/issues/4319 . But I reproduced the issue on 2 completely different machines, one running Alpine Linux, the other running NixOS. This makes a distro config error less likely.
| https://github.com/dagger/dagger/issues/1659 | https://github.com/dagger/dagger/pull/2542 | af955dccb3f4bac86a54893d784ca99d94127f30 | 9f79d63cf8a44557ce033a54584ca2a998b051aa | "2022-02-24T07:29:33Z" | go | "2022-06-01T21:05:33Z" |
closed | dagger/dagger | https://github.com/dagger/dagger | 1,625 | ["go.mod", "go.sum"] | Better DX for healthcheck | I think the `test` field in `healthcheck` should be abstracted into a new `cmd` field and the time intervals could also be humanized.
Currently the `test` field is a single list where the first element has special meaning:
```cue
#HealthCheck: {
test?: [...string]
interval?: int
timeout?: int
startperiod?: int
retries?: int
}
```
The options are:
- `[]`: inherit healthcheck
- `["NONE"]` : disable healthcheck
- `["CMD", args...]` : exec arguments directly
- `["CMD-SHELL", command]` : run command with system's default shell
Here's what some dockerfile instructions produce:
#### CMD-SHELL
```dockerfile
HEALTHCHECK --interval=5m --timeout=3s CMD curl -f http://localhost/ || exit 1
```
```cue
healthcheck: {
test: [
"CMD-SHELL",
"curl -f http://localhost/ || exit 1",
]
interval: 300000000000
timeout: 3000000000
}
```
#### CMD
```dockerfile
HEALTHCHECK --interval=5m --timeout=3s CMD ["curl", "-f", "http://localhost/"]
```
```cue
healthcheck: {
test: [
"CMD",
"curl",
"-f",
"http://localhost/",
]
interval: 300000000000
timeout: 3000000000
}
```
#### NONE
```dockerfile
HEALTHCHECK NONE
```
```cue
healthcheck: {
test: ["NONE"]
}
```
## Proposal
Change to:
```cue
#HealthCheck: {
{
disable: true
} | {
cmd: string | [...string]
interval?: int | #Duration
timeout?: int | #Duration
start_period?: int | #Duration
retries?: int
}
}
#Duration: string // regex here
```
Then, the previous calls would become:
```cue
config: {
healthcheck: {
cmd: "curl -f http://localhost/ || exit 1"
interval: "3s"
timeout: "3s"
}
}
config: {
healthcheck: {
cmd: ["curl", "-f", "http://localhost/"]
interval: "3s"
timeout: "3s"
}
}
config: {
healthcheck: disable: true
}
``` | https://github.com/dagger/dagger/issues/1625 | https://github.com/dagger/dagger/pull/2699 | 3127b4aad6f80e7464fbf38d32b984f1d206215e | 0312696a950a239889b27c19c2dc517086bf0f74 | "2022-02-16T17:39:50Z" | go | "2022-06-22T15:23:37Z" |
closed | dagger/dagger | https://github.com/dagger/dagger | 1,624 | ["go.mod", "go.sum"] | Unset image metadata | Ever since I started working on #1535, I wanted to be able to also unset some things.
I tried a first pass at the time that didn't work out, but decided to not delay because of it. I want to try again π
For me this has come up for one reason. Sometimes I use a base image that's mostly fine, but I wish they hadn't set up a few `VOLUME`, `EXPOSE` or `ENV` instructions.
I've wondered about a `docker.#Unset`, but it's not clear to me how you would chose what to delete precisely.
What I want to explore is to allow `docker.#Set` to have _null_ values, which would efectively unset the field:
```cue
dagger.#Set & {
// this would be a **version** of #ImageConfig that accepts nulls
config: {
volume: {
"/etc/salt/pki/": null
"/home/.console": {}
}
expose: {
"4505/tcp": null
"4506/tcp": null
"9090/tcp": {}
}
env: {
MARIADB_NAME: null
MARIADB_USERNAME: null
NGINX_PORT_NUMBER: "8080"
}
entrypoint: ["/init.sh"]
}
}
```
`input` and `output` would still be normal `#ImageConfig`. | https://github.com/dagger/dagger/issues/1624 | https://github.com/dagger/dagger/pull/1756 | c82bc00f879919a49a80772a6a3d2ab1de77f2c2 | a698ef1c08159c13ba9fcceccacf0030a06bb0dc | "2022-02-16T16:55:43Z" | go | "2022-03-10T19:17:17Z" |
closed | dagger/dagger | https://github.com/dagger/dagger | 1,623 | ["sdk/nodejs/package.json", "sdk/nodejs/yarn.lock"] | [Question] How to add user cue package? | After `dagger init`, it will generate a `cue.mod` with default dagger packages. How can I add a new dagger package of my own? I saw a `usr/` directory. Is it the right place?
<img width="305" alt="image" src="https://user-images.githubusercontent.com/920884/154194009-e14c566e-a4c6-47cb-b6c0-8a4ab1499f33.png">
| https://github.com/dagger/dagger/issues/1623 | https://github.com/dagger/dagger/pull/3807 | 072a6c1b2e76724bcd1209c2a3db853acb43f314 | 19954e6202edd8f4fb0fb372dc3ea3e013e95c0d | "2022-02-16T04:03:58Z" | go | "2022-11-16T16:26:31Z" |
closed | dagger/dagger | https://github.com/dagger/dagger | 1,598 | ["website/package.json", "website/yarn.lock"] | Action API | ## Overview
I propose formalizing the concept of an *action*, and exposing it to developers in a new *Action API*.
Using the Action API, developers can:
* Customize how the DAG is presented to the user at runtime (show actual actions instead of raw CUE tree or low-level tasks)
* Synchronize actions: #940, #1249 , etc.
* Make error messages more useful. The hierarchy of actions act as a "stack frame" with less noise than raw CUE errors
This proposal is one part of a 4-part bundle:
* #1598 (this proposal)
* #1597
* #1558
* #1579
## Proposed design
This is a work in progress. Fire at will.
### #Action definition
```cue
package dagger
#Action: {
_dagger: action: {
// Unique ID assigned by engine. Use for synchronization
id: #ID
// Human-friendly human name (defaults to parent field name)
name?: string
// Long description (defaults to comments above parent field)
description?: string
// Print a message to the user before executing the action
before?: string
// Print a message to the user after executing the action
after?: string
}
...
}
// A unique object ID allocated at runtime
#ID: string
```
Usage example:
```cue
package main
import (
"dagger.io"
)
dagger.#Plan & {
actions: {
// Not an action
staging: {
// This is an action
deploy: {
_dagger: action {
description: "Deploy staging environment"
after: """
Staging deployed:
Frontend: \(www.url)
Backend: \(api.url)
"""
}
www: netlify.#Deploy & {
...
}
api: ecs.#Deploy & {
...
}
}
}
```
### Synchronization
*TODO*
### Core actions
Core actions implement the `#Action` interface, so their output can be customized, synchronized, etc. This is not yet implemented.
## Related issues
* #1558
* #940
* #1249
* #1579 | https://github.com/dagger/dagger/issues/1598 | https://github.com/dagger/dagger/pull/1458 | 3dab09292468d95a83341a3dc0fd9d4a8d44d78a | abcd01ccfa5ffa88669b61af77b59258e5bd795c | "2022-02-11T02:15:01Z" | go | "2022-01-19T23:56:56Z" |
closed | dagger/dagger | https://github.com/dagger/dagger | 1,560 | ["website/package.json", "website/src/theme/Navbar/index.js", "website/src/theme/Navbar/styles.module.css", "website/yarn.lock"] | docs.dagger.io fails to run locally | When I run `make web`, I get the following errors:
This is what I get in a browser:
If I bump docusaurus to `^2.0.0-beta.15`, I get the following errors:
And the docs are still broken in the browser:
The only fix that worked for me was to revert back to a previous version via `git checkout 0a44aecf559a446155a8e2d0abc20de75ac84ab7 -- website/`
I am not going to paste the output of `git diff --staged` because it's >4k lines long.
These are the commits between the version that works for me, and the current `main`:
```log
git log 0a44aecf559a446155a8e2d0abc20de75ac84ab7..main --oneline -- website
c1b1cdb0 (origin/main, origin/HEAD, main) Merge pull request #1541 from dagger/dependabot/npm_and_yarn/website/cypress-9.4.1
b58edfe1 Merge pull request #1542 from dagger/dependabot/npm_and_yarn/website/mdx-js/react-2.0.0
28000409 build(deps): bump sass from 1.49.0 to 1.49.4 in /website
d1103b1a build(deps): bump @mdx-js/react from 1.6.22 to 2.0.0 in /website
adea6b87 build(deps-dev): bump cypress from 9.3.1 to 9.4.1 in /website
6bb87863 build(deps): bump amplitude-js from 8.16.0 to 8.16.1 in /website
b838e09e build(deps): bump @svgr/webpack from 6.2.0 to 6.2.1 in /website
a1163007 build(deps): bump @docusaurus/core in /website
1e46a954 build(deps): bump nanoid from 3.1.30 to 3.2.0 in /website
2db670d5 build(deps): bump amplitude-js from 8.15.1 to 8.16.0 in /website
0da34f00 build(deps): bump docusaurus-plugin-sass from 0.2.1 to 0.2.2 in /website
fd367c4b build(deps): bump sass from 1.48.0 to 1.49.0 in /website
fa674280 Merge pull request #1459 from dagger/dependabot/npm_and_yarn/website/cypress-9.3.1
511f5fc3 build(deps): bump amplitude-js from 8.15.0 to 8.15.1 in /website
acca5a9a build(deps-dev): bump cypress from 9.2.1 to 9.3.1 in /website
aa4cdd9c docs: :bug: increate cypress get timeout to avoid github action errors
52fbdfc7 build(deps): bump shelljs from 0.8.4 to 0.8.5 in /website
567aa492 Bump sass from 1.47.0 to 1.48.0 in /website
4b763b29 Merge pull request #1412 from dagger/dependabot/npm_and_yarn/website/follow-redirects-1.14.7
d1bd6c7d Bump follow-redirects from 1.14.6 to 1.14.7 in /website
f2ad4667 Bump @svgr/webpack from 5.5.0 to 6.2.0 in /website
6b301b27 docs: :bug: fix editurl path
707a3f0a docs: :bug: Fix Cypress test wrapper
b69866b7 docs: :package: Update docusaurus to beta-14
```
Hope that helps you narrow down this issue @slumbering. | https://github.com/dagger/dagger/issues/1560 | https://github.com/dagger/dagger/pull/1562 | 5dfdf5149f75e5db24a72a5a3244cfc479fb8b09 | c04d0cdd0bced70363beaa4a1a4def2559d58d41 | "2022-02-07T08:41:55Z" | go | "2022-02-07T11:09:41Z" |
closed | dagger/dagger | https://github.com/dagger/dagger | 1,559 | ["pkg/universe.dagger.io/bash/test/test.cue", "pkg/universe.dagger.io/docker/run.cue", "pkg/universe.dagger.io/docker/test/run.cue", "pkg/universe.dagger.io/netlify/netlify.cue", "pkg/universe.dagger.io/yarn/yarn.cue"] | docker.#Run: export files and directories to a shorter path | Change the API for `docker.#Run.export.files` and `docker.#Run.export.directories`, so that the `contents` field is not needed.
The API is not changed for *declaring* exports:
```
action: run: docker.#Run & {
export: {
files: "/foo.txt": _
directories: "/bar": _
}
}
```
The API is changed for *referencing* exports. Note the absence of `contents` field:
```
action: run: _
foo: run.export.files."/foo.txt"
bar: run.export.directories."/bar"
```
This would incrementally improve the developer experience. | https://github.com/dagger/dagger/issues/1559 | https://github.com/dagger/dagger/pull/1603 | a01ee5f8b0436584d32da9b0fb0f2151edb61982 | 51cc976242edf9673a39a4f6dd86dfa59a4840b9 | "2022-02-07T06:48:39Z" | go | "2022-02-18T21:55:31Z" |
closed | dagger/dagger | https://github.com/dagger/dagger | 1,556 | ["website/package.json", "website/yarn.lock"] | Port bats package to europa universe | cf. https://github.com/dagger/dagger/issues/1549 | https://github.com/dagger/dagger/issues/1556 | https://github.com/dagger/dagger/pull/1163 | 399a7aba30493315f11bcd4390c8a16e290ff6d6 | 51af80b5a87fe41793c0218594dfba272b71d1ba | "2022-02-04T21:13:11Z" | go | "2021-11-29T21:48:22Z" |
closed | dagger/dagger | https://github.com/dagger/dagger | 1,555 | ["pkg/universe.dagger.io/docker/run.cue", "pkg/universe.dagger.io/docker/test/run.cue"] | Europa: docker.#Run entrypoint behavior does not seem to match docker run cli | The default behavior of `docker run` when no `--entrypoint` is provided, and `ENTRYPOINT[]` has not been overridden is to use `/bin/sh -c`. This allows `CMD` to be easily processed through the shell. Overridding entrypoint allows for bootstrapping scripts to do setup, perhaps `export` some necessary env vars, then `exec "$@"` as one example.
The current implementation does not seem to allow providing a direct entrypoint to use besides the one in image config. From `docker.#Run._exec`:
```cue
if cmd != _|_ {
args: [cmd.name] + cmd._flatFlags + cmd.args
}
if cmd == _|_ {
args: list.Concat([
if _image.config.entrypoint != _|_ {
_image.config.entrypoint
},
if _image.config.cmd != _|_ {
_image.config.cmd
},
])
}
```
In the above code, `cmd` is always exec'd without a shell which is fine, but the only way to use entrypoint and arbitrary commands together is to set them in the image config which by the nature of immutable configs you must do so via `engine.#Set` which can be verbose and confusing.
It seems that `docker.#Run` should provide an `entrypoint` field; if this field is `_|_` then image.config.entrypoint is used instead, and if that is `_|_` then `docker.#Run` defaults to what? `/bin/sh -c` ? or nothing? | https://github.com/dagger/dagger/issues/1555 | https://github.com/dagger/dagger/pull/1808 | 749278965c0b2cbc2c9936625d63da225c24a777 | 323f01278a686f034a0fb8aa59c5ef4ad6d6349c | "2022-02-04T19:11:57Z" | go | "2022-03-21T17:18:18Z" |
closed | dagger/dagger | https://github.com/dagger/dagger | 1,532 | ["pkg/universe.dagger.io/alpine/alpine.cue"] | Alpine: ability to pin package version might be useless | (placeholder) as discussed with @aluzzardi, Alpine ties package versions to Alpine version, so there may never be a useful way to pin `packages.FOO.version`.
| https://github.com/dagger/dagger/issues/1532 | https://github.com/dagger/dagger/pull/1548 | c1b1cdb062a715539032af855b6877e7ff2e3e2c | 1d1b9083b338faec823c443d1726a589e3155ad0 | "2022-01-31T20:19:41Z" | go | "2022-02-04T00:06:06Z" |
closed | dagger/dagger | https://github.com/dagger/dagger | 1,492 | ["plan/task/source.go", "tests/tasks.bats", "tests/tasks/dockerfile/cue.mod/pkg/.gitignore", "tests/tasks/source/source.cue", "tests/tasks/source/source_invalid_path.cue", "tests/tasks/source/source_relative.cue", "tests/tasks/source/testdata/world.txt"] | engine.#Source.path is not properly supporting relative paths | In some cases setting `path: "./scripts"` results in 'invalid path' or `path does not exist` errors. It seems it looks for the path to be relative to `cwd` rather than `v.Filename` | https://github.com/dagger/dagger/issues/1492 | https://github.com/dagger/dagger/pull/1527 | a0c89a335fd02b7de600bc426f40c810df5f8110 | a850f5453327382d44a315ebf365041434ffc39b | "2022-01-24T19:49:01Z" | go | "2022-01-28T23:21:14Z" |
closed | dagger/dagger | https://github.com/dagger/dagger | 1,489 | ["pkg/alpha.dagger.io/universe.bats"] | TestCompose is failing consistently | We had 3 failures in a row: https://github.com/dagger/dagger/runs/4921785672?check_suite_focus=true#step:9:426
While https://github.com/dagger/dagger/pull/1476 doesn't change anything code-wise in Dagger, I cannot merge it when the **CI / Universe** check is failing.
I am suspecting that it's the 100% CPU utilisation on the `dagger-ci` VM:
I don't know why this started happening just now, but if I had to guess since I don't have access to this VM, then I am suspecting file handles leaking.
The simplest thing to do is to restart this VM and see if it fixes itself - which I am going to do next - but this is something that I would like us to look into. This VM is a big liability for our pipeline and I would be keen on spending a bit of time improving it. | https://github.com/dagger/dagger/issues/1489 | https://github.com/dagger/dagger/pull/1493 | 21f81bc8f6329188aae20064975ee5efe1d6e9e5 | 2715b7b6d0a435103fc93d1d58769a2f580a69f9 | "2022-01-24T16:06:15Z" | go | "2022-01-25T11:15:51Z" |
closed | dagger/dagger | https://github.com/dagger/dagger | 1,482 | ["website/package.json", "website/yarn.lock"] | [Bug] Failed to test input/output | Trying to run the following to test dagger input/output
```
package func
import (
"alpha.dagger.io/dagger"
)
metadata: {
name: string & dagger.#Input
}
outputs: {
metadata: {
name: metadata.name & dagger.#Output
}
}
```
After running `dagger up`, the output value is always "_":
```
Output Value Description
outputs.metadata.name _ -
``` | https://github.com/dagger/dagger/issues/1482 | https://github.com/dagger/dagger/pull/982 | 1eec9ec8fe5bfac70339e5acb24dd2e59f18f9a6 | 6be4bbf49d209ad7d3ac95474216b98b53c3750e | "2022-01-22T03:29:11Z" | go | "2021-09-15T21:54:27Z" |
closed | dagger/dagger | https://github.com/dagger/dagger | 1,445 | ["pkg/universe.dagger.io/docker/push.cue"] | Europa: `auth` in `docker.#Push` doesn't seem to be working | If auth is only in `docker.#Push`:
```cue
dagger.#Plan & {
inputs: {
secrets: registry: envvar: "REGISTRY_PASSWORD"
}
actions: {
base: docker.#Pull & {
source: "alpine"
}
push: docker.#Push & {
dest: "registry.example.net/test"
image: base.image
auth: { ... }
}
}
}
```
I get this error:
```
ERR actions.push._push | failed: failed to solve: unexpected status: 401 Unauthorized
```
But if the same auth is also in `docker.#Pull` then it works. That's because the login is global to the session, so pull is authenticating but not push. | https://github.com/dagger/dagger/issues/1445 | https://github.com/dagger/dagger/pull/1448 | 6aed3348a0bd53916ddf3bf5782a2448633787fc | ed8bb3f91ba45ebce012beaaec0f9a43787824d8 | "2022-01-18T16:31:59Z" | go | "2022-01-19T18:36:32Z" |
closed | dagger/dagger | https://github.com/dagger/dagger | 1,429 | ["website/package.json", "website/yarn.lock"] | PROPOSAL: Simplify #TransformSecret | `#TransformSecret` is currently used as such:
```cue
repoPassword: engine.#TransformSecret & {
input: inputs.secrets.sops.contents
// output signature after tranformation
// output: #Secret | {[string]: output}
#function: {
input: _
output: yaml.Unmarshal(input)
}
}
```
- I think it's pretty cool but IMHO hard to grasp for the average person as it's using super advanced concepts (CUE callback as a definition with back and forth between the runtime).
- Using it is not reserved to advanced users -- anyone interacting with `sops` or any other structured secrets (json/yaml) will need this
- Even though the callback makes it generic and powerful, only CUE built-ins can be applied.
- I think the only realistic uses cases for this are `yaml.Unmarshal()` and `json.Unmarshal()`.
If we're limited to json/yaml unmarshaling, I think the following alternative would be simpler:
```cue
#UnmarshalSecret: {
// The original secret
input: #Secret
// Secret format
format: "json" | "yaml"
// A new secret or (map of secrets) with the transformation applied
output: #Secret | {[string]: output}
}
```
The drawback is there's things `#TransformSecret` can do that `#UnmarshalSecret` just can't. For instance, you could apply a `strings.Replace` transformation, etc.
But at what point are those common?
Keep in mind you can always write an action to manipulate a secret however you want (e.g. `strings.Replace` can be achieved with `bash.#Script` + `sed` + `engine.#NewSecret`).
The reason we need this is to manipulate structured secrets (e.g. "expanding" from one secret to a map of secret, which you cannot do otherwise), so wouldn't `UnmarshalSecret` fit the bill?
/cc @talentedmrjones @shykes @jlongtine | https://github.com/dagger/dagger/issues/1429 | https://github.com/dagger/dagger/pull/893 | 283a5f76a81cce679470806a76b5689c4887f4d8 | cfd5cfbfcbcbc556f4c1114614fc0ef1e6bbc18b | "2022-01-14T08:33:44Z" | go | "2021-08-20T15:26:37Z" |
closed | dagger/dagger | https://github.com/dagger/dagger | 1,378 | ["mod/require.go", "mod/require_test.go"] | Inconsistencies in dagger mod get | Currently you are forced to use the .git suffix if the repository is not from github.
The imported package keeps the suffix thus altering the import directive to be used, therefore the import will be different in the tests of the project containing the package compared to projects where dagger mod get is used.
Moreover, the structure of a [package](https://github.com/grouville/dagger-serverless) is different from what is [documented](https://docs.dagger.io/1010/dev-cue-package/)
Supposing we have a repository called gitlab.banana.org/wonderful with a tag called v0.1.0 and this repository contains a directory called poteto like the cue package name. In this case i have to do:
`dagger mod get gitlab.banana.org/wonderful.git/[email protected]`
The resulting package name will be gitlab.banana.org/wonderful.git/poteto
It would be better to remove the .git suffix or just treat gitlab (or others) the same way as github, in other words, make this command work:
`dagger mod get gitlab.banana.org/wonderful/[email protected]`
| https://github.com/dagger/dagger/issues/1378 | https://github.com/dagger/dagger/pull/1431 | e60b9dc268e491623f1327c7652ccda0664ca25b | 455beae7622e026e399b22ff02155e4b5b529b9a | "2022-01-10T18:04:14Z" | go | "2022-01-18T09:11:21Z" |
closed | dagger/dagger | https://github.com/dagger/dagger | 1,369 | ["plan/task/exec.go", "tests/tasks.bats", "tests/tasks/exec/http_proxy.cue"] | Dagger doesn't work behind a corporate proxy | dagger up return error behind a http proxy
Test with :
* dagger 0.1.0-alpha.31 (374f1ba) linux/amd64 and dagger devel (7d965942) linux/amd64
* Ubuntu 20.04.3 LTS
* Docker 20
All docker command work with my proxy (configure into ~/.docker/config.json and /etc/systemd/system/docker.service.d/http-proxy.conf)
But with dagger I got this error.
```
[β] wait 10.3s
[β] app.source 0.0s
[β] registry.run 10.3s
#5 0.160 fetch https://dl-cdn.alpinelinux.org/alpine/v3.15/main/x86_64/APKINDEX.tar.gz
#5 5.164 fetch https://dl-cdn.alpinelinux.org/alpine/v3.15/community/x86_64/APKINDEX.tar.gz
#5 5.164 WARNING: Ignoring https://dl-cdn.alpinelinux.org/alpine/v3.15/main: temporary error (try again later)
#5 10.17 WARNING: Ignoring https://dl-cdn.alpinelinux.org/alpine/v3.15/community: temporary error (try again later)
#5 10.17 ERROR: unable to select packages:
#5 10.17 bash (no such package):
#5 10.17 required by: world[bash]
[β] app.ctr 10.2s
8:45PM FTL failed to up environment: task failed: process "apk add -U --no-cache bash" did not complete successfully: exit code: 1
```
If I remove my VPN and proxy, first step of dagger are ok, but not the docker image download part :
```
8:47PM DBG detected buildkit config haveHostNetwork=true isActive=true version=v0.9.3
8:47PM DBG detected buildkit config haveHostNetwork=true isActive=true version=v0.9.3
8:47PM DBG failed to check universe version: universe not installed
8:47PM DBG spawning buildkit job attrs=null localdirs={
"/home/me/examples/todoapp": "/home/me/examples/todoapp"
}
[β] wait 35.7s
[β] app.source 0.1s
[β] registry.run 11.5s
[β] app.ctr 48.1s
[β] app.build 0.1s
[β] image 10.0s
dependency detected dependency=app.build
executing operation do=load pipeline=image
executing operation do=fetch-container pipeline=image.#up[0].from
#17 load metadata for docker.io/library/nginx:latest
#17 sha256:06c466a4eb6821b81bd3e48610e5f38dab858b1e9acb01d6e2f6b11c8fabe6bc
#17 ERROR: failed to do request: Head "https://registry-1.docker.io/v2/library/nginx/manifests/latest": proxyconnect tcp: dial tcp: lookup proxy on 127.0.0.53:53: server misbehaving
------
> @image.#up[0].from@ load metadata for docker.io/library/nginx:latest:
------
8:48PM FTL failed to up environment: task failed: failed to do request: Head "https://registry-1.docker.io/v2/library/nginx/manifests/latest": proxyconnect tcp: dial tcp: lookup proxy on 127.0.0.53:53: server misbehaving
```
After I reconnect my VPN and proxy and all end :)
```
8:49PM DBG detected buildkit config haveHostNetwork=true isActive=true version=v0.9.3
8:49PM DBG detected buildkit config haveHostNetwork=true isActive=true version=v0.9.3
8:49PM DBG failed to check universe version: universe not installed
8:49PM DBG spawning buildkit job attrs=null localdirs={
"/home/me/examples/todoapp": "/home/me/examples/todoapp"
}
[β] wait 0.2s
[β] app.source 0.1s
[β] registry.run 1.1s
[β] app.ctr 0.0s
[β] app.build 0.1s
[β] image 39.1s
[β] push.source 1.0s
[β] push.push 1.3s
4.6s
[β] push.digest 0.6s
[β] push.ref 0.5s
[β] run.ref 0.5s
[β] run.run 2.5s
Output Value Description
app.build struct Build output directory
push.ref "localhost:5042/todoapp:latest@sha256:514251eadf5c1de89b72f8c82600dc33d8670985b4c3520d0b8a1fab3598a5ed" Image ref
push.digest "sha256:514251eadf5c1de89b72f8c82600dc33d8670985b4c3520d0b8a1fab3598a5ed" Image digest
run.ref "localhost:5042/todoapp:latest@sha256:514251eadf5c1de89b72f8c82600dc33d8670985b4c3520d0b8a1fab3598a5ed" Image reference (e.g: nginx:alpine)
run.run.env.IMAGE_REF "localhost:5042/todoapp:latest@sha256:514251eadf5c1de89b72f8c82600dc33d8670985b4c3520d0b8a1fab3598a5ed" -
appURL "http://localhost:8080/"
```
It's look like one part support proxy but not other one... | https://github.com/dagger/dagger/issues/1369 | https://github.com/dagger/dagger/pull/2748 | 0fffdc223bb9d6c103538ef2fbbf5ed6fb5f3950 | a12e9f2d5300c0dce379fc327a3e103cea6a01cf | "2022-01-07T19:59:45Z" | go | "2022-07-07T01:40:57Z" |
closed | dagger/dagger | https://github.com/dagger/dagger | 1,360 | ["docs/guides/1226-coding-style.md", "pkg/universe.dagger.io/README.md", "website/sidebars.js"] | Package Coding Style | We should have a README file somewhere encoding package coding style.
Right now there's a few proposals around:
- #1243
- #397
- #1322 | https://github.com/dagger/dagger/issues/1360 | https://github.com/dagger/dagger/pull/2096 | 03829e907f211627ba655e8431c5be2c865b6e02 | 732ef96a0695b36df66935704e51310f7b225765 | "2022-01-07T02:56:52Z" | go | "2022-04-11T17:48:09Z" |
closed | dagger/dagger | https://github.com/dagger/dagger | 1,358 | ["website/package.json", "website/yarn.lock"] | Port Universe to 0.2/Europa | Universe packages must be ported to the Europa syntax. This is a tracking issue for the entire collection of Universe.
For each, we should:
- Determine whether it **should be ported** or not
- If it requires further discussion, create a **dedicated issue** (**do not discuss individual packages here**)
- Have an **assignee**
- And finally, an **implementation status** βπ§ β
Before we can start porting these, we must finalize reference packages #1359
| Package | Needed by (real configs only) | Should be ported? | Dedicated Issue | Assignee | Status |
| --- | --- | --- | --- | --- | --- |
|**alpine**| changelog.com | β
|| @talentedmrjones | β
|
|**argocd**| ? | :question:||||
|**aws**| ? | β
| https://github.com/dagger/dagger/issues/1388 | @talentedmrjones | β
#1622 |
|**aws/cloudformation**| ? | ? || @talentedmrjones ||
|**aws/ecr**| ? | :question:||||
|**aws/ecs**| ? | :question:||||
|**aws/eks**| ? | :question:||||
|**aws/elb**| ? | :question:||||
|**aws/rds**| ? | :question:||||
|**aws/s3**| ? | :question:||||
|**azure**| ? | :question:||||
|**azure/resourcegroup**| ? | :question:||||
|**azure/staticwebapp**| ? | :question:||||
|**azure/storage**| ? | :question:||||
|**bats**| Dagger CI | :question:||||
|**docker**| changelog.com, Dagger CI | :question:||||
|**docker/compose**| ? | :question:||||
|**gcp**| ? | :question:||||
|**gcp/cloudrun**| ? | :question:||||
|**gcp/gcr**| ? | :question:||||
|**gcp/gcs**| ? | :question:||||
|**gcp/gke**| ? | :question:||||
|**gcp/secretmanager**| ? | :question:||||
|**git**| Changelog.com, Todoapp example, Dagger CI | :question:||||
|**go**| ? | :question:||||
|**graphql**| ? | β
|| @slumbering ||
|**http**| ? | β
|| @slumbering ||
|**io**| βDagger classicβ? | β Deprecated by `dagger.io/dagger` and `universe.dagger.io/docker` ||||
|**java**| ? | :question:||||
|**java/maven**| ? | :question:||||
|**js/yarn**| Todo app example | :question:||||
|**kubernetes**| ? | :question:||||
|**kubernetes/helm**| ? | :question:||||
|**kubernetes/customize**| ? | :question:||||
|**netlify**| Todo app example | :question:||||
|**os**| βDagger classicβ? | β Deprecated by `dagger.io/dagger` and `universe.dagger.io/docker`. ||||
|**random**| ? | β Feels like it should be a future `engine` feature instead. ||||
|**terraform**| ? | :question:||||
|**trivy**| ? | :question:||||
| https://github.com/dagger/dagger/issues/1358 | https://github.com/dagger/dagger/pull/640 | 06f04be21438daf02780389a2a2aa1aa871eb6b6 | 53fa2844c0fac588b5742bd66e8a115c50e3160b | "2022-01-07T02:31:50Z" | go | "2021-06-15T12:27:23Z" |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.