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 | 1,352 | ["website/package.json", "website/yarn.lock"] | Europa: add formatting constraints to `engine.#Ref` | New Europa API defines `#Ref` type for docker image ref. Currently it’s a simple string, but could be restricted further as a convenience to developers.
| https://github.com/dagger/dagger/issues/1352 | https://github.com/dagger/dagger/pull/640 | 06f04be21438daf02780389a2a2aa1aa871eb6b6 | 53fa2844c0fac588b5742bd66e8a115c50e3160b | "2022-01-06T20:02:10Z" | go | "2021-06-15T12:27:23Z" |
closed | dagger/dagger | https://github.com/dagger/dagger | 1,344 | ["cmd/dagger/cmd/mod/get.go", "mod/repo.go", "pkg/pkg.go"] | mod get doesn't work in Europa | Since it relies on "projects" (e.g. `.dagger`), `mod get` doesn't work anymore. | https://github.com/dagger/dagger/issues/1344 | https://github.com/dagger/dagger/pull/1519 | f47d44da79db91905cf7851061087b7231ec0260 | 7b8a637bea7039e2433783b1a2a97c495920beec | "2022-01-06T01:39:51Z" | go | "2022-01-28T17:39:25Z" |
closed | dagger/dagger | https://github.com/dagger/dagger | 1,339 | ["pkg/dagger.io/dagger/engine/image.cue", "pkg/universe.dagger.io/docker/set.cue", "pkg/universe.dagger.io/docker/test/docker.bats", "pkg/universe.dagger.io/docker/test/set.cue"] | Europa: Set image metadata in a Docker build | ## Problem
The new Docker Build API in Europa (`universe.dagger.io/docker.#Build`) lacks the ability to set Docker image metadata. As compared to Dockerfile features:
| Feature | Dockerfile operation | CUE operation |
| -- | -- | -- |
| Set default working directory | `WORKDIR <PATH>` | Not available |
| Set default user | `USER <ID>` | Not available |
| etc. | etc. | etc. |
This feature is tricky to implement, because it is a form of *override*, and CUE is designed to make overrides difficult. For good reason - abuse of overrides is a huge cause of runaway configuration complexity. But in this case, well, that’s just how Docker images work: 99% of builds involve 1) pulling a base image with a config outside of our control, then 2) overriding some fields in that config. Supporting this pattern is a must-have for adoption.
## Proof of concept
Thanks to @helderco, we have a working proof of concept. This can live in the `universe.dagger.io/docker` package.
Latest proof-of-concept:
> ```
> #Set: {
> input: #Image
> config: #ImageConfig
> output: #Image & {
> rootfs: input.rootfs
> "config": {
> for field, value in input.config {
> // doesn't exist in config, copy away
> if config[field] == _|_ {
> "\(field)": value
> }
> }
> for field, value in config {
> // replace any field that don't need merging
> if !list.Contains(["Env", "Labels"], field) {
> "\(field)": value
> }
> // handle special Env case
> if field == "Env" {
> Env: (_#MergeEnvs & {
> a: input.config.Env
> b: config.Env
> }).output
> }
> // handle special Labels case
> if field == "Labels" {
> Labels: (_#MergeMaps & {
> a: input.config.Labels
> b: config.Labels
> }).output
> }
> }
> }
> }
> }
>
> _#MergeEnvs: {
> a: [...string]
> b: [...string]
> _a_map: (_#ListToMap & { input: a }).output
> _b_map: (_#ListToMap & { input: b }).output
> _reconcile: (_#MergeMaps & { "a": _a_map, "b": _b_map }).output
> "output": [
> for field, value in _reconcile {
> "\(field)=\(value)"
> }
> ]
> }
>
> _#ListToMap: {
> sep: string | *"="
> input: [...string]
> "output": [string]: string
> "output": {
> for value in input {
> let pair = strings.Split(value, sep)
> "\(pair[0])": pair[1]
> }
> }
> }
>
> _#MergeMaps: {
> a: [string]: string
> b: [string]: string
> "output": {
> for field, value in a {
> if b[field] == _|_ {
> "\(field)": value
> }
> }
> for field, value in b {
> "\(field)": value
> }
> }
> }
>```
>
## Resources
* Original discussion: https://github.com/thechangelog/changelog.com/pull/401#discussion_r767925747
* More recent discussion: #1227 | https://github.com/dagger/dagger/issues/1339 | https://github.com/dagger/dagger/pull/1535 | 946629d1faf7e32f3e1ba535dad762886bbe5b41 | 676a895a0f33dad5c5f3330716ac12942cd351aa | "2022-01-04T22:51:06Z" | go | "2022-02-01T00:09:22Z" |
closed | dagger/dagger | https://github.com/dagger/dagger | 1,305 | ["client/client.go", "docs/reference/europa/dagger/engine.md", "plan/task/newsecret.go", "stdlib/europa/dagger/engine/secret.cue", "tests/tasks.bats", "tests/tasks/newsecret/newsecret.cue"] | Support loading secrets from actions | It's currently not possible to load new secrets from a plan -- secrets can only be passed as inputs.
This led to secrets-generating packages to output `string`s instead, and have other packages arbitrarily support either strings or secrets which is messy.
Proposal: `engine.#NewSecret` task with pretty much the same interface as `engine.#ReadFile`:
```cue
#NewSecret: {
// Filesystem tree holding the secret
input: #FS
// Path of the secret to read
path: string
// Whether to trim leading and trailing space characters from secret value
trimSpace: *true | false
// Contents of the secret
output: #Secret
}
``` | https://github.com/dagger/dagger/issues/1305 | https://github.com/dagger/dagger/pull/1307 | 4dec90a9624582ba0696e4cabff4357adcc40d11 | c5126412b0f5543590185d606a944d37a65ffaa2 | "2021-12-23T16:14:11Z" | go | "2022-01-10T20:09:21Z" |
closed | dagger/dagger | https://github.com/dagger/dagger | 1,287 | ["core/docs/d7yxc-operator_manual.md", "docs/current/faq.md"] | support rootless mode? | One of the install steps here shows how to use 'sudo' to install it: https://docs.dagger.io/1001/install/
That shouldn't be needed, lately I use containers that run in rootless mode (e.g. `podman` instead of `docker` and a wrapper that calls `podman` instead of `docker` for backwards compat, or `runc`, etc.), and a rootful docker may simply not be available in certain environments as a matter of security policy.
Therefore it'd be very useful if the `sudo` installation mode would be optional and `dagger` could run fully featured in rootless mode.
i.e. it'd be very nice if `dagger` was `rootless` first (sort of how you develop your applications cloud first, etc.)
I haven't tried yet whether this'd be possible by using the 'install from source' method, but the documentation doesn't mention `rootless` at all.
See https://rootlesscontaine.rs/ for various ways of running rootless containers (docker can do it too, although none of the distros I use have actually packaged the rootless mode of docker).
There is also some information here on how to use BuildKit with podman that might prove useful in integrating into dagger's docs: https://pythonspeed.com/articles/podman-buildkit/ | https://github.com/dagger/dagger/issues/1287 | https://github.com/dagger/dagger/pull/5809 | 8f6c3125f14a31e39e251492897c86768147fe26 | e63200db6dd4da2ceff56447d99b01056140b482 | "2021-12-22T00:16:02Z" | go | "2023-10-12T22:04:22Z" |
closed | dagger/dagger | https://github.com/dagger/dagger | 1,256 | ["go.mod", "go.sum", "plan/plan.go", "tests/tasks/hidden/cue.mod/module.cue", "tests/tasks/hidden/cue.mod/pkg/.gitignore", "tests/tasks/hidden/cue.mod/usr/testing.dagger.io/hidden/hidden.cue", "tests/tasks/hidden/hidden.cue"] | Europa: actions in hidden fields | ## Problem
There may or may not be a problem, depending on whether the desired behavior is already supported.
## Desired behavior
Dagger should support configuring actions in hidden fields. For example:
```
// Action configured in a regular field
foo: docker.#Run & {
script: “echo hello foo!”
}
// Action configured in a hidden field
_bar: docker.#Run & {
script: echo hello bar!”
}
```
In this example, *BOTH* actions should be detected and executed. | https://github.com/dagger/dagger/issues/1256 | https://github.com/dagger/dagger/pull/1403 | f13c0fe1d8bd246ce4b690cc2c9c30cd96b7bb5c | 9b81b46677eac098713927106bad74d1434a3c52 | "2021-12-17T19:57:39Z" | go | "2022-01-12T20:42:46Z" |
closed | dagger/dagger | https://github.com/dagger/dagger | 1,249 | ["go.mod", "go.sum"] | Terminate an action | ## Problem
Dagger has the ability to run commands in containers (`engine.#Exec`). These commands can be long-running (for example a test database). But there is no reliable way to terminate this command later. This effectively makes it impossible to execute long-running commands without hanging DAG execution.
A typical example (from real-world use case #1227):
* Start a test database (`engine.#Exec`)
* Execute tests against test database (`engine.Exec`)
* After the tests aere completed, terminate the test database (*this is the missing feature*)
## Solution
Here’s a suggestion to get us started:
```
package engine
// Terminate a task
#Terminate: {
// The ID of the task to terminate
id: #TaskID
}
// Each task produces a unique ID which can be safely referenced
// NOTE: not necessarily the same as our internal IDs
#Exec: {
// Dagger task ID.
target: #TaskID
…
}
```
Example:
```
sleep: engine.#Exec & {
args: [“sleep”, “100”]
}
terminate: engine.#Terminate & {
target: sleep.id
}
```
NOTE: in this example, `sleep` and `terminate` will run in parallel, causing `sleep` to be terminated immediately. For a more useful example, we need a way to run `terminate` after other commands. This requires [explicit dependencies between tasks](https://github.com/dagger/dagger/issues/1248).
| https://github.com/dagger/dagger/issues/1249 | https://github.com/dagger/dagger/pull/781 | 696b8a4d4cb8831c8c316dbe15e94bbbaa9d9fb2 | 58eebc5f8d9af0dbd838815151b9c7318afdc802 | "2021-12-17T07:12:18Z" | go | "2021-07-03T16:22:32Z" |
closed | dagger/dagger | https://github.com/dagger/dagger | 1,222 | ["europa-universe/docker/docker.cue", "stdlib/europa/dagger/engine/spec/engine/exec.cue"] | Europa: engine.#Exec: attach stdin, stdout, stderr | Expand the Engine API to give developers control over the standard streams (stdin, stdout, stderr) of the commands they’re executing.
This was part in the original Europa spec, but was temporarily removed to resolve outstanding design issues:
* How to handle multiple writers? Are they forbidden? Do they randomly share the stream? Undefined behavior? Is the full stream multiplexed to each reader?
* How to avoid deadlocks? Unix-style pipes require concurrent execution. But the original spec leads to *sequential* execution because the stdout/stdin link is considered to be a dependency. This requires further design discussion
* How can the streams be used other than to chain commands? Could they eventually be exposed to the client as inputs or outputs?
For reference, here is the original spec:
```
package engine
#Stream: {
_stream: ID: string
}
#Exec: {
// […]
// Optionally attach to command standard input stream
stdin?: #Stream
// Optionally attach to command standard output stream
stdout?: #Stream
// Optionally attach to command standard error stream
stderr?: #Stream
}
```
| https://github.com/dagger/dagger/issues/1222 | https://github.com/dagger/dagger/pull/1223 | 19322a7cb9c58866661f4eae31bf3f37722d366d | 9e859e6233374b2c611b1db366e22cf737eae174 | "2021-12-14T22:27:52Z" | go | "2021-12-17T01:17:38Z" |
closed | dagger/dagger | https://github.com/dagger/dagger | 1,220 | ["cmd/dagger/cmd/up.go", "plan/plan.go"] | Europa: Stopgap implementation to output computed state | In Europa we're missing a way to retrieve state (e.g. `dagger query`).
I don't know what the long term solution would look like, and maybe we don't need to figure that out for the Europa release.
However, in the meantime, we do need **some** way to programmatically get the computed state back, at the very least for our integration tests.
I propose this straw-man: `dagger up --output [path]`. The output file content would be the equivalent of `state/computed.json` in mainstream Europa.
/cc @shykes @samalba @talentedmrjones | https://github.com/dagger/dagger/issues/1220 | https://github.com/dagger/dagger/pull/1279 | cbd141d019d48e839d6b647923f9563a2c2b09a6 | f3caa342e8721541a5aa32a0020fd5d8b52d646f | "2021-12-14T14:57:19Z" | go | "2021-12-21T17:48:04Z" |
closed | dagger/dagger | https://github.com/dagger/dagger | 1,218 | ["docs/learn/1011-package-manager.md"] | docs: 404 to github.com/dagger/packages | Issue inside https://docs.dagger.io/1011/package-manager/#install
GitHub link send to `https://github.com/dagger/packages/blob/main/gcpcloudrun/source.cue`
and returns to a 404 (private repo maybe?).
| https://github.com/dagger/dagger/issues/1218 | https://github.com/dagger/dagger/pull/1428 | 971346c6d57ba8283cfc486e8bd11273165f38e6 | 63d655d8f39f08ecc0cd56baed7ff354efbb3ba9 | "2021-12-14T10:33:21Z" | go | "2022-01-14T08:30:47Z" |
closed | dagger/dagger | https://github.com/dagger/dagger | 1,207 | ["go.mod", "go.sum"] | Hidden fields traversal for cue/flow | We should support `_hidden` tasks in Europa.
This requires upstream support, for which @jlongtine already opened a PR: https://github.com/cue-lang/cue/pull/1419 | https://github.com/dagger/dagger/issues/1207 | https://github.com/dagger/dagger/pull/2698 | bbfef122d98226003da8930117abf66fae61c829 | 16c6675f1353da8d96aab19e40f9a0dcc7b98fd4 | "2021-12-13T15:20:07Z" | go | "2022-06-23T08:29:14Z" |
closed | dagger/dagger | https://github.com/dagger/dagger | 1,205 | ["cmd/dagger/cmd/common/track.go", "telemetry/telemetry.go"] | Include CI runners in analytics | Currently `dagger` sends basic analytics on long-running commands (this can be disabled with the semi-standard DO_NOT_TRACK environment variable). But not all commands are included in the analytics: commands run in a CI environment (according to best-effort heuristics) are entirely skipped. This results in an analytics blind spot: basically we don’t know anything about real-world usage of Dagger in CI. This is a major problem because we are positioning Dagger as a portable development kit for CICD: running in CI environments is a major use case.
There is a good reason for not sending these events: they produce noisier data because they do not include a stable engine ID. So every individual run looks like an entirely new engine.
This is a valid concern but there is a better way to address it: when a CI environment is detected, add a special `ci: true` attribute to the event, and send it. The analytics service can either filter out these CI events (same behavior as today) or use them for new queries. Unlike today, we would have the choice. | https://github.com/dagger/dagger/issues/1205 | https://github.com/dagger/dagger/pull/1801 | a406b15ef403ca55bbac98807b151b763fab2029 | e9d3b2fd15569e9b4ae66c2504d4c8439a810077 | "2021-12-11T03:26:40Z" | go | "2022-03-14T23:11:26Z" |
closed | dagger/dagger | https://github.com/dagger/dagger | 1,159 | ["website/yarn.lock"] | Document dagger auto-completion | Thanks to viper, dagger supports shell auto-completion natively:
e.g.: `dagger completion zsh`
We should document it as it's a very low hanging fruit to improve the UX. | https://github.com/dagger/dagger/issues/1159 | https://github.com/dagger/dagger/pull/2822 | 59adcef42f8d085335dac015715a96872ea78c18 | db172bf3bdafbf4f99fd9fec7d617fac793fb400 | "2021-11-23T19:44:54Z" | go | "2022-07-21T08:06:46Z" |
closed | dagger/dagger | https://github.com/dagger/dagger | 1,118 | ["cmd/dagger/cmd/up.go", "mod/mod.go"] | Broken dagger init | This is multiple problems, very possibly related, found by @kzap while following the getting started tutorial.
### Problem #1: no secret keys
For some reason, the `keys.txt` file was corrupted (missing the key information):
```
$ dagger new local -p ./plans/local
9:16PM FTL system | failed to create environment: failed to parse input: no secret keys found
$ cat ~/.config/dagger/keys.txt
# created: 2021-11-09T21:03:15-05:00
```
### Problem #2: Panic on `dagger init`
```
$ dagger init
panic: runtime error: invalid memory address or nil pointer dereference
[signal SIGSEGV: segmentation violation code=0x2 addr=0x0 pc=0x10106481c]
goroutine 12 [running]:
go.dagger.io/dagger/cmd/dagger/cmd.getUniverseCurrentVersion(0x0, 0x0, 0x0)
/home/runner/work/dagger/dagger/cmd/dagger/cmd/version.go:237 +0x5c
go.dagger.io/dagger/cmd/dagger/cmd.isUniverseVersionLatest(0x14000331e48, 0x0, 0x0, 0x0)
/home/runner/work/dagger/dagger/cmd/dagger/cmd/version.go:266 +0x20
go.dagger.io/dagger/cmd/dagger/cmd.checkVersion()
/home/runner/work/dagger/dagger/cmd/dagger/cmd/version.go:310 +0x2a8
created by go.dagger.io/dagger/cmd/dagger/cmd.init.11.func1
/home/runner/work/dagger/dagger/cmd/dagger/cmd/root.go:43 +0xa8
```
### Problem #3: Universe version checking is NOT done in dev
For some reason the universe check code is bundled with the binary version checks, which is only performed on releases and not in dev versions (nor CI).
This is the reason we never spotted Problem #2 before. | https://github.com/dagger/dagger/issues/1118 | https://github.com/dagger/dagger/pull/1196 | 9b2746b2cb1e75bb8143b114527b4673a42aa598 | bbc938ddd6cf9035e3170c8a7679a3a47846eed0 | "2021-11-10T02:52:01Z" | go | "2021-12-21T16:58:17Z" |
closed | dagger/dagger | https://github.com/dagger/dagger | 1,111 | ["Makefile", "cmd/dagger/cmd/input/socket.go", "environment/pipeline.go", "go.mod", "go.sum", "solver/socketprovider.go", "solver/socketprovider_unix.go", "solver/socketprovider_windows.go", "state/input.go", "stdlib/dagger/dagger.cue"] | Support `input stream` on Windows | Currently, most examples work out of the box on Windows, unless the config requires access to the local docker socket (eg. "Getting started" from the docs).
We need to implement npipe support for Windows so the client can proxy `\\.\pipe\docker_engine` (host) to `/var/run/docker.sock` (WSL).
This last change should unblock all windows users with a decent support as soon as it's released.
Assigning to myself. | https://github.com/dagger/dagger/issues/1111 | https://github.com/dagger/dagger/pull/1112 | 2d371ca32b8ecf2569e6b10456be6252360e7cb1 | 8ffee8922eeff3de6b5faf6c4c51c96839890586 | "2021-11-08T23:10:41Z" | go | "2021-11-09T02:06:50Z" |
closed | dagger/dagger | https://github.com/dagger/dagger | 1,105 | ["solver/registryauth.go", "solver/registryauth_test.go"] | Target when logging in to a private registry in a build requires a repo? | It appears that when I connect to my private registry for a build, I get an unauthorized response unless the target includes a repo (even if it doesn't exist).
```cue
package main
import (
"alpha.dagger.io/dagger"
"alpha.dagger.io/dagger/op"
)
#Auth: {
target: dagger.#Input & {string}
username: dagger.#Input & {string}
secret: dagger.#Input & {dagger.#Secret | string}
}
// Add `auths` to `docker.#Build`
#Build: {
source: dagger.#Input & {dagger.#Artifact}
dockerfile: dagger.#Input & {*null | string}
args?: [string]: string | dagger.#Secret
auths: [...#Auth]
#up: [
for auth in auths {
op.#DockerLogin & {
for k, v in auth {
"\(k)": v
}
}
},
op.#DockerBuild & {
context: source
if dockerfile != null {
"dockerfile": dockerfile
}
if args != _|_ {
buildArg: args
}
},
]
}
image: #Build & {
source: null
dockerfile: """
FROM registry.example.net/php:7.4
"""
auths: [
#Auth & {
target: "registry.example.net"
username: "example"
}
]
}
```
This returns a **401 Unauthorized**:
```
$ dagger up
[✗] image 0.4s
6:32PM FTL failed to up environment: task failed: registry.example.net/php:7.4: unexpected status code [manifests 7.4]: 401 Unauthorized
```
But **this works**:
```cue
image: #Build & {
source: null
dockerfile: """
FROM registry.example.net/php:7.4
"""
auths: [
#Auth & {
target: "registry.example.net/wat" // repo doesn't exist in the registry
username: "example"
}
]
}
```
Although with *docker.io* it isn't required. The following works:
```cue
image: #Build & {
source: null
dockerfile: """
FROM helder/private-repo
"""
auths: [
#Auth & {
target: "docker.io"
username: "helder"
}
]
}
```
I'm running a `registry:2` container with basic auth behind an Nginx reverse proxy. | https://github.com/dagger/dagger/issues/1105 | https://github.com/dagger/dagger/pull/1454 | abcd01ccfa5ffa88669b61af77b59258e5bd795c | 587f92c9243e18ae69ab4373a7f48cfc248afe5d | "2021-11-07T21:00:07Z" | go | "2022-01-20T02:16:34Z" |
closed | dagger/dagger | https://github.com/dagger/dagger | 1,087 | ["environment/pipeline.go", "solver/solver.go", "stdlib/universe.bats"] | multi-arch support broke docker.#Push | Follow-up of merging https://github.com/dagger/dagger/pull/1074
On the todoapp example, it gives me this error on push.
<img width="944" alt="Screen Shot 2021-11-01 at 4 16 45 PM" src="https://user-images.githubusercontent.com/216487/139754301-32c429ef-d95e-47b0-9280-8bd0d6372da4.png">
Not sure the root cause since the docker.#Push hasn't change, it seems that the default arch is no more set on the pushed image. | https://github.com/dagger/dagger/issues/1087 | https://github.com/dagger/dagger/pull/1089 | 954192118e563dc0b4b8215d5b2c0e7096ae3ab0 | 2cc3f9ad5a47f98181bb239566e9a158e9ff0145 | "2021-11-01T23:23:06Z" | go | "2021-11-02T17:58:40Z" |
closed | dagger/dagger | https://github.com/dagger/dagger | 1,032 | ["stdlib/git/git.cue", "stdlib/git/tests/git/git.cue"] | Git.#Repository's origin links to a mounted repository, not the provided URL | ### Context
In order to benefit from Buildkit's cache, we are using the `op.#FetchGit` llb instruction to fetch a git repository. However, using this instruction the way we are currently doing, the `origin` ref links a mounted volume, not the URL provided.
### Issue
This is an issue when using git commands using the ref as source (git.#Commit) and incoming ones (listing refs) | https://github.com/dagger/dagger/issues/1032 | https://github.com/dagger/dagger/pull/1033 | badc3a169da5e02cbe6dec73b4419be8723acb7c | 16d4fc0c98b5af33733cd56ed4bd6b089b8a8fba | "2021-10-04T14:44:07Z" | go | "2021-10-04T23:10:20Z" |
closed | dagger/dagger | https://github.com/dagger/dagger | 988 | ["go.mod", "go.sum"] | [BUG] Dagger stall when there is no buildkitd active. | When the *dagger-buildkitd* container is not started, the `dagger up` is blocking indefinitely and you have to send SIGTERM signals to stop it.
We should check that the buildkit daemon is active and if not stop the command and print an error stating that the server (or the daemon) is not active or is unavailable. | https://github.com/dagger/dagger/issues/988 | https://github.com/dagger/dagger/pull/4722 | 2ed262c629e4e589d3a335a09dcf8d098fb4848c | 72085322218259ae71cf86cbab51fba08c09da9d | "2021-09-17T14:29:32Z" | go | "2023-04-12T16:18:46Z" |
closed | dagger/dagger | https://github.com/dagger/dagger | 984 | ["docs/reference/docker/README.md", "stdlib/.dagger/env/docker-run-local/values.yaml", "stdlib/docker/command.cue", "stdlib/docker/compose/compose.cue", "stdlib/docker/docker.cue", "stdlib/docker/tests/run-local/local.cue", "stdlib/universe.bats"] | Enable access to local Docker engine | Accessing a local docker engine in a secure way would be very useful, for onboarding especially.
There is code already merged for this, but not enabled because of unresolved security concerns.
- [x] Implement `dagger.#Stream` primitive to mount a stream into a buildkit container
- [x] Implement a `dagger input socket` command to inject a local unix socket into an environment as a stream
- [x] Update the `docker` Cue package to accept a `dagger.#Stream` as docker engine socket. | https://github.com/dagger/dagger/issues/984 | https://github.com/dagger/dagger/pull/1003 | 9776532fa7cfd933f772bec981ac2fd423887063 | 9120c52545ecb85958efa54ae2adfd1dca731bf3 | "2021-09-15T22:59:14Z" | go | "2021-09-23T22:28:26Z" |
closed | dagger/dagger | https://github.com/dagger/dagger | 977 | ["go.mod", "go.sum"] | Docs: environment names in tutorials are confusing | Dagger tutorials guide you through the use and creation of various Dagger environments. The names we chose for those environments are confusing users.
Currently the names are:
* [s3](https://docs.dagger.io/1003/get-started/)
* [multibucket](https://docs.dagger.io/1004/dev-first-env/)
* [gcpcloudrun](https://docs.dagger.io/1006/google-cloud-run/)
* [kube](https://docs.dagger.io/1007/kubernetes/)
* [cloudformation](https://docs.dagger.io/1008/aws-cloudformation/)
Feedback so far (from 2 different users) is that those names are surprising, and create confusion about what a Dagger environment is, and how it relates to the familiar definition of “environment”.
Examples of environment names that would have been more familiar to those users:
* Dev
* Staging
* Prod
| https://github.com/dagger/dagger/issues/977 | https://github.com/dagger/dagger/pull/1754 | 26fe2630b516dc03995bec7022cb6146f503b437 | 102ec55d4e65b09b153c69b21a984dbcaa5e8f43 | "2021-09-14T20:00:49Z" | go | "2022-03-10T19:46:04Z" |
closed | dagger/dagger | https://github.com/dagger/dagger | 972 | ["cmd/dagger/cmd/input/dir.go", "tests/cli.bats"] | `dagger input dir src xxxx -e prod` hangs forever | The command `dagger input dir src xxxx -e prod` hangs forever when `xxxx` doesn't exist. | https://github.com/dagger/dagger/issues/972 | https://github.com/dagger/dagger/pull/973 | 4d45e269e006899dc28ba64913a51520aa10a641 | 8dbfdaca1bf2decd474fff5a3ad366fbd3f8eaaf | "2021-09-14T13:58:14Z" | go | "2021-09-14T15:44:33Z" |
closed | dagger/dagger | https://github.com/dagger/dagger | 941 | ["go.mod", "go.sum"] | Improve display of logs from the CLI during a `dagger up` | Feedback from @benja-M-1
- [x] The part of the logs that are grayed-out are actually very useful and should be highlighted (e.g. Name of the missing input).
- [x] Grouping logs by pipeline (#up) instead of displaying them realtime would be more useful. It's a mess to associate each log line to its corresponding pipeline.
- [x] Auto-collapse logs for a pipeline that was successful, usually only errors are useful.
Because of those issues, JSON logs are often more useful than formatted ones. | https://github.com/dagger/dagger/issues/941 | https://github.com/dagger/dagger/pull/4722 | 2ed262c629e4e589d3a335a09dcf8d098fb4848c | 72085322218259ae71cf86cbab51fba08c09da9d | "2021-09-03T00:19:42Z" | go | "2023-04-12T16:18:46Z" |
closed | dagger/dagger | https://github.com/dagger/dagger | 940 | ["go.mod", "go.sum"] | Support explicit dependency | Sometimes the implicit dependency of the dag is not enough, because a component `A` does not have any useful output for component `B`. However `A` must be executed before `B`.
In such a scenario, it would be useful to have the ability to define a dependency explicitly. | https://github.com/dagger/dagger/issues/940 | https://github.com/dagger/dagger/pull/123 | 9dbec2030cd799ef3d3ba61d4f17d19a3e6f7235 | b1626033dead786076c6f83248a3afcba9e64953 | "2021-09-03T00:10:54Z" | go | "2021-02-17T21:28:18Z" |
closed | dagger/dagger | https://github.com/dagger/dagger | 905 | ["go.mod", "go.sum"] | Implement ArgoCD | ## Request
Initial [ArgoCD](https://argoproj.github.io/argo-cd/) implementation with app support.
## Requirement
* https://github.com/dagger/dagger/issues/853
## Notes
There is an existing PR (https://github.com/dagger/dagger/pull/883) which will be refactored and moved to a dedicated repository when package manager becomes available.
| https://github.com/dagger/dagger/issues/905 | https://github.com/dagger/dagger/pull/1754 | 26fe2630b516dc03995bec7022cb6146f503b437 | 102ec55d4e65b09b153c69b21a984dbcaa5e8f43 | "2021-08-23T08:47:39Z" | go | "2022-03-10T19:46:04Z" |
closed | dagger/dagger | https://github.com/dagger/dagger | 894 | ["website/package.json", "website/yarn.lock"] | docs.dagger.io search does not work | Any search term entered is blocked on the spinner, see below:
<img width="562" alt="Screen Shot 2021-08-17 at 2 46 01 PM" src="https://user-images.githubusercontent.com/216487/129811283-b2571f10-35fa-4460-a616-fa9f2bc7d4e3.png">
| https://github.com/dagger/dagger/issues/894 | https://github.com/dagger/dagger/pull/5735 | 604fd0e1c4575a9c254b330e6e463ef8094f072e | 9335bcb329a8d43aa351097016d7d57a85bd9852 | "2021-08-17T22:58:17Z" | go | "2023-09-13T10:15:02Z" |
closed | dagger/dagger | https://github.com/dagger/dagger | 888 | ["cmd/dagger/cmd/input/bool.go", "cmd/dagger/cmd/input/root.go", "state/input.go", "tests/cli.bats", "tests/cli/input/bool/main.cue"] | Bool input type integration (CLI option) | Currently, dagger's CLI doesn't accept a bool type as input:
```shell
➜ universe git:(docs-test) ✗ dagger input
Manage an environment's inputs
Usage:
dagger input [command]
Available Commands:
container Add a container image as input artifact
dir Add a local directory as input artifact
git Add a git repository as input artifact
json Add a JSON input
list List the inputs of an environment
secret Add an encrypted input secret
text Add a text input
unset Remove input of an environment
yaml Add a YAML input
Flags:
-h, --help help for input
Global Flags:
-w, --workspace string Specify a workspace (defaults to current git repository)
Use "dagger input [command] --help" for more information about a command.
```
It led me to write hacky configs to bypass it, however, it's not sustainable:
```shell
localMode: dagger.#Input & { string | *null }
```
Having a bool type as input is important because it's a good way to leverage environments to its fullest: I use it to have a local testing behavior on previously implement code.
Having a bool as input makes it backward compatible on all the configs without changing the code: I just have 2 environments, one with the bool as null, the other as a string (should be true/ a bool), the code remains exactly the same. | https://github.com/dagger/dagger/issues/888 | https://github.com/dagger/dagger/pull/916 | 9d7b40253dc500b1508c741a06bff71384e06f39 | a8b3d9325d5bf794d2928ad0133a9442bd730102 | "2021-08-17T00:48:22Z" | go | "2021-08-24T17:51:18Z" |
closed | dagger/dagger | https://github.com/dagger/dagger | 884 | ["go.mod", "go.sum"] | Input git doesn't take care of subdir argument | ## Problem
I found an issue with `dagger input git` command.
If we check the usage if input with `dagger input git --help`, here's the result
```
$ dagger input git --help
Add a git repository as input artifact
Usage:
dagger input git TARGET REMOTE [REF] [SUBDIR] [flags]
....
```
We see that we can add a`SUBDIR` argument. But that arg isn't used in reality.
## Reproduce
With the following `cue file`
```cue
package example
import (
"alpha.dagger.io/dagger"
"alpha.dagger.io/os"
)
repo: dagger.#Input & { dagger.#Artifact }
TestRepo: os.#Container & {
always: true
command: "ls -la /input/repo"
mount: "/input/repo": from: repo
}
```
Add repository input
```
dagger input git repo "https://github.com/dagger/examples.git" "main"
```
Up
```
dagger up
```
You should see the following output
<details>
<summary>Logs</summary>
```
6:12PM INF repo | computing environment=repro-git
6:12PM INF repo | #3 0.595 e9d82651acb58ab10a620f6ee121347e7da7ebef refs/heads/main environment=repro-git
6:12PM INF repo | completed environment=repro-git duration=600ms
6:12PM INF TestRepo | computing environment=repro-git
6:12PM INF TestRepo | completed environment=repro-git duration=200ms
Output Value Description
6:12PM INF TestRepo | #6 0.174 total 48 environment=repro-git
6:12PM INF TestRepo | #6 0.174 drwxr-xr-x 1 root root 4096 Aug 13 16:12 . environment=repro-git
6:12PM INF TestRepo | #6 0.174 drwxr-xr-x 3 root root 4096 Aug 13 16:12 .. environment=repro-git
6:12PM INF TestRepo | #6 0.174 drwxrwxrwx 3 root root 4096 Aug 13 12:55 .github environment=repro-git
6:12PM INF TestRepo | #6 0.174 -rw-rw-rw- 1 root root 92 Aug 13 12:55 .markdownlint.yaml environment=repro-git
6:12PM INF TestRepo | #6 0.174 -rw-rw-rw- 1 root root 11357 Aug 13 12:55 LICENSE environment=repro-git
6:12PM INF TestRepo | #6 0.174 -rw-rw-rw- 1 root root 251 Aug 13 12:55 Makefile environment=repro-git
6:12PM INF TestRepo | #6 0.174 -rw-rw-rw- 1 root root 316 Aug 13 12:55 README.md environment=repro-git
6:12PM INF TestRepo | #6 0.174 drwxrwxrwx 5 root root 4096 Aug 13 12:55 helloapp environment=repro-git
6:12PM INF TestRepo | #6 0.174 drwxrwxrwx 7 root root 4096 Aug 13 12:55 todoapp environment=repro-git
6:12PM INF TestRepo | #6 0.174 drwxrwxrwx 8 root root 4096 Aug 13 12:55 voteapp environment=repro-git
```
</details>
Now let's add the subdir argument
```
dagger input git repo "https://github.com/dagger/examples.git" "main" "todoapp"
```
Up
```
dagger up
```
The output will not change for the previous example
<details>
<summary>Logs</summary>
```
6:12PM INF repo | computing environment=repro-git
6:12PM INF repo | #3 0.417 e9d82651acb58ab10a620f6ee121347e7da7ebef refs/heads/main environment=repro-git
6:12PM INF repo | completed environment=repro-git duration=400ms
6:12PM INF TestRepo | computing environment=repro-git
6:12PM INF TestRepo | #6 0.090 total 48 environment=repro-git
6:12PM INF TestRepo | #6 0.090 drwxr-xr-x 1 root root 4096 Aug 13 16:12 . environment=repro-git
6:12PM INF TestRepo | #6 0.090 drwxr-xr-x 3 root root 4096 Aug 13 16:12 .. environment=repro-git
6:12PM INF TestRepo | #6 0.090 drwxrwxrwx 3 root root 4096 Aug 13 12:55 .github environment=repro-git
6:12PM INF TestRepo | #6 0.090 -rw-rw-rw- 1 root root 92 Aug 13 12:55 .markdownlint.yaml environment=repro-git
6:12PM INF TestRepo | #6 0.090 -rw-rw-rw- 1 root root 11357 Aug 13 12:55 LICENSE environment=repro-git
6:12PM INF TestRepo | #6 0.090 -rw-rw-rw- 1 root root 251 Aug 13 12:55 Makefile environment=repro-git
6:12PM INF TestRepo | #6 0.090 -rw-rw-rw- 1 root root 316 Aug 13 12:55 README.md environment=repro-git
6:12PM INF TestRepo | #6 0.090 drwxrwxrwx 5 root root 4096 Aug 13 12:55 helloapp environment=repro-git
6:12PM INF TestRepo | #6 0.090 drwxrwxrwx 7 root root 4096 Aug 13 12:55 todoapp environment=repro-git
6:12PM INF TestRepo | #6 0.090 drwxrwxrwx 8 root root 4096 Aug 13 12:55 voteapp environment=repro-git
6:12PM INF TestRepo | completed environment=repro-git duration=200ms
Output Value Description
```
</details>
## Expected behavior
We can use the `git` package to see what should be the artifact with the subdir option.
Here's an example file to compare
```
package example
import (
"alpha.dagger.io/git"
"alpha.dagger.io/os"
)
gitRepository: git.#Repository & {
remote: "https://github.com/dagger/examples.git"
ref: "main"
subdir: "todoapp"
}
TestRepoWithGit: os.#Container & {
always: true
command: "ls -la /input/repo"
mount: "/input/repo": from: gitRepository
}
```
Up
```
dagger up
```
We will successfully get the subdir
<details>
<summary>Logs</summary>
```
6:29PM INF repo | computing environment=repro-git
6:29PM INF gitRepository | computing environment=repro-git
6:29PM INF repo | #3 0.868 e9d82651acb58ab10a620f6ee121347e7da7ebef refs/heads/main environment=repro-git
6:29PM INF repo | completed environment=repro-git duration=900ms
6:29PM INF gitRepository | completed environment=repro-git duration=900ms
6:29PM INF TestRepoWithGit | computing environment=repro-git
6:29PM INF TestRepoWithGit | completed environment=repro-git duration=200ms
Output Value Description
6:29PM INF TestRepoWithGit | #7 0.115 total 504 environment=repro-git
6:29PM INF TestRepoWithGit | #7 0.115 drwxr-xr-x 1 root root 4096 Aug 13 16:29 . environment=repro-git
6:29PM INF TestRepoWithGit | #7 0.115 drwxr-xr-x 3 root root 4096 Aug 13 16:29 .. environment=repro-git
6:29PM INF TestRepoWithGit | #7 0.115 drwxrwxrwx 3 root root 4096 Aug 5 20:55 .dagger environment=repro-git
6:29PM INF TestRepoWithGit | #7 0.115 -rw-rw-rw- 1 root root 20 Aug 5 20:55 .gitignore environment=repro-git
6:29PM INF TestRepoWithGit | #7 0.115 -rw-rw-rw- 1 root root 492 Aug 5 20:55 Dockerfile environment=repro-git
6:29PM INF TestRepoWithGit | #7 0.115 -rw-rw-rw- 1 root root 68 Aug 5 20:55 README.md environment=repro-git
6:29PM INF TestRepoWithGit | #7 0.115 -rwxrwxrwx 1 root root 680 Aug 5 20:55 import-tutorial-key.sh environment=repro-git
6:29PM INF TestRepoWithGit | #7 0.115 drwxrwxrwx 2 root root 4096 Aug 5 20:55 k8s environment=repro-git
6:29PM INF TestRepoWithGit | #7 0.115 -rw-rw-rw- 1 root root 794 Aug 5 20:55 package.json environment=repro-git
6:29PM INF TestRepoWithGit | #7 0.115 drwxrwxrwx 2 root root 4096 Aug 5 20:55 public environment=repro-git
6:29PM INF TestRepoWithGit | #7 0.115 drwxrwxrwx 2 root root 4096 Aug 5 20:55 s3 environment=repro-git
6:29PM INF TestRepoWithGit | #7 0.115 drwxrwxrwx 3 root root 4096 Aug 5 20:55 src environment=repro-git
6:29PM INF TestRepoWithGit | #7 0.115 -rw-rw-rw- 1 root root 465514 Aug 5 20:55 yarn.lock environment=repro-git
```
</details>
## Solution
After digging into `state/input.go`, I found that `Compile` method doesn't take care of `subdir` argument.
```go
func (git gitInput) Compile(_ string, _ *State) (*compiler.Value, error) {
ref := "HEAD"
if git.Ref != "" {
ref = git.Ref
}
return compiler.Compile("", fmt.Sprintf(
`#up: [{do:"fetch-git", remote:"%s", ref:"%s"}]`,
git.Remote,
ref,
))
}
```
To fix that error, we should add the field subdir in the interpolation. | https://github.com/dagger/dagger/issues/884 | https://github.com/dagger/dagger/pull/1754 | 26fe2630b516dc03995bec7022cb6146f503b437 | 102ec55d4e65b09b153c69b21a984dbcaa5e8f43 | "2021-08-13T16:34:11Z" | go | "2022-03-10T19:46:04Z" |
closed | dagger/dagger | https://github.com/dagger/dagger | 856 | ["sdk/nodejs/package.json", "sdk/nodejs/yarn.lock"] | Track all cue performance related PRs [No structure sharing yet] | When developing a bigger use case using Dagger with @TomChv, we encountered performance related problems.
The aim of this issue to regroup all the hacks we will need to implement until Cue's core team fixes the origin of the lag (cf. https://github.com/cue-lang/cue/issues/803)
* All related issues are happening on a `cue eval` command and lead to a very long compute time
* Definitions are the heart of the problem
* The bug is always related to a field with `multiple values`, reducing the number of potentiel value reduces the compute time
First issue opened: https://github.com/cue-lang/cue/issues/1129
Fix proposal: https://github.com/cue-lang/cue/issues/804 | https://github.com/dagger/dagger/issues/856 | https://github.com/dagger/dagger/pull/3976 | cc1bdc746a82789bb9f2fbc1772e74ff982c294f | a9067a977016f6e8c306d001918aba73d33b168b | "2021-07-29T10:55:06Z" | go | "2022-11-23T22:23:26Z" |
closed | dagger/dagger | https://github.com/dagger/dagger | 848 | ["go.mod", "go.sum"] | `os.#JSON` package implementation to reinject variables inside cue tree | While working with dagger, I felt the need to process some variables inside a shell script, and reinject them into the cue tree.
As of now, it is only possible with the low level `op` operations, as `os.#File` only retrieves strings. An `os.#Json` or `os.#Export` might be necessary if we want `os.#Container` to become mainstream | https://github.com/dagger/dagger/issues/848 | https://github.com/dagger/dagger/pull/306 | 12302f7aa13089fe583b58a3bfa3af2418228c76 | 308ade0a794d141ddf0143979bc94cd6af5263af | "2021-07-27T08:08:35Z" | go | "2021-04-09T21:03:56Z" |
closed | dagger/dagger | https://github.com/dagger/dagger | 832 | ["docs/core-concepts/1218-cli-telemetry.md", "website/sidebars.js"] | Tracking in `dagger` tool, and how to opt out | Our tracking dilemma in a nutshell:
* As open-source *developers*, we need more data about how our software is used, in order to make it better. Solliciting users directly, for example with live interviews and surveys, is useful but not sufficient: we also need tracking. This need is even more acute in the early stages of development, when the final form of the product is not yet known, and can only be found by a fast-moving feedback loop between product changes and user feedback.
* As open-source *users*, we want to know when, how and why our usage is tracked; and we want a simple way to opt out of tracking.
To solve this dilemnna in Dagger, we propose the following design:
* By default, `dagger` would track usage in a way way comparable to other developer tools, such as `gatsby` and `netlify`.
* What is tracked, and how, is clearly and honestly explained to the user.
* There is a simple way to opt out of tracking. This can be done either with a tool-specific environment variable (same as gastby and netlify), or by implementing proposed standards such as [Console Do Not Track (DNT)](https://consoledonottrack.com) which defines a standard `DO_NOT_TRACK` environment variable.
* If we implement a system-wide setting such as `DO_NOT_TRACK`, there must also be a way to explicitly op into Dagger telemetry (for example to help collect data during the beta test period) without having to remove the system-wide `DO_NOT_TRACK`. For example there could be a `DAGGER_TELEMETRY` variable (not set by default).
* When logged into Dagger Cloud (our planned optional cloud service), telemetry would be re-enabled so that Cloud customers can monitor their fleet of open-source engines (this is a commonly requested feature).
## Request for comments
* Are you OK with `dagger` tracking usage by default in a similar way to `netlify` and `gatsby`?
* Should we honor the global `DO_NOT_TRACK` environment variable per the DNT standard? Or should we use a tool-specific env variable for opt-out, the way `gatsby` and `netlify` do today?
Thanks! | https://github.com/dagger/dagger/issues/832 | https://github.com/dagger/dagger/pull/1929 | b32c8732bc7bd932dbdb5dc42fe2434c53cfeb38 | 9f196ca14fa372a2ccd6f192b4c504b799e2c1c4 | "2021-07-16T10:43:26Z" | go | "2022-03-29T23:22:17Z" |
closed | dagger/dagger | https://github.com/dagger/dagger | 823 | ["state/input.go"] | [BUG] Windows version of 0.19 throw an error on dagger up | I have two environments:
-WSL
-Windows 10
I created an empty workspace (no .cue files), did dagger init and dagger new 'myworkplace'
Expected result:
```bash
user@laptop:/mnt/c/Users/user/.alefesta/dg-orig$ dagger up
1:46PM FTL system | failed to up environment: plan config: no CUE files in .
```
on WSL this works fine (Linux binary) on Windows I get:
```powershell
panic: illegal character U+0073 's' in escape sequence:
1:28
goroutine 44 [running]:
go.dagger.io/dagger/environment.(*Environment).LocalDirs(0xc000610560,
0x1f349a0)
/home/runner/work/dagger/dagger/environment/environment.go:174
+0x3e5
go.dagger.io/dagger/client.(*Client).buildfn(0xc000286630, 0x237f378, 0xc00046e600, 0xc000545810, 0xc000610560, 0xc0002aa378, 0xc00015a840, 0xc000396d20, 0xc0000c20e0)
/home/runner/work/dagger/dagger/client/client.go:102 +0xa6
go.dagger.io/dagger/client.(*Client).Do.func2(0xc000396ee0, 0xc0000c20e0)
/home/runner/work/dagger/dagger/client/client.go:92 +0x67
golang.org/x/sync/errgroup.(*Group).Go.func1(0xc0001b4270, 0xc00046e780)
/home/runner/go/pkg/mod/golang.org/x/[email protected]/errgroup/errgroup.go:57 +0x62
created by golang.org/x/sync/errgroup.(*Group).Go
/home/runner/go/pkg/mod/golang.org/x/[email protected]/errgroup/errgroup.go:54 +0x71
```
as per the image attached
| https://github.com/dagger/dagger/issues/823 | https://github.com/dagger/dagger/pull/1103 | b956ed4d918a409bb6520aafe7fcec1b2b223dc6 | 23d488d4625bb83b9cb9bec4dcf537415e833924 | "2021-07-14T11:55:09Z" | go | "2021-11-08T21:20:31Z" |
closed | dagger/dagger | https://github.com/dagger/dagger | 801 | ["website/package.json", "website/yarn.lock"] | Parsing: issue with inputs beginning with '--' | When reviewing the netlify package, I generated a personal token which randomly started with `--`.
This led to the encounter of this parsing error:
```shell
$ dagger input secret site.netlify.account.token "--lyYc_hJ*********************" -e multibucket
failed to execute command: unknown flag: --lyYc_hJPbP**
```
* The same happens with all inputs, Viper doesn't seem to parse them properly/doesn't seem to understand that an input is expected
| https://github.com/dagger/dagger/issues/801 | https://github.com/dagger/dagger/pull/5270 | fe95d0e583204296a96b174b01d317660f95c120 | deed95218e120e6a7e9d57dd095b90216c136610 | "2021-07-09T12:49:09Z" | go | "2023-06-02T18:51:53Z" |
closed | dagger/dagger | https://github.com/dagger/dagger | 800 | ["sdk/nodejs/package.json", "sdk/nodejs/yarn.lock"] | Persistence keys: help actions manage their own state | This is a proposal for one particular solution to the problem of state persistence in Dagger.
## Problem
Sometimes, a component in the DAG needs to remember what they did earlier - usually so that they can undo it. This feature is called “persistent state” or “state” for short. For example, a component which creates Amazon S3 buckets needs persistent state to remember which buckets they created, in case the user wants to destroy them later.
One obvious use of persistent state is the “dagger down” feature (#309): the ability to “clean up” all side effects cause by a Dagger environment. But there are other uses as well.
One reason Dagger does not yet support state persistence, is that it is very difficult to do correctly. The more state Dagger is responsible for persisting, the more things can go wrong, and the more complex Dagger must become to manage possible errors. There is also the problem of customization: managing more state means storing more data, and different users have very different opinions on how to store their data. The bigger the data, the more opinions diverge on how to store it, and the more customizable Dagger must be to accomodate’s everyone’s opinion. This leads to more complexity.
The ideal solution would allow individual Dagger components to persist as much state as they need, while keeping data size and customization of data storage, and therefore complexity, to an absolute minumum.
## Solution
There is no way to implement state persistence in the Dagger core in a way that will 1) meet the requirements of every component in the DAG, 2) avoid the extra complexity of implementing reliable storage, 3) avoid the extra complexity of allowing customization of storage backend.
So we don’t. Instead, we implement the primitives necessary for each component in the DAG to either 1) implement its own storage, or 2) provide storage middleware for other components - all in Cue.
This requires 2 primitives:
1. Persistence keys: a CUE developer can request that Dagger generate *and persist* a unique key (perhaps a UUID, perhaps a human-friendly slug.. details are TBD), and inject it into the specified Cue value.
2. Storage middleware interface: the standard library should define a common storage API in an abstract Cue interface, and provide a reference implementation on the provider side (S3; local directory; rsync..) and consumer side (terraform, netlify..) to seed an ecosystem of storage middleware. This is crucial, for example, to allow wrapping of low-level package such as terraform without leaking abstraction. If I import a `multidb` package which happens to wrap a custom terraform configuration, it should be easy (and perhaps required) for me to provide a standard storage middleware component to store terraform state. It *should not* be locked in that I can only use, say, AWS S3.
## Technical design
### Cue API for persistence keys
This is still work in progress.
Example code:
```
appname: string @dagger(persistenceKey)
```
Example value:`appname: “happy-panda-3654”`
### Storage of persistence keys
Dagger is responsible for storing the persistence keys and mapping them to the correct environment and path. This is similar to how output values are persisted today.
The defining feature of this proposal is what Dagger is *not* responsible for: storing arbitrary data and making them available read-write to buildkit pipelines. This is now 100% the responsibility of the Cue developer (aka “userland”).
### Storage middleware interface
This is still work in progress. The storage middleware interface is a regular Cue interface. Any Dagger user can design and share their own interface. But only Dagger maintainers can define a standard and designate the “correct” patterns. | https://github.com/dagger/dagger/issues/800 | https://github.com/dagger/dagger/pull/3976 | cc1bdc746a82789bb9f2fbc1772e74ff982c294f | a9067a977016f6e8c306d001918aba73d33b168b | "2021-07-09T11:35:01Z" | go | "2022-11-23T22:23:26Z" |
closed | dagger/dagger | https://github.com/dagger/dagger | 785 | ["go.mod", "go.sum"] | Implement Serverless Application abstraction on top of AWS Lambda | We need a high-level Application abstraction on top of AWS Lambda, the initial need is for internal tooling (deploy a simple API endpoint without dealing with infra complexity).
Requirements:
- Support Lambda [language-runtimes](https://docs.aws.amazon.com/lambda/latest/dg/lambda-runtimes.html) and [container images](https://docs.aws.amazon.com/lambda/latest/dg/runtimes-images.html)
- Support deploying several functions at once
- Easily map a function to a domain and/or URL path - all declared from Cue
- No need to integrate with stdlib for now, just expose a simple `#Application` definition
- Do not expose infra complexity (if it relies on CloudFormation, templates need to be hidden from the top-level definition)
- Support non-HTTPs functions (HTTP is simply a trigger for the function)
Competiting implementations:
- [AWS Serverless Application Model](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/what-is-sam.html)
- [AWS SAM CLI](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/serverless-sam-cli-install.html)
- [Serverless framework](https://www.serverless.com/)
- [Apex Up](https://apex.sh/up/) | https://github.com/dagger/dagger/issues/785 | https://github.com/dagger/dagger/pull/5545 | 1cb2060cbc7da58bd187f24ea6b340b6dd96762a | 866cf8cb0572df4f0e4aea22bf5375774927dd28 | "2021-07-05T12:56:17Z" | go | "2023-08-03T14:28:47Z" |
closed | dagger/dagger | https://github.com/dagger/dagger | 770 | ["go.mod", "go.sum"] | discord community link expired or invalid | https://discord.gg/Rmffpmc
link doe not work in readme, is it still active or valid ? | https://github.com/dagger/dagger/issues/770 | https://github.com/dagger/dagger/pull/5459 | bdf0a37ed18007ab47fc9b0445fb20aeade699c9 | 1e7aa6da766b876ca7fb42968186978bdb3a6afa | "2021-07-01T16:50:51Z" | go | "2023-07-14T17:58:19Z" |
closed | dagger/dagger | https://github.com/dagger/dagger | 745 | ["website/package.json", "website/yarn.lock"] | Locked out of `dagger edit` after removing the wrong field | I removed the `plan.module` field of my environment in `dagger edit`. After that, all commands against that environment failed, including `dagger edit`. This made it impossible to revert my error, short of running `git checkout -f — values.yaml`. I tried editing the file manually but that caused sops errors.
I see 2 distinct problems:
* The `plan.module` field should be optional. When not specified, `dagger` should silently use the default value: `.`.
* Even if a mandatory field is missing, or the values.yaml file otherwise broken, it should always be possible to modify it with `dagger edit` in order to fix the problem.
| https://github.com/dagger/dagger/issues/745 | https://github.com/dagger/dagger/pull/2818 | 61fd0d795efd73c09f843771df888bce3c616a1d | 196c213575a9b6badbb63c26c0840ff8bd4d34dc | "2021-06-28T13:46:45Z" | go | "2022-07-21T09:38:23Z" |
closed | dagger/dagger | https://github.com/dagger/dagger | 742 | ["docs/learn/102-dev.md", "docs/learn/106-cloudrun.md", "docs/learn/108-cloudformation.md"] | Tutorials: adopt new “plan outside of environment” coding style | We are deprecating the original method of embedding cue configuration (“the plan”) inside each environment directory. The recommended method is to write Cue configuration in a regular cue module (for example at the root of the repository, or any sub-directory), then reference that configuration in the environment.
Our tutorials don’t use this method yet: we should change them so that they do.
| https://github.com/dagger/dagger/issues/742 | https://github.com/dagger/dagger/pull/775 | 773f26babeb80a6e8d19e46dd479d90a3ae82acb | 70b2a9e58a04695d8a02bb20f0027ace0b1e5c53 | "2021-06-28T13:23:55Z" | go | "2021-07-07T10:00:39Z" |
closed | dagger/dagger | https://github.com/dagger/dagger | 739 | ["go.mod", "go.sum"] | Tutorial: specify environment explicitly | Relaying feedback by @amylindburg , thanks Amy!
> If you want the user to simply be able to type in the proposed commands to be successful, then there are a few commands where --environment should be specified (because you end up creating several during the tutorial). But not a biggie.
> `dagger query point --environment="cloudformation"` | https://github.com/dagger/dagger/issues/739 | https://github.com/dagger/dagger/pull/5459 | bdf0a37ed18007ab47fc9b0445fb20aeade699c9 | 1e7aa6da766b876ca7fb42968186978bdb3a6afa | "2021-06-28T09:40:57Z" | go | "2023-07-14T17:58:19Z" |
closed | dagger/dagger | https://github.com/dagger/dagger | 733 | ["docs/learn/102-dev.md", "docs/learn/107-kubernetes.md", "docs/learn/108-cloudformation.md", "docs/reference/universe/file.md"] | [Documentation change] dagger doc dagger.io/{module} not working | When we run ```dagger doc dagger.io/netlify``` it throws an error
```FTL system | cannot compile code: cannot find package "dagger.io/netlify"``` for any module.
I tried it with ```dagger doc alpha.dagger.io/netlify```, it was working. Just need to update the doc. | https://github.com/dagger/dagger/issues/733 | https://github.com/dagger/dagger/pull/734 | e16fd88f4c54546f66cfcecd4674d93cff68581c | 53522842edb275f57d3bd647972209b69b4d12ac | "2021-06-27T13:00:10Z" | go | "2021-06-27T13:16:46Z" |
closed | dagger/dagger | https://github.com/dagger/dagger | 723 | ["sdk/python/requirements.txt"] | Web companion | It would be neat if `dagger` could optionally launch a companion webapp to monitor and configure an environment. This companion webapp would not implement a specific feature, but rather provide a platform for delivering various features that are more appropriate for a web environment. This would allow the CLI to focus on what it does best, and relax the requirement to do absolutely everything in a POSIX terminal, which is very challenging.
In short: if `dagger` always has access to 2 modes of user interface, terminal and browser, it can deliver a better user experience than with only one of them.
Examples of products following this pattern:
* [Streamlit](https://streamlit.io)
* ?
Examples of possible in-browser features:
* Interactive configuration forms generated from cue spec. We had this feature in the Blocklayer SaaS beta: it is very nice!
* Visual DAG representation
* Interactive CUE sandbox
* Log streaming and search
_Originally posted by @shykes in https://github.com/dagger/dagger/discussions/366_ | https://github.com/dagger/dagger/issues/723 | https://github.com/dagger/dagger/pull/5840 | 49340f005c5eff1a0cf4f3d4becc5c58406d5700 | df982b85b9a60d45468247593271af893dbb63c7 | "2021-06-25T11:39:57Z" | go | "2023-10-11T11:55:55Z" |
closed | dagger/dagger | https://github.com/dagger/dagger | 722 | ["go.mod", "go.sum"] | Share access to encrypted secrets | Dagger supports encrypting secrets out of the box. But it does not (yet) support controlling who can access which encrypted secret.
Our underlying crypto framework (AGE and SOPS) provides building blocks for very powerful collaboration workflows. Now we have to assemble these building blocks in a particular way, and provide an outstanding collaboration experience in Dagger :) | https://github.com/dagger/dagger/issues/722 | https://github.com/dagger/dagger/pull/5459 | bdf0a37ed18007ab47fc9b0445fb20aeade699c9 | 1e7aa6da766b876ca7fb42968186978bdb3a6afa | "2021-06-25T11:36:06Z" | go | "2023-07-14T17:58:19Z" |
closed | dagger/dagger | https://github.com/dagger/dagger | 719 | ["go.mod", "go.sum"] | Incorrect `missing input behavior` with closed/ redirected stdout | @TomChv realized that one of our Bats test didn't fail on a test with missing inputs :
```bash
# Inside universe dir
# Command that didn't work at first
./node_modules/bats/bin/bats universe.bats -f "docker run: local"
# How to reproduce it locally
dagger up -e docker-run-local >&- # <-- should fail and exit code should return 1, but not the case
```
**The behavior:**
If the stdout isn't linked to a terminal, we don't print missing inputs as errors but as warnings. As bats redirects the stdout, we fall under this behavior.
_More precisely:_
```go file="dagger/cmd/dagger/cmd/up.go"
func checkInputs(ctx context.Context, st *state.State) {
lg := log.Ctx(ctx)
warnOnly := viper.GetBool("force") || !term.IsTerminal(int(os.Stdout.Fd()))
## In bats tests, we fall under this case `!term.IsTerminal(int(os.Stdout.Fd()))`
...
for _, i := range notConcreteInputs {
if warnOnly { ## And inside this one!
lg.Warn().Str("input", i.Path().String()).Msg("required input is missing")
} else {
lg.Error().Str("input", i.Path().String()).Msg("required input is missing")
}
}
```
We don't know why this case had been managed, so your vision is welcomed :-) | https://github.com/dagger/dagger/issues/719 | https://github.com/dagger/dagger/pull/5459 | bdf0a37ed18007ab47fc9b0445fb20aeade699c9 | 1e7aa6da766b876ca7fb42968186978bdb3a6afa | "2021-06-25T00:21:16Z" | go | "2023-07-14T17:58:19Z" |
closed | dagger/dagger | https://github.com/dagger/dagger | 711 | ["sdk/python/requirements.txt"] | Enforce real names in DCO signoff |
## Summary
Maintainers must check each commit to make sure that the DCO statement (`Signed-off-by: `) includes the real name of the contributor, and not a pseudonym.
## Context
Dagger uses the [Developer Certificate of Origin (DCO)](https://en.wikipedia.org/wiki/Developer_Certificate_of_Origin) process to make sure all contributors are legally allowed to contribute. Major projects like Linux and Docker use DCO to protect their contributors.
DCO is implemented by requiring that each commit include a special “signed-off-by” line, to state that the author of the commit has read and agrees to the DCO certification.
*It’s important that contributors use their real name in the sign-off line*! Currently there is no check to make sure that is the case. | https://github.com/dagger/dagger/issues/711 | https://github.com/dagger/dagger/pull/5840 | 49340f005c5eff1a0cf4f3d4becc5c58406d5700 | df982b85b9a60d45468247593271af893dbb63c7 | "2021-06-23T08:44:16Z" | go | "2023-10-11T11:55:55Z" |
closed | dagger/dagger | https://github.com/dagger/dagger | 699 | ["cmd/dagger/cmd/init.go", "cmd/dagger/cmd/list.go", "cmd/dagger/cmd/new.go", "environment/environment.go", "state/state.go", "state/workspace.go", "state/workspace_test.go", "tests/cli.bats", "tests/helpers.bash"] | Default plan directory to `.` | To complete #631: #648 introduced a `--module` and `--package` flag to `dagger new`.
By default, we use `.dagger/env/XXX/plan` as the cue module. Instead, we should default to `.`. | https://github.com/dagger/dagger/issues/699 | https://github.com/dagger/dagger/pull/772 | 21bed8aee69fd4d9547c0c67777eeae7bddcb94d | f8531fdb0b7df9eacf05a52b24dd78e169ca353b | "2021-06-21T15:50:52Z" | go | "2021-07-07T15:34:23Z" |
closed | dagger/dagger | https://github.com/dagger/dagger | 657 | ["netlify.toml"] | Can’t link to API reference (no index page) | In the API reference section of the docs, each individual package has an address (for example `/reference/universe/alpine`), but there is no address for the API reference as a whole.
* `/reference` returns 404
* `/reference/universe` returns 404
This makes it difficult for other docs pages to link to the APi reference, which would be very useful. | https://github.com/dagger/dagger/issues/657 | https://github.com/dagger/dagger/pull/658 | c55f714fec98ed461398e88b4e5c0f218b855c5f | 7403765aacae5f98506286a4075f37d87f573d98 | "2021-06-16T13:31:12Z" | go | "2021-06-16T14:04:00Z" |
closed | dagger/dagger | https://github.com/dagger/dagger | 627 | ["website/package.json", "website/yarn.lock"] | op: #DockerLogin secret is outdated | Actually, we use the old version of `dagger.#Secret` in `#DockerLogin`
```
#DockerLogin: {
do: "docker-login"
target: string | *"https://index.docker.io/v1/"
username: string
// FIXME: should be a #Secret (circular import)
secret: string | bytes
}
```
That's a real problem because we can't send secret. Tests are using `dagger compute --input-yaml inputs.yaml` but it gonna be deprecated and I'm not sure that we always want to input the yaml as file.
For example :
```
import (
"dagger.io/dagger/op"
)
TestRegistry: {
username: string
secret: string
}
TestLogin: {
login: #up: [
op.#DockerLogin & {
username: TestRegistry.username
"secret": TestRegistry.secret
},
]
}
```
It doesn't works if I do `dagger input yaml TestRegistry -f ./docker-push/inputs.yaml` where `inputs.yaml` has fields `username` and `secret` because `yaml` is not interpreted like `dagger compute input-yaml`. | https://github.com/dagger/dagger/issues/627 | https://github.com/dagger/dagger/pull/4224 | 27e735f674d23c87a72d83c6982945b8e8c1a1fe | 9529f2983c2e6d395a21ba91fba715e04342bc22 | "2021-06-12T12:05:14Z" | go | "2022-12-20T10:53:09Z" |
closed | dagger/dagger | https://github.com/dagger/dagger | 566 | ["docs/current/sdk/nodejs/snippets/yarn.lock"] | `dagger up` shows all intermediary inputs and outputs | `dagger up` now prints the environment’s outputs, which is very useful. However, there is no distinction between “final” outputs and “intermediary” outputs (because we don’t know how to make that distinction). As a result, a typical configuration will print intermediary outputs which are 1) not useful to the end user, and 2) confusing because their contents are obscure.
For example, see `voteapp` in https://github.com/dagger/examples | https://github.com/dagger/dagger/issues/566 | https://github.com/dagger/dagger/pull/5370 | 72fb1527e9b06ede2c4f5e8eac9a489f5f9e1b7f | 0c8da0a136047f58930ba69d0b5779cfcffb93b7 | "2021-06-04T16:24:36Z" | go | "2023-06-26T18:25:03Z" |
closed | dagger/dagger | https://github.com/dagger/dagger | 553 | ["sdk/nodejs/package.json", "sdk/nodejs/yarn.lock"] | output list: artifacts are displayed as cue code | This happens with `js/yarn` (e.g. `examples/react`), at the end of `dagger up` (and when using `dagger output list`), artifacts (`docs.build` is a `dagger.#Artifact`) are displayed like this:
```
docs.build {\n from: {\n image: {\n package: {\n bash: "=~5.1"\n yarn: "=~1.22"\n }\n version: *"3.13.5@sha256:69e70a79f2d41ab5d637de98c1e0b055206ba40a8145e7bddb55ccc04e13cf8f" | string\n }\n setup: []\n command: """\n [ -n "$ENVFILE_NAME" ] && echo "$ENVFILE" > "$ENVFILE_NAME"\n yarn --cwd "$YARN_CWD" install --production false\n\n opts=( $(echo $YARN_ARGS) )\n yarn --cwd "$YARN_CWD" run "$YARN_BUILD_SCRIPT" ${opts[@]}\n mv "$YARN_BUILD_DIRECTORY" /build\n """\n env: {\n PATH: *"/sbin:/bin:/usr/sbin:/usr/bin:/usr/local/sbin:/usr/local/bin" | string\n YARN_BUILD_SCRIPT: *"build" | string\n YARN_ARGS: ""\n YARN_CACHE_FOLDER: "/cache/yarn"\n YARN_CWD: "tools/daggosaurus/"\n YARN_BUILD_DIRECTORY: "tools/daggosaurus/build"\n }\n dir: "/src"\n always: *false | true\n copy: {}\n mount: {\n "/src": {\n from: {}\n }\n }\n cache: {\n "/cache/yarn": true\n }\n tmpfs: {}\n shell: {\n path: "/bin/bash"\n args: *["-c"] | []\n search: {\n "/sbin": true\n "/bin": true\n "/usr/sbin": true\n "/usr/bin": true\n "/usr/local/sbin": true\n "/usr/local/bin": true\n }\n }\n }\n path: "/build"\n} -
```
I suggest we add a test for this as well to make sure it keeps working | https://github.com/dagger/dagger/issues/553 | https://github.com/dagger/dagger/pull/4762 | c28be850965658b1b8e81675500bd6cff439e91f | 98cfa060dafde629cd25d02673908cadb1003a6e | "2021-06-02T22:33:45Z" | go | "2023-03-17T15:50:47Z" |
closed | dagger/dagger | https://github.com/dagger/dagger | 552 | ["go.mod", "go.sum"] | stdlib: docker.#Push missing features | 1\. `docker.#Push` doesn't support authenticated pushes (and therefore cannot work, unless pushing to a local unauthenticated registry).
Support was added in #373 in `op.#DockerLogin`.
Either `docker.#Push` takes credentials or we expose a `docker.#Login` component.
2\. `docker.#Push` doesn't export the reference/digest of what was just pushed. Support was added to `op.#PushContainer` in #303. I suggest `docker.#Push` takes a `name` as an input and has a `ref` and `digest` as outputs.
3\. Tests for all of the above. `op.#DockerPush` is fully tested, `docker.#Push` must as well
/cc @shykes @samalba | https://github.com/dagger/dagger/issues/552 | https://github.com/dagger/dagger/pull/5740 | 64f6410e6b9b5dbb1dec82e36de1e674bd7bb856 | d9c7b7b45769c01d6e62e1b835e26bce933fa3b5 | "2021-06-02T22:25:49Z" | go | "2023-09-16T09:13:47Z" |
closed | dagger/dagger | https://github.com/dagger/dagger | 548 | ["go.mod", "go.sum"] | `dagger up` doesn't rerun buildkit after a manual stop of it's container | After spawning some tty blocking `#op.Exec` commands inside Buildkit for some tests. I wasn't sure if they were still processing in the background.
I manually stopped the buildkit container, then `dagger up` again. However, it didn't reconnect to the buildkit container, neither creates a new one. The only way is to delete the container and rerun `dagger up`. Btw, `jaegertracing` also interferes with the rerun, it also needs to be stopped
Proof :
```
➜ docker ps
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
12954505d27f moby/buildkit:v0.8.3 "buildkitd" 28 minutes ago Up 28 minutes dagger-buildkitd
f29138643feb localstack/localstack "docker-entrypoint.sh" 28 hours ago Up 28 hours 0.0.0.0:4566->4566/tcp, 0.0.0.0:4571->4571/tcp, 8080/tcp localstack_main
➜ docker stop 12954505d27f
12954505d27f
➜ dagger up
6:41PM FTL system | failed to query environment: listing workers for Build: failed to list workers: rpc error: code = Unavailable desc = connection closed
➜ docker ps -a | grep buildkit
12954505d27f moby/buildkit:v0.8.3 "buildkitd" 28 minutes ago Exited (1) 17 seconds ago dagger-buildkitd
➜ docker rm 12954505d27f
12954505d27f
➜ dagger up
6:42PM INF system | starting buildkit version=v0.8.3
6:42PM INF test | computing
6:42PM INF test | completed duration=1.1s
Output Value Description
``` | https://github.com/dagger/dagger/issues/548 | https://github.com/dagger/dagger/pull/5740 | 64f6410e6b9b5dbb1dec82e36de1e674bd7bb856 | d9c7b7b45769c01d6e62e1b835e26bce933fa3b5 | "2021-06-02T16:48:17Z" | go | "2023-09-16T09:13:47Z" |
closed | dagger/dagger | https://github.com/dagger/dagger | 543 | ["go.mod", "go.sum"] | Distinguish core packages from “universe” packages | Dagger distributes several Cue packages for use by the Dagger developer community. There are 2 types of packages:
- Core packages, which expose features of Dagger itself. Currently those are `dagger.io/os`, `dagger.io/file`, `dagger.io/dagger` and `dagger.io/dagger/op`. This may change in the future (possible by merging these packages into one).
- “Universe” packages, which implement useful components to be reused by others in the community. For example AWS integration, Netlify integration, Docker integration, etc.
Currently these 2 types of packages are mixed together, and are not clearly differentiated. It would be useful to do so, as the number and variety of universe packages grows. The core packages play a special role and should easy to identify.
The simplest separation would be to prefix universe packages with `/universe`, for example:
```
import (
// Core packages
“dagger.io/os”
“dagger.io/dagger”
“dagger.io/dagger/os”
“dagger.io/file”
// Universe packages
“dagger.io/universe/aws”
“dagger.io/universe/netlify”
“dagger.io/universe/docker”
)
```
| https://github.com/dagger/dagger/issues/543 | https://github.com/dagger/dagger/pull/5845 | df982b85b9a60d45468247593271af893dbb63c7 | 6127466d16229d44214e71417568f9883afcefe4 | "2021-06-02T14:00:26Z" | go | "2023-10-11T12:31:59Z" |
closed | dagger/dagger | https://github.com/dagger/dagger | 533 | ["website/package.json", "website/yarn.lock"] | `dagger up` fails when docker is not installed | When running `dagger up` on a machine with no docker client installed:
```
$ dagger up
3:26PM ERR system | failed to run docker: exec: "docker": executable file not found in $PATH output=
3:26PM FTL system | unable to create client: exec: "docker": executable file not found in $PATH
```
Tested on https://github.com/dagger/examples | https://github.com/dagger/dagger/issues/533 | https://github.com/dagger/dagger/pull/2447 | 50e0217049cc44071048f6b385a11d7dcc054011 | c9780a90e0a2e30103176133e61e6a01a6bcbe16 | "2021-06-01T15:27:19Z" | go | "2022-05-17T07:08:43Z" |
closed | dagger/dagger | https://github.com/dagger/dagger | 532 | ["go.mod", "go.sum"] | failed to load environment: unable to decrypt state: Error getting data key: 0 successful groups required, got 0 | When running `dagger list` in a workspace for which I don’t have the private key, the following error appears: `failed to load environment: unable to decrypt state: Error getting data key: 0 successful groups required, got 0`.
To reproduce, fetch the dagger examples repo, and try to use it:
```
$ git clone https://github.com/dagger/examples
$ cd examples/helloapp
$ dagger list
3:14PM ERR system | failed to load environment: unable to decrypt state: Error getting data key: 0 successful groups required, got 0 name=staging
``` | https://github.com/dagger/dagger/issues/532 | https://github.com/dagger/dagger/pull/5384 | 70d78ba5e8700d4e885382c7b35efd21482eeac0 | 55f9569ef6a766c5806813491e49be2d829e1453 | "2021-06-01T15:15:57Z" | go | "2023-07-03T10:47:40Z" |
closed | dagger/dagger | https://github.com/dagger/dagger | 519 | ["Makefile", "cmd/dagger/cmd/version.go", "go.mod", "keychain/keys.go"] | dagger list and other commands that access the env are broken with official release (Mac OS) | Happens only with the official release (not if I compile myself), due to cgo that is disabled.
<img width="675" alt="Screen Shot 2021-05-28 at 2 50 44 PM" src="https://user-images.githubusercontent.com/216487/119986517-c9598500-bf78-11eb-8d67-200a3255f058.png">
Workaround:
```sh
export USER=$LOGNAME
```
If `dagger list`, try `dagger new foobar` from an empty workspace.
cc @aluzzardi | https://github.com/dagger/dagger/issues/519 | https://github.com/dagger/dagger/pull/520 | 8d5c3f4f0fa9815f5e9cf59320ec8d8c3f82db1b | e045366e82b3fb352c1f744e9510222ff7a3eb8b | "2021-05-28T12:53:28Z" | go | "2021-05-28T19:08:52Z" |
closed | dagger/dagger | https://github.com/dagger/dagger | 507 | ["go.mod", "go.sum"] | Personalize 404 error message | Doc website | When visiting an unknown URL (https://docs.dagger.io/devel/deqs), the 404 page retrieved seems in debug mode, showing some S3 infos :
```Code: NoSuchKey
Message: The specified key does not exist.
Key: devel/deqs
RequestId:
HostId: ``` | https://github.com/dagger/dagger/issues/507 | https://github.com/dagger/dagger/pull/340 | e6d96ef5c9cc68a277762d204b32dbc44f019151 | d93c8929cbfa7d3e873ac95e80db65dfe35cefd5 | "2021-05-26T16:42:33Z" | go | "2021-04-19T19:33:22Z" |
closed | dagger/dagger | https://github.com/dagger/dagger | 506 | ["sdk/nodejs/package.json", "sdk/nodejs/yarn.lock"] | Inconsistent naming in menubar | Doc website | When arriving on the doc website, we can see, on the left, the menubar of all the accessible pages for a given version
**Devel version, left menubar**
```
Introduction
Install Dagger <==
Dagger vs. Other software <==
GUIDES
Programming Guide
Operator Manual
COMMUNITY <==
GitHub
Discord
```
**All other alpha versions, left menubar**
```
Introduction
Getting started <==
Dagger vs. Other <==
GUIDES
Programming Guide
Operator Manual
MORE <==
GitHub
Discord
```
Plus, all the intro pages include links to these given pages, but their naming follows Devel's one, regardless of the menubar names :
```
Learn More
Dagger vs. Other Software
Dagger Programming Guide
Dagger Operator Manual
Download and Install
Install Dagger <== redirects to Getting started menu page in alpha versions
``` | https://github.com/dagger/dagger/issues/506 | https://github.com/dagger/dagger/pull/4591 | 89294dbff8caac755a977eb5dfc6df32fa511d52 | 7786ccaa2d687acff4a55f6e1cd36c860804cd96 | "2021-05-26T16:15:54Z" | go | "2023-02-14T15:49:31Z" |
closed | dagger/dagger | https://github.com/dagger/dagger | 495 | ["sdk/python/poetry.lock", "sdk/python/src/dagger/cli.py", "sdk/python/src/dagger/server/cli.py"] | Broken BuildKit deduplication when using cache mounts | We've had a regression since BuildKit 0.8.3: when using cache mounts, pipelines get executed multiple times (each time they're referenced).
This is because we use the cue value path as "cache key".
https://github.com/dagger/dagger/pull/414 implemented a workaround: if the value is a reference, use the reference as the "cache key" rather than the value itself (see https://github.com/dagger/dagger/pull/414/files#diff-12b33ae88bbb59b957748ffced0d12a6a6248013fc81d342fdc44343ce2c692cR441 `canonicalPath()`)
However, the fix is not recursive so we have the same problem when using references of references.
We fixed the issue in AWS by removing cache mounts (#481), however all other packages using cache mounts are still broken.
Suggested resolution:
- Implement a proper fix for cache mounts to that take into account reference of references. **!!! NOTE: I tried to recursively resolve the reference but I run into issues**. Unfortunately I don't remember exactly what the issue was, but I think I ended up with multiple pipelines sharing the same cache (e.g. `foo: go.#Build` and `bar: go.#Build` sharing the same cache because they're both references to `go`, which is wrong, they shouldn't share the cache).
- If we can't find a quick solution for that, instead of removing the mount in the cue config like we did for s3 (which hides the problem until next time), perhaps we should disable cache mounts in dagger itself (e.g. replace with a mkdir in LLB). At least it fixes the problem for ALL configs without requiring any Cue changes, and we can re-enable them at once when we have a fix | https://github.com/dagger/dagger/issues/495 | https://github.com/dagger/dagger/pull/5076 | 7a12edb9a16fb52f5cf14fef1e9ca3540aea3cdc | f6317b608d86bf800defaf71dbf0e4c773b015d4 | "2021-05-25T01:35:22Z" | go | "2023-05-04T22:26:08Z" |
closed | dagger/dagger | https://github.com/dagger/dagger | 460 | ["website/package.json", "website/yarn.lock"] | The dagger version CLI doesn't require the Global Flags and hence should be removed from the help page |
## Environment
- Macbook Pro Catalina
- Dagger Release Version
```
dagger version --check
dagger version 0.1.0-alpha.5 darwin/amd64
dagger is up to date.
```
## Issue
The ```dagger version``` CLI doesn't require the Global Flags and hence should be removed.
```
dagger help version
Print dagger version
Usage:
dagger version [flags]
Flags:
--check check if dagger is up to date
-h, --help help for version
Global Flags:
-e, --environment string Select an environment
--log-format string Log format (json, pretty). Defaults to json if the terminal is not a tty
-l, --log-level string Log level (default "info")
```
| https://github.com/dagger/dagger/issues/460 | https://github.com/dagger/dagger/pull/1170 | b2ecc392e576bcb285393026ccf392f71d049f72 | 5533d9561e3e530b43f17c1fbf24abceb44e7b9c | "2021-05-13T06:12:21Z" | go | "2021-12-02T23:18:21Z" |
closed | dagger/dagger | https://github.com/dagger/dagger | 451 | ["go.mod", "go.sum"] | SIGSEGV when two cue files have different package names in the same environment | Here is my environment:
```
dmp@macArena:~/Projects/Go/src/github.com/blocklayerhq/dagger$ cat ~/.dagger/store/docker-elastic/deployment.json
{
"id": "4d81378c-db20-45fb-a15d-df768d5d336e",
"name": "docker-elastic",
"plan": {
"type": "dir",
"dir": {
"path": "/Users/dmp/Projects/Distribution/docker-images/infrastructure/docker-elastic",
"include": [
"*.cue",
"cue.mod"
]
}
},
"inputs": [
{
"key": "Root",
"value": {
"type": "dir",
"dir": {
"path": "/Users/dmp/Projects/Distribution/docker-images/infrastructure/docker-elastic"
}
}
}
]
}
```
Going "up", segfaults in client.go line 124 (which apparently loads the environment).
```
panic: runtime error: invalid memory address or nil pointer dereference
[signal SIGSEGV: segmentation violation code=0x1 addr=0x10 pc=0x12673c6]
goroutine 55 [running]:
cuelang.org/go/internal/core/adt.(*Vertex).getNodeContext(0x0, 0xc0008d1a00, 0xc000b30000)
/Users/dmp/Applications/bin/gvm/pkgsets/go1.16/global/pkg/mod/cuelang.org/[email protected]/internal/core/adt/eval.go:911 +0x26
cuelang.org/go/internal/core/adt.(*OpContext).Unify(0xc0008d1a00, 0x0, 0xc0008d1a05)
/Users/dmp/Applications/bin/gvm/pkgsets/go1.16/global/pkg/mod/cuelang.org/[email protected]/internal/core/adt/eval.go:172 +0x50
cuelang.org/go/internal/core/adt.(*Vertex).Finalize(...)
/Users/dmp/Applications/bin/gvm/pkgsets/go1.16/global/pkg/mod/cuelang.org/[email protected]/internal/core/adt/composite.go:445
cuelang.org/go/cue.newVertexRoot(0xc00011cd70, 0xc0008d1a00, 0x0, 0xc0008d1a00, 0x12bf84b, 0xc000680480)
/Users/dmp/Applications/bin/gvm/pkgsets/go1.16/global/pkg/mod/cuelang.org/[email protected]/cue/types.go:615 +0x6f
cuelang.org/go/cue.newValueRoot(0xc00011cd70, 0xc0008d1a00, 0x23ed858, 0x0, 0x0, 0x0, 0xc0005c94a8)
/Users/dmp/Applications/bin/gvm/pkgsets/go1.16/global/pkg/mod/cuelang.org/[email protected]/cue/types.go:624 +0x70
cuelang.org/go/cue.(*Context).make(0xc00011cd70, 0x0, 0x23eced8, 0xc000ad9c80, 0x23eced8)
/Users/dmp/Applications/bin/gvm/pkgsets/go1.16/global/pkg/mod/cuelang.org/[email protected]/cue/context.go:249 +0x51
cuelang.org/go/cue.(*Context).BuildInstances(0xc00011cd70, 0xc00011fcf8, 0x1, 0x1, 0xc00011fcf8, 0x1, 0x1, 0xc00051cbd0, 0xc0005679f0)
/Users/dmp/Applications/bin/gvm/pkgsets/go1.16/global/pkg/mod/cuelang.org/[email protected]/cue/context.go:150 +0xf8
dagger.io/go/dagger/compiler.Build(0xc0005c9828, 0x0, 0x0, 0x0, 0xc0005c9938, 0xc00003cb20, 0x0)
/Users/dmp/Projects/Go/src/github.com/blocklayerhq/dagger/dagger/compiler/build.go:60 +0x25f
dagger.io/go/dagger.(*Environment).LoadPlan(0xc00003c2e0, 0x23e9818, 0xc00023a800, 0xc000052480, 0xc000286028, 0x23edd58, 0xc00002e680, 0xc00003cb20, 0x0, 0x0, ...)
/Users/dmp/Projects/Go/src/github.com/blocklayerhq/dagger/dagger/environment.go:108 +0x3c5
dagger.io/go/dagger.(*Client).buildfn.func1(0x23e9818, 0xc00023a800, 0x23edd58, 0xc00002e680, 0x0, 0x0, 0x0)
/Users/dmp/Projects/Go/src/github.com/blocklayerhq/dagger/dagger/client.go:124 +0x1c5
github.com/moby/buildkit/frontend/gateway/grpcclient.(*grpcClient).Run(0xc00002e680, 0x23e9818, 0xc00023a800, 0xc00023aec0, 0x0, 0x0)
/Users/dmp/Applications/bin/gvm/pkgsets/go1.16/global/pkg/mod/github.com/moby/[email protected]/frontend/gateway/grpcclient/client.go:187 +0x142
github.com/moby/buildkit/client.(*Client).Build.func2(0xc00029a161, 0x19, 0xc000468380, 0x0, 0x0)
/Users/dmp/Applications/bin/gvm/pkgsets/go1.16/global/pkg/mod/github.com/moby/[email protected]/client/build.go:56 +0x2a2
github.com/moby/buildkit/client.(*Client).solve.func3(0x0, 0x0)
/Users/dmp/Applications/bin/gvm/pkgsets/go1.16/global/pkg/mod/github.com/moby/[email protected]/client/solve.go:224 +0x6e
golang.org/x/sync/errgroup.(*Group).Go.func1(0xc00045a9c0, 0xc00055b100)
/Users/dmp/Applications/bin/gvm/pkgsets/go1.16/global/pkg/mod/golang.org/x/[email protected]/errgroup/errgroup.go:57 +0x59
created by golang.org/x/sync/errgroup.(*Group).Go
/Users/dmp/Applications/bin/gvm/pkgsets/go1.16/global/pkg/mod/golang.org/x/[email protected]/errgroup/errgroup.go:54 +0x66
```
Maybe this should be fixed for #448 ? | https://github.com/dagger/dagger/issues/451 | https://github.com/dagger/dagger/pull/6572 | 6a3634f6e9b66c124511e07ffc669e3fe5e709ed | 57be8a6f2e65ea108abdc65e58c328365386491a | "2021-05-12T18:28:35Z" | go | "2024-02-01T20:31:11Z" |
closed | dagger/dagger | https://github.com/dagger/dagger | 449 | ["solver/solver.go", "tests/plan.bats", "tests/plan/client/filesystem/write/test.cue"] | Duplicate log messages | This will naturally run only once ("echo LOL" one time):
```
foo: #up: [
op.#DockerBuild & {
dockerfile: """
FROM dubodubonduponey/debian
ARG TARGETPLATFORM
RUN echo LOL $TARGETPLATFORM
"""
},
]
```
This will run twice (echo LOL multiple times):
```
foo: #up: [
op.#DockerBuild & {
dockerfile: """
FROM dubodubonduponey/debian
ARG TARGETPLATFORM
RUN echo LOL $TARGETPLATFORM
"""
},
op.#PushContainer & {
ref: "push-registry.local/dagger/test:1"
},
]
```
If you add DockerLogin before, it runs once more. | https://github.com/dagger/dagger/issues/449 | https://github.com/dagger/dagger/pull/2267 | 92c8c7a2da9ec90a924d7236e540f83ec1f12419 | 2bcd0ac31ce760ce23700b5611fa580aad3c165b | "2021-05-12T17:51:41Z" | go | "2022-04-26T18:10:27Z" |
closed | dagger/dagger | https://github.com/dagger/dagger | 445 | ["website/package.json", "website/yarn.lock"] | Execution time grows 📈 with config size | It appears that execution time for `dagger up` grows logarithmically with configuration size. When a configuration reaches medium-to-large size, `dagger up` can take several minutes to complete.
This issue can be found, in a more moderate form, when running `cue eval`.
There are many ongoing discussions and investigations related to this issue. If possible, please refer them here, so we can have all information in one place, and discuss how to fix it.
| https://github.com/dagger/dagger/issues/445 | https://github.com/dagger/dagger/pull/1141 | 002608b3ba03b7d5defc9b1799bf8fc68c555b3d | 428ce961333f292d977c85cddcbe52d4853596af | "2021-05-11T22:45:26Z" | go | "2021-11-17T16:46:43Z" |
closed | dagger/dagger | https://github.com/dagger/dagger | 442 | ["Makefile", "tests/README.md"] | `make integration` fails silently when `sops` is not installed | If the [sops](https://github.com/mozilla/sops) tool is not installed, `make integration` will skip all tests which require encrypted inputs, with the confusing error message “skipped: foo/bar/inputs.yaml cannot be decrypted”).
| https://github.com/dagger/dagger/issues/442 | https://github.com/dagger/dagger/pull/443 | 98b3951c7386a8bb62d8a986b9d27a4940367a3d | 2d067c19b43a1ef6e061e9a566f4dca182d57291 | "2021-05-11T21:50:49Z" | go | "2021-05-12T18:29:16Z" |
closed | dagger/dagger | https://github.com/dagger/dagger | 436 | ["website/package.json", "website/yarn.lock"] | duplication between dagger.io/os with dagger.io/file | #418 added `dagger.io/os` (`#File`, `#Dir`) which duplicates the functionality of `dagger.io/file` (#180).
The two need to be merged together | https://github.com/dagger/dagger/issues/436 | https://github.com/dagger/dagger/pull/1091 | 5e0d582ddd403ac9b55aa90166ae941b9eefa0ae | 1c8ca28b70e336614e403426cc16f4886f8a26ca | "2021-05-08T00:47:27Z" | go | "2021-11-09T03:15:24Z" |
closed | dagger/dagger | https://github.com/dagger/dagger | 432 | ["dagger/compiler/build.go"] | SIGSEGV on wrong cue syntax | ```
debian: #up: [
op.#DockerBuild & {
dockerfile: """FROM debian
"""
},
]
```
Should have been a new line before FROM - but then, should not SIGSEGV right?
(seems like a cue bug?) | https://github.com/dagger/dagger/issues/432 | https://github.com/dagger/dagger/pull/456 | 668d6ae23f15d672397f85df59f1aa09d8420b20 | 835ac9eef3ff5e710d1472f6afa16d058465689a | "2021-05-07T19:09:54Z" | go | "2021-05-12T23:20:32Z" |
closed | dagger/dagger | https://github.com/dagger/dagger | 428 | ["go.mod", "go.sum"] | dockerfilePath appears to be misleading or not implemented as it should | `#DockerBuild.dockerfilePath` (apparently: https://github.com/dagger/dagger/blob/62eedd647039f9d237b5be4609f4fe6cb1cda3c8/dagger/pipeline.go#L815) translate to `--option filename` (for buildkit), hence allows simply to specify an alternative name for the Dockerfile, and not to specify an actual path (that part would translate to `--local dockerfile=` IIRC and seem to be missing).
Looking at https://github.com/dagger/dagger/blob/c8dbbaa1c6c585c9a44b68b1e55deaeb9709ef9f/tests/ops/dockerbuild/main.cue#L57 seem to suggest the intent was to indeed have a single option to specify both the dirpath and basename (which I agree is better UX than the buildkit approach).
Suggestion would be to either implement this proper (by splitting basename and dir component and feed buildkit both filename and dockerfile, or alternatively rename dockerfilePath to reflect the fact it only control the basename of the file and not the dir.
Hope I'm not missing something here. | https://github.com/dagger/dagger/issues/428 | https://github.com/dagger/dagger/pull/5130 | 03ee4e411ab0d590c3c7ac8b6e4221c85174ee68 | 3bb9ca66d347db4d056ed14d0a3c1c4a8e769840 | "2021-05-07T03:42:37Z" | go | "2023-05-18T12:09:11Z" |
closed | dagger/dagger | https://github.com/dagger/dagger | 396 | ["go.mod", "go.sum"] | Manage digests for docker and git refs | Sometimes my configuration fetches a git or docker repository without specifying a digest, and I want to add the current digest to avoid unexpected changes in the future. But how do I find out the current digest? Dagger does not provide a command to do this. I have to search for specialized tooling and learn how to use it, just to get that ref.
Since git and docker refs and digests are important concepts in Dagger, it makes sense for the `dagger` command to make it easy to manage digests. | https://github.com/dagger/dagger/issues/396 | https://github.com/dagger/dagger/pull/5130 | 03ee4e411ab0d590c3c7ac8b6e4221c85174ee68 | 3bb9ca66d347db4d056ed14d0a3c1c4a8e769840 | "2021-04-30T17:51:43Z" | go | "2023-05-18T12:09:11Z" |
closed | dagger/dagger | https://github.com/dagger/dagger | 364 | ["cmd/dagger/cmd/input/root.go", "cmd/dagger/cmd/input/unset.go", "tests/cli.bats"] | Unset input on deployment | ## Problem
Actually, it's not possible to remove an `input` from a deployment and that's really frustrating...
Imagine an user who do a typo when adding an input ? He will not delete the deployment and restart all from the beggining.
## Proposal
Add a flag `unset` on `dagger input` which take the `cue path` as argument and remove the input
### Example
```
$ dagger input text name "John Doe"
updated deployment...
$ dagger input list
Saved Inputs:
name: {text <nil> <nil> <nil> 0xc000612710 <nil> <nil> <nil>} # This display is not really friendly btw
Plan Inputs:
Path From Type
name (plan) string
$ dagger input unset name
updated deployment...
$ dagger input list
Saved Inputs:
Plan Inputs:
Path From Type
name (plan) string
``` | https://github.com/dagger/dagger/issues/364 | https://github.com/dagger/dagger/pull/385 | 9d421c6c4299f6ab6ea147322199e32e87b82a49 | 8abf06cb9bb8764eabc77fe0641e7602e5300b05 | "2021-04-23T14:37:50Z" | go | "2021-04-30T18:19:17Z" |
closed | dagger/dagger | https://github.com/dagger/dagger | 357 | ["website/package.json", "website/yarn.lock"] | Unique environment ID | Each dagger environment (aka deployment) has a simple name that is only unique locally. There should also be a globally unique ID for each environment. This ID should not depend on the simple name.
If the ID is derived from a unique per-environment keypair (eg. ID = hash of the pubkey), then we can use that keypair as a foundation for very promising features: cryptographic access control; content trust via TUF; etc.
I don’t know how much must be implemented by launch - but at the very least we should agree on a clear design before launch, since it will affect state format. | https://github.com/dagger/dagger/issues/357 | https://github.com/dagger/dagger/pull/4101 | 1e3e17949c4732b436a2c774043bd9da24cba34a | 302902b8110188c6458295d25be0ac802dba3bdd | "2021-04-22T20:38:51Z" | go | "2022-12-06T11:00:45Z" |
closed | dagger/dagger | https://github.com/dagger/dagger | 353 | ["stdlib/dagger/op/op.cue"] | `dagger query` is very slow | How to reproduce:
```
cd ./examples/jamstack
# configure app_config.cue
dagger new
dagger up
dagger query # takes 7 seconds on a MBP with M1 proc
```
Likely to be introduced with this commit: https://github.com/dagger/dagger/commit/3e2b46bf3aaefdfe552bb8d42513293a286d0481 (will confirm asap) | https://github.com/dagger/dagger/issues/353 | https://github.com/dagger/dagger/pull/356 | c717af0403d06d9d8fed3199b311bb550d1b3fbf | 4f91907ac4c0aff25687c769a1004aa05efa9120 | "2021-04-22T17:19:31Z" | go | "2021-04-22T19:14:37Z" |
closed | dagger/dagger | https://github.com/dagger/dagger | 330 | ["website/package.json", "website/yarn.lock"] | Atomic rollouts | When deploying `A` and `B`, if `A` succeeds then `B` fails the rollout is left as is. This can result in a broken deployment since we now have a new version of `A` with an old version of `B`.
Ideally, if a version N of a plan fails, dagger should be re-apply N-1 to bring back `A` and `B` to the same version.
/cc @samalba | https://github.com/dagger/dagger/issues/330 | https://github.com/dagger/dagger/pull/2639 | 52971518ad4286eff3e00af129de3c30a2f74e51 | a50562519a09249085149214fdb4f444f8387d42 | "2021-04-15T18:10:22Z" | go | "2022-06-17T10:19:33Z" |
closed | dagger/dagger | https://github.com/dagger/dagger | 316 | ["cmd/dagger/cmd/common/common.go", "cmd/dagger/cmd/compute.go", "cmd/dagger/cmd/down.go", "cmd/dagger/cmd/new.go", "cmd/dagger/cmd/query.go", "cmd/dagger/cmd/up.go", "dagger/client.go", "dagger/pipeline.go", "dagger/solver.go", "examples/jamstack/ecr_image.cue"] | Support command "up --no-cache" to temporarily disable the cache | It's important to be able to to disable the cache on-demand, one-time.
`dagger up --no-cache` | https://github.com/dagger/dagger/issues/316 | https://github.com/dagger/dagger/pull/327 | 551f281bf7bc404a02b01600655cfdc42097880e | 493406afe75277a50478cb4a69cf349674bc1858 | "2021-04-12T21:47:18Z" | go | "2021-04-15T18:37:45Z" |
closed | dagger/dagger | https://github.com/dagger/dagger | 312 | ["cmd/dagger/cmd/list.go"] | No way to know the current deployment based on local path | We need a way to know the current deployment when working from a local directory. For instance a small `*` or any visual indication when doing `dagger list`. Otherwise, there is no way to know a given directory is mapped to a deployment.
It would also be nice to know which path is mapped to which deployment.
Example:
```
$ dagger list
myapp (~/work/myapp)
test (/tmp/thisisatest)
$ cd ~/work/myapp
$ dagger list
myapp (~/work/myapp) - current
test (/tmp/thisisatest)
``` | https://github.com/dagger/dagger/issues/312 | https://github.com/dagger/dagger/pull/343 | d000b2912b45f927c25a390c53a52823bce06362 | d2d0734eaa926485d6f1e22271b765f9a7a6cc42 | "2021-04-11T02:21:35Z" | go | "2021-04-22T18:50:09Z" |
closed | dagger/dagger | https://github.com/dagger/dagger | 277 | ["pkg/dagger.io/dagger/engine/fs.cue", "plan/task/source.go", "tests/tasks.bats", "tests/tasks/source/hello.txt", "tests/tasks/source/source.cue", "tests/tasks/source/source_include_exclude.cue", "tests/tasks/source/source_invalid_path.cue", "tests/tasks/source/source_not_exist.cue", "tests/tasks/source/test.sh", "tests/tasks/source/world.txt"] | Embed files in a cue configuration | ## Problem
There are two distinct problems caused by the absence of so-called “embedding”.
### Embedding in top-level configuration
Sometimes one wants to embed a Dagger configuration directly in an application repository, in the same way one might embed a Dockerfile or docker-compose.yaml.
This is currently possible but not seamless. It requires several redundant steps:
1. The deployment plan declares an input of type artifact. For example `source: dagger.#Artifact`
2. Each new deployment must explicitly load the current directory into that input: `dagger input dir source .`
With embedding, that second step would be implicit.
### Embedding in an imported package
Sometimes one wants to embed non-CUE files in the source directory of a package, then introspect their contents from within the package.
For example, the `netlify` package embeds a shell script to be injected into a Docker container image, and later executed. In the absence of an API to introspect its own source directory, the package must embed the contents of the shell script as a multi-line string. A better DX would be to store the shell script in a separate `netlify.sh` file, and reference it at runtime by introspection.
## Solution
Extend the Dagger API to support file embedding. There are many possible ways to design this. Do find the best design, we need to answer a few questions first. See below.
### Proposed solution
```
package engine
// Access the source directory for the current CUE package
// This may safely be called from any package
#Source: {
// Optionally exclude certain files
include: […string]
// Optionall include certain files
exclude: […string]
// The source directory, with include and exclude filters applied
output: #FS
}
```
Example:
```
package main
import (
“dagger.io/dagger”
)
{
inputs: directories: src?: _
actions: src: inputs.directories.src.contents
} | {
actions: {
_pkgSource: dagger.#Source
src: _pkgSource.output
}
}
```
## Design questions
### One feature for both use cases?
There are two distinct use cases for embedding: in the top-level configuration, and in an imported package. Can they be solved with the same feature?
### Overlap with input directories?
There is already a way to access the contents of a directory from CUE: directory inputs. How well will a new embedding feature co-exist with regular directory inputs? Can we clearly explain to developers which feature should be used when?
### Overlap with upstream CUE?
Does CUE plan support for embedding? If so, should we use it? Do we risk conflicting with it? | https://github.com/dagger/dagger/issues/277 | https://github.com/dagger/dagger/pull/1312 | 63d655d8f39f08ecc0cd56baed7ff354efbb3ba9 | 4c673aae5291886d715cd025fbd29f6631be2373 | "2021-04-05T21:06:19Z" | go | "2022-01-14T09:51:20Z" |
closed | dagger/dagger | https://github.com/dagger/dagger | 276 | ["dagger/store.go"] | Multiple deployments with the same name? | It appears multiple deployments can have the same name, which is confusing.
```
$ dagger up
7:50PM FTL system | multiple deployments match the current directory, select one with `--deployment` deploymentPath=/home/shykes/dagger deployments=[
"dagger",
"dagger-dev",
"dagger-dev"
]
```
```
$ ls ~/.dagger/store/
dagger dagger-dev react
```
| https://github.com/dagger/dagger/issues/276 | https://github.com/dagger/dagger/pull/279 | 1ae0ce65e90e4ff3b67317c957636b64058e1f35 | 7cf1163a2b7055a1dae6cdf36aad295398e2487a | "2021-04-05T19:52:47Z" | go | "2021-04-06T00:09:35Z" |
closed | dagger/dagger | https://github.com/dagger/dagger | 232 | ["sdk/python/poetry.lock"] | Set default loglevel to INFO (not DEBUG) | Now that we are expanding the number of testers, we should not print debug messages by default. This has been confusing to several users.
For example, yesterday I was asked “where is the tarball and where can I retrieve it?”. This is because of a system message from the buildkit exporter producing the tar stream with the output values to be retrieved by the dagger client, and stored in the state. Not only is that message not useful, it is actively confusing unless you are specifically looking to debug the internals of dagger. | https://github.com/dagger/dagger/issues/232 | https://github.com/dagger/dagger/pull/5075 | 34e743983cb6290674ff4c2714404e269fdc25d3 | 7c879a2cc5e2c4c41f89ab8d5dd221cc8f9d30d2 | "2021-03-31T22:25:16Z" | go | "2023-05-04T22:54:32Z" |
closed | dagger/dagger | https://github.com/dagger/dagger | 226 | ["go.mod", "go.sum"] | Store deployment state in a txtar file rather than directory | Cue makes heavy use of the [txtar format](https://pkg.go.dev/golang.org/x/tools/txtar), originally created for the needs of the Go project. It’s a very simple text archive format. It could make our life easier to store deployment state in a txtar file (one file per deployment) rather than in posix directories.
Benefits include:
- Easier to import/export to a serialized format
- Easier to build a sync API on top (API endpoint could imply send / receive the txtar blob)
Just a thought!
cc @mpvl @myitcv if you have an opinion on the suitability of txtar, and its future in the cue project? | https://github.com/dagger/dagger/issues/226 | https://github.com/dagger/dagger/pull/1649 | c207b7e3a92095c866f08d397e201c809d9e90f8 | c82bc00f879919a49a80772a6a3d2ab1de77f2c2 | "2021-03-31T21:40:15Z" | go | "2022-03-10T19:00:32Z" |
closed | dagger/dagger | https://github.com/dagger/dagger | 186 | ["website/package.json", "website/yarn.lock"] | add lint task to `cue eval` the stdlib | This would help catch some errors earlier. (one I just fixed in #182)
We'd probably want to temp shim in the `cue.mod/dagger.io -> stdlib` symlink for this to work.
Currently it says this:
```
$ cue eval ./stdlib/...
combining bulk optional fields with other fields deprecated as of v0.2.1: try running `cue fix` using CUE v0.2.2 on the file or module to upgrade:
./stdlib/aws/cloudformation/cloudformation.cue:100:2
```
fyi @samalba | https://github.com/dagger/dagger/issues/186 | https://github.com/dagger/dagger/pull/1035 | 21eef61983373159e1f8eb21b4a98d4264c81aa5 | badc3a169da5e02cbe6dec73b4419be8723acb7c | "2021-03-16T21:05:04Z" | go | "2021-10-04T23:09:01Z" |
closed | dagger/dagger | https://github.com/dagger/dagger | 181 | ["sdk/python/poetry.lock"] | Root cmd persistent flags for logging not working | haven't diagnosed completely, but thinking the issue may be with the viper binding(?) | https://github.com/dagger/dagger/issues/181 | https://github.com/dagger/dagger/pull/4394 | 1e54736caeaf9d1f851371178d4f04a93acb545c | 2f8ca6de00299b2714d98f55316ea528b981bbd0 | "2021-03-15T18:19:47Z" | go | "2023-01-18T01:08:23Z" |
closed | dagger/dagger | https://github.com/dagger/dagger | 151 | ["core/docs/d7yxc-operator_manual.md", "docs/current/faq.md"] | Drop privileges in the managed buildkitd | Right now, when no buildkit address is specified, dagger will create its own instance https://github.com/dagger/dagger/pull/149
The container is created using `--privileged` which is far from ideal. We could look into dropping `--privileged` and using more fine grained `--security-opt`s instead, see:
https://github.com/moby/buildkit/blob/master/docs/rootless.md | https://github.com/dagger/dagger/issues/151 | https://github.com/dagger/dagger/pull/5809 | 8f6c3125f14a31e39e251492897c86768147fe26 | e63200db6dd4da2ceff56447d99b01056140b482 | "2021-03-03T19:12:33Z" | go | "2023-10-12T22:04:22Z" |
closed | dagger/dagger | https://github.com/dagger/dagger | 150 | ["go.mod", "go.sum", "internal/mage/go.mod", "internal/mage/go.sum"] | Rename dagger.#Exec: "dir" to "workdir" | I find `dagger.#Exec: dir` to be confusing. It's not explicitly that it sets the working directory for the command. I would rename it to `workdir` instead.
| https://github.com/dagger/dagger/issues/150 | https://github.com/dagger/dagger/pull/6568 | 01268a5fe62067f7d5dddfb5f5d90ecf4909eac4 | e06291a14e7f694ea2b04c1e30c41ebe751f8f21 | "2021-03-03T03:18:38Z" | go | "2024-02-06T12:01:00Z" |
closed | dagger/dagger | https://github.com/dagger/dagger | 146 | ["sdk/python/poetry.lock"] | Container Push Support | Currently, there is no way to export an image within a dagger config (e.g. "docker push").
This is extremely limiting -- for instance, it's impossible to deploy a container since it needs to be pushed to a registry before being able to run somewhere.
#134 added support for `#DockerBuild` which is half of the solution.
The underlying limitation is it's not currently possible to export an image from within the buildkit frontend API. | https://github.com/dagger/dagger/issues/146 | https://github.com/dagger/dagger/pull/4693 | 7ca67e75b0aa064d59bcfca6fafcafc6a3c828c0 | 0345058d089c213b0df646b5e68a307006c5b541 | "2021-03-01T22:10:37Z" | go | "2023-03-06T12:00:02Z" |
closed | dagger/dagger | https://github.com/dagger/dagger | 142 | ["sdk/python/poetry.lock"] | Docker Image Metadata | #141 added some light support for image metadata
However, this is only half the battle.
If you were to do a FetchContainer followed by a PushContainer (?), all the metadata would be lost.
Regardless of using FetchContainer or not -- if we don't keep track of image metadata during pipeline execution, our resulting images cannot contain things such as "sticky" ENV (e.g. a docker run of an image produced by dagger will lack PATH altogether).
Flagging as `priority/high` for now, might decide to downgrade later. | https://github.com/dagger/dagger/issues/142 | https://github.com/dagger/dagger/pull/5112 | 0ae172a590ca30eeb86a495cff39bba031887f21 | 0cb0383921a09642d5fddc1096de702fb85fbd6e | "2021-02-25T22:31:41Z" | go | "2023-05-05T15:04:07Z" |
closed | dagger/dagger | https://github.com/dagger/dagger | 130 | ["go.mod", "go.sum"] | ENV from fetched container is lost | When doing a `#FetchContainer`, `ENV` instructions (such as `PATH`) are lost.
| https://github.com/dagger/dagger/issues/130 | https://github.com/dagger/dagger/pull/6010 | 16b9328aefbc68c3897e503ff24feb8e8ba5de16 | 47837d05154c8d9a12784f9db055b8090980847a | "2021-02-19T08:39:47Z" | go | "2023-10-30T14:09:32Z" |
closed | dagger/dagger | https://github.com/dagger/dagger | 110 | ["sdk/python/poetry.lock"] | Component validation errors are unintelligible | Let's say that instead of `do: "fetch-container"` we mistakenly type `op: "fetch-container"`, like so:
```
package main
A: #dagger: compute: [
{ op: "fetch-container", ref: "alpine" },
]
```
The generator error looks like this:
> FTL failed to compute error="buildkit solve: invalid task: invalid component: #Component: 7 errors in empty disjunction:\n#Component: conflicting values bool and {#dagger:{compute:[{op:\"fetch-container\",ref:\"alpine\"}]}} (mismatched types bool and struct):\n /config/main.cue:3:4\n spec.cue:42:2\n#Component: conflicting values bytes and {#dagger:{compute:[{op:\"fetch-container\",ref:\"alpine\"}]}} (mismatched types bytes and struct):\n /config/main.cue:3:4\n spec.cue:42:32\n#Component: conflicting values float and {#dagger:{compute:[{op:\"fetch-container\",ref:\"alpine\"}]}} (mismatched types float and struct):\n /config/main.cue:3:4\n spec.cue:42:15\n#Component: conflicting values int and {#dagger:{compute:[{op:\"fetch-container\",ref:\"alpine\"}]}} (mismatched types int and struct):\n /config/main.cue:3:4\n spec.cue:42:9\n#Component: conflicting values string and {#dagger:{compute:[{op:\"fetch-container\",ref:\"alpine\"}]}} (mismatched types string and struct):\n /config/main.cue:3:4\n spec.cue:42:23\n#Component.#dagger.compute.0: 1 errors in empty disjunction:\n#Component.#dagger.compute.0: field `op` not allowed:\n /config/main.cue:3:1\n /config/main.cue:4:4\n spec.cue:36:1\n spec.cue:38:11\n spec.cue:49:12\n spec.cue:56:14\n spec.cue:59:6\n spec.cue:107:18\n\n"
| https://github.com/dagger/dagger/issues/110 | https://github.com/dagger/dagger/pull/4482 | a317d20b69c2052c397772c74c62460b237e84a8 | e647a6f82310c2cce367c343aed7b999b04916cb | "2021-02-09T00:02:36Z" | go | "2023-02-08T18:21:52Z" |
closed | dagger/dagger | https://github.com/dagger/dagger | 106 | ["sdk/python/poetry.lock"] | Support multi-arch Components | With the growing number of arm machines, it's critical to support multi-arch builds.
From the simple example in the repo:
```
#alpine: dagger.#Component & {
version: "3.13.1@sha256:3c7497bf0c7af93428242d6176e8f7905f2201d8fc5861f45be7a346b5f23436"
package: [string]: true | false | string
#dagger: compute: [
{
do: "fetch-container"
ref: "index.docker.io/alpine\(version)"
},
for pkg, info in package {
if (info & true) != _|_ {
do: "exec"
args: ["apk", "add", "-U", "--no-cache", pkg]
}
if (info & string) != _|_ {
do: "exec"
args: ["apk", "add", "-U", "--no-cache", "\(pkg)\(info)"]
}
},
]
}
```
Here the base image implicitly points to x86 because of the digest.
Then, a dagger component is likely to be arch specific, for instance:
```
#awsCli: {
version: *"2.1.23" | string
#dagger: compute: [
dagger.#Load & {
from: #alpine & {
package: {
jq: true
bash: true
curl: true
"libc6-compat": true
}
}
},
dagger.#Exec & {
args: ["bash", "-c", """
cd /tmp; curl -sfL "https://awscli.amazonaws.com/awscli-exe-linux-x86_64-\(version).zip" -o aws.zip &&
unzip aws.zip &&
./aws/install
rm -rf aws*
"""
]
}
]
}
```
This will only work on x86. We need a way to auto-select Components and based images depending on the host arch so we can write multi-arch components.
buildkit's Dockerfile is a good example: https://github.com/moby/buildkit/blob/master/Dockerfile | https://github.com/dagger/dagger/issues/106 | https://github.com/dagger/dagger/pull/4646 | 6ffc131f6a3fe03d573586e12eb19226f2a8f41f | faf5b93725d5aae1ab748f6061dc281e112c6313 | "2021-02-06T01:40:07Z" | go | "2023-02-24T23:25:52Z" |
closed | nektos/act | https://github.com/nektos/act | 2,206 | ["pkg/runner/action_cache.go", "pkg/runner/action_cache_test.go"] | `--use-new-action-cache` doesn't handle `HEAD` | ### Bug report info
```plain text
act version: 4ca35d2
GOOS: darwin
GOARCH: arm64
NumCPU: 10
Docker host: DOCKER_HOST environment variable is not set
Sockets found:
/var/run/docker.sock
Config files:
/Users/jsoref/.actrc:
#-P ubuntu-latest=node:12.20.1-buster-slim
#-P ubuntu-20.04=node:12.20.1-buster-slim
#-P ubuntu-18.04=node:12.20.1-buster-slim
-P ubuntu-latest=catthehacker/ubuntu:act-latest
-P ubuntu-22.04=catthehacker/ubuntu:act-22.04
-P ubuntu-20.04=catthehacker/ubuntu:act-20.04
-P ubuntu-18.04=catthehacker/ubuntu:act-18.04
-P ubuntu-16.04=catthehacker/ubuntu:act-16.04
-P self-hosted=catthehacker/ubuntu:act-latest
-P ubuntu-latest-4cpu=ubuntu:act-latest
-P ubuntu-latest-8cpu=ubuntu:act-latest
Build info:
Go version: go1.21.6
Module path: command-line-arguments
Main version:
Main path:
Main checksum:
Build settings:
-buildmode: exe
-compiler: gc
-ldflags: -X main.version=4ca35d2
DefaultGODEBUG: panicnil=1
CGO_ENABLED: 1
CGO_CFLAGS:
CGO_CPPFLAGS:
CGO_CXXFLAGS:
CGO_LDFLAGS:
GOARCH: arm64
GOOS: darwin
Docker Engine:
Engine version: 23.0.6
Engine runtime: runc
Cgroup version: 1
Cgroup driver: cgroupfs
Storage driver: overlay2
Registry URI: https://index.docker.io/v1/
OS: Alpine Linux v3.18
OS type: linux
OS version: 3.18.5
OS arch: aarch64
OS kernel: 6.1.64-0-virt
OS CPU: 2
OS memory: 1973 MB
Security options:
name=seccomp,profile=builtin
```
### Command used with act
```sh
~/code/nektos/act/dist/local/act --use-new-action-cache -s ACTIONS_STEP_DEBUG=true
```
### Describe issue
Error: failed to fetch "https://github.com/check-spelling-sandbox/sub-actions-0" version "HEAD": couldn't find remote ref "HEAD"
### Link to GitHub repository
https://github.com/check-spelling-sandbox/sub-actions-0/blob/a346debe23919e80d1b24a059027c0e898117763/.github/workflows/test.yml
### Workflow content
```yml
on: push
jobs:
test:
runs-on: ubuntu-latest
steps:
- name: checkout
uses: actions/checkout@v4
- name: test local
uses: ./test
- name: test public
uses: check-spelling-sandbox/sub-actions-0/test@HEAD
```
### Relevant log output
```sh
jsoref@jsoref-mbp sub-actions-0 % ~/code/nektos/act/dist/local/act --use-new-action-cache -s ACTIONS_STEP_DEBUG=true -v
WARN ⚠ You are using Apple M-series chip and you have not specified container architecture, you might encounter issues while running act. If so, try running it with '--container-architecture linux/amd64'. ⚠
DEBU[0000] Loading environment from /var/folders/r3/n29fz25x72x191fdv6mhhr3m0000gp/T/tmp.OgpfaaBnyw/sub-actions-0/.env
DEBU[0000] Loading action inputs from /var/folders/r3/n29fz25x72x191fdv6mhhr3m0000gp/T/tmp.OgpfaaBnyw/sub-actions-0/.input
DEBU[0000] Loading secrets from /var/folders/r3/n29fz25x72x191fdv6mhhr3m0000gp/T/tmp.OgpfaaBnyw/sub-actions-0/.secrets
DEBU[0000] Loading vars from /var/folders/r3/n29fz25x72x191fdv6mhhr3m0000gp/T/tmp.OgpfaaBnyw/sub-actions-0/.vars
DEBU[0000] Evaluated matrix inclusions: map[]
DEBU[0000] Loading workflows from '/var/folders/r3/n29fz25x72x191fdv6mhhr3m0000gp/T/tmp.OgpfaaBnyw/sub-actions-0/.github/workflows'
DEBU[0000] Loading workflows recursively
DEBU[0000] Found workflow 'test.yml' in '/var/folders/r3/n29fz25x72x191fdv6mhhr3m0000gp/T/tmp.OgpfaaBnyw/sub-actions-0/.github/workflows/test.yml'
DEBU[0000] Reading workflow '/var/folders/r3/n29fz25x72x191fdv6mhhr3m0000gp/T/tmp.OgpfaaBnyw/sub-actions-0/.github/workflows/test.yml'
DEBU[0000] Preparing plan with all jobs
DEBU[0000] Using the only detected workflow event: push
DEBU[0000] Planning jobs for event: push
DEBU[0000] Conditional GET for notices etag=dc91bad3-e1dd-4d9d-8dd5-5b630fc490a7
DEBU[0000] gc: 2024-02-05 15:27:43.600916 -0500 EST m=+0.016884126 module=artifactcache
DEBU[0000] Plan Stages: [0x140003a0390]
DEBU[0000] Stages Runs: [test]
DEBU[0000] Job.Name: test
DEBU[0000] Job.RawNeeds: {0 0 <nil> [] 0 0}
DEBU[0000] Job.RawRunsOn: {8 0 !!str ubuntu-latest <nil> [] 5 18}
DEBU[0000] Job.Env: {0 0 <nil> [] 0 0}
DEBU[0000] Job.If: {0 0 success() <nil> [] 0 0}
DEBU[0000] Job.Steps: checkout
DEBU[0000] Job.Steps: test local
DEBU[0000] Job.Steps: test public
DEBU[0000] Job.TimeoutMinutes:
DEBU[0000] Job.Services: map[]
DEBU[0000] Job.Strategy: <nil>
DEBU[0000] Job.RawContainer: {0 0 <nil> [] 0 0}
DEBU[0000] Job.Defaults.Run.Shell:
DEBU[0000] Job.Defaults.Run.WorkingDirectory:
DEBU[0000] Job.Outputs: map[]
DEBU[0000] Job.Uses:
DEBU[0000] Job.With: map[]
DEBU[0000] Job.Result:
DEBU[0000] Empty Strategy, matrixes=[map[]]
DEBU[0000] Job Matrices: [map[]]
DEBU[0000] Runner Matrices: map[]
DEBU[0000] Final matrix after applying user inclusions '[map[]]'
DEBU[0000] Loading revision from git directory
DEBU[0000] Found revision: a346debe23919e80d1b24a059027c0e898117763
DEBU[0000] HEAD points to 'a346debe23919e80d1b24a059027c0e898117763'
DEBU[0000] using github ref: refs/heads/main
DEBU[0000] Found revision: a346debe23919e80d1b24a059027c0e898117763
DEBU[0000] Detected CPUs: 10
[test.yml/test] [DEBUG] evaluating expression 'success()'
[test.yml/test] [DEBUG] expression 'success()' evaluated to '***'
[test.yml/test] 🚀 Start image=catthehacker/ubuntu:act-latest
INFO[0000] Parallel tasks (0) below minimum, setting to 1
[test.yml/test] 🐳 docker pull image=catthehacker/ubuntu:act-latest platform= username= forcePull=***
[test.yml/test] [DEBUG] 🐳 docker pull catthehacker/ubuntu:act-latest
[test.yml/test] [DEBUG] pulling image 'docker.io/catthehacker/ubuntu:act-latest' ()
DEBU[0000] Saving notices etag=dc91bad3-e1dd-4d9d-8dd5-5b630fc490a7
DEBU[0000] No new notices
[test.yml/test] [DEBUG] Pulling from catthehacker/ubuntu :: act-latest
[test.yml/test] [DEBUG] Digest: sha256:fa1bac54a63b8f2d338d5b3e2beb326bb70904d993e26f1c5804a97d0013de8c ::
[test.yml/test] [DEBUG] Status: Image is up to date for catthehacker/ubuntu:act-latest ::
INFO[0008] Parallel tasks (0) below minimum, setting to 1
[test.yml/test] 🐳 docker create image=catthehacker/ubuntu:act-latest platform= entrypoint=["tail" "-f" "/dev/null"] cmd=[] network="host"
[test.yml/test] [DEBUG] Common container.Config ==> &{Hostname: Domainname: User: AttachStdin:false AttachStdout:false AttachStderr:false ExposedPorts:map[] Tty:*** OpenStdin:false StdinOnce:false Env:[RUNNER_TOOL_CACHE=/opt/hostedtoolcache RUNNER_OS=Linux RUNNER_ARCH=ARM64 RUNNER_TEMP=/tmp LANG=C.UTF-8] Cmd:[] Healthcheck:<nil> ArgsEscaped:false Image:catthehacker/ubuntu:act-latest Volumes:map[] WorkingDir:/var/folders/r3/n29fz25x72x191fdv6mhhr3m0000gp/T/tmp.OgpfaaBnyw/sub-actions-0 Entrypoint:[] NetworkDisabled:false MacAddress: OnBuild:[] Labels:map[] StopSignal: StopTimeout:<nil> Shell:[]}
[test.yml/test] [DEBUG] Common container.HostConfig ==> &{Binds:[/var/run/docker.sock:/var/run/docker.sock] ContainerIDFile: LogConfig:{Type: Config:map[]} NetworkMode:host PortBindings:map[] RestartPolicy:{Name: MaximumRetryCount:0} AutoRemove:false VolumeDriver: VolumesFrom:[] ConsoleSize:[0 0] Annotations:map[] CapAdd:[] CapDrop:[] CgroupnsMode: DNS:[] DNSOptions:[] DNSSearch:[] ExtraHosts:[] GroupAdd:[] IpcMode: Cgroup: Links:[] OomScoreAdj:0 PidMode: Privileged:false PublishAllPorts:false ReadonlyRootfs:false SecurityOpt:[] StorageOpt:map[] Tmpfs:map[] UTSMode: UsernsMode: ShmSize:0 Sysctls:map[] Runtime: Isolation: Resources:{CPUShares:0 Memory:0 NanoCPUs:0 CgroupParent: BlkioWeight:0 BlkioWeightDevice:[] BlkioDeviceReadBps:[] BlkioDeviceWriteBps:[] BlkioDeviceReadIOps:[] BlkioDeviceWriteIOps:[] CPUPeriod:0 CPUQuota:0 CPURealtimePeriod:0 CPURealtimeRuntime:0 CpusetCpus: CpusetMems: Devices:[] DeviceCgroupRules:[] DeviceRequests:[] KernelMemory:0 KernelMemoryTCP:0 MemoryReservation:0 MemorySwap:0 MemorySwappiness:<nil> OomKillDisable:<nil> PidsLimit:<nil> Ulimits:[] CPUCount:0 CPUPercent:0 IOMaximumIOps:0 IOMaximumBandwidth:0} Mounts:[{Type:volume Source:act-toolcache Target:/toolcache ReadOnly:false Consistency: BindOptions:<nil> VolumeOptions:<nil> TmpfsOptions:<nil> ClusterOptions:<nil>} {Type:volume Source:act-test-yml-test-1022155a5276c1a9bd474715a469356fa6538d4315e857809c6e7a523bcb2644-env Target:/var/run/act ReadOnly:false Consistency: BindOptions:<nil> VolumeOptions:<nil> TmpfsOptions:<nil> ClusterOptions:<nil>} {Type:volume Source:act-test-yml-test-1022155a5276c1a9bd474715a469356fa6538d4315e857809c6e7a523bcb2644 Target:/var/folders/r3/n29fz25x72x191fdv6mhhr3m0000gp/T/tmp.OgpfaaBnyw/sub-actions-0 ReadOnly:false Consistency: BindOptions:<nil> VolumeOptions:<nil> TmpfsOptions:<nil> ClusterOptions:<nil>}] MaskedPaths:[] ReadonlyPaths:[] Init:<nil>}
[test.yml/test] [DEBUG] input.NetworkAliases ==> [test]
[test.yml/test] [DEBUG] Created container name=act-test-yml-test-1022155a5276c1a9bd474715a469356fa6538d4315e857809c6e7a523bcb2644 id=ae6c60e496b6a98298ae9e3dbf72f384582101d8388c8a6da17e8cacf1543feb from image catthehacker/ubuntu:act-latest (platform: )
[test.yml/test] [DEBUG] ENV ==> [RUNNER_TOOL_CACHE=/opt/hostedtoolcache RUNNER_OS=Linux RUNNER_ARCH=ARM64 RUNNER_TEMP=/tmp LANG=C.UTF-8]
[test.yml/test] 🐳 docker run image=catthehacker/ubuntu:act-latest platform= entrypoint=["tail" "-f" "/dev/null"] cmd=[] network="host"
[test.yml/test] [DEBUG] Starting container: ae6c60e496b6a98298ae9e3dbf72f384582101d8388c8a6da17e8cacf1543feb
[test.yml/test] [DEBUG] Started container: ae6c60e496b6a98298ae9e3dbf72f384582101d8388c8a6da17e8cacf1543feb
[test.yml/test] [DEBUG] Writing entry to tarball workflow/event.json len:2
[test.yml/test] [DEBUG] Writing entry to tarball workflow/envs.txt len:0
[test.yml/test] [DEBUG] Extracting content to '/var/run/act/'
[test.yml/test] [DEBUG] Loading revision from git directory
[test.yml/test] [DEBUG] Found revision: a346debe23919e80d1b24a059027c0e898117763
[test.yml/test] [DEBUG] HEAD points to 'a346debe23919e80d1b24a059027c0e898117763'
[test.yml/test] [DEBUG] using github ref: refs/heads/main
[test.yml/test] [DEBUG] Found revision: a346debe23919e80d1b24a059027c0e898117763
[test.yml/test] [DEBUG] Loading revision from git directory
[test.yml/test] [DEBUG] Found revision: a346debe23919e80d1b24a059027c0e898117763
[test.yml/test] [DEBUG] HEAD points to 'a346debe23919e80d1b24a059027c0e898117763'
[test.yml/test] [DEBUG] using github ref: refs/heads/main
[test.yml/test] [DEBUG] Found revision: a346debe23919e80d1b24a059027c0e898117763
[test.yml/test] [DEBUG] Skipping local actions/checkout because workdir was already copied
[test.yml/test] [DEBUG] skip pre step for 'checkout': no action model available
[test.yml/test] [DEBUG] Loading revision from git directory
[test.yml/test] [DEBUG] Found revision: a346debe23919e80d1b24a059027c0e898117763
[test.yml/test] [DEBUG] HEAD points to 'a346debe23919e80d1b24a059027c0e898117763'
[test.yml/test] [DEBUG] using github ref: refs/heads/main
[test.yml/test] [DEBUG] Found revision: a346debe23919e80d1b24a059027c0e898117763
[test.yml/test] [DEBUG] skipping post step for 'test public'; step was not executed
[test.yml/test] [DEBUG] skipping post step for 'test local'; step was not executed
[test.yml/test] [DEBUG] skipping post step for 'checkout'; step was not executed
[test.yml/test] Cleaning up container for job test
[test.yml/test] [DEBUG] Removed container: ae6c60e496b6a98298ae9e3dbf72f384582101d8388c8a6da17e8cacf1543feb
[test.yml/test] [DEBUG] 🐳 docker volume rm act-test-yml-test-1022155a5276c1a9bd474715a469356fa6538d4315e857809c6e7a523bcb2644
[test.yml/test] [DEBUG] 🐳 docker volume rm act-test-yml-test-1022155a5276c1a9bd474715a469356fa6538d4315e857809c6e7a523bcb2644-env
[test.yml/test] 🏁 Job succeeded
[test.yml/test] [DEBUG] Loading revision from git directory
[test.yml/test] [DEBUG] Found revision: a346debe23919e80d1b24a059027c0e898117763
[test.yml/test] [DEBUG] HEAD points to 'a346debe23919e80d1b24a059027c0e898117763'
[test.yml/test] [DEBUG] using github ref: refs/heads/main
[test.yml/test] [DEBUG] Found revision: a346debe23919e80d1b24a059027c0e898117763
Error: failed to fetch "https://github.com/check-spelling-sandbox/sub-actions-0" version "HEAD": couldn't find remote ref "HEAD"
jsoref@jsoref-mbp sub-actions-0 %
```
### Additional information
_No response_ | https://github.com/nektos/act/issues/2206 | https://github.com/nektos/act/pull/2208 | 852959e1e14bf5cd9c0284d15ca899bef68ff4af | 5601fb0e136fad09282705ef65cbc9b2c6f0bebf | "2024-02-05T20:28:03Z" | go | "2024-02-18T03:53:22Z" |
closed | nektos/act | https://github.com/nektos/act | 2,193 | ["cmd/root.go"] | Crash on version 0.2.58 with "open : no such file or directory" | ### Bug report info
```plain text
act version: 0.2.58
GOOS: linux
GOARCH: amd64
NumCPU: 20
Docker host: DOCKER_HOST environment variable is not set
Sockets found:
/var/run/docker.sock
Config files:
/root/.actrc:
-P ubuntu-latest=catthehacker/ubuntu:act-latest
-P ubuntu-22.04=catthehacker/ubuntu:act-22.04
-P ubuntu-20.04=catthehacker/ubuntu:act-20.04
-P ubuntu-18.04=catthehacker/ubuntu:act-18.04
Build info:
Go version: go1.20.13
Module path: github.com/nektos/act
Main version: (devel)
Main path: github.com/nektos/act
Main checksum:
Build settings:
-buildmode: exe
-compiler: gc
-ldflags: -s -w -X main.version=0.2.58 -X main.commit=3ed38d8e8b63f435cb845fbe9cdccc7ff032f402 -X main.date=2024-02-01T02:12:51Z -X main.builtBy=goreleaser
CGO_ENABLED: 0
GOARCH: amd64
GOOS: linux
GOAMD64: v1
vcs: git
vcs.revision: 3ed38d8e8b63f435cb845fbe9cdccc7ff032f402
vcs.time: 2024-02-01T02:12:33Z
vcs.modified: false
Docker Engine:
Engine version: 25.0.0
Engine runtime: runc
Cgroup version: 2
Cgroup driver: systemd
Storage driver: overlay2
Registry URI: https://index.docker.io/v1/
OS: Ubuntu 22.04.3 LTS
OS type: linux
OS version: 22.04
OS arch: x86_64
OS kernel: 6.5.0-15-generic
OS CPU: 20
OS memory: 31775 MB
Security options:
name=apparmor
name=seccomp,profile=builtin
name=cgroupns
```
### Command used with act
```sh
act -j test
```
### Describe issue
Run the github workflow with a positive output
### Link to GitHub repository
https://github.com/cplee/github-actions-demo
### Workflow content
```yml
name: CI
on: push
jobs:
test:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v2
- uses: actions/setup-node@v1
- run: npm install
- run: npm test
```
### Relevant log output
```sh
DEBU[0000] Loading environment from /home/user/Documents/projects/github-actions-demo/.env
DEBU[0000] Loading action inputs from /home/user/Documents/projects/github-actions-demo/.input
DEBU[0000] Loading secrets from /home/user/Documents/projects/github-actions-demo/.secrets
DEBU[0000] Loading vars from /home/user/Documents/projects/github-actions-demo/.vars
DEBU[0000] Evaluated matrix inclusions: map[]
DEBU[0000] Loading workflows from '/home/user/Documents/projects/github-actions-demo/.github/workflows'
DEBU[0000] Loading workflows recursively
DEBU[0000] Found workflow 'main.yml' in '/home/user/Documents/projects/github-actions-demo/.github/workflows/main.yml'
DEBU[0000] Reading workflow '/home/user/Documents/projects/github-actions-demo/.github/workflows/main.yml'
DEBU[0000] Conditional GET for notices etag=96b12462-d702-4b18-af76-8a7da5d9756e
DEBU[0000] Preparing plan with all jobs
DEBU[0000] Using the only detected workflow event: push
DEBU[0000] Planning jobs for event: push
? Please choose the default image you want to use with act:
- Large size image: ca. 17GB download + 53.1GB storage, you will need 75GB of free disk space, snapshots of GitHub Hosted Runners without snap and pulled docker images
- Medium size image: ~500MB, includes only necessary tools to bootstrap actions and aims to be compatible with most actions
- Micro size image: <200MB, contains only NodeJS required to bootstrap actions, doesn't work with all actions
Default image and other options can be changed manually in ~/.actrc (please refer to https://github.com/nektos/act#configuration for additional information about file structure) Medium
FATA[0001] open : no such file or directory
```
### Additional information
with 0.2.57 works everything fine! | https://github.com/nektos/act/issues/2193 | https://github.com/nektos/act/pull/2195 | 3ed38d8e8b63f435cb845fbe9cdccc7ff032f402 | 12c0c4277af1e3d07a6389c3260d28579ba31e01 | "2024-02-01T14:34:35Z" | go | "2024-02-01T21:57:16Z" |
closed | nektos/act | https://github.com/nektos/act | 2,183 | ["pkg/container/docker_run.go", "pkg/container/docker_run_test.go"] | new-action-cache: rootless containers cannot read actions due to access level | _This is behind a feature flag and doesn't cause problems unless explicit opt in_
Using rootful container avoids the problem | https://github.com/nektos/act/issues/2183 | https://github.com/nektos/act/pull/2242 | 352ad41ad2b8a205b12442859280b0e938b7e4ab | 119ceb81d906be5e1b23bd085f642ffde7144ef5 | "2024-01-30T22:02:18Z" | go | "2024-03-08T01:25:03Z" |
closed | nektos/act | https://github.com/nektos/act | 2,085 | ["pkg/runner/run_context.go", "pkg/runner/run_context_test.go"] | Job-level `if` ignored when calling a reusable workflow | ### Bug report info
```plain text
act version: 0.2.53
GOOS: darwin
GOARCH: arm64
NumCPU: 12
Docker host: DOCKER_HOST environment variable is not set
Sockets found:
/var/run/docker.sock
$HOME/.docker/run/docker.sock
Config files:
/Users/jonj/.actrc:
-P ubuntu-latest=node:16-buster-slim
-P ubuntu-22.04=node:16-bullseye-slim
-P ubuntu-20.04=node:16-buster-slim
-P ubuntu-18.04=node:16-buster-slim
Build info:
Go version: go1.21.3
Module path: command-line-arguments
Main version:
Main path:
Main checksum:
Build settings:
-buildmode: exe
-compiler: gc
-ldflags: -X main.version=0.2.53
DefaultGODEBUG: panicnil=1
CGO_ENABLED: 1
CGO_CFLAGS:
CGO_CPPFLAGS:
CGO_CXXFLAGS:
CGO_LDFLAGS:
GOARCH: arm64
GOOS: darwin
Docker Engine:
Engine version: 24.0.6
Engine runtime: runc
Cgroup version: 2
Cgroup driver: cgroupfs
Storage driver: overlay2
Registry URI: https://index.docker.io/v1/
OS: Docker Desktop
OS type: linux
OS version:
OS arch: aarch64
OS kernel: 6.4.16-linuxkit
OS CPU: 12
OS memory: 7844 MB
Security options:
name=seccomp,profile=unconfined
name=cgroupns
```
### Command used with act
```sh
act -vW .github/workflows/sample.yml
```
### Describe issue
If you call a reusable workflow conditionally, act ignores the conditional and always runs it. Act should respect the `if` expression when determining whether to call the reusable workflow, just as GitHub does.
Per the documentation, `if` is one of the [supported keywords](https://docs.github.com/en/actions/using-workflows/reusing-workflows#supported-keywords-for-jobs-that-call-a-reusable-workflow) for jobs that call reusable workflows.
### Link to GitHub repository
https://github.com/jenseng/dynamic-uses/actions/runs/6819338970
### Workflow content
```yml
# .github/workflows/sample.yml
name: test
on: push
jobs:
test:
if: false
uses: ./.github/workflows/sample2.yml
# .github/workflows/sample2.yml
name: test
on: workflow_call
jobs:
test:
runs-on: ubuntu-latest
steps:
- run: |
echo ::error::this should not run!
exit 1
```
### Relevant log output
```sh
WARN ⚠ You are using Apple M-series chip and you have not specified container architecture, you might encounter issues while running act. If so, try running it with '--container-architecture linux/amd64'. ⚠
DEBU[0000] Loading environment from /Users/jonj/projects/dynamic-uses/.env
DEBU[0000] Loading action inputs from /Users/jonj/projects/dynamic-uses/.input
DEBU[0000] Loading secrets from /Users/jonj/projects/dynamic-uses/.secrets
DEBU[0000] Loading vars from /Users/jonj/projects/dynamic-uses/.vars
DEBU[0000] Evaluated matrix inclusions: map[]
DEBU[0000] Loading workflow '/Users/jonj/projects/dynamic-uses/.github/workflows/sample.yml'
DEBU[0000] Reading workflow '/Users/jonj/projects/dynamic-uses/.github/workflows/sample.yml'
DEBU[0000] Conditional GET for notices etag=3ab79ee3-dac6-4685-b8d0-a6a766c10cbf
DEBU[0000] Preparing plan with all jobs
DEBU[0000] Using the only detected workflow event: push
DEBU[0000] Planning jobs for event: push
DEBU[0000] gc: 2023-11-09 17:59:37.871646 -0700 MST m=+0.033583084 module=artifactcache
DEBU[0000] Plan Stages: [0x1400000e2e8]
DEBU[0000] Stages Runs: [test]
DEBU[0000] Job.Name: test
DEBU[0000] Job.RawNeeds: {0 0 <nil> [] 0 0}
DEBU[0000] Job.RawRunsOn: {0 0 <nil> [] 0 0}
DEBU[0000] Job.Env: {0 0 <nil> [] 0 0}
DEBU[0000] Job.If: {8 0 !!bool false <nil> [] 5 9}
DEBU[0000] Job.TimeoutMinutes:
DEBU[0000] Job.Services: map[]
DEBU[0000] Job.Strategy: <nil>
DEBU[0000] Job.RawContainer: {0 0 <nil> [] 0 0}
DEBU[0000] Job.Defaults.Run.Shell:
DEBU[0000] Job.Defaults.Run.WorkingDirectory:
DEBU[0000] Job.Outputs: map[]
DEBU[0000] Job.Uses: ./.github/workflows/sample2.yml
DEBU[0000] Job.With: map[]
DEBU[0000] Job.Result:
DEBU[0000] Empty Strategy, matrixes=[map[]]
DEBU[0000] Job Matrices: [map[]]
DEBU[0000] Runner Matrices: map[]
DEBU[0000] Final matrix after applying user inclusions '[map[]]'
DEBU[0000] Loading revision from git directory
DEBU[0000] Found revision: e97ea9384ae2a40ee8c8eef5b4c9c2323a0df3f3
DEBU[0000] HEAD points to 'e97ea9384ae2a40ee8c8eef5b4c9c2323a0df3f3'
DEBU[0000] using github ref: refs/heads/debug-act-bug6
DEBU[0000] Found revision: e97ea9384ae2a40ee8c8eef5b4c9c2323a0df3f3
DEBU[0000] Detected CPUs: 12
[test/test] [DEBUG] evaluating expression 'false'
[test/test] [DEBUG] expression 'false' evaluated to 'false'
DEBU[0000] Loading workflow '/Users/jonj/projects/dynamic-uses/.github/workflows/sample2.yml'
DEBU[0000] Reading workflow '/Users/jonj/projects/dynamic-uses/.github/workflows/sample2.yml'
DEBU[0000] Plan Stages: [0x1400011ec30]
DEBU[0000] Stages Runs: [test]
DEBU[0000] Job.Name: test
DEBU[0000] Job.RawNeeds: {0 0 <nil> [] 0 0}
DEBU[0000] Job.RawRunsOn: {8 0 !!str ubuntu-latest <nil> [] 5 14}
DEBU[0000] Job.Env: {0 0 <nil> [] 0 0}
DEBU[0000] Job.If: {0 0 success() <nil> [] 0 0}
DEBU[0000] Job.Steps: echo ::error::this should not run!
exit 1
DEBU[0000] Job.TimeoutMinutes:
DEBU[0000] Job.Services: map[]
DEBU[0000] Job.Strategy: <nil>
DEBU[0000] Job.RawContainer: {0 0 <nil> [] 0 0}
DEBU[0000] Job.Defaults.Run.Shell:
DEBU[0000] Job.Defaults.Run.WorkingDirectory:
DEBU[0000] Job.Outputs: map[]
DEBU[0000] Job.Uses:
DEBU[0000] Job.With: map[]
DEBU[0000] Job.Result:
DEBU[0000] Empty Strategy, matrixes=[map[]]
DEBU[0000] Job Matrices: [map[]]
DEBU[0000] Runner Matrices: map[]
DEBU[0000] Final matrix after applying user inclusions '[map[]]'
[test/test] [DEBUG] Loading revision from git directory
[test/test] [DEBUG] Found revision: e97ea9384ae2a40ee8c8eef5b4c9c2323a0df3f3
[test/test] [DEBUG] HEAD points to 'e97ea9384ae2a40ee8c8eef5b4c9c2323a0df3f3'
[test/test] [DEBUG] using github ref: refs/heads/debug-act-bug6
[test/test] [DEBUG] Found revision: e97ea9384ae2a40ee8c8eef5b4c9c2323a0df3f3
DEBU[0000] Detected CPUs: 12
[test/test/test] [DEBUG] evaluating expression 'success()'
[test/test/test] [DEBUG] expression 'success()' evaluated to 'true'
[test/test/test] 🚀 Start image=node:16-buster-slim
INFO[0000] Parallel tasks (0) below minimum, setting to 1
[test/test/test] 🐳 docker pull image=node:16-buster-slim platform= username= forcePull=true
[test/test/test] [DEBUG] 🐳 docker pull node:16-buster-slim
[test/test/test] [DEBUG] pulling image 'docker.io/library/node:16-buster-slim' ()
DEBU[0000] Saving notices etag=3ab79ee3-dac6-4685-b8d0-a6a766c10cbf
DEBU[0000] No new notices
[test/test/test] [DEBUG] Pulling from library/node :: 16-buster-slim
[test/test/test] [DEBUG] Digest: sha256:3ebf2875c188d22939c6ab080cfb1a4a6248cc86bae600ea8e2326aa03acdb8f ::
[test/test/test] [DEBUG] Status: Image is up to date for node:16-buster-slim ::
[test/test/test] [DEBUG] Removed container: 1f97922e525f287201e09a9d484ce056167bb504ad0c9565466554aafe6d6465
[test/test/test] [DEBUG] 🐳 docker volume rm act-test-test-test-5d1e1a4313b35f9e866f54c0a4ffe4a7eba19b60139ecb031689c9aadf598940
[test/test/test] [DEBUG] 🐳 docker volume rm act-test-test-test-5d1e1a4313b35f9e866f54c0a4ffe4a7eba19b60139ecb031689c9aadf598940-env
INFO[0001] Parallel tasks (0) below minimum, setting to 1
[test/test/test] 🐳 docker create image=node:16-buster-slim platform= entrypoint=["tail" "-f" "/dev/null"] cmd=[] network="host"
[test/test/test] [DEBUG] Common container.Config ==> &{Hostname: Domainname: User: AttachStdin:false AttachStdout:false AttachStderr:false ExposedPorts:map[] Tty:true OpenStdin:false StdinOnce:false Env:[RUNNER_TOOL_CACHE=/opt/hostedtoolcache RUNNER_OS=Linux RUNNER_ARCH=ARM64 RUNNER_TEMP=/tmp LANG=C.UTF-8] Cmd:[] Healthcheck:<nil> ArgsEscaped:false Image:node:16-buster-slim Volumes:map[] WorkingDir:/Users/jonj/projects/dynamic-uses Entrypoint:[] NetworkDisabled:false MacAddress: OnBuild:[] Labels:map[] StopSignal: StopTimeout:<nil> Shell:[]}
[test/test/test] [DEBUG] Common container.HostConfig ==> &{Binds:[/var/run/docker.sock:/var/run/docker.sock] ContainerIDFile: LogConfig:{Type: Config:map[]} NetworkMode:host PortBindings:map[] RestartPolicy:{Name: MaximumRetryCount:0} AutoRemove:false VolumeDriver: VolumesFrom:[] ConsoleSize:[0 0] Annotations:map[] CapAdd:[] CapDrop:[] CgroupnsMode: DNS:[] DNSOptions:[] DNSSearch:[] ExtraHosts:[] GroupAdd:[] IpcMode: Cgroup: Links:[] OomScoreAdj:0 PidMode: Privileged:false PublishAllPorts:false ReadonlyRootfs:false SecurityOpt:[] StorageOpt:map[] Tmpfs:map[] UTSMode: UsernsMode: ShmSize:0 Sysctls:map[] Runtime: Isolation: Resources:{CPUShares:0 Memory:0 NanoCPUs:0 CgroupParent: BlkioWeight:0 BlkioWeightDevice:[] BlkioDeviceReadBps:[] BlkioDeviceWriteBps:[] BlkioDeviceReadIOps:[] BlkioDeviceWriteIOps:[] CPUPeriod:0 CPUQuota:0 CPURealtimePeriod:0 CPURealtimeRuntime:0 CpusetCpus: CpusetMems: Devices:[] DeviceCgroupRules:[] DeviceRequests:[] KernelMemory:0 KernelMemoryTCP:0 MemoryReservation:0 MemorySwap:0 MemorySwappiness:<nil> OomKillDisable:<nil> PidsLimit:<nil> Ulimits:[] CPUCount:0 CPUPercent:0 IOMaximumIOps:0 IOMaximumBandwidth:0} Mounts:[{Type:volume Source:act-toolcache Target:/toolcache ReadOnly:false Consistency: BindOptions:<nil> VolumeOptions:<nil> TmpfsOptions:<nil> ClusterOptions:<nil>} {Type:volume Source:act-test-test-test-5d1e1a4313b35f9e866f54c0a4ffe4a7eba19b60139ecb031689c9aadf598940-env Target:/var/run/act ReadOnly:false Consistency: BindOptions:<nil> VolumeOptions:<nil> TmpfsOptions:<nil> ClusterOptions:<nil>} {Type:volume Source:act-test-test-test-5d1e1a4313b35f9e866f54c0a4ffe4a7eba19b60139ecb031689c9aadf598940 Target:/Users/jonj/projects/dynamic-uses ReadOnly:false Consistency: BindOptions:<nil> VolumeOptions:<nil> TmpfsOptions:<nil> ClusterOptions:<nil>}] MaskedPaths:[] ReadonlyPaths:[] Init:<nil>}
[test/test/test] [DEBUG] input.NetworkAliases ==> [test]
[test/test/test] [DEBUG] not a use defined config??
[test/test/test] [DEBUG] Created container name=act-test-test-test-5d1e1a4313b35f9e866f54c0a4ffe4a7eba19b60139ecb031689c9aadf598940 id=273a829978eeda53d708708dde84e43d8980385730bf174b1a975884eef4b827 from image node:16-buster-slim (platform: )
[test/test/test] [DEBUG] ENV ==> [RUNNER_TOOL_CACHE=/opt/hostedtoolcache RUNNER_OS=Linux RUNNER_ARCH=ARM64 RUNNER_TEMP=/tmp LANG=C.UTF-8]
[test/test/test] 🐳 docker run image=node:16-buster-slim platform= entrypoint=["tail" "-f" "/dev/null"] cmd=[] network="host"
[test/test/test] [DEBUG] Starting container: 273a829978eeda53d708708dde84e43d8980385730bf174b1a975884eef4b827
[test/test/test] [DEBUG] Started container: 273a829978eeda53d708708dde84e43d8980385730bf174b1a975884eef4b827
[test/test/test] [DEBUG] Writing entry to tarball workflow/event.json len:2
[test/test/test] [DEBUG] Writing entry to tarball workflow/envs.txt len:0
[test/test/test] [DEBUG] Extracting content to '/var/run/act/'
[test/test/test] [DEBUG] Loading revision from git directory
[test/test/test] [DEBUG] Found revision: e97ea9384ae2a40ee8c8eef5b4c9c2323a0df3f3
[test/test/test] [DEBUG] HEAD points to 'e97ea9384ae2a40ee8c8eef5b4c9c2323a0df3f3'
[test/test/test] [DEBUG] using github ref: refs/heads/debug-act-bug6
[test/test/test] [DEBUG] Found revision: e97ea9384ae2a40ee8c8eef5b4c9c2323a0df3f3
[test/test/test] [DEBUG] Loading revision from git directory
[test/test/test] [DEBUG] Found revision: e97ea9384ae2a40ee8c8eef5b4c9c2323a0df3f3
[test/test/test] [DEBUG] HEAD points to 'e97ea9384ae2a40ee8c8eef5b4c9c2323a0df3f3'
[test/test/test] [DEBUG] using github ref: refs/heads/debug-act-bug6
[test/test/test] [DEBUG] Found revision: e97ea9384ae2a40ee8c8eef5b4c9c2323a0df3f3
[test/test/test] [DEBUG] Loading revision from git directory
[test/test/test] [DEBUG] Found revision: e97ea9384ae2a40ee8c8eef5b4c9c2323a0df3f3
[test/test/test] [DEBUG] HEAD points to 'e97ea9384ae2a40ee8c8eef5b4c9c2323a0df3f3'
[test/test/test] [DEBUG] using github ref: refs/heads/debug-act-bug6
[test/test/test] [DEBUG] Found revision: e97ea9384ae2a40ee8c8eef5b4c9c2323a0df3f3
[test/test/test] [DEBUG] Loading revision from git directory
[test/test/test] [DEBUG] Found revision: e97ea9384ae2a40ee8c8eef5b4c9c2323a0df3f3
[test/test/test] [DEBUG] HEAD points to 'e97ea9384ae2a40ee8c8eef5b4c9c2323a0df3f3'
[test/test/test] [DEBUG] using github ref: refs/heads/debug-act-bug6
[test/test/test] [DEBUG] Found revision: e97ea9384ae2a40ee8c8eef5b4c9c2323a0df3f3
[test/test/test] [DEBUG] setupEnv => map[ACT:true ACTIONS_CACHE_URL:http://172.24.80.224:50279/ CI:true GITHUB_ACTION:0 GITHUB_ACTIONS:true GITHUB_ACTION_PATH: GITHUB_ACTION_REF: GITHUB_ACTION_REPOSITORY: GITHUB_ACTOR:nektos/act GITHUB_API_URL:https://api.github.com GITHUB_BASE_REF: GITHUB_EVENT_NAME:push GITHUB_EVENT_PATH:/var/run/act/workflow/event.json GITHUB_GRAPHQL_URL:https://api.github.com/graphql GITHUB_HEAD_REF: GITHUB_JOB:test GITHUB_REF:refs/heads/debug-act-bug6 GITHUB_REF_NAME:debug-act-bug6 GITHUB_REF_TYPE:branch GITHUB_REPOSITORY:jenseng/dynamic-uses GITHUB_REPOSITORY_OWNER:jenseng GITHUB_RETENTION_DAYS:0 GITHUB_RUN_ID:1 GITHUB_RUN_NUMBER:1 GITHUB_SERVER_URL:https://github.com GITHUB_SHA:e97ea9384ae2a40ee8c8eef5b4c9c2323a0df3f3 GITHUB_TOKEN: GITHUB_WORKFLOW:test GITHUB_WORKSPACE:/Users/jonj/projects/dynamic-uses ImageOS:ubuntu20 RUNNER_PERFLOG:/dev/null RUNNER_TRACKING_ID:]
[test/test/test] [DEBUG] Loading revision from git directory
[test/test/test] [DEBUG] Found revision: e97ea9384ae2a40ee8c8eef5b4c9c2323a0df3f3
[test/test/test] [DEBUG] HEAD points to 'e97ea9384ae2a40ee8c8eef5b4c9c2323a0df3f3'
[test/test/test] [DEBUG] using github ref: refs/heads/debug-act-bug6
[test/test/test] [DEBUG] Found revision: e97ea9384ae2a40ee8c8eef5b4c9c2323a0df3f3
[test/test/test] [DEBUG] Loading revision from git directory
[test/test/test] [DEBUG] Found revision: e97ea9384ae2a40ee8c8eef5b4c9c2323a0df3f3
[test/test/test] [DEBUG] HEAD points to 'e97ea9384ae2a40ee8c8eef5b4c9c2323a0df3f3'
[test/test/test] [DEBUG] using github ref: refs/heads/debug-act-bug6
[test/test/test] [DEBUG] Found revision: e97ea9384ae2a40ee8c8eef5b4c9c2323a0df3f3
[test/test/test] [DEBUG] evaluating expression ''
[test/test/test] [DEBUG] expression '' evaluated to 'true'
[test/test/test] ⭐ Run Main echo ::error::this should not run!
exit 1
[test/test/test] [DEBUG] Writing entry to tarball workflow/outputcmd.txt len:0
[test/test/test] [DEBUG] Writing entry to tarball workflow/statecmd.txt len:0
[test/test/test] [DEBUG] Writing entry to tarball workflow/pathcmd.txt len:0
[test/test/test] [DEBUG] Writing entry to tarball workflow/envs.txt len:0
[test/test/test] [DEBUG] Writing entry to tarball workflow/SUMMARY.md len:0
[test/test/test] [DEBUG] Extracting content to '/var/run/act'
[test/test/test] [DEBUG] Loading revision from git directory
[test/test/test] [DEBUG] Found revision: e97ea9384ae2a40ee8c8eef5b4c9c2323a0df3f3
[test/test/test] [DEBUG] HEAD points to 'e97ea9384ae2a40ee8c8eef5b4c9c2323a0df3f3'
[test/test/test] [DEBUG] using github ref: refs/heads/debug-act-bug6
[test/test/test] [DEBUG] Found revision: e97ea9384ae2a40ee8c8eef5b4c9c2323a0df3f3
[test/test/test] [DEBUG] Loading revision from git directory
[test/test/test] [DEBUG] Found revision: e97ea9384ae2a40ee8c8eef5b4c9c2323a0df3f3
[test/test/test] [DEBUG] HEAD points to 'e97ea9384ae2a40ee8c8eef5b4c9c2323a0df3f3'
[test/test/test] [DEBUG] using github ref: refs/heads/debug-act-bug6
[test/test/test] [DEBUG] Found revision: e97ea9384ae2a40ee8c8eef5b4c9c2323a0df3f3
[test/test/test] [DEBUG] Loading revision from git directory
[test/test/test] [DEBUG] Found revision: e97ea9384ae2a40ee8c8eef5b4c9c2323a0df3f3
[test/test/test] [DEBUG] HEAD points to 'e97ea9384ae2a40ee8c8eef5b4c9c2323a0df3f3'
[test/test/test] [DEBUG] using github ref: refs/heads/debug-act-bug6
[test/test/test] [DEBUG] Found revision: e97ea9384ae2a40ee8c8eef5b4c9c2323a0df3f3
[test/test/test] [DEBUG] Loading revision from git directory
[test/test/test] [DEBUG] Found revision: e97ea9384ae2a40ee8c8eef5b4c9c2323a0df3f3
[test/test/test] [DEBUG] HEAD points to 'e97ea9384ae2a40ee8c8eef5b4c9c2323a0df3f3'
[test/test/test] [DEBUG] using github ref: refs/heads/debug-act-bug6
[test/test/test] [DEBUG] Found revision: e97ea9384ae2a40ee8c8eef5b4c9c2323a0df3f3
[test/test/test] [DEBUG] Wrote command
echo ::error::this should not run!
exit 1
to 'workflow/0'
[test/test/test] [DEBUG] Writing entry to tarball workflow/0 len:44
[test/test/test] [DEBUG] Extracting content to '/var/run/act'
[test/test/test] 🐳 docker exec cmd=[bash --noprofile --norc -e -o pipefail /var/run/act/workflow/0] user= workdir=
[test/test/test] [DEBUG] Exec command '[bash --noprofile --norc -e -o pipefail /var/run/act/workflow/0]'
[test/test/test] [DEBUG] Working directory '/Users/jonj/projects/dynamic-uses'
[test/test/test] ❗ ::error::this should not run!
[test/test/test] ❌ Failure - Main echo ::error::this should not run!
exit 1
[test/test/test] exitcode '1': failure
[test/test/test] 🏁 Job failed
[test/test/test] [DEBUG] Loading revision from git directory
[test/test/test] [DEBUG] Found revision: e97ea9384ae2a40ee8c8eef5b4c9c2323a0df3f3
[test/test/test] [DEBUG] HEAD points to 'e97ea9384ae2a40ee8c8eef5b4c9c2323a0df3f3'
[test/test/test] [DEBUG] using github ref: refs/heads/debug-act-bug6
[test/test/test] [DEBUG] Found revision: e97ea9384ae2a40ee8c8eef5b4c9c2323a0df3f3
[test/test/test] [DEBUG] Loading revision from git directory
[test/test/test] [DEBUG] Found revision: e97ea9384ae2a40ee8c8eef5b4c9c2323a0df3f3
[test/test/test] [DEBUG] HEAD points to 'e97ea9384ae2a40ee8c8eef5b4c9c2323a0df3f3'
[test/test/test] [DEBUG] using github ref: refs/heads/debug-act-bug6
[test/test/test] [DEBUG] Found revision: e97ea9384ae2a40ee8c8eef5b4c9c2323a0df3f3
Error: Job 'test' failed
```
### Additional information
_No response_ | https://github.com/nektos/act/issues/2085 | https://github.com/nektos/act/pull/2087 | 04011b6b78c70d36db18419861c737cd0d72d146 | 55477899e70595ec8d8269387643ccca46fd6b38 | "2023-11-10T01:01:16Z" | go | "2023-11-12T20:01:32Z" |
closed | nektos/act | https://github.com/nektos/act | 2,081 | ["pkg/runner/run_context.go", "pkg/runner/step_test.go"] | Setting `-s GITHUB_TOKEN=...` causes a `GITHUB_TOKEN` env variable to be set in jobs | ### Bug report info
```plain text
act version: 0.2.53
GOOS: darwin
GOARCH: arm64
NumCPU: 12
Docker host: DOCKER_HOST environment variable is not set
Sockets found:
/var/run/docker.sock
$HOME/.docker/run/docker.sock
Config files:
/Users/jonj/.actrc:
-P ubuntu-latest=node:16-buster-slim
-P ubuntu-22.04=node:16-bullseye-slim
-P ubuntu-20.04=node:16-buster-slim
-P ubuntu-18.04=node:16-buster-slim
Build info:
Go version: go1.21.3
Module path: command-line-arguments
Main version:
Main path:
Main checksum:
Build settings:
-buildmode: exe
-compiler: gc
-ldflags: -X main.version=0.2.53
DefaultGODEBUG: panicnil=1
CGO_ENABLED: 1
CGO_CFLAGS:
CGO_CPPFLAGS:
CGO_CXXFLAGS:
CGO_LDFLAGS:
GOARCH: arm64
GOOS: darwin
Docker Engine:
Engine version: 24.0.6
Engine runtime: runc
Cgroup version: 2
Cgroup driver: cgroupfs
Storage driver: overlay2
Registry URI: https://index.docker.io/v1/
OS: Docker Desktop
OS type: linux
OS version:
OS arch: aarch64
OS kernel: 6.4.16-linuxkit
OS CPU: 12
OS memory: 7844 MB
Security options:
name=seccomp,profile=unconfined
name=cgroupns
```
### Command used with act
```sh
act -s GITHUB_TOKEN=thisisasecret -vW .github/workflows/sample.yml
```
### Describe issue
If you set a `GITHUB_TOKEN` secret, a `GITHUB_TOKEN` env variable will automatically be set in jobs, even if you don't explicitly specify it in the `env`. This is inconsistent with actual GitHub Actions workflows; if you want a `GITHUB_TOKEN` env variable, you need to explicitly set it via `env`.
This is problematic since it can result in poorly written jobs "working" locally with act but then breaking when pushed to GitHub. I've run into this multiple times when I've written a job that uses the `gh` CLI but forgotten to actually set the `GITHUB_TOKEN` in `env`; my local test works, but then the real run fails 🫠
### Link to GitHub repository
https://github.com/jenseng/dynamic-uses/actions/runs/6801630930/job/18492924811
### Workflow content
```yml
name: test
on: push
jobs:
test:
runs-on: ubuntu-latest
steps:
- run: echo "GITHUB_TOKEN is NOT set 😅"
if: (!env.GITHUB_TOKEN)
- run: |
echo "::error::GITHUB_TOKEN is set but shouldn't be!"
exit 1
if: env.GITHUB_TOKEN
```
### Relevant log output
```sh
WARN ⚠ You are using Apple M-series chip and you have not specified container architecture, you might encounter issues while running act. If so, try running it with '--container-architecture linux/amd64'. ⚠
DEBU[0000] Loading environment from /Users/jonj/projects/dynamic-uses/.env
DEBU[0000] Loading action inputs from /Users/jonj/projects/dynamic-uses/.input
DEBU[0000] Loading secrets from /Users/jonj/projects/dynamic-uses/.secrets
DEBU[0000] Loading vars from /Users/jonj/projects/dynamic-uses/.vars
DEBU[0000] Evaluated matrix inclusions: map[]
DEBU[0000] Loading workflow '/Users/jonj/projects/dynamic-uses/.github/workflows/sample.yml'
DEBU[0000] Reading workflow '/Users/jonj/projects/dynamic-uses/.github/workflows/sample.yml'
DEBU[0000] Conditional GET for notices etag=b769c9d4-c638-4197-b343-39d63c669434
DEBU[0000] Preparing plan with all jobs
DEBU[0000] Using the only detected workflow event: push
DEBU[0000] Planning jobs for event: push
DEBU[0000] gc: 2023-11-08 10:12:08.04153 -0700 MST m=+0.004306626 module=artifactcache
DEBU[0000] Plan Stages: [0x14000394330]
DEBU[0000] Stages Runs: [test]
DEBU[0000] Job.Name: test
DEBU[0000] Job.RawNeeds: {0 0 <nil> [] 0 0}
DEBU[0000] Job.RawRunsOn: {8 0 !!str ubuntu-latest <nil> [] 5 14}
DEBU[0000] Job.Env: {0 0 <nil> [] 0 0}
DEBU[0000] Job.If: {0 0 success() <nil> [] 0 0}
DEBU[0000] Job.Steps: echo "GITHUB_TOKEN is NOT set 😅"
DEBU[0000] Job.Steps: echo "::error::GITHUB_TOKEN is set but shouldn't be!"
exit 1
DEBU[0000] Job.TimeoutMinutes:
DEBU[0000] Job.Services: map[]
DEBU[0000] Job.Strategy: <nil>
DEBU[0000] Job.RawContainer: {0 0 <nil> [] 0 0}
DEBU[0000] Job.Defaults.Run.Shell:
DEBU[0000] Job.Defaults.Run.WorkingDirectory:
DEBU[0000] Job.Outputs: map[]
DEBU[0000] Job.Uses:
DEBU[0000] Job.With: map[]
DEBU[0000] Job.Result:
DEBU[0000] Empty Strategy, matrixes=[map[]]
DEBU[0000] Job Matrices: [map[]]
DEBU[0000] Runner Matrices: map[]
DEBU[0000] Final matrix after applying user inclusions '[map[]]'
DEBU[0000] Loading revision from git directory
DEBU[0000] Found revision: 26b632fc2f4f001e4e955fa13a7cafcbd01e9897
DEBU[0000] HEAD points to '26b632fc2f4f001e4e955fa13a7cafcbd01e9897'
DEBU[0000] using github ref: refs/heads/debug-act-bug5
DEBU[0000] Found revision: 26b632fc2f4f001e4e955fa13a7cafcbd01e9897
DEBU[0000] Detected CPUs: 12
[test/test] [DEBUG] evaluating expression 'success()'
[test/test] [DEBUG] expression 'success()' evaluated to 'true'
[test/test] 🚀 Start image=node:16-buster-slim
INFO[0000] Parallel tasks (0) below minimum, setting to 1
[test/test] 🐳 docker pull image=node:16-buster-slim platform= username= forcePull=true
[test/test] [DEBUG] 🐳 docker pull node:16-buster-slim
[test/test] [DEBUG] pulling image 'docker.io/library/node:16-buster-slim' ()
DEBU[0000] Saving notices etag=b769c9d4-c638-4197-b343-39d63c669434
DEBU[0000] No new notices
[test/test] [DEBUG] Pulling from library/node :: 16-buster-slim
[test/test] [DEBUG] Digest: sha256:3ebf2875c188d22939c6ab080cfb1a4a6248cc86bae600ea8e2326aa03acdb8f ::
[test/test] [DEBUG] Status: Image is up to date for node:16-buster-slim ::
INFO[0001] Parallel tasks (0) below minimum, setting to 1
[test/test] 🐳 docker create image=node:16-buster-slim platform= entrypoint=["tail" "-f" "/dev/null"] cmd=[] network="host"
[test/test] [DEBUG] Common container.Config ==> &{Hostname: Domainname: User: AttachStdin:false AttachStdout:false AttachStderr:false ExposedPorts:map[] Tty:true OpenStdin:false StdinOnce:false Env:[RUNNER_TOOL_CACHE=/opt/hostedtoolcache RUNNER_OS=Linux RUNNER_ARCH=ARM64 RUNNER_TEMP=/tmp LANG=C.UTF-8] Cmd:[] Healthcheck:<nil> ArgsEscaped:false Image:node:16-buster-slim Volumes:map[] WorkingDir:/Users/jonj/projects/dynamic-uses Entrypoint:[] NetworkDisabled:false MacAddress: OnBuild:[] Labels:map[] StopSignal: StopTimeout:<nil> Shell:[]}
[test/test] [DEBUG] Common container.HostConfig ==> &{Binds:[/var/run/docker.sock:/var/run/docker.sock] ContainerIDFile: LogConfig:{Type: Config:map[]} NetworkMode:host PortBindings:map[] RestartPolicy:{Name: MaximumRetryCount:0} AutoRemove:false VolumeDriver: VolumesFrom:[] ConsoleSize:[0 0] Annotations:map[] CapAdd:[] CapDrop:[] CgroupnsMode: DNS:[] DNSOptions:[] DNSSearch:[] ExtraHosts:[] GroupAdd:[] IpcMode: Cgroup: Links:[] OomScoreAdj:0 PidMode: Privileged:false PublishAllPorts:false ReadonlyRootfs:false SecurityOpt:[] StorageOpt:map[] Tmpfs:map[] UTSMode: UsernsMode: ShmSize:0 Sysctls:map[] Runtime: Isolation: Resources:{CPUShares:0 Memory:0 NanoCPUs:0 CgroupParent: BlkioWeight:0 BlkioWeightDevice:[] BlkioDeviceReadBps:[] BlkioDeviceWriteBps:[] BlkioDeviceReadIOps:[] BlkioDeviceWriteIOps:[] CPUPeriod:0 CPUQuota:0 CPURealtimePeriod:0 CPURealtimeRuntime:0 CpusetCpus: CpusetMems: Devices:[] DeviceCgroupRules:[] DeviceRequests:[] KernelMemory:0 KernelMemoryTCP:0 MemoryReservation:0 MemorySwap:0 MemorySwappiness:<nil> OomKillDisable:<nil> PidsLimit:<nil> Ulimits:[] CPUCount:0 CPUPercent:0 IOMaximumIOps:0 IOMaximumBandwidth:0} Mounts:[{Type:volume Source:act-toolcache Target:/toolcache ReadOnly:false Consistency: BindOptions:<nil> VolumeOptions:<nil> TmpfsOptions:<nil> ClusterOptions:<nil>} {Type:volume Source:act-test-test-24f46b2e65c2fc9b49cf0e305f210649cb0a45d5b5dc0a1380eb443748b7420b-env Target:/var/run/act ReadOnly:false Consistency: BindOptions:<nil> VolumeOptions:<nil> TmpfsOptions:<nil> ClusterOptions:<nil>} {Type:volume Source:act-test-test-24f46b2e65c2fc9b49cf0e305f210649cb0a45d5b5dc0a1380eb443748b7420b Target:/Users/jonj/projects/dynamic-uses ReadOnly:false Consistency: BindOptions:<nil> VolumeOptions:<nil> TmpfsOptions:<nil> ClusterOptions:<nil>}] MaskedPaths:[] ReadonlyPaths:[] Init:<nil>}
[test/test] [DEBUG] input.NetworkAliases ==> [test]
[test/test] [DEBUG] not a use defined config??
[test/test] [DEBUG] Created container name=act-test-test-24f46b2e65c2fc9b49cf0e305f210649cb0a45d5b5dc0a1380eb443748b7420b id=1e288b3bcd8b78297aa2727fda554700c278136b7111739e398969ebf98f9bf9 from image node:16-buster-slim (platform: )
[test/test] [DEBUG] ENV ==> [RUNNER_TOOL_CACHE=/opt/hostedtoolcache RUNNER_OS=Linux RUNNER_ARCH=ARM64 RUNNER_TEMP=/tmp LANG=C.UTF-8]
[test/test] 🐳 docker run image=node:16-buster-slim platform= entrypoint=["tail" "-f" "/dev/null"] cmd=[] network="host"
[test/test] [DEBUG] Starting container: 1e288b3bcd8b78297aa2727fda554700c278136b7111739e398969ebf98f9bf9
[test/test] [DEBUG] Started container: 1e288b3bcd8b78297aa2727fda554700c278136b7111739e398969ebf98f9bf9
[test/test] [DEBUG] Writing entry to tarball workflow/event.json len:2
[test/test] [DEBUG] Writing entry to tarball workflow/envs.txt len:0
[test/test] [DEBUG] Extracting content to '/var/run/act/'
[test/test] [DEBUG] Loading revision from git directory
[test/test] [DEBUG] Found revision: 26b632fc2f4f001e4e955fa13a7cafcbd01e9897
[test/test] [DEBUG] HEAD points to '26b632fc2f4f001e4e955fa13a7cafcbd01e9897'
[test/test] [DEBUG] using github ref: refs/heads/debug-act-bug5
[test/test] [DEBUG] Found revision: 26b632fc2f4f001e4e955fa13a7cafcbd01e9897
[test/test] [DEBUG] Loading revision from git directory
[test/test] [DEBUG] Found revision: 26b632fc2f4f001e4e955fa13a7cafcbd01e9897
[test/test] [DEBUG] HEAD points to '26b632fc2f4f001e4e955fa13a7cafcbd01e9897'
[test/test] [DEBUG] using github ref: refs/heads/debug-act-bug5
[test/test] [DEBUG] Found revision: 26b632fc2f4f001e4e955fa13a7cafcbd01e9897
[test/test] [DEBUG] Loading revision from git directory
[test/test] [DEBUG] Found revision: 26b632fc2f4f001e4e955fa13a7cafcbd01e9897
[test/test] [DEBUG] HEAD points to '26b632fc2f4f001e4e955fa13a7cafcbd01e9897'
[test/test] [DEBUG] using github ref: refs/heads/debug-act-bug5
[test/test] [DEBUG] Found revision: 26b632fc2f4f001e4e955fa13a7cafcbd01e9897
[test/test] [DEBUG] Loading revision from git directory
[test/test] [DEBUG] Found revision: 26b632fc2f4f001e4e955fa13a7cafcbd01e9897
[test/test] [DEBUG] HEAD points to '26b632fc2f4f001e4e955fa13a7cafcbd01e9897'
[test/test] [DEBUG] using github ref: refs/heads/debug-act-bug5
[test/test] [DEBUG] Found revision: 26b632fc2f4f001e4e955fa13a7cafcbd01e9897
[test/test] [DEBUG] setupEnv => map[ACT:true ACTIONS_CACHE_URL:http://172.24.80.224:49775/ CI:true GITHUB_ACTION:0 GITHUB_ACTIONS:true GITHUB_ACTION_PATH: GITHUB_ACTION_REF: GITHUB_ACTION_REPOSITORY: GITHUB_ACTOR:nektos/act GITHUB_API_URL:https://api.github.com GITHUB_BASE_REF: GITHUB_EVENT_NAME:push GITHUB_EVENT_PATH:/var/run/act/workflow/event.json GITHUB_GRAPHQL_URL:https://api.github.com/graphql GITHUB_HEAD_REF: GITHUB_JOB:test GITHUB_REF:refs/heads/debug-act-bug5 GITHUB_REF_NAME:debug-act-bug5 GITHUB_REF_TYPE:branch GITHUB_REPOSITORY:jenseng/dynamic-uses GITHUB_REPOSITORY_OWNER:jenseng GITHUB_RETENTION_DAYS:0 GITHUB_RUN_ID:1 GITHUB_RUN_NUMBER:1 GITHUB_SERVER_URL:https://github.com GITHUB_SHA:26b632fc2f4f001e4e955fa13a7cafcbd01e9897 GITHUB_TOKEN:*** GITHUB_WORKFLOW:test GITHUB_WORKSPACE:/Users/jonj/projects/dynamic-uses ImageOS:ubuntu20 RUNNER_PERFLOG:/dev/null RUNNER_TRACKING_ID:]
[test/test] [DEBUG] Loading revision from git directory
[test/test] [DEBUG] Found revision: 26b632fc2f4f001e4e955fa13a7cafcbd01e9897
[test/test] [DEBUG] HEAD points to '26b632fc2f4f001e4e955fa13a7cafcbd01e9897'
[test/test] [DEBUG] using github ref: refs/heads/debug-act-bug5
[test/test] [DEBUG] Found revision: 26b632fc2f4f001e4e955fa13a7cafcbd01e9897
[test/test] [DEBUG] Loading revision from git directory
[test/test] [DEBUG] Found revision: 26b632fc2f4f001e4e955fa13a7cafcbd01e9897
[test/test] [DEBUG] HEAD points to '26b632fc2f4f001e4e955fa13a7cafcbd01e9897'
[test/test] [DEBUG] using github ref: refs/heads/debug-act-bug5
[test/test] [DEBUG] Found revision: 26b632fc2f4f001e4e955fa13a7cafcbd01e9897
[test/test] [DEBUG] evaluating expression '(!env.GITHUB_TOKEN)'
[test/test] [DEBUG] expression '(!env.GITHUB_TOKEN)' evaluated to 'false'
[test/test] [DEBUG] Skipping step 'echo "GITHUB_TOKEN is NOT set 😅"' due to '(!env.GITHUB_TOKEN)'
[test/test] [DEBUG] Loading revision from git directory
[test/test] [DEBUG] Found revision: 26b632fc2f4f001e4e955fa13a7cafcbd01e9897
[test/test] [DEBUG] HEAD points to '26b632fc2f4f001e4e955fa13a7cafcbd01e9897'
[test/test] [DEBUG] using github ref: refs/heads/debug-act-bug5
[test/test] [DEBUG] Found revision: 26b632fc2f4f001e4e955fa13a7cafcbd01e9897
[test/test] [DEBUG] Loading revision from git directory
[test/test] [DEBUG] Found revision: 26b632fc2f4f001e4e955fa13a7cafcbd01e9897
[test/test] [DEBUG] HEAD points to '26b632fc2f4f001e4e955fa13a7cafcbd01e9897'
[test/test] [DEBUG] using github ref: refs/heads/debug-act-bug5
[test/test] [DEBUG] Found revision: 26b632fc2f4f001e4e955fa13a7cafcbd01e9897
[test/test] [DEBUG] Loading revision from git directory
[test/test] [DEBUG] Found revision: 26b632fc2f4f001e4e955fa13a7cafcbd01e9897
[test/test] [DEBUG] HEAD points to '26b632fc2f4f001e4e955fa13a7cafcbd01e9897'
[test/test] [DEBUG] using github ref: refs/heads/debug-act-bug5
[test/test] [DEBUG] Found revision: 26b632fc2f4f001e4e955fa13a7cafcbd01e9897
[test/test] [DEBUG] setupEnv => map[ACT:true ACTIONS_CACHE_URL:http://172.24.80.224:49775/ CI:true GITHUB_ACTION:1 GITHUB_ACTIONS:true GITHUB_ACTION_PATH: GITHUB_ACTION_REF: GITHUB_ACTION_REPOSITORY: GITHUB_ACTOR:nektos/act GITHUB_API_URL:https://api.github.com GITHUB_BASE_REF: GITHUB_EVENT_NAME:push GITHUB_EVENT_PATH:/var/run/act/workflow/event.json GITHUB_GRAPHQL_URL:https://api.github.com/graphql GITHUB_HEAD_REF: GITHUB_JOB:test GITHUB_REF:refs/heads/debug-act-bug5 GITHUB_REF_NAME:debug-act-bug5 GITHUB_REF_TYPE:branch GITHUB_REPOSITORY:jenseng/dynamic-uses GITHUB_REPOSITORY_OWNER:jenseng GITHUB_RETENTION_DAYS:0 GITHUB_RUN_ID:1 GITHUB_RUN_NUMBER:1 GITHUB_SERVER_URL:https://github.com GITHUB_SHA:26b632fc2f4f001e4e955fa13a7cafcbd01e9897 GITHUB_TOKEN:*** GITHUB_WORKFLOW:test GITHUB_WORKSPACE:/Users/jonj/projects/dynamic-uses ImageOS:ubuntu20 RUNNER_PERFLOG:/dev/null RUNNER_TRACKING_ID:]
[test/test] [DEBUG] Loading revision from git directory
[test/test] [DEBUG] Found revision: 26b632fc2f4f001e4e955fa13a7cafcbd01e9897
[test/test] [DEBUG] HEAD points to '26b632fc2f4f001e4e955fa13a7cafcbd01e9897'
[test/test] [DEBUG] using github ref: refs/heads/debug-act-bug5
[test/test] [DEBUG] Found revision: 26b632fc2f4f001e4e955fa13a7cafcbd01e9897
[test/test] [DEBUG] Loading revision from git directory
[test/test] [DEBUG] Found revision: 26b632fc2f4f001e4e955fa13a7cafcbd01e9897
[test/test] [DEBUG] HEAD points to '26b632fc2f4f001e4e955fa13a7cafcbd01e9897'
[test/test] [DEBUG] using github ref: refs/heads/debug-act-bug5
[test/test] [DEBUG] Found revision: 26b632fc2f4f001e4e955fa13a7cafcbd01e9897
[test/test] [DEBUG] evaluating expression 'env.GITHUB_TOKEN'
[test/test] [DEBUG] expression 'env.GITHUB_TOKEN' evaluated to '%!t(string=***)'
[test/test] ⭐ Run Main echo "::error::GITHUB_TOKEN is set but shouldn't be!"
exit 1
[test/test] [DEBUG] Writing entry to tarball workflow/outputcmd.txt len:0
[test/test] [DEBUG] Writing entry to tarball workflow/statecmd.txt len:0
[test/test] [DEBUG] Writing entry to tarball workflow/pathcmd.txt len:0
[test/test] [DEBUG] Writing entry to tarball workflow/envs.txt len:0
[test/test] [DEBUG] Writing entry to tarball workflow/SUMMARY.md len:0
[test/test] [DEBUG] Extracting content to '/var/run/act'
[test/test] [DEBUG] Loading revision from git directory
[test/test] [DEBUG] Found revision: 26b632fc2f4f001e4e955fa13a7cafcbd01e9897
[test/test] [DEBUG] HEAD points to '26b632fc2f4f001e4e955fa13a7cafcbd01e9897'
[test/test] [DEBUG] using github ref: refs/heads/debug-act-bug5
[test/test] [DEBUG] Found revision: 26b632fc2f4f001e4e955fa13a7cafcbd01e9897
[test/test] [DEBUG] Loading revision from git directory
[test/test] [DEBUG] Found revision: 26b632fc2f4f001e4e955fa13a7cafcbd01e9897
[test/test] [DEBUG] HEAD points to '26b632fc2f4f001e4e955fa13a7cafcbd01e9897'
[test/test] [DEBUG] using github ref: refs/heads/debug-act-bug5
[test/test] [DEBUG] Found revision: 26b632fc2f4f001e4e955fa13a7cafcbd01e9897
[test/test] [DEBUG] Loading revision from git directory
[test/test] [DEBUG] Found revision: 26b632fc2f4f001e4e955fa13a7cafcbd01e9897
[test/test] [DEBUG] HEAD points to '26b632fc2f4f001e4e955fa13a7cafcbd01e9897'
[test/test] [DEBUG] using github ref: refs/heads/debug-act-bug5
[test/test] [DEBUG] Found revision: 26b632fc2f4f001e4e955fa13a7cafcbd01e9897
[test/test] [DEBUG] Loading revision from git directory
[test/test] [DEBUG] Found revision: 26b632fc2f4f001e4e955fa13a7cafcbd01e9897
[test/test] [DEBUG] HEAD points to '26b632fc2f4f001e4e955fa13a7cafcbd01e9897'
[test/test] [DEBUG] using github ref: refs/heads/debug-act-bug5
[test/test] [DEBUG] Found revision: 26b632fc2f4f001e4e955fa13a7cafcbd01e9897
[test/test] [DEBUG] Wrote command
echo "::error::GITHUB_TOKEN is set but shouldn't be!"
exit 1
to 'workflow/1'
[test/test] [DEBUG] Writing entry to tarball workflow/1 len:63
[test/test] [DEBUG] Extracting content to '/var/run/act'
[test/test] 🐳 docker exec cmd=[bash --noprofile --norc -e -o pipefail /var/run/act/workflow/1] user= workdir=
[test/test] [DEBUG] Exec command '[bash --noprofile --norc -e -o pipefail /var/run/act/workflow/1]'
[test/test] [DEBUG] Working directory '/Users/jonj/projects/dynamic-uses'
[test/test] ❗ ::error::GITHUB_TOKEN is set but shouldn't be!
[test/test] ❌ Failure - Main echo "::error::GITHUB_TOKEN is set but shouldn't be!"
exit 1
[test/test] exitcode '1': failure
[test/test] 🏁 Job failed
[test/test] [DEBUG] Loading revision from git directory
[test/test] [DEBUG] Found revision: 26b632fc2f4f001e4e955fa13a7cafcbd01e9897
[test/test] [DEBUG] HEAD points to '26b632fc2f4f001e4e955fa13a7cafcbd01e9897'
[test/test] [DEBUG] using github ref: refs/heads/debug-act-bug5
[test/test] [DEBUG] Found revision: 26b632fc2f4f001e4e955fa13a7cafcbd01e9897
Error: Job 'test' failed
```
### Additional information
_No response_ | https://github.com/nektos/act/issues/2081 | https://github.com/nektos/act/pull/2089 | 610358e1c37630598e5d5022089bc43274ccc997 | 18b4714e38d4871947eff0acb7f1c8f4625fda9f | "2023-11-08T17:19:37Z" | go | "2023-11-12T17:52:08Z" |
closed | nektos/act | https://github.com/nektos/act | 2,080 | ["cmd/platforms.go", "pkg/runner/run_context.go", "pkg/runner/run_context_test.go"] | `runs-on` does not accept array expressions | ### Bug report info
```plain text
act version: 0.2.53
GOOS: darwin
GOARCH: arm64
NumCPU: 12
Docker host: DOCKER_HOST environment variable is not set
Sockets found:
/var/run/docker.sock
$HOME/.docker/run/docker.sock
Config files:
/Users/jonj/.actrc:
-P ubuntu-latest=node:16-buster-slim
-P ubuntu-22.04=node:16-bullseye-slim
-P ubuntu-20.04=node:16-buster-slim
-P ubuntu-18.04=node:16-buster-slim
Build info:
Go version: go1.21.3
Module path: command-line-arguments
Main version:
Main path:
Main checksum:
Build settings:
-buildmode: exe
-compiler: gc
-ldflags: -X main.version=0.2.53
DefaultGODEBUG: panicnil=1
CGO_ENABLED: 1
CGO_CFLAGS:
CGO_CPPFLAGS:
CGO_CXXFLAGS:
CGO_LDFLAGS:
GOARCH: arm64
GOOS: darwin
Docker Engine:
Engine version: 24.0.6
Engine runtime: runc
Cgroup version: 2
Cgroup driver: cgroupfs
Storage driver: overlay2
Registry URI: https://index.docker.io/v1/
OS: Docker Desktop
OS type: linux
OS version:
OS arch: aarch64
OS kernel: 6.4.16-linuxkit
OS CPU: 12
OS memory: 7844 MB
Security options:
name=seccomp,profile=unconfined
name=cgroupns
```
### Command used with act
```sh
act -vW .github/workflows/sample.yml
```
### Describe issue
If `runs-on` receives an array expression, act incorrectly evaluates it to `%!t(string=Array)`. act correctly handles string expressions, as well as static string and array yaml values.
I.e. these work:
* `runs-on: ubuntu-latest`
* `runs-on: ${{ fromJSON('"ubuntu-latest"') }}`
* `runs-on: [ubuntu-latest]`
But this does not:
* `runs-on: ${{ fromJSON('["ubuntu-latest"]') }}`
The bug isn't specific to `fromJSON`, as the same issue occurs if the expression is an array value from a matrix, e.g.
```yaml
runs-on: ${{ matrix.runner }}
strategy:
matrix:
runner: [[ubuntu-latest], [self-hosted, my-cool-label]]
```
These scenarios all work as expected in actual GitHub Actions workflow runs.
### Link to GitHub repository
https://github.com/jenseng/dynamic-uses/actions/runs/6801153354/job/18491354468
### Workflow content
```yml
name: test
on: push
jobs:
test:
# runs-on: ubuntu-latest
# runs-on: ${{ fromJSON('"ubuntu-latest"') }}
# runs-on: [ubuntu-latest]
runs-on: ${{ fromJSON('["ubuntu-latest"]') }}
steps:
- run: echo "Hello, world!"
```
### Relevant log output
```sh
WARN ⚠ You are using Apple M-series chip and you have not specified container architecture, you might encounter issues while running act. If so, try running it with '--container-architecture linux/amd64'. ⚠
DEBU[0000] Loading environment from /Users/jonj/projects/dynamic-uses/.env
DEBU[0000] Loading action inputs from /Users/jonj/projects/dynamic-uses/.input
DEBU[0000] Loading secrets from /Users/jonj/projects/dynamic-uses/.secrets
DEBU[0000] Loading vars from /Users/jonj/projects/dynamic-uses/.vars
DEBU[0000] Evaluated matrix inclusions: map[]
DEBU[0000] Loading workflow '/Users/jonj/projects/dynamic-uses/.github/workflows/sample.yml'
DEBU[0000] Reading workflow '/Users/jonj/projects/dynamic-uses/.github/workflows/sample.yml'
DEBU[0000] Preparing plan with all jobs
DEBU[0000] Using the only detected workflow event: push
DEBU[0000] Planning jobs for event: push
DEBU[0000] Conditional GET for notices etag=c694094f-9a86-4866-bf11-876c821d9fcb
DEBU[0000] gc: 2023-11-08 09:31:06.262245 -0700 MST m=+0.030477292 module=artifactcache
DEBU[0000] Plan Stages: [0x1400011ee10]
DEBU[0000] Stages Runs: [test]
DEBU[0000] Job.Name: test
DEBU[0000] Job.RawNeeds: {0 0 <nil> [] 0 0}
DEBU[0000] Job.RawRunsOn: {8 0 !!str ${{ fromJSON('["ubuntu-latest"]') }} <nil> [] 8 14}
DEBU[0000] Job.Env: {0 0 <nil> [] 0 0}
DEBU[0000] Job.If: {0 0 success() <nil> [] 0 0}
DEBU[0000] Job.Steps: echo "Hello, world!"
DEBU[0000] Job.TimeoutMinutes:
DEBU[0000] Job.Services: map[]
DEBU[0000] Job.Strategy: <nil>
DEBU[0000] Job.RawContainer: {0 0 <nil> [] 0 0}
DEBU[0000] Job.Defaults.Run.Shell:
DEBU[0000] Job.Defaults.Run.WorkingDirectory:
DEBU[0000] Job.Outputs: map[]
DEBU[0000] Job.Uses:
DEBU[0000] Job.With: map[]
DEBU[0000] Job.Result:
DEBU[0000] Empty Strategy, matrixes=[map[]]
DEBU[0000] Job Matrices: [map[]]
DEBU[0000] Runner Matrices: map[]
DEBU[0000] Final matrix after applying user inclusions '[map[]]'
DEBU[0000] Loading revision from git directory
DEBU[0000] Found revision: 4af4b6a3356b02639095850fe2dce350906070ba
DEBU[0000] HEAD points to '4af4b6a3356b02639095850fe2dce350906070ba'
DEBU[0000] using github ref: refs/heads/debug-act-bug3
DEBU[0000] Found revision: 4af4b6a3356b02639095850fe2dce350906070ba
DEBU[0000] Detected CPUs: 12
[test/test] [DEBUG] evaluating expression 'success()'
[test/test] [DEBUG] expression 'success()' evaluated to 'true'
[test/test] [DEBUG] expression '${{ fromJSON('["ubuntu-latest"]') }}' rewritten to 'format('{0}', fromJSON('["ubuntu-latest"]'))'
[test/test] [DEBUG] evaluating expression 'format('{0}', fromJSON('["ubuntu-latest"]'))'
[test/test] [DEBUG] expression 'format('{0}', fromJSON('["ubuntu-latest"]'))' evaluated to '%!t(string=Array)'
[test/test] [DEBUG] expression '${{ fromJSON('["ubuntu-latest"]') }}' rewritten to 'format('{0}', fromJSON('["ubuntu-latest"]'))'
[test/test] [DEBUG] evaluating expression 'format('{0}', fromJSON('["ubuntu-latest"]'))'
[test/test] [DEBUG] expression 'format('{0}', fromJSON('["ubuntu-latest"]'))' evaluated to '%!t(string=Array)'
[test/test] 🚧 Skipping unsupported platform -- Try running with `-P Array=...`
DEBU[0000] Saving notices etag=c694094f-9a86-4866-bf11-876c821d9fcb
DEBU[0000] No new notices
```
### Additional information
_No response_ | https://github.com/nektos/act/issues/2080 | https://github.com/nektos/act/pull/2088 | 1c16fd1967d68c76aeab6b88d7ac9a6bde1f4123 | 610358e1c37630598e5d5022089bc43274ccc997 | "2023-11-08T16:42:45Z" | go | "2023-11-12T17:40:06Z" |
closed | nektos/act | https://github.com/nektos/act | 2,017 | ["pkg/exprparser/functions_test.go", "pkg/exprparser/interpreter.go"] | Float formatting doesn't match actions/runner | ### Bug report info
```plain text
act version: 0.2.50
GOOS: darwin
GOARCH: arm64
NumCPU: 12
Docker host: DOCKER_HOST environment variable is not set
Sockets found:
/var/run/docker.sock
$HOME/.docker/run/docker.sock
Config files:
/Users/jonj/.actrc:
-P ubuntu-latest=node:16-buster-slim
-P ubuntu-22.04=node:16-bullseye-slim
-P ubuntu-20.04=node:16-buster-slim
-P ubuntu-18.04=node:16-buster-slim
Build info:
Go version: go1.21.0
Module path: command-line-arguments
Main version:
Main path:
Main checksum:
Build settings:
-buildmode: exe
-compiler: gc
-ldflags: -X main.version=0.2.50
DefaultGODEBUG: panicnil=1
CGO_ENABLED: 1
CGO_CFLAGS:
CGO_CPPFLAGS:
CGO_CXXFLAGS:
CGO_LDFLAGS:
GOARCH: arm64
GOOS: darwin
Docker Engine:
Engine version: 24.0.5
Engine runtime: runc
Cgroup version: 2
Cgroup driver: cgroupfs
Storage driver: overlay2
Registry URI: https://index.docker.io/v1/
OS: Docker Desktop
OS type: linux
OS version:
OS arch: aarch64
OS kernel: 5.15.49-linuxkit-pr
OS CPU: 6
OS memory: 7851 MB
Security options:
name=seccomp,profile=unconfined
name=cgroupns
```
### Command used with act
```sh
act -W .github/workflows/push.yml
```
### Describe issue
When deserializing a JSON string, all numbers are floats. Because act formats floats with fewer significant digits than actions/runner, this can be problematic (e.g. it's an id and you're about to use it in an API call).
### Link to GitHub repository
_No response_
### Workflow content
```yml
on: push
jobs:
act-bug:
runs-on: ubuntu-latest
steps:
- run: echo '${{ 123456 }}'
- run: echo '${{ 1234567 }}'
- run: echo '${{ fromJSON('123456') }}'
- run: echo '${{ fromJSON('1234567') }}'
```
### Relevant log output
```sh
[push.yml/act-bug] ⭐ Run Main echo '123456'
[push.yml/act-bug] 🐳 docker exec cmd=[bash --noprofile --norc -e -o pipefail /var/run/act/workflow/0] user= workdir=
| 123456
[push.yml/act-bug] ✅ Success - Main echo '123456'
[push.yml/act-bug] ⭐ Run Main echo '1234567'
[push.yml/act-bug] 🐳 docker exec cmd=[bash --noprofile --norc -e -o pipefail /var/run/act/workflow/1] user= workdir=
| 1234567
[push.yml/act-bug] ✅ Success - Main echo '1234567'
[push.yml/act-bug] ⭐ Run Main echo '123456'
[push.yml/act-bug] 🐳 docker exec cmd=[bash --noprofile --norc -e -o pipefail /var/run/act/workflow/2] user= workdir=
| 123456
[push.yml/act-bug] ✅ Success - Main echo '123456'
[push.yml/act-bug] ⭐ Run Main echo '1.234567e+06'
[push.yml/act-bug] 🐳 docker exec cmd=[bash --noprofile --norc -e -o pipefail /var/run/act/workflow/3] user= workdir=
| 1.234567e+06
[push.yml/act-bug] ✅ Success - Main echo '1.234567e+06'
[push.yml/act-bug] 🏁 Job succeeded
```
### Additional information
Note the `1.234567e+06` on the last step. By contrast, when running the workflow on GitHub, it formats those with enough significant digits and no trailing zero:
```
2023-09-21T20:58:56.3876205Z Complete job name: act-bug
2023-09-21T20:58:56.4870929Z ##[group]Run echo '123456'
2023-09-21T20:58:56.4871406Z [36;1mecho '123456'[0m
2023-09-21T20:58:56.5538650Z shell: /usr/bin/bash -e {0}
2023-09-21T20:58:56.5539040Z ##[endgroup]
2023-09-21T20:58:56.6109623Z 123456
2023-09-21T20:58:56.6306780Z ##[group]Run echo '1234567'
2023-09-21T20:58:56.6307114Z [36;1mecho '1234567'[0m
2023-09-21T20:58:56.6367106Z shell: /usr/bin/bash -e {0}
2023-09-21T20:58:56.6367419Z ##[endgroup]
2023-09-21T20:58:56.6452122Z 1234567
2023-09-21T20:58:56.6480835Z ##[group]Run echo '123456'
2023-09-21T20:58:56.6481500Z [36;1mecho '123456'[0m
2023-09-21T20:58:56.6538459Z shell: /usr/bin/bash -e {0}
2023-09-21T20:58:56.6538933Z ##[endgroup]
2023-09-21T20:58:56.6820069Z 123456
2023-09-21T20:58:56.6854603Z ##[group]Run echo '1234567'
2023-09-21T20:58:56.6855053Z [36;1mecho '1234567'[0m
2023-09-21T20:58:56.6914094Z shell: /usr/bin/bash -e {0}
2023-09-21T20:58:56.6914796Z ##[endgroup]
2023-09-21T20:58:56.6998866Z 1234567
``` | https://github.com/nektos/act/issues/2017 | https://github.com/nektos/act/pull/2018 | 99067a9c1ed3b9cdb75797a7e87e6ef0471105f8 | ace4cd47c7f099864866b1f60e064fecde7f36ea | "2023-09-21T21:08:52Z" | go | "2023-10-13T20:01:04Z" |
closed | nektos/act | https://github.com/nektos/act | 2,016 | ["cmd/root.go", "pkg/container/docker_socket.go", "pkg/container/docker_socket_test.go"] | --container-daemon-socket and DOCKER_HOST both required with Podman | ### Bug report info
```plain text
❯ gh act --bug-report
act version: 0.2.50
GOOS: linux
GOARCH: amd64
NumCPU: 8
Docker host: unix:///run/user/1000/podman/podman.sock
Sockets found:
/var/run/docker.sock(broken)
$XDG_RUNTIME_DIR/docker.sock
$XDG_RUNTIME_DIR/podman/podman.sock
Config files:
/home/tom/.actrc:
-P ubuntu-latest=node:12.20.1-buster-slim
-P ubuntu-20.04=node:12.20.1-buster-slim
-P ubuntu-18.04=node:12.20.1-buster-slim
-P ubuntu-16.04=node:12.20.1-stretch-slim
Build info:
Go version: go1.20.7
Module path: github.com/nektos/act
Main version: (devel)
Main path: github.com/nektos/act
Main checksum:
Build settings:
-buildmode: exe
-compiler: gc
-trimpath: true
CGO_ENABLED: 0
GOARCH: amd64
GOOS: linux
GOAMD64: v1
vcs: git
vcs.revision: e8856f0fb00fcdd16eef2325b845f55f5d346f51
vcs.time: 2023-08-21T16:17:06Z
vcs.modified: true
Docker Engine:
Engine version: 4.6.2
Engine runtime: crun
Cgroup version: 2
Cgroup driver: systemd
Storage driver: overlay
Registry URI:
OS: fedora
OS type: linux
OS version: 38
OS arch: amd64
OS kernel: 6.4.15-200.fc38.x86_64
OS CPU: 8
OS memory: 15687 MB
Security options:
name=seccomp,profile=default
name=rootless
name=selinux
```
### Command used with act
```sh
act --container-daemon-socket $XDG_RUNTIME_DIR/podman/podman.sock pull_request -e pull_request.json
# or
export DOCKER_HOST=unix://$XDG_RUNTIME_DIR/podman/podman.sock
act pull_request -e pull_request.json
```
### Describe issue
When using Podman with the `podman.socket` service running, it is necessary to specify *both* `--container-daemon-socket` *and* `DOCKER_HOST`. It seems like it should be sufficient to only set `DOCKER_HOST` and for that socket to be used, without having to also pass `--container-daemon-socket`.
Output with DOCKER_HOST unset:
```
❯ gh act --container-daemon-socket $XDG_RUNTIME_DIR/podman/podman.sock pull_request -e pull_request.json
[Asana/set-state-waiting] 🚀 Start image=node:12.20.1-buster-slim
[Asana/set-state-waiting] 🐳 docker pull image=node:12.20.1-buster-slim platform= username= forcePull=true
Error: permission denied while trying to connect to the Docker daemon socket at unix:///var/run/docker.sock: Post "http://%2Fvar%2Frun%2Fdocker.sock/v1.24/images/create?fromImage=node&tag=12.20.1-buster-slim": dial unix /var/run/docker.sock: connect: permission denied
```
**N.B.** There is no additional log output when using `-v` in this case.
---
Output with DOCKER_HOST set, no command line argument:
```
❯ export DOCKER_HOST=unix://$XDG_RUNTIME_DIR/podman/podman.sock
❯ gh act pull_request -e pull_request.json
[Asana/set-state-waiting] 🚀 Start image=node:12.20.1-buster-slim
[Asana/set-state-waiting] 🐳 docker pull image=node:12.20.1-buster-slim platform= username= forcePull=true
[Asana/set-state-waiting] 🐳 docker create image=node:12.20.1-buster-slim platform= entrypoint=["tail" "-f" "/dev/null"] cmd=[]
Error: failed to create container: 'Error response from daemon: container create: statfs /var/run/docker.sock: permission denied'
```
With both the environment variable and the command line argument, the command runs successfully.
Verbose output for **this case** is shown below.
### Link to GitHub repository
_No response_
### Workflow content
```yml
name: Asana
on:
pull_request:
types: ["opened", "edited", "reopened", "synchronize", "ready_for_review"]
jobs:
set-state-waiting:
if: ${{ !github.event.pull_request.draft }}
runs-on: ubuntu-latest
steps:
- name: Checkout
uses: actions/checkout@v2
```
### Relevant log output
```sh
[Asana/set-state-waiting] [DEBUG] pulling image 'docker.io/library/node:12.20.1-buster-slim' ()
DEBU[0000] Saving notices etag=16104d16-7646-4b54-86fe-f05680fde0a5
DEBU[0000] No new notices
[Asana/set-state-waiting] [DEBUG] Already exists :: cd4902827248
[Asana/set-state-waiting] [DEBUG] Already exists :: 450331f0fd6d
[Asana/set-state-waiting] [DEBUG] Already exists :: 56f831d51b9a
[Asana/set-state-waiting] [DEBUG] Already exists :: d7361e2eb1cb
[Asana/set-state-waiting] [DEBUG] Already exists :: 45b42c59be33
[Asana/set-state-waiting] [DEBUG] Pulling fs layer :: 4ead7950876e
[Asana/set-state-waiting] [DEBUG] Download complete :: 4ead7950876e
[Asana/set-state-waiting] [DEBUG] Download complete :: 4ead7950876e
[Asana/set-state-waiting] 🐳 docker create image=node:12.20.1-buster-slim platform= entrypoint=["tail" "-f" "/dev/null"] cmd=[]
[Asana/set-state-waiting] [DEBUG] Common container.Config ==> &{Hostname: Domainname: User: AttachStdin:false AttachStdout:false AttachStderr:false ExposedPorts:map[] Tty:true OpenStdin:false StdinOnce:false Env:[RUNNER_TOOL_CACHE=/opt/hostedtoolcache RUNNER_OS=Linux RUNNER_ARCH=amd64 RUNNER_TEMP=/tmp LANG=C.UTF-8] Cmd:[] Healthcheck:<nil> ArgsEscaped:false Image:node:12.20.1-buster-slim Volumes:map[] WorkingDir:/home/tom/dev/nbycomp/asana-github-actions Entrypoint:[] NetworkDisabled:false MacAddress: OnBuild:[] Labels:map[] StopSignal: StopTimeout:<nil> Shell:[]}
[Asana/set-state-waiting] [DEBUG] Common container.HostConfig ==> &{Binds:[/var/run/docker.sock:/var/run/docker.sock] ContainerIDFile: LogConfig:{Type: Config:map[]} NetworkMode:host PortBindings:map[] RestartPolicy:{Name: MaximumRetryCount:0} AutoRemove:false VolumeDriver: VolumesFrom:[] ConsoleSize:[0 0] Annotations:map[] CapAdd:[] CapDrop:[] CgroupnsMode: DNS:[] DNSOptions:[] DNSSearch:[] ExtraHosts:[] GroupAdd:[] IpcMode: Cgroup: Links:[] OomScoreAdj:0 PidMode: Privileged:false PublishAllPorts:false ReadonlyRootfs:false SecurityOpt:[] StorageOpt:map[] Tmpfs:map[] UTSMode: UsernsMode: ShmSize:0 Sysctls:map[] Runtime: Isolation: Resources:{CPUShares:0 Memory:0 NanoCPUs:0 CgroupParent: BlkioWeight:0 BlkioWeightDevice:[] BlkioDeviceReadBps:[] BlkioDeviceWriteBps:[] BlkioDeviceReadIOps:[] BlkioDeviceWriteIOps:[] CPUPeriod:0 CPUQuota:0 CPURealtimePeriod:0 CPURealtimeRuntime:0 CpusetCpus: CpusetMems: Devices:[] DeviceCgroupRules:[] DeviceRequests:[] KernelMemory:0 KernelMemoryTCP:0 MemoryReservation:0 MemorySwap:0 MemorySwappiness:<nil> OomKillDisable:<nil> PidsLimit:<nil> Ulimits:[] CPUCount:0 CPUPercent:0 IOMaximumIOps:0 IOMaximumBandwidth:0} Mounts:[{Type:volume Source:act-toolcache Target:/toolcache ReadOnly:false Consistency: BindOptions:<nil> VolumeOptions:<nil> TmpfsOptions:<nil> ClusterOptions:<nil>} {Type:volume Source:act-Asana-set-state-waiting-9673d7f8d5ebf1d8a45653134007d1a04bfeeb01bae6f2e7b538729310d1ff6a-env Target:/var/run/act ReadOnly:false Consistency: BindOptions:<nil> VolumeOptions:<nil> TmpfsOptions:<nil> ClusterOptions:<nil>} {Type:volume Source:act-Asana-set-state-waiting-9673d7f8d5ebf1d8a45653134007d1a04bfeeb01bae6f2e7b538729310d1ff6a Target:/home/tom/dev/nbycomp/asana-github-actions ReadOnly:false Consistency: BindOptions:<nil> VolumeOptions:<nil> TmpfsOptions:<nil> ClusterOptions:<nil>}] MaskedPaths:[] ReadonlyPaths:[] Init:<nil>}
Error: failed to create container: 'Error response from daemon: container create: statfs /var/run/docker.sock: permission denied'
```
### Additional information
_No response_ | https://github.com/nektos/act/issues/2016 | https://github.com/nektos/act/pull/2181 | 6e80373eb6a2e87dc228431a7d26c32fa8b4bae9 | f2e65e1d406255cad05b562138758b73219fa74d | "2023-09-21T06:45:20Z" | go | "2024-02-06T17:18:11Z" |
closed | nektos/act | https://github.com/nektos/act | 2,014 | ["pkg/exprparser/interpreter.go", "pkg/runner/expression.go", "pkg/runner/hashfiles/index.js"] | hashFiles does not resolve paths relative to GITHUB_WORKSPACE | ### Bug report info
```plain text
act version: 0.2.50
GOOS: linux
GOARCH: amd64
NumCPU: 16
Docker host: DOCKER_HOST environment variable is not set
Sockets found:
/var/run/docker.sock
Config files:
/home/mgsk/.actrc:
-P ubuntu-latest=catthehacker/ubuntu:act-latest
-P ubuntu-22.04=catthehacker/ubuntu:act-22.04
-P ubuntu-20.04=catthehacker/ubuntu:act-20.04
-P ubuntu-18.04=catthehacker/ubuntu:act-18.04
--env ACTIONS_CACHE_URL=http://localhost:8080/
--env ACTIONS_RUNTIME_URL=http://localhost:8080/
--env ACTIONS_RUNTIME_TOKEN=foo
Build info:
Go version: go1.20.7
Module path: github.com/nektos/act
Main version: (devel)
Main path: github.com/nektos/act
Main checksum:
Build settings:
-buildmode: exe
-compiler: gc
-ldflags: -s -w -X main.version=0.2.50 -X main.commit=80b0955303888742c3ab73af5758bb7b01f5f57c -X main.date=2023-09-01T02:12:50Z -X main.builtBy=goreleaser
CGO_ENABLED: 0
GOARCH: amd64
GOOS: linux
GOAMD64: v1
vcs: git
vcs.revision: 80b0955303888742c3ab73af5758bb7b01f5f57c
vcs.time: 2023-09-01T02:12:28Z
vcs.modified: false
Docker Engine:
Engine version: 20.10.21
Engine runtime: runc
Cgroup version: 2
Cgroup driver: systemd
Storage driver: overlay2
Registry URI: https://index.docker.io/v1/
OS: Ubuntu 23.04
OS type: linux
OS version: 23.04
OS arch: x86_64
OS kernel: 6.2.0-32-generic
OS CPU: 16
OS memory: 64232 MB
Security options:
name=apparmor
name=seccomp,profile=default
name=cgroupns
```
### Command used with act
```sh
`./bin/act`
```
### Describe issue
The [github actions docs](https://docs.github.com/en/actions/learn-github-actions/expressions#hashfiles) state
> The path is relative to the GITHUB_WORKSPACE directory
but that does not appear to be so when using `act`.
See the attached repo which
* has a workflow that uses the `checkout` action with a `path`
* has a file `foo` at its root
* has a step which prints the value of `hashFiles('foo')`
In Github's own runner, this [works fine](https://github.com/notmgsk/act-bug/actions/runs/6252454302/job/16975767156): the file `foo` is found, hashed, and printed. When using `act`, the file is not found.
### Link to GitHub repository
https://github.com/notmgsk/act-bug
### Workflow content
```yml
name: Test
on:
push:
jobs:
test:
name: Test
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v2
with:
path: "test"
- name: test
env:
THE_HASH: ${{ hashFiles('test/foo') }}
run: echo $THE_HASH
```
### Relevant log output
```sh
time="2023-09-20T19:19:40+01:00" level=debug msg="Loading environment from /home/mgsk/hackery/other/act-bug/.env"
time="2023-09-20T19:19:40+01:00" level=debug msg="Loading action inputs from /home/mgsk/hackery/other/act-bug/.input"
time="2023-09-20T19:19:40+01:00" level=debug msg="Loading secrets from /home/mgsk/hackery/other/act-bug/.secrets"
time="2023-09-20T19:19:40+01:00" level=debug msg="Loading vars from /home/mgsk/hackery/other/act-bug/.vars"
time="2023-09-20T19:19:40+01:00" level=debug msg="Conditional GET for notices etag=80e90080-cbc3-41d4-b5f6-18ef0d15e0d0"
time="2023-09-20T19:19:40+01:00" level=debug msg="Evaluated matrix inclusions: map[]"
time="2023-09-20T19:19:40+01:00" level=debug msg="Loading workflows from '/home/mgsk/hackery/other/act-bug/.github/workflows'"
time="2023-09-20T19:19:40+01:00" level=debug msg="Loading workflows recursively"
time="2023-09-20T19:19:40+01:00" level=debug msg="Found workflow 'test.yml' in '/home/mgsk/hackery/other/act-bug/.github/workflows/test.yml'"
time="2023-09-20T19:19:40+01:00" level=debug msg="Reading workflow '/home/mgsk/hackery/other/act-bug/.github/workflows/test.yml'"
time="2023-09-20T19:19:40+01:00" level=debug msg="Preparing plan with all jobs"
time="2023-09-20T19:19:40+01:00" level=debug msg="Using the only detected workflow event: push"
time="2023-09-20T19:19:40+01:00" level=debug msg="Planning jobs for event: push"
time="2023-09-20T19:19:40+01:00" level=debug msg="Plan Stages: [0xc0004ad3b0]"
time="2023-09-20T19:19:40+01:00" level=debug msg="Stages Runs: [Test]"
time="2023-09-20T19:19:40+01:00" level=debug msg="Job.Name: Test"
time="2023-09-20T19:19:40+01:00" level=debug msg="Job.RawNeeds: {0 0 <nil> [] 0 0}"
time="2023-09-20T19:19:40+01:00" level=debug msg="Job.RawRunsOn: {8 0 !!str ubuntu-latest <nil> [] 9 14}"
time="2023-09-20T19:19:40+01:00" level=debug msg="Job.Env: {0 0 <nil> [] 0 0}"
time="2023-09-20T19:19:40+01:00" level=debug msg="Job.If: {0 0 success() <nil> [] 0 0}"
time="2023-09-20T19:19:40+01:00" level=debug msg="Job.Steps: actions/checkout@v2"
time="2023-09-20T19:19:40+01:00" level=debug msg="Job.Steps: test"
time="2023-09-20T19:19:40+01:00" level=debug msg="Job.TimeoutMinutes: "
time="2023-09-20T19:19:40+01:00" level=debug msg="Job.Services: map[]"
time="2023-09-20T19:19:40+01:00" level=debug msg="Job.Strategy: <nil>"
time="2023-09-20T19:19:40+01:00" level=debug msg="Job.RawContainer: {0 0 <nil> [] 0 0}"
time="2023-09-20T19:19:40+01:00" level=debug msg="Job.Defaults.Run.Shell: "
time="2023-09-20T19:19:40+01:00" level=debug msg="Job.Defaults.Run.WorkingDirectory: "
time="2023-09-20T19:19:40+01:00" level=debug msg="Job.Outputs: map[]"
time="2023-09-20T19:19:40+01:00" level=debug msg="Job.Uses: "
time="2023-09-20T19:19:40+01:00" level=debug msg="Job.With: map[]"
time="2023-09-20T19:19:40+01:00" level=debug msg="Job.Result: "
time="2023-09-20T19:19:40+01:00" level=debug msg="Empty Strategy, matrixes=[map[]]"
time="2023-09-20T19:19:40+01:00" level=debug msg="Job Matrices: [map[]]"
time="2023-09-20T19:19:40+01:00" level=debug msg="Runner Matrices: map[]"
time="2023-09-20T19:19:40+01:00" level=debug msg="Final matrix after applying user inclusions '[map[]]'"
time="2023-09-20T19:19:40+01:00" level=debug msg="Loading revision from git directory"
time="2023-09-20T19:19:40+01:00" level=debug msg="Found revision: 7637d68d81a405033ac72362bec5afffdb10776a"
time="2023-09-20T19:19:40+01:00" level=debug msg="HEAD points to '7637d68d81a405033ac72362bec5afffdb10776a'"
time="2023-09-20T19:19:40+01:00" level=debug msg="using github ref: refs/heads/master"
time="2023-09-20T19:19:40+01:00" level=debug msg="Found revision: 7637d68d81a405033ac72362bec5afffdb10776a"
time="2023-09-20T19:19:40+01:00" level=debug msg="Detected CPUs: 16"
time="2023-09-20T19:19:41+01:00" level=debug msg="Saving notices etag=80e90080-cbc3-41d4-b5f6-18ef0d15e0d0"
time="2023-09-20T19:19:41+01:00" level=debug msg="No new notices"
```
### Additional information
_No response_ | https://github.com/nektos/act/issues/2014 | https://github.com/nektos/act/pull/1940 | 2f479ba02470579d32d1cb14f106461063b20726 | 7c7d80ebdd4aee01bb858a828ad864aa120b4a75 | "2023-09-20T18:20:23Z" | go | "2023-10-03T22:56:18Z" |
closed | nektos/act | https://github.com/nektos/act | 2,003 | ["pkg/runner/run_context.go"] | act does not create separate containers for matrix builds with reusable workflows | ### Bug report info
```plain text
act version: 0.2.50
GOOS: darwin
GOARCH: amd64
NumCPU: 8
Docker host: DOCKER_HOST environment variable is not set
Sockets found:
/var/run/docker.sock
$HOME/.docker/run/docker.sock
Config files:
/Users/andy/.actrc:
-P ubuntu-latest=ghcr.io/catthehacker/ubuntu:act-latest
-P ubuntu-20.04=ghcr.io/catthehacker/ubuntu:act-20.04
-P ubuntu-18.04=ghcr.io/catthehacker/ubuntu:act-18.04
Build info:
Go version: go1.21.0
Module path: command-line-arguments
Main version:
Main path:
Main checksum:
Build settings:
-buildmode: exe
-compiler: gc
-ldflags: -X main.version=0.2.50
DefaultGODEBUG: panicnil=1
CGO_ENABLED: 1
CGO_CFLAGS:
CGO_CPPFLAGS:
CGO_CXXFLAGS:
CGO_LDFLAGS:
GOARCH: amd64
GOOS: darwin
GOAMD64: v1
Docker Engine:
Engine version: 24.0.5
Engine runtime: runc
Cgroup version: 2
Cgroup driver: cgroupfs
Storage driver: overlay2
Registry URI: https://index.docker.io/v1/
OS: Docker Desktop
OS type: linux
OS version:
OS arch: x86_64
OS kernel: 5.15.49-linuxkit-pr
OS CPU: 4
OS memory: 7859 MB
Security options:
name=seccomp,profile=unconfined
name=cgroupns
```
### Command used with act
```sh
act -j call-reusable-workflow
```
### Describe issue
When using act with reusable workflows called with a matrix strategy, act does not create separate docker containers for each matrix combination; it tries to run them all in the same container which generates an error (see log output below).
If I run the same matrix strategy in a standalone workflow, act creates a separate docker container for each matrix combination and the workflow runs successfully.
### Link to GitHub repository
https://github.com/Andy4495/act-workflow-test
### Workflow content
```yml
# The "caller" workflow
name: Call Reusable Workflow
on:
push:
workflow_dispatch:
jobs:
call-reusable-workflow:
strategy:
matrix:
include:
- message: test1
- message: test2
- message: test3
- message: test4
name: call-reusable-workflow
uses: Andy4495/act-workflow-test/.github/workflows/reusable-flow.yml@main
with:
message: ${{ matrix.message }}
---
# The "called" (reusable) workflow
name: reusable-workflow
on:
workflow_call:
inputs:
message:
description: Message to display
required: true
type: string
jobs:
reusable-workflow:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v4
- name: Print the message
run: |
echo Test reusable workflow ${{ inputs.message }}
```
### Relevant log output
```sh
Error: failed to create container: 'Error response from daemon: Conflict. The container name "/act-call-reusable-workflow-reusable-workflow-reusable-workflow-c7535ef5a84abfd1f2412cceca72bd226072ccb44b16a59787972320d9cb1a2d" is already in use by container "d0baad951ea56daf6bd3097af098d08b22d726733e0e4a54120fe40c357874a0". You have to remove (or rename) that container to be able to reuse that name.'
```
### Additional information
As mentioned above, this works fine with standalone workflows. | https://github.com/nektos/act/issues/2003 | https://github.com/nektos/act/pull/2015 | 55b09a04cd14006b34eef02f0d19120759ee167b | 1c16fd1967d68c76aeab6b88d7ac9a6bde1f4123 | "2023-09-11T18:38:22Z" | go | "2023-11-12T17:21:41Z" |
closed | nektos/act | https://github.com/nektos/act | 1,980 | ["go.mod", "go.sum"] | Fails silently when docker is not running | ### Bug report info
```plain text
ct version: 0.2.49
GOOS: darwin
GOARCH: arm64
NumCPU: 8
Docker host: DOCKER_HOST environment variable is not set
Sockets found:
/var/run/docker.sock
$HOME/.docker/run/docker.sock
Config files:
/Users/juan/.actrc:
-P ubuntu-latest=catthehacker/ubuntu:act-latest
-P ubuntu-22.04=catthehacker/ubuntu:act-22.04
-P ubuntu-20.04=catthehacker/ubuntu:act-20.04
-P ubuntu-18.04=catthehacker/ubuntu:act-18.04
Build info:
Go version: go1.20.6
Module path: command-line-arguments
Main version:
Main path:
Main checksum:
Build settings:
-buildmode: exe
-compiler: gc
-ldflags: -X main.version=0.2.49
CGO_ENABLED: 1
CGO_CFLAGS:
CGO_CPPFLAGS:
CGO_CXXFLAGS:
CGO_LDFLAGS:
GOARCH: arm64
GOOS: darwin
Docker Engine:
Engine version: 23.0.5
Engine runtime: runc
Cgroup version: 2
Cgroup driver: cgroupfs
Storage driver: overlay2
Registry URI: https://index.docker.io/v1/
OS: Docker Desktop
OS type: linux
OS version:
OS arch: aarch64
OS kernel: 5.15.49-linuxkit
OS CPU: 4
OS memory: 7851 MB
Security options:
name=seccomp,profile=builtin
name=cgroupns
```
### Command used with act
```sh
act -j auctions-management --container-architecture linux/amd64
```
### Describe issue
When running act commands with the docker daemon not running, no warning or notification is provided to the user.
This might be an improvement rather than a bug.
### Link to GitHub repository
_No response_
### Workflow content
```yml
name: Lint build and unit test users management service
on:
push:
branches: ["main", "dev"]
pull_request:
branches: ["main", "dev"]
jobs:
lint-build-unit:
runs-on: ubuntu-latest
defaults:
run:
working-directory: ./users-management-service/
steps:
- uses: actions/checkout@v3
- uses: actions/setup-node@v3
with:
cache: 'npm'
cache-dependency-path: './users-management-service/package-lock.json'
- run: npm ci
- run: npm run lint
- run: npm run build
- run: npm run test:cov
```
### Relevant log output
```sh
No output is the issue
```
### Additional information
_No response_ | https://github.com/nektos/act/issues/1980 | https://github.com/nektos/act/pull/838 | a0d360236ef5466a441631c2f93794b55d4b76c5 | b5e8a18683c77c7035c704bb7cec980401c73e18 | "2023-08-21T21:38:44Z" | go | "2021-10-18T20:24:05Z" |
closed | nektos/act | https://github.com/nektos/act | 1,967 | [".github/workflows/checks.yml"] | Allow node20 in action.yml as action runtime | ### Act version
v0.2.49
### Feature description
See https://github.com/actions/runner/releases/tag/v2.308.0
Since act doesn't care about the version behind `node` why not just exec all `node<number>` via `node`? | https://github.com/nektos/act/issues/1967 | https://github.com/nektos/act/pull/1395 | bd5e0d24d68cddab105ee76bc2fb8000dce76a11 | 37f5b7f4a2bc363be670ee65f623c6b54ec9d8c5 | "2023-08-14T11:20:15Z" | go | "2022-10-17T18:14:30Z" |
closed | nektos/act | https://github.com/nektos/act | 1,944 | ["cmd/root.go"] | Incorrect podman socket location | ### Bug report info
```plain text
act version: 0.2.46
GOOS: linux
GOARCH: amd64
NumCPU: 8
Docker host: DOCKER_HOST environment variable is not set
Sockets found:
Config files:
Build info:
Go version: go1.20.7
Module path: github.com/nektos/act
Main version: (devel)
Main path: github.com/nektos/act
Main checksum:
Build settings:
-buildmode: exe
-compiler: gc
CGO_ENABLED: 1
CGO_CFLAGS:
CGO_CPPFLAGS:
CGO_CXXFLAGS:
CGO_LDFLAGS:
GOARCH: amd64
GOOS: linux
GOAMD64: v1
vcs: git
vcs.revision: cdc6d4bc6a386ad68996cd4e51df4284740b988f
vcs.time: 2023-07-17T03:46:34Z
vcs.modified: false
Error: Cannot connect to the Docker daemon at unix:///var/run/docker.sock. Is the docker daemon running?
```
### Command used with act
```sh
./act --bug-report
```
### Describe issue
Sockets found should list podman user socket, found at `$XDG_RUNTIME_DIR/podman/podman.sock` and system service socket `/run/podman/podman.sock` if user has permissions to access it. Those are the default socket locations: https://docs.podman.io/en/latest/markdown/podman-system-service.1.html
Expect output of `act --bug-report` would be:
```
act version: 0.2.46
GOOS: linux
GOARCH: amd64
NumCPU: 8
Docker host: DOCKER_HOST environment variable is not set
Sockets found:
/run/podman/podman.sock
Config files:
Build info:
Go version: go1.20.7
Module path: github.com/nektos/act
Main version: (devel)
Main path: github.com/nektos/act
Main checksum:
Build settings:
-buildmode: exe
-compiler: gc
CGO_ENABLED: 1
CGO_CFLAGS:
CGO_CPPFLAGS:
CGO_CXXFLAGS:
CGO_LDFLAGS:
GOARCH: amd64
GOOS: linux
GOAMD64: v1
vcs: git
vcs.revision: cdc6d4bc6a386ad68996cd4e51df4284740b988f
vcs.time: 2023-07-17T03:46:34Z
vcs.modified: true
Error: Cannot connect to the Docker daemon at unix:///var/run/docker.sock. Is the docker daemon running?
```
### Link to GitHub repository
https://github.com/nektos/act/
### Workflow content
```yml
N/A
```
### Relevant log output
```sh
N/A
```
### Additional information
_No response_ | https://github.com/nektos/act/issues/1944 | https://github.com/nektos/act/pull/1961 | a00fd960a5d67a21b87ce7f055d9ae89f1603345 | 9f06ca75e447f5fa08de31d2e2577d703df86cc1 | "2023-08-03T07:36:31Z" | go | "2023-08-11T05:33:53Z" |
closed | nektos/act | https://github.com/nektos/act | 1,894 | [".github/workflows/checks.yml", ".github/workflows/release.yml", ".goreleaser.yml", "Makefile"] | 0.2.47 release was not completed | 👋 it looks like 0.2.47 release was not completed, see [this action run](https://github.com/nektos/act/actions/runs/5428652209/jobs/9873037000), raise this issue for some awareness. Thanks!
relates to https://github.com/Homebrew/homebrew-core/pull/135514 | https://github.com/nektos/act/issues/1894 | https://github.com/nektos/act/pull/1895 | e597046195774991a75ff66506fdfcc3fc903364 | 15618d11874d8f95ffcf10f7cccb013d13e190d6 | "2023-07-03T15:56:23Z" | go | "2023-07-10T17:15:16Z" |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.